technicalpickles · April 6, 2009 03:17 · Apr 6, 2009 · Apr 3, 2009 · Apr 3, 2009 · Apr 2, 2009
diff --git a/snippet.rb b/snippet.rb
@@ -16,11 +16,34 @@ def respond_to?(sym, include_private = false)
   end
 
 end
+
+class NegativeFilterableEnumerable
+  def initialize(original)
+    @original = original
+  end
+
+  def ==(value)
+    @original.select { |v| v != value }
+  end
+
+  def method_missing(sym, *args, &block)
+    @original.select {|v| ! v.send(sym, *args, &block) }
+  end
+
+  def respond_to?(sym, include_private = false)
+    @original.all? {|v| v.respond_to?(sym, include_private) }
+  end
+
+end
 
 module Enumerable
   def filter
     FilterableEnumerable.new(self)
   end
+
+  def filter_not
+    NegativeFilterableEnumerable.new(self)
+  end
 end
 
 
@@ -50,16 +73,20 @@ def test_eq
     assert_equal [5], @array.filter == 5
   end
 
-  def test_neq
-    assert_equal [0, 1, 2, 3, 4, 6, 7, 8, 10], @array.filter != 5
+  def test_not_eq
+    assert_equal [0, 1, 2, 3, 4, 6, 7, 8, 9, 10], @array.filter_not == 5
   end
 
   def test_method_missing
     assert_equal [0], @array.filter.zero?
   end
+
+  def test_not_method_missing
+    assert_equal [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], @array.filter_not.zero?
+  end
 
   def test_respond_to
     assert @array.filter.respond_to?(:zero?)
   end
 
-end
+end
diff --git a/snippet.rb b/snippet.rb
@@ -18,14 +18,6 @@ def respond_to?(sym, include_private = false)
 end
 
 module Enumerable
-  def >(value)
-    select { |v| v > value }
-  end
-
-  def <(value)
-    select { |v| v < value }
-  end
-
   def filter
     FilterableEnumerable.new(self)
   end

diff --git a/snippet.rb b/snippet.rb
@@ -3,34 +3,18 @@ def initialize(original)
     @original = original
   end
 
-  def >(value)
-    @original.select { |v| v > value }
-  end
-
-  def >=(value)
-    @original.select { |v| v >= value }
-  end
-
-  def <(value)
-    @original.select { |v| v < value }
-  end
-
-  def <=(value)
-    @original.select { |v| v <= value }
-  end
-
   def ==(value)
     @original.select { |v| v == value }
   end
-
+ 
   def method_missing(sym, *args, &block)
     @original.select {|v| v.send(sym, *args, &block) }
   end
-
+ 
   def respond_to?(sym, include_private = false)
     @original.all? {|v| v.respond_to?(sym, include_private) }
   end
-
+ 
 end
 
 module Enumerable
@@ -53,37 +37,37 @@ class TestFilterableEnumerable < Test::Unit::TestCase
   def setup
     @array = (0..10).to_a
   end
-
+ 
   def test_gte
     assert_equal [5, 6, 7, 8, 9, 10], @array.filter >= 5
   end
-
+ 
   def test_gt
     assert_equal [6, 7, 8, 9, 10], @array.filter > 5
   end
-
+ 
   def test_lte
     assert_equal [0, 1, 2, 3, 4], @array.filter < 5
   end
-
+ 
   def test_le
     assert_equal [0, 1, 2, 3, 4, 5], @array.filter <= 5
   end
-
+ 
   def test_eq
     assert_equal [5], @array.filter == 5
   end
-
+ 
   def test_neq
     assert_equal [0, 1, 2, 3, 4, 6, 7, 8, 10], @array.filter != 5
   end
-
+ 
   def test_method_missing
     assert_equal [0], @array.filter.zero?
   end
-
+ 
   def test_respond_to
     assert @array.filter.respond_to?(:zero?)
   end
-
-end
+ 
+end
diff --git a/snippet.rb b/snippet.rb
@@ -6,29 +6,38 @@ def initialize(original)
   def >(value)
     @original.select { |v| v > value }
   end
-
+ 
   def >=(value)
     @original.select { |v| v >= value }
   end
-
+ 
   def <(value)
     @original.select { |v| v < value }
   end
-
+ 
   def <=(value)
     @original.select { |v| v <= value }
   end
-
+ 
   def ==(value)
     @original.select { |v| v == value }
   end
-end
 
+  def method_missing(sym, *args, &block)
+    @original.select {|v| v.send(sym, *args, &block) }
+  end
+
+  def respond_to?(sym, include_private = false)
+    @original.all? {|v| v.respond_to?(sym, include_private) }
+  end
+
+end
+
 module Enumerable
   def >(value)
     select { |v| v > value }
   end
-
+ 
   def <(value)
     select { |v| v < value }
   end
@@ -37,14 +46,44 @@ def filter
     FilterableEnumerable.new(self)
   end
 end
+
+
+require 'test/unit'
+class TestFilterableEnumerable < Test::Unit::TestCase
+  def setup
+    @array = (0..10).to_a
+  end
 
+  def test_gte
+    assert_equal [5, 6, 7, 8, 9, 10], @array.filter >= 5
+  end
 
-a = (1..10).to_a
-a.filter >= 5 # => [5, 6, 7, 8, 9, 10]
-a.filter > 5 # => [6, 7, 8, 9, 10]
-a.filter < 5 # => [1, 2, 3, 4]
-a.filter <= 5 # => [1, 2, 3, 4, 5]
-a.filter == 5 # => [5]
+  def test_gt
+    assert_equal [6, 7, 8, 9, 10], @array.filter > 5
+  end
 
-# and the problem case:
-a.filter != 5 # => false
+  def test_lte
+    assert_equal [0, 1, 2, 3, 4], @array.filter < 5
+  end
+
+  def test_le
+    assert_equal [0, 1, 2, 3, 4, 5], @array.filter <= 5
+  end
+
+  def test_eq
+    assert_equal [5], @array.filter == 5
+  end
+
+  def test_neq
+    assert_equal [0, 1, 2, 3, 4, 6, 7, 8, 10], @array.filter != 5
+  end
+
+  def test_method_missing
+    assert_equal [0], @array.filter.zero?
+  end
+
+  def test_respond_to
+    assert @array.filter.respond_to?(:zero?)
+  end
+
+end
diff --git a/snippet.rb b/snippet.rb
@@ -45,3 +45,6 @@ def filter
 a.filter < 5 # => [1, 2, 3, 4]
 a.filter <= 5 # => [1, 2, 3, 4, 5]
 a.filter == 5 # => [5]
+
+# and the problem case:
+a.filter != 5 # => false
diff --git a/snippet.rb b/snippet.rb
@@ -7,10 +7,18 @@ def >(value)
     @original.select { |v| v > value }
   end
 
+  def >=(value)
+    @original.select { |v| v >= value }
+  end
+
   def <(value)
     @original.select { |v| v < value }
   end
 
+  def <=(value)
+    @original.select { |v| v <= value }
+  end
+
   def ==(value)
     @original.select { |v| v == value }
   end
@@ -28,11 +36,12 @@ def <(value)
   def filter
     FilterableEnumerable.new(self)
   end
-
 end
 
 
 a = (1..10).to_a
+a.filter >= 5 # => [5, 6, 7, 8, 9, 10]
 a.filter > 5 # => [6, 7, 8, 9, 10]
 a.filter < 5 # => [1, 2, 3, 4]
+a.filter <= 5 # => [1, 2, 3, 4, 5]
 a.filter == 5 # => [5]
diff --git a/snippet.rb b/snippet.rb
@@ -1,4 +1,21 @@
-# Yes this is a terrible idea, but we're just getting started...
+class FilterableEnumerable
+  def initialize(original)
+    @original = original
+  end
+
+  def >(value)
+    @original.select { |v| v > value }
+  end
+
+  def <(value)
+    @original.select { |v| v < value }
+  end
+
+  def ==(value)
+    @original.select { |v| v == value }
+  end
+end
+
 module Enumerable
   def >(value)
     select { |v| v > value }
@@ -7,8 +24,15 @@ def >(value)
   def <(value)
     select { |v| v < value }
   end
+
+  def filter
+    FilterableEnumerable.new(self)
+  end
 
 end
 
+
 a = (1..10).to_a
-a > 5 # => [6, 7, 8, 9, 10]
+a.filter > 5 # => [6, 7, 8, 9, 10]
+a.filter < 5 # => [1, 2, 3, 4]
+a.filter == 5 # => [5]
diff --git a/snippet.rb b/snippet.rb
@@ -0,0 +1,14 @@
+# Yes this is a terrible idea, but we're just getting started...
+module Enumerable
+  def >(value)
+    select { |v| v > value }
+  end
+
+  def <(value)
+    select { |v| v < value }
+  end
+
+end
+
+a = (1..10).to_a
+a > 5 # => [6, 7, 8, 9, 10]