facets 2.8.2 → 2.8.3

data/lib/more/facets/stash.rb

@@ -1,65 +1,180 @@
-require 'facets/hash/rekey'
-
-# = Hash
-#
 # Stash is just like Hash, except that all keys are
 # converted to Strings.
 #
-# This is rather fresh code, so is not yet complete.
-# For instnace, it currently does not ensure that default
-# keys are strings when using default_proc.
-#
+# Note this doesn't yet handle default_proc.
+
 class Stash < Hash
 
-  def fetch(k)
-    super(k.to_s)
+  #
+  def self.[](*hash)
+    s = new
+    super(*hash).each{ |k,v| s[k] = v }
+    s
   end
 
-  def store(k, v)
-    super(k.to_s, v)
+  #
+  def [](key)
+    super(convert_key(key))
   end
 
-  def has_key?(k)
-    super(k.to_s)
+  #
+  def []=(key,value)
+    super(convert_key(key), value)
   end
 
-  def key?(k)
-    super(k.to_s)
+  #
+  def <<(other)
+    case other
+    when Hash
+      super(other.rekey{ |key| convert_key(key) })
+    when Array
+      self[other[0]] = other[1]
+    else
+      raise ArgumentError
+    end
   end
 
-  def [](k)
-    super(k.to_s)
+  #
+  def fetch(key)
+    super(convert_key(key))
   end
 
-  def []=(k,v)
-    super(k.to_s, v)
+  #
+  def store(key, value)
+    super(convert_key(key), value)
   end
 
-  def <<(other)
-    cash other
-    when Hash
-      super(other.rekey(&:to_s))
-    when Array
-      self[other[0].to_s] = other[1]
+  #
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  #
+  def has_key?(key)
+    super(convert_key(key))
+  end
+
+  #
+  def include?(key)
+    super(convert_key(key))
+  end
+
+  #
+  def member?(key)
+    super(convert_key(key))
+  end
+
+
+  # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }.to_stash
+  #   foo.rekey!{ |k| k.upcase }  #=>  { "NAME"=>"Gavin", "WIFE"=>:Lisa }
+  #   foo.inspect                 #=>  { "NAME"=>"Gavin", "WIFE"=>:Lisa }
+  #
+  def rekey!(*args, &block)
+    # for backward comptability (TODO: DEPRECATE?).
+    block = args.pop.to_sym.to_proc if args.size == 1
+    if args.empty?
+      block = lambda{|k| k} unless block
+      keys.each do |k|
+        nk = block[k]
+        self[nk.to_s]=delete(k) #if nk
+      end
     else
-      raise ArgumentError
+      raise ArgumentError, "3 for 2" if block
+      to, from = *args
+      self[to] = delete(from) if has_key?(from)
     end
+    self
+  end
+
+  #
+  def rekey(*args, &block)
+    dup.rekey!(*args, &block)
+  end
+
+  #
+  def delete(key)
+    super(convert_key(key))
   end
 
+  #
   def update(other)
-    super(other.rekey(&:to_s))
+    super(other.rekey{ |key| convert_key(key) })
   end
 
+  # Same as #update.
   def merge!(other)
-    super(other.rekey(&:to_s))
+    super(other.rekey{ |key| convert_key(key) })
   end
-  
-  def replace
-    super(other.rekey(&:to_s))
+
+  #
+  def merge(other)
+    super(other.rekey{ |key| convert_key(key) })
+  end
+
+  #
+  def replace(other)
+    super(other.rekey{ |key| convert_key(key) })
   end
 
+  #
   def values_at(*keys)
-    super(keys.map{|k|k.to_s})
+    super(*keys.map{ |key| convert_key(key) })
+  end
+
+  #
+  def to_hash
+    h = {}
+    each{ |k,v| h[k] = v }
+    h
+  end
+
+  alias_method :to_h, :to_hash
+
+  private
+
+    def convert_key(key)
+      key.to_s
+    end
+
+end
+
+class Hash
+
+  # Convert a Hash to a Stash object.
+  def to_stash
+    Stash[self]
+  end
+
+  # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.rekey!{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo.inspect               #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #
+  # This method comes from Ruby Facets.
+
+  def rekey!(*args, &block)
+    # for backward comptability (TODO: DEPRECATE).
+    block = args.pop.to_sym.to_proc if args.size == 1
+    if args.empty?
+      block = lambda{|k| k.to_sym} unless block
+      keys.each do |k|
+        nk = block[k]
+        self[nk]=delete(k) if nk
+      end
+    else
+      raise ArgumentError, "3 for 2" if block
+      to, from = *args
+      self[to] = self.delete(from) if self.has_key?(from)
+    end
+    self
+  end
+
+  # Non-inplace #rekey! method.
+  def rekey(*args, &block)
+    dup.rekey!(*args, &block)
   end
 
 end

data/meta/released

@@ -1 +1 @@
-2010-02-22
+2010-04-10

data/meta/version

@@ -1 +1 @@
-2.8.2
+2.8.3

data/test/core/array/test_recursive.rb

@@ -0,0 +1,18 @@
+require 'facets/array/recursive'
+require 'test/unit'
+
+class TestArrayRecursive < Test::Unit::TestCase
+
+  def test_each
+    a = []
+    [1,2,['a','b']].recursive.each{ |v| a << v }
+    assert_equal([1,2,'a','b'], a)
+  end
+
+  def test_map
+    a = [1,2,['a','b']].recursive.map{ |v| v.succ }
+    assert_equal([2,3,['b','c']], a)
+  end
+
+end
+

data/test/core/enumerable/test_recursive.rb

@@ -0,0 +1,18 @@
+require 'facets/enumerable/recursive'
+require 'test/unit'
+
+class TestEnumerableRecursive < Test::Unit::TestCase
+
+  def test_each
+    a = []
+    [1,2,['a','b']].recursive.each{ |v| a << v }
+    assert_equal([1,2,'a','b'], a)
+  end
+
+  def test_map
+    a = [1,2,['a','b']].recursive.map{ |v| v.succ }
+    assert_equal([2,3,['b','c']], a)
+  end
+
+end
+

data/test/core/file/test_ext.rb

@@ -0,0 +1,31 @@
+require 'facets/file/ext'
+require 'test/unit'
+ 
+class Test_File_Ext < Test::Unit::TestCase
+
+  # Standard file names.  
+  def test_ext_standard
+    s = 'file.txt'
+    assert_equal('txt', File.ext(s))
+    assert_equal('file.old', File.ext(s, 'old'))
+    assert_equal('file', File.ext(s, ''))
+  end
+
+  # Initially no extension.
+  def test_ext_none
+    s = 'file'
+    assert_equal('', File.ext(s))
+    assert_equal('file.txt', File.ext(s, 'txt'))
+    assert_equal('file', File.ext(s, ''))
+  end 
+
+  # Some non-standard case.
+  def test_ext_non_standard
+    s = '.profile'
+    assert_equal('', File.ext(s))
+    assert_equal('.profile.new', File.ext(s, 'new'))
+    assert_equal('.profile', File.ext(s, ''))
+  end
+
+end
+

data/test/core/hash/test_recursive.rb

@@ -0,0 +1,23 @@
+require 'facets/hash/recursive'
+require 'test/unit'
+
+class TestHashRecursive < Test::Unit::TestCase
+
+  def test_each
+    a = []
+    {:a=>1,:b=>{:c=>3}}.recursive.each{ |k,v| a << [k,v] }
+    assert_equal([[:a,1],[:c,3], [:b,{:c=>3}]], a)
+  end
+
+  def test_map_moot
+    a = {:a=>1,:b=>{:c=>3}}.recursive.map{ |k,v| [k, v] }
+    assert_equal([[:a,1],[:b,[[:c,3]]]], a)
+  end
+
+  def test_map
+    a = {:a=>1,:b=>{:c=>3}}.recursive.map{ |k,v| Hash===v ? [k, v.succ] : [k,v] }
+    assert_equal([[:a,1],[:b,[[:c,3]]]], a)
+  end
+
+end
+

data/test/core/hash/test_to_module.rb

@@ -0,0 +1,21 @@
+require 'facets/hash/to_module'
+require 'test/unit'
+
+class TC_Hash_To_Module < Test::Unit::TestCase
+
+  def test_to_module
+    h = { :a=>1, :b=>2 }
+    m = h.to_module
+    assert(Module === m)
+  end
+
+  def test_to_module_methods
+    h = { :a=>1, :b=>2 }
+    m = h.to_module
+    x = Class.new{ include m }.new
+    assert_equal( 1, x.a )
+    assert_equal( 2, x.b )
+  end
+
+end
+

data/test/core/kernel/test_assign.rb

@@ -0,0 +1,57 @@
+require 'facets/kernel/assign.rb'
+require 'test/unit'
+
+class TestKernelAssign < Test::Unit::TestCase
+
+  C = Struct.new(:name, :address, :zip)
+
+  def test_assign_with_arguments
+    bob = C.new
+
+    bob.assign(:name, "Bob Sawyer")
+    bob.assign(:address, "123 Maple, Anytown NC")
+    bob.assign(:zip, 12345)
+
+    assert_equal("Bob Sawyer", bob.name)
+    assert_equal("123 Maple, Anytown NC", bob.address)
+    assert_equal(12345, bob.zip)
+  end
+
+  def test_assign_with_hash
+    bob = C.new
+
+    x = { :name => "Bob Sawyer", :address => "123 Maple, Anytown NC", :zip => 12345 }
+
+    bob.assign(x)
+
+    assert_equal(x[:name], bob.name)
+    assert_equal(x[:address], bob.address)
+    assert_equal(x[:zip], bob.zip)
+  end
+
+  def test_assign_with_assoc_array
+    bob = C.new
+
+    x = [[:name, "Bob Sawyer"], [:address, "123 Maple, Anytown NC"], [:zip, 12345]]
+
+    bob.assign(x)
+
+    assert_equal("Bob Sawyer", bob.name)
+    assert_equal("123 Maple, Anytown NC", bob.address)
+    assert_equal(12345, bob.zip)
+  end
+
+  def test_assign_with_block
+    bob = C.new
+
+    x = lambda {|s| s.name = "Bob Sawyer"; s.address = "123 Maple, Anytown NC"; s.zip = 12345 }
+
+    bob.assign(&x)
+
+    assert_equal("Bob Sawyer", bob.name)
+    assert_equal("123 Maple, Anytown NC", bob.address)
+    assert_equal(12345, bob.zip)
+  end
+
+end
+

data/test/core/kernel/test_assign_from.rb

@@ -0,0 +1,20 @@
+require 'facets/kernel/assign_from.rb'
+require 'test/unit'
+
+class TestKernelAssignFrom < Test::Unit::TestCase
+
+  C = Struct.new(:name, :address, :zip)
+
+  def test_assign_from
+    bob = C.new("Bob Sawyer", "123 Maple, Anytown NC", 12345)
+    joe = C.new("Joe Pitare")
+
+    joe.assign_from(bob, :address, :zip)
+
+    assert_equal("Joe Pitare", joe.name)
+    assert_equal("123 Maple, Anytown NC", joe.address)
+    assert_equal(12345, joe.zip)
+  end
+
+end
+

data/test/more/test_prepend.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'facets/prepend'
+
+class TC_Class_Prepend < Test::Unit::TestCase
+
+   class C
+     def f
+       "f"
+     end
+   end
+
+   module M
+     def f
+       '{' + super + '}'
+     end
+   end
+
+   class C
+     prepend M
+   end
+
+   #
+   def test_prepend
+     c = C.new
+     assert_equal("{f}", c.f)
+   end
+
+end