facets 2.9.3 → 3.0.0

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

@@ -16,5 +16,9 @@ module Kernel
     end
   end
 
+  #def meta_def( name, &blk )
+  #  meta_eval { define_method name, &blk }
+  #end
+
 end
 

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

@@ -13,21 +13,18 @@ module Kernel
   #     obj.object_send(:foo)
   #   end
   #
-  # TODO: object_send needs to change for 1.9. Is it #public_send ?
-  #
-  # CREDIT: Trans
-  #--
-  # Which implementation is faster?
-  #++
+  # DEPRECATED: Use #public_send instead.
+
+  alias object_send public_send rescue nil
 
-  def object_send(name, *args, &blk)
-    #instance_eval "self.#{name}(*args)"
-    if respond_to?(name)
-      __send__(name, *args, &blk)
-    else
-      __send__(:method_missing, name, *args, &blk)
-    end
-  end
+  #def object_send(name, *args, &blk)
+  #  #instance_eval "self.#{name}(*args)"
+  #  if respond_to?(name)
+  #    __send__(name, *args, &blk)
+  #  else
+  #    __send__(:method_missing, name, *args, &blk)
+  #  end
+  #end
 
 end
 

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

@@ -2,6 +2,8 @@ require 'facets/functor'
 
 module Kernel
 
+  # TODO: Should Kernel#respond be moved to functor gem?
+
   # Like #respond_to? but returns the result of the call
   # if it does indeed respond.
   #
@@ -13,30 +15,18 @@ module Kernel
   #   x.respond(:f)  #=> "f"
   #   x.respond(:g)  #=> nil
   #
-  # or
-  #
-  #   x.respond.f   #=> "f"
-  #   x.respond.g   #=> nil
-  #
   # This method was known as #try until Rails defined #try
   # to be something more akin to #ergo.
   #
-  # CREDIT: Trans, Chris Wanstrath
+  # CREDIT: Chris Wanstrath
 
   def respond(sym=nil, *args, &blk)
     if sym
       return nil if not respond_to?(sym)
       __send__(sym, *args, &blk)
     else
-      ## TODO: use after 1.8.6 not supported anymore
-      ##Functor.new do |op, *a, &b|
-      ##  respond(op, *a, &b)
-      ##end
       Functor.new(&method(:respond).to_proc)
     end
   end
 
-  # DEPRECATED: #respond is enough.
-  #alias_method :respond_with_value, :respond
-
 end

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

@@ -1,48 +1,36 @@
+require 'facets/functor'
+
 module Kernel
 
-  unless method_defined?(:tap)  # 1.8.7+
+  # The tap K-Combinator. This yields self -and- returns self.
+  #
+  #   'foo.yml'.tap{ |f| YAML.load(f) }  #=> 'foo.yml'
+  #
+  # Unlike Ruby's definition, this rendition can be used as a higher
+  # order message. This form allows a single call before returning
+  # the receiver.
+  #
+  #   YAML.tap.load_file('foo.yml').load_file('bar.yml')
+  #
+  # IMPORTANT: This is one of few core overrides in Facets.
 
-    # The tap K-Combinator. This yields self -and- returns self.
-    #
-    # Note, Ruby 1.9+ does not support the zero arity #instance_eval
-    # variation so it has been deprecated.
-    def tap #:yield:
+  def tap #:yield:
+    if block_given?
       yield(self)
       self
+    else
+      Functor.new{ |op,*a,&b| self.send(op, *a, &b); self }
     end
-
-    #--
-    # == Old definition
-    #
-    #
-    #   def tap #:yield:
-    #     if block_given?
-    #       b.arity == 1 ? yield(self) : instance_eval(&b)
-    #     end
-    #     return self
-    #   end
-    #
-    # == Future definition?
-    #
-    # This is a consideration for a future #tap using Functor:
-    #
-    #   require 'facets/functor'
-    #
-    #   def tap(&b)
-    #     if block_given?
-    #       b.arity == 1 ? yield(self) : instance_eval(&b)
-    #       self
-    #     else
-    #       Functor.new{ |op, *args| self.send(op, *args); self }
-    #     end
-    #   end
-    #
-    # It would allow a single call, before returning the original.
-    # However there are not very many useful things you can do with
-    # that.
-    #++
-
   end
 
-end
+  # Old Definition:
+  #
+  #   def tap #:yield:
+  #     if block_given?
+  #       b.arity == 1 ? yield(self) : instance_eval(&b)
+  #     end
+  #     return self
+  #   end
+  #
 
+end

data/lib/core/facets/load_path.rb

@@ -0,0 +1 @@
+require_relative 'load_path/search'

data/lib/core/facets/load_path/search.rb

@@ -0,0 +1,16 @@
+class << $LOAD_PATH
+
+  # Search load path for matching patterns.
+  #
+  def search(match)
+    found = []
+    uniq.map do |path|
+      list = Dir.glob(File.join(File.expand_path(path), match))
+      list = list.map{ |d| d.chomp('/') }
+      found.concat(list)
+    end
+    found
+  end
+
+end
+

data/lib/core/facets/matchdata.rb

@@ -1,5 +1,3 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'matchdata/match.rb'
 require_relative 'matchdata/matchset.rb'
 

data/lib/core/facets/method.rb

@@ -1,5 +1,3 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'method/composition.rb'
 #require_relative 'method/memoize'         # uncommon
 require_relative 'method/op_mul.rb'

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

@@ -1,55 +1,70 @@
 class Method
 
+  # TODO: Is it really necessary to have method composition?
+  # Could we not just convert to Proc and have Proc omposition,
+  # which doesn't require a special class (albeit #owner and #arity
+  # and such are not as well supported).
+
   # Method Composition class acts a proxy for composed methods.
   #
   # @author Mike Burns
   class Composition
 
     #
-    def initialize(f,g)
+    def initialize(*f)
       @f = f
-      @g = g
+    end
+
+    #
+    def inspect
+      x = @f.map{ |f| f.inspect }.join(' * ')
+      "#<Method::Composition: #{x}>"
     end
 
     #
     def *(h)
-      Composition.new(self, h)
+      #Composition.new(self, h)
+      @f << h
     end
 
     #
     def ^(n)
+      raise ArgumentError if n < 0
+
       return self if n < 2
-      Composition.new(self, self ^ (n-1))
+
+      #Composition.new(self, self ^ (n-1))
+      (n - 1).times{ @f = @f.concat(@f) }
     end
 
     #
     def owner
-      @g.owner
+      @f.last.owner
     end
 
     #
     def receiver
-      @g.receiver
-    end
-
-    #
-    def inspect
-      "#<Method::Composition: #{@f.inspect} * #{@g.inspect}>"
+      @f.first.receiver
     end
 
     #
     def arity
-      @g.arity
+      @f.last.arity
     end
 
     #
     def to_proc
-      Proc.new {|x| @f.call(*@g.call(*x)) }
+      #Proc.new {|x| @f.call(*@g.call(*x)) }
+      Proc.new { |*x| call(*x) }
     end
 
     #
-    def call(x)
-      @f.call(*@g.call(*x))
+    def call(*x)
+      r = x
+      @f.reverse_each do |f|
+        r = f.call(*r)
+      end
+      r
     end
 
     #
@@ -73,7 +88,8 @@ class Method
     if n < 2
       self
     else
-      Composistion.new(self, self ^ (n-1))
+      #Composition.new(self, self ^ (n-1))
+      Composition.new( *([self] * n) )
     end
   end
 

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

@@ -0,0 +1,13 @@
+require 'facets/proc'
+
+class Method
+  # Curry a Method into a new Proc.
+
+  def curry(*args)
+    to_proc.curry(*args)
+  end
+end
+
+
+# TODO: The question is as to whether to integrate this into Method::Composition,
+# or if Composition should be scuttled for just converting to Proc.

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

@@ -0,0 +1,10 @@
+require 'facets/proc/partial'
+
+class Method
+  # Convert a method into a new partial Proc.
+
+  def partial(*args)
+    to_proc.partial(*args)
+  end
+end
+

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

@@ -0,0 +1,33 @@
+class Method
+
+  #
+  # @return [Boolean]
+  #   Returns true if self encapsulates a public method.
+  #
+  # @author Robert Gleeson
+  #
+  def public?
+    receiver.public_methods.include? name
+  end
+
+  #
+  # @return [Boolean]
+  #   Returns true if self encapsulates a protected method.
+  #
+  # @author Robert Gleeson
+  #
+  def protected?
+    receiver.protected_methods.include? name
+  end
+
+  #
+  # @return [Boolean]
+  #   Returns true if self encapsulates a private method.
+  #
+  # @author Robert Gleeson
+  #
+  def private?
+    receiver.private_methods.include? name
+  end
+
+end

data/lib/core/facets/module.rb

@@ -1,5 +1,3 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'module/abstract.rb'
 require_relative 'module/alias_accessor.rb'
 require_relative 'module/alias_method_chain.rb'

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

@@ -0,0 +1,11 @@
+class Module
+
+  # Alias a class method.
+  #
+  def alias_class_method(name, target)
+    class << self
+      alias_method(name, target)
+    end
+  end
+
+end

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

@@ -1,31 +1 @@
-class Module
-
-  # Returns the root name of the module/class.
-  #
-  #   module ::BaseName
-  #     class Example
-  #     end
-  #   end
-  #
-  #   BaseName::Example.name       #=> "BaseName::Example"
-  #   BaseName::Example.basename   #=> "Example"
-  #
-  # For anonymous modules this will provide a basename
-  # based on Module#inspect.
-  #
-  #   m = Module.new
-  #   m.inspect       # "#<Module:0xb7bb0434>"
-  #   m.basename      # "Module_0xb7bb0434"
-  #
-  # CREDIT: Trans
-
-  def basename
-    if name and not name.empty?
-      name.gsub(/^.*::/, '')
-    else
-      nil #inspect.gsub('#<','').gsub('>','').sub(':', '_')
-    end
-  end
-
-end
-
+require 'facets/module/lastname'

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

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

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

@@ -0,0 +1,30 @@
+class Module
+
+  # Returns the root name of the module/class.
+  #
+  #   module ::BaseName
+  #     class Example
+  #     end
+  #   end
+  #
+  #   BaseName::Example.name       #=> "BaseName::Example"
+  #   BaseName::Example.lastname   #=> "Example"
+  #
+  # Returns nil when module is anonymous.
+  #
+  # CREDIT: Trans
+
+  def lastname
+    if name and not name.empty?
+      name.gsub(/^.*::/, '')
+    else
+      nil #inspect.gsub('#<','').gsub('>','').sub(':', '_')
+    end
+  end
+
+  # Original name, but conflicts with File.basename, so is
+  # mildly deprecated. 
+  alias basename lastname
+
+end
+

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

@@ -157,7 +157,7 @@ class Module
   # CREDIT: David Heinemeier Hansson
   #
   # @uncommon
-  #   require 'facets/module/cattr'
+  #   require 'facets/module/mattr'
   #
   def mattr(*syms)
     writers, readers = syms.flatten.partition{ |a| a.to_s =~ /=$/ }
@@ -187,7 +187,7 @@ class Module
   # CREDIT: David Heinemeier Hansson
   #
   # @uncommon
-  #   require 'facets/module/cattr'
+  #   require 'facets/module/mattr'
   #
   def mattr_reader( *syms )
     syms.flatten.each do |sym|
@@ -230,7 +230,7 @@ class Module
   # CREDIT: David Heinemeier Hansson
   #
   # @uncommon
-  #   require 'facets/module/cattr'
+  #   require 'facets/module/mattr'
   #
   def mattr_writer(*syms)
     syms.flatten.each do |sym|
@@ -270,7 +270,7 @@ class Module
   # CREDIT: David Heinemeier Hansson
   #
   # @uncommon
-  #   require 'facets/module/cattr'
+  #   require 'facets/module/mattr'
   #
   def mattr_accessor(*syms)
     mattr_reader(*syms) + mattr_writer(*syms)