Remove Array subclassing

Inheriting from Array (and other core types) is problematic:

  - It exposes a very wide interface with many methods that are not
    really relevant to the subclass.
  - It can cause some weird side effects, as many Array operations are
    in C and have hardcoded return values; for example, combining two
    array subclasses returns a new Array instead of the subclass.

Avoid these problems using delegation and the Enumerable module where
applicable.

3 files changed, 56 insertions, 13 deletions

diff --git a/Library/Homebrew/compilers.rb b/Library/Homebrew/compilers.rb
index 03a1de6bc..eaaf041b5 100644
--- a/Library/Homebrew/compilers.rb
+++ b/Library/Homebrew/compilers.rb
@@ -1,19 +1,45 @@
-class Compilers < Array
-  def include? cc
+class Compilers
+  include Enumerable
+
+  def initialize(*args)
+    @compilers = Array.new(*args)
+  end
+
+  def each(*args, &block)
+    @compilers.each(*args, &block)
+  end
+
+  def include?(cc)
     cc = cc.name if cc.is_a? Compiler
-    self.any? { |c| c.name == cc }
+    @compilers.any? { |c| c.name == cc }
+  end
+
+  def <<(o)
+    @compilers << o
+    self
   end
 end
 
 
-class CompilerFailures < Array
-  def include? cc
+class CompilerFailures
+  include Enumerable
+
+  def initialize(*args)
+    @failures = Array.new(*args)
+  end
+
+  def each(*args, &block)
+    @failures.each(*args, &block)
+  end
+
+  def include?(cc)
     cc = Compiler.new(cc) unless cc.is_a? Compiler
-    self.any? { |failure| failure.compiler == cc.name }
+    @failures.any? { |failure| failure.compiler == cc.name }
   end
 
-  def <<(failure)
-    super(failure) unless self.include? failure.compiler
+  def <<(o)
+    @failures << o unless include? o.compiler
+    self
   end
 end
 
@@ -72,7 +98,7 @@ class CompilerSelector
     # @compilers is our list of available compilers. If @f declares a
     # failure with compiler foo, then we remove foo from the list if
     # the failing build is >= the currently installed version of foo.
-    @compilers.reject! do |cc|
+    @compilers = @compilers.reject do |cc|
       failure = @f.fails_with? cc
       next unless failure
       failure.build >= cc.build
diff --git a/Library/Homebrew/dependencies.rb b/Library/Homebrew/dependencies.rb
index 0e4d4be2f..3dd5a3101 100644
--- a/Library/Homebrew/dependencies.rb
+++ b/Library/Homebrew/dependencies.rb
@@ -85,11 +85,28 @@ private
 
 end
 
+class Dependencies
+  include Enumerable
+
+  def initialize(*args)
+    @deps = Array.new(*args)
+  end
+
+  def each(*args, &block)
+    @deps.each(*args, &block)
+  end
 
-# A list of formula dependencies.
-class Dependencies < Array
   def <<(o)
-    super(o) unless include? o
+    @deps << o unless @deps.include? o
+    self
+  end
+
+  def empty?
+    @deps.empty?
+  end
+
+  def *(arg)
+    @deps * arg
   end
 end
 
diff --git a/Library/Homebrew/test/test_dependencies.rb b/Library/Homebrew/test/test_dependencies.rb
index 4758aad0a..a09dee7cb 100644
--- a/Library/Homebrew/test/test_dependencies.rb
+++ b/Library/Homebrew/test/test_dependencies.rb
@@ -30,7 +30,7 @@ class DependencyTests < Test::Unit::TestCase
   def test_no_duplicate_dependencies
     @d.add 'foo'
     @d.add 'foo' => :build
-    assert_equal 1, @d.deps.length
+    assert_equal 1, @d.deps.count
     assert_empty @d.find_dependency('foo').tags
   end
 end