1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
class Tty
class <<self
def blue; bold 34; end
def white; bold 39; end
def red; underline 31; end
def yellow; underline 33 ; end
def reset; escape 0; end
def em; underline 39; end
private
def color n
escape "0;#{n}"
end
def bold n
escape "1;#{n}"
end
def underline n
escape "4;#{n}"
end
def escape n
"\033[#{n}m" if $stdout.tty?
end
end
end
# args are additional inputs to puts until a nil arg is encountered
def ohai title, *sput
title = title.to_s[0, `/usr/bin/tput cols`.strip.to_i-4] unless ARGV.verbose?
puts "#{Tty.blue}==>#{Tty.white} #{title}#{Tty.reset}"
puts *sput unless sput.empty?
end
def opoo warning
puts "#{Tty.red}Warning#{Tty.reset}: #{warning}"
end
def onoe error
lines = error.to_s.split'\n'
puts "#{Tty.red}Error#{Tty.reset}: #{lines.shift}"
puts *lines unless lines.empty?
end
def pretty_duration s
return "2 seconds" if s < 3 # avoids the plural problem ;)
return "#{s.to_i} seconds" if s < 120
return "%.1f minutes" % (s/60)
end
def interactive_shell
fork do
# TODO make the PS1 var change pls
#brown="\[\033[0;33m\]"
#reset="\[\033[0m\]"
#ENV['PS1']="Homebrew-#{HOMEBREW_VERSION} #{brown}\W#{reset}\$ "
exec ENV['SHELL']
end
Process.wait
unless $?.success?
puts "Aborting due to non-zero exit status"
exit $?
end
end
module Homebrew
def self.system cmd, *args
puts "#{cmd} #{args*' '}" if ARGV.verbose?
fork do
yield if block_given?
args.collect!{|arg| arg.to_s}
exec(cmd, *args) rescue nil
exit! 1 # never gets here unless exec failed
end
Process.wait
$?.success?
end
end
# Kernel.system but with exceptions
def safe_system cmd, *args
raise ExecutionError.new(cmd, args, $?) unless Homebrew.system(cmd, *args)
end
# prints no output
def quiet_system cmd, *args
Homebrew.system(cmd, *args) do
$stdout.close
$stderr.close
end
end
def curl *args
safe_system 'curl', '-f#LA', HOMEBREW_USER_AGENT, *args unless args.empty?
end
def puts_columns items, cols = 4
return if items.empty?
if $stdout.tty?
# determine the best width to display for different console sizes
console_width = `/bin/stty size`.chomp.split(" ").last.to_i
console_width = 80 if console_width <= 0
longest = items.sort_by { |item| item.length }.last
optimal_col_width = (console_width.to_f / (longest.length + 2).to_f).floor
cols = optimal_col_width > 1 ? optimal_col_width : 1
IO.popen("/usr/bin/pr -#{cols} -t -w#{console_width}", "w"){|io| io.puts(items) }
else
puts *items
end
end
def exec_editor *args
editor=ENV['EDITOR']
if editor.nil?
if system "/usr/bin/which -s mate"
editor='mate'
else
editor='/usr/bin/vim'
end
end
# we split the editor because especially on mac "mate -w" is common
# but we still want to use the comma-delimited version of exec because then
# we don't have to escape args, and escaping 100% is tricky
exec *(editor.split+args)
end
# GZips the given path, and returns the gzipped file
def gzip path
system "/usr/bin/gzip", path
return Pathname.new(path+".gz")
end
# returns array of architectures suitable for -arch gcc flag
def archs_for_command cmd
cmd = cmd.to_s # If we were passed a Pathname, turn it into a string.
cmd = `/usr/bin/which #{cmd}` unless Pathname.new(cmd).absolute?
cmd.gsub! ' ', '\\ ' # Escape spaces in the filename.
IO.popen("/usr/bin/file #{cmd}").readlines.inject(%w[]) do |archs, line|
case line
when /Mach-O executable ppc/
archs << :ppc7400
when /Mach-O 64-bit executable ppc64/
archs << :ppc64
when /Mach-O executable i386/
archs << :i386
when /Mach-O 64-bit executable x86_64/
archs << :x86_64
else
archs
end
end
end
# String extensions added by inreplace below.
module HomebrewInreplaceExtension
# Looks for Makefile style variable defintions and replaces the
# value with "new_value", or removes the definition entirely.
def change_make_var! flag, new_value
new_value = "#{flag}=#{new_value}"
gsub! Regexp.new("^#{flag}[ \\t]*=[ \\t]*(.*)$"), new_value
end
# Removes variable assignments completely.
def remove_make_var! flags
flags.each do |flag|
# Also remove trailing \n, if present.
gsub! Regexp.new("^#{flag}[ \\t]*=(.*)$\n?"), ""
end
end
# Finds the specified variable
def get_make_var flag
m = match Regexp.new("^#{flag}[ \\t]*=[ \\t]*(.*)$")
return m[1] if m
return nil
end
end
def inreplace path, before=nil, after=nil
[*path].each do |path|
f = File.open(path, 'r')
s = f.read
if before == nil and after == nil
s.extend(HomebrewInreplaceExtension)
yield s
else
s.gsub!(before, after)
end
f.reopen(path, 'w').write(s)
f.close
end
end
def ignore_interrupts
std_trap = trap("INT") {}
yield
ensure
trap("INT", std_trap)
end
def nostdout
if ARGV.verbose?
yield
else
begin
require 'stringio'
real_stdout = $stdout
$stdout = StringIO.new
yield
ensure
$stdout = real_stdout
end
end
end
|
