facets 2.7.0 → 2.8.0

data/lib/core/facets/array/conjoin.rb

@@ -1,9 +1,9 @@
 class Array
 
-  # This is more advnaced form of #join. It allows for fine control
+  # This is more advanced form of #join. It allows for fine control
   # of separators.
   #
-  # NOTE: The old version used to default it's separator to ", " and
+  # NOTE: The old version used to default its separator to ", " and
   # default the terminating separator to " and ". This is no longer
   # the case. You must specifically provide these parameters.
   #

data/lib/core/facets/array/pad.rb

@@ -1,6 +1,6 @@
 class Array
 
-  # Pad an array with a given <tt>value</tt> upto a given <tt>length</tt>.
+  # Pad an array with a given <tt>value</tt> up to a given <tt>length</tt>.
   #
   #   [0,1,2].pad(6,"a")  #=> [0,1,2,"a","a","a"]
   #

data/lib/core/facets/array/recursively.rb

@@ -1,7 +1,7 @@
 class Array
 
-  # Apply a block to hash, and recursively apply that block
-  # to each subhash.
+  # Apply a block to array, and recursively apply that block
+  # to each subarray.
   #
   #   arr = ["a", ["b", "c", nil], nil]
   #   arr.recursively{|a| a.compact! }

data/lib/core/facets/array/splice.rb

@@ -2,7 +2,7 @@ class Array
 
   # Splice acts a combination of #slice! and #store.
   # If two arguments are given it calls #store.
-  # If a single argument is give it calls slice!.
+  # If a single argument is given it calls slice!.
   #
   #   a = [1,2,3]
   #   a.splice(1)    #=> 2

data/lib/core/facets/binding/caller.rb

@@ -29,8 +29,7 @@ class Binding
   #   tester  #=> :tester
   #
   def __callee__
-    name = /\`([^\']+)\'/.match(caller(1).first)[1]
-    return name.to_sym
+    eval('__callee__')
   end
 
   # There is a lot of debate on what to call this.
@@ -41,8 +40,7 @@ class Binding
   #   tester  #=> "tester"
   #
   def __method__
-    name = /\`([^\']+)\'/.match(caller(1).first)[1]
-    return name
+    eval('__method__')
   end
 
 end

data/lib/core/facets/comparable/comparable.rb

@@ -13,9 +13,9 @@
 
 class Module
 
-  # Automatically generate sorting defintions base on attribute fields.
+  # Automatically generate sorting definitions based on attribute fields.
   #
-  #   include SortOn(:a, :b)
+  #   include Comparable(:a, :b)
   #
   # is equivalent to including a module containing:
   #

data/lib/core/facets/dir/ascend.rb

@@ -16,6 +16,9 @@ class Dir
   #
   # CREDIT: Daniel Berger, Jeffrey Schwab
 
+  # TODO: make it work with windows too
+  # use FileTest.root?
+
   def self.ascend(dir, inclusive=true, &blk)
     dir = dir.dup
     blk.call(dir) if inclusive

data/lib/core/facets/dir/recurse.rb

@@ -4,6 +4,10 @@ class Dir
   # to the given block.
   #
   # CREDIT: George Moschovitis
+  #
+  # TODO: If fully compatible, reimplement as alias of Find.find,
+  # or just copy and paste Find.find code here if it looks more robust.
+  #
   def self.recurse(path='.', &block)
     list = []
     stoplist = ['.', '..']

data/lib/core/facets/duplicable.rb

@@ -1,34 +1,32 @@
-class Object #:nodoc:
+class Object
   # Can you safely call #dup on this object?
   # False for nil, false, true, symbols, and numbers; true otherwise.
   def dup?   ; true ; end
   def clone? ; true ; end
 end
 
-class NilClass #:nodoc:
+class NilClass
   def dup?   ; false ; end
   def clone? ; false ; end
 end
 
-class FalseClass #:nodoc:
+class FalseClass
   def dup?   ; false ; end
   def clone? ; false ; end
 end
 
-class TrueClass #:nodoc:
+class TrueClass
   def dup?   ; false ; end
   def clone? ; false ; end
 end
 
-class Symbol #:nodoc:
+class Symbol
   def dup?   ; false ; end
   def clone? ; false ; end
 end
 
-class Numeric #:nodoc:
+class Numeric
   def dup?   ; false ; end
   def clone? ; false ; end
 end
 
-# :facets: extra
-

data/lib/core/facets/enumerable/count.rb

@@ -1,28 +1,37 @@
+require 'facets/hash/count'
+
 module Enumerable
 
   unless method_defined?(:count)
 
     # Count the number of items in an enumerable
-    # equal (==) to the given object.
+    # equal (==) to the given object(s).
     #
     #   e = [ 'a', '1', 'a' ]
-    #   e.count('1')    #=> 1
-    #   e.count('a')    #=> 2
+    #   e.count('1')     #=> 1
+    #   e.count('a')     #=> 2
+    #   e.count('a', 1)  #=> 3
     #
-    # Count can also handle multiple-valued blocks.
+    # Note that Hash#count only considers values.
     #
-    #   e = { 'a' => 2, 'a' => 2, 'b' => 1 }
-    #   e.count('a',2)  #=> 1
+    #   e = { 'a' => 2, 'x' => 2, 'b' => 1 }
+    #   e.count(1) #=> 1
+    #   e.count(2) #=> 2
     #
     # CREDIT: Trans
 
-    def count(item=ArgumentError, &blk)
-      return select(&blk).size              if block_given?
-      return select{ |*i| item == i }.size  if ArgumentError == item
-      begin
-        size
-      rescue
-        (i=0; each{|e| i+=1 }; i)
+    def count(*items, &block)
+      if block || !items.empty?
+        r = self
+        r = r.select(&block) if block
+        r = r.select{ |x| items.any?{ |i| i == x } } if !items.empty?
+        r.size
+      else
+        begin
+          size
+        rescue
+          i=0; each{ |e| i+=1 }; i
+        end
       end
     end
 

data/lib/core/facets/enumerable/map_detect.rb

@@ -0,0 +1,28 @@
+module Enumerable
+
+  # Yield each element to the block.  Returns the result of
+  # the block when the block is true, terminating early as detect does.
+  # 
+  #   obj1.foo? #=> false
+  #   obj2.foo? #=> true
+  #
+  #   obj2.foo  #=> "a value"
+  #
+  #   [obj1, obj2].map_detect { |obj| obj.foo if obj.foo? } #=> "a value"
+  #
+  # If the block is never true, return the object given in the first parameter,
+  # or nil if none specified.
+  #
+  #   [1,2,3].map_detect { |_| false }    #=> nil
+  #   [false].map_detect(1) { |_| false } #=> 1
+  #
+  def map_detect(value_for_none_matching = nil)
+    each do |member|
+      if result = yield(member)
+        return result
+      end
+    end
+    
+    value_for_none_matching
+  end
+end

data/lib/core/facets/enumerable/mash.rb

@@ -13,14 +13,22 @@ module Enumerable
 
   def mash(&yld)
     if yld
-      inject({}) do |h, *kv| # Used to be inject({}) do |h,kv|
-        r = *yld[*kv]        # The *-op works differnt from to_a on single element hash!!!
-        nk, nv = *r          # Used to be nk, nv = *yld[*kv].to_a.flatten
+      h = {}
+      each do |*kv|
+        r = yld[*kv]
+        case r
+        when Hash
+          nk, nv = *r.to_a[0]
+        when Range
+          nk, nv = r.first, r.last
+        else
+          nk, nv = *r
+        end
         h[nk] = nv
-        h
       end
+      h
     else
-      Enumerator.new(self,:graph)  # Used to be Hash[*self.to_a] or Hash[*self.to_a.flatten]
+      Enumerator.new(self,:mash)
     end
   end
 

data/lib/core/facets/enumerable/per.rb

@@ -1,8 +1,10 @@
 require 'facets/functor'
 
+#--
 # TODO: Consider Enumerator methods
+#++
 
-module Enumerable #:nodoc:
+module Enumerable
 
   # Per element meta-functor.
   #

data/lib/core/facets/hash/count.rb

@@ -0,0 +1,14 @@
+require 'facets/enumerable/count'
+
+class Hash
+
+  # Like Enumerable#count, but counts hash values.
+  #
+  #   {:A=>1, :B=>1}.count(1) #=> 2
+  #
+  def count(value)
+    values.count(value)
+  end
+
+end
+

data/lib/core/facets/hash/data.rb

@@ -0,0 +1,14 @@
+require 'facets/functor'
+
+class Hash
+
+  # TODO: The name of this method may change.
+  #
+  def data
+    Functor.new() do |op| 
+      self[op]
+    end
+  end
+
+end
+

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

@@ -19,7 +19,7 @@ module Kernel
 
   end
 
-  unless method_defined?(:__callee__)  # 1.9+  # TODO: Is this so?
+  unless method_defined?(:__callee__)  # 1.9+
 
     # Retreive the current running method name.
     #

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

@@ -6,17 +6,18 @@ module Kernel
   #
   # produces
   #
-  #   /home/dave/projects/foo.rb, 38
-  #   "hi"
+  #   "hi" (/home/dave/projects/foo.rb, 38)
   #
-  # TODO: This is borderline "prime". Keep here?
-  # Another copy of it exits in dtools.rb
-
   def d(*x)
-    puts "#{__FILE__}, #{__LINE__}"
-    x.each{ |e| puts e.inspect } #p(*x)
-    x.size > 1 ? x : x.last #x.last
+    puts "#{x.inspect} #{caller[0]}"
+    return *x
   end
 
+  #def d(*x)
+  #  puts "#{__FILE__}, #{__LINE__}"
+  #  x.each{ |e| puts e.inspect } #p(*x)
+  #  x.size > 1 ? x : x.last #x.last
+  #end
+
 end
 

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

@@ -0,0 +1,20 @@
+module Kernel
+
+  # During this trying time when no one can get their
+  # techie catchwords to stick to the refrigerator no
+  # matter how hard they slap it # with the enchanted
+  # magnetic spatula, it’s good to know that the
+  # contrived phrases really do fly, graceful and
+  # unclasped and bearing north toward chilled shrimp.
+  # I know what my Hallowe’en pumpkin is going to say.
+  #
+  #                       -- why the lucky stiff
+  #
+  # CREDIT: WhyTheLuckyStiff
+
+  def eigenclass
+    (class << self; self; end)
+  end
+
+end
+

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

@@ -0,0 +1,10 @@
+module Kernel
+
+  alias_method :_extend, :extend
+
+  def extend(*mod, &blk)
+    _extend *mod unless mod.empty?
+    _extend Module.new(&blk) if blk
+  end
+
+end

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

@@ -13,6 +13,7 @@ module Kernel
   # block is provided to eval against it.
   #
   #     It is what it is.
+  #     But I think I like this one best.
   #
   # CREDIT: Trans
 

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

@@ -40,15 +40,16 @@ class InstanceVariables
 
   def []=(name, value)
     name = atize(name)
-    @delegate.instance_varaible_set(name,value)
+    @delegate.instance_variable_set(name,value)
   end
 
   def <<(pair)
     name, value = *pair
     name = atize(name)
-    @delegate.instance_varaible_set(name, value)
+    @delegate.instance_variable_set(name, value)
   end
 
+  # (See also: Kernel#populate, which uses accessor method rather than setting instance variables directly.)
   def update(hash)
     hash.each do |pair|
       self << pair
@@ -82,7 +83,6 @@ class InstanceVariables
 end
 
 =begin demo
-
   class Friend
     attr_accessor :name, :age, :phone
     def initialize(name, age, phone)
@@ -91,7 +91,7 @@ end
   end
 
   f1 = Friend.new("John", 30, "555-1212")
-  p f1.variables
-  p f1.variables.to_hash
-
+  p f1.instance_vars
+  f1.instance_vars.update({:name=>'Jerry'})
+  p f1.instance_vars
 =end

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

@@ -0,0 +1,18 @@
+module Kernel
+
+  # Alias a method defined in the metaclass (ie. singleton class).
+  #
+  #   def X.y?; "y?" ; end
+  #   X.meta_alias "ynot?", "y?"
+  #   X.ynot?  #=> y?
+  #
+  # CREDIT: Trans
+
+  def meta_alias(*args)
+    meta_class do
+      alias_method(*args)
+    end
+  end
+
+end
+

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

@@ -0,0 +1,17 @@
+module Kernel
+
+  # 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
+
+  alias_method :metaclass, :meta_class
+
+end
+