facets 1.0.0 → 1.0.1

data/lib/facet/hash/join.rb

@@ -1,19 +0,0 @@
-
-class Hash
-
-  def join( pair_divider='', elem_divider='' )
-    s = []
-    each_pair { |k,v| s << "#{k}#{pair_divider}#{v}" }
-    s.join(elem_divider)
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-# TODO

data/lib/facet/hash/keys_to_iv.rb

@@ -1,60 +0,0 @@
-class Hash
-
-  # Converts all keys in the Hash to be String values, returning a new Hash.
-  # With a from_class parameter, limits conversion to only a certain class of keys.
-  # It defaults to nil which convert any key class.
-  #
-  #   foo = { :name=>'Gavin', :wife=>:Lisa }
-  #   foo.keys_to_iv    #=>  { "@name"=>"Gavin", "@wife"=>:Lisa }
-  #   foo.inspect       #=>  { :name =>"Gavin", :wife=>:Lisa }
-  #
-  def keys_to_iv( of_class=nil )
-    self.dup.keys_to_instance_vars!( of_class )
-  end
-
-  # Aliases for better Extensions and Rails compatibility
-  alias_method( :variablize_keys, :keys_to_iv )
-
-  # Synonym for Hash#keys_to_string, but modifies the receiver in place (and returns it).
-  # With a from_class parameter, limits conversion to only a certain class of keys.
-  # It defaults to nil which convert any key class.
-  #
-  #   foo = { :name=>'Gavin', :wife=>:Lisa }
-  #   foo.keys_to_iv!   #=>  { "@name"=>"Gavin", "@wife"=>:Lisa }
-  #   foo.inspect       #=>  { "@name"=>"Gavin", "@wife"=>:Lisa }
-  #
-  def keys_to_iv!( of_class=nil )
-    raise ArgumentError, "Parameter must be a class" unless of_class.kind_of?(Class) if of_class
-    if of_class
-      self.each_key do |k|
-        if k.respond_to?(:to_s) and k.class == of_class
-          k = k.to_s
-          nk = k[0,1] != '@' ? k : "@#{k}"
-          self[nk]=self.delete(k)
-        end
-      end
-    else
-      self.each_key do |k|
-        if k.respond_to?(:to_s)
-          k = k.to_s
-          nk = k[0,1] != '@' ? k : "@#{k}"
-          self[nk]=self.delete(k)
-        end
-      end
-    end
-    self
-  end
-
-  # Aliases for better Extensions and Rails compatibility
-  alias_method( :variablize_keys!, :keys_to_iv! )
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-# TODO

data/lib/facet/hash/keys_to_s.rb

@@ -1,80 +0,0 @@
-
-class Hash
-
-  # Converts all keys in the Hash to be String values, returning a new Hash.
-  # With a from_class parameter, limits conversion to only a certain class of keys.
-  # It defaults to nil which convert any key class.
-  #
-  #   foo = { :name=>'Gavin', :wife=>:Lisa }
-  #   foo.keys_to_s    #=>  { "name"=>"Gavin", "wife"=>:Lisa }
-  #   foo.inspect      #=>  { :name =>"Gavin", :wife=>:Lisa }
-  #
-  #--
-  # Adapted from Gavin Sinclair's #convert_keys.
-  #++
-  def keys_to_s( from_class=nil )
-    raise ArgumentError, "Parameter must be a class" unless from_class.kind_of?(Class) if from_class
-    self.dup.keys_to_s!( from_class )
-  end
-
-  # Aliases for better Extensions and Rails compatibility
-  alias_method( :stringify_keys, :keys_to_s )
-
-  # Synonym for Hash#keys_to_string, but modifies the receiver in place (and returns it).
-  # With a from_class parameter, limits conversion to only a certain class of keys.
-  # It defaults to nil which convert any key class.
-  #
-  #   foo = { :name=>'Gavin', :wife=>:Lisa }
-  #   foo.keys_to_s!    #=>  { "name"=>"Gavin", "wife"=>:Lisa }
-  #   foo.inspect       #=>  { "name"=>"Gavin", "wife"=>:Lisa }
-  #
-  #--
-  # Adapted from Gavin Sinclair's #convert_keys.
-  #++
-  def keys_to_s!( from_class=nil )
-    raise ArgumentError, "Parameter must be a class" unless from_class.kind_of?(Class) if from_class
-    if from_class
-      self.each_key{ |k|
-        self[k.to_s]=self.delete(k) if k.respond_to?(:to_s) and k.class == from_class
-      }
-    else
-      self.each_key{ |k|
-        self[k.to_s]=self.delete(k) if k.respond_to?(:to_s)
-      }
-    end
-    self
-  end
-
-  # Aliases for better Extensions and Rails compatibility
-  alias_method( :stringify_keys!, :keys_to_s! )
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCHash < Test::Unit::TestCase
-
-    def test_keys_to_s
-      foo = { :a=>1, :b=>2 }
-      assert_equal( { "a"=>1, "b"=>2 }, foo.keys_to_s )
-      assert_equal( { :a =>1, :b=>2 }, foo  )
-    end
-
-    def test_keys_to_s!
-      foo = { :a=>1, :b=>2 }
-      assert_equal( { "a"=>1, "b"=>2 }, foo.keys_to_s!  )
-      assert_equal( { "a"=>1, "b"=>2 }, foo )
-    end
-
-  end
-
-=end

data/lib/facet/hash/keys_to_sym.rb

@@ -1,91 +0,0 @@
-
-class Hash
-
-  # Converts all keys in the Hash to be Symbol values, returning a new Hash.
-  # With a from_class parameter, limits conversion to only a certain class of keys.
-  # It defaults to String --use nil to convert any key class.
-  #
-  #   foo = { :name=>'Gavin', 'wife'=>:Lisa }
-  #   foo.keys_to_sym    #=>  { :name=>"Gavin", :wife=>:Lisa }
-  #   foo.inspect        #=>  { "name" =>"Gavin", "wife"=>:Lisa }
-  #
-  #--
-  # Adapted from Gavin Sinclair's graceous work #symbolify_keys.
-  #++
-  def keys_to_sym( from_class=String )
-    raise ArgumentError, "Parameter must be a class" unless from_class.kind_of?(Class) if from_class
-    self.dup.keys_to_sym!( from_class )
-  end
-
-  alias_method( :symbolize_keys, :keys_to_sym )
-
-  #--
-  # # 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#keys_to_symbol, but modifies the receiver in place (and returns it).
-  # With a from_class parameter, limits conversion to only a certain class of keys.
-  # It defaults to String --use nil to convert any key class.
-  #
-  #   foo = { 'name'=>'Gavin', 'wife'=>:Lisa }
-  #   foo.keys_to_sym!    #=>  { :name=>"Gavin", :wife=>:Lisa }
-  #   foo.inspect         #=>  { :name=>"Gavin", :wife=>:Lisa }
-  #
-  #--
-  # Adapted from Gavin Sinclair's graceous work #symbolify_keys!
-  #++
-  def keys_to_sym!( from_class=String )
-    raise ArgumentError, "Parameter must be a class" unless from_class.kind_of?(Class) if from_class
-    if from_class
-      self.each_key{ |k|
-        self[k.to_sym]=self.delete(k) if k.respond_to?(:to_sym) and k.class == from_class
-      }
-    else
-      self.each_key{ |k|
-        self[k.to_sym]=self.delete(k) if k.respond_to?(:to_sym)
-      }
-    end
-    self
-  end
-
-  alias_method( :symbolize_keys!, :keys_to_sym! )
-
-  #--
-  # # 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! )
-  #++
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCHash < Test::Unit::TestCase
-
-    def test_keys_to_sym
-      foo = { 'a'=>1, 'b'=>2 }
-      assert_equal( { :a=>1, :b=>2 }, foo.keys_to_sym )
-      assert_equal( { "a" =>1, "b"=>2 }, foo )
-    end
-
-    def test_keys_to_sym!
-      foo = { 'a'=>1, 'b'=>2 }
-      assert_equal( { :a=>1, :b=>2 }, foo.keys_to_sym! )
-      assert_equal( { :a=>1, :b=>2 }, foo  )
-    end
-
-  end
-
-=end

data/lib/facet/hash/op_fetch.rb

@@ -1,146 +0,0 @@
-require 'facet/hash/at'
-
-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 TC_HashSlice < 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/lib/facet/hash/op_lshift.rb

@@ -1,28 +0,0 @@
-class Hash
-  # Alias shorthand for #update.
-  alias_method( :<<, :update )
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCHash < Test::Unit::TestCase
-
-    def test_shift_update
-      a = { :a => 1, :b => 2, :c => 3 }
-      b = { :a => 0, :d => 4 }
-      e = { :a => 0, :b => 2, :c => 3, :d => 4 }
-      assert_equal( e, a << b )
-    end
-
-  end
-
-=end

data/lib/facet/hash/op_store.rb

@@ -1,2 +0,0 @@
-# stub
-require 'facet/hash/op_fetch'

data/lib/facet/hash/rand_key.rb

@@ -1,47 +0,0 @@
-class Hash
-
-  # Returns a random key.
-  #
-  #   {:one => 1, :two => 2, :three => 3}.pick_key  #=> :three
-  #
-  def rand_key
-    keys.at( rand(keys.size) )
-  end
-
-  # Delete a random key-value pair, returning the key.
-  #
-  #   a = {:one => 1, :two => 2, :three => 3}
-  #   a.pick_key!  #=> :two
-  #   a            #=> {:one => 1, :three => 3}
-  #
-  def rand_key!
-    k,v = rand_pair
-    delete( k )
-    return k
-  end
-
-  alias_method( :pick_key, :rand_key! )
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCHash < Test::Unit::TestCase
-
-    def test_rand_key
-      h = { :a=>1, :b=>2, :c=>3 }
-      10.times { assert( h.keys.include?( h.rand_key ) ) }
-    end
-
-  end
-
-=end