Decouple CompilerSelector from MacOS, clean up tests

Library/Homebrew/compilers.rb

@@ -94,11 +94,12 @@ class CompilerQueue
 end
 
 class CompilerSelector
-  def initialize(f)
+  def initialize(f, versions=MacOS)
     @f = f
+    @versions = versions
     @compilers = CompilerQueue.new
     %w{clang llvm gcc gcc_4_0}.map(&:to_sym).each do |cc|
-      version = MacOS.send("#{cc}_build_version")
+      version = @versions.send("#{cc}_build_version")
       unless version.nil?
         @compilers << Compiler.new(cc, version, priority_for(cc))
       end
@@ -107,7 +108,7 @@ class CompilerSelector
     # non-Apple GCC 4.x
     SharedEnvExtension::GNU_GCC_VERSIONS.each do |v|
       name = "gcc-4.#{v}"
-      version = MacOS.non_apple_gcc_version(name)
+      version = @versions.non_apple_gcc_version(name)
       unless version.nil?
         # priority is based on version, with newest preferred first
         @compilers << Compiler.new(name, version, 1.0 + v/10.0)
@@ -133,7 +134,7 @@ class CompilerSelector
 
   def priority_for(cc)
     case cc
-    when :clang then MacOS.clang_build_version >= 318 ? 3 : 0.5
+    when :clang then @versions.clang_build_version >= 318 ? 3 : 0.5
     when :gcc   then 2.5
     when :llvm  then 2
     when :gcc_4_0 then 0.25

Library/Homebrew/test/test_compiler_selector.rb

@@ -20,30 +20,32 @@ class CompilerSelectorTests < Test::Unit::TestCase
     end
   end
 
-  def setup
-    MacOS.stubs(:gcc_4_0_build_version).returns(nil)
-    MacOS.stubs(:gcc_build_version).returns(5666)
-    MacOS.stubs(:llvm_build_version).returns(2336)
-    MacOS.stubs(:clang_build_version).returns(425)
-    # Yes, this is ugly - we only want one GCC version to be available.
-    MacOS.send(:alias_method, :old_non_apple_gcc_version, :non_apple_gcc_version)
-    MacOS.send(:define_method, :non_apple_gcc_version) do |name|
-      if name == 'gcc-4.8'
-        '4.8.1'
-      else
-        nil
-      end
+  class CompilerVersions
+    attr_accessor :gcc_4_0_build_version, :gcc_build_version,
+      :llvm_build_version, :clang_build_version
+
+    def initialize(versions={})
+      {
+        :gcc_4_0_build_version => nil,
+        :gcc_build_version     => 5666,
+        :llvm_build_version    => 2336,
+        :clang_build_version   => 425,
+      }.merge(versions).each { |k, v| instance_variable_set("@#{k}", v) }
+    end
+
+    def non_apple_gcc_version(name)
+      name == "gcc-4.8" ? "4.8.1" : nil
     end
-    @f  = Double.new
-    @cc = :clang
   end
 
-  def teardown
-    MacOS.send(:alias_method, :non_apple_gcc_version, :old_non_apple_gcc_version)
+  def setup
+    @f  = Double.new
+    @cc = :clang
+    @versions = CompilerVersions.new
   end
 
   def actual_cc
-    CompilerSelector.new(@f).compiler
+    CompilerSelector.new(@f, @versions).compiler
   end
 
   def test_all_compiler_failures
@@ -96,7 +98,7 @@ class CompilerSelectorTests < Test::Unit::TestCase
   end
 
   def test_older_clang_precedence
-    MacOS.stubs(:clang_build_version).returns(211)
+    @versions = CompilerVersions.new(:clang_build_version => 211)
     @f << :gcc << 'gcc-4.8'
     assert_equal :llvm, actual_cc
   end
@@ -107,14 +109,16 @@ class CompilerSelectorTests < Test::Unit::TestCase
   end
 
   def test_missing_gcc
-    MacOS.stubs(:gcc_build_version).returns(nil)
+    @versions = CompilerVersions.new( :gcc_build_version => nil)
     @f << :clang << :llvm << 'gcc-4.8'
     assert_raise(CompilerSelectionError) { actual_cc }
   end
 
   def test_missing_llvm_and_gcc
-    MacOS.stubs(:gcc_build_version).returns(nil)
-    MacOS.stubs(:llvm_build_version).returns(nil)
+    @versions = CompilerVersions.new(
+      :gcc_build_version => nil,
+      :llvm_build_version => nil
+    )
     @f << :clang << 'gcc-4.8'
     assert_raise(CompilerSelectionError) { actual_cc }
   end