facets 2.9.2 → 2.9.3

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

@@ -1,3 +1,5 @@
+require 'facets/na'
+
 module Kernel
 
   # Assign via writer using arguments, hash or associative array.
@@ -22,25 +24,21 @@ module Kernel
   #   object.a = 1 if object.respond_to?(:a=)
   #   object.b = 2 if object.respond_to?(:b=)
   #
-  # Using an associative array instead of hash guarantees order of assignemnt
+  # Using an associative array instead of a hash guarantees order of assignment
   # for older versions of Ruby (< 1.8.7).
   #
-  # NOTE: This method used to allow a block which would yield on +self+.
-  # This feature has been deprecated. There are plenty of other ways to
-  # handle this, such as #tap.
-  #
   # TODO: Should this be called #set instead? Consider Module#set in this
   # question, and also #set_from as the alias of #assign_from.
 
-  def assign(data=nil, value=Exception) #:yield:
-    if data
-      if value==Exception
-        data.each do |(k,v)|
-          __send__("#{k}=", v) if respond_to?("#{k}=")
-        end
-      else
-        __send__("#{data}=", value) if respond_to?("#{data}=")
+  def assign(data=nil, value=NA)
+    return self unless data
+
+    if value==NA
+      data.each do |(k,v)|
+        __send__("#{k}=", v) if respond_to?("#{k}=")
       end
+    else
+      __send__("#{data}=", value) if respond_to?("#{data}=")
     end
     self
   end

data/lib/{core-uncommon → core}/facets/kernel/demo.rb

@@ -1,5 +1,8 @@
 module Kernel
 
+  # TODO: Is there a way to do this without the eval string in block?
+  # Preferably just a block and no string.
+
   # For debugging and showing examples. Currently this
   # takes an argument of a string in a block...
   #
@@ -13,12 +16,12 @@ module Kernel
   #   a.slice(1,2)            #=>  [2, 3]
   #   a.map { |x| x**3 }      #=>  [1, 8, 27]
   #
-  # TODO: Is there a way to do this without the eval string in block?
-  # Preferably just a block and no string.
-  #
-  # NOTE: This is not (presently) a common core extension and is not
+  # NOTE: This method is not a common core extension and is not
   # loaded automatically when using <code>require 'facets'</code>.
-
+  #
+  # @uncommon
+  #   require 'facets/kernel/demo'
+  #
   def demo(out=$stdout,&block)
     out << sprintf("%-25s#=>  %s\n", expr = block.call, eval(expr, block.binding).inspect)
   end

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

@@ -0,0 +1,33 @@
+require 'facets/functor'
+
+module Kernel
+
+  # Call methods on the eigenclass (i.e. the singleton_class).
+  #
+  #   name = "Tom"
+  #   name.eigen.define_method(:turkey){ self + " Turkey" }
+  #   name.turkey #=> "Tom Turkey"
+  #
+  # One the nice things you can do with #eigen, is define class attributes
+  # without having to open a `class << self` block.
+  #
+  #   c = Class.new do
+  #     eigen.attr_accessor :a
+  #   end
+  #   c.a = 1
+  #   c.a #=> 1
+  #
+  # NOTE: This was once called `#meta`, but meta is such a generic
+  # and overly used term that 'eigen' was decided upon as a better
+  # choice. You can thank or blame _why for the term, if you like.
+  #
+  def eigen
+    Functor.new do |op,*a,&b|
+      (class << self; self; end).class_eval do
+        __send__(op,*a,&b)
+      end
+    end
+  end
+
+end
+

data/{src/core-uncommon → lib/core}/facets/kernel/eigenclass.rb

@@ -8,11 +8,14 @@ module Kernel
   # unclasped and bearing north toward chilled shrimp.
   # I know what my Hallowe’en pumpkin is going to say.
   #
-  # NOTE: This is not (presently) a common core extension and is not
+  # NOTE: This method is not a common core extension and is not
   # loaded automatically when using <code>require 'facets'</code>.
   #
   # CREDIT: WhyTheLuckyStiff
-
+  #
+  # @uncommon
+  #   require 'facets/kernel/eigenclass'
+  #
   def eigenclass
     (class << self; self; end)
   end

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

@@ -17,7 +17,10 @@ module Kernel
   #
   #   obj.foo  #=> "foo"
   #
-  # NOTE: This is one of the few overrides in Facents.
+  # NOTE: This is one of the few core overrides in Facets.
+  #
+  # @author Trans
+  # @author Marco Otte-Witte (bug fix)
   def extend(*mod, &blk)
     _extend(*mod) unless mod.empty?
     _extend Module.new(&blk) if blk

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

@@ -1,8 +1,8 @@
 module Kernel
 
-  # Don't say it!
-  #
   # TODO: Must reduce the number of singleton method methods.
+
+  # Don't say it!
   #
   def extension
     class << self; self; end

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

@@ -0,0 +1,44 @@
+require 'facets/class/hierarchically'
+
+module Kernel
+
+  # Send a message to each ancestor in an object's class hierarchy.
+  # The method will only be called if the method is defined for the
+  # ancestor.
+  # 
+  # This can be very useful for setting up a `preinitialize` system.
+  #
+  #   m = Module.new do
+  #         attr :a
+  #         def preinitialize
+  #           @a = 1
+  #         end
+  #       end
+  #         
+  #   c = Class.new do
+  #         include m
+  #         def initialize
+  #           hierarchical_send(:preinitialize)
+  #         end
+  #       end
+  #
+  #   c.new.a  #=> 1
+  #
+  # @todo Include singleton class?
+  def hierarchical_send(method_name, *args, &block)
+    method_name = method_name.to_s if RUBY_VERSION < '1.9'
+    this = self
+    self.class.hierarchically do |anc|
+      ## is there really no better way to check for the method?
+      if anc.instance_methods(false).include?(method_name) or
+           anc.public_instance_methods(false).include?(method_name) or
+           anc.private_instance_methods(false).include?(method_name) or
+           anc.protected_instance_methods(false).include?(method_name)
+        im = anc.instance_method(method_name)
+        ##im.arity == 0 ? im.bind(this).call(&block) : im.bind(this).call(*args, &block)
+        im.bind(this).call(*args, &block)
+      end
+    end
+  end
+
+end

data/lib/{core-uncommon → core}/facets/kernel/instance_exec.rb

@@ -20,7 +20,10 @@ class Object #module Kernel
     # and is not loaded automatically when using <code>require 'facets'</code>.
     # However it is a core method in Ruby 1.9, so this only matters for users
     # of Ruby 1.8.x or below.
-
+    #
+    # @uncommon
+    #   require 'facets/kernel/instance_exec'
+    #
     def instance_exec(*args, &block)
       begin
         old_critical, Thread.critical = Thread.critical, true

data/lib/{core-uncommon → core}/facets/kernel/memo.rb

@@ -23,9 +23,12 @@ module Kernel
   #   ex.a = 20
   #   ex.m  #=> 10
   #
-  # NOTE: This is not (presently) a common core extension and is not
+  # NOTE: This method is not a common core extension and is not
   # loaded automatically when using <code>require 'facets'</code>.
-
+  #
+  # @uncommon
+  #   require 'facets/kernel/memo'
+  #
   def memo(*args, &block)
     if args.empty?
       args = block.binding.eval('[self, __method__]')

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

@@ -1,31 +1,33 @@
 module Kernel
 
-  arch_size = (['a'].pack('P').length > 4 ? 64 : 32)
+  ARCH_SIZE = (['a'].pack('P').length > 4 ? 64 : 32)
 
-  if arch_size == 64
-
-    # Returns the object id as a string in hexideciaml,
-    # which is how Ruby reports them with inspect...
-    #
-    #   "ABC".object_hexid  #=> "0x402d359c"
-    #
-    def object_hexid
-      hex = (__id__ << 1)
-      "0x%014x" % hex
+  if RUBY_VERSION < '1.9'
+    if ARCH_SIZE == 64
+      HEXID_TEMPLATE = "0x%012x"
+    else
+      HEXID_TEMPLATE = "0x%x"
     end
-
   else
-
-    # Returns the object id as a string in hexideciaml,
-    # which is how Ruby reports them with inspect...
-    #
-    #   "ABC".object_hexid  #=> "0x402d359c"
-    #
-    def object_hexid
-      hex = (__id__ << 1) #.to_s(16)
-      "0x%x" % hex
+    if ARCH_SIZE == 64
+      HEXID_TEMPLATE = "0x%014x"
+    else
+      HEXID_TEMPLATE = "0x%x"
     end
+  end
 
+  # Returns the object id as a string in hexideciaml,
+  # which is how Ruby reports them with inspect...
+  #
+  #   "ABC".object_hexid  #=> "0x402d359c"
+  #
+  def object_hexid
+    HEXID_TEMPLATE % (__id__ << 1)
   end
 
+  # The 1.9.3 definition is as follows:
+  #def object_hexid
+  #  "0x" + [object_id << 1].pack("L>!").unpack("H*")[0]
+  #end
+
 end

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

@@ -1,8 +1,9 @@
 module Kernel
 
   # Easy access to an object's "special" class.
-
-  def singleton_class(&block)
+  #
+  # NOTE: This is already defined in Ruby 1.9+.
+  def singleton_class
     (class << self; self; end)
   end unless method_defined?(:singleton_class)
 

data/{src/core-uncommon → lib/core}/facets/kernel/trap_chain.rb

@@ -8,10 +8,14 @@ module Kernel
   # registered handler will be invoked. This can be called repeatedly
   # to create a "chain" of handlers. 
   #
-  # NOTE: This is not (presently) a common core extension and is not
+  # NOTE: This method is not a common core extension and is not
   # loaded automatically when using <code>require 'facets'</code>.
   #
   # CREDIT: Tyler Rick
+  #
+  # @uncommon
+  #   require 'facets/kernel/trap_chain'
+  #
   def trap_chain(signal_name, *args, &block)
     previous_interrupt_handler = trap(signal_name, *args) {}
     trap(signal_name, *args) do
@@ -21,3 +25,4 @@ module Kernel
   end
 
 end
+

data/lib/{core-uncommon → core}/facets/kernel/y.rb

@@ -8,11 +8,14 @@ module Kernel
   #
   #  f.call(5, 1) #=> 120
   #
-  # NOTE: This is not (presently) a common core extension and is not
+  # NOTE: This method is not a common core extension and is not
   # loaded automatically when using <code>require 'facets'</code>.
   #
   # CREDIT: Michael Fellinger
-
+  #
+  # @uncommon
+  #   require 'facets/kernel/y'
+  #
   def Y(*args, &block)
     y = lambda{|*args| block.call(*args, &y) }
   end

data/lib/core/facets/lazy.rb

@@ -19,10 +19,9 @@
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.
 
-# = Lazy
-#
 # Everything you need for Lazy evaluation in Ruby.
 #
+# @author MenTaLguY
 module Lazy
 
   # Raised when a demanded computation diverges (e.g. if it tries to directly
@@ -73,13 +72,13 @@ module Lazy
       yield
     end
 
-    # create this once here, rather than creating a proc object for
-    # every evaluation
-    diverges = lambda { raise DivergenceError.new }
-    def diverges.inspect
+    # Create this once here, rather than creating a proc object for every evaluation.
+    DIVERGES = lambda { raise DivergenceError.new }
+
+    # Differentiate inspection of DIVERGES lambda.
+    def DIVERGES.inspect
       "DIVERGES"
     end
-    DIVERGES = diverges
 
     def __result__ #:nodoc:
       __synchronize__ do

data/lib/core/facets/matchdata.rb

@@ -1,10 +1,5 @@
-# Require all MatchData core extensions.
+require 'facets/kernel/require_relative'
 
-if RUBY_VERSION < '1.9'
-  require "facets/matchdata/match.rb"
-  require "facets/matchdata/matchset.rb"
-else
-  require_relative "matchdata/match.rb"
-  require_relative "matchdata/matchset.rb"
-end
+require_relative 'matchdata/match.rb'
+require_relative 'matchdata/matchset.rb'
 

data/lib/core/facets/method.rb

@@ -1,8 +1,7 @@
-# Require all Method core extensions.
+require 'facets/kernel/require_relative'
 
-if RUBY_VERSION < '1.9'
-
-else
-
-end
+require_relative 'method/composition.rb'
+#require_relative 'method/memoize'         # uncommon
+require_relative 'method/op_mul.rb'
+require_relative 'method/op_pow.rb'
 

data/lib/core/facets/method/composition.rb

@@ -0,0 +1,80 @@
+class Method
+
+  # Method Composition class acts a proxy for composed methods.
+  #
+  # @author Mike Burns
+  class Composition
+
+    #
+    def initialize(f,g)
+      @f = f
+      @g = g
+    end
+
+    #
+    def *(h)
+      Composition.new(self, h)
+    end
+
+    #
+    def ^(n)
+      return self if n < 2
+      Composition.new(self, self ^ (n-1))
+    end
+
+    #
+    def owner
+      @g.owner
+    end
+
+    #
+    def receiver
+      @g.receiver
+    end
+
+    #
+    def inspect
+      "#<Method::Composition: #{@f.inspect} * #{@g.inspect}>"
+    end
+
+    #
+    def arity
+      @g.arity
+    end
+
+    #
+    def to_proc
+      Proc.new {|x| @f.call(*@g.call(*x)) }
+    end
+
+    #
+    def call(x)
+      @f.call(*@g.call(*x))
+    end
+
+    #
+    def [](*x)
+      call(*x)
+    end
+
+  end
+
+  # Method composition.
+  #
+  # @author Mike Burns
+  def *(g)
+    Composition.new(self, g)
+  end
+
+  # Method repetition.
+  #
+  # @author Mike Burns
+  def ^(n)
+    if n < 2
+      self
+    else
+      Composistion.new(self, self ^ (n-1))
+    end
+  end
+
+end