facets 1.8.0 → 1.8.8

data/work/hash_open.rb

@@ -0,0 +1,23 @@
+class Hash
+  def open!
+    class << self
+      @_were_public = public_instance_methods - ['close!']
+      @_were_public.each { |m| private m }
+      def method_missing(s,*a)
+        if s.to_s[-1,1] == '='
+          self[s] = a.first
+        else
+          return self[s]
+        end
+      end
+    end
+  end
+  def close!
+    class << self
+      @_were_public.each { |m| public m }
+      @_were_public = nil
+      remove_method(:method_missing)
+    end
+  end
+end
+

data/work/openobject-temp.rb

@@ -0,0 +1,45 @@
+# TO BE DEPRECTATED!!!
+
+require 'facets/more/openhash'
+
+OpenObject = OpenHash
+
+# Core Extensions
+
+class NilClass
+  # Nil converts to an empty OpenHash.
+
+  def to_openobject
+    OpenObject.new
+  end
+end
+
+class Hash
+  # Convert a Hash into an OpenHash.
+
+  def to_openobject
+    OpenObject[self]
+  end
+end
+
+class Proc
+  # Translates a Proc into an OpenHash. By droping an OpenHash into
+  # the Proc, the resulting assignments incured as the procedure is
+  # evaluated produce the OpenHash. This technique is simlar to that
+  # of MethodProbe.
+  #
+  #   p = lambda { |x|
+  #     x.word = "Hello"
+  #   }
+  #   o = p.to_openhash
+  #   o.word #=> "Hello"
+  #
+  # NOTE The Proc must have an arity of one --no more and no less.
+
+  def to_openobject
+    raise ArgumentError, 'bad arity for converting Proc to openhash' if arity != 1
+    o = OpenObject.new
+    self.call( o )
+    o
+  end
+end

metadata

@@ -3,15 +3,15 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: facets
 version: !ruby/object:Gem::Version 
-  version: 1.8.0
-date: 2007-01-24 00:00:00 -05:00
+  version: 1.8.8
+date: 2007-01-31 00:00:00 -05:00
 summary: If Godzilla were a Programmer's Library
 require_paths: 
 - lib
 email: transfire@gmail.com
 homepage: http://facets.rubyforge.org
 rubyforge_project: facets
-description: 
+description: Facets is a large collection of core extension methods and module additions for the Ruby programming language. The core extensions are unique by virtue of thier atomicity. Methods are stored in their own files, allowing for highly granular control of requirements. The modules include a variety of useful classes, mixins and microframeworks, from the Functor to a full-blown SI Units system.
 autorequire: 
 default_executable: 
 bindir: bin
@@ -37,6 +37,8 @@ files:
 - work/README
 - work/TODO
 - work/op_rshift.rb
+- work/hash_open.rb
+- work/openobject-temp.rb
 - work/misc/calibre/ProjectInfo.nilcomparable
 - work/misc/calibre/ProjectInfo.downloader
 - work/misc/calibre/ProjectInfo.reference
@@ -295,7 +297,6 @@ files:
 - lib/facet/association.rb
 - lib/facet/filesystem.rb
 - lib/facet/doublemetaphone.rb
-- lib/facet/openhash.rb
 - lib/facet/main_as_module.rb
 - lib/facet/linkedlist.rb
 - lib/facet/autovivify.rb
@@ -536,11 +537,11 @@ files:
 - lib/facet/enumerable/probability.rb
 - lib/facet/enumerable/elementwise.rb
 - lib/facet/enumerable/one.rb
+- lib/facet/enumerable/cart.rb
 - lib/facet/enumerable/each_with_counter.rb
 - lib/facet/enumerable/accumulate.rb
 - lib/facet/enumerable/cascade.rb
 - lib/facet/enumerable/compact_map.rb
-- lib/facet/enumerable/cross.rb
 - lib/facet/enumerable/to_h.rb
 - lib/facet/enumerable/every.rb
 - lib/facet/enumerable/ideal_entropy.rb
@@ -578,8 +579,10 @@ files:
 - lib/facet/enumerable/ew.rb
 - lib/facet/enumerable/permutation.rb
 - lib/facet/enumerable/injecting.rb
+- lib/facet/enumerable/cartesian_product.rb
+- lib/facet/enumerable/self/cart.rb
 - lib/facet/enumerable/self/combinations.rb
-- lib/facet/enumerable/self/cross.rb
+- lib/facet/enumerable/self/cartesian_product.rb
 - lib/facet/file/self/open_as_string.rb
 - lib/facet/file/self/read_binary.rb
 - lib/facet/file/self/create.rb
@@ -956,7 +959,6 @@ files:
 - lib/facets/more/association.rb
 - lib/facets/more/filesystem.rb
 - lib/facets/more/doublemetaphone.rb
-- lib/facets/more/openhash.rb
 - lib/facets/more/main_as_module.rb
 - lib/facets/more/linkedlist.rb
 - lib/facets/more/autovivify.rb
@@ -1204,11 +1206,11 @@ files:
 - lib/facets/core/enumerable/probability.rb
 - lib/facets/core/enumerable/elementwise.rb
 - lib/facets/core/enumerable/one.rb
+- lib/facets/core/enumerable/cart.rb
 - lib/facets/core/enumerable/each_with_counter.rb
 - lib/facets/core/enumerable/accumulate.rb
 - lib/facets/core/enumerable/cascade.rb
 - lib/facets/core/enumerable/compact_map.rb
-- lib/facets/core/enumerable/cross.rb
 - lib/facets/core/enumerable/to_h.rb
 - lib/facets/core/enumerable/every.rb
 - lib/facets/core/enumerable/ideal_entropy.rb
@@ -1246,8 +1248,10 @@ files:
 - lib/facets/core/enumerable/ew.rb
 - lib/facets/core/enumerable/permutation.rb
 - lib/facets/core/enumerable/injecting.rb
+- lib/facets/core/enumerable/cartesian_product.rb
+- lib/facets/core/enumerable/self/cart.rb
 - lib/facets/core/enumerable/self/combinations.rb
-- lib/facets/core/enumerable/self/cross.rb
+- lib/facets/core/enumerable/self/cartesian_product.rb
 - lib/facets/core/file/self/open_as_string.rb
 - lib/facets/core/file/self/read_binary.rb
 - lib/facets/core/file/self/create.rb

data/lib/facet/enumerable/cross.rb

@@ -1 +0,0 @@
-require 'facets/core/enumerable/cross.rb'

data/lib/facet/enumerable/self/cross.rb

@@ -1 +0,0 @@
-require 'facets/core/enumerable/self/cross.rb'

data/lib/facet/openhash.rb

@@ -1 +0,0 @@
-require 'facets/more/openhash.rb'

data/lib/facets/core/enumerable/cross.rb

@@ -1,47 +0,0 @@
-#--
-# Cross product adapted from code by Michael Neuman.
-#++
-require 'facet/enumerable/self/cross'
-
-module Enumerable
-
-  # The instance level cross-product method.
-  #
-  #   a = []
-  #   [1,2].cross([4,5]){|elem| a << elem }
-  #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
-  #
-  #--
-  # TODO Make a more efficient version just for Array (?)
-  #++
-  def cross(*enums, &block)
-    Enumerable.cross(self, *enums, &block)
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_cross
-      a = [1,2,3].cross([4,5,6])
-      assert_equal( [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]], a )
-      a = []
-      [1,2,3].cross([4,5,6]) {|elem| a << elem }
-      assert_equal( [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]], a )
-    end
-
-  end
-
-=end

data/lib/facets/core/enumerable/self/cross.rb

@@ -1,85 +0,0 @@
-#--
-# Cross product adapted from code by Michael Neuman.
-#++
-require 'generator'
-
-module Enumerable
-
-  #  Provides the cross-product of two or more Enumerables.
-  #  This is the class-level method. The instance method
-  #  calls on this.
-  #
-  #    Enumerable.cross([1,2], [4], ["apple", "banana"])
-  #    #=> [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
-  #
-  #    Enumerable.cross([1,2], [3,4])
-  #    #=> [[1, 3], [1, 4], [2, 3], [2, 4]]
-  #
-  #--
-  # TODO Make a more efficient version just for Array (?)
-  #++
-  def self.cross(*enums, &block)
-
-    raise if enums.empty?
-    gens = enums.map{|e| Generator.new(e)}
-    return [] if gens.any? {|g| g.end?}
-
-    sz = gens.size
-    res = []
-    tuple = Array.new(sz)
-
-    loop do
-      # fill tuple
-      (0 ... sz).each { |i|
-        tuple[i] = gens[i].current
-      }
-      if block.nil?
-        res << tuple.dup
-      else
-        block.call(tuple.dup)
-      end
-
-      # step forward
-      gens[-1].next
-      (sz-1).downto(0) do |i|
-        if gens[i].end?
-          if i > 0
-            gens[i].rewind
-            gens[i-1].next
-          else
-            return res
-          end
-        end
-      end
-    end #loop
-
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCEnumerable < Test::Unit::TestCase
-
-    def test_cross
-      i = [[1,2], [3,4]]
-      o = [[1, 3], [1, 4], [2, 3], [2, 4]]
-      assert_equal( o, Enumerable.cross(*i) )
-      i = [[1,2], [4], ["apple", "banana"]]
-      o = [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
-      assert_equal( o, Enumerable.cross(*i) )
-    end
-
-  end
-
-=end

data/lib/facets/more/openhash.rb

@@ -1,350 +0,0 @@
-# = openhash.rb
-#
-# == Copyright (c) 2005,2006 Thomas Sawyer
-#
-#   Ruby License
-#
-#   This module is free software. You may use, modify, and/or redistribute this
-#   software under the same terms as Ruby.
-#
-#   This program is distributed in the hope that it will be useful, but WITHOUT
-#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-#   FOR A PARTICULAR PURPOSE.
-#
-# == Authors and Contributors
-#
-# * Thomas Sawyer
-# * George Moschovitis
-
-# Author::    Thomas Sawyer
-# Copyright:: Copyright (c) 2005 Thomas Sawyer
-# License::   Ruby License
-
-require 'facets/core/hash/to_h'
-require 'facets/core/hash/to_proc'
-require 'facets/core/kernel/object_class'
-require 'facets/core/kernel/object_hexid'
-#require 'facets/core/hash/symbolize_keys'
-#require 'facets/more/methodfilter'
-
-# = OpenHash
-#
-# OpenHash is similar to OpenStruct, but differs in a couple ways.
-#
-# OpenHash is a subclass of Hash and can do just about everything
-# a Hash can do, except that most public methods have been made
-# protected and thus only available internally or via #send.
-# A small number, like #each are still exposed publically though
-# b/c of their importance.
-#
-# OpenHash will also clobber any method for which a slot is defined.
-# Even generally very important methods can be clobbered, like
-# instance_eval. So be careful. OpenHash should be used in highly
-# controlled scenarios. If you want to pass one off to an "unknown"
-# rountine, it is best to convert it to a Hash first and convert it
-# back to an OpenHash when finished. To facilitate this the method
-# #as_hash! is provided.
-#
-#   o = OpenHash.new(:a=>1,:b=>2)
-#   o.as_hash!{ |h| h.update(:a=>6) }
-#   o #=> #<OpenHash {:a=>6,:b=>2}>
-#
-# Finally, unlike a regular Hash, all OpenHash's keys are symbols and
-# all keys are converted to such using #to_sym on the fly.
-
-class OpenHash < Hash
-
-  PUBLIC_METHODS = /(^__|^instance_|^object_|^\W|^as$|^send$|^class$|\?$)/
-
-  protected *public_instance_methods.select{ |m| m !~ PUBLIC_METHODS }
-
-  def self.[](hash=nil)
-    new(hash)
-  end
-
-  # Inititalizer for OpenHash is slightly differnt than that of Hash.
-  # It does not take a default parameter, but an initial priming Hash
-  # as with OpenStruct. The initializer can still take a default block
-  # however. To set the degault value use ++#default!(value)++.
-  #
-  #   OpenHash(:a=>1).default!(0)
-
-  def initialize( hash=nil, &yld )
-    super( &yld )
-    hash.each { |k,v| define_slot(k,v) } if hash
-  end
-
-  def initialize_copy( orig )
-    orig.each { |k,v| define_slot(k,v) }
-  end
-
-  # Object inspection. (Careful, this can be clobbered!)
-
-  def inspect
-    "#<#{object_class}:#{object_hexid} #{super}>"
-  end
-
-  # Conversion methods. (Careful, these can be clobbered!)
-
-  def to_a() super end
-
-  def to_h() {}.update(self) end
-  def to_hash() {}.update(self) end
-
-  def to_proc() super  end
-
-  def to_openhash() self end
-
-  # Iterate over each key-value pair. (Careful, this can be clobbered!)
-
-  def each(&yld) super(&yld) end
-
-  # Merge one OpenHash with another creating a new OpenHash.
-
-  def merge( other )
-    d = dup
-    d.send(:update, other)
-    d
-  end
-
-  # Update this OpenHash with another.
-
-  def update( other )
-    begin
-      other.each { |k,v| define_slot(k,v) }
-    rescue
-      other = other.to_h
-      retry
-    end
-  end
-
-  # Set the default value.
-
-  def default!(default)
-    self.default = default
-  end
-
-  # Preform inplace action on OpenHash as if it were a regular Hash.
-  #--
-  # TODO Not so sure about #as_hash!. For starters if it doesn't return a hash it will fail.
-  # TODO Replace by using #as(Hash). Perhaps as_hash and as_object shortcuts? Why?
-  #++
-
-  def as_hash!(&yld)
-    replace(yld.call(to_hash))
-  end
-
-  # Check equality. (Should equal be true for Hash too?)
-
-  def ==( other )
-    return false unless OpenHash === other
-    super(other) #(other.send(:table))
-  end
-
-  def []=(k,v)
-    protect_slot(k)
-    super(k.to_sym,v)
-  end
-
-  def [](k)
-    super(k.to_sym)
-  end
-
-  protected
-
-    def store(k,v)
-      super(k.to_sym,v)
-      define_slot(k)
-    end
-
-    def fetch(k,*d,&b)
-      super(k.to_sym,*d,&b)
-    end
-
-    def define_slot( key, value=nil )
-      protect_slot( key )
-      self[key.to_sym] = value
-    end
-
-    def protect_slot( key )
-      (class << self; self; end).class_eval {
-        protected key rescue nil
-      }
-    end
-
-    def method_missing( sym, arg=nil, &blk)
-      type = sym.to_s[-1,1]
-      key = sym.to_s.sub(/[=?!]$/,'').to_sym
-      if type == '='
-        define_slot(key,arg)
-      elsif type == '!'
-        define_slot(key,arg)
-        self
-      else
-        self[key]
-      end
-    end
-
-end
-
-# Core Extensions
-
-class NilClass
-  # Nil converts to an empty OpenHash.
-
-  def to_openhash
-    OpenHash.new
-  end
-end
-
-class Hash
-  # Convert a Hash into an OpenHash.
-
-  def to_openhash
-    OpenHash[self]
-  end
-end
-
-class Proc
-  # Translates a Proc into an OpenHash. By droping an OpenHash into
-  # the Proc, the resulting assignments incured as the procedure is
-  # evaluated produce the OpenHash. This technique is simlar to that
-  # of MethodProbe.
-  #
-  #   p = lambda { |x|
-  #     x.word = "Hello"
-  #   }
-  #   o = p.to_openhash
-  #   o.word #=> "Hello"
-  #
-  # NOTE The Proc must have an arity of one --no more and no less.
-
-  def to_openhash
-    raise ArgumentError, 'bad arity for converting Proc to openhash' if arity != 1
-    o = OpenHash.new
-    self.call( o )
-    o
-  end
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class TestOpenHash1 < Test::Unit::TestCase
-
-    def test_1_01
-      o = OpenHash.new
-      assert( o.respond_to?(:key?) )
-    end
-
-    def test_1_02
-      assert_instance_of( OpenHash, OpenHash[{}] )
-    end
-
-    def test_1_03
-      f0 = OpenHash.new
-      f0[:a] = 1
-      #assert_equal( [1], f0.to_a )
-      assert_equal( {:a=>1}, f0.to_h )
-    end
-
-    def test_1_04
-      f0 = OpenHash[:a=>1]
-      f0[:b] = 2
-      assert_equal( {:a=>1,:b=>2}, f0.to_h )
-    end
-
-    def test_1_05
-      f0 = OpenHash[:class=>1]
-      assert_equal( 1, f0.class )
-    end
-  end
-
-  class TestOpenHash2 < Test::Unit::TestCase
-
-    def test_2_01
-      f0 = OpenHash[:f0=>"f0"]
-      h0 = { :h0=>"h0" }
-      assert_equal( OpenHash[:f0=>"f0", :h0=>"h0"], f0.send(:merge,h0) )
-      assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
-    end
-
-    def test_2_02
-      f1 = OpenHash[:f1=>"f1"]
-      h1 = { :h1=>"h1" }
-      f1.send(:update,h1)
-      h1.update( f1 )
-      assert_equal( OpenHash[:f1=>"f1", :h1=>"h1"], f1 )
-      assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
-    end
-
-    def test_2_03
-      o = OpenHash[:a=>1,:b=>{:x=>9}]
-      assert_equal( 9, o[:b][:x] )
-      assert_equal( 9, o.b[:x] )
-    end
-
-    def test_2_04
-      o = OpenHash["a"=>1,"b"=>{:x=>9}]
-      assert_equal( 1, o["a"] )
-      assert_equal( 1, o[:a] )
-      assert_equal( {:x=>9}, o["b"] )
-      assert_equal( {:x=>9}, o[:b] )
-      assert_equal( 9, o["b"][:x] )
-      assert_equal( nil, o[:b]["x"] )
-    end
-
-  end
-
-  class TestOpenHash3 < Test::Unit::TestCase
-    def test_3_01
-      fo = OpenHash.new
-      9.times{ |i| fo.send( "n#{i}=", 1 ) }
-      9.times{ |i|
-        assert_equal( 1, fo.send( "n#{i}" ) )
-      }
-    end
-  end
-
-  class TestOpenHash4 < Test::Unit::TestCase
-
-    def test_4_01
-      ho = {}
-      fo = OpenHash.new
-      5.times{ |i| ho["n#{i}".to_sym]=1 }
-      5.times{ |i| fo.send( "n#{i}=", 1 ) }
-      assert_equal(ho, fo.to_h)
-    end
-
-  end
-
-  class TestOpenHash5 < Test::Unit::TestCase
-
-    def test_5_01
-      p = lambda { |x|
-        x.word = "Hello"
-      }
-      o = p.to_openhash
-      assert_equal( "Hello", o.word )
-    end
-
-    def test_5_02
-      p = lambda { |x|
-        x.word = "Hello"
-      }
-      o = OpenHash[:a=>1,:b=>2]
-      assert_instance_of( Proc, o.to_proc )
-    end
-
-  end
-
-=end