1 #####################################################################

     2 ###	G L O B A L   H E L P E R   F U N C T I O N S

     3 #####################################################################

     4 

     5 require 'pathname'

     6 require 'readline'

     7 require 'open3'

     8 

     9 # Set some ANSI escape code constants (Shamelessly stolen from Perl's

    10 # Term::ANSIColor by Russ Allbery <rra@stanford.edu> and Zenin <zenin@best.com>

    11 ANSI_ATTRIBUTES = {

    12 	'clear'      => 0,

    13 	'reset'      => 0,

    14 	'bold'       => 1,

    15 	'dark'       => 2,

    16 	'underline'  => 4,

    17 	'underscore' => 4,

    18 	'blink'      => 5,

    19 	'reverse'    => 7,

    20 	'concealed'  => 8,

    21 

    22 	'black'      => 30,   'on_black'   => 40, 

    23 	'red'        => 31,   'on_red'     => 41, 

    24 	'green'      => 32,   'on_green'   => 42, 

    25 	'yellow'     => 33,   'on_yellow'  => 43, 

    26 	'blue'       => 34,   'on_blue'    => 44, 

    27 	'magenta'    => 35,   'on_magenta' => 45, 

    28 	'cyan'       => 36,   'on_cyan'    => 46, 

    29 	'white'      => 37,   'on_white'   => 47

    30 }

    31 

    32 

    33 CLEAR_TO_EOL       = "\e[K"

    34 CLEAR_CURRENT_LINE = "\e[2K"

    35 

    36 

    37 ### Output a logging message

    38 def log( *msg )

    39 	output = colorize( msg.flatten.join(' '), 'cyan' )

    40 	$deferr.puts( output )

    41 end

    42 

    43 

    44 ### Output a logging message if tracing is on

    45 def trace( *msg )

    46 	return unless $trace

    47 	output = colorize( msg.flatten.join(' '), 'yellow' )

    48 	$deferr.puts( output )

    49 end

    50 

    51 

    52 ### Run the specified command +cmd+ with system(), failing if the execution

    53 ### fails.

    54 def run( *cmd )

    55 	cmd.flatten!

    56 

    57 	log( cmd.collect {|part| part =~ /\s/ ? part.inspect : part} ) 

    58 	if $dryrun

    59 		$deferr.puts "(dry run mode)"

    60 	else

    61 		system( *cmd )

    62 		unless $?.success?

    63 			fail "Command failed: [%s]" % [cmd.join(' ')]

    64 		end

    65 	end

    66 end

    67 

    68 

    69 ### Open a pipe to a process running the given +cmd+ and call the given block with it.

    70 def pipeto( *cmd )

    71 	$DEBUG = true

    72 

    73 	cmd.flatten!

    74 	log( "Opening a pipe to: ", cmd.collect {|part| part =~ /\s/ ? part.inspect : part} ) 

    75 	if $dryrun

    76 		$deferr.puts "(dry run mode)"

    77 	else

    78 		open( '|-', 'w+' ) do |io|

    79 		

    80 			# Parent

    81 			if io

    82 				yield( io )

    83 

    84 			# Child

    85 			else

    86 				exec( *cmd )

    87 				fail "Command failed: [%s]" % [cmd.join(' ')]

    88 			end

    89 		end

    90 	end

    91 end

    92 

    93 

    94 ### Download the file at +sourceuri+ via HTTP and write it to +targetfile+.

    95 def download( sourceuri, targetfile )

    96 	oldsync = $defout.sync

    97 	$defout.sync = true

    98 	require 'net/http'

    99 	require 'uri'

   100 

   101 	targetpath = Pathname.new( targetfile )

   102 

   103 	log "Downloading %s to %s" % [sourceuri, targetfile]

   104 	targetpath.open( File::WRONLY|File::TRUNC|File::CREAT, 0644 ) do |ofh|

   105 	

   106 		url = URI.parse( sourceuri )

   107 		downloaded = false

   108 		limit = 5

   109 		

   110 		until downloaded or limit.zero?

   111 			Net::HTTP.start( url.host, url.port ) do |http|

   112 				req = Net::HTTP::Get.new( url.path )

   113 

   114 				http.request( req ) do |res|

   115 					if res.is_a?( Net::HTTPSuccess )

   116 						log "Downloading..."

   117 						res.read_body do |buf|

   118 							ofh.print( buf )

   119 						end

   120 						downloaded = true

   121 						puts "done."

   122 		

   123 					elsif res.is_a?( Net::HTTPRedirection )

   124 						url = URI.parse( res['location'] )

   125 						log "...following redirection to: %s" % [ url ]

   126 						limit -= 1

   127 						sleep 0.2

   128 						next

   129 				

   130 					else

   131 						res.error!

   132 					end

   133 				end

   134 			end

   135 		end

   136 	end

   137 	

   138 	return targetpath

   139 ensure

   140 	$defout.sync = oldsync

   141 end

   142 

   143 

   144 ### Return the fully-qualified path to the specified +program+ in the PATH.

   145 def which( program )

   146 	ENV['PATH'].split(/:/).

   147 		collect {|dir| Pathname.new(dir) + program }.

   148 		find {|path| path.exist? && path.executable? }

   149 end

   150 

   151 

   152 ### Create a string that contains the ANSI codes specified and return it

   153 def ansi_code( *attributes )

   154 	attributes.flatten!

   155 	attributes.collect! {|at| at.to_s }

   156 	# $deferr.puts "Returning ansicode for TERM = %p: %p" %

   157 	# 	[ ENV['TERM'], attributes ]

   158 	return '' unless /(?:vt10[03]|xterm(?:-color)?|linux|screen)/i =~ ENV['TERM']

   159 	attributes = ANSI_ATTRIBUTES.values_at( *attributes ).compact.join(';')

   160 

   161 	# $deferr.puts "  attr is: %p" % [attributes]

   162 	if attributes.empty? 

   163 		return ''

   164 	else

   165 		return "\e[%sm" % attributes

   166 	end

   167 end

   168 

   169 

   170 ### Colorize the given +string+ with the specified +attributes+ and return it, handling 

   171 ### line-endings, color reset, etc.

   172 def colorize( *args )

   173 	string = ''

   174 	

   175 	if block_given?

   176 		string = yield

   177 	else

   178 		string = args.shift

   179 	end

   180 	

   181 	ending = string[/(\s)$/] || ''

   182 	string = string.rstrip

   183 

   184 	return ansi_code( args.flatten ) + string + ansi_code( 'reset' ) + ending

   185 end

   186 

   187 

   188 ### Output the specified <tt>msg</tt> as an ANSI-colored error message

   189 ### (white on red).

   190 def error_message( msg, details='' )

   191 	$deferr.puts colorize( 'bold', 'white', 'on_red' ) { msg } + details

   192 end

   193 alias :error :error_message

   194 

   195 

   196 ### Highlight and embed a prompt control character in the given +string+ and return it.

   197 def make_prompt_string( string )

   198 	return CLEAR_CURRENT_LINE + colorize( 'bold', 'green' ) { string + ' ' }

   199 end

   200 

   201 

   202 ### Output the specified <tt>prompt_string</tt> as a prompt (in green) and

   203 ### return the user's input with leading and trailing spaces removed.  If a

   204 ### test is provided, the prompt will repeat until the test returns true.

   205 ### An optional failure message can also be passed in.

   206 def prompt( prompt_string, failure_msg="Try again." ) # :yields: response

   207 	prompt_string.chomp!

   208 	prompt_string << ":" unless /\W$/.match( prompt_string )

   209 	response = nil

   210 

   211 	begin

   212 		prompt = make_prompt_string( prompt_string )

   213 		response = Readline.readline( prompt ) || ''

   214 		response.strip!

   215 		if block_given? && ! yield( response ) 

   216 			error_message( failure_msg + "\n\n" )

   217 			response = nil

   218 		end

   219 	end while response.nil?

   220 

   221 	return response

   222 end

   223 

   224 

   225 ### Prompt the user with the given <tt>prompt_string</tt> via #prompt,

   226 ### substituting the given <tt>default</tt> if the user doesn't input

   227 ### anything.  If a test is provided, the prompt will repeat until the test

   228 ### returns true.  An optional failure message can also be passed in.

   229 def prompt_with_default( prompt_string, default, failure_msg="Try again." )

   230 	response = nil

   231 

   232 	begin

   233 		response = prompt( "%s [%s]" % [ prompt_string, default ] )

   234 		response = default if response.empty?

   235 

   236 		if block_given? && ! yield( response ) 

   237 			error_message( failure_msg + "\n\n" )

   238 			response = nil

   239 		end

   240 	end while response.nil?

   241 

   242 	return response

   243 end

   244 

   245 

   246 ### Display a description of a potentially-dangerous task, and prompt

   247 ### for confirmation. If the user answers with anything that begins

   248 ### with 'y', yield to the block, else raise with an error.

   249 def ask_for_confirmation( description )

   250 	puts description

   251 

   252 	answer = prompt_with_default( "Continue?", 'n' ) do |input|

   253 		input =~ /^[yn]/i

   254 	end

   255 

   256 	case answer

   257 	when /^y/i

   258 		yield

   259 	else

   260 		error "Aborted."

   261 		fail

   262 	end

   263 end

   264 

   265 

   266 ### Search line-by-line in the specified +file+ for the given +regexp+, returning the

   267 ### first match, or nil if no match was found. If the +regexp+ has any capture groups,

   268 ### those will be returned in an Array, else the whole matching line is returned.

   269 def find_pattern_in_file( regexp, file )

   270 	rval = nil

   271 	

   272 	File.open( file, 'r' ).each do |line|

   273 		if (( match = regexp.match(line) ))

   274 			rval = match.captures.empty? ? match[0] : match.captures

   275 			break

   276 		end

   277 	end

   278 

   279 	return rval

   280 end

   281 

   282 

   283 ### Search line-by-line in the output of the specified +cmd+ for the given +regexp+,

   284 ### returning the first match, or nil if no match was found. If the +regexp+ has any 

   285 ### capture groups, those will be returned in an Array, else the whole matching line

   286 ### is returned.

   287 def find_pattern_in_pipe( regexp, *cmd )

   288 	output = []

   289 	

   290 	Open3.popen3( *cmd ) do |stdin, stdout, stderr|

   291 		stdin.close

   292 

   293 		output << stdout.gets until stdout.eof?

   294 		output << stderr.gets until stderr.eof?

   295 	end

   296 	

   297 	result = output.find { |line| regexp.match(line) } 

   298 	return $1 || result

   299 end

   300 

   301 

   302 ### Extract all the non Rake-target arguments from ARGV and return them.

   303 def get_target_args

   304 	args = ARGV.reject {|arg| Rake::Task.task_defined?(arg) }

   305 	return args

   306 end

   307 

   308 

   309 

   310 require 'rubygems/dependency_installer'

   311 require 'rubygems/source_index'

   312 require 'rubygems/requirement'

   313 require 'rubygems/doc_manager'

   314 

   315 ### Install the specified +gems+ if they aren't already installed.

   316 def install_gems( *gems )

   317 	gems.flatten!

   318 	

   319 	defaults = Gem::DependencyInstaller::DEFAULT_OPTIONS.merge({

   320 		:generate_rdoc     => true,

   321 		:generate_ri       => true,

   322 		:install_dir       => Gem.dir,

   323 		:format_executable => false,

   324 		:test              => false,

   325 		:version           => Gem::Requirement.default,

   326 	  })

   327     

   328 	# Check for root

   329 	if Process.euid != 0

   330 		$stderr.puts "This probably won't work, as you aren't root, but I'll try anyway"

   331 	end

   332 

   333 	gemindex = Gem::SourceIndex.from_installed_gems

   334 

   335 	gems.each do |gemname|

   336 		if (( specs = gemindex.search(gemname) )) && ! specs.empty?

   337 			log "Version %s of %s is already installed; skipping..." % 

   338 				[ specs.first.version, specs.first.name ]

   339 			next

   340 		end

   341 

   342 		log "Trying to install #{gemname.inspect}..."

   343 		installer = Gem::DependencyInstaller.new

   344 		installer.install( gemname )

   345 

   346 		installer.installed_gems.each do |spec|

   347 			log "Installed: %s" % [ spec.full_name ]

   348 		end

   349 

   350 	end

   351 end

   352 

   353