enumerable-extra 0.1.0 → 0.1.1

data/CHANGES

@@ -1,2 +1,10 @@
-= 0.1.0 - 14-May-2009
-* Initial release
+= 0.1.1 - 18-Jul-2009
+* Added 1.9.x compatibility. Note that Enumerator objects are explicitly
+  converted back to arrays to match the 1.8.x behavior.
+* Changed license to Artistic 2.0, and added it explictly to the gemspec.
+* Removed the required_ruby_version from the gemspec since it's now
+  compatible.
+* Updated the README, including a missing warranty disclaimer (whoops).
+
+= 0.1.0 - 14-May-2009
+* Initial release

data/MANIFEST

@@ -1,7 +1,7 @@
-* CHANGES
-* README
-* MANIFEST
-* Rakefile
-* enumerable-extra.gemspec
-* lib/enumerable/extra
-* test/tc_enumerable_extra.rb
+* CHANGES
+* README
+* MANIFEST
+* Rakefile
+* enumerable-extra.gemspec
+* lib/enumerable/extra
+* test/tc_enumerable_extra.rb

data/README

@@ -1,54 +1,61 @@
-= Description
-   This library includes modified versions of the Enumerable methods, designed
-   to make list comprehensions a little bit easier and prettier in Ruby.
-
-= Installation
-   rake test (optional)
-   rake install (non-gem) OR rake install_gem (gem)
-
-= Synopsis
-   require 'enumerable/extra'
-
-   array = %w/foo bar baz/
-
-   array.map(:upcase) => ['FOO', 'BAR', 'BAZ']
-   array.map(:+, 'A') => ['fooA', 'barA', 'bazA']
-
-   numbers = [1,2,3]
-   numbers.sum => 6
-
-= Motivation
-   This library was created in reaction to the ugly "&" (or worse, "&its")
-   notation started by Ruby on Rails and perpetuated by the Symbol#to_proc
-   adherents.
-
-   The theory behind Symbol#to_proc is that it's a generic metaprogramming
-   solution that will solve a certain range of programming problems. The
-   reality is that 99% of people use it for list comprehensions*. So, instead
-   of introducing crappy notation, I decided that it made better sense to
-   modify Enumerable methods to accept arguments.
-
-   There are two advantages to this. First, superior notation, i.e. no need
-   for the ampersand. One of the reasons I chose Ruby as my primary programming
-   language in the first place was the beauty of its notation. I don't want
-   to see that ruined by Symbol#to_proc. Also, coming from a C background, I
-   find the ampersand too reminiscent of C address notation.
-
-   Second, Symbol#to_proc is very slow.
-
-   * Based on the questions and solutions that I see on the ruby-talk and rails
-     mailing lists. I've monitored the former for almost seven years and the
-     latter for close to two now. This is in addition to many blogs I read that
-     occasionally touch on the subject.
-
-= Future Plans
-   Modify several more Enumerable methods.
-
-= License
-   Ruby's
-
-= Warranty
-
-= Author
-   Daniel J. Berger
-   djberg96 at nospam at gmail dot com
+= Description
+   This library includes modified versions of the Enumerable methods, designed
+   to make list comprehensions a little bit easier and prettier in Ruby.
+
+= Installation
+   rake test (optional)
+   rake install (non-gem) OR rake install_gem (gem)
+
+= Synopsis
+   require 'enumerable/extra'
+
+   array = %w/foo bar baz/
+
+   array.map(:upcase) => ['FOO', 'BAR', 'BAZ']
+   array.map(:+, 'A') => ['fooA', 'barA', 'bazA']
+
+   numbers = [1,2,3]
+   numbers.sum => 6
+
+= Motivation
+   This library was created in reaction to the ugly "&" (or worse, "&its")
+   notation started by Ruby on Rails and perpetuated by the Symbol#to_proc
+   adherents.
+
+   The theory behind Symbol#to_proc is that it's a generic metaprogramming
+   solution that will solve a certain range of programming problems. The
+   reality is that 99% of people use it for list comprehensions*. So, instead
+   of introducing crappy notation, I decided that it made better sense to
+   modify Enumerable methods to accept arguments.
+
+   There are two advantages to this. First, superior notation, i.e. no need
+   for the ampersand. One of the reasons I chose Ruby as my primary programming
+   language in the first place was the beauty of its notation. I don't want
+   to see that ruined by Symbol#to_proc. Also, coming from a C background, I
+   find the ampersand too reminiscent of C address notation.
+
+   Second, Symbol#to_proc is very slow.
+   
+   Update: It seems Symbol#to_proc is reasonably fast now in the 1.9.x branch.
+   However, it does not allow you to pass arguments to a method. That means
+   you still can't do the equivalent of [1,2,3].map(:+, 1), for example.
+
+   * Based on the questions and solutions that I see on the ruby-talk and rails
+     mailing lists. I've monitored the former for almost seven years and the
+     latter for close to two now. This is in addition to many blogs I read that
+     occasionally touch on the subject.
+
+= Future Plans
+   Modify several more Enumerable methods.
+
+= License
+   Artistic 2.0
+
+= Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose
+
+= Author
+   Daniel J. Berger
+   djberg96 at nospam at gmail dot com

data/lib/enumerable/extra.rb

@@ -1,149 +1,127 @@
-module Enumerable  
-   EXTRA_VERSION = '0.1.0'
-
-   alias old_map map
-   alias old_collect collect
-
-   # Returns the numeric total of the elements of +enum+, using +total+ as
-   # an accumulator (0 by default). Raises an error if any of the elements
-   # are non-numeric.
-   #
-   def sum(total = 0)
-      each{ |val| total += val }
-      total
-   end
-
-   # Returns a new array containing the results of running +method+ once for
-   # every element in the enumerable object. If both arguments and a block
-   # are provided the arguments are processed first, then passed to
-   # the block.
-   #
-   # If no method is provided, then it behaves as the standard MRI method.
-   #
-   # Examples:
-   #
-   #  array = ['foo', 'bar']
-   #
-   #  # No arguments
-   #  array.map(:capitalize) => ['Foo', 'Bar']
-   #
-   #  # With arguments
-   #  array.map(:+, 'x') => ['foox', 'barx']
-   #
-   #  # With arguments and a block
-   #  array.map(:capitalize){ |e| e + 'x' } => ['Foox', 'Barx']
-   #
-   def map(method=nil, *args, &block)
-      if method
-         array  = []
-         method = method.to_sym unless method.is_a?(Symbol)
-
-         each{ |obj|
-            temp = obj.send(method, *args)
-            if block
-               array << block.call(temp)
-            else
-               array << temp
-            end
-         }
-
-         array
-      else
-         old_map(&block)
-      end
-   end
-
-   # Reset the aliases
-   alias collect map
-end
-
-class Array
-   alias old_map map
-   alias old_map! map!
-   alias old_collect collect
-   alias old_collect! collect!
-   #alias old_select select
-
-   # Returns a new array containing the results of running +block+ once for
-   # every element in the +array+.
-   #
-   # Examples:
-   #
-   #  array = ['foo', 'bar']
-   #
-   #  # No arguments
-   #  array.map(:capitalize) => ['Foo', 'Bar']
-   #
-   #  # With arguments
-   #  array.map(:+, 'x') => ['foox', 'barx']
-   #
-   #  # With arguments and a block
-   #  array.map(:capitalize){ |e| e + 'x' } => ['Foox', 'Barx']
-   #--
-   # The Array class actually has its own implementation of the +map+ method,
-   # hence the duplication.
-   # 
-   def map(method=nil, *args, &block)
-      if method
-         array  = []
-         method = method.to_sym unless method.is_a?(Symbol)
-
-         each{ |obj|
-            temp = obj.send(method, *args)
-            if block
-               array << block.call(temp)
-            else
-               array << temp
-            end
-         }
-         array
-      else
-         old_map(&block)
-      end
-   end
-
-   # Same as Array#map, but modifies the receiver in place. Also note that
-   # a block is _not_ required. If no block is given, an array of values
-   # is returned instead
-   #
-   def map!(method=nil, *args, &block)
-      self.replace(map(method, *args, &block))
-   end
-
-=begin
-   def select(method=nil, condition = nil, *args, &block)
-      array = [] unless block
-      if method
-         if block
-            warn 'block ignored when arguments provided'
-         end
-
-         if condition.nil?
-            raise 'condition must be provided if method is provided'
-         end
-
-         method = method.to_sym unless method.is_a?(Symbol)
-
-         each{ |obj|
-            if args.length > 0
-               if obj.send(method, condition, *args)
-                  array << obj
-               end
-            else
-               if obj.send(method, condition)
-                  array << obj                  
-               end
-            end
-         }
-
-         return array
-      else
-         old_select(&block)   
-      end
-   end
-=end
-
-   # Reset the aliases
-   alias collect map
-   alias collect! map!
-end
+module Enumerable  
+   EXTRA_VERSION = '0.1.1'
+
+   alias old_map map
+   alias old_collect collect
+
+   # Returns the numeric total of the elements of +enum+, using +total+ as
+   # an accumulator (0 by default). Raises an error if any of the elements
+   # are non-numeric.
+   #
+   def sum(total = 0)
+      each{ |val| total += val }
+      total
+   end
+
+   # Returns a new array containing the results of running +method+ once for
+   # every element in the enumerable object. If both arguments and a block
+   # are provided the arguments are processed first, then passed to
+   # the block.
+   #
+   # If no method argument is provided, then it behaves as the standard MRI
+   # method.
+   #
+   # Examples:
+   #
+   #  array = ['foo', 'bar']
+   #
+   #  # No arguments
+   #  array.map(:capitalize) => ['Foo', 'Bar']
+   #
+   #  # With arguments
+   #  array.map(:+, 'x') => ['foox', 'barx']
+   #
+   #  # With arguments and a block
+   #  array.map(:capitalize){ |e| e + 'x' } => ['Foox', 'Barx']
+   #
+   # Note that for 1.9.x users, Enumerator objects are converted explicitly
+   # back into arrays.
+   #
+   def map(method=nil, *args, &block)
+      if method
+         array  = []
+         method = method.to_sym unless method.is_a?(Symbol)
+
+         each{ |obj|
+            temp = obj.send(method, *args)
+            if block
+               array << block.call(temp)
+            else
+               array << temp
+            end
+         }
+
+         # Convert enumerators back to arrays for 1.9.x
+         RUBY_VERSION.to_f >= 1.9 ? array.to_a : array
+      else
+         RUBY_VERSION.to_f ? old_map(&block).to_a : old_map(&block)
+      end
+   end
+
+   # Reset the aliases
+   alias collect map
+end
+
+class Array
+   # These methods are defined separately in array.c, and they are not actual
+   # aliases, so we must alias them each separately from Enumerable. 
+
+   alias old_map map
+   alias old_map! map!
+   alias old_collect collect
+   alias old_collect! collect!
+
+   # Returns a new array containing the results of running +block+ once for
+   # every element in the +array+.
+   #
+   # Examples:
+   #
+   #  array = ['foo', 'bar']
+   #
+   #  # No arguments
+   #  array.map(:capitalize) => ['Foo', 'Bar']
+   #
+   #  # With arguments
+   #  array.map(:+, 'x') => ['foox', 'barx']
+   #
+   #  # With arguments and a block
+   #  array.map(:capitalize){ |e| e + 'x' } => ['Foox', 'Barx']
+   #
+   # Note that for 1.9.x users, Enumerator objects are converted explicitly
+   # back into arrays.
+   #--
+   # The Array class actually has its own implementation of the +map+ method,
+   # hence the duplication.
+   # 
+   def map(method=nil, *args, &block)
+      if method
+         array  = []
+         method = method.to_sym unless method.is_a?(Symbol)
+
+         each{ |obj|
+            temp = obj.send(method, *args)
+            if block
+               array << block.call(temp)
+            else
+               array << temp
+            end
+         }
+
+         RUBY_VERSION.to_f >= 1.9 ? array.to_a : array
+      else
+         RUBY_VERSION.to_f >= 1.9 ? old_map(&block).to_a : old_map(&block)
+      end
+   end
+
+   # Same as Array#map, but modifies the receiver in place. Also note that
+   # a block is _not_ required. If no block is given, an array of values
+   # is returned instead
+   #
+   def map!(method=nil, *args, &block)
+      self.replace(map(method, *args, &block))
+   end
+
+   # Reset the aliases
+   alias collect map
+   alias collect! map!
+end

data/test/tc_enumerable_extra.rb

@@ -1,77 +1,77 @@
-########################################################################
-# tc_enumerable_extra.rb
-#
-# Test case for the enumerable-extra library. You should run this
-# test via the 'rake test' task.
-########################################################################
-require 'test/unit'
-require 'enumerable/extra'
-
-class TC_Enumerable_Extra < Test::Unit::TestCase
-   def setup
-      @words   = %w/foo bar baz/
-      @numbers = [1,2,3]
-      @hash    = {'foo', 1, 'bar', 2}
-      @array   = []
-   end
-
-   def test_version
-      assert_equal('0.1.0', Enumerable::EXTRA_VERSION)
-   end
-
-   def test_sum
-      assert_respond_to(@numbers, :sum)
-      assert_equal(6, @numbers.sum)
-      assert_equal(20, @numbers.sum(14))
-   end
-
-   def test_sum_expected_errors
-      assert_raises(TypeError){ @words.sum }
-   end
-
-   def test_map_array_no_block
-      assert_nothing_raised{ @words.map }
-      assert_equal(%w/foo bar baz/, @words.map)
-      assert_equal(%w/FOO BAR BAZ/, @words.map(:upcase))
-      assert_equal(%w/fooA barA bazA/, @words.map(:+, 'A'))
-      assert_equal(%w/foo bar baz/, @words) # Verify receiver unmodified
-   end
-
-   # Test the alias explicitly
-   def test_collect_array_no_block
-      assert_nothing_raised{ @words.collect }
-      assert_equal(%w/foo bar baz/, @words.collect)
-      assert_equal(%w/FOO BAR BAZ/, @words.collect(:upcase))
-      assert_equal(%w/fooA barA bazA/, @words.collect(:+, 'A'))
-      assert_equal(%w/foo bar baz/, @words) # Verify receiver unmodified
-   end
-
-   def test_map_bang_array_no_block
-      assert_nothing_raised{ @words.map! }
-      assert_equal(%w/foo bar baz/, @words.map!)
-      assert_equal(%w/FOO BAR BAZ/, @words.map!(:upcase))
-      assert_equal(%w/FOO BAR BAZ/, @words) # Verify receiver modified
-   end
-
-   def test_map_with_block
-      assert_nothing_raised{ @words.map{} }
-      assert_nothing_raised{ @words.map{ |e| @array << e } }
-      assert_equal(%w/foo bar baz/, @array)
-      
-      @array = []
-      assert_nothing_raised{ @words.map(:upcase){ |e| @array << e } }
-      assert_equal(%w/FOO BAR BAZ/, @array)
-
-      @array = []
-      assert_nothing_raised{ @words.map(:+, 'A'){ |e| @array << e } }
-      assert_equal(%w/fooA barA bazA/, @array)
-      assert_equal(%w/foo bar baz/, @words) # Verify receiver unmodified
-   end
-
-   def teardown
-      @words   = nil
-      @numbers = nil
-      @hash    = nil
-      @array   = nil
-   end
-end
+########################################################################
+# tc_enumerable_extra.rb
+#
+# Test case for the enumerable-extra library. You should run this
+# test via the 'rake test' task.
+########################################################################
+require 'test/unit'
+require 'enumerable/extra'
+
+class TC_Enumerable_Extra < Test::Unit::TestCase
+   def setup
+      @words   = %w/foo bar baz/
+      @numbers = [1,2,3]
+      @hash    = {'foo' => 1, 'bar' => 2}
+      @array   = []
+   end
+
+   def test_version
+      assert_equal('0.1.1', Enumerable::EXTRA_VERSION)
+   end
+
+   def test_sum
+      assert_respond_to(@numbers, :sum)
+      assert_equal(6, @numbers.sum)
+      assert_equal(20, @numbers.sum(14))
+   end
+
+   def test_sum_expected_errors
+      assert_raises(TypeError){ @words.sum }
+   end
+
+   def test_map_array_no_block
+      assert_nothing_raised{ @words.map }
+      assert_equal(%w/foo bar baz/, @words.map)
+      assert_equal(%w/FOO BAR BAZ/, @words.map(:upcase))
+      assert_equal(%w/fooA barA bazA/, @words.map(:+, 'A'))
+      assert_equal(%w/foo bar baz/, @words) # Verify receiver unmodified
+   end
+
+   # Test the alias explicitly
+   def test_collect_array_no_block
+      assert_nothing_raised{ @words.collect }
+      assert_equal(%w/foo bar baz/, @words.collect)
+      assert_equal(%w/FOO BAR BAZ/, @words.collect(:upcase))
+      assert_equal(%w/fooA barA bazA/, @words.collect(:+, 'A'))
+      assert_equal(%w/foo bar baz/, @words) # Verify receiver unmodified
+   end
+
+   def test_map_bang_array_no_block
+      assert_nothing_raised{ @words.map! }
+      assert_equal(%w/foo bar baz/, @words.map!)
+      assert_equal(%w/FOO BAR BAZ/, @words.map!(:upcase))
+      assert_equal(%w/FOO BAR BAZ/, @words) # Verify receiver modified
+   end
+
+   def test_map_with_block
+      assert_nothing_raised{ @words.map{} }
+      assert_nothing_raised{ @words.map{ |e| @array << e } }
+      assert_equal(%w/foo bar baz/, @array)
+      
+      @array = []
+      assert_nothing_raised{ @words.map(:upcase){ |e| @array << e } }
+      assert_equal(%w/FOO BAR BAZ/, @array)
+
+      @array = []
+      assert_nothing_raised{ @words.map(:+, 'A'){ |e| @array << e } }
+      assert_equal(%w/fooA barA bazA/, @array)
+      assert_equal(%w/foo bar baz/, @words) # Verify receiver unmodified
+   end
+
+   def teardown
+      @words   = nil
+      @numbers = nil
+      @hash    = nil
+      @array   = nil
+   end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: enumerable-extra
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Daniel Berger
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-14 00:00:00 -06:00
+date: 2009-07-18 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -31,8 +31,8 @@ files:
 - MANIFEST
 has_rdoc: true
 homepage: http://www.rubyforge.org/projects/shards
-licenses: []
-
+licenses: 
+- Artistic 2.0
 post_install_message: 
 rdoc_options: []
 
@@ -40,9 +40,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - - <
+  - - ">="
     - !ruby/object:Gem::Version 
-      version: 1.9.0
+      version: "0"
   version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
@@ -53,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: shards
-rubygems_version: 1.3.3
+rubygems_version: 1.3.4
 signing_key: 
 specification_version: 3
 summary: Enhanced methods for Enumerable objects