facets 2.9.3 → 3.0.0

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

@@ -0,0 +1,13 @@
+module Enumerable
+
+  # Map each element into another class via class constructor.
+  #
+  # @param [#new] to_class
+  #   Generally a class, but any object that repsonds to #new.
+  #
+  def map_to(to_class)
+    map{ |e| to_class.new(e) }
+  end
+
+end
+

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

@@ -1 +1,34 @@
-require 'facets/enumerable/graph'
+module Enumerable
+
+  # Like `#map`/`#collect`, but generates a Hash. The block is expected
+  # to return two values: the key and the value for the new hash.
+  #
+  #   numbers  = (1..3)
+  #   squares  = numbers.mash{ |n| [n, n*n] }   # { 1=>1, 2=>4, 3=>9 }
+  #   sq_roots = numbers.mash{ |n| [n*n, n] }   # { 1=>1, 4=>2, 9=>3 }
+  #
+  # CREDIT: Andrew Dudzik (adudzik), Trans
+
+  def mash(&yld)
+    if yld
+      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
+      end
+      h
+    else
+      Enumerator.new(self,:graph)
+    end
+  end
+
+end
+

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

@@ -3,24 +3,26 @@ module Enumerable
   # Returns an array of elements for the elements that occur n times.
   # Or according to the results of a given block.
   #
-  #   a = [1,1,2,3,3,4,5,5]
+  #     a = [1,1,2,3,3,4,5,5]
   #
-  #   a.occur(1).sort               #=> [2,4]
-  #   a.occur(2).sort               #=> [1,3,5]
-  #   a.occur(3).sort               #=> []
+  #     a.occur(1).sort               #=> [2,4]
+  #     a.occur(2).sort               #=> [1,3,5]
+  #     a.occur(3).sort               #=> []
   #
-  #   a.occur(1..1).sort            #=> [2,4]
-  #   a.occur(2..3).sort            #=> [1,3,5]
+  #     a.occur(1..1).sort            #=> [2,4]
+  #     a.occur(2..3).sort            #=> [1,3,5]
   #
-  #   a.occur { |n| n == 1 }.sort   #=> [2,4]
-  #   a.occur { |n| n > 1 }.sort    #=> [1,3,5]
+  #     a.occur { |n| n == 1 }.sort   #=> [2,4]
+  #     a.occur { |n| n > 1 }.sort    #=> [1,3,5]
   #
   def occur(n=nil) #:yield:
     result = Hash.new { |hash, key| hash[key] = Array.new }
-    self.each do |item|
+
+    each do |item|
       key = item
       result[key] << item
     end
+
     if block_given?
       result.reject! { |key, values| ! yield(values.size) }
     else
@@ -31,6 +33,7 @@ module Enumerable
         result.reject! { |key, values| values.size != n }
       end
     end
+
     return result.values.flatten.uniq
   end
 

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

@@ -0,0 +1,56 @@
+module Enumerable
+  
+  # Returns the _only_ element in the enumerable. Raises an IndexError if
+  # the enumreable has more then one element.
+  #
+  #   [5].only      # => 5
+  #
+  #   expect IndexError do
+  #     [1,2,3].only
+  #   end
+  #
+  #   expect IndexError do
+  #     [].only
+  #   end
+  #
+  # CREDIT: Lavir the Whiolet, Gavin Sinclair, Noah Gibbs
+  #
+  def only
+    first = false
+    first_item = nil
+
+    each do |item|
+      if first
+        raise IndexError, "not the only element of enumerable"
+      else
+        first = true
+        first_item = item
+      end
+    end
+ 
+    if first
+      return first_item
+    else
+      raise IndexError, "not the only element of enumerable"
+    end
+  end
+
+  # Does this Enumerable have the only element?
+  # 
+  # It differs from Enumerable#one? in that it does not check the items
+  # themselves. It checks the quantity only.
+  # 
+  # CREDIT: Lavir the Whiolet
+  #
+  def only?
+    first = false
+
+    each do |item|
+      return false if first
+      first = true
+    end
+
+    return first
+  end
+
+end

data/lib/core/facets/enumerable/{cluster_by.rb → organize_by.rb}

@@ -1,18 +1,19 @@
-require 'facets/enumerable/group_by'
-
 module Enumerable
 
   # Similar to #group_by but returns an array of the groups.
   # Returned elements are sorted by block.
   #
-  #    %w{this is a test}.cluster_by {|x| x[0]}
+  #    %w{this is a test}.organize_by {|x| x[0]}
   #    #=> [ ['a'], ['is'], ['this', 'test'] ]
   #
   # CREDIT: Erik Veenstra
 
-  def cluster_by(&b)
+  def organize_by(&b)
     group_by(&b).sort.transpose.pop || []   # group_by(&b).values ?
   end
 
+  # DEPRECATED: Name changed to avoid confusion with #cluster.
+  alias cluster_by organize_by
+
 end
 

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

@@ -0,0 +1,20 @@
+module Enumerable
+
+  # Like `each_slice(2)` but ensures the last 
+  # element has a pair if odd sized.
+  #
+  #   [:a,1,:b,2,:c,3].pair.to_a  #=> [[:a,1],[:b,2],[:c,3]]
+  #
+  def pair(missing=nil)
+    return to_enum(:pair) unless block_given?
+
+    each_slice(2) do |kv|
+      if kv.size == 1
+        yield kv.first, missing
+      else
+        yield kv.first, kv.last
+      end
+    end
+  end
+
+end

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

@@ -1,21 +1,38 @@
 require 'facets/functor'
 
-#--
-# TODO: Consider Enumerator methods.
-#++
-
 module Enumerable
 
+  # TODO: Consider Enumerator methods.
+
+  # TODO: Should Enumerable#pre be moved to functor gem?
+
+  # TODO: Does the `*y` argument make sense?
+
   # Per element meta-functor.
   #
-  #   ([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]
   #
   # Using fluid notation.
   #
-  #   ([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
+      Functor.new do |op, *args, &blk|
+        __send__(enum_method || :map, *enum_args){ |x, *y| x.__send__(op, *y, *args, &blk) }
+      end
+    else
+      Functor.new do |enumr_method, *enumr_args|
+        Functor.new do |op, *args, &blk|
+          __send__(enumr_method, *enumr_args){ |x, *y| x.__send__(op, *y, *args, &blk) }
+        end
+      end
+    end
+  end
+
+=begin
   def per(enum_method=nil, *enum_args)
     if enum_method
       Permeator.new(self, enum_method, *enum_args)
@@ -50,35 +67,10 @@ module Enumerable
     end
 
     def method_missing(sym, *args, &blk)
-      @enum_object.__send__(@enum_method){ |x| x.__send__(sym, *args, &blk) }
+      #@enum_object.__send__(@enum_method){ |x| x.__send__(sym, *args, &blk) }
+      @enum_object.__send__(@enum_method){ |x, *y| x.__send__(sym, *y, *args, &blk) }
     end
   end
-
-## TODO: Use this when 1.8.6 support is not longer needed.
-=begin
-    # Per element meta-functor.
-    #
-    #   ([1,2,3].per(:map) + 3)     #=> [4,5,6]
-    #   ([1,2,3].per(:select) > 1)  #=> [2,3]
-    #
-    # Using fluid notation.
-    #
-    #   ([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
-        Functor.new do |op, *args, &blk|
-          __send__(enum_method, *enum_args){ |x| x.__send__(op, *args, &blk) }
-        end
-      else
-        Functor.new do |enumr_method, *enumr_args|
-          Functor.new do |op, *args, &blk|
-            __send__(enumr_method, *enumr_args){ |x| x.__send__(op, *args, &blk) }
-          end
-        end
-      end
-    end
 =end
 
 end

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

@@ -9,11 +9,11 @@ module Enumerable
   end
 
   # Recursor is a specialized Functor for recurively iterating over Enumerables.
-  #--
+  #
   # TODO: Return Enumerator if no +yld+ block is given.
   #
-  # TODO: Add limiting +depth+ option to Enumerable#recursively ?
-  #++
+  # TODO: Add limiting +depth+ option to Enumerable#recursively?
+  #
   class Recursor
     instance_methods(true).each{ |m| private m unless /^(__|object_id$)/ =~ m.to_s }
 

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

@@ -0,0 +1,36 @@
+module Enumerable
+
+  # Squeeze out the same elements. This behaves like C++ unique(),
+  # removing equivalent elements that are concomitant to each other.
+  # To get a similar result with Array#uniq, the array would have to
+  # be sorted first.
+  #
+  # Calculation order is O(n).
+  #
+  # Examples
+  #
+  #   [1,2,2,3,3,2,1].squeeze #=> [1,2,3,2,1]
+  #   [1,2,2,3,3,2,1].sort.squeeze #=> [1,2,3]
+  #   [1,2,2,3,3,2,1].squeeze(*[3]) #=> [1,2,2,3,2,1]
+  #
+  # Returns [Array].
+  #
+  # CREDIT: T. Yamada
+
+  def squeeze(*limited_to)
+    first = true
+    r = []   # result
+    c = nil  # current
+    each do |e|
+      if !limited_to.empty? && !limited_to.include?(e)
+        r << e
+      elsif first || c != e
+        r << e
+        first = false
+        c = e
+      end
+    end
+    r
+  end
+
+end

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

@@ -2,16 +2,28 @@ module Enumerable
 
   # Uses #+ to sum the enumerated elements.
   #
-  #   [1,2,3].sum  #=> 6
-  #   [3,3,3].sum  #=> 9
+  #     [1,2,3].sum      #=> 6
+  #     [3,3,3].sum      #=> 9
+  #     [].sum           #=> 0
   #
-  # @author Dawid Marcin Grzesiak (bug fix)
+  # A initial value can be passed to the method.
+  #
+  #     [].sum(5)        #=> 5
+  #     [1,2,3].sum(10)  #=> 16
+  #
+  # A block can also be passed to coax the elements before summation.
+  # 
+  #     [1.1,2.2,3.3].sum(10.4, &:to_i)  #=> 16.4
+  #
+  # Notice the initial value is not effected by the block.
+  #
+  # @author Dawid Marcin Grzesiak
 
-  def sum(identity=0, &block)
+  def sum(*identity, &block)
     if block_given?
-      map(&block).sum(identity)
+      map(&block).sum(*identity)
     else
-      inject{ |sum, element| sum + element } || identity
+      reduce(*identity) { |sum, element| sum + element }
     end
   end
 

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

@@ -0,0 +1,23 @@
+module Enumerable
+
+  # Take an associative array and unassociate it.
+  #
+  #   [[:a,1], [:b,2]].unassociate.to_a     #=> [:a, [1], :b, [2]]
+  #   [[:a,1], [:b,2]].unassociate(1).to_a  #=> [:a, 1, :b, 2]
+  #
+  def unassociate(index = 1..-1)
+    return to_enum(:unassociate, index) unless block_given?
+
+    each do |v|
+      case v
+      when Array
+        yield v[0]
+        yield v[index]
+      else
+        yield v
+        yield nil
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,25 @@
+module Enumerable
+  # Create a hash whose keys are the enumerable's elements, with specified
+  # values.
+  #
+  # If no block is given, the given parameter (default true) is used for
+  # all values, e.g.:
+  #
+  #     [1,2,3].value_by{ true }     #=> {1=>true, 2=>true, 3=>true}
+  #     [1,2,3].value_by{ "a" }      #=> {1=>"a", 2=>"a", 3=>"a"}
+  #
+  # If a block is given, each key's value is the result of running the
+  # block for that key, e.g.:
+  #
+  #     [1,2,3].value_by{ |n| "a"*n }  #=> {1=>"a", 2=>"aa", 3=>"aaa"}
+  #
+  # @author Ronen Barzel
+  #
+  def value_by
+    return to_enum(:value_by) unless block_given?
+
+    h = {}
+    each { |item| h[item] = yield(item) }
+    h
+  end
+end

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

@@ -1,36 +1,27 @@
-# for Ruby 1.8 -> 1.9 transition
-unless defined?(::Enumerator)
-  begin
-    require 'enumerator'
-    Enumerator = Enumerable::Enumerator unless defined? ::Enumerator
-  rescue LoadError # Ruby 1.9 already has it built-in.
-  end
-end
-
 require 'facets/functor'
 
 class Enumerator
 
-  #
-  def fx
-    Functor.new(&method(:fx_send).to_proc)
-  end
-
-  private
+  # TODO: Should Enumerator#fx be moved to functor gem?
 
   #
-  def fx_send(op, *a, &b)
-    map{ |e| e.send(op, *a, &b) }
+  def fx
+    Functor.new do |op, *a, &b|
+      map{ |e| e.send(op, *a, &b) }
+    end
   end
 
-  ## TODO: When no longer needed to support 1.8.6 we can use:
-  ##
-  ## #
-  ## def fx
-  ##   Functor.new do |op, *a, &b|
-  ##     map{ |e| e.send(op, *a, &b) }
-  ##   end
-  ## end
+#  Old 1.8 version (left temporarily for reference)
+#
+#  def fx
+#    Functor.new(&method(:fx_send).to_proc)
+#  end
+#
+#  private
+#
+#  def fx_send(op, *a, &b)
+#    map{ |e| e.send(op, *a, &b) }
+#  end
 
 end