facets 2.8.1 → 2.8.2

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

@@ -2,20 +2,20 @@ require 'facets/functor'
 
 module Enumerable
 
+  EWISE = {}
+
   # Returns an elementwise Functor designed to make R-like
-  # elementwise operations possible.
+  # elementwise operations possible. This is very much like
+  # the #every method, but it treats array argument specially.
   #
-  #   [1,2].elementwise + 3          #=> [4,5]
-  #   [1,2].elementwise + [4,5]      #=> [5,7]
-  #   [1,2].elementwise + [[4,5],3]  #=> [[5,7],[4,5]
+  #   [1,2].ewise + 3          #=> [4,5]
+  #   [1,2].ewise + [4,5]      #=> [5,7]
+  #   [1,2].ewise + [[4,5],3]  #=> [[5,7],[4,5]
   #
-  #--
   # Special thanks to Martin DeMello for helping to develop this.
-  #++
 
-  def elementwise(count=1)
-    @_elementwise_functor ||= []
-    @_elementwise_functor[count] ||= Functor.new do |op,*args|
+  def ewise(count=1)
+    EWISE[[self,count]] ||= Functor.new do |op,*args|
       if args.empty?
         r = self
         count.times do
@@ -46,16 +46,22 @@ module Enumerable
     end
   end
 
-  # Concise alias for #elementwise.
+  # Long-term for #ewise.
   #
   #   a = [1,2]
-  #   a.ewise + 3          #=> [4,5]
-  #   a.ewise + [4,5]      #=> [5,7]
-  #   a.ewise + [[4,5],3]  #=> [[5,7],[4,5]
+  #   a.elementwise + 3          #=> [4,5]
+  #   a.elementwise + [4,5]      #=> [5,7]
+  #   a.elementwise + [[4,5],3]  #=> [[5,7],[4,5]
   #
-  # Note this used to be #ew as weel as the '%' operator.
-  # Both of whihc are deprecated.
+  alias_method :elementwise, :ewise
 
-  alias_method :ewise, :elementwise
+  # Operator equivalent of #elementwise.
+  #
+  # This was deprecated along with it's file "op_tilde.rb".
+  #
+  #def ~@
+  #  ewise
+  #end
 
 end
+

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

@@ -0,0 +1,13 @@
+module Enumerable
+
+  unless method_defined?(:exclude?) or defined?(::ActiveSupport)  # 1.9 or ActiveSupport
+
+    # The inverse of #include?.
+    #
+    def exclude?(object)
+      !include?(object)
+    end
+
+  end
+
+end

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

@@ -1,16 +1,20 @@
 module Enumerable
 
-  # The block acts as an arbitrary filter on the data. Unlike
-  # map, it can choose to drop elements from the result, and/or add
-  # additional ones. The first object passed to the block is the receiver
-  # of the output.
+  # The block acts as an arbitrary filter on the data. Unlike map,
+  # it can choose to drop elements from the result and/or add
+  # additional elements. The first object passed to the block is
+  # the receiver of the output.
   #
   #   (1..1_000_000_000).
-  #     filter { |out,i| out << i if i % 2 == 0 }.  # like select
-  #     filter { |out,i| out << i + 100 }.          # like map
-  #     take(10).each { |i| puts i }
+  #     filter{ |out,i| out << i if i % 2 == 0 }.  # like select
+  #     filter{ |out,i| out << i + 100 }.          # like map
+  #     take(10).each{ |i| puts i }
   #
-  def filter(output=[])
+  # This is very similar to #each_with_object, but #filter handles
+  # argument better by reversing their order and using the splat
+  # operator.
+
+  def filter(output=[]) #:yeild:
     if block_given?
       each do |*input|
         yield(output, *input)
@@ -21,5 +25,11 @@ module Enumerable
     end
   end
 
+  # OLD NAME
+  # CREDIT: David Black, Louis J Scoras
+  #def injecting(k)
+  #  each{ |i| yield(k, i) }; k
+  #end
+
 end
 

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

@@ -0,0 +1,37 @@
+module Enumerable
+
+  # Yield each element to the block and return the result
+  # of the block when that result evaluates as true,
+  # terminating early like #detect and #find.
+  # 
+  #   obj1.foo? #=> false
+  #   obj2.foo? #=> true
+  #   obj2.foo  #=> "value"
+  #
+  #   [obj1, obj2].find_yield{ |obj| obj.foo if obj.foo? }     #=> "value"
+  #
+  # Another example:
+  #
+  #   [1,2,3,4,5].find_yield{ |i| j = i+1; j if j % 4 == 0 }   #=> "5"
+  #
+  # If the block is never true, return the object given in the first parameter,
+  # or nil if none specified.
+  #
+  #   [1,2,3].find_yield{ |_| false }    #=> nil
+  #   [false].find_yield(1){ |_| false } #=> 1
+  #
+  def find_yield(fallback=nil) #:yield:
+    each do |member|
+      result = yield(member)
+      return result if result 
+    end
+    fallback
+  end
+
+  # DEPRECATE: This has been renamed to #find_yield.
+  def map_detect(fallback=nil)
+    find_yield(fallback)
+  end
+
+end
+

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

@@ -1,28 +1 @@
-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
+require 'facets/enumerable/find_yield'

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

@@ -9,8 +9,8 @@ module Enumerable
 
   def map_with_index
     r = []
-    each_index do |i|
-      r << yield(self[i], i)
+    each_with_index do |e, i|
+      r << yield(e, i)
     end
     r
   end

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

@@ -1,7 +1,7 @@
 require 'facets/functor'
 
 #--
-# TODO: Consider Enumerator methods
+# TODO: Consider Enumerator methods.
 #++
 
 module Enumerable
@@ -22,7 +22,7 @@ module Enumerable
       #  __send__(enum_method, *enum_args){ |x| x.__send__(op, *args) } #, &blk) }
       #end
     else
-      @__per__ ||= Functor.new do |enum_method, *enum_args|
+      Functor.new do |enum_method, *enum_args|
         Permeator.new(self, enum_method, *enum_args)
         #Functor.new do |op, *args|
         #  __send__(enum_method, *enum_args){ |x| x.__send__(op, *args) } #, &blk) }

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

@@ -0,0 +1,43 @@
+module Enumerable
+
+  # A versitle compaction method. Like #map but used
+  # to filter out multiple items in a single step.
+  #
+  # Without +trash+ arguments +nil+ is assumed.
+  #
+  #   [1, nil, 2].purge  #=> [1,2]
+  #
+  # If +trash+ arguments are given, each argument is
+  # compared for a match using #==.
+  #
+  #   (1..6).purge(3,4)  #=> [1,2,5,6]
+  #
+  # If a block is given, the yield is used in the
+  # matching condition instead of the element itsef.
+  # 
+  #   (1..6).purge(0){ |n| n % 2 }  #=> [1,3,5]
+  #
+  # NOTE: This could just as well be an override of the
+  # core #compact method, but to avoid potential issues
+  # associated with overriding core methods we use the
+  # alternate name #purge.
+  #
+  # CREDIT: Trans
+
+  def purge(*trash, &block)
+    trash = [nil] if trash.empty?
+    r = []
+    if block_given?
+      each do |e|
+        y = yield(e)
+        r << e unless trash.any?{|t| t == y}
+      end
+    else
+      each do |e|
+        r << e unless trash.any?{|t| t == e}
+      end
+    end
+    r
+  end
+
+end

data/lib/core/facets/enumerator.rb

@@ -0,0 +1,70 @@
+begin
+  require 'enumerator' #if RUBY_VERSION < 1.9
+  # for Ruby 1.8 -> 1.9 transition
+  Enumerator = Enumerable::Enumerator unless defined? ::Enumerator
+
+  class Enumerator
+
+    alias :old_initialize :initialize
+
+    # Provides the ruby-1.9 block form of Enumerator, where you can write:
+    #
+    #    obj = Enumerator.new do |yielder|
+    #       .. do stuff
+    #       yielder.yield data      # or: yielder << data
+    #       .. etc
+    #    end
+    #
+    # When obj.each is called, the block is run once. It should call
+    # yielder.yield with each item it wishes to generate.
+    #
+    # Example:
+    #
+    #   fib = Enumerator.new { |y|
+    #     a = b = 1
+    #     loop {   
+    #       y << a
+    #       a, b = b, a + b
+    #     }
+    #   }  
+    #
+    #   assert_equal [1, 1, 2, 3, 5, 8, 13, 21, 34, 55], fib.take(10)
+                                                  
+    def initialize(*args, &block)
+      if block_given?
+        @body = block
+        old_initialize(self, :_start)
+      else
+        old_initialize(*args)
+      end
+    end
+
+    def _start(*args,&receiver) #:nodoc:
+      @body.call(Yielder.new(receiver), *args)
+    end
+
+    # Wrapper to allow yielder.yield(output) or yielder << output
+    # in the same way as ruby-1.9
+
+    class Yielder #:nodoc:
+      def initialize(proc)
+        @proc = proc
+      end
+      def yield(*args)
+        @proc[*args]
+      end
+      alias :<< :yield
+    end
+
+  end
+
+rescue LoadError # Ruby 1.9 already has it built-in.
+end
+
+path = __FILE__.chomp('.rb')
+base = File.basename(path)
+Dir[File.join(path, '*.rb')].each do |lib|
+  #require lib # why is this so much slower?
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/core/facets/enumerator/fx.rb

@@ -0,0 +1,20 @@
+begin
+  require 'enumerator' #if RUBY_VERSION < 1.9
+  # for Ruby 1.8 -> 1.9 transition
+  Enumerator = Enumerable::Enumerator unless defined? ::Enumerator
+rescue LoadError # Ruby 1.9 already has it built-in.
+end
+
+require 'facets/functor'
+
+class Enumerator
+
+  #
+  def fx
+    Functor.new do |op, *a|
+      each{ |e| e.send(op, *a) }
+    end
+  end
+
+end
+

data/lib/core/facets/integer/multiple.rb

@@ -1,6 +1,6 @@
 class Integer
 
-  # Is is a multiple of a given number?
+  # Is +self+ a multiple of a given number?
   #
   #   7.multiple?(2)  #=> false
   #   8.multiple?(2)  #=> true
@@ -8,7 +8,11 @@ class Integer
   # CREDIT: Trans
 
   def multiple?(number)
-    self % number == 0
+    if number.zero?
+      zero? ? true : false
+    else
+      self % number == 0
+    end
   end
 
 end

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

@@ -0,0 +1,2 @@
+require 'facets/kernel/true'
+

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

@@ -0,0 +1,26 @@
+module Kernel
+
+  # Returns true is an object is class TrueClass,
+  # otherwise false.
+  #
+  #   true.true?   #=> true
+  #   false.true?  #=> false
+  #   nil.true?    #=> false
+  #
+  def true?
+    (true == self)
+  end
+
+  # Returns true is an object is class FalseClass,
+  # otherwise false.
+  #
+  #   true.false?   #=> false
+  #   false.false?  #=> true
+  #   nil.false?    #=> false
+  #
+  def false?
+    (false == self)
+  end
+
+end
+

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

@@ -1,7 +1,7 @@
 class Numeric
 
-  # Returns +self+.
-
+  # Returns +self+, useful for polymorphic cases.
+  #
   def length
     self
   end

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

@@ -0,0 +1,20 @@
+class Numeric
+
+  # Returns the size of the string representation of
+  # a numerical value.
+  #
+  #      1.spacing   #=> 1
+  #     10.spacing   #=> 2
+  #    100.spacing   #=> 3
+  #   -100.spacing   #=> 4
+  #    1.2.spacing   #=> 3
+  #
+  # CREDIT: Victor H. Goff III
+
+  def spacing
+    to_s.length
+  end
+
+end
+
+

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

@@ -0,0 +1,9 @@
+class Proc
+
+  #
+  def bind_to(object)
+    Proc.new{object.instance_eval(&self)}
+  end
+
+end
+