facets 1.7.46 → 1.8.0

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

@@ -0,0 +1,14 @@
+
+module Kernel
+
+  # Sets $VERBOSE to true for the duration of the block
+  # and back to its original value afterwards.
+
+  def enable_warnings
+    old_verbose, $VERBOSE = $VERBOSE, true
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+end

data/lib/facets/core/kernel/{quaclass.rb → instance_class.rb}

@@ -1,18 +1,19 @@
 
 module Kernel
 
-  # Easy access to an object qua class, otherwise
-  # known as the object's metaclass or singleton class.
+  # Easy access to an object qua class, otherwise known
+  # as the object's metaclass or singleton class. This
+  # implemnetation alwasy returns the class, even if a
+  # block is provided to eval against it.
   #
   #     It is what it is.
   #
   #               -- transonoma
 
-  def quaclass( &block )
+  def instance_class( &block )
     (class << self; self; end).module_eval(&block) if block
     (class << self; self; end)
   end
-  alias_method :__quaclass__, :quaclass
 
 end
 
@@ -29,9 +30,9 @@ end
 
   class TCKernel < Test::Unit::TestCase
 
-    def test_singleton
+    def test_instance_class
       o = Object.new
-      assert_equal( (class << o; self; end), o.quaclass )
+      assert_equal( (class << o; self; end), o.instance_class )
     end
 
   end

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

@@ -1,17 +1,13 @@
-
-require 'facets/core/proc/to_method'
+require 'facets/core/proc/bind'
 
 module Kernel
 
   # Like instace_eval but allows parameters to be passed.
-  #
-  # The implementation is thread-safe thanks to the 
-  # Thread.current.object_id trick, but it doesn't work with
-  # immediate values (Fixnums and friends), and most 
-  # importantly it bombs when given a frozen object.
-
-  def instance_exec(*args, &block)
-    block.to_method(nil,self).call(*args)
+
+  unless defined?(instance_exec) # 1.9
+    def instance_exec(*arguments, &block)
+      block.bind(self)[*arguments]
+    end
   end
 
 end
@@ -53,6 +49,12 @@ end
       assert_equal([:arg_value, :dummy_value, 1], obj.instance_exec(:arg_value, &block))
     end
 
+    def test_instance_exec_with_immediate_value
+      obj = 1
+      block = lambda { |a| [a,self] }
+      assert_equal(["A", 1], obj.instance_exec("A", &block))
+    end
+
   end
 
 =end

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

@@ -0,0 +1,12 @@
+# CREDIT David Heinemeier Hansson
+
+module Kernel
+
+  def instance_values
+    instance_variables.inject({}) do |values, name|
+    values[name[1..-1]] = instance_variable_get(name)
+      values
+    end
+  end
+
+end

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

@@ -0,0 +1,14 @@
+require 'facets/core/kernel/meta_class'
+
+module Kernel
+
+  # Alias a method defined in the metaclass (ie. singleton class).
+
+  def meta_alias(*args)
+    meta_class do
+      alias_method(*args)
+    end
+  end
+
+end
+

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

@@ -0,0 +1,38 @@
+
+class Object
+
+  # Easy access to an object's "special" class,
+  # otherwise known as it's metaclass or singleton class.
+
+  def meta_class(&block)
+    if block_given?
+      (class << self; self; end).class_eval(&block)
+    else
+      (class << self; self; end)
+    end
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCKernel < Test::Unit::TestCase
+
+    def test_meta_class
+      o = Object.new
+      assert_equal( (class << o; self; end), o.meta_class )
+    end
+
+  end
+
+=end

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

@@ -0,0 +1,14 @@
+require 'facets/core/kernel/meta_class'
+
+module Kernel
+
+  # Add method to a meta-class.
+
+  def meta_def( name, &block )
+    meta_class do
+      define_method( name, &block )
+    end
+  end
+
+end
+

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

@@ -0,0 +1,16 @@
+require 'facets/core/kernel/meta_class'
+
+module Kernel
+
+  # Evaluate code in a metaclass.
+
+  def meta_eval( str=nil, &blk )
+    if str
+      meta_class.instance_eval( str )
+    else
+      meta_class.instance_eval( &blk )
+    end
+  end
+
+end
+

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

@@ -2,12 +2,15 @@
 class Object
 
   # Easy access to an object's "special" class,
-  # otherwise known as it's meta class or singleton class.
-  #
-  def metaclass
-    (class << self; self; end)
+  # otherwise known as it's metaclass or singleton class.
+
+  def metaclass(&block)
+    if block_given?
+      (class << self; self; end).class_eval(&block)
+    else
+      (class << self; self; end)
+    end
   end
-  #warn 'metaclass is being depricated. Use #own or #singleton.'
 
 end
 
@@ -28,13 +31,6 @@ end
     def test_metaclass
       o = Object.new
       assert_equal( (class << o; self; end), o.metaclass )
-      #assert_nothing_raised do
-      #  o.metaclass_eval{ @@a = "test" }
-      #end
-      #assert_nothing_raised do
-      #  o.define_metaclass_method(:testing){ |x| x + 1 }
-      #end
-      #assert_equal(2, o.testing(1) )
     end
 
   end

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

@@ -0,0 +1,21 @@
+
+module Kernel
+
+  # Send only to public methods.
+  #--
+  # Which implementation is faster?
+  #++
+
+  def object_send(name,*args,&blk)
+    #instance_eval "self.#{name}(*args)"
+    if respond_to?(name)
+      send(name,*args,&blk)
+    elsif respond_to?(:method_missing)
+      method_missing(name,*args,&blk)
+    else
+      raise NoMethodError
+    end
+  end
+
+end
+

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

@@ -0,0 +1,39 @@
+require 'facets/core/hash/to_h'
+require 'facets/core/proc/to_h'
+
+module Kernel
+
+  # Similiar to #set_with, but ignores missing setters.
+
+  def populate( data=nil, &yld )
+
+    if data
+      data.to_h.each do |k,v|
+        send( "#{k}=", v ) rescue nil
+      end
+    end
+
+    if yld
+      yld.to_h.each do |k,v|
+        send( "#{k}=", v ) rescue nil
+      end
+    end
+
+    # If the context of the error could be known
+    # this could be used instead of converting the
+    # block to a hash.
+
+    #begin
+    #  yield self
+    #rescue NoMethodError => e
+    #  if e.context == self and e.name.to_s =~ /=$/
+    #    resume
+    #  else
+    #    raise e
+    #  end
+    #end
+
+    self
+  end
+
+end

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

@@ -0,0 +1,41 @@
+
+module Kernel
+
+  # Easy access to an object qua class, otherwise
+  # known as the object's metaclass or singleton class.
+  #
+  # Yes, another one.
+
+  def qua_class(&block)
+    if block_given?
+      (class << self; self; end).class_eval(&block)
+    else
+      (class << self; self; end)
+    end
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCKernel < Test::Unit::TestCase
+
+    def test_qua_class
+      o = Object.new
+      assert_equal( (class << o; self; end), o.qua_class )
+    end
+
+  end
+
+=end
+

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

@@ -1,49 +1,9 @@
-#--
-# Courtesy of Mikael Brockman
-#++
+# Stub for #with
+# 
+# NOTE The #returning method is identical to #with, however technically it 
+# probably should force the return of the stated object irregardless
+# of any return statements that might appear within it's block.
+# But this would require implementation in RUby itself.
 
-module Kernel
+require 'facets/more/with.rb'
 
-  # A Ruby-ized realization of the K combinator.
-  #
-  #   def foo
-  #     returning values = [] do
-  #       values << 'bar'
-  #       values << 'baz'
-  #     end
-  #   end
-  #
-  #   foo # => ['bar', 'baz']
-  #
-  def returning(value)
-    yield
-    value
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCKernel < Test::Unit::TestCase
-
-    def test_returning
-      foo = returning( values = [] ) do
-        values << 'bar'
-        values << 'baz'
-      end
-      assert_equal( ['bar', 'baz'], foo )
-    end
-
-  end
-
-=end

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

@@ -3,12 +3,18 @@ module Kernel
 
   # Call parent class/module methods once bound to self.
 
-  def send_as(klass, meth, *args, &blk)
-    selfclass = Kernel.instance_method(:class).bind(self).call
-    raise ArgumentError if ! selfclass.ancestors.include?(klass)
-    klass.instance_method(meth).bind(self).call(*args, &blk)
+  def send_as( ancestor, sym, *args, &blk )
+    ancestor.instance_method(sym).bind(self).call(*args,&blk)
   end
 
+#--
+#   def send_as(klass, meth, *args, &blk)
+#     selfclass = Kernel.instance_method(:class).bind(self).call
+#     raise ArgumentError if ! selfclass.ancestors.include?(klass)
+#     klass.instance_method(meth).bind(self).call(*args, &blk)
+#   end
+#++
+
 end
 
 

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

@@ -2,12 +2,15 @@ require 'facet/kernel/set_from'
 
 module Kernel
 
-  # Assign via setter methods using a hash (or assoc array).
+  # Assign via setter methods using a hash, associative
+  # array or block.
   #
   #   object.set_with( :a => 1, :b => 2 )
   #   object.set_with( :a, 1, :b, 2 )
   #   object.set_with( [:a, 1], [:b, 2] )
   #   object.set_with( *[[:a, 1], [:b, 2]] )
+  #   object.set_with{ |s| s.a = 1; s.b = 2 }
+  #     
   #
   # These are all the same as doing:
   #
@@ -16,7 +19,10 @@ module Kernel
   #
   # The array forms gaurentees order of operation.
   #
-  def set_with(*args)
+  # This method does not check to make sure the object
+  # repsonds to the setter method. For that see #populate.
+
+  def set_with(*args) #:yield:
     harg = args.last.is_a?(Hash) ? args.pop : {}
 
     unless args.empty?
@@ -33,13 +39,16 @@ module Kernel
     end
 
     args.each do |k,v|
-      self.send( "#{k}=", v ) #if respond_to?("#{k}=")
+      self.send( "#{k}=", v )
     end
 
     harg.each do |k,v|
-      self.send( "#{k}=", v ) #if respond_to?("#{k}=")
+      self.send( "#{k}=", v )
     end
 
+    yield self if block_given?
+
+    self
   end
 
 end
@@ -60,10 +69,19 @@ end
 
     Customer = Struct.new( "Customer", :name, :address, :zip )
 
-    def test_set_with
+    def test_hash
+      bob = Customer.new()
+      x = { :name => "Bob Sawyer", :address => "123 Maple, Anytown NC", :zip => 12345 }
+      bob.set_with(x)
+      assert_equal(x[:name], bob.name)
+      assert_equal(x[:address], bob.address)
+      assert_equal(x[:zip], bob.zip)
+    end
+
+    def test_block
       bob = Customer.new()
-      sethash = { :name => "Bob Sawyer", :address => "123 Maple, Anytown NC", :zip => 12345 }
-      bob.set_with(sethash)
+      x = lambda {|s| s.name = "Bob Sawyer"; s.address = "123 Maple, Anytown NC"; s.zip = 12345 }
+      bob.set_with(&x)
       assert_equal("Bob Sawyer", bob.name)
       assert_equal("123 Maple, Anytown NC", bob.address)
       assert_equal(12345, bob.zip)