1 files changed, 110 insertions, 85 deletions

diff --git a/Library/Homebrew/utils.rb b/Library/Homebrew/utils.rb
index 1c3127f49..a6c47b27a 100644
--- a/Library/Homebrew/utils.rb
+++ b/Library/Homebrew/utils.rb
@@ -1,22 +1,45 @@
-require 'pathname'
-require 'exceptions'
-require 'os/mac'
-require 'utils/json'
-require 'utils/inreplace'
-require 'utils/popen'
-require 'utils/fork'
-require 'open-uri'
+require "pathname"
+require "exceptions"
+require "os/mac"
+require "utils/json"
+require "utils/inreplace"
+require "utils/popen"
+require "utils/fork"
+require "open-uri"
 
 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
-    def green; bold 32; end
-    def gray; bold 30; end
+    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
+
+    def green
+      bold 32
+    end
+
+    def gray
+      bold 30
+    end
 
     def width
       `/usr/bin/tput cols`.strip.to_i
@@ -28,71 +51,74 @@ class Tty
 
     private
 
-    def color n
+    def color(n)
       escape "0;#{n}"
     end
-    def bold n
+
+    def bold(n)
       escape "1;#{n}"
     end
-    def underline n
+
+    def underline(n)
       escape "4;#{n}"
     end
-    def escape n
+
+    def escape(n)
       "\033[#{n}m" if $stdout.tty?
     end
   end
 end
 
-def ohai title, *sput
+def ohai(title, *sput)
   title = Tty.truncate(title) if $stdout.tty? && !ARGV.verbose?
   puts "#{Tty.blue}==>#{Tty.white} #{title}#{Tty.reset}"
   puts sput
 end
 
-def oh1 title
+def oh1(title)
   title = Tty.truncate(title) if $stdout.tty? && !ARGV.verbose?
   puts "#{Tty.green}==>#{Tty.white} #{title}#{Tty.reset}"
 end
 
-def opoo warning
+def opoo(warning)
   $stderr.puts "#{Tty.yellow}Warning#{Tty.reset}: #{warning}"
 end
 
-def onoe error
+def onoe(error)
   $stderr.puts "#{Tty.red}Error#{Tty.reset}: #{error}"
 end
 
-def ofail error
+def ofail(error)
   onoe error
   Homebrew.failed = true
 end
 
-def odie error
+def odie(error)
   onoe error
   exit 1
 end
 
-def pretty_duration s
+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)
+  "%.1f minutes" % (s/60)
 end
 
-def plural n, s="s"
+def plural(n, s = "s")
   (n == 1) ? "" : s
 end
 
-def interactive_shell f=nil
+def interactive_shell(f = nil)
   unless f.nil?
-    ENV['HOMEBREW_DEBUG_PREFIX'] = f.prefix
-    ENV['HOMEBREW_DEBUG_INSTALL'] = f.full_name
+    ENV["HOMEBREW_DEBUG_PREFIX"] = f.prefix
+    ENV["HOMEBREW_DEBUG_INSTALL"] = f.full_name
   end
 
   if ENV["SHELL"].include?("zsh") && ENV["HOME"].start_with?(HOMEBREW_TEMP.resolved_path.to_s)
     FileUtils.touch "#{ENV["HOME"]}/.zshrc"
   end
 
-  Process.wait fork { exec ENV['SHELL'] }
+  Process.wait fork { exec ENV["SHELL"] }
 
   if $?.success?
     return
@@ -105,11 +131,11 @@ def interactive_shell f=nil
 end
 
 module Homebrew
-  def self.system cmd, *args
-    puts "#{cmd} #{args*' '}" if ARGV.verbose?
+  def self.system(cmd, *args)
+    puts "#{cmd} #{args*" "}" if ARGV.verbose?
     pid = fork do
       yield if block_given?
-      args.collect!{|arg| arg.to_s}
+      args.collect!(&:to_s)
       exec(cmd, *args) rescue nil
       exit! 1 # never gets here unless exec failed
     end
@@ -125,7 +151,7 @@ module Homebrew
     HOMEBREW_REPOSITORY.cd { `git show -s --format="%cr" HEAD 2>/dev/null`.chuzzle }
   end
 
-  def self.install_gem_setup_path! gem, version=nil, executable=gem
+  def self.install_gem_setup_path!(gem, version = nil, executable = gem)
     require "rubygems"
     ENV["PATH"] = "#{Gem.user_dir}/bin:#{ENV["PATH"]}"
 
@@ -147,87 +173,85 @@ module Homebrew
 end
 
 def with_system_path
-  old_path = ENV['PATH']
-  ENV['PATH'] = '/usr/bin:/bin'
+  old_path = ENV["PATH"]
+  ENV["PATH"] = "/usr/bin:/bin"
   yield
 ensure
-  ENV['PATH'] = old_path
+  ENV["PATH"] = old_path
 end
 
-def run_as_not_developer(&block)
-  begin
-    old = ENV.delete "HOMEBREW_DEVELOPER"
-    yield
-  ensure
-    ENV["HOMEBREW_DEVELOPER"] = old
-  end
+def run_as_not_developer(&_block)
+  old = ENV.delete "HOMEBREW_DEVELOPER"
+  yield
+ensure
+  ENV["HOMEBREW_DEVELOPER"] = old
 end
 
 # Kernel.system but with exceptions
-def safe_system cmd, *args
-  Homebrew.system(cmd, *args) or raise ErrorDuringExecution.new(cmd, args)
+def safe_system(cmd, *args)
+  Homebrew.system(cmd, *args) || raise(ErrorDuringExecution.new(cmd, args))
 end
 
 # prints no output
-def quiet_system cmd, *args
+def quiet_system(cmd, *args)
   Homebrew.system(cmd, *args) do
     # Redirect output streams to `/dev/null` instead of closing as some programs
     # will fail to execute if they can't write to an open stream.
-    $stdout.reopen('/dev/null')
-    $stderr.reopen('/dev/null')
+    $stdout.reopen("/dev/null")
+    $stderr.reopen("/dev/null")
   end
 end
 
-def curl *args
+def curl(*args)
   brewed_curl = HOMEBREW_PREFIX/"opt/curl/bin/curl"
   curl = if MacOS.version <= "10.6" && brewed_curl.exist?
     brewed_curl
   else
-    Pathname.new '/usr/bin/curl'
+    Pathname.new "/usr/bin/curl"
   end
-  raise "#{curl} is not executable" unless curl.exist? and curl.executable?
+  raise "#{curl} is not executable" unless curl.exist? && curl.executable?
 
   flags = HOMEBREW_CURL_ARGS
   flags = flags.delete("#") if ARGV.verbose?
 
   args = [flags, HOMEBREW_USER_AGENT, *args]
-  args << "--verbose" if ENV['HOMEBREW_CURL_VERBOSE']
+  args << "--verbose" if ENV["HOMEBREW_CURL_VERBOSE"]
   args << "--silent" unless $stdout.tty?
 
   safe_system curl, *args
 end
 
-def puts_columns items, star_items=[]
+def puts_columns(items, star_items = [])
   return if items.empty?
 
   if star_items && star_items.any?
-    items = items.map{|item| star_items.include?(item) ? "#{item}*" : item}
+    items = items.map { |item| star_items.include?(item) ? "#{item}*" : item }
   end
 
   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
+    longest = items.sort_by(&: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) }
+    IO.popen("/usr/bin/pr -#{cols} -t -w#{console_width}", "w") { |io| io.puts(items) }
   else
     puts items
   end
 end
 
-def which cmd, path=ENV['PATH']
+def which(cmd, path = ENV["PATH"])
   path.split(File::PATH_SEPARATOR).each do |p|
     pcmd = File.expand_path(cmd, p)
     return Pathname.new(pcmd) if File.file?(pcmd) && File.executable?(pcmd)
   end
-  return nil
+  nil
 end
 
 def which_editor
-  editor = ENV.values_at('HOMEBREW_EDITOR', 'VISUAL', 'EDITOR').compact.first
+  editor = ENV.values_at("HOMEBREW_EDITOR", "VISUAL", "EDITOR").compact.first
   return editor unless editor.nil?
 
   # Find Textmate
@@ -248,31 +272,31 @@ def which_editor
   editor
 end
 
-def exec_editor *args
+def exec_editor(*args)
   safe_exec(which_editor, *args)
 end
 
-def exec_browser *args
-  browser = ENV['HOMEBREW_BROWSER'] || ENV['BROWSER'] || OS::PATH_OPEN
+def exec_browser(*args)
+  browser = ENV["HOMEBREW_BROWSER"] || ENV["BROWSER"] || OS::PATH_OPEN
   safe_exec(browser, *args)
 end
 
-def safe_exec cmd, *args
+def safe_exec(cmd, *args)
   # This buys us proper argument quoting and evaluation
   # of environment variables in the cmd parameter.
   exec "/bin/sh", "-c", "#{cmd} \"$@\"", "--", *args
 end
 
 # GZips the given paths, and returns the gzipped paths
-def gzip *paths
+def gzip(*paths)
   paths.collect do |path|
-    with_system_path { safe_system 'gzip', path }
+    with_system_path { safe_system "gzip", path }
     Pathname.new("#{path}.gz")
   end
 end
 
 # Returns array of architectures that the given command or library is built for.
-def archs_for_command cmd
+def archs_for_command(cmd)
   cmd = which(cmd) unless Pathname.new(cmd).absolute?
   Pathname.new(cmd).archs
 end
@@ -302,9 +326,9 @@ def nostdout
 end
 
 def paths
-  @paths ||= ENV['PATH'].split(File::PATH_SEPARATOR).collect do |p|
+  @paths ||= ENV["PATH"].split(File::PATH_SEPARATOR).collect do |p|
     begin
-      File.expand_path(p).chomp('/')
+      File.expand_path(p).chomp("/")
     rescue ArgumentError
       onoe "The following PATH component is invalid: #{p}"
     end
@@ -321,7 +345,8 @@ def shell_profile
   end
 end
 
-module GitHub extend self
+module GitHub
+  extend self
   ISSUES_URI = URI.parse("https://api.github.com/search/issues")
 
   Error = Class.new(RuntimeError)
@@ -334,7 +359,7 @@ module GitHub extend self
         Try again in #{pretty_ratelimit_reset(reset)}, or create an personal access token:
           https://github.com/settings/tokens
         and then set the token as: HOMEBREW_GITHUB_API_TOKEN
-        EOS
+                    EOS
     end
 
     def pretty_ratelimit_reset(reset)
@@ -352,19 +377,19 @@ module GitHub extend self
         GitHub #{error}
         HOMEBREW_GITHUB_API_TOKEN may be invalid or expired, check:
           https://github.com/settings/tokens
-        EOS
+                    EOS
     end
   end
 
-  def open(url, &block)
+  def open(url, &_block)
     # This is a no-op if the user is opting out of using the GitHub API.
-    return if ENV['HOMEBREW_NO_GITHUB_API']
+    return if ENV["HOMEBREW_NO_GITHUB_API"]
 
     require "net/https"
 
     headers = {
       "User-Agent" => HOMEBREW_USER_AGENT,
-      "Accept"     => "application/vnd.github.v3+json",
+      "Accept"     => "application/vnd.github.v3+json"
     }
 
     headers["Authorization"] = "token #{HOMEBREW_GITHUB_API_TOKEN}" if HOMEBREW_GITHUB_API_TOKEN
@@ -397,7 +422,7 @@ module GitHub extend self
     end
   end
 
-  def issues_matching(query, qualifiers={})
+  def issues_matching(query, qualifiers = {})
     uri = ISSUES_URI.dup
     uri.query = build_query_string(query, qualifiers)
     open(uri) { |json| json["items"] }
@@ -416,10 +441,10 @@ module GitHub extend self
   def build_search_qualifier_string(qualifiers)
     {
       :repo => "Homebrew/homebrew",
-      :in => "title",
-    }.update(qualifiers).map { |qualifier, value|
+      :in => "title"
+    }.update(qualifiers).map do |qualifier, value|
       "#{qualifier}:#{value}"
-    }.join("+")
+    end.join("+")
   end
 
   def uri_escape(query)
@@ -431,17 +456,17 @@ module GitHub extend self
     end
   end
 
-  def issues_for_formula name
+  def issues_for_formula(name)
     issues_matching(name, :state => "open")
   end
 
   def print_pull_requests_matching(query)
-    return [] if ENV['HOMEBREW_NO_GITHUB_API']
+    return [] if ENV["HOMEBREW_NO_GITHUB_API"]
     ohai "Searching pull requests..."
 
     open_or_closed_prs = issues_matching(query, :type => "pr")
 
-    open_prs = open_or_closed_prs.select {|i| i["state"] == "open" }
+    open_prs = open_or_closed_prs.select { |i| i["state"] == "open" }
     if open_prs.any?
       puts "Open pull requests:"
       prs = open_prs