list-utils 0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Kevin C. Baird
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1 @@
+TODO

data/lib/list-utils.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+# list_utils.rb
+
+# Adds several syntactic sugar methods and method aliases, inspired by CPAN's 
+# List::Util and List::MoreUtils modules, and the Haskell 98 Standard Prelude.
+class Array
+
+# Returns a copy of the Array with the first <i>count</i> items missing.
+  def drop(count)
+    self[ count .. -1 ]
+  end
+
+# Returns a copy of the Array from the first point at which <i>&blk</i> 
+# is <b>false</b> to the end.
+  def drop_while(&blk)
+    return self unless yield head
+    tail ? tail.drop_while(&blk) : []
+  end
+
+# Returns a copy of the Array from the first point at which <i>&blk</i> 
+# is <b>true</b> to the end.
+  def drop_until(&blk)
+    return self if yield head
+    tail ? tail.drop_until(&blk) : []
+  end
+
+  alias_method :elem?, :include?
+
+# Returns the number of elements for which <i>&blk</i> is <b>false</b>.
+  def false_count(&blk)
+    size - true_count(&blk)
+  end
+
+  alias_method :filter,     :find_all
+  alias_method :find_first, :detect
+
+# Performs the method identified by <i>method_sym</i> on each element
+# with the following element as the single argument.
+# * (0..9).to_a.fold(:+) = 45
+# * [0, 1].fold(:+) = 1
+# * [0, 1].fold(:*) = 0
+# * 'hello'.split('').fold(:+) = 'hello'
+  def fold(method_sym)
+    output = first
+    (self - [first]).each do |e|
+      output = output.send(method_sym, e)
+    end
+    output
+  end
+  
+  alias_method :head, :first
+
+# Returns <b>true</b> if none of the elements satisfy <i>&blk</i>, 
+# <b>false</b> otherwise.
+  def none?(&blk) 
+    not any?(&blk)
+  end
+
+# Returns <b>true</b> if any of the elements do not satisfy <i>&blk</i>, 
+# <b>false</b> otherwise.
+  def not_all?(&blk) 
+    not all?(&blk)
+  end
+
+# Returns a randomly-chosen element of the Array.
+  def rand_element
+    shuffle[0]
+  end
+
+  alias_method :reduce, :fold
+ 
+# Returns all elements of the Array in order except the first.
+  def rest
+    self[ 1 .. -1 ]
+  end
+
+# Returns a copy of the Array in random order.
+  def shuffle
+    sort_by { rand }
+  end
+
+# Syntactic sugar for <b>fold(:+)</b>.
+  def sum
+    fold(:+)
+  end
+
+  alias_method :tail, :rest
+ 
+# Returns the first <i>count</i> elements of the Array.
+  def take(count)
+    self[0 .. (count-1) ]
+  end
+
+  alias_method :take_while, :drop_until
+  alias_method :take_until, :drop_while
+
+# Returns the number of elements for which <i>&blk</i> is <b>true</b>.
+  def true_count(&blk)
+    filter(&blk).size
+  end
+
+end
+
+if (__FILE__ == $0)
+  a = (0..9).to_a
+  non_zeroes = a.drop_while { |x| x.zero? }
+  puts %Q[non_zeroes = #{non_zeroes.inspect}]
+  above_five = a.drop_while { |x| x <= 5 }
+  puts %Q[above 5 = #{above_five.inspect}]
+  above_five = a.drop_until { |x| x > 5 }
+  puts %Q[above 5 = #{above_five.inspect}]
+  below_five = a.take_while { |x| x < 5 }
+  puts %Q[below 5 = #{below_five.inspect}]
+  below_five = a.take_until { |x| x >= 5 }
+  puts %Q[below 5 = #{below_five.inspect}]
+  first_six = a.take(6)
+  puts %Q[first 6 = #{first_six.inspect}]
+end

data/tests/list-utils-test.rb

@@ -0,0 +1,231 @@
+#!/usr/bin/env ruby
+# test_list_utils.rb
+
+require %q[lib/list_utils]
+require %q[test/unit]
+
+class Tester < Test::Unit::TestCase
+
+  EMPTY_STRING = %q[]
+  EMPTY_ARRAY  = []
+  DIGITS       = (0..9).to_a
+  HELLO        = %q[hello]
+  HELLOA       = HELLO.split(EMPTY_STRING)
+  VOWELS       = %w[a e i o u y]
+
+  LAMBDA = {
+    :above4?    => lambda { |x| x > 4  },
+    :above10?   => lambda { |x| x > 10 },
+    :below5?    => lambda { |x| x < 5  },
+    :digit?     => lambda { |x| DIGITS.include?(x) },
+    :vowel?     => lambda { |x| VOWELS.include?(x) },
+    :not_vowel? => lambda { |x| not VOWELS.include?(x) },
+  }
+  
+  COMPARISONS = [:above4?, :above10?, :below5?]
+  NON_COMPARISONS = LAMBDA.keys - COMPARISONS
+
+  def test_drop
+    assert_equal EMPTY_ARRAY, EMPTY_ARRAY.drop(0)
+    assert_equal DIGITS,      DIGITS.drop(0)
+    assert_equal EMPTY_ARRAY, DIGITS.drop(DIGITS.size)
+    assert_equal (1..9).to_a, DIGITS.drop(1)
+    assert_equal %w[l l o],   HELLOA.drop(2)
+  end
+
+  def test_drop_while
+    COMPARISONS.each do |lk|
+      assert_raise(ArgumentError) { HELLOA.drop_while( &LAMBDA[lk] ) }
+    end
+    NON_COMPARISONS.each { |lk| assert_equal EMPTY_ARRAY, EMPTY_ARRAY.drop_while( &LAMBDA[lk] ) }
+    assert_equal DIGITS,      DIGITS.drop_while( &LAMBDA[:vowel?] )
+    assert_equal HELLOA,      HELLOA.drop_while( &LAMBDA[:vowel?] )
+    assert_equal EMPTY_ARRAY, DIGITS.drop_while( &LAMBDA[:not_vowel?] )
+    assert_equal HELLOA.tail, HELLOA.drop_while( &LAMBDA[:not_vowel?] )
+    assert_equal DIGITS.filter(&LAMBDA[:above4?]), DIGITS.drop_while( &LAMBDA[:below5?] )
+  end
+
+  def test_drop_until
+    COMPARISONS.each do |lk|
+      assert_raise(NoMethodError) { EMPTY_ARRAY.drop_until( &LAMBDA[lk] ) }
+    end
+    NON_COMPARISONS.each { |lk| assert_equal EMPTY_ARRAY.drop_until( &LAMBDA[lk] ), EMPTY_ARRAY }
+    assert_equal EMPTY_ARRAY, DIGITS.drop_until( &LAMBDA[:vowel?] )
+    assert_equal HELLOA.tail, HELLOA.drop_until( &LAMBDA[:vowel?] )
+    assert_equal DIGITS,      DIGITS.drop_until( &LAMBDA[:not_vowel?] )
+    assert_equal HELLOA,      HELLOA.drop_until( &LAMBDA[:not_vowel?] )
+    assert_equal DIGITS.filter( &LAMBDA[:above4?] ), DIGITS.drop_until( &LAMBDA[:above4?] )
+  end
+
+  def test_elem
+    assert_equal false, EMPTY_ARRAY.elem?(0)
+    assert_equal false, EMPTY_ARRAY.elem?(nil)
+    assert       DIGITS.elem?(0)     
+    HELLOA.each { |char| assert HELLOA.elem?(char) }
+    assert_equal false, DIGITS.elem?(EMPTY_STRING)
+    assert_equal false, DIGITS.elem?(nil)
+    assert_equal false, [].elem?(nil)
+    assert_equal false, [].elem?(EMPTY_STRING)
+    assert_equal false, HELLOA.elem?(0)
+  end
+
+  def test_false_count
+    LAMBDA.keys.each do |lk|
+      assert_equal 0, EMPTY_ARRAY.false_count( &LAMBDA[lk] )
+    end
+    assert_equal 0, DIGITS.false_count( &LAMBDA[:digit?] )
+    assert_equal 3, HELLOA.false_count( &LAMBDA[:vowel?] )
+    assert_equal 2, HELLOA.false_count( &LAMBDA[:not_vowel?] )
+    assert_equal DIGITS.size, DIGITS.false_count( &LAMBDA[:vowel?] )
+    assert_equal HELLOA.size, HELLOA.false_count( &LAMBDA[:digit?] )
+  end
+
+  def test_filter
+    COMPARISONS.each do |lk|
+      assert_raise(ArgumentError) { HELLOA.drop_while( &LAMBDA[lk] ) }
+    end
+    LAMBDA.keys.each { |lk| assert_equal EMPTY_ARRAY.filter( &LAMBDA[lk] ), EMPTY_ARRAY }
+    assert_equal DIGITS,      DIGITS.filter( &LAMBDA[:digit?]     )
+    assert_equal EMPTY_ARRAY, HELLOA.filter( &LAMBDA[:digit?]     )
+    assert_equal DIGITS,      DIGITS.filter( &LAMBDA[:not_vowel?] )
+    assert_equal %w[h l l],   HELLOA.filter( &LAMBDA[:not_vowel?] )
+    assert_equal EMPTY_ARRAY, DIGITS.filter( &LAMBDA[:vowel?]     )
+    assert_equal %w[e o],     HELLOA.filter( &LAMBDA[:vowel?]     )
+  end
+
+  def test_find_first
+    COMPARISONS.each do |lk|
+      assert_raise(ArgumentError) { HELLOA.find_first( &LAMBDA[lk] ) }
+    end
+    NON_COMPARISONS.each { |lk| assert_nil EMPTY_ARRAY.find_first( &LAMBDA[lk] ) }
+    assert_equal 5,     DIGITS.find_first( &LAMBDA[:above4?]    )
+    assert_nil          DIGITS.find_first( &LAMBDA[:above10?]   )
+    assert_equal %q[e], HELLOA.find_first( &LAMBDA[:vowel?]     )
+    assert_equal %q[h], HELLOA.find_first( &LAMBDA[:not_vowel?] )
+  end
+
+  def test_fold
+    assert_equal 45,     DIGITS.fold(:+)
+    assert_equal 0,      DIGITS.fold(:*)
+    assert_equal 45,     DIGITS.tail.fold(:+)
+    assert_equal 362880, DIGITS.tail.fold(:*)
+    assert_equal HELLO,  HELLOA.fold(:+), HELLO
+  end
+  
+  def test_head
+    assert_equal DIGITS[0], DIGITS.head
+    assert_equal 0,         DIGITS.head
+    assert_nil   EMPTY_ARRAY.head 
+  end
+
+  def test_none
+    COMPARISONS.each do |lk| 
+      assert_raise(ArgumentError) { HELLOA.none?( &LAMBDA[lk] ) }
+    end
+    LAMBDA.keys.each { |lk| assert_equal true, EMPTY_ARRAY.none?( &LAMBDA[lk] ) }
+    assert_equal true,  DIGITS.none?( &LAMBDA[:above10?]   )
+    assert_equal false, DIGITS.none?( &LAMBDA[:above4?]    )
+    assert_equal false, DIGITS.none?( &LAMBDA[:below5?]    )
+    assert_equal false, DIGITS.none?( &LAMBDA[:digit?]     )
+    assert_equal true,  DIGITS.none?( &LAMBDA[:vowel?]     )
+    assert_equal false, DIGITS.none?( &LAMBDA[:not_vowel?] )
+    assert_equal true,  HELLOA.none?( &LAMBDA[:digit?]     )
+    assert_equal false, HELLOA.none?( &LAMBDA[:vowel?]     )
+    assert_equal false, HELLOA.none?( &LAMBDA[:not_vowel?] )
+  end
+  
+  def test_not_all
+    COMPARISONS.each do |lk| 
+      assert_equal true, DIGITS.not_all?( &LAMBDA[lk] )
+      assert_raise(ArgumentError) { HELLOA.not_all?( &LAMBDA[lk] ) }
+    end
+    LAMBDA.keys.each { |lk| assert_equal false, EMPTY_ARRAY.not_all?( &LAMBDA[lk] ) }
+    assert_equal false, DIGITS.not_all?( &LAMBDA[:digit?]     )
+    assert_equal true,  DIGITS.not_all?( &LAMBDA[:vowel?]     )
+    assert_equal false, DIGITS.not_all?( &LAMBDA[:not_vowel?] )
+    assert_equal true,  HELLOA.not_all?( &LAMBDA[:digit?]     )
+    assert_equal true,  HELLOA.not_all?( &LAMBDA[:vowel?]     )
+    assert_equal true,  HELLOA.not_all?( &LAMBDA[:not_vowel?] )
+  end
+  
+  def test_rand_element
+    [DIGITS, HELLOA].each do |a| 
+      100.times { assert a.include?(a.rand_element) }
+    end
+    assert_nil EMPTY_ARRAY.rand_element
+  end
+  
+  def test_reduce
+    #TODO
+  end
+  
+  def test_rest
+    #TODO
+  end
+  
+  def test_shuffle
+    [DIGITS, HELLOA].each do |a| 
+      100.times { assert_equal a.sort, a.shuffle.sort }
+    end
+    assert_equal EMPTY_ARRAY, EMPTY_ARRAY.shuffle
+  end
+  
+  def test_sum
+    assert_equal nil,   EMPTY_ARRAY.sum
+    assert_equal 45,    DIGITS.sum
+    assert_equal 10,    DIGITS.filter( &LAMBDA[:below5?] ).sum
+    assert_equal HELLO, HELLOA.sum
+  end
+  
+  def test_tail
+    assert_nil   EMPTY_ARRAY.tail
+    assert_equal (1..9).to_a, DIGITS.tail
+    assert_equal %w[e l l o], HELLOA.tail
+    
+  end
+  
+  def test_take
+    0.upto(10) { |x| assert_equal EMPTY_ARRAY, EMPTY_ARRAY.take(x) }
+    [DIGITS, HELLOA].each do |a|
+      assert_equal [a.head],                                a.take(1)
+      assert_equal [a.head, a.tail.head],                   a.take(2)
+      assert_equal [a.head, a.tail.head, a.tail.tail.head], a.take(3)
+    end
+  end
+  
+  def test_take_while
+    COMPARISONS.each do |lk|
+      assert_raise(NoMethodError) { EMPTY_ARRAY.take_while( &LAMBDA[lk] ) }
+    end
+    NON_COMPARISONS.each { |lk| assert_equal EMPTY_ARRAY.take_while( &LAMBDA[lk] ), EMPTY_ARRAY }
+    assert_equal EMPTY_ARRAY, DIGITS.take_while( &LAMBDA[:vowel?] )
+    assert_equal HELLOA.tail, HELLOA.take_while( &LAMBDA[:vowel?] )
+    assert_equal DIGITS,      DIGITS.take_while( &LAMBDA[:not_vowel?] )
+    assert_equal HELLOA,      HELLOA.take_while( &LAMBDA[:not_vowel?] )
+    assert_equal DIGITS.filter( &LAMBDA[:above4?] ), DIGITS.take_while( &LAMBDA[:above4?] )
+  end
+  
+  def test_take_until
+    COMPARISONS.each do |lk|
+      assert_raise(ArgumentError) { HELLOA.take_until( &LAMBDA[lk] ) }
+    end
+    NON_COMPARISONS.each { |lk| assert_equal EMPTY_ARRAY, EMPTY_ARRAY.take_until( &LAMBDA[lk] ) }
+    assert_equal DIGITS,      DIGITS.take_until( &LAMBDA[:vowel?] )
+    assert_equal HELLOA,      HELLOA.take_until( &LAMBDA[:vowel?] )
+    assert_equal EMPTY_ARRAY, DIGITS.take_until( &LAMBDA[:not_vowel?] )
+    assert_equal HELLOA.tail, HELLOA.take_until( &LAMBDA[:not_vowel?] )
+    assert_equal DIGITS.filter(&LAMBDA[:above4?]), DIGITS.take_until( &LAMBDA[:below5?] )
+  end
+  
+  def test_true_count
+    LAMBDA.keys.each do |lk|
+      assert_equal 0, EMPTY_ARRAY.true_count( &LAMBDA[lk] )
+    end
+    assert_equal DIGITS.size, DIGITS.true_count( &LAMBDA[:digit?] )
+    assert_equal 2,           HELLOA.true_count( &LAMBDA[:vowel?] )
+    assert_equal 3,           HELLOA.true_count( &LAMBDA[:not_vowel?] )
+    assert_equal 0,           DIGITS.true_count( &LAMBDA[:vowel?] )
+    assert_equal 0,           HELLOA.true_count( &LAMBDA[:digit?] )
+  end
+  
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: list-utils
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2007-12-05 00:00:00 -05:00
+summary: A collection of syntactically sweet Array methods
+require_paths: 
+- lib
+email: kcbaird@world.oberlin.edu
+homepage: http://list-utils-gem.rubyforge.org
+rubyforge_project: 
+description: list-utils adds several list-related methods and method aliases to the Array class. Among its inspirations are the List::Util and List::MoreUtils CPAN modules for Perl at http://cpan.org and the Haskell 98 Prelude (http://www.haskell.org/onlinereport/prelude-index.html).
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Kevin C. Baird
+files: 
+- lib/list-utils.rb
+- tests/list-utils-test.rb
+- MIT-LICENSE
+- README
+test_files: 
+- tests/list-utils-test.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- MIT-LICENSE
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+