enumerable-extra 0.1.0

data/CHANGES

@@ -0,0 +1,2 @@
+= 0.1.0 - 14-May-2009
+* Initial release

data/MANIFEST

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

data/README

@@ -0,0 +1,54 @@
+= 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

data/lib/enumerable/extra.rb

@@ -0,0 +1,149 @@
+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

data/test/tc_enumerable_extra.rb

@@ -0,0 +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

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: enumerable-extra
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Daniel Berger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-14 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: "     The enumerable-extra library provides overridden Enumerable methods\n     that make it easier to handle common operations that apply to each\n     element of a list without resorting to Symbol#to_proc. It also adds\n     an Enumerable#sum method.\n"
+email: djberg96@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+- MANIFEST
+files: 
+- lib/enumerable/extra.rb
+- test/tc_enumerable_extra.rb
+- README
+- CHANGES
+- MANIFEST
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/shards
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - <
+    - !ruby/object:Gem::Version 
+      version: 1.9.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: shards
+rubygems_version: 1.3.3
+signing_key: 
+specification_version: 3
+summary: Enhanced methods for Enumerable objects
+test_files: 
+- test/tc_enumerable_extra.rb