facets 2.9.1 → 2.9.2

data/work/defunct/core/facets/enumerable/cascade.rb

@@ -0,0 +1,28 @@
+module Enumerable
+
+  #   # Cascade actions on each enumerated element.
+  #   #
+  #   #   [9, 19, 29].cascade :succ, :to_s, :reverse
+  #   #   => ["01", "02", "03"]
+  #   #
+  #   # See ruby-talk:199877.
+  #
+  #   def cascade(*methods)
+  #     methods.inject(self){ |ary, method| ary.map{ |x| x.send(method)}}
+  #   end
+
+
+  # DEPRECATED:
+  #
+  #   # Why the term counter? There may be a change in Ruby 2.0
+  #   # to use this word instead of index. Index will
+  #   # still be used for Array, since that is the proper meaning
+  #   # in that context. In the mean time, aliases are provided.
+  #
+  #   alias_method( :collect_with_counter, :collect_with_index )
+  #   alias_method( :map_with_counter, :collect_with_index )
+  #
+  #   #instance_map and #instance_select --too invasive for convenience.
+
+end
+

data/work/defunct/core/facets/enumerable/each.rb

@@ -0,0 +1,89 @@
+# TODO:
+#
+#   - Remove require 'enumerator' for Ruby 1.9.
+#   - Suggest Enumerator's #each_slice use block arity if no parameter is given.
+
+require 'enumerator' # for each_slice
+
+module Enumerable
+
+  # Iterators over each element pairing.
+  #
+  #   [:a,:b,:c,:d].each_pair { |a,b|  puts "#{a} -> #{b}" }
+  #
+  # _produces_
+  #
+  #   a -> b
+  #   c -> d
+  #
+  #  CREDIT: Martin DeMello
+
+  def each_pair #:yield:
+    e1 = nil
+    each_with_index do |e,i|
+      if i % 2 == 0
+        e1 = e
+        next
+      else
+        yield(e1,e)
+      end
+    end
+  end
+
+  # Iterate over each n items based on arity.
+  #
+  #   [1,2,3,4].eachn do |x, y|
+  #     p [x,y]
+  #   end
+  #
+  # _produces_
+  #
+  #   [1,2]
+  #   [3,4]
+  #
+  #  CREDIT: Martin DeMello
+
+  def eachn(&block)
+    n = block.arity.abs
+    each_slice(n) {|i| block.call(*i)}
+  end
+
+
+  # DEPRECATED
+  #
+  #   # Why the term counter? There may be a change in Ruby 2.0
+  #   # to use this word instead of index. Index will
+  #   # still be used for Array, since that is the proper meaning
+  #   # in that context. In the mean time, aliases are provided.
+  #
+  #   # More appropriate naming since an enumerable is not
+  #   # neccesarily "indexed", as is an Array or Hash.
+  #   alias_method :each_with_counter, :each_with_index
+
+end
+
+
+
+=begin test
+
+  def test_each_pair
+    r = []
+    a = [1,2,3,4]
+    a.each_pair{ |a,b| r << [a,b] }
+    assert_equal( [[1,2],[3,4]], r )
+  end
+
+  def test_eachn
+    x = []
+    [1,2,3,4].eachn{ |a,b| x << [a,b] }
+    o = [[1,2],[3,4]]
+    assert_equal( o, x )
+
+    x = []
+    [1,2,3,4,5].eachn{ |a,b,c| x << [a,b,c] }
+    o = [[1,2,3],[4,5,nil]]
+    assert_equal( o, x )
+  end
+
+=end
+

data/work/defunct/core/facets/enumerable/to_hash.rb

@@ -0,0 +1,30 @@
+module Enumerable
+
+  # Produces a hash from an Enumerable with index for keys.
+  #
+  #   enu = 'a'..'b'
+  #   enu.to_hash  #=> { 0=>'a', 1=>'b' }
+  #
+  # If a block is passed, the hash values will be set by
+  # calling the block with the enumerated element and it's
+  # counter.
+  #
+  #   enu = 'a'..'b'
+  #   enu.to_hash{ |e,i| e }  #=> { 0=>'a', 1=>'b' }
+  #
+  # See also #mash.
+  #
+  # CREDIT: Trans
+
+  def to_hash( &blk )
+    h = {}
+    if blk
+      each_with_index{ |e,i| h[i] = blk.call(e,i) }
+    else
+      each_with_index{ |e,i| h[i] = e }
+    end
+    h
+  end
+
+end
+

data/work/defunct/core/facets/hash/access.rb

@@ -0,0 +1,146 @@
+
+class Hash
+
+  # Adds slicing to Hash#[]. If more than one key arguments
+  # is given to <tt>Hash#[]</tt>, the return value will be
+  # an array of the corresponding values.
+  #
+  #   h = { :a => 1, :b => 2, :c => 3 }
+  #   h[:a]            #=> 1
+  #   h[:a, :b]        #=> [1,2]
+
+  def []( *sliceKeys )
+    if sliceKeys.length == 1
+      return at( sliceKeys[0] )
+    else
+      return values_at( *sliceKeys )
+    end
+  end
+
+  # Add slicing to element assignment operator.
+  #
+  #   h = {:a=>1, :b=>2, :c=>3}
+  #
+  #   h[:a] = 9              #=> 9
+  #   h                      #=> {:a=>9, :b=>2, :c=>3}
+  #
+  #   h[:a, :c] = [10,11]    #=> [10,11]
+  #   h                      #=> {:a=>10, :b=>2, :c=>11}
+
+  def []=( *args )
+    if args.length <= 2
+      return store( *args )
+    end
+    aVals = args.pop
+    aVals = [aVals] unless aVals.kind_of?( Array )
+    args.each_index{ |i| store( args[i], aVals[i] ) }
+  end
+
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TestHashSlice < Test::Unit::TestCase
+
+    @hash = nil
+    AryKey = %w{an array as a key}
+    AryVal = %w{an array as a value}
+
+    def setup
+      @hash = {
+        "this" => "is",
+        "a" => "test",
+        "hash" => "with",
+        "some" => "values",
+        "for" => "testing",
+        AryKey => 'aryKey',
+        'aryVal' => AryVal
+      }
+    end
+
+    # Testing teardown method
+    def teardown
+      @hash = nil
+    end
+
+    # Make sure we haven't screwed up regular element reference
+    def test_get_regular
+        assert_equal('is', @hash['this'])
+        assert_equal('aryKey', @hash[ AryKey ])
+        assert_equal(AryVal, @hash[ 'aryVal' ])
+        assert_nil(@hash['nonExistant'])
+    end
+
+    # Test slice reference
+    def test_get_2args
+      res = @hash['this','a']
+      assert_instance_of( Array, res )
+      assert_equal( ['is','test'], res )
+
+      assert_equal(['aryKey','with'], @hash[ AryKey, 'hash' ])
+
+      assert_equal([AryVal,'testing'], @hash[ 'aryVal', 'for' ])
+
+      assert_equal(['aryKey',AryVal], @hash[ AryKey, 'aryVal' ])
+
+      res = @hash['nonExistant', 'anotherNonExistant']
+      assert_nil(res[0])
+      assert_nil(res[1])
+
+      @hash.default = 'default'
+      res = @hash['nonExistant', 'anotherNonExistant']
+      assert_equal( 'default', res[0] )
+      assert_equal( 'default', res[1] )
+    end
+
+    # Test fetching slices with duplicate keys
+    def test_get_duplicate_args
+      assert_equal(['is','is'], @hash['this','this'])
+      assert_equal(['aryKey','aryKey'], @hash[ AryKey, AryKey ])
+      assert_equal([AryVal,AryVal], @hash[ 'aryVal', 'aryVal' ])
+      assert_equal(['aryKey',AryVal,'aryKey','aryKey'], @hash[ AryKey, 'aryVal', AryKey, AryKey ])
+    end
+
+    # Test to make sure we haven't mucked up regular element assign
+    def test_set_regular
+      # Single string key assign
+      @hash['this'] = 'something else'
+      assert_equal( 'something else', @hash['this'] )
+
+      # Single array key assign
+      @hash[AryKey] = 'something else'
+      assert_equal( 'something else', @hash[AryKey] )
+
+      # Make sure range-assign behaviour is unchanged
+      rng = 1..5
+      @hash[ rng ] = 1..5
+      assert_instance_of( Range, @hash[rng] )
+      assert_equal( 1..5, @hash[1..5] )
+    end
+
+    # Test slice-assign
+    def test_set_2args
+      # Test slice-assign with string keys
+      assert_nothing_raised {@hash['this','a'] = 'other', 'stuff'}
+      assert_equal( 'other', @hash['this'] )
+      assert_equal( 'stuff', @hash['a'] )
+
+      # Test slice-assign with array keys and a string and array value
+      assert_nothing_raised {@hash[AryKey, %w{some other array}] = 'another', %w{set of values}}
+      assert_equal( 'another', @hash[AryKey] )
+      assert_equal( %w{set of values}, @hash[%w{some other array}] )
+    end
+
+  end
+
+=end

data/work/defunct/core/facets/hash/group_by_value.rb

@@ -0,0 +1,66 @@
+class Hash
+
+  # Like group_by, but allows hash values to be grouped with weeding out the keys...
+  #
+  #   birthdays = {...}   # Maps each person to his/her birthday.
+  #
+  # Now I want to have the list of people that have their birthday
+  # on a specific date. This can be done by creating a hash first,
+  # using group_by ...
+  #
+  #   birthdays.group_by{|person, birthday| birthday}
+  #
+  # This returns ...
+  #
+  #   {date=>[[person1, date], [person2, date], [person3, date]]}
+  #
+  # which is a bit inconvient. Too many dates. I would rather
+  # like to have ...
+  #
+  #   {date=>[person1, person2, person3]]}
+  #
+  # This can be achieved by ...
+  #
+  #   birthdays.inject!({}){|h, (person, date)| (h[date] ||= []) << person}
+  #
+  # I've used this pattern just once too often, so I moved the code
+  # to Hash (and Enumerable, for associative arrays). Here's the
+  # cleaner code...
+  #
+  #   birthdays.group_by_value
+  #
+  # Now, an actual example.
+  #
+  #   h = {"A"=>1, "B"=>1, "C"=>1, "D"=>2, "E"=>2, "F"=>2, "G"=>3, "H"=>3, "I"=>3}
+  #
+  #   h.group_by_value        # => {1=>["A", "B", "C"], 2=>["D", "E", "F"], 3=>["G", "H", "I"]}
+  #   h.sort.group_by_value   # => [[1, ["A", "B", "C"]], [2, ["D", "E", "F"]], [3, ["G", "H", "I"]]]
+  #
+  # CREDIT: Erik Veenstra
+  
+  def group_by_value
+    res = {}
+    each{|k, v| (res[v] ||= []) << k}
+    res
+  end
+
+end
+
+
+# Not sure this is a good idea for enumerable.
+#
+class Array
+
+  # For associative arrays, like the result of Hash#sort.
+  #
+  #  [[1,2],[3,4]].group_by_value  #=> []
+  #
+  def group_by_value
+    kv  = k = v = nil
+    res = []
+    each{|k, v| (res.assoc(v) || (res << kv=[v, []]; kv)).last << k}
+    res
+  end
+
+end
+

data/work/defunct/core/facets/hash/normalize_keys.rb

@@ -0,0 +1,134 @@
+class Hash
+
+  # NOTE: This method is really usurped by Hash#rekey.
+  #       It remains available for the time being for improved
+  #       intercompability with Rail's ActiveSupport library.
+
+  # Converts all keys in the Hash accroding to the given block.
+  # If the block return +nil+ for given key, then that key will be
+  # left intact.
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.normalize_keys{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo.inspect                       #=>  { :name =>"Gavin", :wife=>:Lisa }
+  #
+  #  CREDIT: Trans
+  #  CREDIT: Gavin Sinclair
+
+  def normalize_keys( &block )
+    dup.send(:normalize_keys!, &block)
+  end
+
+  # Synonym for Hash#normalize_keys, but modifies the receiver in place (and returns it).
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.normalize_keys!{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo.inspect                        #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #
+  #   CREDIT: Trans
+  #   CREDIT: Gavin Sinclair
+
+  def normalize_keys!( &block )
+    keys.each{ |k|
+      nk = block[k]
+      self[nk]=delete(k) if nk
+    }
+    self
+  end
+
+  # Converts all keys in the Hash to Symbols, returning a new Hash.
+  # With a +filter+, limits conversion to only a certain selection of keys.
+  #
+  #   foo = { :name=>'Gavin', 'wife'=>:Lisa }
+  #   foo.symbolize_keys    #=>  { :name=>"Gavin", :wife=>:Lisa }
+  #   foo.inspect           #=>  { "name" =>"Gavin", "wife"=>:Lisa }
+  #
+  #   CREDIT: Trans
+  #   CREDIT: Gavin Sinclair
+
+  def symbolize_keys( &filter )
+    if filter
+      normalize_keys{ |k| filter[k] ? k.to_sym : nil }
+    else
+      normalize_keys{ |k| k.to_sym }
+    end
+  end
+
+  alias_method( :keys_to_sym, :symbolize_keys )
+
+  #--
+  # # Rails has these aliases too, but they are not very good for
+  # # gerenal use, IMHO. But perhaps someone can convince me otherwise.
+  # alias_method( :to_options,  :symbolize_keys )
+  #++
+
+  # Synonym for Hash#symbolize_keys, but modifies the receiver in place and returns it.
+  # With a +filter+ parameter, limits conversion to only a certain selection of keys.
+  #
+  #   foo = { 'name'=>'Gavin', 'wife'=>:Lisa }
+  #   foo.symbolize_keys!    #=>  { :name=>"Gavin", :wife=>:Lisa }
+  #   foo.inspect            #=>  { :name=>"Gavin", :wife=>:Lisa }
+  #
+  #   CREDIT: Trans
+  #   CREDIT: Gavin Sinclair
+
+  def symbolize_keys!( &filter )
+    if filter
+      normalize_keys!{ |k| filter[k] ? k.to_sym : nil }
+    else
+      normalize_keys!{ |k| k.to_sym }
+    end
+
+  end
+
+  alias_method( :keys_to_sym!, :symbolize_keys! )
+
+  #--
+  # # Rails has these aliases too, but they are not very good for
+  # # gerenal use, IMHO. But perhaps someone can convince me otherwise.
+  # alias_method( :to_options!, :symbolize_keys! )
+  #++
+
+
+  # Converts all keys in the Hash to Strings, returning a new Hash.
+  # With a +filter+ parameter, limits conversion to only a certain selection of keys.
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.stringify_keys    #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo.inspect           #=>  { :name =>"Gavin", :wife=>:Lisa }
+  #
+  #   CREDIT: Trans
+  #   CREDIT: Gavin Sinclair
+
+  def stringify_keys( &filter )
+    if filter
+      normalize_keys{ |k| filter[k] ? k.to_s : nil }
+    else
+      normalize_keys{ |k| k.to_s }
+    end
+  end
+
+  alias_method(:keys_to_s, :stringify_keys)
+
+  # Synonym for Hash#stringify_keys, but modifies the receiver in place and returns it.
+  # With a +filter+ parameter, limits conversion to only a certain selection of keys.
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.stringify_keys!    #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo.inspect            #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #
+  #   CREDIT: Trans
+  #   CREDIT: Gavin Sinclair
+
+  def stringify_keys!( &filter )
+    if filter
+      normalize_keys!{ |k| filter[k] ? k.to_s : nil }
+    else
+      normalize_keys!{ |k| k.to_s }
+    end
+  end
+
+  alias_method( :keys_to_s!, :stringify_keys!)
+
+end
+