From fd343a11fbde41420fe13b4acab7bce8eea34d13 Mon Sep 17 00:00:00 2001
From: Shaun Jackman
Date: Fri, 3 Feb 2017 10:47:44 -0800
Subject: gcc_version_formula: Use gcc@4.x rather than gcc4x

---
 Library/Homebrew/extend/ENV/shared.rb | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/extend/ENV/shared.rb b/Library/Homebrew/extend/ENV/shared.rb
index 7b468574a..3b07e0a71 100644
--- a/Library/Homebrew/extend/ENV/shared.rb
+++ b/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
 
-- 
cgit v1.2.3


From aeaf3d594c5ba417bfad582f48c79a2883f8475c Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Fri, 17 Feb 2017 18:35:26 +0100
Subject: Convert Utils::Shell test to spec.

---
 Library/Homebrew/test/shell_test.rb       | 56 -------------------
 Library/Homebrew/test/utils/shell_spec.rb | 93 +++++++++++++++++++++++++++++++
 2 files changed, 93 insertions(+), 56 deletions(-)
 delete mode 100644 Library/Homebrew/test/shell_test.rb
 create mode 100644 Library/Homebrew/test/utils/shell_spec.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/shell_test.rb b/Library/Homebrew/test/shell_test.rb
deleted file mode 100644
index 970489702..000000000
--- a/Library/Homebrew/test/shell_test.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-require "testing_env"
-require "utils/shell"
-
-class ShellSmokeTest < Homebrew::TestCase
-  def test_path_to_shell
-    # raw command name
-    assert_equal :bash, Utils::Shell.path_to_shell("bash")
-    # full path
-    assert_equal :bash, Utils::Shell.path_to_shell("/bin/bash")
-    # versions
-    assert_equal :zsh, Utils::Shell.path_to_shell("zsh-5.2")
-    # strip newline too
-    assert_equal :zsh, Utils::Shell.path_to_shell("zsh-5.2\n")
-  end
-
-  def test_path_to_shell_failure
-    assert_nil Utils::Shell.path_to_shell("")
-    assert_nil Utils::Shell.path_to_shell("@@@@@@")
-    assert_nil Utils::Shell.path_to_shell("invalid_shell-4.2")
-  end
-
-  def test_sh_quote
-    assert_equal "''", Utils::Shell.sh_quote("")
-    assert_equal "\\\\", Utils::Shell.sh_quote("\\")
-    assert_equal "'\n'", Utils::Shell.sh_quote("\n")
-    assert_equal "\\$", Utils::Shell.sh_quote("$")
-    assert_equal "word", Utils::Shell.sh_quote("word")
-  end
-
-  def test_csh_quote
-    assert_equal "''", Utils::Shell.csh_quote("")
-    assert_equal "\\\\", Utils::Shell.csh_quote("\\")
-    # note this test is different than for sh
-    assert_equal "'\\\n'", Utils::Shell.csh_quote("\n")
-    assert_equal "\\$", Utils::Shell.csh_quote("$")
-    assert_equal "word", Utils::Shell.csh_quote("word")
-  end
-
-  def prepend_path_shell(shell, path, fragment)
-    ENV["SHELL"] = shell
-
-    prepend_message = Utils::Shell.prepend_path_in_shell_profile(path)
-    assert(
-      prepend_message.start_with?(fragment),
-      "#{shell}: expected #{prepend_message} to match #{fragment}",
-    )
-  end
-
-  def test_prepend_path_in_shell_profile
-    prepend_path_shell "/bin/tcsh", "/path", "echo 'setenv PATH /path"
-
-    prepend_path_shell "/bin/bash", "/path", "echo 'export PATH=\"/path"
-
-    prepend_path_shell "/usr/local/bin/fish", "/path", "echo 'set -g fish_user_paths \"/path\" $fish_user_paths' >>"
-  end
-end
diff --git a/Library/Homebrew/test/utils/shell_spec.rb b/Library/Homebrew/test/utils/shell_spec.rb
new file mode 100644
index 000000000..c44bd8253
--- /dev/null
+++ b/Library/Homebrew/test/utils/shell_spec.rb
@@ -0,0 +1,93 @@
+require "utils/shell"
+
+describe Utils::Shell do
+  describe "::shell_profile" do
+    it "returns ~/.bash_profile by default" do
+      ENV["SHELL"] = "/bin/another_shell"
+      expect(subject.shell_profile).to eq("~/.bash_profile")
+    end
+
+    it "returns ~/.bash_profile for Sh" do
+      ENV["SHELL"] = "/bin/another_shell"
+      expect(subject.shell_profile).to eq("~/.bash_profile")
+    end
+
+    it "returns ~/.bash_profile for Bash" do
+      ENV["SHELL"] = "/bin/bash"
+      expect(subject.shell_profile).to eq("~/.bash_profile")
+    end
+
+    it "returns ~/.zshrc for Zsh" do
+      ENV["SHELL"] = "/bin/zsh"
+      expect(subject.shell_profile).to eq("~/.zshrc")
+    end
+
+    it "returns ~/.kshrc for Ksh" do
+      ENV["SHELL"] = "/bin/ksh"
+      expect(subject.shell_profile).to eq("~/.kshrc")
+    end
+  end
+
+  describe "::path_to_shell" do
+    it "supports a raw command name" do
+      expect(subject.path_to_shell("bash")).to eq(:bash)
+    end
+
+    it "supports full paths" do
+      expect(subject.path_to_shell("/bin/bash")).to eq(:bash)
+    end
+
+    it "supports versions" do
+      expect(subject.path_to_shell("zsh-5.2")).to eq(:zsh)
+    end
+
+    it "strips newlines" do
+      expect(subject.path_to_shell("zsh-5.2\n")).to eq(:zsh)
+    end
+
+    it "returns nil when input is invalid" do
+      expect(subject.path_to_shell("")).to be nil
+      expect(subject.path_to_shell("@@@@@@")).to be nil
+      expect(subject.path_to_shell("invalid_shell-4.2")).to be nil
+    end
+  end
+
+  specify "::sh_quote" do
+    expect(subject.sh_quote("")).to eq("''")
+    expect(subject.sh_quote("\\")).to eq("\\\\")
+    expect(subject.sh_quote("\n")).to eq("'\n'")
+    expect(subject.sh_quote("$")).to eq("\\$")
+    expect(subject.sh_quote("word")).to eq("word")
+  end
+
+  specify "::csh_quote" do
+    expect(subject.csh_quote("")).to eq("''")
+    expect(subject.csh_quote("\\")).to eq("\\\\")
+    # note this test is different than for sh
+    expect(subject.csh_quote("\n")).to eq("'\\\n'")
+    expect(subject.csh_quote("$")).to eq("\\$")
+    expect(subject.csh_quote("word")).to eq("word")
+  end
+
+  describe "::prepend_path_in_shell_profile" do
+    let(:path) { "/my/path" }
+
+    it "supports Tcsh" do
+      ENV["SHELL"] = "/bin/tcsh"
+      expect(subject.prepend_path_in_shell_profile(path))
+        .to start_with("echo 'setenv PATH #{path}:$")
+    end
+
+    it "supports Bash" do
+      ENV["SHELL"] = "/bin/bash"
+      expect(subject.prepend_path_in_shell_profile(path))
+        .to start_with("echo 'export PATH=\"#{path}:$")
+    end
+
+    it "supports Fish" do
+      ENV["SHELL"] = "/usr/local/bin/fish"
+      expect(subject.prepend_path_in_shell_profile(path))
+        .to start_with("echo 'set -g fish_user_paths \"#{path}\" $fish_user_paths' >>")
+    end
+  end
+end
-- 
cgit v1.2.3


From 262f357d86f145fad3c78b3d843b32ac4e384f5e Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Sat, 18 Feb 2017 22:17:32 +0100
Subject: Convert CompilerFailure test to spec.

---
 Library/Homebrew/test/compiler_failure_spec.rb | 41 ++++++++++++++++++++
 Library/Homebrew/test/compiler_failure_test.rb | 52 --------------------------
 2 files changed, 41 insertions(+), 52 deletions(-)
 create mode 100644 Library/Homebrew/test/compiler_failure_spec.rb
 delete mode 100644 Library/Homebrew/test/compiler_failure_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/compiler_failure_spec.rb b/Library/Homebrew/test/compiler_failure_spec.rb
new file mode 100644
index 000000000..81e464a87
--- /dev/null
+++ b/Library/Homebrew/test/compiler_failure_spec.rb
@@ -0,0 +1,41 @@
+require "compilers"
+
+describe CompilerFailure do
+  matcher :fail_with do |expected|
+    match do |actual|
+      actual.fails_with?(expected)
+    end
+  end
+
+  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
diff --git a/Library/Homebrew/test/compiler_failure_test.rb b/Library/Homebrew/test/compiler_failure_test.rb
deleted file mode 100644
index c0b74d128..000000000
--- a/Library/Homebrew/test/compiler_failure_test.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-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
-- 
cgit v1.2.3


From df50a7e56e5947dce3bbbec671dfb9312dd2bbd1 Mon Sep 17 00:00:00 2001
From: Sergey Parhomenko
Date: Sun, 19 Feb 2017 14:06:51 +0100
Subject: Add /usr/libexec/cups to the list of system dirs

---
 Library/Homebrew/cask/lib/hbc/macos.rb | 1 +
 1 file changed, 1 insertion(+)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/cask/lib/hbc/macos.rb b/Library/Homebrew/cask/lib/hbc/macos.rb
index 5c1515d0c..d47e04fb2 100644
--- a/Library/Homebrew/cask/lib/hbc/macos.rb
+++ b/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",
-- 
cgit v1.2.3


From 05a98f24c4d21b3a3c7fcb4045e74619a4628f4c Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Thu, 16 Feb 2017 21:17:46 +0100
Subject: Convert Utils test to spec.

---
 .../Homebrew/test/utils/bottles/bintray_spec.rb    |  18 ++
 Library/Homebrew/test/utils/popen_spec.rb          |  28 ++
 Library/Homebrew/test/utils_spec.rb                | 283 +++++++++++++++++++++
 Library/Homebrew/test/utils_test.rb                | 252 ------------------
 4 files changed, 329 insertions(+), 252 deletions(-)
 create mode 100644 Library/Homebrew/test/utils/bottles/bintray_spec.rb
 create mode 100644 Library/Homebrew/test/utils/popen_spec.rb
 create mode 100644 Library/Homebrew/test/utils_spec.rb
 delete mode 100644 Library/Homebrew/test/utils_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/utils/bottles/bintray_spec.rb b/Library/Homebrew/test/utils/bottles/bintray_spec.rb
new file mode 100644
index 000000000..a7dfc00ea
--- /dev/null
+++ b/Library/Homebrew/test/utils/bottles/bintray_spec.rb
@@ -0,0 +1,18 @@
+require "utils/bottles"
+
+describe Utils::Bottles::Bintray do
+  describe "::package" do
+    it "converts a Formula name to a package name" do
+      expect(described_class.package("openssl@1.1")).to eq("openssl:1.1")
+      expect(described_class.package("gtk+")).to eq("gtkx")
+      expect(described_class.package("llvm")).to eq("llvm")
+    end
+  end
+
+  describe "::repository" do
+    it "returns the repository for a given Tap" do
+      expect(described_class.repository(Tap.new("homebrew", "bintray-test")))
+        .to eq("bottles-bintray-test")
+    end
+  end
+end
diff --git a/Library/Homebrew/test/utils/popen_spec.rb b/Library/Homebrew/test/utils/popen_spec.rb
new file mode 100644
index 000000000..e3704a876
--- /dev/null
+++ b/Library/Homebrew/test/utils/popen_spec.rb
@@ -0,0 +1,28 @@
+require "utils/popen"
+
+describe Utils do
+  describe "::popen_read" do
+    it "reads the standard output of a given command" do
+      expect(subject.popen_read("sh", "-c", "echo success").chomp).to eq("success")
+      expect($?).to be_a_success
+    end
+
+    it "can be given a block to manually read from the pipe" do
+      expect(
+        subject.popen_read("sh", "-c", "echo success") do |pipe|
+          pipe.read.chomp
+        end,
+      ).to eq("success")
+      expect($?).to be_a_success
+    end
+  end
+
+  describe "::popen_write" do
+    it "with supports writing to a command's standard input" do
+      subject.popen_write("grep", "-q", "success") do |pipe|
+        pipe.write("success\n")
+      end
+      expect($?).to be_a_success
+    end
+  end
+end
diff --git a/Library/Homebrew/test/utils_spec.rb b/Library/Homebrew/test/utils_spec.rb
new file mode 100644
index 000000000..de6b287d2
--- /dev/null
+++ b/Library/Homebrew/test/utils_spec.rb
@@ -0,0 +1,283 @@
+require "utils"
+
+RSpec::Matchers.alias_matcher :have_failed, :be_failed
+
+describe "globally-scoped helper methods" do
+  let(:dir) { @dir = Pathname.new(Dir.mktmpdir) }
+
+  after(:each) { dir.rmtree unless @dir.nil? }
+
+  def esc(code)
+    /(\e\[\d+m)*\e\[#{code}m/
+  end
+
+  describe "#ofail" do
+    it "sets Homebrew.failed to true" do
+      begin
+        shutup do
+          ofail "foo"
+        end
+
+        expect(Homebrew).to have_failed
+      ensure
+        Homebrew.failed = false
+      end
+    end
+  end
+
+  describe "#odie" do
+    it "exits with 1" do
+      expect(self).to receive(:exit).and_return(1)
+      expect {
+        odie "foo"
+      }.to output("Error: foo\n").to_stderr
+    end
+  end
+
+  describe "#pretty_installed" do
+    subject { pretty_installed("foo") }
+
+    context "when $stdout is a TTY" do
+      before(:each) { allow($stdout).to receive(:tty?).and_return(true) }
+
+      context "with HOMEBREW_NO_EMOJI unset" do
+        before(:each) { ENV.delete("HOMEBREW_NO_EMOJI") }
+
+        it "returns a string with a colored checkmark" do
+          expect(subject)
+            .to match(/#{esc 1}foo #{esc 32}✔#{esc 0}/)
+        end
+      end
+
+      context "with HOMEBREW_NO_EMOJI set" do
+        before(:each) { ENV["HOMEBREW_NO_EMOJI"] = "1" }
+
+        it "returns a string with colored info" do
+          expect(subject)
+            .to match(/#{esc 1}foo \(installed\)#{esc 0}/)
+        end
+      end
+    end
+
+    context "when $stdout is not a TTY" do
+      before(:each) { allow($stdout).to receive(:tty?).and_return(false) }
+
+      it "returns plain text" do
+        expect(subject).to eq("foo")
+      end
+    end
+  end
+
+  describe "#pretty_uninstalled" do
+    subject { pretty_uninstalled("foo") }
+
+    context "when $stdout is a TTY" do
+      before(:each) { allow($stdout).to receive(:tty?).and_return(true) }
+
+      context "with HOMEBREW_NO_EMOJI unset" do
+        before(:each) { ENV.delete("HOMEBREW_NO_EMOJI") }
+
+        it "returns a string with a colored checkmark" do
+          expect(subject)
+            .to match(/#{esc 1}foo #{esc 31}✘#{esc 0}/)
+        end
+      end
+
+      context "with HOMEBREW_NO_EMOJI set" do
+        before(:each) { ENV["HOMEBREW_NO_EMOJI"] = "1" }
+
+        it "returns a string with colored info" do
+          expect(subject)
+            .to match(/#{esc 1}foo \(uninstalled\)#{esc 0}/)
+        end
+      end
+    end
+
+    context "when $stdout is not a TTY" do
+      before(:each) { allow($stdout).to receive(:tty?).and_return(false) }
+
+      it "returns plain text" do
+        expect(subject).to eq("foo")
+      end
+    end
+  end
+
+  describe "#interactive_shell" do
+    let(:shell) { dir/"myshell" }
+
+    it "starts an interactive shell session" do
+      IO.write shell, <<-EOS.undent
+        #!/bin/sh
+        echo called > "#{dir}/called"
+      EOS
+
+      FileUtils.chmod 0755, shell
+
+      ENV["SHELL"] = shell
+
+      expect { interactive_shell }.not_to raise_error
+      expect(dir/"called").to exist
+    end
+  end
+
+  describe "#with_custom_locale" do
+    it "temporarily overrides the system locale" do
+      ENV["LC_ALL"] = "en_US.UTF-8"
+
+      with_custom_locale("C") do
+        expect(ENV["LC_ALL"]).to eq("C")
+      end
+
+      expect(ENV["LC_ALL"]).to eq("en_US.UTF-8")
+    end
+  end
+
+  describe "#run_as_not_developer" do
+    it "temporarily unsets HOMEBREW_DEVELOPER" do
+      ENV["HOMEBREW_DEVELOPER"] = "foo"
+
+      run_as_not_developer do
+        expect(ENV["HOMEBREW_DEVELOPER"]).to be nil
+      end
+
+      expect(ENV["HOMEBREW_DEVELOPER"]).to eq("foo")
+    end
+  end
+
+  describe "#which" do
+    let(:cmd) { dir/"foo" }
+
+    before(:each) { FileUtils.touch cmd }
+
+    it "returns the first executable that is found" do
+      cmd.chmod 0744
+      expect(which(File.basename(cmd), File.dirname(cmd))).to eq(cmd)
+    end
+
+    it "skips non-executables" do
+      expect(which(File.basename(cmd), File.dirname(cmd))).to be nil
+    end
+
+    it "skips malformed path and doesn't fail" do
+      # 'which' should not fail if a path is malformed
+      # see https://github.com/Homebrew/legacy-homebrew/issues/32789 for an example
+      cmd.chmod 0744
+
+      # ~~ will fail because ~foo resolves to foo's home and there is no '~' user
+      path = ["~~", File.dirname(cmd)].join(File::PATH_SEPARATOR)
+      expect(which(File.basename(cmd), path)).to eq(cmd)
+    end
+  end
+
+  describe "#which_all" do
+    let(:cmd1) { dir/"foo" }
+    let(:cmd2) { dir/"bar/foo" }
+    let(:cmd3) { dir/"bar/baz/foo" }
+
+    before(:each) do
+      (dir/"bar/baz").mkpath
+
+      FileUtils.touch cmd2
+
+      [cmd1, cmd3].each do |cmd|
+        FileUtils.touch cmd
+        cmd.chmod 0744
+      end
+    end
+
+    it "returns an array of all executables that are found" do
+      path = [
+        "#{dir}/bar/baz",
+        "#{dir}/baz:#{dir}",
+        "~baduserpath",
+      ].join(File::PATH_SEPARATOR)
+      expect(which_all("foo", path)).to eq([cmd3, cmd1])
+    end
+  end
+
+  specify "#which_editor" do
+    ENV["HOMEBREW_EDITOR"] = "vemate"
+    expect(which_editor).to eq("vemate")
+  end
+
+  specify "#gzip" do
+    Dir.mktmpdir do |path|
+      path = Pathname.new(path)
+      somefile = path/"somefile"
+      FileUtils.touch somefile
+      expect(gzip(somefile)[0].to_s).to eq("#{somefile}.gz")
+      expect(Pathname.new("#{somefile}.gz")).to exist
+    end
+  end
+
+  specify "#capture_stderr" do
+    err = capture_stderr do
+      $stderr.print "test"
+    end
+
+    expect(err).to eq("test")
+  end
+
+  describe "#pretty_duration" do
+    it "converts seconds to a human-readable string" do
+      expect(pretty_duration(1)).to eq("1 second")
+      expect(pretty_duration(2.5)).to eq("2 seconds")
+      expect(pretty_duration(42)).to eq("42 seconds")
+      expect(pretty_duration(240)).to eq("4 minutes")
+      expect(pretty_duration(252.45)).to eq("4 minutes 12 seconds")
+    end
+  end
+
+  specify "#plural" do
+    expect(plural(1)).to eq("")
+    expect(plural(0)).to eq("s")
+    expect(plural(42)).to eq("s")
+    expect(plural(42, "")).to eq("")
+  end
+
+  specify "#disk_usage_readable" do
+    expect(disk_usage_readable(1)).to eq("1B")
+    expect(disk_usage_readable(1000)).to eq("1000B")
+    expect(disk_usage_readable(1024)).to eq("1K")
+    expect(disk_usage_readable(1025)).to eq("1K")
+    expect(disk_usage_readable(4_404_020)).to eq("4.2M")
+    expect(disk_usage_readable(4_509_715_660)).to eq("4.2G")
+  end
+
+  describe "#number_readable" do
+    it "returns a string with thousands separators" do
+      expect(number_readable(1)).to eq("1")
+      expect(number_readable(1_000)).to eq("1,000")
+      expect(number_readable(1_000_000)).to eq("1,000,000")
+    end
+  end
+
+  specify "#truncate_text_to_approximate_size" do
+    glue = "\n[...snip...]\n" # hard-coded copy from truncate_text_to_approximate_size
+    n = 20
+    long_s = "x" * 40
+
+    s = truncate_text_to_approximate_size(long_s, n)
+    expect(s.length).to eq(n)
+    expect(s).to match(/^x+#{Regexp.escape(glue)}x+$/)
+
+    s = truncate_text_to_approximate_size(long_s, n, front_weight: 0.0)
+    expect(s).to eq(glue + ("x" * (n - glue.length)))
+
+    s = truncate_text_to_approximate_size(long_s, n, front_weight: 1.0)
+    expect(s).to eq(("x" * (n - glue.length)) + glue)
+  end
+
+  describe "#odeprecated" do
+    it "raises a MethodDeprecatedError" do
+      ENV.delete("HOMEBREW_DEVELOPER")
+      expect {
+        odeprecated(
+          "method", "replacement",
+          caller: ["#{HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core/"],
+          disable: true
+        )
+      }.to raise_error(MethodDeprecatedError, %r{method.*replacement.*homebrew/homebrew-core.*homebrew/core}m)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/utils_test.rb b/Library/Homebrew/test/utils_test.rb
deleted file mode 100644
index 1f2fb7b55..000000000
--- a/Library/Homebrew/test/utils_test.rb
+++ /dev/null
@@ -1,252 +0,0 @@
-require "testing_env"
-require "utils"
-require "tempfile"
-require "utils/shell"
-
-class UtilTests < Homebrew::TestCase
-  def setup
-    super
-    @dir = Pathname.new(mktmpdir)
-  end
-
-  def esc(code)
-    /(\e\[\d+m)*\e\[#{code}m/
-  end
-
-  def test_ofail
-    shutup { ofail "foo" }
-    assert Homebrew.failed?
-  ensure
-    Homebrew.failed = false
-  end
-
-  def test_odie
-    expects(:exit).returns 1
-    shutup { odie "foo" }
-  end
-
-  def test_pretty_installed
-    $stdout.stubs(:tty?).returns true
-    ENV.delete("HOMEBREW_NO_EMOJI")
-    tty_with_emoji_output = /\A#{esc 1}foo #{esc 32}✔#{esc 0}\Z/
-    assert_match tty_with_emoji_output, pretty_installed("foo")
-
-    ENV["HOMEBREW_NO_EMOJI"] = "1"
-    tty_no_emoji_output = /\A#{esc 1}foo \(installed\)#{esc 0}\Z/
-    assert_match tty_no_emoji_output, pretty_installed("foo")
-
-    $stdout.stubs(:tty?).returns false
-    assert_equal "foo", pretty_installed("foo")
-  end
-
-  def test_pretty_uninstalled
-    $stdout.stubs(:tty?).returns true
-    ENV.delete("HOMEBREW_NO_EMOJI")
-    tty_with_emoji_output = /\A#{esc 1}foo #{esc 31}✘#{esc 0}\Z/
-    assert_match tty_with_emoji_output, pretty_uninstalled("foo")
-
-    ENV["HOMEBREW_NO_EMOJI"] = "1"
-    tty_no_emoji_output = /\A#{esc 1}foo \(uninstalled\)#{esc 0}\Z/
-    assert_match tty_no_emoji_output, pretty_uninstalled("foo")
-
-    $stdout.stubs(:tty?).returns false
-    assert_equal "foo", pretty_uninstalled("foo")
-  end
-
-  def test_interactive_shell
-    mktmpdir do |path|
-      shell = "#{path}/myshell"
-      File.open(shell, "w") do |file|
-        file.write "#!/bin/sh\necho called > #{path}/called\n"
-      end
-      FileUtils.chmod 0755, shell
-      ENV["SHELL"] = shell
-      assert_nothing_raised { interactive_shell }
-      assert File.exist? "#{path}/called"
-    end
-  end
-
-  def test_with_custom_locale
-    ENV["LC_ALL"] = "en_US.UTF-8"
-    with_custom_locale("C") do
-      assert_equal "C", ENV["LC_ALL"]
-    end
-    assert_equal "en_US.UTF-8", ENV["LC_ALL"]
-  end
-
-  def test_run_as_not_developer
-    ENV["HOMEBREW_DEVELOPER"] = "foo"
-    run_as_not_developer do
-      assert_nil ENV["HOMEBREW_DEVELOPER"]
-    end
-    assert_equal "foo", ENV["HOMEBREW_DEVELOPER"]
-  end
-
-  def test_put_columns_empty
-    out, err = capture_io do
-      puts Formatter.columns([])
-    end
-
-    assert_equal out, "\n"
-    assert_equal err, ""
-  end
-
-  def test_which
-    cmd = @dir/"foo"
-    FileUtils.touch cmd
-    cmd.chmod 0744
-    assert_equal Pathname.new(cmd),
-      which(File.basename(cmd), File.dirname(cmd))
-  end
-
-  def test_which_skip_non_executables
-    cmd = @dir/"foo"
-    FileUtils.touch cmd
-    assert_nil which(File.basename(cmd), File.dirname(cmd))
-  end
-
-  def test_which_skip_malformed_path
-    # 'which' should not fail if a path is malformed
-    # see https://github.com/Homebrew/legacy-homebrew/issues/32789 for an example
-    cmd = @dir/"foo"
-    FileUtils.touch cmd
-    cmd.chmod 0744
-
-    # ~~ will fail because ~foo resolves to foo's home and there is no '~' user
-    # here
-    assert_equal Pathname.new(cmd),
-      which(File.basename(cmd), "~~#{File::PATH_SEPARATOR}#{File.dirname(cmd)}")
-  end
-
-  def test_which_all
-    (@dir/"bar/baz").mkpath
-    cmd1 = @dir/"foo"
-    cmd2 = @dir/"bar/foo"
-    cmd3 = @dir/"bar/baz/foo"
-    FileUtils.touch cmd2
-    [cmd1, cmd3].each do |cmd|
-      FileUtils.touch cmd
-      cmd.chmod 0744
-    end
-    assert_equal [cmd3, cmd1],
-      which_all("foo", "#{@dir}/bar/baz:#{@dir}/baz:#{@dir}:~baduserpath")
-  end
-
-  def test_which_editor
-    ENV["HOMEBREW_EDITOR"] = "vemate"
-    assert_equal "vemate", which_editor
-  end
-
-  def test_gzip
-    mktmpdir do |path|
-      somefile = "#{path}/somefile"
-      FileUtils.touch somefile
-      assert_equal "#{somefile}.gz",
-        gzip(somefile)[0].to_s
-      assert File.exist?("#{somefile}.gz")
-    end
-  end
-
-  def test_capture_stderr
-    assert_equal "test\n", capture_stderr { $stderr.puts "test" }
-  end
-
-  def test_shell_profile
-    ENV["SHELL"] = "/bin/sh"
-    assert_equal "~/.bash_profile", Utils::Shell.shell_profile
-    ENV["SHELL"] = "/bin/bash"
-    assert_equal "~/.bash_profile", Utils::Shell.shell_profile
-    ENV["SHELL"] = "/bin/another_shell"
-    assert_equal "~/.bash_profile", Utils::Shell.shell_profile
-    ENV["SHELL"] = "/bin/zsh"
-    assert_equal "~/.zshrc", Utils::Shell.shell_profile
-    ENV["SHELL"] = "/bin/ksh"
-    assert_equal "~/.kshrc", Utils::Shell.shell_profile
-  end
-
-  def test_popen_read
-    out = Utils.popen_read("sh", "-c", "echo success").chomp
-    assert_equal "success", out
-    assert_predicate $?, :success?
-  end
-
-  def test_popen_read_with_block
-    out = Utils.popen_read("sh", "-c", "echo success") do |pipe|
-      pipe.read.chomp
-    end
-    assert_equal "success", out
-    assert_predicate $?, :success?
-  end
-
-  def test_popen_write_with_block
-    Utils.popen_write("grep", "-q", "success") do |pipe|
-      pipe.write("success\n")
-    end
-    assert_predicate $?, :success?
-  end
-
-  def test_pretty_duration
-    assert_equal "1 second", pretty_duration(1)
-    assert_equal "2 seconds", pretty_duration(2.5)
-    assert_equal "42 seconds", pretty_duration(42)
-    assert_equal "4 minutes", pretty_duration(240)
-    assert_equal "4 minutes 12 seconds", pretty_duration(252.45)
-  end
-
-  def test_plural
-    assert_equal "", plural(1)
-    assert_equal "s", plural(0)
-    assert_equal "s", plural(42)
-    assert_equal "", plural(42, "")
-  end
-
-  def test_disk_usage_readable
-    assert_equal "1B", disk_usage_readable(1)
-    assert_equal "1000B", disk_usage_readable(1000)
-    assert_equal "1K", disk_usage_readable(1024)
-    assert_equal "1K", disk_usage_readable(1025)
-    assert_equal "4.2M", disk_usage_readable(4_404_020)
-    assert_equal "4.2G", disk_usage_readable(4_509_715_660)
-  end
-
-  def test_number_readable
-    assert_equal "1", number_readable(1)
-    assert_equal "1,000", number_readable(1_000)
-    assert_equal "1,000,000", number_readable(1_000_000)
-  end
-
-  def test_truncate_text_to_approximate_size
-    glue = "\n[...snip...]\n" # hard-coded copy from truncate_text_to_approximate_size
-    n = 20
-    long_s = "x" * 40
-    s = truncate_text_to_approximate_size(long_s, n)
-    assert_equal n, s.length
-    assert_match(/^x+#{Regexp.escape(glue)}x+$/, s)
-    s = truncate_text_to_approximate_size(long_s, n, front_weight: 0.0)
-    assert_equal glue + ("x" * (n - glue.length)), s
-    s = truncate_text_to_approximate_size(long_s, n, front_weight: 1.0)
-    assert_equal(("x" * (n - glue.length)) + glue, s)
-  end
-
-  def test_odeprecated
-    ENV.delete("HOMEBREW_DEVELOPER")
-    e = assert_raises(MethodDeprecatedError) do
-      odeprecated("method", "replacement",
-        caller: ["#{HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core/"],
-        disable: true)
-    end
-    assert_match "method", e.message
-    assert_match "replacement", e.message
-    assert_match "homebrew/homebrew-core", e.message
-    assert_match "homebrew/core", e.message
-  end
-
-  def test_bottles_bintray
-    assert_equal "openssl:1.1", Utils::Bottles::Bintray.package("openssl@1.1")
-    assert_equal "gtkx", Utils::Bottles::Bintray.package("gtk+")
-    assert_equal "llvm", Utils::Bottles::Bintray.package("llvm")
-
-    tap = Tap.new("homebrew", "bintray-test")
-    assert_equal "bottles-bintray-test", Utils::Bottles::Bintray.repository(tap)
-  end
-end
-- 
cgit v1.2.3


From 44d2617030f8407e74036decd93d94b33db881e7 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Sat, 18 Feb 2017 16:52:36 +0100
Subject: Handle `Homebrew.failed` in `spec_helper`.

---
 Library/Homebrew/test/spec_helper.rb |  6 ++++++
 Library/Homebrew/test/utils_spec.rb  | 14 ++++----------
 2 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/spec_helper.rb b/Library/Homebrew/test/spec_helper.rb
index 292c5786a..63ffe63fe 100644
--- a/Library/Homebrew/test/spec_helper.rb
+++ b/Library/Homebrew/test/spec_helper.rb
@@ -33,6 +33,8 @@ RSpec.configure do |config|
     begin
       TEST_DIRECTORIES.each(&:mkpath)
 
+      @__homebrew_failed = Homebrew.failed?
+
       @__files_before_test = Find.find(TEST_TMPDIR).map { |f| f.sub(TEST_TMPDIR, "") }
 
       @__argv = ARGV.dup
@@ -72,6 +74,10 @@ RSpec.configure do |config|
         file leak detected:
         #{diff.map { |f| "  #{f}" }.join("\n")}
       EOS
+
+      Homebrew.failed = @__homebrew_failed
     end
   end
 end
+
+RSpec::Matchers.alias_matcher :have_failed, :be_failed
diff --git a/Library/Homebrew/test/utils_spec.rb b/Library/Homebrew/test/utils_spec.rb
index de6b287d2..040ad630b 100644
--- a/Library/Homebrew/test/utils_spec.rb
+++ b/Library/Homebrew/test/utils_spec.rb
@@ -1,7 +1,5 @@
 require "utils"
 
-RSpec::Matchers.alias_matcher :have_failed, :be_failed
-
 describe "globally-scoped helper methods" do
   let(:dir) { @dir = Pathname.new(Dir.mktmpdir) }
 
@@ -13,15 +11,11 @@ describe "globally-scoped helper methods" do
 
   describe "#ofail" do
     it "sets Homebrew.failed to true" do
-      begin
-        shutup do
-          ofail "foo"
-        end
+      expect {
+        ofail "foo"
+      }.to output("Error: foo\n").to_stderr
 
-        expect(Homebrew).to have_failed
-      ensure
-        Homebrew.failed = false
-      end
+      expect(Homebrew).to have_failed
     end
   end
 
-- 
cgit v1.2.3


From 0f89f6520ee9054d3e1ba09a3f6e14455375d2ed Mon Sep 17 00:00:00 2001
From: William Woodruff
Date: Thu, 16 Feb 2017 01:33:24 -0500
Subject: keg_relocate: Don't relocate dylib IDs containing metavariables.

---
 Library/Homebrew/extend/os/mac/keg_relocate.rb | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/extend/os/mac/keg_relocate.rb b/Library/Homebrew/extend/os/mac/keg_relocate.rb
index f44a97b31..476e5da4a 100644
--- a/Library/Homebrew/extend/os/mac/keg_relocate.rb
+++ b/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)
-- 
cgit v1.2.3


From 86bec56bf87dcbd923ebd74409685f6fe4a9f38e Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Mon, 20 Feb 2017 13:06:23 +0100
Subject: Make `Formulary` a `module`.

---
 Library/Homebrew/formulary.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/formulary.rb b/Library/Homebrew/formulary.rb
index cf85ba03f..4a65f8704 100644
--- a/Library/Homebrew/formulary.rb
+++ b/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)
-- 
cgit v1.2.3


From 81d105d9a4cbdba1072c3828d173dcaac4bcc2a6 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Thu, 16 Feb 2017 03:15:46 +0100
Subject: Convert String test to spec.

---
 Library/Homebrew/test/string_spec.rb | 49 ++++++++++++++++++++++++++++++++++++
 Library/Homebrew/test/string_test.rb | 40 -----------------------------
 2 files changed, 49 insertions(+), 40 deletions(-)
 create mode 100644 Library/Homebrew/test/string_spec.rb
 delete mode 100644 Library/Homebrew/test/string_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/string_spec.rb b/Library/Homebrew/test/string_spec.rb
new file mode 100644
index 000000000..d1b820b66
--- /dev/null
+++ b/Library/Homebrew/test/string_spec.rb
@@ -0,0 +1,49 @@
+require "extend/string"
+
+describe String do
+  describe "#undent" do
+    it "removes leading whitespace, taking the first line as reference" do
+      string = <<-EOS.undent
+        hi
+........my friend over
+          there
+      EOS
+
+      expect(string).to eq("hi\n........my friend over\n  there\n")
+    end
+
+    it "removes nothing if the text is not indented" do
+      string = <<-EOS.undent
+hi
+I'm not indented
+      EOS
+
+      expect(string).to eq("hi\nI'm not indented\n")
+    end
+
+    it "can be nested" do
+      nested_string = <<-EOS.undent
+        goodbye
+      EOS
+
+      string = <<-EOS.undent
+        hello
+        #{nested_string}
+      EOS
+
+      expect(string).to eq("hello\ngoodbye\n\n")
+    end
+  end
+end
+
+describe StringInreplaceExtension do
+  subject { string.extend(described_class) }
+  let(:string) { "foobar" }
+
+  describe "#sub!" do
+    it "adds an error to #errors when no replacement was made" do
+      subject.sub! "not here", "test"
+      expect(subject.errors).to eq(['expected replacement of "not here" with "test"'])
+    end
+  end
+end
diff --git a/Library/Homebrew/test/string_test.rb b/Library/Homebrew/test/string_test.rb
deleted file mode 100644
index 497c4badb..000000000
--- a/Library/Homebrew/test/string_test.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-require "testing_env"
-require "extend/string"
-
-class StringTest < Homebrew::TestCase
-  def test_undent
-    undented = <<-EOS.undent
-    hi
-....my friend over
-    there
-    EOS
-    assert_equal "hi\n....my friend over\nthere\n", undented
-  end
-
-  def test_undent_not_indented
-    undented = <<-EOS.undent
-hi
-I'm not indented
-    EOS
-    assert_equal "hi\nI'm not indented\n", undented
-  end
-
-  def test_undent_nested
-    nest = <<-EOS.undent
-      goodbye
-    EOS
-
-    undented = <<-EOS.undent
-      hello
-      #{nest}
-    EOS
-
-    assert_equal "hello\ngoodbye\n\n", undented
-  end
-
-  def test_inreplace_sub_failure
-    s = "foobar".extend StringInreplaceExtension
-    s.sub! "not here", "test"
-    assert_equal ['expected replacement of "not here" with "test"'], s.errors
-  end
-end
-- 
cgit v1.2.3


From 14ef15f591795c517b7771c5eb01863b2b577a46 Mon Sep 17 00:00:00 2001
From: ilovezfs
Date: Fri, 30 Sep 2016 03:22:09 -0700
Subject: keg: create symlinks in opt for formula aliases

---
 Library/Homebrew/keg.rb | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/keg.rb b/Library/Homebrew/keg.rb
index 17ff3bcef..bebc3c887 100644
--- a/Library/Homebrew/keg.rb
+++ b/Library/Homebrew/keg.rb
@@ -239,6 +239,11 @@ class Keg
 
   def remove_opt_record
     opt_record.unlink
+    unless aliases.empty?
+      aliases.each do |a|
+        (opt_record.parent/a).unlink
+      end
+    end
     opt_record.parent.rmdir_if_possible
   end
 
@@ -461,9 +466,25 @@ class Keg
     @oldname_opt_record = nil
   end
 
+  def aliases
+    formula_name = rack.basename.to_s
+    aliases_path = Formula[formula_name].tap.path/"Aliases"
+    result = aliases_path.children.select do |c|
+      c.symlink? && c.readlink.basename(".rb").to_s == formula_name
+    end
+    result.map(&:basename).map(&:to_s)
+  end
+
   def optlink(mode = OpenStruct.new)
     opt_record.delete if opt_record.symlink? || opt_record.exist?
     make_relative_symlink(opt_record, path, mode)
+    unless aliases.empty?
+      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, opt_record, mode)
+      end
+    end
 
     return unless oldname_opt_record
     oldname_opt_record.delete
-- 
cgit v1.2.3


From 4c922a089bf2bb8ff379291c90d46b91978dbbb4 Mon Sep 17 00:00:00 2001
From: ilovezfs
Date: Mon, 3 Oct 2016 02:41:17 -0700
Subject: remove unless empty since each is no-op for empty

---
 Library/Homebrew/keg.rb | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/keg.rb b/Library/Homebrew/keg.rb
index bebc3c887..06ac68310 100644
--- a/Library/Homebrew/keg.rb
+++ b/Library/Homebrew/keg.rb
@@ -239,10 +239,8 @@ class Keg
 
   def remove_opt_record
     opt_record.unlink
-    unless aliases.empty?
-      aliases.each do |a|
-        (opt_record.parent/a).unlink
-      end
+    aliases.each do |a|
+      (opt_record.parent/a).unlink
     end
     opt_record.parent.rmdir_if_possible
   end
@@ -478,12 +476,10 @@ class Keg
   def optlink(mode = OpenStruct.new)
     opt_record.delete if opt_record.symlink? || opt_record.exist?
     make_relative_symlink(opt_record, path, mode)
-    unless aliases.empty?
-      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, opt_record, mode)
-      end
+    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, opt_record, mode)
     end
 
     return unless oldname_opt_record
-- 
cgit v1.2.3


From 63295fd81af2b3fa5dc8e933f904b6959727f62e Mon Sep 17 00:00:00 2001
From: ilovezfs
Date: Mon, 3 Oct 2016 02:42:33 -0700
Subject: have opt alias symlink point into the Cellar

in case people expect to be able to find the prefix by only resolving
the symlink once (e.g., if they're using readlink not realpath)
---
 Library/Homebrew/keg.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/keg.rb b/Library/Homebrew/keg.rb
index 06ac68310..dfbf0ad98 100644
--- a/Library/Homebrew/keg.rb
+++ b/Library/Homebrew/keg.rb
@@ -479,7 +479,7 @@ class Keg
     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, opt_record, mode)
+      make_relative_symlink(alias_opt_record, path, mode)
     end
 
     return unless oldname_opt_record
-- 
cgit v1.2.3


From dfa2c247e0dbdbf506f5175a1c839bfd09caecd9 Mon Sep 17 00:00:00 2001
From: Mike McQuaid
Date: Mon, 20 Feb 2017 14:23:01 +0000
Subject: keg: simplify code, handle exceptions.

---
 Library/Homebrew/keg.rb | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/keg.rb b/Library/Homebrew/keg.rb
index dfbf0ad98..b31997d5a 100644
--- a/Library/Homebrew/keg.rb
+++ b/Library/Homebrew/keg.rb
@@ -239,9 +239,7 @@ class Keg
 
   def remove_opt_record
     opt_record.unlink
-    aliases.each do |a|
-      (opt_record.parent/a).unlink
-    end
+    aliases.each { |a| (opt_record.parent/a).unlink }
     opt_record.parent.rmdir_if_possible
   end
 
@@ -465,12 +463,9 @@ class Keg
   end
 
   def aliases
-    formula_name = rack.basename.to_s
-    aliases_path = Formula[formula_name].tap.path/"Aliases"
-    result = aliases_path.children.select do |c|
-      c.symlink? && c.readlink.basename(".rb").to_s == formula_name
-    end
-    result.map(&:basename).map(&:to_s)
+    Formula[rack.basename.to_s].aliases
+  rescue FormulaUnavailableError
+    []
   end
 
   def optlink(mode = OpenStruct.new)
-- 
cgit v1.2.3


From 81a760921320b6508458d6cdbe4c73b3e01b14b3 Mon Sep 17 00:00:00 2001
From: Zhiming Wang
Date: Sat, 18 Feb 2017 10:16:59 -0500
Subject: bump-formula-pr: improve duplicate detection

Reduce the chance of false flagging by making sure that the existing pr
surfaced by GitHub.issues_for_formula actually contains the exact formula name
in its title.
---
 Library/Homebrew/dev-cmd/bump-formula-pr.rb | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/dev-cmd/bump-formula-pr.rb b/Library/Homebrew/dev-cmd/bump-formula-pr.rb
index ea2daf1c4..bfe9c7776 100644
--- a/Library/Homebrew/dev-cmd/bump-formula-pr.rb
+++ b/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
-- 
cgit v1.2.3


From c667a43b9790be9887bf3f175d9e6ab3dad80e1a Mon Sep 17 00:00:00 2001
From: ilovezfs
Date: Mon, 20 Feb 2017 07:51:04 -0800
Subject: audit: fix insecure mirror check when stdout is empty

---
 Library/Homebrew/dev-cmd/audit.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/dev-cmd/audit.rb b/Library/Homebrew/dev-cmd/audit.rb
index 5ed363f7c..9ffef0f99 100644
--- a/Library/Homebrew/dev-cmd/audit.rb
+++ b/Library/Homebrew/dev-cmd/audit.rb
@@ -1499,7 +1499,7 @@ class ResourceAuditor
     secure_url = url.sub "http", "https"
     secure_details = get_content_details(secure_url)
 
-    return if !details[:status].start_with?("2") || !secure_details[:status].start_with?("2")
+    return if details[:status].nil? || secure_details[:status].nil? || !details[:status].start_with?("2") || !secure_details[:status].start_with?("2")
 
     etag_match = details[:etag] && details[:etag] == secure_details[:etag]
     content_length_match = details[:content_length] && details[:content_length] == secure_details[:content_length]
-- 
cgit v1.2.3


From 8e0940cc2f79def7f19c01dc2a9429cf624f0c6e Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Thu, 16 Feb 2017 02:47:44 +0100
Subject: Convert Formulary test to spec.

---
 Library/Homebrew/test/formulary_spec.rb | 219 ++++++++++++++++++++++++++++++++
 Library/Homebrew/test/formulary_test.rb | 189 ---------------------------
 2 files changed, 219 insertions(+), 189 deletions(-)
 create mode 100644 Library/Homebrew/test/formulary_spec.rb
 delete mode 100644 Library/Homebrew/test/formulary_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/formulary_spec.rb b/Library/Homebrew/test/formulary_spec.rb
new file mode 100644
index 000000000..8e9d23589
--- /dev/null
+++ b/Library/Homebrew/test/formulary_spec.rb
@@ -0,0 +1,219 @@
+require "formula"
+require "formula_installer"
+require "utils/bottles"
+
+describe Formulary do
+  let(:formula_name) { "testball_bottle" }
+  let(:formula_path) { CoreTap.new.formula_dir/"#{formula_name}.rb" }
+  let(:formula_content) do
+    <<-EOS.undent
+      class #{subject.class_s(formula_name)} < Formula
+        url "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
+        sha256 TESTBALL_SHA256
+
+        bottle do
+          cellar :any_skip_relocation
+          root_url "file://#{bottle_dir}"
+          sha256 "9abc8ce779067e26556002c4ca6b9427b9874d25f0cafa7028e05b5c5c410cb4" => :#{Utils::Bottles.tag}
+        end
+
+        def install
+          prefix.install "bin"
+          prefix.install "libexec"
+        end
+      end
+    EOS
+  end
+  let(:bottle_dir) { Pathname.new("#{TEST_FIXTURE_DIR}/bottles") }
+  let(:bottle) { bottle_dir/"testball_bottle-0.1.#{Utils::Bottles.tag}.bottle.tar.gz" }
+
+  describe "::class_s" do
+    it "replaces '+' with 'x'" do
+      expect(subject.class_s("foo++")).to eq("Fooxx")
+    end
+
+    it "converts a string to PascalCase" do
+      expect(subject.class_s("shell.fm")).to eq("ShellFm")
+      expect(subject.class_s("s-lang")).to eq("SLang")
+      expect(subject.class_s("pkg-config")).to eq("PkgConfig")
+      expect(subject.class_s("foo_bar")).to eq("FooBar")
+    end
+
+    it "replaces '@' with 'AT'" do
+      expect(subject.class_s("openssl@1.1")).to eq("OpensslAT11")
+    end
+  end
+
+  describe "::factory" do
+    before(:each) do
+      formula_path.write formula_content
+    end
+
+    it "returns a Formula" do
+      expect(subject.factory(formula_name)).to be_kind_of(Formula)
+    end
+
+    it "returns a Formula when given a fully qualified name" do
+      expect(subject.factory("homebrew/core/#{formula_name}")).to be_kind_of(Formula)
+    end
+
+    it "raises an error if the Formula cannot be found" do
+      expect {
+        subject.factory("not_existed_formula")
+      }.to raise_error(FormulaUnavailableError)
+    end
+
+    context "if the Formula has the wrong class" do
+      let(:formula_name) { "giraffe" }
+      let(:formula_content) do
+        <<-EOS.undent
+          class Wrong#{subject.class_s(formula_name)} < Formula
+          end
+        EOS
+      end
+
+      it "raises an error" do
+        expect {
+          subject.factory(formula_name)
+        }.to raise_error(FormulaClassUnavailableError)
+      end
+    end
+
+    it "returns a Formula when given a path" do
+      expect(subject.factory(formula_path)).to be_kind_of(Formula)
+    end
+
+    it "returns a Formula when given a URL" do
+      formula = shutup do
+        subject.factory("file://#{formula_path}")
+      end
+
+      expect(formula).to be_kind_of(Formula)
+    end
+
+    it "returns a Formula when given a bottle" do
+      formula = subject.factory(bottle)
+      expect(formula).to be_kind_of(Formula)
+      expect(formula.local_bottle_path).to eq(bottle.realpath)
+    end
+
+    it "returns a Formula when given an alias" do
+      alias_dir = CoreTap.instance.alias_dir
+      alias_dir.mkpath
+      alias_path = alias_dir/"foo"
+      FileUtils.ln_s formula_path, alias_path
+      result = subject.factory("foo")
+      expect(result).to be_kind_of(Formula)
+      expect(result.alias_path).to eq(alias_path.to_s)
+    end
+
+    context "with installed Formula" do
+      let(:formula) { subject.factory(formula_path) }
+      let(:installer) { FormulaInstaller.new(formula) }
+
+      it "returns a Formula when given a rack" do
+        shutup do
+          installer.install
+        end
+
+        f = subject.from_rack(formula.rack)
+        expect(f).to be_kind_of(Formula)
+        expect(f.build).to be_kind_of(Tab)
+      end
+
+      it "returns a Formula when given a Keg" do
+        shutup do
+          installer.install
+        end
+
+        keg = Keg.new(formula.prefix)
+        f = subject.from_keg(keg)
+        expect(f).to be_kind_of(Formula)
+        expect(f.build).to be_kind_of(Tab)
+      end
+    end
+
+    context "from Tap" do
+      let(:tap) { Tap.new("homebrew", "foo") }
+      let(:formula_path) { tap.path/"#{formula_name}.rb" }
+
+      it "returns a Formula when given a name" do
+        expect(subject.factory(formula_name)).to be_kind_of(Formula)
+      end
+
+      it "returns a Formula from an Alias path" do
+        alias_dir = tap.path/"Aliases"
+        alias_dir.mkpath
+        FileUtils.ln_s formula_path, alias_dir/"bar"
+        expect(subject.factory("bar")).to be_kind_of(Formula)
+      end
+
+      it "raises an error when the Formula cannot be found" do
+        expect {
+          subject.factory("#{tap}/not_existed_formula")
+        }.to raise_error(TapFormulaUnavailableError)
+      end
+
+      it "returns a Formula when given a fully qualified name" do
+        expect(subject.factory("#{tap}/#{formula_name}")).to be_kind_of(Formula)
+      end
+
+      it "raises an error if a Formula is in multiple Taps" do
+        begin
+          another_tap = Tap.new("homebrew", "bar")
+          (another_tap.path/"#{formula_name}.rb").write formula_content
+          expect {
+            subject.factory(formula_name)
+          }.to raise_error(TapFormulaAmbiguityError)
+        ensure
+          another_tap.path.rmtree
+        end
+      end
+    end
+  end
+
+  specify "::from_contents" do
+    expect(subject.from_contents(formula_name, formula_path, formula_content)).to be_kind_of(Formula)
+  end
+
+  specify "::to_rack" do
+    expect(subject.to_rack(formula_name)).to eq(HOMEBREW_CELLAR/formula_name)
+
+    (HOMEBREW_CELLAR/formula_name).mkpath
+    expect(subject.to_rack(formula_name)).to eq(HOMEBREW_CELLAR/formula_name)
+
+    expect {
+      subject.to_rack("a/b/#{formula_name}")
+    }.to raise_error(TapFormulaUnavailableError)
+  end
+
+  describe "::find_with_priority" do
+    let(:core_path) { CoreTap.new.formula_dir/"#{formula_name}.rb" }
+    let(:tap) { Tap.new("homebrew", "foo") }
+    let(:tap_path) { tap.path/"#{formula_name}.rb" }
+
+    before(:each) do
+      core_path.write formula_content
+      tap_path.write formula_content
+    end
+
+    it "prioritizes core Formulae" do
+      formula = subject.find_with_priority(formula_name)
+      expect(formula).to be_kind_of(Formula)
+      expect(formula.path).to eq(core_path)
+    end
+
+    it "prioritizes Formulae from pinned Taps" do
+      begin
+        tap.pin
+        formula = shutup do
+          subject.find_with_priority(formula_name)
+        end
+        expect(formula).to be_kind_of(Formula)
+        expect(formula.path).to eq(tap_path.realpath)
+      ensure
+        tap.pinned_symlink_path.parent.parent.rmtree
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/formulary_test.rb b/Library/Homebrew/test/formulary_test.rb
deleted file mode 100644
index ea7ecf8d0..000000000
--- a/Library/Homebrew/test/formulary_test.rb
+++ /dev/null
@@ -1,189 +0,0 @@
-require "testing_env"
-require "formula"
-require "formula_installer"
-require "utils/bottles"
-
-class FormularyTest < Homebrew::TestCase
-  def test_class_naming
-    assert_equal "ShellFm", Formulary.class_s("shell.fm")
-    assert_equal "Fooxx", Formulary.class_s("foo++")
-    assert_equal "SLang", Formulary.class_s("s-lang")
-    assert_equal "PkgConfig", Formulary.class_s("pkg-config")
-    assert_equal "FooBar", Formulary.class_s("foo_bar")
-    assert_equal "OpensslAT11", Formulary.class_s("openssl@1.1")
-  end
-end
-
-class FormularyFactoryTest < Homebrew::TestCase
-  def setup
-    super
-    @name = "testball_bottle"
-    @path = CoreTap.new.formula_dir/"#{@name}.rb"
-    @bottle_dir = Pathname.new("#{TEST_FIXTURE_DIR}/bottles")
-    @bottle = @bottle_dir/"testball_bottle-0.1.#{Utils::Bottles.tag}.bottle.tar.gz"
-    @path.write <<-EOS.undent
-      class #{Formulary.class_s(@name)} < Formula
-        url "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
-        sha256 TESTBALL_SHA256
-
-        bottle do
-          cellar :any_skip_relocation
-          root_url "file://#{@bottle_dir}"
-          sha256 "9abc8ce779067e26556002c4ca6b9427b9874d25f0cafa7028e05b5c5c410cb4" => :#{Utils::Bottles.tag}
-        end
-
-        def install
-          prefix.install "bin"
-          prefix.install "libexec"
-        end
-      end
-    EOS
-  end
-
-  def test_factory
-    assert_kind_of Formula, Formulary.factory(@name)
-  end
-
-  def test_factory_with_fully_qualified_name
-    assert_kind_of Formula, Formulary.factory("homebrew/core/#{@name}")
-  end
-
-  def test_formula_unavailable_error
-    assert_raises(FormulaUnavailableError) { Formulary.factory("not_existed_formula") }
-  end
-
-  def test_formula_class_unavailable_error
-    name = "giraffe"
-    path = CoreTap.new.formula_dir/"#{name}.rb"
-    path.write "class Wrong#{Formulary.class_s(name)} < Formula\nend\n"
-
-    assert_raises(FormulaClassUnavailableError) { Formulary.factory(name) }
-  end
-
-  def test_factory_from_path
-    assert_kind_of Formula, Formulary.factory(@path)
-  end
-
-  def test_factory_from_url
-    formula = shutup { Formulary.factory("file://#{@path}") }
-    assert_kind_of Formula, formula
-  ensure
-    formula.path.unlink
-  end
-
-  def test_factory_from_bottle
-    formula = Formulary.factory(@bottle)
-    assert_kind_of Formula, formula
-    assert_equal @bottle.realpath, formula.local_bottle_path
-  end
-
-  def test_factory_from_alias
-    alias_dir = CoreTap.instance.alias_dir
-    alias_dir.mkpath
-    alias_path = alias_dir/"foo"
-    FileUtils.ln_s @path, alias_path
-    result = Formulary.factory("foo")
-    assert_kind_of Formula, result
-    assert_equal alias_path.to_s, result.alias_path
-  end
-
-  def test_factory_from_rack_and_from_keg
-    formula = Formulary.factory(@path)
-    installer = FormulaInstaller.new(formula)
-    shutup { installer.install }
-    keg = Keg.new(formula.prefix)
-    f = Formulary.from_rack(formula.rack)
-    assert_kind_of Formula, f
-    assert_kind_of Tab, f.build
-    f = Formulary.from_keg(keg)
-    assert_kind_of Formula, f
-    assert_kind_of Tab, f.build
-  ensure
-    keg.unlink
-  end
-
-  def test_load_from_contents
-    assert_kind_of Formula, Formulary.from_contents(@name, @path, @path.read)
-  end
-
-  def test_to_rack
-    assert_equal HOMEBREW_CELLAR/@name, Formulary.to_rack(@name)
-    (HOMEBREW_CELLAR/@name).mkpath
-    assert_equal HOMEBREW_CELLAR/@name, Formulary.to_rack(@name)
-    assert_raises(TapFormulaUnavailableError) { Formulary.to_rack("a/b/#{@name}") }
-  end
-end
-
-class FormularyTapFactoryTest < Homebrew::TestCase
-  def setup
-    super
-    @name = "foo"
-    @tap = Tap.new "homebrew", "foo"
-    @path = @tap.path/"#{@name}.rb"
-    @code = <<-EOS.undent
-      class #{Formulary.class_s(@name)} < Formula
-        url "foo-1.0"
-      end
-    EOS
-    @path.write @code
-  end
-
-  def test_factory_tap_formula
-    assert_kind_of Formula, Formulary.factory(@name)
-  end
-
-  def test_factory_tap_alias
-    alias_dir = @tap.path/"Aliases"
-    alias_dir.mkpath
-    FileUtils.ln_s @path, alias_dir/"bar"
-    assert_kind_of Formula, Formulary.factory("bar")
-  end
-
-  def test_tap_formula_unavailable_error
-    assert_raises(TapFormulaUnavailableError) { Formulary.factory("#{@tap}/not_existed_formula") }
-  end
-
-  def test_factory_tap_formula_with_fully_qualified_name
-    assert_kind_of Formula, Formulary.factory("#{@tap}/#{@name}")
-  end
-
-  def test_factory_ambiguity_tap_formulae
-    another_tap = Tap.new "homebrew", "bar"
-    (another_tap.path/"#{@name}.rb").write @code
-    assert_raises(TapFormulaAmbiguityError) { Formulary.factory(@name) }
-  ensure
-    another_tap.path.rmtree
-  end
-end
-
-class FormularyTapPriorityTest < Homebrew::TestCase
-  def setup
-    super
-    @name = "foo"
-    @core_path = CoreTap.new.formula_dir/"#{@name}.rb"
-    @tap = Tap.new "homebrew", "foo"
-    @tap_path = @tap.path/"#{@name}.rb"
-    code = <<-EOS.undent
-      class #{Formulary.class_s(@name)} < Formula
-        url "foo-1.0"
-      end
-    EOS
-    @core_path.write code
-    @tap_path.write code
-  end
-
-  def test_find_with_priority_core_formula
-    formula = Formulary.find_with_priority(@name)
-    assert_kind_of Formula, formula
-    assert_equal @core_path, formula.path
-  end
-
-  def test_find_with_priority_tap_formula
-    @tap.pin
-    formula = shutup { Formulary.find_with_priority(@name) }
-    assert_kind_of Formula, formula
-    assert_equal @tap_path.realpath, formula.path
-  ensure
-    @tap.pinned_symlink_path.parent.parent.rmtree
-  end
-end
-- 
cgit v1.2.3


From 68a2471916bfbe1a4491e92c097f93c38cdaeecc Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Mon, 20 Feb 2017 22:24:44 +0100
Subject: Use `alias_matcher` for `fail_with`.

---
 Library/Homebrew/test/compiler_failure_spec.rb | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/compiler_failure_spec.rb b/Library/Homebrew/test/compiler_failure_spec.rb
index 81e464a87..b4fab0b27 100644
--- a/Library/Homebrew/test/compiler_failure_spec.rb
+++ b/Library/Homebrew/test/compiler_failure_spec.rb
@@ -1,12 +1,8 @@
 require "compilers"
 
-describe CompilerFailure do
-  matcher :fail_with do |expected|
-    match do |actual|
-      actual.fails_with?(expected)
-    end
-  end
+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)
-- 
cgit v1.2.3


From 9904eae48a5e4129905b48e5fe61afbb82726a39 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Fri, 17 Feb 2017 19:05:17 +0100
Subject: Convert FormulaPin test to spec.

---
 Library/Homebrew/test/formula_pin_spec.rb | 41 +++++++++++++++++++++++++
 Library/Homebrew/test/formula_pin_test.rb | 51 -------------------------------
 2 files changed, 41 insertions(+), 51 deletions(-)
 create mode 100644 Library/Homebrew/test/formula_pin_spec.rb
 delete mode 100644 Library/Homebrew/test/formula_pin_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/formula_pin_spec.rb b/Library/Homebrew/test/formula_pin_spec.rb
new file mode 100644
index 000000000..909bfbc2b
--- /dev/null
+++ b/Library/Homebrew/test/formula_pin_spec.rb
@@ -0,0 +1,41 @@
+require "formula_pin"
+
+describe FormulaPin do
+  subject { described_class.new(formula) }
+  let(:name) { "double" }
+  let(:formula) { double(Formula, name: name, rack: HOMEBREW_CELLAR/name) }
+
+  before(:each) do
+    formula.rack.mkpath
+
+    allow(formula).to receive(:installed_prefixes) do
+      formula.rack.directory? ? formula.rack.subdirs : []
+    end
+
+    allow(formula).to receive(:installed_kegs) do
+      formula.installed_prefixes.map { |prefix| Keg.new(prefix) }
+    end
+  end
+
+  it "is not pinnable by default" do
+    expect(subject).not_to be_pinnable
+  end
+
+  it "is pinnable if the Keg exists" do
+    (formula.rack/"0.1").mkpath
+    expect(subject).to be_pinnable
+  end
+
+  specify "#pin and #unpin" do
+    (formula.rack/"0.1").mkpath
+
+    subject.pin
+    expect(subject).to be_pinned
+    expect(HOMEBREW_PINNED_KEGS/name).to be_a_directory
+    expect(HOMEBREW_PINNED_KEGS.children.count).to eq(1)
+
+    subject.unpin
+    expect(subject).not_to be_pinned
+    expect(HOMEBREW_PINNED_KEGS).not_to be_a_directory
+  end
+end
diff --git a/Library/Homebrew/test/formula_pin_test.rb b/Library/Homebrew/test/formula_pin_test.rb
deleted file mode 100644
index 7e3c7efa0..000000000
--- a/Library/Homebrew/test/formula_pin_test.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-require "testing_env"
-require "formula_pin"
-
-class FormulaPinTests < Homebrew::TestCase
-  class FormulaDouble
-    def name
-      "double"
-    end
-
-    def rack
-      HOMEBREW_CELLAR/name
-    end
-
-    def installed_prefixes
-      rack.directory? ? rack.subdirs : []
-    end
-
-    def installed_kegs
-      installed_prefixes.map { |d| Keg.new d }
-    end
-  end
-
-  def setup
-    super
-    @f   = FormulaDouble.new
-    @pin = FormulaPin.new(@f)
-    @f.rack.mkpath
-  end
-
-  def test_not_pinnable
-    refute_predicate @pin, :pinnable?
-  end
-
-  def test_pinnable_if_kegs_exist
-    (@f.rack/"0.1").mkpath
-    assert_predicate @pin, :pinnable?
-  end
-
-  def test_unpin
-    (@f.rack/"0.1").mkpath
-    @pin.pin
-
-    assert_predicate @pin, :pinned?
-    assert_equal 1, HOMEBREW_PINNED_KEGS.children.length
-
-    @pin.unpin
-
-    refute_predicate @pin, :pinned?
-    refute_predicate HOMEBREW_PINNED_KEGS, :directory?
-  end
-end
-- 
cgit v1.2.3


From 1ff6846218367fc73736039d668b319acebd8cae Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Sun, 12 Feb 2017 23:03:46 +0100
Subject: Convert StringInreplaceExtension test to spec.

---
 Library/Homebrew/test/inreplace_spec.rb | 251 ++++++++++++++++++++++++++++++++
 Library/Homebrew/test/inreplace_test.rb | 119 ---------------
 2 files changed, 251 insertions(+), 119 deletions(-)
 create mode 100644 Library/Homebrew/test/inreplace_spec.rb
 delete mode 100644 Library/Homebrew/test/inreplace_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/inreplace_spec.rb b/Library/Homebrew/test/inreplace_spec.rb
new file mode 100644
index 000000000..5be44f50d
--- /dev/null
+++ b/Library/Homebrew/test/inreplace_spec.rb
@@ -0,0 +1,251 @@
+require "extend/string"
+require "tempfile"
+require "utils/inreplace"
+
+describe StringInreplaceExtension do
+  subject { string.extend(described_class) }
+
+  describe "#change_make_var!" do
+    context "flag" do
+      context "with spaces" do
+        let(:string) do
+          <<-EOS.undent
+            OTHER=def
+            FLAG = abc
+            FLAG2=abc
+          EOS
+        end
+
+        it "is successfully replaced" do
+          subject.change_make_var! "FLAG", "def"
+          expect(subject).to eq <<-EOS.undent
+            OTHER=def
+            FLAG=def
+            FLAG2=abc
+          EOS
+        end
+
+        it "is successfully appended" do
+          subject.change_make_var! "FLAG", "\\1 def"
+          expect(subject).to eq <<-EOS.undent
+            OTHER=def
+            FLAG=abc def
+            FLAG2=abc
+          EOS
+        end
+      end
+
+      context "with tabs" do
+        let(:string) do
+          <<-EOS.undent
+            CFLAGS\t=\t-Wall -O2
+            LDFLAGS\t=\t-lcrypto -lssl
+          EOS
+        end
+
+        it "is successfully replaced" do
+          subject.change_make_var! "CFLAGS", "-O3"
+          expect(subject).to eq <<-EOS.undent
+            CFLAGS=-O3
+            LDFLAGS\t=\t-lcrypto -lssl
+          EOS
+        end
+      end
+    end
+
+    context "empty flag between other flags" do
+      let(:string) do
+        <<-EOS.undent
+          OTHER=def
+          FLAG =
+          FLAG2=abc
+        EOS
+      end
+
+      it "is successfully replaced" do
+        subject.change_make_var! "FLAG", "def"
+        expect(subject).to eq <<-EOS.undent
+          OTHER=def
+          FLAG=def
+          FLAG2=abc
+        EOS
+      end
+    end
+
+    context "empty flag" do
+      let(:string) do
+        <<-EOS.undent
+          FLAG =
+          mv file_a file_b
+        EOS
+      end
+
+      it "is successfully replaced" do
+        subject.change_make_var! "FLAG", "def"
+        expect(subject).to eq <<-EOS.undent
+          FLAG=def
+          mv file_a file_b
+        EOS
+      end
+    end
+
+    context "shell-style variable" do
+      let(:string) do
+        <<-EOS.undent
+          OTHER=def
+          FLAG=abc
+          FLAG2=abc
+        EOS
+      end
+
+      it "is successfully replaced" do
+        subject.change_make_var! "FLAG", "def"
+        expect(subject).to eq <<-EOS.undent
+          OTHER=def
+          FLAG=def
+          FLAG2=abc
+        EOS
+      end
+    end
+  end
+
+  describe "#remove_make_var!" do
+    context "flag" do
+      context "with spaces" do
+        let(:string) do
+          <<-EOS.undent
+            OTHER=def
+            FLAG = abc
+            FLAG2 = def
+          EOS
+        end
+
+        it "is successfully removed" do
+          subject.remove_make_var! "FLAG"
+          expect(subject).to eq <<-EOS.undent
+            OTHER=def
+            FLAG2 = def
+          EOS
+        end
+      end
+
+      context "with tabs" do
+        let(:string) do
+          <<-EOS.undent
+            CFLAGS\t=\t-Wall -O2
+            LDFLAGS\t=\t-lcrypto -lssl
+          EOS
+        end
+
+        it "is successfully removed" do
+          subject.remove_make_var! "LDFLAGS"
+          expect(subject).to eq <<-EOS.undent
+            CFLAGS\t=\t-Wall -O2
+          EOS
+        end
+      end
+    end
+
+    context "multiple flags" do
+      let(:string) do
+        <<-EOS.undent
+          OTHER=def
+          FLAG = abc
+          FLAG2 = def
+          OTHER2=def
+        EOS
+      end
+
+      specify "are be successfully removed" do
+        subject.remove_make_var! ["FLAG", "FLAG2"]
+        expect(subject).to eq <<-EOS.undent
+          OTHER=def
+          OTHER2=def
+        EOS
+      end
+    end
+  end
+
+  describe "#get_make_var" do
+    context "with spaces" do
+      let(:string) do
+        <<-EOS.undent
+          CFLAGS = -Wall -O2
+          LDFLAGS = -lcrypto -lssl
+        EOS
+      end
+
+      it "extracts the value for a given variable" do
+        expect(subject.get_make_var("CFLAGS")).to eq("-Wall -O2")
+      end
+    end
+
+    context "with tabs" do
+      let(:string) do
+        <<-EOS.undent
+          CFLAGS\t=\t-Wall -O2
+          LDFLAGS\t=\t-lcrypto -lssl
+        EOS
+      end
+
+      it "extracts the value for a given variable" do
+        expect(subject.get_make_var("CFLAGS")).to eq("-Wall -O2")
+      end
+    end
+  end
+
+  describe "#sub!" do
+    let(:string) { "foo" }
+
+    it "replaces the first occurence" do
+      subject.sub!("o", "e")
+      expect(subject).to eq("feo")
+    end
+  end
+
+  describe "#gsub!" do
+    let(:string) { "foo" }
+
+    it "replaces the all occurences" do
+      subject.gsub!("o", "e") # rubocop:disable Performance/StringReplacement
+      expect(subject).to eq("fee")
+    end
+  end
+end
+
+describe Utils::Inreplace do
+  let(:file) { Tempfile.new("test") }
+
+  before(:each) do
+    file.write <<-EOS.undent
+      a
+      b
+      c
+    EOS
+  end
+
+  after(:each) { file.unlink }
+
+  it "raises error if there is nothing to replace" do
+    expect {
+      described_class.inreplace file.path, "d", "f"
+    }.to raise_error(Utils::InreplaceError)
+  end
+
+  it "raises error if there is nothing to replace" do
+    expect {
+      described_class.inreplace(file.path) do |s|
+        s.gsub!("d", "f") # rubocop:disable Performance/StringReplacement
+      end
+    }.to raise_error(Utils::InreplaceError)
+  end
+
+  it "raises error if there is nothing to replace" do
+    expect {
+      described_class.inreplace(file.path) do |s|
+        s.change_make_var! "VAR", "value"
+        s.remove_make_var! "VAR2"
+      end
+    }.to raise_error(Utils::InreplaceError)
+  end
+end
diff --git a/Library/Homebrew/test/inreplace_test.rb b/Library/Homebrew/test/inreplace_test.rb
deleted file mode 100644
index 0e62f9d3f..000000000
--- a/Library/Homebrew/test/inreplace_test.rb
+++ /dev/null
@@ -1,119 +0,0 @@
-require "testing_env"
-require "extend/string"
-require "utils/inreplace"
-
-class InreplaceTest < Homebrew::TestCase
-  def test_change_make_var
-    # Replace flag
-    s1 = "OTHER=def\nFLAG = abc\nFLAG2=abc"
-    s1.extend(StringInreplaceExtension)
-    s1.change_make_var! "FLAG", "def"
-    assert_equal "OTHER=def\nFLAG=def\nFLAG2=abc", s1
-  end
-
-  def test_change_make_var_empty
-    # Replace empty flag
-    s1 = "OTHER=def\nFLAG = \nFLAG2=abc"
-    s1.extend(StringInreplaceExtension)
-    s1.change_make_var! "FLAG", "def"
-    assert_equal "OTHER=def\nFLAG=def\nFLAG2=abc", s1
-  end
-
-  def test_change_make_var_empty_2
-    # Replace empty flag
-    s1 = "FLAG = \nmv file_a file_b"
-    s1.extend(StringInreplaceExtension)
-    s1.change_make_var! "FLAG", "def"
-    assert_equal "FLAG=def\nmv file_a file_b", s1
-  end
-
-  def test_change_make_var_append
-    # Append to flag
-    s1 = "OTHER=def\nFLAG = abc\nFLAG2=abc"
-    s1.extend(StringInreplaceExtension)
-    s1.change_make_var! "FLAG", "\\1 def"
-    assert_equal "OTHER=def\nFLAG=abc def\nFLAG2=abc", s1
-  end
-
-  def test_change_make_var_shell_style
-    # Shell variables have no spaces around =
-    s1 = "OTHER=def\nFLAG=abc\nFLAG2=abc"
-    s1.extend(StringInreplaceExtension)
-    s1.change_make_var! "FLAG", "def"
-    assert_equal "OTHER=def\nFLAG=def\nFLAG2=abc", s1
-  end
-
-  def test_remove_make_var
-    # Replace flag
-    s1 = "OTHER=def\nFLAG = abc\nFLAG2 = def"
-    s1.extend(StringInreplaceExtension)
-    s1.remove_make_var! "FLAG"
-    assert_equal "OTHER=def\nFLAG2 = def", s1
-  end
-
-  def test_remove_make_vars
-    # Replace flag
-    s1 = "OTHER=def\nFLAG = abc\nFLAG2 = def\nOTHER2=def"
-    s1.extend(StringInreplaceExtension)
-    s1.remove_make_var! ["FLAG", "FLAG2"]
-    assert_equal "OTHER=def\nOTHER2=def", s1
-  end
-
-  def test_get_make_var
-    s = "CFLAGS = -Wall -O2\nLDFLAGS = -lcrypto -lssl"
-    s.extend(StringInreplaceExtension)
-    assert_equal "-Wall -O2", s.get_make_var("CFLAGS")
-  end
-
-  def test_change_make_var_with_tabs
-    s = "CFLAGS\t=\t-Wall -O2\nLDFLAGS\t=\t-lcrypto -lssl"
-    s.extend(StringInreplaceExtension)
-
-    assert_equal "-Wall -O2", s.get_make_var("CFLAGS")
-
-    s.change_make_var! "CFLAGS", "-O3"
-    assert_equal "CFLAGS=-O3\nLDFLAGS\t=\t-lcrypto -lssl", s
-
-    s.remove_make_var! "LDFLAGS"
-    assert_equal "CFLAGS=-O3\n", s
-  end
-
-  def test_sub_gsub
-    s = "foo"
-    s.extend(StringInreplaceExtension)
-
-    s.sub!("f", "b")
-    assert_equal "boo", s
-
-    # Under current context, we are testing `String#gsub!`, so let's disable rubocop temporarily.
-    s.gsub!("o", "e") # rubocop:disable Performance/StringReplacement
-    assert_equal "bee", s
-  end
-
-  def test_inreplace_errors
-    require "tempfile"
-    extend(Utils::Inreplace)
-
-    file = Tempfile.new("test")
-
-    file.write "a\nb\nc\n"
-
-    assert_raises(Utils::InreplaceError) do
-      inreplace file.path, "d", "f"
-    end
-
-    assert_raises(Utils::InreplaceError) do
-      # Under current context, we are testing `String#gsub!`, so let's disable rubocop temporarily.
-      inreplace(file.path) { |s| s.gsub!("d", "f") } # rubocop:disable Performance/StringReplacement
-    end
-
-    assert_raises(Utils::InreplaceError) do
-      inreplace(file.path) do |s|
-        s.change_make_var! "VAR", "value"
-        s.remove_make_var! "VAR2"
-      end
-    end
-  ensure
-    file.unlink
-  end
-end
-- 
cgit v1.2.3


From 9c1db3c820f715f62f550ba1e54f16f9b89bc6ed Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 02:50:52 +0100
Subject: Convert JavaRequirement test to spec.

---
 .../Homebrew/test/os/mac/java_requirement_spec.rb  | 34 ++++++++++++++++++++++
 .../Homebrew/test/os/mac/java_requirement_test.rb  | 31 --------------------
 2 files changed, 34 insertions(+), 31 deletions(-)
 create mode 100644 Library/Homebrew/test/os/mac/java_requirement_spec.rb
 delete mode 100644 Library/Homebrew/test/os/mac/java_requirement_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/os/mac/java_requirement_spec.rb b/Library/Homebrew/test/os/mac/java_requirement_spec.rb
new file mode 100644
index 000000000..f6404db92
--- /dev/null
+++ b/Library/Homebrew/test/os/mac/java_requirement_spec.rb
@@ -0,0 +1,34 @@
+require "requirements/java_requirement"
+require "fileutils"
+
+describe JavaRequirement do
+  subject { described_class.new(%w[1.8]) }
+  let(:java_home) { Dir.mktmpdir }
+  let(:java_home_path) { Pathname.new(java_home) }
+
+  before(:each) do
+    FileUtils.mkdir java_home_path/"bin"
+    FileUtils.touch java_home_path/"bin/java"
+    allow(subject).to receive(:preferred_java).and_return(java_home_path/"bin/java")
+    expect(subject).to be_satisfied
+  end
+
+  after(:each) { java_home_path.rmtree }
+
+  specify "Apple Java environment" do
+    expect(ENV).to receive(:prepend_path)
+    expect(ENV).to receive(:append_to_cflags)
+
+    subject.modify_build_environment
+    expect(ENV["JAVA_HOME"]).to eq(java_home)
+  end
+
+  specify "Oracle Java environment" do
+    FileUtils.mkdir java_home_path/"include"
+    expect(ENV).to receive(:prepend_path)
+    expect(ENV).to receive(:append_to_cflags).twice
+
+    subject.modify_build_environment
+    expect(ENV["JAVA_HOME"]).to eq(java_home)
+  end
+end
diff --git a/Library/Homebrew/test/os/mac/java_requirement_test.rb b/Library/Homebrew/test/os/mac/java_requirement_test.rb
deleted file mode 100644
index 83c1af95c..000000000
--- a/Library/Homebrew/test/os/mac/java_requirement_test.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-require "testing_env"
-require "requirements/java_requirement"
-require "fileutils"
-
-class OSMacJavaRequirementTests < Homebrew::TestCase
-  def setup
-    super
-    @java_req = JavaRequirement.new(%w[1.8])
-    @tmp_java_home = mktmpdir
-    @tmp_pathname = Pathname.new(@tmp_java_home)
-    FileUtils.mkdir @tmp_pathname/"bin"
-    FileUtils.touch @tmp_pathname/"bin/java"
-    @java_req.stubs(:preferred_java).returns(@tmp_pathname/"bin/java")
-    @java_req.satisfied?
-  end
-
-  def test_java_env_apple
-    ENV.expects(:prepend_path)
-    ENV.expects(:append_to_cflags)
-    @java_req.modify_build_environment
-    assert_equal ENV["JAVA_HOME"], @tmp_java_home
-  end
-
-  def test_java_env_oracle
-    FileUtils.mkdir @tmp_pathname/"include"
-    ENV.expects(:prepend_path)
-    ENV.expects(:append_to_cflags).twice
-    @java_req.modify_build_environment
-    assert_equal ENV["JAVA_HOME"], @tmp_java_home
-  end
-end
-- 
cgit v1.2.3


From 1be7852493cee7f7af9b31cef4547aca23bebb0b Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Mon, 20 Feb 2017 23:28:13 +0100
Subject: Convert SoftwareSpec test to spec.

---
 Library/Homebrew/test/software_spec_spec.rb | 184 ++++++++++++++++++++++++++++
 Library/Homebrew/test/software_spec_test.rb | 184 ----------------------------
 2 files changed, 184 insertions(+), 184 deletions(-)
 create mode 100644 Library/Homebrew/test/software_spec_spec.rb
 delete mode 100644 Library/Homebrew/test/software_spec_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/software_spec_spec.rb b/Library/Homebrew/test/software_spec_spec.rb
new file mode 100644
index 000000000..5fd4f598a
--- /dev/null
+++ b/Library/Homebrew/test/software_spec_spec.rb
@@ -0,0 +1,184 @@
+require "software_spec"
+
+RSpec::Matchers.alias_matcher :have_defined_resource, :be_resource_defined
+RSpec::Matchers.alias_matcher :have_defined_option, :be_option_defined
+
+describe SoftwareSpec do
+  let(:owner) { double(name: "some_name", full_name: "some_name", tap: "homebrew/core") }
+
+  describe "#resource" do
+    it "defines a resource" do
+      subject.resource("foo") { url "foo-1.0" }
+      expect(subject).to have_defined_resource("foo")
+    end
+
+    it "sets itself to be the resource's owner" do
+      subject.resource("foo") { url "foo-1.0" }
+      subject.owner = owner
+      subject.resources.each_value do |r|
+        expect(r.owner).to eq(subject)
+      end
+    end
+
+    it "receives the owner's version if it has no own version" do
+      subject.url("foo-42")
+      subject.resource("bar") { url "bar" }
+      subject.owner = owner
+
+      expect(subject.resource("bar").version).to eq("42")
+    end
+
+    it "raises an error when duplicate resources are defined" do
+      subject.resource("foo") { url "foo-1.0" }
+      expect {
+        subject.resource("foo") { url "foo-1.0" }
+      }.to raise_error(DuplicateResourceError)
+    end
+
+    it "raises an error when accessing missing resources" do
+      subject.owner = owner
+      expect {
+        subject.resource("foo")
+      }.to raise_error(ResourceMissingError)
+    end
+  end
+
+  describe "#owner" do
+    it "sets the owner" do
+      subject.owner = owner
+      expect(subject.owner).to eq(owner)
+    end
+
+    it "sets the name" do
+      subject.owner = owner
+      expect(subject.name).to eq(owner.name)
+    end
+  end
+
+  describe "#option" do
+    it "defines an option" do
+      subject.option("foo")
+      expect(subject).to have_defined_option("foo")
+    end
+
+    it "raises an error when it begins with dashes" do
+      expect {
+        subject.option("--foo")
+      }.to raise_error(ArgumentError)
+    end
+
+    it "raises an error when name is empty" do
+      expect {
+        subject.option("")
+      }.to raise_error(ArgumentError)
+    end
+
+    it "special cases the cxx11 option" do
+      subject.option(:cxx11)
+      expect(subject).to have_defined_option("c++11")
+      expect(subject).not_to have_defined_option("cxx11")
+    end
+
+    it "supports options with descriptions" do
+      subject.option("bar", "description")
+      expect(subject.options.first.description).to eq("description")
+    end
+
+    it "defaults to an empty string when no description is given" do
+      subject.option("foo")
+      expect(subject.options.first.description).to eq("")
+    end
+  end
+
+  describe "#deprecated_option" do
+    it "allows specifying deprecated options" do
+      subject.deprecated_option("foo" => "bar")
+      expect(subject.deprecated_options).not_to be_empty
+      expect(subject.deprecated_options.first.old).to eq("foo")
+      expect(subject.deprecated_options.first.current).to eq("bar")
+    end
+
+    it "allows specifying deprecated options as a Hash from an Array/String to an Array/String" do
+      subject.deprecated_option(["foo1", "foo2"] => "bar1", "foo3" => ["bar2", "bar3"])
+      expect(subject.deprecated_options).to include(DeprecatedOption.new("foo1", "bar1"))
+      expect(subject.deprecated_options).to include(DeprecatedOption.new("foo2", "bar1"))
+      expect(subject.deprecated_options).to include(DeprecatedOption.new("foo3", "bar2"))
+      expect(subject.deprecated_options).to include(DeprecatedOption.new("foo3", "bar3"))
+    end
+
+    it "raises an error when empty" do
+      expect {
+        subject.deprecated_option({})
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#depends_on" do
+    it "allows specifying dependencies" do
+      subject.depends_on("foo")
+      expect(subject.deps.first.name).to eq("foo")
+    end
+
+    it "allows specifying optional dependencies" do
+      subject.depends_on "foo" => :optional
+      expect(subject).to have_defined_option("with-foo")
+    end
+
+    it "allows specifying recommended dependencies" do
+      subject.depends_on "bar" => :recommended
+      expect(subject).to have_defined_option("without-bar")
+    end
+  end
+
+  specify "explicit options override defaupt depends_on option description" do
+    subject.option("with-foo", "blah")
+    subject.depends_on("foo" => :optional)
+    expect(subject.options.first.description).to eq("blah")
+  end
+
+  describe "#patch" do
+    it "adds a patch" do
+      subject.patch(:p1, :DATA)
+      expect(subject.patches.count).to eq(1)
+      expect(subject.patches.first.strip).to eq(:p1)
+    end
+  end
+end
+
+describe HeadSoftwareSpec do
+  specify "#version" do
+    expect(subject.version).to eq(Version.create("HEAD"))
+  end
+
+  specify "#verify_download_integrity" do
+    expect(subject.verify_download_integrity(Object.new)).to be nil
+  end
+end
+
+describe BottleSpecification do
+  specify "#sha256" do
+    checksums = {
+      snow_leopard_32: "deadbeef" * 8,
+      snow_leopard: "faceb00c" * 8,
+      lion: "baadf00d" * 8,
+      mountain_lion: "8badf00d" * 8,
+    }
+
+    checksums.each_pair do |cat, digest|
+      subject.sha256(digest => cat)
+    end
+
+    checksums.each_pair do |cat, digest|
+      checksum, = subject.checksum_for(cat)
+      expect(Checksum.new(:sha256, digest)).to eq(checksum)
+    end
+  end
+
+  %w[root_url prefix cellar rebuild].each do |method|
+    specify "##{method}" do
+      object = Object.new
+      subject.public_send(method, object)
+      expect(subject.public_send(method)).to eq(object)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/software_spec_test.rb b/Library/Homebrew/test/software_spec_test.rb
deleted file mode 100644
index 026265a4a..000000000
--- a/Library/Homebrew/test/software_spec_test.rb
+++ /dev/null
@@ -1,184 +0,0 @@
-require "testing_env"
-require "software_spec"
-
-class SoftwareSpecTests < Homebrew::TestCase
-  def setup
-    super
-    @spec = SoftwareSpec.new
-  end
-
-  def test_resource
-    @spec.resource("foo") { url "foo-1.0" }
-    assert @spec.resource_defined?("foo")
-  end
-
-  def test_raises_when_duplicate_resources_are_defined
-    @spec.resource("foo") { url "foo-1.0" }
-    assert_raises(DuplicateResourceError) do
-      @spec.resource("foo") { url "foo-1.0" }
-    end
-  end
-
-  def test_raises_when_accessing_missing_resources
-    @spec.owner = Class.new do
-      def name
-        "test"
-      end
-
-      def full_name
-        "test"
-      end
-
-      def tap
-        "homebrew/core"
-      end
-    end.new
-    assert_raises(ResourceMissingError) { @spec.resource("foo") }
-  end
-
-  def test_set_owner
-    owner = stub name: "some_name",
-                 full_name: "some_name",
-                 tap: "homebrew/core"
-    @spec.owner = owner
-    assert_equal owner, @spec.owner
-  end
-
-  def test_resource_owner
-    @spec.resource("foo") { url "foo-1.0" }
-    @spec.owner = stub name: "some_name",
-                       full_name: "some_name",
-                       tap: "homebrew/core"
-    assert_equal "some_name", @spec.name
-    @spec.resources.each_value { |r| assert_equal @spec, r.owner }
-  end
-
-  def test_resource_without_version_receives_owners_version
-    @spec.url("foo-42")
-    @spec.resource("bar") { url "bar" }
-    @spec.owner = stub name: "some_name",
-                       full_name: "some_name",
-                       tap: "homebrew/core"
-    assert_version_equal "42", @spec.resource("bar").version
-  end
-
-  def test_option
-    @spec.option("foo")
-    assert @spec.option_defined?("foo")
-  end
-
-  def test_option_raises_when_begins_with_dashes
-    assert_raises(ArgumentError) { @spec.option("--foo") }
-  end
-
-  def test_option_raises_when_name_empty
-    assert_raises(ArgumentError) { @spec.option("") }
-  end
-
-  def test_cxx11_option_special_case
-    @spec.option(:cxx11)
-    assert @spec.option_defined?("c++11")
-    refute @spec.option_defined?("cxx11")
-  end
-
-  def test_option_description
-    @spec.option("bar", "description")
-    assert_equal "description", @spec.options.first.description
-  end
-
-  def test_option_description_defaults_to_empty_string
-    @spec.option("foo")
-    assert_equal "", @spec.options.first.description
-  end
-
-  def test_deprecated_option
-    @spec.deprecated_option("foo" => "bar")
-    refute_empty @spec.deprecated_options
-    assert_equal "foo", @spec.deprecated_options.first.old
-    assert_equal "bar", @spec.deprecated_options.first.current
-  end
-
-  def test_deprecated_options
-    @spec.deprecated_option(["foo1", "foo2"] => "bar1", "foo3" => ["bar2", "bar3"])
-    assert_includes @spec.deprecated_options, DeprecatedOption.new("foo1", "bar1")
-    assert_includes @spec.deprecated_options, DeprecatedOption.new("foo2", "bar1")
-    assert_includes @spec.deprecated_options, DeprecatedOption.new("foo3", "bar2")
-    assert_includes @spec.deprecated_options, DeprecatedOption.new("foo3", "bar3")
-  end
-
-  def test_deprecated_option_raises_when_empty
-    assert_raises(ArgumentError) { @spec.deprecated_option({}) }
-  end
-
-  def test_depends_on
-    @spec.depends_on("foo")
-    assert_equal "foo", @spec.deps.first.name
-  end
-
-  def test_dependency_option_integration
-    @spec.depends_on "foo" => :optional
-    @spec.depends_on "bar" => :recommended
-    assert @spec.option_defined?("with-foo")
-    assert @spec.option_defined?("without-bar")
-  end
-
-  def test_explicit_options_override_default_dep_option_description
-    @spec.option("with-foo", "blah")
-    @spec.depends_on("foo" => :optional)
-    assert_equal "blah", @spec.options.first.description
-  end
-
-  def test_patch
-    @spec.patch :p1, :DATA
-    assert_equal 1, @spec.patches.length
-    assert_equal :p1, @spec.patches.first.strip
-  end
-end
-
-class HeadSoftwareSpecTests < Homebrew::TestCase
-  def setup
-    super
-    @spec = HeadSoftwareSpec.new
-  end
-
-  def test_version
-    assert_version_equal "HEAD", @spec.version
-  end
-
-  def test_verify_download_integrity
-    assert_nil @spec.verify_download_integrity(Object.new)
-  end
-end
-
-class BottleSpecificationTests < Homebrew::TestCase
-  def setup
-    super
-    @spec = BottleSpecification.new
-  end
-
-  def test_checksum_setters
-    checksums = {
-      snow_leopard_32: "deadbeef"*8,
-      snow_leopard: "faceb00c"*8,
-      lion: "baadf00d"*8,
-      mountain_lion: "8badf00d"*8,
-    }
-
-    checksums.each_pair do |cat, digest|
-      @spec.sha256(digest => cat)
-    end
-
-    checksums.each_pair do |cat, digest|
-      checksum, = @spec.checksum_for(cat)
-      assert_equal Checksum.new(:sha256, digest), checksum
-    end
-  end
-
-  def test_other_setters
-    double = Object.new
-    %w[root_url prefix cellar rebuild].each do |method|
-      @spec.send(method, double)
-      assert_equal double, @spec.send(method)
-    end
-  end
-end
-- 
cgit v1.2.3


From e0d5afc2375709e217729806016cfd283eb912d5 Mon Sep 17 00:00:00 2001
From: Bob W. Hogg
Date: Mon, 20 Feb 2017 19:19:26 -0800
Subject: java_requirement: Make macOS overrides extend Requirement

This doesn't actually seem to make that much difference,
but it is at least consistent with the main class body and with
the Linux overrides.
---
 Library/Homebrew/extend/os/mac/requirements/java_requirement.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/extend/os/mac/requirements/java_requirement.rb b/Library/Homebrew/extend/os/mac/requirements/java_requirement.rb
index 451e0001b..5f989bb56 100644
--- a/Library/Homebrew/extend/os/mac/requirements/java_requirement.rb
+++ b/Library/Homebrew/extend/os/mac/requirements/java_requirement.rb
@@ -1,4 +1,4 @@
-class JavaRequirement
+class JavaRequirement < Requirement
   cask "java"
 
   env do
-- 
cgit v1.2.3


From 5ec95978104eab9679340e739c3a5fd5786b4722 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 04:52:53 +0100
Subject: Convert OS::Mac::Keg test to spec.

---
 Library/Homebrew/test/os/mac/keg_spec.rb         | 32 +++++++++++
 Library/Homebrew/test/os/mac/keg_test.rb         | 69 ------------------------
 Library/Homebrew/test/spec_helper.rb             |  2 +
 Library/Homebrew/test/support/helper/fixtures.rb | 13 +++++
 4 files changed, 47 insertions(+), 69 deletions(-)
 create mode 100644 Library/Homebrew/test/os/mac/keg_spec.rb
 delete mode 100644 Library/Homebrew/test/os/mac/keg_test.rb
 create mode 100644 Library/Homebrew/test/support/helper/fixtures.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/os/mac/keg_spec.rb b/Library/Homebrew/test/os/mac/keg_spec.rb
new file mode 100644
index 000000000..562c2ba6a
--- /dev/null
+++ b/Library/Homebrew/test/os/mac/keg_spec.rb
@@ -0,0 +1,32 @@
+require "keg"
+
+describe Keg do
+  include FileUtils
+
+  subject { described_class.new(keg_path) }
+
+  describe "#mach_o_files" do
+    let(:keg_path) { HOMEBREW_CELLAR/"a/1.0" }
+
+    before(:each) { (keg_path/"lib").mkpath }
+
+    after(:each) { subject.unlink }
+
+    it "skips hardlinks" do
+      cp dylib_path("i386"), keg_path/"lib/i386.dylib"
+      ln keg_path/"lib/i386.dylib", keg_path/"lib/i386_hardlink.dylib"
+
+      subject.link
+      expect(subject.mach_o_files.count).to eq(1)
+    end
+
+    it "isn't confused by symlinks" do
+      cp dylib_path("i386"), keg_path/"lib/i386.dylib"
+      ln keg_path/"lib/i386.dylib", keg_path/"lib/i386_hardlink.dylib"
+      ln_s keg_path/"lib/i386.dylib", keg_path/"lib/i386_symlink.dylib"
+
+      subject.link
+      expect(subject.mach_o_files.count).to eq(1)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/os/mac/keg_test.rb b/Library/Homebrew/test/os/mac/keg_test.rb
deleted file mode 100644
index d1103415d..000000000
--- a/Library/Homebrew/test/os/mac/keg_test.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-require "testing_env"
-require "keg"
-require "stringio"
-
-class OSMacLinkTests < Homebrew::TestCase
-  include FileUtils
-
-  def setup
-    super
-
-    keg = HOMEBREW_CELLAR.join("foo", "1.0")
-    keg.join("bin").mkpath
-
-    %w[hiworld helloworld goodbye_cruel_world].each do |file|
-      touch keg.join("bin", file)
-    end
-
-    @keg = Keg.new(keg)
-    @dst = HOMEBREW_PREFIX.join("bin", "helloworld")
-    @nonexistent = Pathname.new("/some/nonexistent/path")
-
-    @mode = OpenStruct.new
-
-    @old_stdout = $stdout
-    $stdout = StringIO.new
-
-    mkpath HOMEBREW_PREFIX/"bin"
-    mkpath HOMEBREW_PREFIX/"lib"
-  end
-
-  def teardown
-    @keg.unlink
-
-    $stdout = @old_stdout
-
-    rmtree HOMEBREW_PREFIX/"lib"
-
-    super
-  end
-
-  def test_mach_o_files_skips_hardlinks
-    a = HOMEBREW_CELLAR/"a/1.0"
-    (a/"lib").mkpath
-    FileUtils.cp dylib_path("i386"), a/"lib/i386.dylib"
-    FileUtils.ln a/"lib/i386.dylib", a/"lib/i386_link.dylib"
-
-    keg = Keg.new(a)
-    keg.link
-
-    assert_equal 1, keg.mach_o_files.size
-  ensure
-    keg.unlink
-  end
-
-  def test_mach_o_files_isnt_confused_by_symlinks
-    a = HOMEBREW_CELLAR/"a/1.0"
-    (a/"lib").mkpath
-    FileUtils.cp dylib_path("i386"), a/"lib/i386.dylib"
-    FileUtils.ln a/"lib/i386.dylib", a/"lib/i386_link.dylib"
-    FileUtils.ln_s a/"lib/i386.dylib", a/"lib/1.dylib"
-
-    keg = Keg.new(a)
-    keg.link
-
-    assert_equal 1, keg.mach_o_files.size
-  ensure
-    keg.unlink
-  end
-end
diff --git a/Library/Homebrew/test/spec_helper.rb b/Library/Homebrew/test/spec_helper.rb
index d8694eefc..b58125aec 100644
--- a/Library/Homebrew/test/spec_helper.rb
+++ b/Library/Homebrew/test/spec_helper.rb
@@ -15,6 +15,7 @@ require "global"
 require "tap"
 
 require "test/support/helper/shutup"
+require "test/support/helper/fixtures"
 
 TEST_DIRECTORIES = [
   CoreTap.instance.path/"Formula",
@@ -29,6 +30,7 @@ TEST_DIRECTORIES = [
 RSpec.configure do |config|
   config.order = :random
   config.include(Test::Helper::Shutup)
+  config.include(Test::Helper::Fixtures)
   config.before(:each) do |example|
     if example.metadata[:needs_macos]
       skip "not on macOS" unless OS.mac?
diff --git a/Library/Homebrew/test/support/helper/fixtures.rb b/Library/Homebrew/test/support/helper/fixtures.rb
new file mode 100644
index 000000000..716fe2008
--- /dev/null
+++ b/Library/Homebrew/test/support/helper/fixtures.rb
@@ -0,0 +1,13 @@
+module Test
+  module Helper
+    module Fixtures
+      def dylib_path(name)
+        Pathname.new("#{TEST_FIXTURE_DIR}/mach/#{name}.dylib")
+      end
+
+      def bundle_path(name)
+        Pathname.new("#{TEST_FIXTURE_DIR}/mach/#{name}.bundle")
+      end
+    end
+  end
+end
-- 
cgit v1.2.3


From 9fc14e663bc52b5e32a4c2d07ed6114b99fcbf54 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 05:00:26 +0100
Subject: Convert GPG2Requirement test to spec.

---
 Library/Homebrew/test/gpg2_requirement_spec.rb | 23 +++++++++++++++++++++++
 Library/Homebrew/test/gpg2_requirement_test.rb | 25 -------------------------
 2 files changed, 23 insertions(+), 25 deletions(-)
 create mode 100644 Library/Homebrew/test/gpg2_requirement_spec.rb
 delete mode 100644 Library/Homebrew/test/gpg2_requirement_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/gpg2_requirement_spec.rb b/Library/Homebrew/test/gpg2_requirement_spec.rb
new file mode 100644
index 000000000..f46b31196
--- /dev/null
+++ b/Library/Homebrew/test/gpg2_requirement_spec.rb
@@ -0,0 +1,23 @@
+require "requirements/gpg2_requirement"
+require "fileutils"
+
+describe GPG2Requirement do
+  let(:dir) { @dir = Pathname.new(Dir.mktmpdir) }
+
+  after(:each) do
+    FileUtils.rm_rf dir unless @dir.nil?
+  end
+
+  describe "#satisfied?" do
+    it "returns true if GPG2 is installed" do
+      ENV["PATH"] = dir/"bin"
+      (dir/"bin/gpg").write <<-EOS.undent
+        #!/bin/bash
+        echo 2.0.30
+      EOS
+      FileUtils.chmod 0755, dir/"bin/gpg"
+
+      expect(subject).to be_satisfied
+    end
+  end
+end
diff --git a/Library/Homebrew/test/gpg2_requirement_test.rb b/Library/Homebrew/test/gpg2_requirement_test.rb
deleted file mode 100644
index 3297c2851..000000000
--- a/Library/Homebrew/test/gpg2_requirement_test.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-require "testing_env"
-require "requirements/gpg2_requirement"
-require "fileutils"
-
-class GPG2RequirementTests < Homebrew::TestCase
-  def setup
-    super
-    @dir = Pathname.new(mktmpdir)
-    (@dir/"bin/gpg").write <<-EOS.undent
-      #!/bin/bash
-      echo 2.0.30
-    EOS
-    FileUtils.chmod 0755, @dir/"bin/gpg"
-  end
-
-  def teardown
-    FileUtils.rm_rf @dir
-    super
-  end
-
-  def test_satisfied
-    ENV["PATH"] = @dir/"bin"
-    assert_predicate GPG2Requirement.new, :satisfied?
-  end
-end
-- 
cgit v1.2.3


From 423f22df0033f83a04a9452d2e755a96e830b039 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 05:13:05 +0100
Subject: Convert `search_remote_tap` test to spec.

---
 Library/Homebrew/test/cmd/search_remote_tap_spec.rb | 19 +++++++++++++++++++
 Library/Homebrew/test/search_remote_tap_test.rb     | 19 -------------------
 2 files changed, 19 insertions(+), 19 deletions(-)
 create mode 100644 Library/Homebrew/test/cmd/search_remote_tap_spec.rb
 delete mode 100644 Library/Homebrew/test/search_remote_tap_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/cmd/search_remote_tap_spec.rb b/Library/Homebrew/test/cmd/search_remote_tap_spec.rb
new file mode 100644
index 000000000..99c2cc20b
--- /dev/null
+++ b/Library/Homebrew/test/cmd/search_remote_tap_spec.rb
@@ -0,0 +1,19 @@
+require "cmd/search"
+
+describe Homebrew do
+  specify "#search_tap" do
+    json_response = {
+      "tree" => [
+        {
+          "path" => "Formula/not-a-formula.rb",
+          "type" => "blob",
+        },
+      ],
+    }
+
+    allow(GitHub).to receive(:open).and_yield(json_response)
+
+    expect(described_class.search_tap("homebrew", "not-a-tap", "not-a-formula"))
+      .to eq(["homebrew/not-a-tap/not-a-formula"])
+  end
+end
diff --git a/Library/Homebrew/test/search_remote_tap_test.rb b/Library/Homebrew/test/search_remote_tap_test.rb
deleted file mode 100644
index 9dd9ee654..000000000
--- a/Library/Homebrew/test/search_remote_tap_test.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-require "testing_env"
-require "cmd/search"
-
-class SearchRemoteTapTests < Homebrew::TestCase
-  def test_search_remote_tap
-    json_response = {
-      "tree" => [
-        {
-          "path" => "Formula/not-a-formula.rb",
-          "type" => "blob",
-        },
-      ],
-    }
-
-    GitHub.stubs(:open).yields(json_response)
-
-    assert_equal ["homebrew/not-a-tap/not-a-formula"], Homebrew.search_tap("homebrew", "not-a-tap", "not-a-formula")
-  end
-end
-- 
cgit v1.2.3


From 66e3541b12eddaa18422a29b0f0ca968f54952f5 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 05:54:16 +0100
Subject: Convert MacOS::Version test to spec.

---
 Library/Homebrew/test/os/mac/version_spec.rb | 51 ++++++++++++++++++++++++++
 Library/Homebrew/test/os/mac/version_test.rb | 54 ----------------------------
 2 files changed, 51 insertions(+), 54 deletions(-)
 create mode 100644 Library/Homebrew/test/os/mac/version_spec.rb
 delete mode 100644 Library/Homebrew/test/os/mac/version_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/os/mac/version_spec.rb b/Library/Homebrew/test/os/mac/version_spec.rb
new file mode 100644
index 000000000..797207b67
--- /dev/null
+++ b/Library/Homebrew/test/os/mac/version_spec.rb
@@ -0,0 +1,51 @@
+require "version"
+require "os/mac/version"
+
+describe OS::Mac::Version do
+  subject { described_class.new("10.7") }
+
+  specify "comparison with Symbol" do
+    expect(subject).to be > :snow_leopard
+    expect(subject).to be == :lion
+    expect(subject).to be === :lion # rubocop:disable Style/CaseEquality
+    expect(subject).to be < :mountain_lion
+  end
+
+  specify "comparison with Fixnum" do
+    expect(subject).to be > 10
+    expect(subject).to be < 11
+  end
+
+  specify "comparison with Float" do
+    expect(subject).to be > 10.6
+    expect(subject).to be == 10.7
+    expect(subject).to be === 10.7 # rubocop:disable Style/CaseEquality
+    expect(subject).to be < 10.8
+  end
+
+  specify "comparison with String" do
+    expect(subject).to be > "10.6"
+    expect(subject).to be == "10.7"
+    expect(subject).to be === "10.7" # rubocop:disable Style/CaseEquality
+    expect(subject).to be < "10.8"
+  end
+
+  specify "comparison with Version" do
+    expect(subject).to be > Version.create("10.6")
+    expect(subject).to be == Version.create("10.7")
+    expect(subject).to be === Version.create("10.7") # rubocop:disable Style/CaseEquality
+    expect(subject).to be < Version.create("10.8")
+  end
+
+  specify "#from_symbol" do
+    expect(described_class.from_symbol(:lion)).to eq(subject)
+    expect { described_class.from_symbol(:foo) }
+      .to raise_error(ArgumentError)
+  end
+
+  specify "#pretty_name" do
+    expect(described_class.new("10.11").pretty_name).to eq("El Capitan")
+    expect(described_class.new("10.8").pretty_name).to eq("Mountain Lion")
+    expect(described_class.new("10.10").pretty_name).to eq("Yosemite")
+  end
+end
diff --git a/Library/Homebrew/test/os/mac/version_test.rb b/Library/Homebrew/test/os/mac/version_test.rb
deleted file mode 100644
index ba4217691..000000000
--- a/Library/Homebrew/test/os/mac/version_test.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-require "testing_env"
-require "version"
-require "os/mac/version"
-
-class OSMacVersionTests < Homebrew::TestCase
-  def setup
-    super
-    @v = MacOS::Version.new("10.7")
-  end
-
-  def test_compare_with_symbol
-    assert_operator @v, :>, :snow_leopard
-    assert_operator @v, :==, :lion
-    assert_operator @v, :===, :lion
-    assert_operator @v, :<, :mountain_lion
-  end
-
-  def test_compare_with_fixnum
-    assert_operator @v, :>, 10
-    assert_operator @v, :<, 11
-  end
-
-  def test_compare_with_float
-    assert_operator @v, :>, 10.6
-    assert_operator @v, :==, 10.7
-    assert_operator @v, :===, 10.7
-    assert_operator @v, :<, 10.8
-  end
-
-  def test_compare_with_string
-    assert_operator @v, :>, "10.6"
-    assert_operator @v, :==, "10.7"
-    assert_operator @v, :===, "10.7"
-    assert_operator @v, :<, "10.8"
-  end
-
-  def test_compare_with_version
-    assert_operator @v, :>, Version.create("10.6")
-    assert_operator @v, :==, Version.create("10.7")
-    assert_operator @v, :===, Version.create("10.7")
-    assert_operator @v, :<, Version.create("10.8")
-  end
-
-  def test_from_symbol
-    assert_equal @v, MacOS::Version.from_symbol(:lion)
-    assert_raises(ArgumentError) { MacOS::Version.from_symbol(:foo) }
-  end
-
-  def test_pretty_name
-    assert_equal "El Capitan", MacOS::Version.new("10.11").pretty_name
-    assert_equal "Mountain Lion", MacOS::Version.new("10.8").pretty_name
-    assert_equal "Yosemite", MacOS::Version.new("10.10").pretty_name
-  end
-end
-- 
cgit v1.2.3


From 15d681064173f06c5ca9de665d90cc9f036c6613 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 06:09:09 +0100
Subject: Convert `os/mac/blacklist` test to spec.

---
 Library/Homebrew/test/blacklist_spec.rb        | 18 +++++++++++-------
 Library/Homebrew/test/os/mac/blacklist_test.rb | 12 ------------
 2 files changed, 11 insertions(+), 19 deletions(-)
 delete mode 100644 Library/Homebrew/test/os/mac/blacklist_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/blacklist_spec.rb b/Library/Homebrew/test/blacklist_spec.rb
index 89d254893..01882167d 100644
--- a/Library/Homebrew/test/blacklist_spec.rb
+++ b/Library/Homebrew/test/blacklist_spec.rb
@@ -1,12 +1,8 @@
 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
diff --git a/Library/Homebrew/test/os/mac/blacklist_test.rb b/Library/Homebrew/test/os/mac/blacklist_test.rb
deleted file mode 100644
index 26dd84ed9..000000000
--- a/Library/Homebrew/test/os/mac/blacklist_test.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-require "testing_env"
-require "blacklist"
-
-class OSMacBlacklistTests < Homebrew::TestCase
-  def assert_blacklisted(s)
-    assert blacklisted?(s), "'#{s}' should be blacklisted"
-  end
-
-  def test_xcode
-    %w[xcode Xcode].each { |s| assert_blacklisted s }
-  end
-end
-- 
cgit v1.2.3


From 799da6dbe80b4808e66d81c0004d279abcbf55ea Mon Sep 17 00:00:00 2001
From: Kimmo Lehto
Date: Tue, 21 Feb 2017 11:12:34 +0200
Subject: Prepend selected ruby to PATH in RubyRequirement

---
 Library/Homebrew/requirements/ruby_requirement.rb | 37 +++++++++++++++++++----
 1 file changed, 31 insertions(+), 6 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/requirements/ruby_requirement.rb b/Library/Homebrew/requirements/ruby_requirement.rb
index a890435a5..e432edddb 100644
--- a/Library/Homebrew/requirements/ruby_requirement.rb
+++ b/Library/Homebrew/requirements/ruby_requirement.rb
@@ -9,15 +9,14 @@ class RubyRequirement < Requirement
   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
+    found_ruby = rubies.detect { |ruby| suitable?(ruby) }
+    return unless found_ruby
+    ENV.prepend_path "PATH", found_ruby.dirname
+    found_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 +32,30 @@ class RubyRequirement < Requirement
       name
     end
   end
+
+  private
+
+  def rubies
+    rubies = which_all("ruby")
+    if ruby_formula.installed?
+      rubies.unshift Pathname.new(ruby_formula.bin/"ruby")
+    end
+    rubies.uniq
+  end
+
+  def suitable?(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
+
+  def ruby_formula
+    @ruby_formula ||= Formula["ruby"]
+  rescue FormulaUnavailableError
+    nil
+  end
+
 end
-- 
cgit v1.2.3


From df7ae5eb26a9552ff61c66ed5680c701bf0be7df Mon Sep 17 00:00:00 2001
From: Kimmo Lehto
Date: Tue, 21 Feb 2017 11:24:53 +0200
Subject: Use the env block

---
 Library/Homebrew/requirements/ruby_requirement.rb | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/requirements/ruby_requirement.rb b/Library/Homebrew/requirements/ruby_requirement.rb
index e432edddb..817cf3e32 100644
--- a/Library/Homebrew/requirements/ruby_requirement.rb
+++ b/Library/Homebrew/requirements/ruby_requirement.rb
@@ -8,11 +8,10 @@ class RubyRequirement < Requirement
     super
   end
 
-  satisfy build_env: false do
-    found_ruby = rubies.detect { |ruby| suitable?(ruby) }
-    return unless found_ruby
-    ENV.prepend_path "PATH", found_ruby.dirname
-    found_ruby
+  satisfy build_env: false { suitable_ruby }
+
+  env do
+    ENV.prepend_path "PATH", suitable_ruby
   end
 
   def message
@@ -35,6 +34,10 @@ class RubyRequirement < Requirement
 
   private
 
+  def suitable_ruby
+    rubies.detect { |ruby| suitable?(ruby) }
+  end
+
   def rubies
     rubies = which_all("ruby")
     if ruby_formula.installed?
-- 
cgit v1.2.3


From 91c1a54b674c0468729de9ba62cccfaef2188af7 Mon Sep 17 00:00:00 2001
From: Kimmo Lehto
Date: Tue, 21 Feb 2017 11:26:40 +0200
Subject: Extra check

---
 Library/Homebrew/requirements/ruby_requirement.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/requirements/ruby_requirement.rb b/Library/Homebrew/requirements/ruby_requirement.rb
index 817cf3e32..f03399078 100644
--- a/Library/Homebrew/requirements/ruby_requirement.rb
+++ b/Library/Homebrew/requirements/ruby_requirement.rb
@@ -40,7 +40,7 @@ class RubyRequirement < Requirement
 
   def rubies
     rubies = which_all("ruby")
-    if ruby_formula.installed?
+    if ruby_formula && ruby_formula.installed?
       rubies.unshift Pathname.new(ruby_formula.bin/"ruby")
     end
     rubies.uniq
-- 
cgit v1.2.3


From f5a0ae176a1abed5ecba42a436a8a32595c21a9d Mon Sep 17 00:00:00 2001
From: Kimmo Lehto
Date: Tue, 21 Feb 2017 13:16:04 +0200
Subject: Syntax fail

---
 Library/Homebrew/requirements/ruby_requirement.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/requirements/ruby_requirement.rb b/Library/Homebrew/requirements/ruby_requirement.rb
index f03399078..0caedb5ca 100644
--- a/Library/Homebrew/requirements/ruby_requirement.rb
+++ b/Library/Homebrew/requirements/ruby_requirement.rb
@@ -8,7 +8,7 @@ class RubyRequirement < Requirement
     super
   end
 
-  satisfy build_env: false { suitable_ruby }
+  satisfy(build_env: false) { suitable_ruby }
 
   env do
     ENV.prepend_path "PATH", suitable_ruby
-- 
cgit v1.2.3


From a81bd81a14b6f1b85f523dc9cdb925ed7cc62b9a Mon Sep 17 00:00:00 2001
From: ilovezfs
Date: Tue, 21 Feb 2017 04:35:52 -0800
Subject: brew uninstal alias for brew uninstall

If `brew instal` is permissible, `brew uninstal` should be, too.
---
 Library/Homebrew/brew.sh             | 1 +
 Library/Homebrew/cask/lib/hbc/cli.rb | 1 +
 Library/Homebrew/global.rb           | 1 +
 3 files changed, 3 insertions(+)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/brew.sh b/Library/Homebrew/brew.sh
index 81a52f474..11c1a6c59 100644
--- a/Library/Homebrew/brew.sh
+++ b/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" ;;
diff --git a/Library/Homebrew/cask/lib/hbc/cli.rb b/Library/Homebrew/cask/lib/hbc/cli.rb
index 73ab121d2..8e178e373 100644
--- a/Library/Homebrew/cask/lib/hbc/cli.rb
+++ b/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",
diff --git a/Library/Homebrew/global.rb b/Library/Homebrew/global.rb
index 5e88947c9..391f5b012 100644
--- a/Library/Homebrew/global.rb
+++ b/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",
-- 
cgit v1.2.3


From 606790d06284df4765128117269c06a4df7e197c Mon Sep 17 00:00:00 2001
From: Mike McQuaid
Date: Tue, 31 Jan 2017 11:42:13 +0000
Subject: audit: check for version aliases.

Current version aliases should be provided for versioned formulae so
people can `brew install foo@1.2` to provide pin-like behaviour.
---
 Library/Homebrew/dev-cmd/audit.rb | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/dev-cmd/audit.rb b/Library/Homebrew/dev-cmd/audit.rb
index 9ffef0f99..9da5d28b4 100644
--- a/Library/Homebrew/dev-cmd/audit.rb
+++ b/Library/Homebrew/dev-cmd/audit.rb
@@ -295,6 +295,27 @@ class FormulaAuditor
 
     problem "File should end with a newline" unless text.trailing_newline?
 
+    versioned_formulae = Dir[formula.path.to_s.gsub(/\.rb$/, "@*.rb")]
+    needs_versioned_alias = !versioned_formulae.empty? &&
+                            formula.tap &&
+                            formula.aliases.grep(/.@\d/).empty?
+    if needs_versioned_alias
+      _, last_alias_version = File.basename(versioned_formulae.sort.reverse.first)
+                                  .gsub(/\.rb$/, "")
+                                  .split("@")
+      major, minor, = formula.version.to_s.split(".")
+      alias_name = if last_alias_version.split(".").length == 1
+        "#{formula.name}@#{major}"
+      else
+        "#{formula.name}@#{major}.#{minor}"
+      end
+      problem <<-EOS.undent
+        Formula has other versions so create an alias:
+          cd #{formula.tap.alias_dir}
+          ln -s #{formula.path.to_s.gsub(formula.tap.path, "..")} #{alias_name}
+      EOS
+    end
+
     return unless @strict
 
     present = audit_components
@@ -410,7 +431,8 @@ class FormulaAuditor
           problem "Dependency '#{dep.name}' was renamed; use new name '#{dep_f.name}'."
         end
 
-        if @@aliases.include?(dep.name)
+        if @@aliases.include?(dep.name) &&
+           (core_formula? || !dep_f.versioned_formula?)
           problem "Dependency '#{dep.name}' is an alias; use the canonical name '#{dep.to_formula.full_name}'."
         end
 
-- 
cgit v1.2.3


From 68bd744d0e44e40a5e3269bb16030134d937a524 Mon Sep 17 00:00:00 2001
From: Mike McQuaid
Date: Mon, 20 Feb 2017 14:05:40 +0000
Subject: readall: check for shadowed aliases.

This will become particularly relevant when there’s a new version of a
formula and the existing alias needs to be removed.
---
 Library/Homebrew/readall.rb | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/readall.rb b/Library/Homebrew/readall.rb
index 3dd7075ec..52addfa87 100644
--- a/Library/Homebrew/readall.rb
+++ b/Library/Homebrew/readall.rb
@@ -24,16 +24,15 @@ module Readall
       !failed
     end
 
-    def valid_aliases?(alias_dirs)
+    def valid_aliases?(alias_dir, formula_dir)
+      return false unless alias_dir.directory?
+
       failed = false
-      alias_dirs.each do |alias_dir|
-        next unless alias_dir.directory?
-        alias_dir.children.each do |f|
-          next unless f.symlink?
-          next if f.file?
-          onoe "Broken alias: #{f}"
-          failed = true
-        end
+      alias_dir.each_child do |f|
+        next unless f.symlink?
+        next if f.file? && !(formula_dir/"#{f.basename}.rb").exist?
+        onoe "Broken alias: #{f}"
+        failed = true
       end
       !failed
     end
@@ -57,7 +56,7 @@ module Readall
     def valid_tap?(tap, options = {})
       failed = false
       if options[:aliases]
-        valid_aliases = valid_aliases?([tap.alias_dir])
+        valid_aliases = valid_aliases?(tap.alias_dir, tap.formula_dir)
         failed = true unless valid_aliases
       end
       valid_formulae = valid_formulae?(tap.formula_files)
-- 
cgit v1.2.3


From 1ea79cd0b33501ce6ed16961d7c82adb8ceb3cd3 Mon Sep 17 00:00:00 2001
From: Mike McQuaid
Date: Tue, 21 Feb 2017 18:31:34 +0000
Subject: keg: handle missing alias opt link on uninstall.

Fixes an issue introduced in #1192 where there would be a failure if the
alias link didn't exist on removal (which would be the case for anything
with an alias installed before #1192 was merged).
---
 Library/Homebrew/keg.rb | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/keg.rb b/Library/Homebrew/keg.rb
index b31997d5a..94e3ff55b 100644
--- a/Library/Homebrew/keg.rb
+++ b/Library/Homebrew/keg.rb
@@ -239,7 +239,10 @@ class Keg
 
   def remove_opt_record
     opt_record.unlink
-    aliases.each { |a| (opt_record.parent/a).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
 
-- 
cgit v1.2.3


From 2f42dfc68a7c3cfdb2d364fc98dff67fea89e78e Mon Sep 17 00:00:00 2001
From: Mike McQuaid
Date: Tue, 21 Feb 2017 18:50:07 +0000
Subject: audit: fix revision should be removed.

Regression introduced in #1754 which meant that (due to storing the
current formula revision in `attributes_map`) `stable_revisions.empty?`
would never be `true`.
---
 Library/Homebrew/dev-cmd/audit.rb | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/dev-cmd/audit.rb b/Library/Homebrew/dev-cmd/audit.rb
index 9da5d28b4..d9c4bcddb 100644
--- a/Library/Homebrew/dev-cmd/audit.rb
+++ b/Library/Homebrew/dev-cmd/audit.rb
@@ -816,10 +816,12 @@ class FormulaAuditor
 
     return if formula.revision.zero?
     if formula.stable
-      revision_map = attributes_map[:revision][:stable]
-      stable_revisions = revision_map[formula.stable.version] if revision_map
-      if !stable_revisions || stable_revisions.empty?
-        problem "'revision #{formula.revision}' should be removed"
+      if revision_map = attributes_map[:revision][:stable]
+        stable_revisions = revision_map[formula.stable.version]
+        stable_revisions -= [formula.revision]
+        if stable_revisions.empty?
+          problem "'revision #{formula.revision}' should be removed"
+        end
       end
     else # head/devel-only formula
       problem "'revision #{formula.revision}' should be removed"
-- 
cgit v1.2.3


From 400eddcaae9087743ac783d92df23e75808c2006 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 02:02:39 +0100
Subject: Convert Homebrew::Diagnostic::Checks test to spec.

---
 Library/Homebrew/test/diagnostic_spec.rb | 188 ++++++++++++++++++++++++++++++
 Library/Homebrew/test/diagnostic_test.rb | 192 -------------------------------
 2 files changed, 188 insertions(+), 192 deletions(-)
 create mode 100644 Library/Homebrew/test/diagnostic_spec.rb
 delete mode 100644 Library/Homebrew/test/diagnostic_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/diagnostic_spec.rb b/Library/Homebrew/test/diagnostic_spec.rb
new file mode 100644
index 000000000..e749a3b0f
--- /dev/null
+++ b/Library/Homebrew/test/diagnostic_spec.rb
@@ -0,0 +1,188 @@
+require "diagnostic"
+
+describe Homebrew::Diagnostic::Checks do
+  specify "#inject_file_list" do
+    expect(subject.inject_file_list([], "foo:\n")).to eq("foo:\n")
+    expect(subject.inject_file_list(%w[/a /b], "foo:\n")).to eq("foo:\n  /a\n  /b\n")
+  end
+
+  specify "#check_path_for_trailing_slashes" do
+    ENV["PATH"] += File::PATH_SEPARATOR + "/foo/bar/"
+    expect(subject.check_path_for_trailing_slashes)
+      .to match("Some directories in your path end in a slash")
+  end
+
+  specify "#check_for_anaconda" do
+    Dir.mktmpdir do |path|
+      anaconda = "#{path}/anaconda"
+      python = "#{path}/python"
+      FileUtils.touch anaconda
+      File.open(python, "w") do |file|
+        file.write("#! #{`which bash`}\necho -n '#{python}'\n")
+      end
+      FileUtils.chmod 0755, anaconda
+      FileUtils.chmod 0755, python
+
+      ENV["PATH"] = path + File::PATH_SEPARATOR + ENV["PATH"]
+
+      expect(subject.check_for_anaconda).to match("Anaconda")
+    end
+  end
+
+  specify "#check_access_homebrew_repository" do
+    begin
+      mode = HOMEBREW_REPOSITORY.stat.mode & 0777
+      HOMEBREW_REPOSITORY.chmod 0555
+
+      expect(subject.check_access_homebrew_repository)
+        .to match("#{HOMEBREW_REPOSITORY} is not writable.")
+    ensure
+      HOMEBREW_REPOSITORY.chmod mode
+    end
+  end
+
+  specify "#check_access_logs" do
+    begin
+      mode = HOMEBREW_LOGS.stat.mode & 0777
+      HOMEBREW_LOGS.chmod 0555
+
+      expect(subject.check_access_logs)
+        .to match("#{HOMEBREW_LOGS} isn't writable.")
+    ensure
+      HOMEBREW_LOGS.chmod mode
+    end
+  end
+
+  specify "#check_access_cache" do
+    begin
+      mode = HOMEBREW_CACHE.stat.mode & 0777
+      HOMEBREW_CACHE.chmod 0555
+      expect(subject.check_access_cache)
+        .to match("#{HOMEBREW_CACHE} isn't writable.")
+    ensure
+      HOMEBREW_CACHE.chmod mode
+    end
+  end
+
+  specify "#check_access_cellar" do
+    begin
+      mode = HOMEBREW_CELLAR.stat.mode & 0777
+      HOMEBREW_CELLAR.chmod 0555
+
+      expect(subject.check_access_cellar)
+        .to match("#{HOMEBREW_CELLAR} isn't writable.")
+    ensure
+      HOMEBREW_CELLAR.chmod mode
+    end
+  end
+
+  specify "#check_homebrew_prefix" do
+    ENV.delete("JENKINS_HOME")
+    # the integration tests are run in a special prefix
+    expect(subject.check_homebrew_prefix)
+      .to match("Your Homebrew's prefix is not /usr/local.")
+  end
+
+  specify "#check_user_path_1" do
+    bin = HOMEBREW_PREFIX/"bin"
+    sep = File::PATH_SEPARATOR
+    # ensure /usr/bin is before HOMEBREW_PREFIX/bin in the PATH
+    ENV["PATH"] = "/usr/bin#{sep}#{bin}#{sep}" +
+                  ENV["PATH"].gsub(%r{(?:^|#{sep})(?:/usr/bin|#{bin})}, "")
+
+    # ensure there's at least one file with the same name in both /usr/bin/ and
+    # HOMEBREW_PREFIX/bin/
+    (bin/File.basename(Dir["/usr/bin/*"].first)).mkpath
+
+    expect(subject.check_user_path_1)
+      .to match("/usr/bin occurs before #{HOMEBREW_PREFIX}/bin")
+  end
+
+  specify "#check_user_path_2" do
+    ENV["PATH"] = ENV["PATH"].gsub \
+      %r{(?:^|#{File::PATH_SEPARATOR})#{HOMEBREW_PREFIX}/bin}, ""
+
+    expect(subject.check_user_path_1).to be nil
+    expect(subject.check_user_path_2)
+      .to match("Homebrew's bin was not found in your PATH.")
+  end
+
+  specify "#check_user_path_3" do
+    begin
+      sbin = HOMEBREW_PREFIX/"sbin"
+      ENV["PATH"] = "#{HOMEBREW_PREFIX}/bin#{File::PATH_SEPARATOR}" +
+                    ENV["PATH"].gsub(/(?:^|#{Regexp.escape(File::PATH_SEPARATOR)})#{Regexp.escape(sbin)}/, "")
+      (sbin/"something").mkpath
+
+      expect(subject.check_user_path_1).to be nil
+      expect(subject.check_user_path_2).to be nil
+      expect(subject.check_user_path_3)
+        .to match("Homebrew's sbin was not found in your PATH")
+    ensure
+      sbin.rmtree
+    end
+  end
+
+  specify "#check_user_curlrc" do
+    Dir.mktmpdir do |path|
+      FileUtils.touch "#{path}/.curlrc"
+      ENV["CURL_HOME"] = path
+
+      expect(subject.check_user_curlrc).to match("You have a curlrc file")
+    end
+  end
+
+  specify "#check_for_config_scripts" do
+    Dir.mktmpdir do |path|
+      file = "#{path}/foo-config"
+      FileUtils.touch file
+      FileUtils.chmod 0755, file
+      ENV["PATH"] = "#{path}#{File::PATH_SEPARATOR}#{ENV["PATH"]}"
+
+      expect(subject.check_for_config_scripts)
+        .to match('"config" scripts exist')
+    end
+  end
+
+  specify "#check_dyld_vars" do
+    ENV["DYLD_INSERT_LIBRARIES"] = "foo"
+    expect(subject.check_dyld_vars).to match("Setting DYLD_INSERT_LIBRARIES")
+  end
+
+  specify "#check_for_symlinked_cellar" do
+    begin
+      HOMEBREW_CELLAR.rmtree
+
+      Dir.mktmpdir do |path|
+        FileUtils.ln_s path, HOMEBREW_CELLAR
+
+        expect(subject.check_for_symlinked_cellar).to match(path)
+      end
+    ensure
+      HOMEBREW_CELLAR.unlink
+      HOMEBREW_CELLAR.mkpath
+    end
+  end
+
+  specify "#check_tmpdir" do
+    ENV["TMPDIR"] = "/i/don/t/exis/t"
+    expect(subject.check_tmpdir).to match("doesn't exist")
+  end
+
+  specify "#check_for_external_cmd_name_conflict" do
+    Dir.mktmpdir do |path1|
+      Dir.mktmpdir do |path2|
+        [path1, path2].each do |path|
+          cmd = "#{path}/brew-foo"
+          FileUtils.touch cmd
+          FileUtils.chmod 0755, cmd
+        end
+
+        ENV["PATH"] = [path1, path2, ENV["PATH"]].join File::PATH_SEPARATOR
+
+        expect(subject.check_for_external_cmd_name_conflict)
+          .to match("brew-foo")
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/diagnostic_test.rb b/Library/Homebrew/test/diagnostic_test.rb
deleted file mode 100644
index 7a1fb25f7..000000000
--- a/Library/Homebrew/test/diagnostic_test.rb
+++ /dev/null
@@ -1,192 +0,0 @@
-require "testing_env"
-require "fileutils"
-require "pathname"
-require "diagnostic"
-
-class DiagnosticChecksTest < Homebrew::TestCase
-  def setup
-    super
-    @checks = Homebrew::Diagnostic::Checks.new
-  end
-
-  def test_inject_file_list
-    assert_equal "foo:\n",
-      @checks.inject_file_list([], "foo:\n")
-    assert_equal "foo:\n  /a\n  /b\n",
-      @checks.inject_file_list(%w[/a /b], "foo:\n")
-  end
-
-  def test_check_path_for_trailing_slashes
-    ENV["PATH"] += File::PATH_SEPARATOR + "/foo/bar/"
-    assert_match "Some directories in your path end in a slash",
-      @checks.check_path_for_trailing_slashes
-  end
-
-  def test_check_for_anaconda
-    mktmpdir do |path|
-      anaconda = "#{path}/anaconda"
-      python = "#{path}/python"
-      FileUtils.touch anaconda
-      File.open(python, "w") do |file|
-        file.write("#! #{`which bash`}\necho -n '#{python}'\n")
-      end
-      FileUtils.chmod 0755, anaconda
-      FileUtils.chmod 0755, python
-
-      ENV["PATH"] = path + File::PATH_SEPARATOR + ENV["PATH"]
-
-      assert_match "Anaconda",
-        @checks.check_for_anaconda
-    end
-  end
-
-  def test_check_access_homebrew_repository
-    mod = HOMEBREW_REPOSITORY.stat.mode & 0777
-    HOMEBREW_REPOSITORY.chmod 0555
-
-    assert_match "#{HOMEBREW_REPOSITORY} is not writable.",
-      @checks.check_access_homebrew_repository
-  ensure
-    HOMEBREW_REPOSITORY.chmod mod
-  end
-
-  def test_check_access_logs
-    mod = HOMEBREW_LOGS.stat.mode & 0777
-    HOMEBREW_LOGS.chmod 0555
-
-    assert_match "#{HOMEBREW_LOGS} isn't writable.",
-      @checks.check_access_logs
-  ensure
-    HOMEBREW_LOGS.chmod mod
-  end
-
-  def test_check_access_cache
-    mod = HOMEBREW_CACHE.stat.mode & 0777
-    HOMEBREW_CACHE.chmod 0555
-    assert_match "#{HOMEBREW_CACHE} isn't writable.",
-      @checks.check_access_cache
-  ensure
-    HOMEBREW_CACHE.chmod mod
-  end
-
-  def test_check_access_cellar
-    mod = HOMEBREW_CELLAR.stat.mode & 0777
-    HOMEBREW_CELLAR.chmod 0555
-
-    assert_match "#{HOMEBREW_CELLAR} isn't writable.",
-      @checks.check_access_cellar
-  ensure
-    HOMEBREW_CELLAR.chmod mod
-  end
-
-  def test_check_homebrew_prefix
-    ENV.delete("JENKINS_HOME")
-    # the integration tests are run in a special prefix
-    assert_match "Your Homebrew's prefix is not /usr/local.",
-      @checks.check_homebrew_prefix
-  end
-
-  def test_check_user_path_usr_bin_before_homebrew
-    bin = HOMEBREW_PREFIX/"bin"
-    sep = File::PATH_SEPARATOR
-    # ensure /usr/bin is before HOMEBREW_PREFIX/bin in the PATH
-    ENV["PATH"] = "/usr/bin#{sep}#{bin}#{sep}" +
-                  ENV["PATH"].gsub(%r{(?:^|#{sep})(?:/usr/bin|#{bin})}, "")
-
-    # ensure there's at least one file with the same name in both /usr/bin/ and
-    # HOMEBREW_PREFIX/bin/
-    (bin/File.basename(Dir["/usr/bin/*"].first)).mkpath
-
-    assert_match "/usr/bin occurs before #{HOMEBREW_PREFIX}/bin",
-      @checks.check_user_path_1
-  end
-
-  def test_check_user_path_bin
-    ENV["PATH"] = ENV["PATH"].gsub \
-      %r{(?:^|#{File::PATH_SEPARATOR})#{HOMEBREW_PREFIX}/bin}, ""
-
-    assert_nil @checks.check_user_path_1
-    assert_match "Homebrew's bin was not found in your PATH.",
-      @checks.check_user_path_2
-  end
-
-  def test_check_user_path_sbin
-    sbin = HOMEBREW_PREFIX/"sbin"
-    ENV["PATH"] = "#{HOMEBREW_PREFIX}/bin#{File::PATH_SEPARATOR}" +
-                  ENV["PATH"].gsub(/(?:^|#{Regexp.escape(File::PATH_SEPARATOR)})#{Regexp.escape(sbin)}/, "")
-    (sbin/"something").mkpath
-
-    assert_nil @checks.check_user_path_1
-    assert_nil @checks.check_user_path_2
-    assert_match "Homebrew's sbin was not found in your PATH",
-      @checks.check_user_path_3
-  ensure
-    sbin.rmtree
-  end
-
-  def test_check_user_curlrc
-    mktmpdir do |path|
-      FileUtils.touch "#{path}/.curlrc"
-      ENV["CURL_HOME"] = path
-
-      assert_match "You have a curlrc file",
-        @checks.check_user_curlrc
-    end
-  end
-
-  def test_check_for_config_scripts
-    mktmpdir do |path|
-      file = "#{path}/foo-config"
-      FileUtils.touch file
-      FileUtils.chmod 0755, file
-      ENV["PATH"] = "#{path}#{File::PATH_SEPARATOR}#{ENV["PATH"]}"
-
-      assert_match '"config" scripts exist',
-        @checks.check_for_config_scripts
-    end
-  end
-
-  def test_check_dyld_vars
-    ENV["DYLD_INSERT_LIBRARIES"] = "foo"
-    assert_match "Setting DYLD_INSERT_LIBRARIES",
-      @checks.check_dyld_vars
-  end
-
-  def test_check_for_symlinked_cellar
-    HOMEBREW_CELLAR.rmtree
-
-    mktmpdir do |path|
-      FileUtils.ln_s path, HOMEBREW_CELLAR
-
-      assert_match path,
-        @checks.check_for_symlinked_cellar
-    end
-
-  ensure
-    HOMEBREW_CELLAR.unlink
-    HOMEBREW_CELLAR.mkpath
-  end
-
-  def test_check_tmpdir
-    ENV["TMPDIR"] = "/i/don/t/exis/t"
-    assert_match "doesn't exist",
-      @checks.check_tmpdir
-  end
-
-  def test_check_for_external_cmd_name_conflict
-    mktmpdir do |path1|
-      mktmpdir do |path2|
-        [path1, path2].each do |path|
-          cmd = "#{path}/brew-foo"
-          FileUtils.touch cmd
-          FileUtils.chmod 0755, cmd
-        end
-
-        ENV["PATH"] = [path1, path2, ENV["PATH"]].join File::PATH_SEPARATOR
-
-        assert_match "brew-foo",
-          @checks.check_for_external_cmd_name_conflict
-      end
-    end
-  end
-end
-- 
cgit v1.2.3


From 22042797d3111316e977eeee6f70439ae41448f6 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Mon, 20 Feb 2017 22:43:09 +0100
Subject: Convert FormulaLock test to spec.

---
 Library/Homebrew/test/formula_lock_spec.rb | 34 ++++++++++++++++++++++++++++++
 Library/Homebrew/test/formula_lock_test.rb | 23 --------------------
 2 files changed, 34 insertions(+), 23 deletions(-)
 create mode 100644 Library/Homebrew/test/formula_lock_spec.rb
 delete mode 100644 Library/Homebrew/test/formula_lock_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/formula_lock_spec.rb b/Library/Homebrew/test/formula_lock_spec.rb
new file mode 100644
index 000000000..9b5ece813
--- /dev/null
+++ b/Library/Homebrew/test/formula_lock_spec.rb
@@ -0,0 +1,34 @@
+require "formula_lock"
+
+describe FormulaLock do
+  subject { described_class.new("foo") }
+
+  describe "#lock" do
+    it "does not raise an error when already locked" do
+      subject.lock
+
+      expect { subject.lock }.not_to raise_error
+    end
+
+    it "raises an error if a lock already exists" do
+      subject.lock
+
+      expect {
+        described_class.new("foo").lock
+      }.to raise_error(OperationInProgressError)
+    end
+  end
+
+  describe "#unlock" do
+    it "does not raise an error when already unlocked" do
+      expect { subject.unlock }.not_to raise_error
+    end
+
+    it "unlocks a locked Formula" do
+      subject.lock
+      subject.unlock
+
+      expect { described_class.new("foo").lock }.not_to raise_error
+    end
+  end
+end
diff --git a/Library/Homebrew/test/formula_lock_test.rb b/Library/Homebrew/test/formula_lock_test.rb
deleted file mode 100644
index 13244555d..000000000
--- a/Library/Homebrew/test/formula_lock_test.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-require "testing_env"
-require "formula_lock"
-
-class FormulaLockTests < Homebrew::TestCase
-  def setup
-    super
-    @lock = FormulaLock.new("foo")
-    @lock.lock
-  end
-
-  def teardown
-    @lock.unlock
-    super
-  end
-
-  def test_locking_file_with_existing_lock_raises_error
-    assert_raises(OperationInProgressError) { FormulaLock.new("foo").lock }
-  end
-
-  def test_locking_existing_lock_suceeds
-    assert_nothing_raised { @lock.lock }
-  end
-end
-- 
cgit v1.2.3


From e218266aafeacf9b8d0caeabb8dba886b1bb13cc Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 02:23:49 +0100
Subject: Convert Mach-O test to spec.

---
 Library/Homebrew/test/os/mac/mach_spec.rb | 198 ++++++++++++++++++++++++++++
 Library/Homebrew/test/os/mac/mach_test.rb | 211 ------------------------------
 2 files changed, 198 insertions(+), 211 deletions(-)
 create mode 100644 Library/Homebrew/test/os/mac/mach_spec.rb
 delete mode 100644 Library/Homebrew/test/os/mac/mach_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/os/mac/mach_spec.rb b/Library/Homebrew/test/os/mac/mach_spec.rb
new file mode 100644
index 000000000..5c9aafcbb
--- /dev/null
+++ b/Library/Homebrew/test/os/mac/mach_spec.rb
@@ -0,0 +1,198 @@
+describe "Mach-O Pathname tests" do
+  specify "fat dylib" do
+    pn = dylib_path("fat")
+    expect(pn).to be_universal
+    expect(pn).not_to be_i386
+    expect(pn).not_to be_x86_64
+    expect(pn).not_to be_ppc7400
+    expect(pn).not_to be_ppc64
+    expect(pn).to be_dylib
+    expect(pn).not_to be_mach_o_executable
+    expect(pn).not_to be_text_executable
+    expect(pn.arch).to eq(:universal)
+  end
+
+  specify "i386 dylib" do
+    pn = dylib_path("i386")
+    expect(pn).not_to be_universal
+    expect(pn).to be_i386
+    expect(pn).not_to be_x86_64
+    expect(pn).not_to be_ppc7400
+    expect(pn).not_to be_ppc64
+    expect(pn).to be_dylib
+    expect(pn).not_to be_mach_o_executable
+    expect(pn).not_to be_text_executable
+    expect(pn).not_to be_mach_o_bundle
+  end
+
+  specify "x86_64 dylib" do
+    pn = dylib_path("x86_64")
+    expect(pn).not_to be_universal
+    expect(pn).not_to be_i386
+    expect(pn).to be_x86_64
+    expect(pn).not_to be_ppc7400
+    expect(pn).not_to be_ppc64
+    expect(pn).to be_dylib
+    expect(pn).not_to be_mach_o_executable
+    expect(pn).not_to be_text_executable
+    expect(pn).not_to be_mach_o_bundle
+  end
+
+  specify "Mach-O executable" do
+    pn = Pathname.new("#{TEST_FIXTURE_DIR}/mach/a.out")
+    expect(pn).to be_universal
+    expect(pn).not_to be_i386
+    expect(pn).not_to be_x86_64
+    expect(pn).not_to be_ppc7400
+    expect(pn).not_to be_ppc64
+    expect(pn).not_to be_dylib
+    expect(pn).to be_mach_o_executable
+    expect(pn).not_to be_text_executable
+    expect(pn).not_to be_mach_o_bundle
+  end
+
+  specify "fat bundle" do
+    pn = bundle_path("fat")
+    expect(pn).to be_universal
+    expect(pn).not_to be_i386
+    expect(pn).not_to be_x86_64
+    expect(pn).not_to be_ppc7400
+    expect(pn).not_to be_ppc64
+    expect(pn).not_to be_dylib
+    expect(pn).not_to be_mach_o_executable
+    expect(pn).not_to be_text_executable
+    expect(pn).to be_mach_o_bundle
+  end
+
+  specify "i386 bundle" do
+    pn = bundle_path("i386")
+    expect(pn).not_to be_universal
+    expect(pn).to be_i386
+    expect(pn).not_to be_x86_64
+    expect(pn).not_to be_ppc7400
+    expect(pn).not_to be_ppc64
+    expect(pn).not_to be_dylib
+    expect(pn).not_to be_mach_o_executable
+    expect(pn).not_to be_text_executable
+    expect(pn).to be_mach_o_bundle
+  end
+
+  specify "x86_64 bundle" do
+    pn = bundle_path("x86_64")
+    expect(pn).not_to be_universal
+    expect(pn).not_to be_i386
+    expect(pn).to be_x86_64
+    expect(pn).not_to be_ppc7400
+    expect(pn).not_to be_ppc64
+    expect(pn).not_to be_dylib
+    expect(pn).not_to be_mach_o_executable
+    expect(pn).not_to be_text_executable
+    expect(pn).to be_mach_o_bundle
+  end
+
+  specify "non-Mach-O" do
+    pn = Pathname.new("#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz")
+    expect(pn).not_to be_universal
+    expect(pn).not_to be_i386
+    expect(pn).not_to be_x86_64
+    expect(pn).not_to be_ppc7400
+    expect(pn).not_to be_ppc64
+    expect(pn).not_to be_dylib
+    expect(pn).not_to be_mach_o_executable
+    expect(pn).not_to be_text_executable
+    expect(pn).not_to be_mach_o_bundle
+    expect(pn.arch).to eq(:dunno)
+  end
+end
+
+describe ArchitectureListExtension do
+  let(:archs) { [:i386, :x86_64, :ppc7400, :ppc64].extend(described_class) }
+
+  specify "universal checks" do
+    expect(archs).to be_universal
+    expect(archs).to be_intel_universal
+    expect(archs).to be_ppc_universal
+    expect(archs).to be_cross_universal
+    expect(archs).to be_fat
+
+    non_universal = [:i386].extend(described_class)
+    expect(non_universal).not_to be_universal
+
+    intel_only = [:i386, :x86_64].extend(described_class)
+    expect(intel_only).to be_universal
+    expect(intel_only).not_to be_ppc_universal
+    expect(intel_only).not_to be_cross_universal
+
+    ppc_only = [:ppc970, :ppc64].extend(described_class)
+    expect(ppc_only).to be_universal
+    expect(ppc_only).not_to be_intel_universal
+    expect(ppc_only).not_to be_cross_universal
+
+    cross = [:ppc7400, :i386].extend(described_class)
+    expect(cross).to be_universal
+    expect(cross).not_to be_intel_universal
+    expect(cross).not_to be_ppc_universal
+  end
+
+  specify "messaging flags" do
+    archs.remove_ppc!
+    expect(archs.length).to eq(2)
+    expect(archs.as_arch_flags).to match(/-arch i386/)
+    expect(archs.as_arch_flags).to match(/-arch x86_64/)
+  end
+
+  specify "architecture flags" do
+    pn = dylib_path("fat")
+    expect(pn.archs).to be_intel_universal
+    expect(pn.archs.as_arch_flags).to eq("-arch x86_64 -arch i386")
+    expect(pn.archs.as_cmake_arch_flags).to eq("x86_64;i386")
+  end
+end
+
+describe "text executables" do
+  let(:pn) { HOMEBREW_PREFIX/"an_executable" }
+
+  after(:each) { pn.unlink }
+
+  specify "simple shebang" do
+    pn.write "#!/bin/sh"
+    expect(pn).not_to be_universal
+    expect(pn).not_to be_i386
+    expect(pn).not_to be_x86_64
+    expect(pn).not_to be_ppc7400
+    expect(pn).not_to be_ppc64
+    expect(pn).not_to be_dylib
+    expect(pn).not_to be_mach_o_executable
+    expect(pn).to be_text_executable
+    expect(pn.archs).to eq([])
+    expect(pn.arch).to eq(:dunno)
+  end
+
+  specify "shebang with options" do
+    pn.write "#! /usr/bin/perl -w"
+    expect(pn).not_to be_universal
+    expect(pn).not_to be_i386
+    expect(pn).not_to be_x86_64
+    expect(pn).not_to be_ppc7400
+    expect(pn).not_to be_ppc64
+    expect(pn).not_to be_dylib
+    expect(pn).not_to be_mach_o_executable
+    expect(pn).to be_text_executable
+    expect(pn.archs).to eq([])
+    expect(pn.arch).to eq(:dunno)
+  end
+
+  specify "malformed shebang" do
+    pn.write " #!"
+    expect(pn).not_to be_universal
+    expect(pn).not_to be_i386
+    expect(pn).not_to be_x86_64
+    expect(pn).not_to be_ppc7400
+    expect(pn).not_to be_ppc64
+    expect(pn).not_to be_dylib
+    expect(pn).not_to be_mach_o_executable
+    expect(pn).not_to be_text_executable
+    expect(pn.archs).to eq([])
+    expect(pn.arch).to eq(:dunno)
+  end
+end
diff --git a/Library/Homebrew/test/os/mac/mach_test.rb b/Library/Homebrew/test/os/mac/mach_test.rb
deleted file mode 100644
index ed0424be6..000000000
--- a/Library/Homebrew/test/os/mac/mach_test.rb
+++ /dev/null
@@ -1,211 +0,0 @@
-require "testing_env"
-
-class MachOPathnameTests < Homebrew::TestCase
-  def test_fat_dylib
-    pn = dylib_path("fat")
-    assert_predicate pn, :universal?
-    refute_predicate pn, :i386?
-    refute_predicate pn, :x86_64?
-    refute_predicate pn, :ppc7400?
-    refute_predicate pn, :ppc64?
-    assert_predicate pn, :dylib?
-    refute_predicate pn, :mach_o_executable?
-    refute_predicate pn, :text_executable?
-    assert_equal :universal, pn.arch
-  end
-
-  def test_i386_dylib
-    pn = dylib_path("i386")
-    refute_predicate pn, :universal?
-    assert_predicate pn, :i386?
-    refute_predicate pn, :x86_64?
-    refute_predicate pn, :ppc7400?
-    refute_predicate pn, :ppc64?
-    assert_predicate pn, :dylib?
-    refute_predicate pn, :mach_o_executable?
-    refute_predicate pn, :text_executable?
-    refute_predicate pn, :mach_o_bundle?
-  end
-
-  def test_x86_64_dylib
-    pn = dylib_path("x86_64")
-    refute_predicate pn, :universal?
-    refute_predicate pn, :i386?
-    assert_predicate pn, :x86_64?
-    refute_predicate pn, :ppc7400?
-    refute_predicate pn, :ppc64?
-    assert_predicate pn, :dylib?
-    refute_predicate pn, :mach_o_executable?
-    refute_predicate pn, :text_executable?
-    refute_predicate pn, :mach_o_bundle?
-  end
-
-  def test_mach_o_executable
-    pn = Pathname.new("#{TEST_FIXTURE_DIR}/mach/a.out")
-    assert_predicate pn, :universal?
-    refute_predicate pn, :i386?
-    refute_predicate pn, :x86_64?
-    refute_predicate pn, :ppc7400?
-    refute_predicate pn, :ppc64?
-    refute_predicate pn, :dylib?
-    assert_predicate pn, :mach_o_executable?
-    refute_predicate pn, :text_executable?
-    refute_predicate pn, :mach_o_bundle?
-  end
-
-  def test_fat_bundle
-    pn = bundle_path("fat")
-    assert_predicate pn, :universal?
-    refute_predicate pn, :i386?
-    refute_predicate pn, :x86_64?
-    refute_predicate pn, :ppc7400?
-    refute_predicate pn, :ppc64?
-    refute_predicate pn, :dylib?
-    refute_predicate pn, :mach_o_executable?
-    refute_predicate pn, :text_executable?
-    assert_predicate pn, :mach_o_bundle?
-  end
-
-  def test_i386_bundle
-    pn = bundle_path("i386")
-    refute_predicate pn, :universal?
-    assert_predicate pn, :i386?
-    refute_predicate pn, :x86_64?
-    refute_predicate pn, :ppc7400?
-    refute_predicate pn, :ppc64?
-    refute_predicate pn, :dylib?
-    refute_predicate pn, :mach_o_executable?
-    refute_predicate pn, :text_executable?
-    assert_predicate pn, :mach_o_bundle?
-  end
-
-  def test_x86_64_bundle
-    pn = bundle_path("x86_64")
-    refute_predicate pn, :universal?
-    refute_predicate pn, :i386?
-    assert_predicate pn, :x86_64?
-    refute_predicate pn, :ppc7400?
-    refute_predicate pn, :ppc64?
-    refute_predicate pn, :dylib?
-    refute_predicate pn, :mach_o_executable?
-    refute_predicate pn, :text_executable?
-    assert_predicate pn, :mach_o_bundle?
-  end
-
-  def test_non_mach_o
-    pn = Pathname.new("#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz")
-    refute_predicate pn, :universal?
-    refute_predicate pn, :i386?
-    refute_predicate pn, :x86_64?
-    refute_predicate pn, :ppc7400?
-    refute_predicate pn, :ppc64?
-    refute_predicate pn, :dylib?
-    refute_predicate pn, :mach_o_executable?
-    refute_predicate pn, :text_executable?
-    refute_predicate pn, :mach_o_bundle?
-    assert_equal :dunno, pn.arch
-  end
-end
-
-class ArchitectureListExtensionTests < MachOPathnameTests
-  def setup
-    super
-    @archs = [:i386, :x86_64, :ppc7400, :ppc64].extend(ArchitectureListExtension)
-  end
-
-  def test_architecture_list_extension_universal_checks
-    assert_predicate @archs, :universal?
-    assert_predicate @archs, :intel_universal?
-    assert_predicate @archs, :ppc_universal?
-    assert_predicate @archs, :cross_universal?
-    assert_predicate @archs, :fat?
-
-    non_universal = [:i386].extend ArchitectureListExtension
-    refute_predicate non_universal, :universal?
-
-    intel_only = [:i386, :x86_64].extend ArchitectureListExtension
-    assert_predicate intel_only, :universal?
-    refute_predicate intel_only, :ppc_universal?
-    refute_predicate intel_only, :cross_universal?
-
-    ppc_only = [:ppc970, :ppc64].extend ArchitectureListExtension
-    assert_predicate ppc_only, :universal?
-    refute_predicate ppc_only, :intel_universal?
-    refute_predicate ppc_only, :cross_universal?
-
-    cross = [:ppc7400, :i386].extend ArchitectureListExtension
-    assert_predicate cross, :universal?
-    refute_predicate cross, :intel_universal?
-    refute_predicate cross, :ppc_universal?
-  end
-
-  def test_architecture_list_extension_massaging_flags
-    @archs.remove_ppc!
-    assert_equal 2, @archs.length
-    assert_match(/-arch i386/, @archs.as_arch_flags)
-    assert_match(/-arch x86_64/, @archs.as_arch_flags)
-  end
-
-  def test_architecture_list_arch_flags_methods
-    pn = dylib_path("fat")
-    assert_predicate pn.archs, :intel_universal?
-    assert_equal "-arch x86_64 -arch i386", pn.archs.as_arch_flags
-    assert_equal "x86_64;i386", pn.archs.as_cmake_arch_flags
-  end
-end
-
-class TextExecutableTests < Homebrew::TestCase
-  attr_reader :pn
-
-  def setup
-    super
-    @pn = HOMEBREW_PREFIX.join("an_executable")
-  end
-
-  def teardown
-    HOMEBREW_PREFIX.join("an_executable").unlink
-    super
-  end
-
-  def test_simple_shebang
-    pn.write "#!/bin/sh"
-    refute_predicate pn, :universal?
-    refute_predicate pn, :i386?
-    refute_predicate pn, :x86_64?
-    refute_predicate pn, :ppc7400?
-    refute_predicate pn, :ppc64?
-    refute_predicate pn, :dylib?
-    refute_predicate pn, :mach_o_executable?
-    assert_predicate pn, :text_executable?
-    assert_equal [], pn.archs
-    assert_equal :dunno, pn.arch
-  end
-
-  def test_shebang_with_options
-    pn.write "#! /usr/bin/perl -w"
-    refute_predicate pn, :universal?
-    refute_predicate pn, :i386?
-    refute_predicate pn, :x86_64?
-    refute_predicate pn, :ppc7400?
-    refute_predicate pn, :ppc64?
-    refute_predicate pn, :dylib?
-    refute_predicate pn, :mach_o_executable?
-    assert_predicate pn, :text_executable?
-    assert_equal [], pn.archs
-    assert_equal :dunno, pn.arch
-  end
-
-  def test_malformed_shebang
-    pn.write " #!"
-    refute_predicate pn, :universal?
-    refute_predicate pn, :i386?
-    refute_predicate pn, :x86_64?
-    refute_predicate pn, :ppc7400?
-    refute_predicate pn, :ppc64?
-    refute_predicate pn, :dylib?
-    refute_predicate pn, :mach_o_executable?
-    refute_predicate pn, :text_executable?
-    assert_equal [], pn.archs
-    assert_equal :dunno, pn.arch
-  end
-end
-- 
cgit v1.2.3


From 8bb46baebbc0694130b86483705bfef2c159704e Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Wed, 15 Feb 2017 19:20:38 +0100
Subject: Add RSpec support for integration commands.

---
 Library/Homebrew/test/spec_helper.rb               |  1 +
 .../helper/spec/shared_context/integration_test.rb | 94 ++++++++++++++++++++++
 2 files changed, 95 insertions(+)
 create mode 100644 Library/Homebrew/test/support/helper/spec/shared_context/integration_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/spec_helper.rb b/Library/Homebrew/test/spec_helper.rb
index b58125aec..547ec3f7b 100644
--- a/Library/Homebrew/test/spec_helper.rb
+++ b/Library/Homebrew/test/spec_helper.rb
@@ -16,6 +16,7 @@ require "tap"
 
 require "test/support/helper/shutup"
 require "test/support/helper/fixtures"
+require "test/support/helper/spec/shared_context/integration_test"
 
 TEST_DIRECTORIES = [
   CoreTap.instance.path/"Formula",
diff --git a/Library/Homebrew/test/support/helper/spec/shared_context/integration_test.rb b/Library/Homebrew/test/support/helper/spec/shared_context/integration_test.rb
new file mode 100644
index 000000000..dd2271a3a
--- /dev/null
+++ b/Library/Homebrew/test/support/helper/spec/shared_context/integration_test.rb
@@ -0,0 +1,94 @@
+require "rspec"
+require "open3"
+
+RSpec::Matchers.define_negated_matcher :not_to_output, :output
+RSpec::Matchers.define_negated_matcher :be_a_failure, :be_a_success
+
+RSpec.shared_context "integration test" do
+  extend RSpec::Matchers::DSL
+
+  matcher :be_a_success do
+    match do |actual|
+      status = actual.is_a?(Proc) ? actual.call : actual
+      status.respond_to?(:success?) && status.success?
+    end
+
+    def supports_block_expectations?
+      true
+    end
+
+    # It needs to be nested like this:
+    #
+    #   expect {
+    #     expect {
+    #       # command
+    #     }.to be_a_success
+    #   }.to output(something).to_stdout
+    #
+    # rather than this:
+    #
+    #   expect {
+    #     expect {
+    #       # command
+    #     }.to output(something).to_stdout
+    #   }.to be_a_success
+    #
+    def expects_call_stack_jump?
+      true
+    end
+  end
+
+  before(:each) do
+    (HOMEBREW_PREFIX/"bin").mkpath
+    FileUtils.touch HOMEBREW_PREFIX/"bin/brew"
+  end
+
+  after(:each) do
+    FileUtils.rm HOMEBREW_PREFIX/"bin/brew"
+    FileUtils.rmdir HOMEBREW_PREFIX/"bin"
+  end
+
+  # Generate unique ID to be able to
+  # properly merge coverage results.
+  def command_id_from_args(args)
+    @command_count ||= 0
+    pretty_args = args.join(" ").gsub(TEST_TMPDIR, "@TMPDIR@")
+    file_and_line = caller[1].sub(/(.*\d+):.*/, '\1')
+                             .sub("#{HOMEBREW_LIBRARY_PATH}/test/", "")
+    "#{file_and_line}:brew #{pretty_args}:#{@command_count += 1}"
+  end
+
+  # Runs a `brew` command with the test configuration
+  # and with coverage reporting enabled.
+  def brew(*args)
+    env = args.last.is_a?(Hash) ? args.pop : {}
+
+    env.merge!(
+      "HOMEBREW_BREW_FILE" => HOMEBREW_PREFIX/"bin/brew",
+      "HOMEBREW_INTEGRATION_TEST" => command_id_from_args(args),
+      "HOMEBREW_TEST_TMPDIR" => TEST_TMPDIR,
+      "HOMEBREW_DEVELOPER" => ENV["HOMEBREW_DEVELOPER"],
+    )
+
+    ruby_args = [
+      "-W0",
+      "-I", "#{HOMEBREW_LIBRARY_PATH}/test/support/lib",
+      "-I", HOMEBREW_LIBRARY_PATH.to_s,
+      "-rconfig"
+    ]
+    ruby_args << "-rsimplecov" if ENV["HOMEBREW_TESTS_COVERAGE"]
+    ruby_args << "-rtest/support/helper/integration_mocks"
+    ruby_args << (HOMEBREW_LIBRARY_PATH/"brew.rb").resolved_path.to_s
+
+    Bundler.with_original_env do
+      stdout, stderr, status = Open3.capture3(env, RUBY_PATH, *ruby_args, *args)
+      $stdout.print stdout
+      $stderr.print stderr
+      status
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include_context "integration test", :integration_test
+end
-- 
cgit v1.2.3


From 9ac59b99e462e648013ea3a1cbfba295e80b5837 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Sat, 18 Feb 2017 17:38:13 +0100
Subject: Convert `brew analytics` test to spec.

---
 Library/Homebrew/test/analytics_test.rb     | 26 ---------------
 Library/Homebrew/test/cmd/analytics_spec.rb | 52 +++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 26 deletions(-)
 delete mode 100644 Library/Homebrew/test/analytics_test.rb
 create mode 100644 Library/Homebrew/test/cmd/analytics_spec.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/analytics_test.rb b/Library/Homebrew/test/analytics_test.rb
deleted file mode 100644
index 37040f3cd..000000000
--- a/Library/Homebrew/test/analytics_test.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-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
diff --git a/Library/Homebrew/test/cmd/analytics_spec.rb b/Library/Homebrew/test/cmd/analytics_spec.rb
new file mode 100644
index 000000000..aed3a7a33
--- /dev/null
+++ b/Library/Homebrew/test/cmd/analytics_spec.rb
@@ -0,0 +1,52 @@
+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
-- 
cgit v1.2.3


From b59bf2ff6410dc3e226f0c6c42a37f16a86b472b Mon Sep 17 00:00:00 2001
From: ilovezfs
Date: Tue, 21 Feb 2017 11:31:18 -0800
Subject: Revert "audit: check for version aliases."

---
 Library/Homebrew/dev-cmd/audit.rb | 24 +-----------------------
 Library/Homebrew/readall.rb       | 19 ++++++++++---------
 2 files changed, 11 insertions(+), 32 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/dev-cmd/audit.rb b/Library/Homebrew/dev-cmd/audit.rb
index 9da5d28b4..9ffef0f99 100644
--- a/Library/Homebrew/dev-cmd/audit.rb
+++ b/Library/Homebrew/dev-cmd/audit.rb
@@ -295,27 +295,6 @@ class FormulaAuditor
 
     problem "File should end with a newline" unless text.trailing_newline?
 
-    versioned_formulae = Dir[formula.path.to_s.gsub(/\.rb$/, "@*.rb")]
-    needs_versioned_alias = !versioned_formulae.empty? &&
-                            formula.tap &&
-                            formula.aliases.grep(/.@\d/).empty?
-    if needs_versioned_alias
-      _, last_alias_version = File.basename(versioned_formulae.sort.reverse.first)
-                                  .gsub(/\.rb$/, "")
-                                  .split("@")
-      major, minor, = formula.version.to_s.split(".")
-      alias_name = if last_alias_version.split(".").length == 1
-        "#{formula.name}@#{major}"
-      else
-        "#{formula.name}@#{major}.#{minor}"
-      end
-      problem <<-EOS.undent
-        Formula has other versions so create an alias:
-          cd #{formula.tap.alias_dir}
-          ln -s #{formula.path.to_s.gsub(formula.tap.path, "..")} #{alias_name}
-      EOS
-    end
-
     return unless @strict
 
     present = audit_components
@@ -431,8 +410,7 @@ class FormulaAuditor
           problem "Dependency '#{dep.name}' was renamed; use new name '#{dep_f.name}'."
         end
 
-        if @@aliases.include?(dep.name) &&
-           (core_formula? || !dep_f.versioned_formula?)
+        if @@aliases.include?(dep.name)
           problem "Dependency '#{dep.name}' is an alias; use the canonical name '#{dep.to_formula.full_name}'."
         end
 
diff --git a/Library/Homebrew/readall.rb b/Library/Homebrew/readall.rb
index 52addfa87..3dd7075ec 100644
--- a/Library/Homebrew/readall.rb
+++ b/Library/Homebrew/readall.rb
@@ -24,15 +24,16 @@ module Readall
       !failed
     end
 
-    def valid_aliases?(alias_dir, formula_dir)
-      return false unless alias_dir.directory?
-
+    def valid_aliases?(alias_dirs)
       failed = false
-      alias_dir.each_child do |f|
-        next unless f.symlink?
-        next if f.file? && !(formula_dir/"#{f.basename}.rb").exist?
-        onoe "Broken alias: #{f}"
-        failed = true
+      alias_dirs.each do |alias_dir|
+        next unless alias_dir.directory?
+        alias_dir.children.each do |f|
+          next unless f.symlink?
+          next if f.file?
+          onoe "Broken alias: #{f}"
+          failed = true
+        end
       end
       !failed
     end
@@ -56,7 +57,7 @@ module Readall
     def valid_tap?(tap, options = {})
       failed = false
       if options[:aliases]
-        valid_aliases = valid_aliases?(tap.alias_dir, tap.formula_dir)
+        valid_aliases = valid_aliases?([tap.alias_dir])
         failed = true unless valid_aliases
       end
       valid_formulae = valid_formulae?(tap.formula_files)
-- 
cgit v1.2.3


From dd99d656a30ec3ce2de7e60c24e6b0a1b506ff1d Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 21:45:34 +0100
Subject: Convert Utils::Bottles test to spec.

---
 Library/Homebrew/test/os/mac/bottle_tag_test.rb    | 79 ---------------------
 Library/Homebrew/test/spec_helper.rb               |  2 +-
 .../Homebrew/test/utils/bottles/bottles_spec.rb    | 80 ++++++++++++++++++++++
 3 files changed, 81 insertions(+), 80 deletions(-)
 delete mode 100644 Library/Homebrew/test/os/mac/bottle_tag_test.rb
 create mode 100644 Library/Homebrew/test/utils/bottles/bottles_spec.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/os/mac/bottle_tag_test.rb b/Library/Homebrew/test/os/mac/bottle_tag_test.rb
deleted file mode 100644
index 996bd4d53..000000000
--- a/Library/Homebrew/test/os/mac/bottle_tag_test.rb
+++ /dev/null
@@ -1,79 +0,0 @@
-require "testing_env"
-require "utils/bottles"
-
-class OSMacBottleTagTests < Homebrew::TestCase
-  def test_tag_tiger_ppc
-    MacOS.stubs(:version).returns(MacOS::Version.new("10.4"))
-    Hardware::CPU.stubs(:type).returns(:ppc)
-    Hardware::CPU.stubs(:family).returns(:foo)
-    MacOS.stubs(:prefer_64_bit?).returns(false)
-    assert_equal :tiger_foo, Utils::Bottles.tag
-  end
-
-  def test_tag_tiger_intel
-    MacOS.stubs(:version).returns(MacOS::Version.new("10.4"))
-    Hardware::CPU.stubs(:type).returns(:intel)
-    MacOS.stubs(:prefer_64_bit?).returns(false)
-    assert_equal :tiger, Utils::Bottles.tag
-  end
-
-  def test_tag_tiger_ppc_64
-    MacOS.stubs(:version).returns(MacOS::Version.new("10.4"))
-    Hardware::CPU.stubs(:type).returns(:ppc)
-    Hardware::CPU.stubs(:family).returns(:g5)
-    MacOS.stubs(:prefer_64_bit?).returns(true)
-    assert_equal :tiger_g5_64, Utils::Bottles.tag
-  end
-
-  # Note that this will probably never be used
-  def test_tag_tiger_intel_64
-    MacOS.stubs(:version).returns(MacOS::Version.new("10.4"))
-    Hardware::CPU.stubs(:type).returns(:intel)
-    MacOS.stubs(:prefer_64_bit?).returns(true)
-    assert_equal :tiger_64, Utils::Bottles.tag
-  end
-
-  def test_tag_leopard_intel
-    MacOS.stubs(:version).returns(MacOS::Version.new("10.5"))
-    Hardware::CPU.stubs(:type).returns(:intel)
-    MacOS.stubs(:prefer_64_bit?).returns(false)
-    assert_equal :leopard, Utils::Bottles.tag
-  end
-
-  def test_tag_leopard_ppc_64
-    MacOS.stubs(:version).returns(MacOS::Version.new("10.5"))
-    Hardware::CPU.stubs(:type).returns(:ppc)
-    Hardware::CPU.stubs(:family).returns(:g5)
-    MacOS.stubs(:prefer_64_bit?).returns(true)
-    assert_equal :leopard_g5_64, Utils::Bottles.tag
-  end
-
-  def test_tag_leopard_intel_64
-    MacOS.stubs(:version).returns(MacOS::Version.new("10.5"))
-    Hardware::CPU.stubs(:type).returns(:intel)
-    MacOS.stubs(:prefer_64_bit?).returns(true)
-    assert_equal :leopard_64, Utils::Bottles.tag
-  end
-
-  def test_tag_snow_leopard_32
-    MacOS.stubs(:version).returns(MacOS::Version.new("10.6"))
-    Hardware::CPU.stubs(:is_64_bit?).returns(false)
-    assert_equal :snow_leopard_32, Utils::Bottles.tag
-  end
-
-  def test_tag_snow_leopard_64
-    MacOS.stubs(:version).returns(MacOS::Version.new("10.6"))
-    Hardware::CPU.stubs(:is_64_bit?).returns(true)
-    assert_equal :snow_leopard, Utils::Bottles.tag
-  end
-
-  def test_tag_lion
-    MacOS.stubs(:version).returns(MacOS::Version.new("10.7"))
-    assert_equal :lion, Utils::Bottles.tag
-  end
-
-  def test_tag_mountain_lion
-    MacOS.stubs(:version).returns(MacOS::Version.new("10.8"))
-    assert_equal :mountain_lion, Utils::Bottles.tag
-  end
-end
diff --git a/Library/Homebrew/test/spec_helper.rb b/Library/Homebrew/test/spec_helper.rb
index b58125aec..1396fa946 100644
--- a/Library/Homebrew/test/spec_helper.rb
+++ b/Library/Homebrew/test/spec_helper.rb
@@ -33,7 +33,7 @@ RSpec.configure do |config|
   config.include(Test::Helper::Fixtures)
   config.before(:each) do |example|
     if example.metadata[:needs_macos]
-      skip "not on macOS" unless OS.mac?
+      skip "Not on macOS." unless OS.mac?
     end
 
     if example.metadata[:needs_python]
diff --git a/Library/Homebrew/test/utils/bottles/bottles_spec.rb b/Library/Homebrew/test/utils/bottles/bottles_spec.rb
new file mode 100644
index 000000000..8b54b0b34
--- /dev/null
+++ b/Library/Homebrew/test/utils/bottles/bottles_spec.rb
@@ -0,0 +1,80 @@
+require "utils/bottles"
+
+describe Utils::Bottles do
+  describe "#tag", :needs_macos do
+    it "returns :tiger_foo on Tiger PowerPC" do
+      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.4"))
+      allow(Hardware::CPU).to receive(:type).and_return(:ppc)
+      allow(Hardware::CPU).to receive(:family).and_return(:foo)
+      allow(MacOS).to receive(:prefer_64_bit?).and_return(false)
+      expect(described_class.tag).to eq(:tiger_foo)
+    end
+
+    it "returns :tiger on Tiger Intel" do
+      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.4"))
+      allow(Hardware::CPU).to receive(:type).and_return(:intel)
+      allow(MacOS).to receive(:prefer_64_bit?).and_return(false)
+      expect(described_class.tag).to eq(:tiger)
+    end
+
+    it "returns :tiger_g5_64 on Tiger PowerPC 64-bit" do
+      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.4"))
+      allow(Hardware::CPU).to receive(:type).and_return(:ppc)
+      allow(Hardware::CPU).to receive(:family).and_return(:g5)
+      allow(MacOS).to receive(:prefer_64_bit?).and_return(true)
+      expect(described_class.tag).to eq(:tiger_g5_64)
+    end
+
+    # Note that this will probably never be used
+    it "returns :tiger_64 on Tiger Intel 64-bit" do
+      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.4"))
+      allow(Hardware::CPU).to receive(:type).and_return(:intel)
+      allow(MacOS).to receive(:prefer_64_bit?).and_return(true)
+      expect(described_class.tag).to eq(:tiger_64)
+    end
+
+    it "returns :leopard on Leopard Intel" do
+      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.5"))
+      allow(Hardware::CPU).to receive(:type).and_return(:intel)
+      allow(MacOS).to receive(:prefer_64_bit?).and_return(false)
+      expect(described_class.tag).to eq(:leopard)
+    end
+
+    it "returns :leopard_g5_64 on Leopard PowerPC 64-bit" do
+      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.5"))
+      allow(Hardware::CPU).to receive(:type).and_return(:ppc)
+      allow(Hardware::CPU).to receive(:family).and_return(:g5)
+      allow(MacOS).to receive(:prefer_64_bit?).and_return(true)
+      expect(described_class.tag).to eq(:leopard_g5_64)
+    end
+
+    it "returns :leopard_64 on Leopard Intel 64-bit" do
+      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.5"))
+      allow(Hardware::CPU).to receive(:type).and_return(:intel)
+      allow(MacOS).to receive(:prefer_64_bit?).and_return(true)
+      expect(described_class.tag).to eq(:leopard_64)
+    end
+
+    it "returns :snow_leopard_32 on Snow Leopard 32-bit" do
+      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.6"))
+      allow(Hardware::CPU).to receive(:is_64_bit?).and_return(false)
+      expect(described_class.tag).to eq(:snow_leopard_32)
+    end
+
+    it "returns :snow_leopard on Snow Leopard 64-bit" do
+      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.6"))
+      allow(Hardware::CPU).to receive(:is_64_bit?).and_return(true)
+      expect(described_class.tag).to eq(:snow_leopard)
+    end
+
+    it "returns :lion on Lion" do
+      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.7"))
+      expect(described_class.tag).to eq(:lion)
+    end
+
+    it "returns :mountain_lion on Mountain Lion" do
+      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("10.8"))
+      expect(described_class.tag).to eq(:mountain_lion)
+    end
+  end
+end
-- 
cgit v1.2.3


From 168a96d91912c9adc19d8729d0cb6ac54aef7590 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 21:55:11 +0100
Subject: Exclude specs with `:needs_macos` tag when not on macOS.

---
 Library/Homebrew/dev-cmd/tests.rb | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/dev-cmd/tests.rb b/Library/Homebrew/dev-cmd/tests.rb
index 244fbe027..246b5fa46 100644
--- a/Library/Homebrew/dev-cmd/tests.rb
+++ b/Library/Homebrew/dev-cmd/tests.rb
@@ -84,6 +84,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?
-- 
cgit v1.2.3


From f7151e589fec5cd8caef00798c02e0c54eff5419 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 02:50:52 +0100
Subject: Convert JavaRequirement test to spec.

---
 Library/Homebrew/test/java_requirement_spec.rb | 107 +++++++++++++++++++++++++
 Library/Homebrew/test/java_requirement_test.rb |  50 ------------
 2 files changed, 107 insertions(+), 50 deletions(-)
 create mode 100644 Library/Homebrew/test/java_requirement_spec.rb
 delete mode 100644 Library/Homebrew/test/java_requirement_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/java_requirement_spec.rb b/Library/Homebrew/test/java_requirement_spec.rb
new file mode 100644
index 000000000..5adf64c7c
--- /dev/null
+++ b/Library/Homebrew/test/java_requirement_spec.rb
@@ -0,0 +1,107 @@
+require "requirements/java_requirement"
+
+describe JavaRequirement do
+  subject { described_class.new([]) }
+
+  before(:each) do
+    ENV["JAVA_HOME"] = nil
+  end
+
+  describe "#message" do
+    its(:message) { is_expected.to match(/Java is required to install this formula./) }
+  end
+
+  describe "#inspect" do
+    subject { described_class.new(%w[1.7+]) }
+    its(:inspect) { is_expected.to eq('#<JavaRequirement: "java" [] version="1.7+">') }
+  end
+
+  describe "#display_s" do
+    context "without specific version" do
+      its(:display_s) { is_expected.to eq("java") }
+    end
+
+    context "with version 1.8" do
+      subject { described_class.new(%w[1.8]) }
+      its(:display_s) { is_expected.to eq("java = 1.8") }
+    end
+
+    context "with version 1.8+" do
+      subject { described_class.new(%w[1.8+]) }
+      its(:display_s) { is_expected.to eq("java >= 1.8") }
+    end
+  end
+
+  describe "#satisfied?" do
+    subject { described_class.new(%w[1.8]) }
+
+    it "returns false if no `java` executable can be found" do
+      allow(File).to receive(:executable?).and_return(false)
+      expect(subject).not_to be_satisfied
+    end
+
+    it "returns true if #preferred_java returns a path" do
+      allow(subject).to receive(:preferred_java).and_return(Pathname.new("/usr/bin/java"))
+      expect(subject).to be_satisfied
+    end
+
+    context "when #possible_javas contains paths" do
+      let(:path) { Pathname.new(Dir.mktmpdir) }
+      let(:java) { path/"java" }
+
+      def setup_java_with_version(version)
+        IO.write java, <<-EOS.undent
+          #!/bin/sh
+          echo 'java version "#{version}"'
+        EOS
+        FileUtils.chmod "+x", java
+      end
+
+      before(:each) do
+        allow(subject).to receive(:possible_javas).and_return([java])
+      end
+
+      after(:each) do
+        path.rmtree
+      end
+
+      context "and 1.7 is required" do
+        subject { described_class.new(%w[1.7]) }
+
+        it "returns false if all are lower" do
+          setup_java_with_version "1.6.0_5"
+          expect(subject).not_to be_satisfied
+        end
+
+        it "returns true if one is equal" do
+          setup_java_with_version "1.7.0_5"
+          expect(subject).to be_satisfied
+        end
+
+        it "returns false if all are higher" do
+          setup_java_with_version "1.8.0_5"
+          expect(subject).not_to be_satisfied
+        end
+      end
+
+      context "and 1.7+ is required" do
+        subject { described_class.new(%w[1.7+]) }
+
+        it "returns false if all are lower" do
+          setup_java_with_version "1.6.0_5"
+          expect(subject).not_to be_satisfied
+        end
+
+        it "returns true if one is equal" do
+          setup_java_with_version "1.7.0_5"
+          expect(subject).to be_satisfied
+        end
+
+        it "returns true if one is higher" do
+          setup_java_with_version "1.8.0_5"
+          expect(subject).to be_satisfied
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/java_requirement_test.rb b/Library/Homebrew/test/java_requirement_test.rb
deleted file mode 100644
index d0b51f92c..000000000
--- a/Library/Homebrew/test/java_requirement_test.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-require "testing_env"
-require "requirements/java_requirement"
-
-class JavaRequirementTests < Homebrew::TestCase
-  def setup
-    super
-    ENV["JAVA_HOME"] = nil
-  end
-
-  def test_message
-    a = JavaRequirement.new([])
-    assert_match(/Java is required to install this formula./, a.message)
-  end
-
-  def test_inspect
-    a = JavaRequirement.new(%w[1.7+])
-    assert_equal a.inspect, '#<JavaRequirement: "java" [] version="1.7+">'
-  end
-
-  def test_display_s
-    x = JavaRequirement.new([])
-    assert_equal x.display_s, "java"
-    y = JavaRequirement.new(%w[1.8])
-    assert_equal y.display_s, "java = 1.8"
-    z = JavaRequirement.new(%w[1.8+])
-    assert_equal z.display_s, "java >= 1.8"
-  end
-
-  def test_satisfied?
-    a = JavaRequirement.new(%w[1.8])
-    File.stubs(:executable?).returns(false)
-    refute_predicate a, :satisfied?
-
-    b = JavaRequirement.new([])
-    b.stubs(:preferred_java).returns(Pathname.new("/usr/bin/java"))
-    assert_predicate b, :satisfied?
-
-    c = JavaRequirement.new(%w[1.7+])
-    c.stubs(:possible_javas).returns([Pathname.new("/usr/bin/java")])
-    Utils.stubs(:popen_read).returns('java version "1.6.0_5"')
-    refute_predicate c, :satisfied?
-    Utils.stubs(:popen_read).returns('java version "1.8.0_5"')
-    assert_predicate c, :satisfied?
-
-    d = JavaRequirement.new(%w[1.7])
-    d.stubs(:possible_javas).returns([Pathname.new("/usr/bin/java")])
-    Utils.stubs(:popen_read).returns('java version "1.8.0_5"')
-    refute_predicate d, :satisfied?
-  end
-end
-- 
cgit v1.2.3


From babc375372df635c023977de9f1279a7689e2453 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 20:58:43 +0100
Subject: Convert Resource test to spec.

---
 Library/Homebrew/test/resource_spec.rb | 147 +++++++++++++++++++++++++++++++++
 Library/Homebrew/test/resource_test.rb | 133 -----------------------------
 2 files changed, 147 insertions(+), 133 deletions(-)
 create mode 100644 Library/Homebrew/test/resource_spec.rb
 delete mode 100644 Library/Homebrew/test/resource_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/resource_spec.rb b/Library/Homebrew/test/resource_spec.rb
new file mode 100644
index 000000000..6a0419538
--- /dev/null
+++ b/Library/Homebrew/test/resource_spec.rb
@@ -0,0 +1,147 @@
+require "resource"
+
+describe Resource do
+  subject { described_class.new("test") }
+
+  describe "#url" do
+    it "sets the URL" do
+      subject.url("foo")
+      expect(subject.url).to eq("foo")
+    end
+
+    it "can set the URL with specifications" do
+      subject.url("foo", branch: "master")
+      expect(subject.url).to eq("foo")
+      expect(subject.specs).to eq(branch: "master")
+    end
+
+    it "can set the URL with a custom download strategy class" do
+      strategy = Class.new(AbstractDownloadStrategy)
+      subject.url("foo", using: strategy)
+      expect(subject.url).to eq("foo")
+      expect(subject.download_strategy).to eq(strategy)
+    end
+
+    it "can set the URL with specifications and a custom download strategy class" do
+      strategy = Class.new(AbstractDownloadStrategy)
+      subject.url("foo", using: strategy, branch: "master")
+      expect(subject.url).to eq("foo")
+      expect(subject.specs).to eq(branch: "master")
+      expect(subject.download_strategy).to eq(strategy)
+    end
+
+    it "can set the URL with a custom download strategy symbol" do
+      subject.url("foo", using: :git)
+      expect(subject.url).to eq("foo")
+      expect(subject.download_strategy).to eq(GitDownloadStrategy)
+    end
+
+    it "raises an error if the download strategy class is unkown" do
+      expect { subject.url("foo", using: Class.new) }.to raise_error(TypeError)
+    end
+
+    it "does not mutate the specifications hash" do
+      specs = { using: :git, branch: "master" }
+      subject.url("foo", specs)
+      expect(subject.specs).to eq(branch: "master")
+      expect(subject.using).to eq(:git)
+      expect(specs).to eq(using: :git, branch: "master")
+    end
+  end
+
+  describe "#version" do
+    it "sets the version" do
+      subject.version("1.0")
+      expect(subject.version).to eq(Version.parse("1.0"))
+      expect(subject.version).not_to be_detected_from_url
+    end
+
+    it "can detect the version from a URL" do
+      subject.url("http://example.com/foo-1.0.tar.gz")
+      expect(subject.version).to eq(Version.parse("1.0"))
+      expect(subject.version).to be_detected_from_url
+    end
+
+    it "can set the version with a scheme" do
+      klass = Class.new(Version)
+      subject.version klass.new("1.0")
+      expect(subject.version).to eq(Version.parse("1.0"))
+      expect(subject.version).to be_a(klass)
+    end
+
+    it "can set the version from a tag" do
+      subject.url("http://example.com/foo-1.0.tar.gz", tag: "v1.0.2")
+      expect(subject.version).to eq(Version.parse("1.0.2"))
+      expect(subject.version).to be_detected_from_url
+    end
+
+    it "rejects non-string versions" do
+      expect { subject.version(1) }.to raise_error(TypeError)
+      expect { subject.version(2.0) }.to raise_error(TypeError)
+      expect { subject.version(Object.new) }.to raise_error(TypeError)
+    end
+
+    it "returns nil if unset" do
+      expect(subject.version).to be nil
+    end
+  end
+
+  describe "#mirrors" do
+    it "is empty by defaults" do
+      expect(subject.mirrors).to be_empty
+    end
+
+    it "returns an array of mirrors added with #mirror" do
+      subject.mirror("foo")
+      subject.mirror("bar")
+      expect(subject.mirrors).to eq(%w[foo bar])
+    end
+  end
+
+  describe "#checksum" do
+    it "returns nil if unset" do
+      expect(subject.checksum).to be nil
+    end
+
+    it "returns the checksum set with #sha256" do
+      subject.sha256(TEST_SHA256)
+      expect(subject.checksum).to eq(Checksum.new(:sha256, TEST_SHA256))
+    end
+  end
+
+  describe "#download_strategy" do
+    it "returns the download strategy" do
+      strategy = Object.new
+      expect(DownloadStrategyDetector)
+        .to receive(:detect).with("foo", nil).and_return(strategy)
+      subject.url("foo")
+      expect(subject.download_strategy).to eq(strategy)
+    end
+  end
+
+  specify "#verify_download_integrity_missing" do
+    fn = Pathname.new("test")
+
+    allow(fn).to receive(:file?).and_return(true)
+    expect(fn).to receive(:verify_checksum).and_raise(ChecksumMissingError)
+    expect(fn).to receive(:sha256)
+
+    shutup do
+      subject.verify_download_integrity(fn)
+    end
+  end
+
+  specify "#verify_download_integrity_mismatch" do
+    fn = double(file?: true)
+    checksum = subject.sha256(TEST_SHA256)
+
+    expect(fn).to receive(:verify_checksum).with(checksum)
+      .and_raise(ChecksumMismatchError.new(fn, checksum, Object.new))
+
+    shutup do
+      expect {
+        subject.verify_download_integrity(fn)
+      }.to raise_error(ChecksumMismatchError)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/resource_test.rb b/Library/Homebrew/test/resource_test.rb
deleted file mode 100644
index d982a7c33..000000000
--- a/Library/Homebrew/test/resource_test.rb
+++ /dev/null
@@ -1,133 +0,0 @@
-require "testing_env"
-require "resource"
-
-class ResourceTests < Homebrew::TestCase
-  def setup
-    super
-    @resource = Resource.new("test")
-  end
-
-  def test_url
-    @resource.url("foo")
-    assert_equal "foo", @resource.url
-  end
-
-  def test_url_with_specs
-    @resource.url("foo", branch: "master")
-    assert_equal "foo", @resource.url
-    assert_equal({ branch: "master" }, @resource.specs)
-  end
-
-  def test_url_with_custom_download_strategy_class
-    strategy = Class.new(AbstractDownloadStrategy)
-    @resource.url("foo", using: strategy)
-    assert_equal "foo", @resource.url
-    assert_equal strategy, @resource.download_strategy
-  end
-
-  def test_url_with_specs_and_download_strategy
-    strategy = Class.new(AbstractDownloadStrategy)
-    @resource.url("foo", using: strategy, branch: "master")
-    assert_equal "foo", @resource.url
-    assert_equal({ branch: "master" }, @resource.specs)
-    assert_equal strategy, @resource.download_strategy
-  end
-
-  def test_url_with_custom_download_strategy_symbol
-    @resource.url("foo", using: :git)
-    assert_equal "foo", @resource.url
-    assert_equal GitDownloadStrategy, @resource.download_strategy
-  end
-
-  def test_raises_for_unknown_download_strategy_class
-    assert_raises(TypeError) { @resource.url("foo", using: Class.new) }
-  end
-
-  def test_does_not_mutate_specs_hash
-    specs = { using: :git, branch: "master" }
-    @resource.url("foo", specs)
-    assert_equal({ branch: "master" }, @resource.specs)
-    assert_equal(:git, @resource.using)
-    assert_equal({ using: :git, branch: "master" }, specs)
-  end
-
-  def test_version
-    @resource.version("1.0")
-    assert_version_equal "1.0", @resource.version
-    refute_predicate @resource.version, :detected_from_url?
-  end
-
-  def test_version_from_url
-    @resource.url("http://example.com/foo-1.0.tar.gz")
-    assert_version_equal "1.0", @resource.version
-    assert_predicate @resource.version, :detected_from_url?
-  end
-
-  def test_version_with_scheme
-    klass = Class.new(Version)
-    @resource.version klass.new("1.0")
-    assert_version_equal "1.0", @resource.version
-    assert_instance_of klass, @resource.version
-  end
-
-  def test_version_from_tag
-    @resource.url("http://example.com/foo-1.0.tar.gz", tag: "v1.0.2")
-    assert_version_equal "1.0.2", @resource.version
-    assert_predicate @resource.version, :detected_from_url?
-  end
-
-  def test_rejects_non_string_versions
-    assert_raises(TypeError) { @resource.version(1) }
-    assert_raises(TypeError) { @resource.version(2.0) }
-    assert_raises(TypeError) { @resource.version(Object.new) }
-  end
-
-  def test_version_when_url_is_not_set
-    assert_nil @resource.version
-  end
-
-  def test_mirrors
-    assert_empty @resource.mirrors
-    @resource.mirror("foo")
-    @resource.mirror("bar")
-    assert_equal %w[foo bar], @resource.mirrors
-  end
-
-  def test_checksum_setters
-    assert_nil @resource.checksum
-    @resource.sha256(TEST_SHA256)
-    assert_equal Checksum.new(:sha256, TEST_SHA256), @resource.checksum
-  end
-
-  def test_download_strategy
-    strategy = Object.new
-    DownloadStrategyDetector
-      .expects(:detect).with("foo", nil).returns(strategy)
-    @resource.url("foo")
-    assert_equal strategy, @resource.download_strategy
-  end
-
-  def test_verify_download_integrity_missing
-    fn = Pathname.new("test")
-
-    fn.stubs(file?: true)
-    fn.expects(:verify_checksum).raises(ChecksumMissingError)
-    fn.expects(:sha256)
-
-    shutup { @resource.verify_download_integrity(fn) }
-  end
-
-  def test_verify_download_integrity_mismatch
-    fn = stub(file?: true)
-    checksum = @resource.sha256(TEST_SHA256)
-
-    fn.expects(:verify_checksum).with(checksum)
-      .raises(ChecksumMismatchError.new(fn, checksum, Object.new))
-
-    shutup do
-      assert_raises(ChecksumMismatchError) do
-        @resource.verify_download_integrity(fn)
-      end
-    end
-  end
-end
-- 
cgit v1.2.3


From 7393485b7b2f15b84506d1c7f7d157db545aa18f Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 22:51:37 +0100
Subject: Convert `dependency_expansion` test to spec.

---
 Library/Homebrew/test/dependency_expansion_spec.rb | 136 ++++++++++++++++++++
 Library/Homebrew/test/dependency_expansion_test.rb | 138 ---------------------
 2 files changed, 136 insertions(+), 138 deletions(-)
 create mode 100644 Library/Homebrew/test/dependency_expansion_spec.rb
 delete mode 100644 Library/Homebrew/test/dependency_expansion_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/dependency_expansion_spec.rb b/Library/Homebrew/test/dependency_expansion_spec.rb
new file mode 100644
index 000000000..f955237a9
--- /dev/null
+++ b/Library/Homebrew/test/dependency_expansion_spec.rb
@@ -0,0 +1,136 @@
+require "dependency"
+
+describe Dependency do
+  def build_dep(name, tags = [], deps = [])
+    dep = described_class.new(name.to_s, tags)
+    allow(dep).to receive(:to_formula).and_return(double(deps: deps, name: name))
+    dep
+  end
+
+  let(:foo) { build_dep(:foo) }
+  let(:bar) { build_dep(:bar) }
+  let(:baz) { build_dep(:baz) }
+  let(:qux) { build_dep(:qux) }
+  let(:deps) { [foo, bar, baz, qux] }
+  let(:formula) { double(deps: deps, name: "f") }
+
+  describe "::expand" do
+    it "yields dependent and dependency pairs" do
+      i = 0
+      described_class.expand(formula) do |dependent, dep|
+        expect(dependent).to eq(formula)
+        expect(deps[i]).to eq(dep)
+        i += 1
+      end
+    end
+
+    it "returns the dependencies" do
+      expect(described_class.expand(formula)).to eq(deps)
+    end
+
+    it "prunes all when given a block with ::prune" do
+      expect(described_class.expand(formula) { described_class.prune }).to be_empty
+    end
+
+    it "can prune selectively" do
+      deps = described_class.expand(formula) do |_, dep|
+        described_class.prune if dep.name == "foo"
+      end
+
+      expect(deps).to eq([bar, baz, qux])
+    end
+
+    it "preserves dependency order" do
+      allow(foo).to receive(:to_formula).and_return(double(name: "f", deps: [qux, baz]))
+      expect(described_class.expand(formula)).to eq([qux, baz, foo, bar])
+    end
+  end
+
+  it "skips optionals by default" do
+    deps = [build_dep(:foo, [:optional]), bar, baz, qux]
+    f = double(deps: deps, build: double(with?: false), name: "f")
+    expect(described_class.expand(f)).to eq([bar, baz, qux])
+  end
+
+  it "keeps recommended dependencies by default" do
+    deps = [build_dep(:foo, [:recommended]), bar, baz, qux]
+    f = double(deps: deps, build: double(with?: true), name: "f")
+    expect(described_class.expand(f)).to eq(deps)
+  end
+
+  it "merges repeated dependencies with differing options" do
+    foo2 = build_dep(:foo, ["option"])
+    baz2 = build_dep(:baz, ["option"])
+    deps << foo2 << baz2
+    deps = [foo2, bar, baz2, qux]
+    deps.zip(described_class.expand(formula)) do |expected, actual|
+      expect(expected.tags).to eq(actual.tags)
+      expect(expected).to eq(actual)
+    end
+  end
+
+  it "merges dependencies and perserves env_proc" do
+    env_proc = double
+    dep = described_class.new("foo", [], env_proc)
+    allow(dep).to receive(:to_formula).and_return(double(deps: [], name: "foo"))
+    deps.replace([dep])
+    expect(described_class.expand(formula).first.env_proc).to eq(env_proc)
+  end
+
+  it "merges tags without duplicating them" do
+    foo2 = build_dep(:foo, ["option"])
+    foo3 = build_dep(:foo, ["option"])
+    deps << foo2 << foo3
+
+    expect(described_class.expand(formula).first.tags).to eq(%w[option])
+  end
+
+  it "skips parent but yields children with ::skip" do
+    f = double(
+      name: "f",
+      deps: [
+        build_dep(:foo, [], [bar, baz]),
+        build_dep(:foo, [], [baz]),
+      ],
+    )
+
+    deps = described_class.expand(f) do |_dependent, dep|
+      described_class.skip if %w[foo qux].include? dep.name
+    end
+
+    expect(deps).to eq([bar, baz])
+  end
+
+  it "keeps dependency but prunes recursive dependencies with ::keep_but_prune_recursive_deps" do
+    foo = build_dep(:foo, [:build], bar)
+    baz = build_dep(:baz, [:build])
+    f = double(name: "f", deps: [foo, baz])
+
+    deps = described_class.expand(f) do |_dependent, dep|
+      described_class.keep_but_prune_recursive_deps if dep.build?
+    end
+
+    expect(deps).to eq([foo, baz])
+  end
+
+  it "returns only the dependencies given as a collection as second argument" do
+    expect(formula.deps).to eq([foo, bar, baz, qux])
+    expect(described_class.expand(formula, [bar, baz])).to eq([bar, baz])
+  end
+
+  it "doesn't raise an error when a dependency is cyclic" do
+    foo = build_dep(:foo)
+    bar = build_dep(:bar, [], [foo])
+    allow(foo).to receive(:to_formula).and_return(double(deps: [bar], name: foo.name))
+    f = double(name: "f", deps: [foo, bar])
+    expect { described_class.expand(f) }.not_to raise_error
+  end
+
+  it "cleans the expand stack" do
+    foo = build_dep(:foo)
+    allow(foo).to receive(:to_formula).and_raise(FormulaUnavailableError, foo.name)
+    f = double(name: "f", deps: [foo])
+    expect { described_class.expand(f) }.to raise_error(FormulaUnavailableError)
+    expect(described_class.instance_variable_get(:@expand_stack)).to be_empty
+  end
+end
diff --git a/Library/Homebrew/test/dependency_expansion_test.rb b/Library/Homebrew/test/dependency_expansion_test.rb
deleted file mode 100644
index 58a731121..000000000
--- a/Library/Homebrew/test/dependency_expansion_test.rb
+++ /dev/null
@@ -1,138 +0,0 @@
-require "testing_env"
-require "dependency"
-
-class DependencyExpansionTests < Homebrew::TestCase
-  def build_dep(name, tags = [], deps = [])
-    dep = Dependency.new(name.to_s, tags)
-    dep.stubs(:to_formula).returns(stub(deps: deps, name: name))
-    dep
-  end
-
-  def setup
-    super
-    @foo = build_dep(:foo)
-    @bar = build_dep(:bar)
-    @baz = build_dep(:baz)
-    @qux = build_dep(:qux)
-    @deps = [@foo, @bar, @baz, @qux]
-    @f    = stub(deps: @deps, name: "f")
-  end
-
-  def test_expand_yields_dependent_and_dep_pairs
-    i = 0
-    Dependency.expand(@f) do |dependent, dep|
-      assert_equal @f, dependent
-      assert_equal dep, @deps[i]
-      i += 1
-    end
-  end
-
-  def test_expand_no_block
-    assert_equal @deps, Dependency.expand(@f)
-  end
-
-  def test_expand_prune_all
-    assert_empty Dependency.expand(@f) { Dependency.prune }
-  end
-
-  def test_expand_selective_pruning
-    deps = Dependency.expand(@f) do |_, dep|
-      Dependency.prune if dep.name == "foo"
-    end
-
-    assert_equal [@bar, @baz, @qux], deps
-  end
-
-  def test_expand_preserves_dependency_order
-    @foo.stubs(:to_formula).returns(stub(name: "f", deps: [@qux, @baz]))
-    assert_equal [@qux, @baz, @foo, @bar], Dependency.expand(@f)
-  end
-
-  def test_expand_skips_optionals_by_default
-    deps = [build_dep(:foo, [:optional]), @bar, @baz, @qux]
-    f = stub(deps: deps, build: stub(with?: false), name: "f")
-    assert_equal [@bar, @baz, @qux], Dependency.expand(f)
-  end
-
-  def test_expand_keeps_recommendeds_by_default
-    deps = [build_dep(:foo, [:recommended]), @bar, @baz, @qux]
-    f = stub(deps: deps, build: stub(with?: true), name: "f")
-    assert_equal deps, Dependency.expand(f)
-  end
-
-  def test_merges_repeated_deps_with_differing_options
-    @foo2 = build_dep(:foo, ["option"])
-    @baz2 = build_dep(:baz, ["option"])
-    @deps << @foo2 << @baz2
-    deps = [@foo2, @bar, @baz2, @qux]
-    deps.zip(Dependency.expand(@f)) do |expected, actual|
-      assert_equal expected.tags, actual.tags
-      assert_equal expected, actual
-    end
-  end
-
-  def test_merger_preserves_env_proc
-    env_proc = stub
-    dep = Dependency.new("foo", [], env_proc)
-    dep.stubs(:to_formula).returns(stub(deps: [], name: "foo"))
-    @deps.replace [dep]
-    assert_equal env_proc, Dependency.expand(@f).first.env_proc
-  end
-
-  def test_merged_tags_no_dupes
-    @foo2 = build_dep(:foo, ["option"])
-    @foo3 = build_dep(:foo, ["option"])
-    @deps << @foo2 << @foo3
-
-    assert_equal %w[option], Dependency.expand(@f).first.tags
-  end
-
-  def test_skip_skips_parent_but_yields_children
-    f = stub(
-      name: "f",
-      deps: [
-        build_dep(:foo, [], [@bar, @baz]),
-        build_dep(:foo, [], [@baz]),
-      ],
-    )
-
-    deps = Dependency.expand(f) do |_dependent, dep|
-      Dependency.skip if %w[foo qux].include? dep.name
-    end
-
-    assert_equal [@bar, @baz], deps
-  end
-
-  def test_keep_dep_but_prune_recursive_deps
-    foo = build_dep(:foo, [:build], @bar)
-    baz = build_dep(:baz, [:build])
-    f = stub(name: "f", deps: [foo, baz])
-
-    deps = Dependency.expand(f) do |_dependent, dep|
-      Dependency.keep_but_prune_recursive_deps if dep.build?
-    end
-
-    assert_equal [foo, baz], deps
-  end
-
-  def test_deps_with_collection_argument
-    assert_equal [@foo, @bar, @baz, @qux], @f.deps
-    assert_equal [@bar, @baz], Dependency.expand(@f, [@bar, @baz])
-  end
-
-  def test_cyclic_dependency
-    foo = build_dep(:foo)
-    bar = build_dep(:bar, [], [foo])
-    foo.stubs(:to_formula).returns(stub(deps: [bar], name: "foo"))
-    f = stub(name: "f", deps: [foo, bar])
-    assert_nothing_raised { Dependency.expand(f) }
-  end
-
-  def test_clean_expand_stack
-    foo = build_dep(:foo)
-    foo.stubs(:to_formula).raises(FormulaUnavailableError, "foo")
-    f = stub(name: "f", deps: [foo])
-    assert_raises(FormulaUnavailableError) { Dependency.expand(f) }
-    assert_empty Dependency.instance_variable_get(:@expand_stack)
-  end
-end
-- 
cgit v1.2.3


From b4a2fe502cc8bef717e9f52efe5926cc27d1e9a6 Mon Sep 17 00:00:00 2001
From: Kimmo Lehto
Date: Wed, 22 Feb 2017 09:21:31 +0200
Subject: Proposed changes

---
 Library/Homebrew/requirements/ruby_requirement.rb | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/requirements/ruby_requirement.rb b/Library/Homebrew/requirements/ruby_requirement.rb
index 0caedb5ca..327c13170 100644
--- a/Library/Homebrew/requirements/ruby_requirement.rb
+++ b/Library/Homebrew/requirements/ruby_requirement.rb
@@ -8,10 +8,10 @@ class RubyRequirement < Requirement
     super
   end
 
-  satisfy(build_env: false) { suitable_ruby }
+  satisfy(build_env: false) { new_enough_ruby }
 
   env do
-    ENV.prepend_path "PATH", suitable_ruby
+    ENV.prepend_path "PATH", new_enough_ruby
   end
 
   def message
@@ -34,19 +34,20 @@ class RubyRequirement < Requirement
 
   private
 
-  def suitable_ruby
-    rubies.detect { |ruby| suitable?(ruby) }
+  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 Pathname.new(ruby_formula.bin/"ruby")
+      rubies.unshift ruby_formula.bin/"ruby"
     end
     rubies.uniq
   end
 
-  def suitable?(ruby)
+  def new_enough?(ruby)
     version = Utils.popen_read(ruby, "-e", "print RUBY_VERSION").strip
     version =~ /^\d+\.\d+/ && Version.create(version) >= min_version
   end
@@ -54,11 +55,4 @@ class RubyRequirement < Requirement
   def min_version
     @min_version ||= Version.create(@version)
   end
-
-  def ruby_formula
-    @ruby_formula ||= Formula["ruby"]
-  rescue FormulaUnavailableError
-    nil
-  end
-
 end
-- 
cgit v1.2.3


From ac5b6b6eeaec7b6ee2fb79a28d69c6036ee49299 Mon Sep 17 00:00:00 2001
From: Mike McQuaid
Date: Wed, 22 Feb 2017 08:49:24 +0000
Subject: Revert "audit: fix revision should be removed."

---
 Library/Homebrew/dev-cmd/audit.rb | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/dev-cmd/audit.rb b/Library/Homebrew/dev-cmd/audit.rb
index d4d6a6d72..9ffef0f99 100644
--- a/Library/Homebrew/dev-cmd/audit.rb
+++ b/Library/Homebrew/dev-cmd/audit.rb
@@ -794,12 +794,10 @@ class FormulaAuditor
 
     return if formula.revision.zero?
     if formula.stable
-      if revision_map = attributes_map[:revision][:stable]
-        stable_revisions = revision_map[formula.stable.version]
-        stable_revisions -= [formula.revision]
-        if stable_revisions.empty?
-          problem "'revision #{formula.revision}' should be removed"
-        end
+      revision_map = attributes_map[:revision][:stable]
+      stable_revisions = revision_map[formula.stable.version] if revision_map
+      if !stable_revisions || stable_revisions.empty?
+        problem "'revision #{formula.revision}' should be removed"
       end
     else # head/devel-only formula
       problem "'revision #{formula.revision}' should be removed"
-- 
cgit v1.2.3


From e793e526611ca4cbc6d0155af8c596c4e826fc41 Mon Sep 17 00:00:00 2001
From: Mike McQuaid
Date: Wed, 22 Feb 2017 08:49:49 +0000
Subject: Revert "formula_versions: handle uncommitted formulae."

---
 Library/Homebrew/formula_versions.rb | 29 ++++++++++-------------------
 1 file changed, 10 insertions(+), 19 deletions(-)

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/formula_versions.rb b/Library/Homebrew/formula_versions.rb
index 34b766fde..28c2a3be8 100644
--- a/Library/Homebrew/formula_versions.rb
+++ b/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
-- 
cgit v1.2.3


From 48a211fc90d3b53db3fb2f76d454ee64cab0cdf7 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 06:17:06 +0100
Subject: Convert `os/mac/language` test to spec.

---
 Library/Homebrew/dev-cmd/tests.rb             |  4 +---
 Library/Homebrew/test/os/mac/language_test.rb | 19 -------------------
 Library/Homebrew/test/os/mac_spec.rb          | 22 ++++++++++++++++++++++
 3 files changed, 23 insertions(+), 22 deletions(-)
 delete mode 100644 Library/Homebrew/test/os/mac/language_test.rb
 create mode 100644 Library/Homebrew/test/os/mac_spec.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/dev-cmd/tests.rb b/Library/Homebrew/dev-cmd/tests.rb
index 244fbe027..9cabb3d61 100644
--- a/Library/Homebrew/dev-cmd/tests.rb
+++ b/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"
diff --git a/Library/Homebrew/test/os/mac/language_test.rb b/Library/Homebrew/test/os/mac/language_test.rb
deleted file mode 100644
index e328db5e0..000000000
--- a/Library/Homebrew/test/os/mac/language_test.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-require "testing_env"
-require "locale"
-require "os/mac"
-
-class OSMacLanguageTests < Homebrew::TestCase
-  def test_languages_format
-    OS::Mac.languages.each do |language|
-      assert_nothing_raised do
-        Locale.parse(language)
-      end
-    end
-  end
-
-  def test_language_format
-    assert_nothing_raised do
-      Locale.parse(OS::Mac.language)
-    end
-  end
-end
diff --git a/Library/Homebrew/test/os/mac_spec.rb b/Library/Homebrew/test/os/mac_spec.rb
new file mode 100644
index 000000000..641782451
--- /dev/null
+++ b/Library/Homebrew/test/os/mac_spec.rb
@@ -0,0 +1,22 @@
+require "locale"
+require "os/mac"
+
+describe OS::Mac do
+  describe "::languages" do
+    specify "all languages can be parsed by Locale::parse" do
+      subject.languages.each do |language|
+        expect { Locale.parse(language) }.not_to raise_error
+      end
+    end
+  end
+
+  describe "::language" do
+    it "returns the first item from #languages" do
+      expect(subject.language).to eq(subject.languages.first)
+    end
+
+    it "can be parsed by Locale::parse" do
+      expect { Locale.parse(subject.language) }.not_to raise_error
+    end
+  end
+end
-- 
cgit v1.2.3


From 85ff9add185fc24d99b296cf9cca3071b6d865c0 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Wed, 15 Feb 2017 02:02:25 +0100
Subject: Convert Pathname test to spec.

---
 Library/Homebrew/test/pathname_spec.rb | 300 +++++++++++++++++++++++++++++++++
 Library/Homebrew/test/pathname_test.rb | 263 -----------------------------
 2 files changed, 300 insertions(+), 263 deletions(-)
 create mode 100644 Library/Homebrew/test/pathname_spec.rb
 delete mode 100644 Library/Homebrew/test/pathname_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/pathname_spec.rb b/Library/Homebrew/test/pathname_spec.rb
new file mode 100644
index 000000000..da12d4347
--- /dev/null
+++ b/Library/Homebrew/test/pathname_spec.rb
@@ -0,0 +1,300 @@
+require "tmpdir"
+require "extend/pathname"
+require "install_renamed"
+
+describe Pathname do
+  include FileUtils
+
+  let(:src) { Pathname.new(Dir.mktmpdir) }
+  let(:dst) { Pathname.new(Dir.mktmpdir) }
+  let(:file) { src/"foo" }
+  let(:dir) { src/"bar" }
+
+  after(:each) { rm_rf [src, dst] }
+
+  describe DiskUsageExtension do
+    before(:each) do
+      mkdir_p dir/"a-directory"
+      touch [dir/".DS_Store", dir/"a-file"]
+      File.truncate(dir/"a-file", 1_048_576)
+      ln_s dir/"a-file", dir/"a-symlink"
+      ln dir/"a-file", dir/"a-hardlink"
+    end
+
+    describe "#file_count" do
+      it "returns the number of files in a directory" do
+        expect(dir.file_count).to eq(3)
+      end
+    end
+
+    describe "#abv" do
+      context "when called on a directory" do
+        it "returns a string with the file count and disk usage" do
+          expect(dir.abv).to eq("3 files, 1M")
+        end
+      end
+
+      context "when called on a file" do
+        it "returns the disk usage" do
+          expect((dir/"a-file").abv).to eq("1M")
+        end
+      end
+    end
+  end
+
+  describe "#rmdir_if_possible" do
+    before(:each) { mkdir_p dir }
+
+    it "returns true and removes a directory if it doesn't contain files" do
+      expect(dir.rmdir_if_possible).to be true
+      expect(dir).not_to exist
+    end
+
+    it "returns false and doesn't delete a directory if it contains files" do
+      touch dir/"foo"
+      expect(dir.rmdir_if_possible).to be false
+      expect(dir).to be_a_directory
+    end
+
+    it "ignores .DS_Store files" do
+      touch dir/".DS_Store"
+      expect(dir.rmdir_if_possible).to be true
+      expect(dir).not_to exist
+    end
+  end
+
+  describe "#write" do
+    it "creates a file and writes to it" do
+      expect(file).not_to exist
+      file.write("CONTENT")
+      expect(File.read(file)).to eq("CONTENT")
+    end
+
+    it "raises an error if the file already exists" do
+      touch file
+      expect { file.write("CONTENT") }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe "#append_lines" do
+    it "appends lines to a file" do
+      touch file
+
+      file.append_lines("CONTENT")
+      expect(File.read(file)).to eq <<-EOS.undent
+        CONTENT
+      EOS
+
+      file.append_lines("CONTENTS")
+      expect(File.read(file)).to eq <<-EOS.undent
+        CONTENT
+        CONTENTS
+      EOS
+    end
+
+    it "raises an error if the file does not exist" do
+      expect(file).not_to exist
+      expect { file.append_lines("CONTENT") }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe "#atomic_write" do
+    it "atomically replaces a file" do
+      touch file
+      file.atomic_write("CONTENT")
+      expect(File.read(file)).to eq("CONTENT")
+    end
+
+    it "preserves permissions" do
+      File.open(file, "w", 0100777).close
+      file.atomic_write("CONTENT")
+      expect(file.stat.mode).to eq(0100777 & ~File.umask)
+    end
+
+    it "preserves default permissions" do
+      file.atomic_write("CONTENT")
+      sentinel = file.parent.join("sentinel")
+      touch sentinel
+      expect(file.stat.mode).to eq(sentinel.stat.mode)
+    end
+  end
+
+  describe "#ensure_writable" do
+    it "makes a file writable and restores permissions afterwards" do
+      touch file
+      chmod 0555, file
+      expect(file).not_to be_writable
+      file.ensure_writable do
+        expect(file).to be_writable
+      end
+      expect(file).not_to be_writable
+    end
+  end
+
+  describe "#extname" do
+    it "supports common multi-level archives" do
+      expect(Pathname.new("foo-0.1.tar.gz").extname).to eq(".tar.gz")
+      expect(Pathname.new("foo-0.1.cpio.gz").extname).to eq(".cpio.gz")
+    end
+  end
+
+  describe "#stem" do
+    it "returns the basename without double extensions" do
+      expect(Pathname("foo-0.1.tar.gz").stem).to eq("foo-0.1")
+      expect(Pathname("foo-0.1.cpio.gz").stem).to eq("foo-0.1")
+    end
+  end
+
+  describe "#install" do
+    before(:each) do
+      (src/"a.txt").write "This is sample file a."
+      (src/"b.txt").write "This is sample file b."
+    end
+
+    it "raises an error if the file doesn't exist" do
+      expect { dst.install "non_existent_file" }.to raise_error(Errno::ENOENT)
+    end
+
+    it "installs a file to a directory with its basename" do
+      touch file
+      dst.install(file)
+      expect(dst/file.basename).to exist
+      expect(file).not_to exist
+    end
+
+    it "creates intermediate directories" do
+      touch file
+      expect(dir).not_to be_a_directory
+      dir.install(file)
+      expect(dir).to be_a_directory
+    end
+
+    it "can install a file" do
+      dst.install src/"a.txt"
+      expect(dst/"a.txt").to exist, "a.txt was not installed"
+      expect(dst/"b.txt").not_to exist, "b.txt was installed."
+    end
+
+    it "can install an array of files" do
+      dst.install [src/"a.txt", src/"b.txt"]
+
+      expect(dst/"a.txt").to exist, "a.txt was not installed"
+      expect(dst/"b.txt").to exist, "b.txt was not installed"
+    end
+
+    it "can install a directory" do
+      bin = src/"bin"
+      bin.mkpath
+      mv Dir[src/"*.txt"], bin
+      dst.install bin
+
+      expect(dst/"bin/a.txt").to exist, "a.txt was not installed"
+      expect(dst/"bin/b.txt").to exist, "b.txt was not installed"
+    end
+
+    it "supports renaming files" do
+      dst.install src/"a.txt" => "c.txt"
+
+      expect(dst/"c.txt").to exist, "c.txt was not installed"
+      expect(dst/"a.txt").not_to exist, "a.txt was installed but not renamed"
+      expect(dst/"b.txt").not_to exist, "b.txt was installed"
+    end
+
+    it "supports renaming multiple files" do
+      dst.install(src/"a.txt" => "c.txt", src/"b.txt" => "d.txt")
+
+      expect(dst/"c.txt").to exist, "c.txt was not installed"
+      expect(dst/"d.txt").to exist, "d.txt was not installed"
+      expect(dst/"a.txt").not_to exist, "a.txt was installed but not renamed"
+      expect(dst/"b.txt").not_to exist, "b.txt was installed but not renamed"
+    end
+
+    it "supports renaming directories" do
+      bin = src/"bin"
+      bin.mkpath
+      mv Dir[src/"*.txt"], bin
+      dst.install bin => "libexec"
+
+      expect(dst/"bin").not_to exist, "bin was installed but not renamed"
+      expect(dst/"libexec/a.txt").to exist, "a.txt was not installed"
+      expect(dst/"libexec/b.txt").to exist, "b.txt was not installed"
+    end
+
+    it "can install directories as relative symlinks" do
+      bin = src/"bin"
+      bin.mkpath
+      mv Dir[src/"*.txt"], bin
+      dst.install_symlink bin
+
+      expect(dst/"bin").to be_a_symlink
+      expect(dst/"bin").to be_a_directory
+      expect(dst/"bin/a.txt").to exist
+      expect(dst/"bin/b.txt").to exist
+      expect((dst/"bin").readlink).to be_relative
+    end
+
+    it "can install relative paths as symlinks" do
+      dst.install_symlink "foo" => "bar"
+      expect((dst/"bar").readlink).to eq(Pathname.new("foo"))
+    end
+  end
+
+  describe InstallRenamed do
+    before(:each) do
+      dst.extend(InstallRenamed)
+    end
+
+    it "renames the installed file if it already exists" do
+      file.write "a"
+      dst.install file
+
+      file.write "b"
+      dst.install file
+
+      expect(File.read(dst/file.basename)).to eq("a")
+      expect(File.read(dst/"#{file.basename}.default")).to eq("b")
+    end
+
+    it "renames the installed directory" do
+      file.write "a"
+      dst.install src
+      expect(File.read(dst/src.basename/file.basename)).to eq("a")
+    end
+
+    it "recursively renames directories" do
+      (dst/dir.basename).mkpath
+      (dst/dir.basename/"another_file").write "a"
+      dir.mkpath
+      (dir/"another_file").write "b"
+      dst.install dir
+      expect(File.read(dst/dir.basename/"another_file.default")).to eq("b")
+    end
+  end
+
+  describe "#cp_path_sub" do
+    it "copies a file and replaces the given pattern" do
+      file.write "a"
+      file.cp_path_sub src, dst
+      expect(File.read(dst/file.basename)).to eq("a")
+    end
+
+    it "copies a directory and replaces the given pattern" do
+      dir.mkpath
+      dir.cp_path_sub src, dst
+      expect(dst/dir.basename).to be_a_directory
+    end
+  end
+end
+
+describe FileUtils do
+  let(:dst) { Pathname.new(Dir.mktmpdir) }
+
+  describe "#mkdir" do
+    it "creates indermediate directories" do
+      described_class.mkdir dst/"foo/bar/baz" do
+        expect(dst/"foo/bar/baz").to exist, "foo/bar/baz was not created"
+        expect(dst/"foo/bar/baz").to be_a_directory, "foo/bar/baz was not a directory structure"
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/pathname_test.rb b/Library/Homebrew/test/pathname_test.rb
deleted file mode 100644
index b48a26fbd..000000000
--- a/Library/Homebrew/test/pathname_test.rb
+++ /dev/null
@@ -1,263 +0,0 @@
-require "testing_env"
-require "tmpdir"
-require "extend/pathname"
-require "install_renamed"
-
-module PathnameTestExtension
-  include FileUtils
-
-  def setup
-    super
-    @src  = Pathname.new(mktmpdir)
-    @dst  = Pathname.new(mktmpdir)
-    @file = @src/"foo"
-    @dir  = @src/"bar"
-  end
-end
-
-class PathnameTests < Homebrew::TestCase
-  include PathnameTestExtension
-
-  def test_disk_usage_extension
-    mkdir_p @dir/"a-directory"
-    touch @dir/".DS_Store"
-    touch @dir/"a-file"
-    File.truncate(@dir/"a-file", 1_048_576)
-    ln_s @dir/"a-file", @dir/"a-symlink"
-    ln @dir/"a-file", @dir/"a-hardlink"
-    assert_equal 3, @dir.file_count
-    assert_equal "3 files, 1M", @dir.abv
-    assert_equal "1M", (@dir/"a-file").abv
-  end
-
-  def test_rmdir_if_possible
-    mkdir_p @dir
-    touch @dir/"foo"
-
-    assert !@dir.rmdir_if_possible
-    assert_predicate @dir, :directory?
-
-    rm_f @dir/"foo"
-    assert @dir.rmdir_if_possible
-    refute_predicate @dir, :exist?
-  end
-
-  def test_rmdir_if_possible_ignore_ds_store
-    mkdir_p @dir
-    touch @dir/".DS_Store"
-    assert @dir.rmdir_if_possible
-    refute_predicate @dir, :exist?
-  end
-
-  def test_write
-    @file.write("CONTENT")
-    assert_equal "CONTENT", File.read(@file)
-  end
-
-  def test_write_does_not_overwrite
-    touch @file
-    assert_raises(RuntimeError) { @file.write("CONTENT") }
-  end
-
-  def test_append_lines
-    touch @file
-    @file.append_lines("CONTENT")
-    assert_equal "CONTENT\n", File.read(@file)
-    @file.append_lines("CONTENTS")
-    assert_equal "CONTENT\nCONTENTS\n", File.read(@file)
-  end
-
-  def test_append_lines_does_not_create
-    assert_raises(RuntimeError) { @file.append_lines("CONTENT") }
-  end
-
-  def test_atomic_write
-    touch @file
-    @file.atomic_write("CONTENT")
-    assert_equal "CONTENT", File.read(@file)
-  end
-
-  def test_atomic_write_preserves_permissions
-    File.open(@file, "w", 0100777) {}
-    @file.atomic_write("CONTENT")
-    assert_equal 0100777 & ~File.umask, @file.stat.mode
-  end
-
-  def test_atomic_write_preserves_default_permissions
-    @file.atomic_write("CONTENT")
-    sentinel = @file.parent.join("sentinel")
-    touch sentinel
-    assert_equal sentinel.stat.mode, @file.stat.mode
-  end
-
-  def test_ensure_writable
-    touch @file
-    chmod 0555, @file
-    @file.ensure_writable { assert_predicate @file, :writable? }
-    refute_predicate @file, :writable?
-  end
-
-  def test_extname
-    assert_equal ".tar.gz", Pathname("foo-0.1.tar.gz").extname
-    assert_equal ".cpio.gz", Pathname("foo-0.1.cpio.gz").extname
-  end
-
-  def test_stem
-    assert_equal "foo-0.1", Pathname("foo-0.1.tar.gz").stem
-    assert_equal "foo-0.1", Pathname("foo-0.1.cpio.gz").stem
-  end
-
-  def test_install_missing_file
-    assert_raises(Errno::ENOENT) { @dst.install "non_existent_file" }
-  end
-
-  def test_install_removes_original
-    touch @file
-    @dst.install(@file)
-
-    assert_predicate @dst/@file.basename, :exist?
-    refute_predicate @file, :exist?
-  end
-
-  def test_install_creates_intermediate_directories
-    touch @file
-    refute_predicate @dir, :directory?
-    @dir.install(@file)
-    assert_predicate @dir, :directory?
-  end
-
-  def test_install_renamed
-    @dst.extend(InstallRenamed)
-
-    @file.write "a"
-    @dst.install @file
-    @file.write "b"
-    @dst.install @file
-
-    assert_equal "a", File.read(@dst/@file.basename)
-    assert_equal "b", File.read(@dst/"#{@file.basename}.default")
-  end
-
-  def test_install_renamed_directory
-    @dst.extend(InstallRenamed)
-    @file.write "a"
-    @dst.install @src
-    assert_equal "a", File.read(@dst/@src.basename/@file.basename)
-  end
-
-  def test_install_renamed_directory_recursive
-    @dst.extend(InstallRenamed)
-    (@dst/@dir.basename).mkpath
-    (@dst/@dir.basename/"another_file").write "a"
-    @dir.mkpath
-    (@dir/"another_file").write "b"
-    @dst.install @dir
-    assert_equal "b", File.read(@dst/@dir.basename/"another_file.default")
-  end
-
-  def test_cp_path_sub_file
-    @file.write "a"
-    @file.cp_path_sub @src, @dst
-    assert_equal "a", File.read(@dst/"foo")
-  end
-
-  def test_cp_path_sub_directory
-    @dir.mkpath
-    @dir.cp_path_sub @src, @dst
-    assert_predicate @dst/@dir.basename, :directory?
-  end
-end
-
-class PathnameInstallTests < Homebrew::TestCase
-  include PathnameTestExtension
-
-  def setup
-    super
-    (@src/"a.txt").write "This is sample file a."
-    (@src/"b.txt").write "This is sample file b."
-  end
-
-  def test_install
-    @dst.install @src/"a.txt"
-
-    assert_predicate @dst/"a.txt", :exist?, "a.txt was not installed"
-    refute_predicate @dst/"b.txt", :exist?, "b.txt was installed."
-  end
-
-  def test_install_list
-    @dst.install [@src/"a.txt", @src/"b.txt"]
-
-    assert_predicate @dst/"a.txt", :exist?, "a.txt was not installed"
-    assert_predicate @dst/"b.txt", :exist?, "b.txt was not installed"
-  end
-
-  def test_install_glob
-    @dst.install Dir[@src/"*.txt"]
-
-    assert_predicate @dst/"a.txt", :exist?, "a.txt was not installed"
-    assert_predicate @dst/"b.txt", :exist?, "b.txt was not installed"
-  end
-
-  def test_install_directory
-    bin = @src/"bin"
-    bin.mkpath
-    mv Dir[@src/"*.txt"], bin
-    @dst.install bin
-
-    assert_predicate @dst/"bin/a.txt", :exist?, "a.txt was not installed"
-    assert_predicate @dst/"bin/b.txt", :exist?, "b.txt was not installed"
-  end
-
-  def test_install_rename
-    @dst.install @src/"a.txt" => "c.txt"
-
-    assert_predicate @dst/"c.txt", :exist?, "c.txt was not installed"
-    refute_predicate @dst/"a.txt", :exist?, "a.txt was installed but not renamed"
-    refute_predicate @dst/"b.txt", :exist?, "b.txt was installed"
-  end
-
-  def test_install_rename_more
-    @dst.install(@src/"a.txt" => "c.txt", @src/"b.txt" => "d.txt")
-
-    assert_predicate @dst/"c.txt", :exist?, "c.txt was not installed"
-    assert_predicate @dst/"d.txt", :exist?, "d.txt was not installed"
-    refute_predicate @dst/"a.txt", :exist?, "a.txt was installed but not renamed"
-    refute_predicate @dst/"b.txt", :exist?, "b.txt was installed but not renamed"
-  end
-
-  def test_install_rename_directory
-    bin = @src/"bin"
-    bin.mkpath
-    mv Dir[@src/"*.txt"], bin
-    @dst.install bin => "libexec"
-
-    refute_predicate @dst/"bin", :exist?, "bin was installed but not renamed"
-    assert_predicate @dst/"libexec/a.txt", :exist?, "a.txt was not installed"
-    assert_predicate @dst/"libexec/b.txt", :exist?, "b.txt was not installed"
-  end
-
-  def test_install_symlink
-    bin = @src/"bin"
-    bin.mkpath
-    mv Dir[@src/"*.txt"], bin
-    @dst.install_symlink bin
-
-    assert_predicate @dst/"bin", :symlink?
-    assert_predicate @dst/"bin", :directory?
-    assert_predicate @dst/"bin/a.txt", :exist?
-    assert_predicate @dst/"bin/b.txt", :exist?
-    assert_predicate((@dst/"bin").readlink, :relative?)
-  end
-
-  def test_install_relative_symlink
-    @dst.install_symlink "foo" => "bar"
-    assert_equal Pathname.new("foo"), (@dst/"bar").readlink
-  end
-
-  def test_mkdir_creates_intermediate_directories
-    mkdir @dst/"foo/bar/baz" do
-      assert_predicate @dst/"foo/bar/baz", :exist?, "foo/bar/baz was not created"
-      assert_predicate @dst/"foo/bar/baz", :directory?, "foo/bar/baz was not a directory structure"
-    end
-  end
-end
-- 
cgit v1.2.3


From ca4fba99c417437aca2efb36cc3c89e871d5f5a0 Mon Sep 17 00:00:00 2001
From: Markus Reiter
Date: Tue, 21 Feb 2017 05:37:08 +0100
Subject: Convert CompilerSelector test to spec.

---
 Library/Homebrew/test/compiler_selector_spec.rb | 122 ++++++++++++++++++++++++
 Library/Homebrew/test/compiler_selector_test.rb | 117 -----------------------
 2 files changed, 122 insertions(+), 117 deletions(-)
 create mode 100644 Library/Homebrew/test/compiler_selector_spec.rb
 delete mode 100644 Library/Homebrew/test/compiler_selector_test.rb

(limited to 'Library/Homebrew')

diff --git a/Library/Homebrew/test/compiler_selector_spec.rb b/Library/Homebrew/test/compiler_selector_spec.rb
new file mode 100644
index 000000000..0f6f6b5f2
--- /dev/null
+++ b/Library/Homebrew/test/compiler_selector_spec.rb
@@ -0,0 +1,122 @@
+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
diff --git a/Library/Homebrew/test/compiler_selector_test.rb b/Library/Homebrew/test/compiler_selector_test.rb
deleted file mode 100644
index aa1a6f97e..000000000
--- a/Library/Homebrew/test/compiler_selector_test.rb
+++ /dev/null
@@ -1,117 +0,0 @@
-require "testing_env"
-require "compilers"
-require "software_spec"
-
-class CompilerSelectorTests < Homebrew::TestCase
-  class Double < SoftwareSpec
-    def <<(cc)
-      fails_with(cc)
-      self
-    end
-  end
-
-  class CompilerVersions
-    attr_accessor :gcc_4_0_build_version, :gcc_build_version,
-      :clang_build_version
-
-    def initialize
-      @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
-
-    def non_apple_gcc_version(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
-
-  def setup
-    super
-    @f  = Double.new
-    @cc = :clang
-    @versions = CompilerVersions.new
-    @selector = CompilerSelector.new(
-      @f, @versions, [:clang, :gcc, :llvm, :gnu]
-    )
-  end
-
-  def actual_cc
-    @selector.compiler
-  end
-
-  def test_all_compiler_failures
-    @f << :clang << :llvm << :gcc << { gcc: "4.8" } << { gcc: "4.7" }
-    assert_raises(CompilerSelectionError) { actual_cc }
-  end
-
-  def test_no_compiler_failures
-    assert_equal @cc, actual_cc
-  end
-
-  def test_fails_with_clang
-    @f << :clang
-    assert_equal :gcc, actual_cc
-  end
-
-  def test_fails_with_llvm
-    @f << :llvm
-    assert_equal :clang, actual_cc
-  end
-
-  def test_fails_with_gcc
-    @f << :gcc
-    assert_equal :clang, actual_cc
-  end
-
-  def test_fails_with_non_apple_gcc
-    @f << { gcc: "4.8" }
-    assert_equal :clang, actual_cc
-  end
-
-  def test_mixed_failures_1
-    @f << :clang << :gcc
-    assert_equal "gcc-4.8", actual_cc
-  end
-
-  def test_mixed_failures_2
-    @f << :clang << :llvm
-    assert_equal :gcc, actual_cc
-  end
-
-  def test_mixed_failures_3
-    @f << :gcc << :llvm
-    assert_equal :clang, actual_cc
-  end
-
-  def test_mixed_failures_4
-    @f << :clang << { gcc: "4.8" }
-    assert_equal :gcc, actual_cc
-  end
-
-  def test_mixed_failures_5
-    @f << :clang << :gcc << :llvm << { gcc: "4.8" }
-    assert_equal "gcc-4.7", actual_cc
-  end
-
-  def test_gcc_precedence
-    @f << :clang << :gcc
-    assert_equal "gcc-4.8", actual_cc
-  end
-
-  def test_missing_gcc
-    @versions.gcc_build_version = Version::NULL
-    @f << :clang << :llvm << { gcc: "4.8" } << { gcc: "4.7" }
-    assert_raises(CompilerSelectionError) { actual_cc }
-  end
-
-  def test_missing_llvm_and_gcc
-    @versions.gcc_build_version = Version::NULL
-    @f << :clang << { gcc: "4.8" } << { gcc: "4.7" }
-    assert_raises(CompilerSelectionError) { actual_cc }
-  end
-end
-- 
cgit v1.2.3