facets 2.8.4 → 2.9.0.pre.1

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

@@ -0,0 +1 @@
+require 'facets/module/op'

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

@@ -0,0 +1 @@
+require 'facets/module/op'

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

@@ -0,0 +1 @@
+require 'facets/module/op'

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

@@ -2,20 +2,18 @@ require 'facets/string/pathize'
 
 class Module
 
-  # Converts a class name to a unix path
+  # Converts a class name to a unix path.
   #
-  # Examples
-  #   CoolClass.pathize       #=> "cool_class"
-  #   My::CoolClass.pathize   #=> "my/cool_class"
+  #   module ::ExamplePathize
+  #     module Example
+  #     end
+  #   end
+  #
+  #   ExamplePathize.pathize           #=> "example_pathize"
+  #   ExamplePathize::Example.pathize  #=> "example_pathize/example"
   #
   def pathize
     name.pathize
-    #to_s.
-    #  gsub(/::/, '/').
-    #  gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-    #  gsub(/([a-z\d])([A-Z])/,'\1_\2').
-    #  tr("-", "_").
-    #  downcase
   end
 
 end

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

@@ -6,21 +6,21 @@ class Module
   # defines methods by the name of a hash key which
   # calls the method with the name of the hash's value.
   #
-  #   class Example
+  #   class RedirectExample
   #     redirect_method :hi => :hello, :hey => :hello
   #     def hello(name)
-  #       puts "Hello, #{name}."
+  #       "Hello, #{name}."
   #     end
   #   end
   #
-  #   e = Example.new
+  #   e = RedirectExample.new
   #   e.hello("Bob")    #=> "Hello, Bob."
   #   e.hi("Bob")       #=> "Hello, Bob."
   #   e.hey("Bob")      #=> "Hello, Bob."
   #
-  # The above class definition is equivalent to:
+  # The above class definition is equivalent to ...
   #
-  #   class Example
+  #   class RedirectExample
   #     def hi(*args)
   #       hello(*args)
   #     end

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

@@ -0,0 +1 @@
+require 'facets/module/nodef'

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

@@ -4,7 +4,17 @@ class Module
 
   # Aliases a method and undefines the original.
   #
-  #   rename_method( :to_method, :from_method  )
+  #   class RenameExample
+  #     def foo; "foo"; end
+  #     rename_method(:bar, :foo)
+  #   end
+  # 
+  #   example = RenameExample.new
+  #   example.bar  #=> 'foo'
+  #
+  #   expect NoMethodError do
+  #     example.foo
+  #   end
   #
   # CREDIT: Trans
 
@@ -14,7 +24,7 @@ class Module
     undef_method( from_sym )
   end
 
-  alias_method :rename,   :rename_method
+  alias_method :rename, :rename_method
 
 end
 

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

@@ -2,11 +2,24 @@ require 'facets/module/redirect_method'
 require 'facets/module/redefine_method'
 require 'facets/module/rename_method'
 require 'facets/module/wrap_method'
+require 'facets/module/nodef'
 
 class Module
 
-  # Return a new module based on another.
-  # This includes the original module into the new one.
+  # Return a new module based on another. This includes the original module
+  # into the new revised module.
+  #
+  #   module ReviseExample
+  #     def foo; "foo"; end
+  #   end
+  #
+  #   ReviseExample2 = ReviseExample.revise do
+  #     alias_method :bar, :foo
+  #   end
+  #
+  #   object = Object.new
+  #   object.extend ReviseExample2
+  #   object.bar  #=> 'foo'
   #
   # CREDIT: Trans
 
@@ -18,45 +31,11 @@ class Module
   end
 
   alias_method :revisal, :revise
+end
 
-  # Using integrate is just like using include except the
-  # module included is a reconstruction of the one given
-  # altered by the commands given in the block.
-  #
-  # Convenient commands available are: #rename, #redef,
-  # #remove, #nodef and #wrap. But any module method
-  # can be used.
-  #
-  #   module W
-  #     def q ; "q" ; end
-  #     def y ; "y" ; end
-  #   end
-  #
-  #   class X
-  #     integrate W do
-  #       nodef :y
-  #     end
-  #   end
-  #
-  #   x = X.new
-  #   x.q  #=> "q"
-  #   x.y  #=> missing method error
-  #
-  # This is like #revisal, but #revisal only
-  # returns the reconstructred module. It does not
-  # include it.
-  #
-  # CREDIT: Trans
-
-  def integrate(mod, &block)
-    #include mod.revisal( &blk )
-    m = Module.new{ include mod }
-    m.class_eval(&block)
-    include m
-  end
-
-  alias_method :remove, :remove_method
-  alias_method :nodef,  :undef_method
-
+class Class
+  undef_method :revise
+  undef_method :revisal
 end
 
+

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

@@ -5,7 +5,7 @@ class Module
     # Sets an option to the given value. If the value is a proc,
     # the proc will be called every time the option is accessed.
     #
-    # CREDIT: ? (Sinatra)
+    # CREDIT: Blake Mizerany (Sinatra)
 
     def set(option, value=self, &block)
       raise ArgumentError if block && value != self

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

@@ -0,0 +1 @@
+require 'facets/module/instance_method_defined'

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

@@ -2,13 +2,13 @@ class Module
 
   # Returns the name of module's container module.
   #
-  #   module Example
-  #     class Demo
+  #   module ::SpaceName
+  #     class Example
   #     end
   #   end
   #
-  #   Demo.name         #=> "Example::Demo"
-  #   Demo.spacename    #=> "Example"
+  #   SpaceName::Example.name         #=> "SpaceName::Example"
+  #   SpaceName::Example.spacename    #=> "SpaceName"
   #
   # This used to be called +dirname+.
   #

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

@@ -0,0 +1,20 @@
+class Module
+
+  # Create an instance of Object and extend it with +self+.
+  #
+  #   mod = Module.new do
+  #     def foo; "foo"; end
+  #   end
+  #
+  #   obj = mod.to_obj
+  #
+  #   obj.foo #=> "foo"
+  #
+  def to_obj
+    o = Object.new
+    o.extend self
+    o
+  end
+
+end
+

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

@@ -2,17 +2,24 @@ class Module
 
   #private  # (we'll leave this one public for AOP-like uses).
 
-  # Creates a new method wrapping the previous of
-  # the same name. Reference to the old method
-  # is passed into the new definition block
-  # as the first parameter.
+  # Creates a new method wrapping the previous of the same name.
+  # Reference to the old method is passed into the new definition
+  # block as the first parameter.
   #
-  #   wrap_method( sym ) { |old_meth, *args|
-  #     old_meth.call
-  #     ...
-  #   }
+  #   class WrapExample
+  #     def foo
+  #       "foo"
+  #     end
   #
-  # Keep in mind that this can not be used to wrap methods
+  #     wrap_method(:foo) do |old_meth, *args|
+  #       old_meth.call + '!'
+  #     end
+  #   end
+  #
+  #   example = WrapExample.new
+  #   example.foo #=> 'foo!'
+  #
+  # Keep in mind that this cannot be used to wrap methods
   # that take a block.
   #
   # CREDIT: Trans

data/lib/core/facets/na.rb

@@ -0,0 +1,15 @@
+# N/A exception is useful for specifying non-argument defaults when +nil+
+# is a valid value.
+#
+#   def f(x=NA)
+#   end
+#
+# NA is also used to represent an argument "slot" for Proc#partial.
+#
+# NA is a subclass of ArgumentError.
+
+class NA < ArgumentError
+  class << self
+    def method_missing(*); self; end
+  end
+end

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

@@ -1,10 +1,8 @@
 class Numeric
 
   # Conceptually, rounding is expected to apply to floating point numbers.
-  # However it can actually be applied to pretty much and Numeric object.
-  # For example, one could round an Integer to the nearest kilo. So the
-  # actual round.rb lib is in the numeric folder, but we'll add this
-  # here for convenience.
+  # However it can actually be applied to pretty much any Numeric object.
+  # For example, one could round an Integer to the nearest kilo.
   #
   # See Float#round_at.
 
@@ -20,6 +18,7 @@ class Numeric
 
 end
 
+=begin
 class Integer
 
   # See Float#round_at.
@@ -35,6 +34,7 @@ class Integer
   end
 
 end
+=end
 
 class Float
 

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

@@ -0,0 +1 @@
+require 'facets/numeric/round'

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

@@ -0,0 +1 @@
+require 'facets/numeric/round'

data/lib/core/facets/object.rb

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/core/facets/objectspace/reflect.rb

@@ -6,14 +6,12 @@ module ObjectSpace
   # is actual according to Ruby's Kernel definitions, just
   # in case such methods have been overridden.
   #
-  #  ObjectSpace.reflect(obj).id
+  #  ObjectSpace.reflect("object").object_id
   #
-  #--
   # There is also a global short-cut for this method to ease
   # meta-programming with it.
   #
-  #   $ref[obj].class
-  #++
+  #   $ref["object"].class
   #
   # Typically theis method will be used to gather the object's
   # id, as in the example given, or it's class, but any Kernel
@@ -23,16 +21,31 @@ module ObjectSpace
   # cases it is not needed, but in certain cases is useful
   # for improving the robustness of meta-programming solutions.
   #
-  # Note that this is also equivalent to using +as(Kernel)+:
+  # Note that this is also equivalent to using +as(Kernel)+ ...
   #
-  #   obj.as(Kernel).id
+  #   "object".as(Kernel).object_id
   #
   # But obviously, in this case there is the risk that #as has
   # be overridden too.
   #
   def self.reflect(obj)
-    Functor.new do |meth, *a, &b|
-      Kernel.instance_method(meth).bind(obj).call(*a, &b)
+    ## TODO: use this after 1.8.6 support discontinued
+    ## Functor.new do |op, *a, &b|
+    ##   Kernel.instance_method(op).bind(obj).call(*a, &b)
+    ## end
+    Reflector.new(obj)
+  end
+
+  #
+  class Reflector #:nodoc:
+    instance_methods(true).each{ |m| private m unless /^(__|object_id$)/ =~ m.to_s }
+
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def method_missing(op, *args, &yld)
+      Kernel.instance_method(op).bind(@obj).call(*args, &yld)
     end
   end
 
@@ -40,8 +53,10 @@ end
 
 # Shorcut for +ObjectSpace.reflect+.
 $ref = lambda do |obj|
-  Functor.new do |meth, *a, &b|
-    Kernel.instance_method(meth).bind(obj).call(*a, &b)
-  end
+  ## TODO: use this after 1.8.6 support discontinued
+  ## Functor.new do |meth, *a, &b|
+  ##  Kernel.instance_method(meth).bind(obj).call(*a, &b)
+  ## end
+  ObjectSpace.reflect(obj)
 end
 

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

@@ -1,16 +1,18 @@
+require 'facets/kernel/singleton_class'
+
 class Proc
 
   # Bind a Proc to an object returning a Method.
   #
   # NOTE: This version comes from Rails. The old Facets
-  #       version used thread.rb, but I no longer think
-  #       the implementaiton is thread critical. Please
-  #       make a bug report if this proves wrong.
+  # version used thread.rb, but I no longer think
+  # the implementaiton is thread critical. Please
+  # make a bug report if this proves wrong.
   #
   def bind(object)
     block, time = self, Time.now
-    (class << object; self; end).class_eval do
-      method_name = "__bind_#{time.to_i}_#{time.usec}"
+    method_name = "__bind_#{time.to_i}_#{time.usec}"
+    object.singleton_class.class_eval do
       define_method(method_name, &block)
       method = instance_method(method_name)
       remove_method(method_name)

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

@@ -1,5 +1,13 @@
 class Proc
 
+  # Bind a procedure to an object. This works
+  # wrapping instance_eval on the Proc object
+  # and then wrapping this in a new Proc.
+  #
+  #    a = [1,2,3]
+  #    p1 = Proc.new{ join(' ') }
+  #    p2 = p1.bind_to(a)
+  #    p2.call  #=> '1 2 3'
   #
   def bind_to(object)
     Proc.new{object.instance_eval(&self)}

data/lib/{more/facets → core/facets/proc}/partial.rb

@@ -1,14 +1,21 @@
+require 'facets/na'
+
 class Proc
 
   # Convert a Proc object into new partial Proc object.
   #
   #   a = proc { |a,b,c| a+b+c }
-  #   b = a.partial(X,2,X)
+  #   b = a.partial(NA,2,NA)
   #   b[1,3] #=> 6
   #
+  # Note, the #__ method, which used to be used in stay of NA,
+  # has been deprecated.
+  #
+  #--
   #   a = proc { |a,b,c| a+b+c }
   #   b = a.partial(__,2,__)
   #   b[1,3] #=> 6
+  #++
   #
   # This method is similar to Proc#curry.
   #
@@ -17,23 +24,10 @@ class Proc
   def partial(*args)
     Proc.new do |*spice|
       result = args.collect do |a|
-        X == a ? spice.pop : a
+        NA == a ? spice.pop : a
       end
       call(*result)
     end
   end
 
 end
-
-# X class is used to represent an argument "slot".
-
-class X < ArgumentError
-end
-
-# Convenience method for an argument slot.
-# It simple returns the X exception class.
-
-def __
-  X
-end
-