Merge branch 'master' into mirror_audit

Library/Homebrew/brew.sh

@@ -207,6 +207,7 @@ case "$HOMEBREW_COMMAND" in
   up)          HOMEBREW_COMMAND="update" ;;
   ln)          HOMEBREW_COMMAND="link" ;;
   instal)      HOMEBREW_COMMAND="install" ;; # gem does the same
+  uninstal)    HOMEBREW_COMMAND="uninstall" ;;
   rm)          HOMEBREW_COMMAND="uninstall" ;;
   remove)      HOMEBREW_COMMAND="uninstall" ;;
   configure)   HOMEBREW_COMMAND="diy" ;;

Library/Homebrew/cask/lib/hbc/cli.rb

@@ -37,6 +37,7 @@ module Hbc
       "-S"       => "search",    # verb starting with "-" is questionable
       "up"       => "update",
       "instal"   => "install",   # gem does the same
+      "uninstal" => "uninstall",
       "rm"       => "uninstall",
       "remove"   => "uninstall",
       "abv"      => "info",

Library/Homebrew/cask/lib/hbc/macos.rb

@@ -181,6 +181,7 @@ module OS
       "/usr/include",
       "/usr/lib",
       "/usr/libexec",
+      "/usr/libexec/cups",
       "/usr/local",
       "/usr/local/Cellar",
       "/usr/local/Frameworks",

Library/Homebrew/dev-cmd/bump-formula-pr.rb

@@ -80,7 +80,8 @@ module Homebrew
 
   def fetch_pull_requests(formula)
     GitHub.issues_for_formula(formula.name, tap: formula.tap).select do |pr|
-      pr["html_url"].include?("/pull/")
+      pr["html_url"].include?("/pull/") &&
+        /(^|\s)#{Regexp.quote(formula.name)}(:|\s|$)/i =~ pr["title"]
     end
   rescue GitHub::RateLimitExceededError => e
     opoo e.message

Library/Homebrew/dev-cmd/tests.rb

@@ -57,9 +57,7 @@ module Homebrew
       ENV["SEED"] = ARGV.next if ARGV.include? "--seed"
 
       files = Dir.glob("test/**/*_{spec,test}.rb")
-                 .reject { |p| !OS.mac? && p.start_with?("test/os/mac/") }
-                 .reject { |p| !OS.mac? && p.start_with?("test/cask/") }
-                 .reject { |p| p.start_with?("test/vendor/bundle/") }
+                 .reject { |p| !OS.mac? && p =~ %r{^test/(os/mac|cask)(/.*|_(test|spec)\.rb)$} }
 
       test_args = []
       test_args << "--trace" if ARGV.include? "--trace"
@@ -84,6 +82,8 @@ module Homebrew
         "--format", "ParallelTests::RSpec::RuntimeLogger",
         "--out", "tmp/parallel_runtime_rspec.log"
       ]
+      spec_args << "--tag" << "~needs_macos" unless OS.mac?
+
       run_tests "parallel_rspec", spec_files, spec_args
 
       if (fs_leak_log = HOMEBREW_LIBRARY_PATH/"tmp/fs_leak.log").file?

Library/Homebrew/extend/ENV/shared.rb

@@ -269,7 +269,7 @@ module SharedEnvExtension
   # @private
   def gcc_version_formula(name)
     version = name[GNU_GCC_REGEXP, 1]
-    gcc_version_name = "gcc#{version.delete(".")}"
+    gcc_version_name = "gcc@#{version}"
 
     gcc = Formulary.factory("gcc")
     if gcc.version_suffix == version
@@ -286,7 +286,6 @@ module SharedEnvExtension
     rescue FormulaUnavailableError => e
       raise <<-EOS.undent
       Homebrew GCC requested, but formula #{e.name} not found!
-      You may need to: brew tap homebrew/versions
       EOS
     end
 

Library/Homebrew/extend/os/mac/keg_relocate.rb

@@ -78,13 +78,19 @@ class Keg
     end
   end
 
+  def filename_contains_metavariable?(fn)
+    fn =~ /^@(loader_|executable_|r)path/
+  end
+
   def each_install_name_for(file, &block)
     dylibs = file.dynamically_linked_libraries
-    dylibs.reject! { |fn| fn =~ /^@(loader_|executable_|r)path/ }
+    dylibs.reject! { |fn| filename_contains_metavariable?(fn) }
     dylibs.each(&block)
   end
 
   def dylib_id_for(file)
+    return file.dylib_id if filename_contains_metavariable?(file.dylib_id)
+
     # The new dylib ID should have the same basename as the old dylib ID, not
     # the basename of the file itself.
     basename = File.basename(file.dylib_id)

Library/Homebrew/extend/os/mac/requirements/java_requirement.rb

-class JavaRequirement
+class JavaRequirement < Requirement
   cask "java"
 
   env do

Library/Homebrew/formula_versions.rb

@@ -15,7 +15,6 @@ class FormulaVersions
     @repository = formula.tap.path
     @entry_name = @path.relative_path_from(repository).to_s
     @max_depth = options[:max_depth]
-    @current_formula = formula
   end
 
   def rev_list(branch)
@@ -65,33 +64,25 @@ class FormulaVersions
 
     attributes.each do |attribute|
       attributes_map[attribute] ||= {}
-      # Set the attributes for the current formula in case it's not been
-      # committed yet.
-      set_attribute_map(attributes_map[attribute], @current_formula, attribute)
     end
 
     rev_list(branch) do |rev|
       formula_at_revision(rev) do |f|
         attributes.each do |attribute|
-          set_attribute_map(attributes_map[attribute], f, attribute)
+          map = attributes_map[attribute]
+          if f.stable
+            map[:stable] ||= {}
+            map[:stable][f.stable.version] ||= []
+            map[:stable][f.stable.version] << f.send(attribute)
+          end
+          next unless f.devel
+          map[:devel] ||= {}
+          map[:devel][f.devel.version] ||= []
+          map[:devel][f.devel.version] << f.send(attribute)
         end
       end
     end
 
     attributes_map
   end
-
-  private
-
-  def set_attribute_map(map, f, attribute)
-    if f.stable
-      map[:stable] ||= {}
-      map[:stable][f.stable.version] ||= []
-      map[:stable][f.stable.version] << f.send(attribute)
-    end
-    return unless f.devel
-    map[:devel] ||= {}
-    map[:devel][f.devel.version] ||= []
-    map[:devel][f.devel.version] << f.send(attribute)
-  end
 end

Library/Homebrew/formulary.rb

@@ -4,7 +4,7 @@ require "tap"
 # The Formulary is responsible for creating instances of Formula.
 # It is not meant to be used directly from formulae.
 
-class Formulary
+module Formulary
   FORMULAE = {}
 
   def self.formula_class_defined?(path)

Library/Homebrew/global.rb

@@ -69,6 +69,7 @@ HOMEBREW_INTERNAL_COMMAND_ALIASES = {
   "up" => "update",
   "ln" => "link",
   "instal" => "install", # gem does the same
+  "uninstal" => "uninstall",
   "rm" => "uninstall",
   "remove" => "uninstall",
   "configure" => "diy",

Library/Homebrew/keg.rb

@@ -239,6 +239,10 @@ class Keg
 
   def remove_opt_record
     opt_record.unlink
+    aliases.each do |a|
+      next if !opt_record.symlink? && !opt_record.exist?
+      (opt_record.parent/a).delete
+    end
     opt_record.parent.rmdir_if_possible
   end
 
@@ -461,9 +465,20 @@ class Keg
     @oldname_opt_record = nil
   end
 
+  def aliases
+    Formula[rack.basename.to_s].aliases
+  rescue FormulaUnavailableError
+    []
+  end
+
   def optlink(mode = OpenStruct.new)
     opt_record.delete if opt_record.symlink? || opt_record.exist?
     make_relative_symlink(opt_record, path, mode)
+    aliases.each do |a|
+      alias_opt_record = opt_record.parent/a
+      alias_opt_record.delete if alias_opt_record.symlink? || alias_opt_record.exist?
+      make_relative_symlink(alias_opt_record, path, mode)
+    end
 
     return unless oldname_opt_record
     oldname_opt_record.delete

Library/Homebrew/requirements/ruby_requirement.rb

@@ -8,16 +8,14 @@ class RubyRequirement < Requirement
     super
   end
 
-  satisfy build_env: false do
-    which_all("ruby").detect do |ruby|
-      version = /\d\.\d/.match Utils.popen_read(ruby, "--version")
-      next unless version
-      Version.create(version.to_s) >= Version.create(@version)
-    end
+  satisfy(build_env: false) { new_enough_ruby }
+
+  env do
+    ENV.prepend_path "PATH", new_enough_ruby
   end
 
   def message
-    s = "Ruby #{@version} is required to install this formula."
+    s = "Ruby >= #{@version} is required to install this formula."
     s += super
     s
   end
@@ -33,4 +31,28 @@ class RubyRequirement < Requirement
       name
     end
   end
+
+  private
+
+  def new_enough_ruby
+    rubies.detect { |ruby| new_enough?(ruby) }
+  end
+
+  def rubies
+    rubies = which_all("ruby")
+    ruby_formula = Formula["ruby"]
+    if ruby_formula && ruby_formula.installed?
+      rubies.unshift ruby_formula.bin/"ruby"
+    end
+    rubies.uniq
+  end
+
+  def new_enough?(ruby)
+    version = Utils.popen_read(ruby, "-e", "print RUBY_VERSION").strip
+    version =~ /^\d+\.\d+/ && Version.create(version) >= min_version
+  end
+
+  def min_version
+    @min_version ||= Version.create(@version)
+  end
 end

Library/Homebrew/test/analytics_test.rb

-require "testing_env"
-
-class IntegrationCommandTestAnalytics < IntegrationCommandTestCase
-  def test_analytics
-    HOMEBREW_REPOSITORY.cd do
-      shutup do
-        system "git", "init"
-      end
-    end
-
-    assert_match "Analytics is disabled (by HOMEBREW_NO_ANALYTICS)",
-      cmd("analytics", "HOMEBREW_NO_ANALYTICS" => "1")
-
-    cmd("analytics", "off")
-    assert_match "Analytics is disabled",
-      cmd("analytics", "HOMEBREW_NO_ANALYTICS" => nil)
-
-    cmd("analytics", "on")
-    assert_match "Analytics is enabled", cmd("analytics",
-      "HOMEBREW_NO_ANALYTICS" => nil)
-
-    assert_match "Invalid usage", cmd_fail("analytics", "on", "off")
-    assert_match "Invalid usage", cmd_fail("analytics", "testball")
-    cmd("analytics", "regenerate-uuid")
-  end
-end

Library/Homebrew/test/blacklist_spec.rb

 require "blacklist"
 
-RSpec::Matchers.define :be_blacklisted do
-  match do |actual|
-    blacklisted?(actual)
-  end
-end
-
 describe "Blacklist" do
+  matcher(:be_blacklisted) { match(&method(:blacklisted?)) }
+
   context "rubygems" do
     %w[gem rubygem rubygems].each do |s|
       subject { s }
@@ -103,9 +99,17 @@ describe "Blacklist" do
     it { is_expected.to be_blacklisted }
   end
 
-  context "haskell_platform" do
+  context "haskell-platform" do
     subject { "haskell-platform" }
 
     it { is_expected.to be_blacklisted }
   end
+
+  context "xcode", :needs_macos do
+    %w[xcode Xcode].each do |s|
+      subject { s }
+
+      it { is_expected.to be_blacklisted }
+    end
+  end
 end

Library/Homebrew/test/cmd/analytics_spec.rb

+describe "brew analytics", :integration_test do
+  before(:each) do
+    HOMEBREW_REPOSITORY.cd do
+      shutup do
+        system "git", "init"
+      end
+    end
+  end
+
+  it "is disabled when HOMEBREW_NO_ANALYTICS is set" do
+    expect { brew "analytics", "HOMEBREW_NO_ANALYTICS" => "1" }
+      .to output(/Analytics is disabled \(by HOMEBREW_NO_ANALYTICS\)/).to_stdout
+      .and not_to_output.to_stderr
+      .and be_a_success
+  end
+
+  context "when HOMEBREW_NO_ANALYTICS is unset" do
+    it "is disabled after running `brew analytics off`" do
+      brew "analytics", "off"
+      expect { brew "analytics", "HOMEBREW_NO_ANALYTICS" => nil }
+        .to output(/Analytics is disabled/).to_stdout
+        .and not_to_output.to_stderr
+        .and be_a_success
+    end
+
+    it "is enabled after running `brew analytics on`" do
+      brew "analytics", "on"
+      expect { brew "analytics", "HOMEBREW_NO_ANALYTICS" => nil }
+        .to output(/Analytics is enabled/).to_stdout
+        .and not_to_output.to_stderr
+        .and be_a_success
+    end
+  end
+
+  it "fails when running `brew analytics on off`" do
+    expect { brew "analytics", "on", "off" }
+      .to output(/Invalid usage/).to_stderr
+      .and not_to_output.to_stdout
+      .and be_a_failure
+  end
+
+  it "fails when running `brew analytics testball`" do
+    expect { brew "analytics", "testball" }
+      .to output(/Invalid usage/).to_stderr
+      .and not_to_output.to_stdout
+      .and be_a_failure
+  end
+
+  it "can generate a new UUID" do
+    expect { brew "analytics", "regenerate-uuid" }.to be_a_success
+  end
+end

Library/Homebrew/test/search_remote_tap_test.rb → Library/Homebrew/test/cmd/search_remote_tap_spec.rb

-require "testing_env"
 require "cmd/search"
 
-class SearchRemoteTapTests < Homebrew::TestCase
-  def test_search_remote_tap
+describe Homebrew do
+  specify "#search_tap" do
     json_response = {
       "tree" => [
         {
@@ -12,8 +11,9 @@ class SearchRemoteTapTests < Homebrew::TestCase
       ],
     }
 
-    GitHub.stubs(:open).yields(json_response)
+    allow(GitHub).to receive(:open).and_yield(json_response)
 
-    assert_equal ["homebrew/not-a-tap/not-a-formula"], Homebrew.search_tap("homebrew", "not-a-tap", "not-a-formula")
+    expect(described_class.search_tap("homebrew", "not-a-tap", "not-a-formula"))
+      .to eq(["homebrew/not-a-tap/not-a-formula"])
   end
 end

Library/Homebrew/test/compiler_failure_spec.rb

+require "compilers"
+
+RSpec::Matchers.alias_matcher :fail_with, :be_fails_with
+
+describe CompilerFailure do
+  describe "::create" do
+    it "creates a failure when given a symbol" do
+      failure = described_class.create(:clang)
+      expect(failure).to fail_with(double("Compiler", name: :clang, version: 425))
+    end
+
+    it "can be given a build number in a block" do
+      failure = described_class.create(:clang) { build 211 }
+      expect(failure).to fail_with(double("Compiler", name: :clang, version: 210))
+      expect(failure).not_to fail_with(double("Compiler", name: :clang, version: 318))
+    end
+
+    it "can be given an empty block" do
+      failure = described_class.create(:clang) {}
+      expect(failure).to fail_with(double("Compiler", name: :clang, version: 425))
+    end
+
+    it "creates a failure when given a hash" do
+      failure = described_class.create(gcc: "4.8")
+      expect(failure).to fail_with(double("Compiler", name: "gcc-4.8", version: "4.8"))
+      expect(failure).to fail_with(double("Compiler", name: "gcc-4.8", version: "4.8.1"))
+      expect(failure).not_to fail_with(double("Compiler", name: "gcc-4.7", version: "4.7"))
+    end
+
+    it "creates a failure when given a hash and a block with aversion" do
+      failure = described_class.create(gcc: "4.8") { version "4.8.1" }
+      expect(failure).to fail_with(double("Compiler", name: "gcc-4.8", version: "4.8"))
+      expect(failure).to fail_with(double("Compiler", name: "gcc-4.8", version: "4.8.1"))
+      expect(failure).not_to fail_with(double("Compiler", name: "gcc-4.8", version: "4.8.2"))
+    end
+  end
+end

Library/Homebrew/test/compiler_failure_test.rb

-require "testing_env"
-require "compilers"
-
-class CompilerFailureTests < Homebrew::TestCase
-  Compiler = Struct.new(:name, :version)
-
-  def assert_fails_with(compiler, failure)
-    assert_operator failure, :fails_with?, compiler
-  end
-
-  def refute_fails_with(compiler, failure)
-    refute_operator failure, :fails_with?, compiler
-  end
-
-  def compiler(name, version)
-    Compiler.new(name, version)
-  end
-
-  def create(spec, &block)
-    CompilerFailure.create(spec, &block)
-  end
-
-  def test_create_with_symbol
-    failure = create(:clang)
-    assert_fails_with compiler(:clang, 425), failure
-  end
-
-  def test_create_with_block
-    failure = create(:clang) { build 211 }
-    assert_fails_with compiler(:clang, 210), failure
-    refute_fails_with compiler(:clang, 318), failure
-  end
-
-  def test_create_with_block_without_build
-    failure = create(:clang) {}
-    assert_fails_with compiler(:clang, 425), failure
-  end
-
-  def test_create_with_hash
-    failure = create(gcc: "4.8")
-    assert_fails_with compiler("gcc-4.8", "4.8"), failure
-    assert_fails_with compiler("gcc-4.8", "4.8.1"), failure
-    refute_fails_with compiler("gcc-4.7", "4.7"), failure
-  end
-
-  def test_create_with_hash_and_version
-    failure = create(gcc: "4.8") { version "4.8.1" }
-    assert_fails_with compiler("gcc-4.8", "4.8"), failure
-    assert_fails_with compiler("gcc-4.8", "4.8.1"), failure
-    refute_fails_with compiler("gcc-4.8", "4.8.2"), failure
-  end
-end

Library/Homebrew/test/compiler_selector_spec.rb

+require "compilers"
+require "software_spec"
+
+describe CompilerSelector do
+  subject { described_class.new(software_spec, versions, compilers) }
+  let(:compilers) { [:clang, :gcc, :llvm, :gnu] }
+  let(:software_spec) { SoftwareSpec.new }
+  let(:cc) { :clang }
+  let(:versions) do
+    double(
+      gcc_4_0_build_version: Version::NULL,
+      gcc_build_version: Version.create("5666"),
+      llvm_build_version: Version::NULL,
+      clang_build_version: Version.create("425"),
+    )
+  end
+
+  before(:each) do
+    allow(versions).to receive(:non_apple_gcc_version) do |name|
+      case name
+      when "gcc-4.8" then Version.create("4.8.1")
+      when "gcc-4.7" then Version.create("4.7.1")
+      else Version::NULL
+      end
+    end
+  end
+
+  describe "#compiler" do
+    it "raises an error if no matching compiler can be found" do
+      software_spec.fails_with(:clang)
+      software_spec.fails_with(:llvm)
+      software_spec.fails_with(:gcc)
+      software_spec.fails_with(gcc: "4.8")
+      software_spec.fails_with(gcc: "4.7")
+
+      expect { subject.compiler }.to raise_error(CompilerSelectionError)
+    end
+
+    it "defaults to cc" do
+      expect(subject.compiler).to eq(cc)
+    end
+
+    it "returns gcc if it fails with clang" do
+      software_spec.fails_with(:clang)
+      expect(subject.compiler).to eq(:gcc)
+    end
+
+    it "returns clang if it fails with llvm" do
+      software_spec.fails_with(:llvm)
+      expect(subject.compiler).to eq(:clang)
+    end
+
+    it "returns clang if it fails with gcc" do
+      software_spec.fails_with(:gcc)
+      expect(subject.compiler).to eq(:clang)
+    end
+
+    it "returns clang if it fails with non-Apple gcc" do
+      software_spec.fails_with(gcc: "4.8")
+      expect(subject.compiler).to eq(:clang)
+    end
+
+    it "still returns gcc-4.8 if it fails with gcc without a specific version" do
+      software_spec.fails_with(:clang)
+      software_spec.fails_with(:gcc)
+      expect(subject.compiler).to eq("gcc-4.8")
+    end
+
+    it "returns gcc if it fails with clang and llvm" do
+      software_spec.fails_with(:clang)
+      software_spec.fails_with(:llvm)
+      expect(subject.compiler).to eq(:gcc)
+    end
+
+    it "returns clang if it fails with gcc and llvm" do
+      software_spec.fails_with(:gcc)
+      software_spec.fails_with(:llvm)
+      expect(subject.compiler).to eq(:clang)
+    end
+
+    example "returns gcc if it fails with a specific gcc version" do
+      software_spec.fails_with(:clang)
+      software_spec.fails_with(gcc: "4.8")
+      expect(subject.compiler).to eq(:gcc)
+    end
+
+    example "returns a lower version of gcc if it fails with the highest version" do
+      software_spec.fails_with(:clang)
+      software_spec.fails_with(:gcc)
+      software_spec.fails_with(:llvm)
+      software_spec.fails_with(gcc: "4.8")
+      expect(subject.compiler).to eq("gcc-4.7")
+    end
+
+    it "prefers gcc" do
+      software_spec.fails_with(:clang)
+      software_spec.fails_with(:gcc)
+      expect(subject.compiler).to eq("gcc-4.8")
+    end
+
+    it "raises an error when gcc is missing" do
+      allow(versions).to receive(:gcc_build_version).and_return(Version::NULL)
+
+      software_spec.fails_with(:clang)
+      software_spec.fails_with(:llvm)
+      software_spec.fails_with(gcc: "4.8")
+      software_spec.fails_with(gcc: "4.7")
+
+      expect { subject.compiler }.to raise_error(CompilerSelectionError)
+    end
+
+    it "raises an error when llvm and gcc are missing" do
+      allow(versions).to receive(:gcc_build_version).and_return(Version::NULL)
+
+      software_spec.fails_with(:clang)
+      software_spec.fails_with(gcc: "4.8")
+      software_spec.fails_with(gcc: "4.7")
+
+      expect { subject.compiler }.to raise_error(CompilerSelectionError)
+    end
+  end
+end