facets 1.4.5 → 1.7.0

data/lib/facets/core/kernel/meta.rb

@@ -0,0 +1,21 @@
+require 'facets/more/functor'
+
+module Kernel
+
+  # Provides access to an object's metaclass (ie. singleton)
+  # by-passsing access provisions. So for example:
+  #
+  #   class X
+  #     meta.attr_accesser :a
+  #   end
+  #
+  #   X.a = 1
+  #   X.a #=> 1
+
+  def meta
+    @_meta_functor ||= Functor.new do |op,*args|
+      (class << self; self; end).send(op,*args)
+    end
+  end
+
+end

data/lib/facets/core/kernel/object_clone.rb

@@ -0,0 +1,4 @@
+module Kernel
+  alias_method :object_dup, :dup
+  alias_method :object_clone, :clone
+end

data/lib/facets/core/kernel/object_dup.rb

@@ -0,0 +1,2 @@
+# stub
+require 'facets/core/object_clone'

data/lib/facets/core/kernel/to_data.rb

@@ -0,0 +1,114 @@
+require 'facets/core/kernel/object_class'
+
+module Kernel
+
+  # Create a hash representation of an object.
+
+  def to_data( deep=false )
+    #return self if Hash === object_class
+    data = {}
+    data.data_represents( object_class )
+    instance_variables.each do |iv|
+      name = iv[1..-1].to_sym  # remove @
+      value = instance_variable_get(iv)
+      value = value.to_data if deep
+      data[name] = value
+    end
+    data
+  end
+
+  # Restore objects state from a hash representation of the object.
+
+  def from_data(snap)
+    #instance_variables.each { |iv| instance_variable_set(iv, snap[iv]) }
+    snap.each { |iv, value| instance_variable_set("@#{iv}", value) }
+    self
+  end
+end
+
+class Hash
+  def data_represents( klass )
+    @data_represents = klass
+  end
+  def data_represents?( klass )
+    @data_represents == klass
+  end
+
+  def to_object( klass=nil )
+    #raise unless @data_represention
+    obj = (klass||@data_represents).allocate
+    obj.from_data( self )
+  end
+
+  def to_data() dup end
+  def from_data(snap) replace(snap) end
+end
+
+class Array
+  def to_data ; dup ; end
+end
+
+class String
+  def to_data() dup end
+  def from_data(snap) replace(snap) end
+end
+
+class Struct
+  def to_data
+    snap = Hash.new
+    each_pair {|k,v| snap[k] = v}
+    snap
+  end
+
+  def from_data(snap)
+    snap.each_pair {|k,v| send(k.to_s + "=", v)} 
+  end
+end
+
+
+=begin test
+
+  class TestToData < Test::Unit::TestCase
+
+    class X
+      attr_accessor :a, :b, :c
+      def initialize(a, b, c)
+        @a, @b, @c = a, b, c
+      end
+      def ==( other )
+        return false if @a != other.a
+        return false if @b != other.b
+        return false if @c != other.c
+        true
+      end
+    end
+
+    def test_001
+      x = X.new( 1, 2, 3 )
+      assert_equal( { :a=>1, :b=>2, :c=>3 }, x.to_data )
+    end
+
+    def test_002
+      x = X.new( 1, 2, [:a,:b] )
+      assert_equal( { :a=>1, :b=>2, :c=>[:a,:b] }, x.to_data )
+    end
+
+    def test_003
+      x = X.new( 1, 2, 3 )
+      d = x.to_data
+      x.a = 3
+      assert_equal( 3, x.a )
+      x.from_data(d)
+      assert_equal( 1, x.a )
+    end
+
+    def test_004
+      x = X.new( 1, 2, 3 )
+      d = x.to_data
+      y = d.to_object
+      assert_equal( x, y )
+    end
+
+  end
+
+=end

data/lib/facets/core/module/alias_method_chain.rb

@@ -26,7 +26,7 @@ class Module
   #
   # so you can safely chain foo, foo?, and foo! with the same feature.
 
-  def alias_method_chain(target, feature=nil)
+  def alias_method_chain(target, feature)
     # Strip out punctuation on predicates or bang methods since
     # e.g. target?_without_feature is not a valid method name.
     aliased_target, punctuation = target.to_s.sub(/([?!])$/, ''), $1

data/lib/facets/core/module/wrap_method.rb

@@ -1,8 +1,10 @@
 class Module
 
+  #--
   # Don't think we should bother making this private.
   # That sort of defeats some of the AOP usefulness of this.
   #private
+  #++
 
   # Creates a new method wrapping the previous of
   # the same name. Reference to the old method
@@ -18,9 +20,7 @@ class Module
   # that take a block.
 
   def wrap_method( sym, &blk )
-    raise ArgumentError, "method does not exist" unless method_defined?( sym )
     old = instance_method(sym)
-    undef_method(sym)
     define_method(sym) { |*args| blk.call(old.bind(self), *args) }
   end
 

data/lib/facets/core/nilclass/status.rb

@@ -4,12 +4,12 @@ class NilClass
   # Nil#status makes it possible to pass messages
   # through a "failure" chain.
 
-  def status( *status )
-    if status.empty?
-      return @status
-    else
+  def status( status=nil )
+    if status
       @status = status
       self
+    else
+      @status
     end
   end
 

data/lib/facets/core/numeric/distance.rb

@@ -0,0 +1,37 @@
+
+class Numeric
+
+  # Returns the distance between self an another value.
+  # This is the same as #- but it provides an alternative
+  # for common naming between variant classes.
+  #
+  #   4.distance(3)  #=> 1
+  #
+  def distance( other )
+    self - other
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCNumeric < Test::Unit::TestCase
+
+    def test_distance
+      assert_equal( 4, 10.distance(6) )
+      assert_equal( 2, 10.distance(8) )
+      assert_equal( -2, 7.distance(9) )
+    end
+
+  end
+
+=end

data/lib/facets/core/proc/compose.rb

@@ -12,22 +12,11 @@ class Proc
   #  a.compose(b).call(4)  #=> 6
   #  b.compase(a).call(4)  #=> 4
   #
-  def compose(other)
-    raise ArgumentError, "arity count mismatch" unless arity == other.arity
-    #proc{ |*a| self.call(other.call(*a)) }
-    proc{ |*a| self.call(*other.call(*a)) }
+  def compose(g)
+    raise ArgumentError, "arity count mismatch" unless arity == g.arity
+    proc{ |*a| self[ *g[*a] ] }
   end
 
-  # Operator for compose.
-  #
-  #  a = lambda { |x| x + 4 }
-  #  b = lambda { |y| y / 2 }
-  #
-  #  (a * b).call(4)  #=> 6
-  #  (b * a).call(4)  #=> 4
-  #
-  alias_method( :*, :compose )
-
 end
 
 
@@ -50,13 +39,6 @@ end
       assert_equal( 4, (b.compose(a)).call(4) )
     end
 
-    def test_compose_op
-      a = lambda { |x| x + 4 }
-      b = lambda { |y| y / 2 }
-      assert_equal( 6, (a * b).call(4) )
-      assert_equal( 4, (b * a).call(4) )
-    end
-
   end
 
 =end

data/lib/facets/core/proc/op_mul.rb

@@ -1,2 +1,51 @@
-# stub
-require 'facet/proc/compose'
+
+class Proc
+
+  # Operator for Proc#compose and Integer#times_collect/of.
+  #
+  #  a = lambda { |x| x + 4 }
+  #  b = lambda { |y| y / 2 }
+  #
+  #  (a * b).call(4)  #=> 6
+  #  (b * a).call(4)  #=> 4
+  #
+  def *(x)
+    if Integer===x
+      # collect times
+      a = []; x.times{|i| a << call(i)}; a
+    else
+      # compose procs
+      proc{|*a| self[x[*a]]}
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCProc < Test::Unit::TestCase
+
+    def test_compose_op
+      a = lambda { |x| x + 4 }
+      b = lambda { |y| y / 2 }
+      assert_equal( 6, (a * b).call(4) )
+      assert_equal( 4, (b * a).call(4) )
+    end
+
+    def test_times_collect_op
+      a = lambda { |x| x + 4 }
+      assert_equal( [4,5,6], a * 3 )
+    end
+
+  end
+
+=end

data/lib/facets/core/proc/to_method.rb

@@ -1,52 +1,40 @@
-
 #--
-# Credit for #to_method goes to Forian Gross (flgr).
+# Credit goes to Forian Gross (flgr) and Mauricio Fernandez.
 #--
 
 require 'thread'
 
-class Proc
+class Object
+  module  TemporaryMethods; end
+  include TemporaryMethods
+end
 
-  MethodMutexes = Hash.new do |hash, key|
-    hash[key] = Mutex.new
-  end
+class Proc
 
   # Creates a local method based on a Proc.
-  def to_method(name=nil)
-    name ||= "!to_method_temp#{self.id}"
-    recv = eval("self", self)
-    klass = recv.class
-    MethodMutexes[klass => name].synchronize do
-      begin
-        klass.send(:define_method, name, &self)
-        return recv.method(name)
-      ensure
-        klass.send(:remove_method, name) if not name
+  def to_method(name=nil, recv=nil)
+    recv ||= eval("self", self)
+    klass = name ? recv.class : TemporaryMethods
+    begin
+      old, Thread.critical = Thread.critical, true
+      unless name
+        n = 0
+        n += 1 while klass.method_defined?(name = "__to_method_#{n}")
+        #n += 1 while recv.respond_to?(name = "__to_method_#{n}")
+      end
+      klass.send(:define_method, name, &self)
+      recv.method(name) #if klass == TemporaryMethods
+    ensure
+      if klass == TemporaryMethods
+        klass.send(:remove_method, name) #rescue nil
+        #klass.send(:undef_method, name) #rescue nil
       end
+      Thread.critical = old
     end
   end
 
 end
 
-=begin
-  # Alternate. I assume this is less "safe" then the above.
-  def to_method
-      # get the object that this proc is bound to
-    obj = eval 'self', self.binding
-      # get the virtual class for the object
-    obj_class = class << obj; self; end
-    proc = self
-      # define the method. A normally invalid method name was chosen to minimize
-      # the chance of a collision. Store the newly created method away.
-    obj_class.instance_eval{define_method(:" ", &proc)}
-    method = obj.method(:" ")
-      # remove the method, and return it.
-    obj_class.instance_eval{remove_method(:" ")}
-    method
-  end
-=end
-
-
 
 #  _____         _
 # |_   _|__  ___| |_
@@ -62,13 +50,26 @@ end
 
     def test_to_method
       a = 2
-      tproc = proc { |x| x + a }  
+      tproc = proc { |x| x + a }
       tmethod = tproc.to_method(:tryit)
       assert_equal( 3, tmethod.call(1) )
       assert_respond_to( self, :tryit )
       assert_equal( 3, tryit(1) )
     end
 
+    # This is dependent on other tests! Be aware!
+
+    def test_memory_leak
+      a = 2
+      tproc = proc { |x| x + a }
+      100.times {
+        tmethod = tproc.to_method
+        assert_equal( 3, tmethod.call(1) )
+      }
+      meths = Symbol.all_symbols.select { |s| s.to_s =~ /^__to_method/ }
+      assert_equal( 1, meths.size )
+    end
+
   end
 
 =end

data/lib/facets/core/string/divide.rb

@@ -0,0 +1,43 @@
+
+class String
+
+  # Breaks a string up into an array based on a regular expression.
+  # Similar to scan, but includes the matches.
+  #
+  #   s = "<p>This<b>is</b>a test.</p>"
+  #   s.divide( /\<.*?\>/ )
+  #
+  # _produces_
+  #
+  #   ["<p>This", "<b>is", "</b>a test.", "</p>"]
+  #
+  def divide( re )
+    re2 = /#{re}.*?(?=#{re}|\Z)/
+    self.scan(re2) #{re}(?=#{re})/)
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_shatter
+      s = "<p>This<b>is</b>a test.</p>"
+      sh = s.divide( /<.*?>/ )
+      e = ["<p>This", "<b>is", "</b>a test.", "</p>"]
+      assert_equal(e, sh)
+    end
+
+  end
+
+=end