enumerable-extra 0.1.2 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 53c514d4bfad5ddebba8d6bdcd6d77b17d2e742f
+  data.tar.gz: 785932257e57a3e5431d137f0a36500b2208b5e0
+SHA512:
+  metadata.gz: 62840e9822367a952618353c09762dfbbfce68cd1c2f84af0cdb2d60c858dcda74da4b1e1da1ebf3815a605c56fae1fa47b3120e1998abad84d625012e83e786
+  data.tar.gz: c9c33ac83978b940d62675d645eb7fbcaa703accbb97cd96eb5f4e11d0a406dbb7092be66aa07e5d7edbc9ae83c7e69e64da35cfb7e4c1dccd4ba119f9c8a7ec

data/CHANGES

@@ -1,3 +1,8 @@
+== 0.2.0 - 1-Nov-2014
+* Added a custom Array#each method that behaves like the Array#zip method when
+  arguments are provided.
+* Minor updates to gemspec and Rakefile.
+
 == 0.1.2 - 27-Sep-2009 
 * Some gemspec udpates.
 * Added the :gem Rake task.

data/README

@@ -1,61 +1,62 @@
 = Description
-   This library includes modified versions of the Enumerable methods, designed
-   to make list comprehensions a little bit easier and prettier in Ruby.
+  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)
+  gem install enumerable-extra
 
 = Synopsis
-   require 'enumerable/extra'
+  require 'enumerable/extra'
 
-   array = %w/foo bar baz/
+  array = %w/foo bar baz/
 
-   array.map(:upcase) => ['FOO', 'BAR', 'BAZ']
-   array.map(:+, 'A') => ['fooA', 'barA', 'bazA']
+  array.map(:upcase) => ['FOO', 'BAR', 'BAZ']
+  array.map(:+, 'A') => ['fooA', 'barA', 'bazA']
 
-   numbers = [1,2,3]
-   numbers.sum => 6
+  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.
+  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.
+  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.
+  * 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.
+  Modify several more Enumerable methods.
 
 = License
    Artistic 2.0
 
+= Copyright
+  (C) 2009-2014 Daniel J. Berger, All Rights Reserved
+
 = 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
+  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
+  Daniel J. Berger

data/Rakefile

@@ -1,26 +1,31 @@
 require 'rake'
 require 'rake/testtask'
+require 'rake/clean'
 
-desc "Install the enumerable-extra library (non-gem)"
-task :install do
-   dest = File.join(Config::CONFIG['sitelibdir'], 'enumerable')
-   Dir.mkdir(dest) unless File.exists? dest
-   cp 'lib/enumerable/extra.rb', dest, :verbose => true
-end
+CLEAN.include("*.gem", "*.rbc")
 
-desc 'Build the enumerable-extra gem'
-task :gem do
-   spec = eval(IO.read('enumerable-extra.gemspec'))
-   Gem::Builder.new(spec).build
-end
+namespace :gem do
+  desc 'Build the enumerable-extra gem'
+  task :create => [:clean] do
+    spec = eval(IO.read('enumerable-extra.gemspec'))
+    if Gem::VERSION < "2.0"
+      Gem::Builder.new(spec).build
+    else
+      require 'rubygems/package'
+      Gem::Package.build(spec)
+    end
+  end
 
-desc "Install the enumerable-extra library as a gem"
-task :install_gem => [:gem] do
-   file = Dir["*.gem"].first
-   sh "gem install #{file}"
+  desc "Install the enumerable-extra library as a gem"
+  task :install => [:create] do
+    file = Dir["*.gem"].first
+    sh "gem install -l #{file}"
+  end
 end
 
 Rake::TestTask.new do |t|
-   t.warning = true
-   t.verbose = true
+  t.warning = true
+  t.verbose = true
 end
+
+task :default => :test

data/enumerable-extra.gemspec

@@ -2,17 +2,16 @@ require 'rubygems'
 
 Gem::Specification.new do |s|
   s.name      = 'enumerable-extra'
-  s.version   = '0.1.2'
+  s.version   = '0.2.0'
   s.license   = 'Artistic 2.0' 
   s.summary   = 'Enhanced methods for Enumerable objects'
   s.author    = 'Daniel Berger'
   s.email     = 'djberg96@gmail.com'
-  s.homepage  = 'http://www.rubyforge.org/projects/shards'
-  s.files     = Dir['**/*'].reject{ |f| f.include?('CVS') }
+  s.homepage  = 'https://github.com/djberg96/enumerable-extra'
+  s.files     = Dir['**/*'].reject{ |f| f.include?('git') }
   s.test_file = 'test/test_enumerable_extra.rb'
   s.has_rdoc  = true
 
-  s.rubyforge_project = 'shards'
   s.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
   
   s.description = <<-EOF

data/lib/enumerable/extra.rb

@@ -1,129 +1,142 @@
 module Enumerable
    
-   # The version of the enumerable-extra library.  
-   EXTRA_VERSION = '0.1.2'
+  # The version of the enumerable-extra library.  
+  EXTRA_VERSION = '0.2.0'
 
-   alias old_map map
-   alias old_collect collect
+  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 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)
+  # 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
-         }
+      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
+      # 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
+  # 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. 
+  # 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!
+  alias old_map map
+  alias old_map! map!
+  alias old_collect collect
+  alias old_collect! collect!
+  alias old_each each
 
-   # 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)
+  # 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
-         }
+      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
+      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
+  # 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!
+  # Iterates over each element in the array, yielding the result. When no
+  # arguments are provided this behaves as the standard Array#each. With
+  # arguments it behaves the same as Array#zip.
+  #
+  def each(*others, &block)
+    if others.nil? || others.empty?
+      old_each(&block)
+    else
+      zip(*others, &block)
+    end
+  end   
+
+  # Reset the aliases
+  alias collect map
+  alias collect! map!
 end

data/test/test_enumerable_extra.rb

@@ -4,74 +4,85 @@
 # Test case for the enumerable-extra library. You should run this
 # test via the 'rake test' task.
 ########################################################################
-require 'test/unit'
+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 setup
+    @words   = %w/foo bar baz/
+    @numbers = [1,2,3]
+    @hash    = {'foo' => 1, 'bar' => 2}
+    @array   = []
+  end
 
-   def test_version
-      assert_equal('0.1.2', Enumerable::EXTRA_VERSION)
-   end
+  test "version number is set properly" do
+    assert_equal('0.2.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
+    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_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
+  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
+  # 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_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)
+  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(:+, 'A'){ |e| @array << e } }
-      assert_equal(%w/fooA barA bazA/, @array)
-      assert_equal(%w/foo bar baz/, @words) # Verify receiver unmodified
-   end
+    @array = []
+    assert_nothing_raised{ @words.map(:upcase){ |e| @array << e } }
+    assert_equal(%w/FOO BAR BAZ/, @array)
 
-   def teardown
-      @words   = nil
-      @numbers = nil
-      @hash    = nil
-      @array   = nil
-   end
+    @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
+
+  test "each accepts arguments" do
+    a1 = [1,2,3]
+    a2 = [4,5,6]
+    assert_nothing_raised{ a1.each(a2){} }
+    assert_equal([[1,4],[2,5],[3,6]], a1.each(a2))
+  end
+
+  test "each defaults to using the old behavior if no arguments are passed" do
+    assert_nothing_raised{ @array.each{} }
+  end
+
+  def teardown
+    @words   = nil
+    @numbers = nil
+    @hash    = nil
+    @array   = nil
+  end
 end

metadata

@@ -1,63 +1,58 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: enumerable-extra
-version: !ruby/object:Gem::Version 
-  version: 0.1.2
+version: !ruby/object:Gem::Version
+  version: 0.2.0
 platform: ruby
-authors: 
+authors:
 - Daniel Berger
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2009-09-28 00:00:00 -06:00
-default_executable: 
+date: 2014-11-01 00:00:00.000000000 Z
 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"
+description: |2
+       The enumerable-extra library provides overridden Enumerable methods
+       that make it easier to handle common operations that apply to each
+       element of a list without resorting to Symbol#to_proc. It also adds
+       an Enumerable#sum method.
 email: djberg96@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README
 - CHANGES
 - MANIFEST
-files: 
+files:
 - CHANGES
-- enumerable-extra.gemspec
-- lib/enumerable/extra.rb
 - MANIFEST
-- Rakefile
 - README
+- Rakefile
+- enumerable-extra.gemspec
+- lib/enumerable/extra.rb
 - test/test_enumerable_extra.rb
-has_rdoc: true
-homepage: http://www.rubyforge.org/projects/shards
-licenses: 
+homepage: https://github.com/djberg96/enumerable-extra
+licenses:
 - Artistic 2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: shards
-rubygems_version: 1.3.5
+rubyforge_project: 
+rubygems_version: 2.4.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Enhanced methods for Enumerable objects
-test_files: 
+test_files:
 - test/test_enumerable_extra.rb