facets 2.9.2 → 2.9.3

data/src/core/facets/enumerable/map_with.rb

@@ -1,18 +0,0 @@
-module Enumerable
-
-  # Combines #zip and #map in a single efficient operation.
-  #
-  #   h = {}
-  #   [1,2,3].map_with [:x,:y,:z] do |n,k|
-  #     h[k] = n
-  #   end
-  #   h  #=> {:x=>1, :y=>2, :z=>3}
-  #
-  def map_with(*arrays, &block)
-    enum_for(:zip, *arrays).map(&block)
-  end
-
-  #
-  alias_method :zip_map, :map_with
-
-end

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

@@ -1,23 +0,0 @@
-module Enumerable
-
-  # Same as #collect but with an iteration counter.
-  #
-  #   a = [1,2,3].collect_with_index { |e,i| e*i }
-  #   a  #=> [0,2,6]
-  #
-  # CREDIT: Gavin Sinclair
-
-  def map_with_index
-    r = []
-    each_with_index do |e, i|
-      r << yield(e, i)
-    end
-    r
-  end
-
-  # Alias for map_with_index.
-
-  alias_method :collect_with_index, :map_with_index
-
-end
-

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

@@ -1 +0,0 @@
-require 'facets/enumerable/graph'

data/src/core/facets/enumerable/modulate.rb

@@ -1,22 +0,0 @@
-module Enumerable
-
-  # Modulate. Divide an array into groups by modulo of the index.
-  #
-  #   [2,4,6,8].modulate(2)  #=> [[2,6],[4,8]]
-  #
-  # CREDIT: Trans
-  #
-  # NOTE: Would the better name for this be 'collate'?
-
-  def modulate(modulo)
-    return to_a if modulo == 1
-    raise ArgumentError, 'bad modulo' if size % modulo != 0
-    r = Array.new(modulo, [])
-    (0...size).each do |i|
-      r[i % modulo] += [self[i]]
-    end
-    r
-  end
-
-end
-

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

@@ -1,32 +0,0 @@
-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
-    # the elements in the collection satisfy the predicate.
-    #
-    # If no predicate is provided, Enumerable#none? returns +true+
-    # if and only if _none_ of the elements have a true value
-    # (i.e. not +nil+ or +false+).
-    #
-    #   [].none?                      # => true
-    #   [nil].none?                   # => true
-    #   [5,8,9].none?                 # => false
-    #   (1...10).none? { |n| n < 0 }  # => true
-    #   (1...10).none? { |n| n > 0 }  # => false
-    #
-    # CREDIT: Gavin Sinclair
-
-    def none?  # :yield: e
-      if block_given?
-        not self.any? { |e| yield e }
-      else
-        not self.any?
-      end
-    end
-
-  end
-
-end
-

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

@@ -1,38 +0,0 @@
-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.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 { |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|
-      key = item
-      result[key] << item
-    end
-    if block_given?
-      result.reject! { |key, values| ! yield(values.size) }
-    else
-      raise ArgumentError unless n
-      if Range === n
-        result.reject! { |key, values| ! n.include?(values.size) }
-      else
-        result.reject! { |key, values| values.size != n }
-      end
-    end
-    return result.values.flatten.uniq
-  end
-
-end
-

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

@@ -1,39 +0,0 @@
-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.
-    #
-    # If no predicate is provided, Enumerable#one? returns +true+ if
-    # and only if <em>exactly one</em> element has a true value
-    # (i.e. not +nil+ or +false+).
-    #
-    #   [].one?                      # => false
-    #   [nil].one?                   # => false
-    #   [5].one?                     # => true
-    #   [5,8,9].one?                 # => false
-    #   (1...10).one? { |n| n == 5 } # => true
-    #   (1...10).one? { |n| n < 5 }  # => false
-    #
-    # CREDIT: Gavin Sinclair
-
-    def one?  # :yield: e
-      matches = 0
-      if block_given?
-        self.each do |e|
-          if yield(e)
-            matches += 1
-            return false if matches > 1
-          end
-        end
-        return (matches == 1)
-      else
-        one? { |e| e }
-      end
-    end
-
-  end
-
-end
-

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

@@ -1,85 +0,0 @@
-require 'facets/functor'
-
-#--
-# TODO: Consider Enumerator methods.
-#++
-
-module Enumerable
-
-  # 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
-      Permeator.new(self, enum_method, *enum_args)
-    else
-      Functor.new do |enumr_method, *enumr_args|
-        Permeator.new(self, enumr_method, *enumr_args)
-      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
-
-## 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/src/core/facets/enumerable/purge.rb

@@ -1,43 +0,0 @@
-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/src/core/facets/enumerable/recursively.rb

@@ -1,66 +0,0 @@
-module Enumerable
-
-  # Returns a recursive functor, that allows enumerable methods to iterate
-  # through enumerable sub-elements. By default it only recurses over
-  # elements of the same type.
-  #
-  def recursively(*types, &block)
-    Recursor.new(self, *types, &block)
-  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 ?
-  #++
-  class Recursor
-    instance_methods(true).each{ |m| private m unless /^(__|object_id$)/ =~ m.to_s }
-
-    def initialize(enum, *types, &block)
-      @enum   = enum
-      @types  = types.empty? ? [@enum.class] : types
-      @block  = block
-    end
-
-    def method_missing(op, &yld)
-      rec = @block || lambda{ |v| v }
-      yld = yld    || lambda{ |v| v }  # ? to_enum
-      @enum.__send__(op) do |v|
-        case v
-        when String # b/c of 1.8
-          yld.call(v)
-        when *@types
-          res = v.recursively(*@types, &@block).__send__(op,&yld)
-          rec.call(res)
-        else
-          yld.call(v)
-        end
-      end
-    end
-  end
-
-  ## TODO: When no longer needing to support 1.8.6 we could get rid of
-  ## the Recursor class and use:
-  ## #
-  ## def recursively(*types, &block)
-  ##   types = types.empty? ? [self.class] : types
-  ##   Functor.new do |op, &yld|
-  ##     rec = block || lambda{ |v| v }
-  ##     yld = yld   || lambda{ |v| v }  # ? to_enum
-  ##     __send__(op) do |v|
-  ##       case v
-  ##       when String # b/c of 1.8
-  ##         yld.call(v)
-  ##       when *types
-  ##         res = v.recursively(*types, &block).__send__(op,&yld)
-  ##         rec.call(res)
-  ##       else
-  ##         yld.call(v)
-  ##       end
-  ##     end
-  ##   end
-  ## end
-
-end
-

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

@@ -1,16 +0,0 @@
-module Enumerable
-
-  # Uses #+ to sum the enumerated elements.
-  #
-  #   [1,2,3].sum  #=> 6
-  #   [3,3,3].sum  #=> 9
-  #
-  def sum(identity = 0, &block)
-    if block_given?
-      map(&block).sum
-    else
-      inject{ |sum, element| sum + element } || identity
-    end
-  end
-
-end

data/src/core/facets/enumerable/take.rb

@@ -1,16 +0,0 @@
-module Enumerable
-
-  # Return the first n items from the collection
-  #
-  def take(n)
-    res = []
-    count = 0
-    each do |e|
-      break if count >= n
-      res << e
-      count += 1
-    end
-    res
-  end unless method_defined?(:take)
-
-end

data/src/core/facets/enumerable/uniq_by.rb

@@ -1,13 +0,0 @@
-module Enumerable
-
-  # Like #uniq, but determines uniqueness based on a given block.
-  #
-  #   (-5..5).to_a.uniq_by {|i| i*i }
-  #   #=> [-5, -4, -3, -2, -1, 0]
-  #
-  def uniq_by #:yield:
-    h = {}; inject([]) {|a,x| h[yield(x)] ||= a << x}
-  end
-
-end
-

data/src/core/facets/enumerable/visit.rb

@@ -1,30 +0,0 @@
-module Enumerable
-
-  # Recursively iterate over all Enumerable elements, or
-  # subset given :type=>[type1, type2, ...].
-  #
-  #   [1, 2, 8..9].visit{ |x| x.succ }
-  #   # => [2, 3, [9, 10]]
-  #
-  def visit(opts={}, &block)
-    type = opts[:type] ? [opts[:type]].flatten : [Enumerable]
-    skip = opts[:skip]
-
-    map do |v|
-      case v
-      when String # b/c of 1.8
-        block.call(v)
-      when *type
-        v.visit(opts, &block)
-      else
-        if skip && Enumerable === v
-          v
-        else
-          block.call(v)
-        end
-      end
-    end
-  end
-
-end
-