facets 2.6.0 → 2.7.0

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

@@ -1,8 +1,8 @@
-if RUBY_VERSION < '1.9'
+class Array
 
-  require 'enumerator'
+  unless method_defined?(:combination) # 1.8.7+
 
-  class Array
+    require 'facets/enumerator'
 
     # Yields the block to each unique combination of _n_ elements.
     #

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

@@ -1,6 +1,8 @@
 class Array
 
-  if RUBY_VERSION < '1.9'
+  # CORE OVERRIDE
+
+  if RUBY_VERSION < '1.8.7'
 
     alias_method :_facets_index, :index
 
@@ -20,3 +22,4 @@ class Array
   end
 
 end
+

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

@@ -1,6 +1,6 @@
-unless (RUBY_VERSION[0,3] == '1.9')
+class Array
 
-  class Array
+  unless method_defined?(:permutation) # 1.8.7+
 
     # Permutation provids the possible orders of an enumerable.
     # Each is indexed by a permutation number. The maximum number of

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

@@ -1,6 +1,6 @@
 class Array
 
-  if RUBY_VERSION < '1.9'
+  unless method_defined?(:product) # 1.8.7+
 
     # Provides the cartesian product of two or more arrays.
     #

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

@@ -1,6 +1,6 @@
 class Binding
 
-  unless (RUBY_VERSION[0,3] == '1.9')
+  unless method_defined?(:eval) # 1.8.7+
 
     # Evaluate a Ruby source code string (or block) in the binding context.
 

data/lib/core/facets/denumerable.rb

@@ -0,0 +1,76 @@
+require 'facets/enumerator'
+#require 'facets/enumerable/take'
+
+# = Denumerable
+#
+# Classes which include Enumerable::Filterable will get versions
+# of map, select etc. which return a Filter, so that they work
+# horizontally without creating intermediate arrays.
+#
+module Denumerable
+
+  #
+  def map
+    Denumerator.new do |output|
+      each do |*input|
+        output.yield yield(*input)
+      end
+    end
+  end
+  alias :collect :map
+
+  #
+  def select
+    Denumerator.new do |output|
+      each do |*input|
+        output.yield(*input) if yield(*input)
+      end
+    end
+  end
+  alias :find_all :select
+
+  #
+  def reject
+    Denumerator.new do |output|
+      each do |*input|
+        output.yield(*input) unless yield(*input)
+      end
+    end
+  end
+
+  # Limit to the first n items in the list
+  def take(n)
+    Denumerator.new do |output|
+      count = 0
+      each do |*input|
+        break if count >= n
+        output.yield(*input)
+        count += 1
+      end
+    end
+  end
+
+  # Skip the first n items in the list
+  def skip(n)
+    Denumerator.new do |output|
+      count = 0
+      each do |*input|
+        output.yield(*input) if count >= n
+        count += 1
+      end
+    end
+  end
+
+  # TODO: add more methods, e.g. grep, take_while etc.
+
+end
+
+
+# = Denumerator
+#
+# A class like Enumerator, but which has 'lazy' versions of map, select etc.
+#
+class Denumerator < Enumerator
+  include Denumerable
+end
+

data/lib/core/facets/duplicable.rb

@@ -0,0 +1,34 @@
+class Object #:nodoc:
+  # 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:
+  def dup?   ; false ; end
+  def clone? ; false ; end
+end
+
+class FalseClass #:nodoc:
+  def dup?   ; false ; end
+  def clone? ; false ; end
+end
+
+class TrueClass #:nodoc:
+  def dup?   ; false ; end
+  def clone? ; false ; end
+end
+
+class Symbol #:nodoc:
+  def dup?   ; false ; end
+  def clone? ; false ; end
+end
+
+class Numeric #:nodoc:
+  def dup?   ; false ; end
+  def clone? ; false ; end
+end
+
+# :facets: extra
+

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

@@ -1,6 +1,6 @@
-unless (RUBY_VERSION[0,3] == '1.9')
+module Enumerable
 
-  module Enumerable
+  unless method_defined?(:count)
 
     # Count the number of items in an enumerable
     # equal (==) to the given object.
@@ -16,8 +16,14 @@ unless (RUBY_VERSION[0,3] == '1.9')
     #
     # CREDIT: Trans
 
-    def count(*c)
-      self.select{ |*i| i == c }.length
+    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)
+      end
     end
 
   end

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

@@ -0,0 +1,77 @@
+require 'facets/denumerable'
+
+module Enumerable
+
+  # Without a block: wrap the Enumerable object in such a way that map,
+  # select and similar operations are performed "horizontally" across a
+  # series of blocks, instead of building an array of results at each step.
+  # This reduces memory usage, allows partial results to be provided
+  # early, and permits working with infinite series.
+  #
+  #   a = (1..1_000_000_000).defer.select{ |i| i % 2 == 0 }.
+  #                                map{ |i| i + 100 }.
+  #                                take(10).to_a
+  #
+  # With a block: 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.
+  #
+  #   (1..1_000_000_000).
+  #     defer { |out,i| out << i if i % 2 == 0 }.  # like select
+  #     defer { |out,i| out << i + 100 }.          # like map
+  #     take(10).
+  #     each { |i| puts i }
+  #
+  # Using with a block, defer(&b), is equivalent to:
+  #
+  #   defer.filter(&b)
+  #
+  # Use a method like to_a or to_h at the end of the chain when you want an
+  # Array or Hash built with the results, or each{...} if you just want
+  # to output each result and discard it.
+  #
+  def defer(&blk)
+    if block_given?
+      Denumerator.new do |output|
+        each do |*input|
+          yield output, *input
+        end
+      end
+    else
+      Denumerator.new do |output|
+        each do |*input|
+          output.yield *input
+        end
+      end
+    end
+  end
+
+end
+
+=begin
+  
+  TODO: (Programming Challenge) Dynamically create this in a single
+  method using a Functor and without the need of Denumerable.
+  
+  Below is my first shot at it. It's close, but it cannot handle
+  infinite series.
+ 
+  require 'facets/functor'
+
+  def defer
+    l = lambda do |enum|
+      Functor.new do |op, *a, &b|
+        case op.to_s
+        when /^(to_|each)/
+          enum.__send__(op, *a, &b)
+        else
+          l[enum.__send__(op, *a, &b)]
+        end
+      end
+    end
+    l[self]
+  end
+
+=end
+

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

@@ -1,4 +1,4 @@
-require 'enumerator'
+require 'facets/enumerator'
 
 module Enumerable
 

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

@@ -0,0 +1,35 @@
+require 'facets/enumerable/per'
+
+module Enumerable
+
+  # Returns an elemental object. This allows
+  # you to map a method on to every element.
+  #
+  #   r = [1,2,3].every + 3  #=> [4,5,6]
+  #
+  def every
+    @_every ||= per(:map)
+  end
+
+  # In place version of #every.
+  #
+  def every!
+    raise NoMethodError unless respond_to?(:map!)
+    @_every_inplace ||= per(:map!)
+  end
+
+  #def every
+  #  @_every ||= Functor.new do |op,*args|
+  #    map{ |a| a.send(op,*args) }
+  #  end
+  #end
+
+  #def every!
+  #  raise NoMethodError unless respond_to?(:map!)
+  #  @_every_inplace ||= Functor.new do |op,*args|
+  #    map!{ |a| a.send(op,*args) }
+  #  end
+  #end
+
+end
+

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

@@ -0,0 +1,25 @@
+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.
+  #
+  #   (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 }
+  #
+  def filter(output=[])
+    if block_given?
+      each do |*input|
+        yield(output, *input)
+      end
+      output
+    else
+      to_enum(:filter)
+    end
+  end
+
+end
+

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

@@ -1,6 +1,6 @@
 module Enumerable
 
-  unless defined?(group_by) or defined?(::ActiveSupport)  # 1.9 or ActiveSupport
+  unless method_defined?(:group_by) or defined?(::ActiveSupport)  # 1.9 or ActiveSupport
 
     # #group_by is used to group items in a collection by something they
     # have in common.  The common factor is the key in the resulting hash, the

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

@@ -1,6 +1,6 @@
-unless (RUBY_VERSION[0,3] == '1.9')
+module Enumerable
 
-  module Enumerable
+  unless method_defined?(:none?)  # 1.8.7+
 
     # Enumerable#none? is the logical opposite of the builtin method
     # Enumerable#any?.  It returns +true+ if and only if _none_ of
@@ -29,3 +29,4 @@ unless (RUBY_VERSION[0,3] == '1.9')
   end
 
 end
+

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

@@ -1,6 +1,6 @@
-unless (RUBY_VERSION[0,3] == '1.9')
+module Enumerable
 
-  module Enumerable
+  unless method_defined?(:one?)  # 1.8.7+
 
     # Enumerable#one? returns +true+ if and only if <em>exactly one</em>
     # element in the collection satisfies the given predicate.
@@ -36,3 +36,4 @@ unless (RUBY_VERSION[0,3] == '1.9')
   end
 
 end
+

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

@@ -0,0 +1,61 @@
+require 'facets/functor'
+
+# TODO: Consider Enumerator methods
+
+module Enumerable #:nodoc:
+
+  # Per element meta-functor.
+  #
+  #   [1,2,3].per + 3             #=> [4,5,6]
+  #   [1,2,3].per(:map) + 3       #=> [4,5,6]
+  #   [1,2,3].per(:select) > 1    #=> [2,3]
+  #
+  #   [1,2,3].per.map + 3       #=> [4,5,6]
+  #   [1,2,3].per.select > 1    #=> [2,3]
+  #
+  def per(enum_method=nil, *enum_args)
+    if enum_method
+      Permeator.new(self, enum_method, *enum_args)
+      #Functor.new do |op, *args|
+      #  __send__(enum_method, *enum_args){ |x| x.__send__(op, *args) } #, &blk) }
+      #end
+    else
+      @__per__ ||= 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) }
+        #end
+      end
+    end
+  end
+
+  # Permeator is a Functor for operating over each element of an Enumearble.
+  # (Note: This used to be called an Elementor.)
+  #
+  # TODO: With Ruby 1.9+ this would not be required, as it can be replaced
+  # by a generic Functor, becuase then lambda definitions can pass blocks.
+  #
+  class Permeator #:nodoc:
+    private(*instance_methods.select{|x| x !~ /^__/ })
+
+    def initialize(enum_object, enum_method=nil, *enum_args)
+      @enum_object = enum_object
+      @enum_method = enum_method || :map
+      @enum_args   = enum_args
+    end
+
+    def instance_delegate
+      @enum_object
+    end
+
+    def instance_operator
+      @enum_method
+    end
+
+    def method_missing(sym, *args, &blk)
+      @enum_object.__send__(@enum_method){ |x| x.__send__(sym, *args, &blk) }
+    end
+  end
+
+end
+

data/lib/core/facets/exception/raised.rb

@@ -0,0 +1,14 @@
+class Exception
+
+  # Does a block raise an a given +exception+.
+  #
+  def raised? #:yeild:
+    begin
+      yield
+      false
+    rescue self
+      true
+    end
+  end
+
+end