facets 2.9.2 → 2.9.3

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

@@ -1,23 +0,0 @@
-class Array
-
-  if RUBY_VERSION < '1.8.7'
-
-    alias_method :_facets_index, :index
-
-    # Allows #index to accept a block.
-    #
-    #   ['a', 'b', 'c'].index{ |x| x.upcase == 'C' } #=> 2
-    #
-    # IMPORTANT: This is one of the few core overrides in Facets.
-    def index(obj=nil, &block)
-      if block_given?
-        _facets_index(find(&block))
-      else
-        _facets_index(obj)
-      end
-    end
-
-  end
-
-end
-

data/src/core/facets/array/indexable.rb

@@ -1,31 +0,0 @@
-require 'facets/indexable'
-require 'facets/array/splice'
-
-class Array
-
-  include Indexable
-
-  # Alias for shift, which removes and returns
-  # the first element in an array.
-  #
-  #   a = ["a","y","z"]
-  #   a.first!      #=> "a"
-  #   a             #=> ["y","z"]
-  #
-  # CREDIT: Trans
-
-  alias_method :first!, :shift
-
-  # Alias for pop, which removes and returns
-  # the last element in an array.
-  #
-  #   a = [1,2,3]
-  #   a.last!       #=> 3
-  #   a             #=> [1,2]
-  #
-  # CREDIT: Trans
-
-  alias_method :last!, :pop
-
-end
-

data/src/core/facets/array/merge.rb

@@ -1,22 +0,0 @@
-class Array
-
-  # In place #merge.
-  #
-  #   a = [1,2]
-  #   a.merge! [2,3]
-  #   a #=> [1,2,3]
-  #
-  # CREDIT: Trans
-
-  def merge!( other )
-    self.replace(self.merge(other))
-  end
-
-  # Alias for <tt>|</tt>.
-  #
-  #   [1,2].merge([2,3])  #=> [1,2,3]
-  #
-  alias_method :merge, :|
-
-end
-

data/src/core/facets/array/mode.rb

@@ -1,22 +0,0 @@
-class Array
-
-  # In Statistics mode is the value that occurs most frequently
-  # in a given set of data. This method returns an array in case
-  # their is a tie.
-  #
-  #   [:a, :b, :c, :b, :d].mode  #=> [:b]
-  #   [:a, :b, :c, :b, :a].mode  #=> [:a, :b]
-  #
-  # Returns an Array of most common elements.
-  #
-  # CREDIT: Robert Klemme
-
-  def mode
-    max = 0
-    c = Hash.new 0
-    each {|x| cc = c[x] += 1; max = cc if cc > max}
-    c.select {|k,v| v == max}.map {|k,v| k}
-  end
-
-end
-

data/src/core/facets/array/nonuniq.rb

@@ -1,37 +0,0 @@
-class Array
-
-  # Returns a list of non-unique elements
-  #
-  #   [1,1,2,2,3,4,5].nonuniq  #=> [1,2]
-  #
-  # CREDIT: Martin DeMello
-
-  def nonuniq
-    h1 = {}
-    h2 = {}
-    each {|i|
-      h2[i] = true if h1[i]
-      h1[i] = true
-    }
-    h2.keys
-  end
-
-  #
-  def nonuniq!
-    h1 = {}
-    h2 = {}
-    each {|i|
-      h2[i] = true if h1[i]
-      h1[i] = true
-    }
-    self.replace(h2.keys)
-  end
-
-  # Return list of duplictate elements.
-  #
-  # CREDIT: Thibaut Barrère
-
-  alias_method :duplicates, :nonuniq
-
-end
-

data/src/core/facets/array/not_empty.rb

@@ -1,13 +0,0 @@
-class Array
-
-  # Not empty?
-  #
-  #   [].not_empty?     #=> false
-  #   [1,2].not_empty?  #=> true
-
-  def not_empty?
-    !empty?
-  end
-
-end
-

data/src/core/facets/array/only.rb

@@ -1,26 +0,0 @@
-class Array
-
-  # Returns the _only_ element in the array.  Raises an IndexError if
-  # the array's size is not 1.
-  #
-  #   [5].only      # => 5
-  #
-  #   expect IndexError do
-  #     [1,2,3].only
-  #   end
-  #
-  #   expect IndexError do
-  #     [].only
-  #   end
-  #
-  # CREDIT: Gavin Sinclair, Noah Gibbs
-
-  def only
-    unless size == 1
-      raise IndexError, "Array#only called on non-single-element array"
-    end
-    first
-  end
-
-end
-

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

@@ -1,41 +0,0 @@
-class Array
-
-  # 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"]
-  #
-  # If <tt>length</tt> is a negative number padding will be added
-  # to the beginning of the array.
-  #
-  #   [0,1,2].pad(-6,"a")  #=> ["a","a","a",0,1,2]
-  #
-  # CREDIT: Richard Laugesen
-
-  def pad(len, val=nil)
-    return dup if self.size >= len.abs
-    if len < 0
-      Array.new((len+size).abs,val) + self
-    else
-      self + Array.new(len-size,val)
-    end
-  end
-
-  # Like #pad but changes the array in place.
-  #
-  #    a = [0,1,2]
-  #    a.pad!(6,"x")
-  #    a  #=> [0,1,2,"x","x","x"]
-  #
-  # CREDIT: Richard Laugesen
-
-  def pad!(len, val=nil)
-    return self if self.size >= len.abs
-    if len < 0
-      replace Array.new((len+size).abs,val) + self
-    else
-      concat Array.new(len-size,val)
-    end
-  end
-
-end
-

data/src/core/facets/array/peek.rb

@@ -1 +0,0 @@
-require 'facets/array/pull'

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

@@ -1,32 +0,0 @@
-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
-    # arrangements is the factorial of the size of the array.
-    #
-    #    [1,2].permutation(2).to_a #=> [[1,2], [2,1]]
-    #
-    # CREDIT: Shin-ichiro Hara
-
-    def permutation(n=size)
-      if size < n or n < 0
-      elsif n == 0
-        yield([])
-      else
-        self[1..-1].permutation(n - 1) do |x|
-          (0...n).each do |i|
-            yield(x[0...i] + [first] + x[i..-1])
-          end
-        end
-        self[1..-1].permutation(n) do |x|
-          yield(x)
-        end
-      end
-    end
-
-  end
-
-end
-

data/src/core/facets/array/poke.rb

@@ -1 +0,0 @@
-require 'facets/array/pull'

data/src/core/facets/array/probability.rb

@@ -1,39 +0,0 @@
-class Array
-
-  # Generates a hash mapping each unique element in the array to the
-  # relative frequency, i.e. the probablity, of it appearence.
-  #
-  #   [:a, :b, :c, :c].probability  #=> {:a=> 0.25, :b=>0.25, :c=>0.5}
-  #
-  # CREDIT: Brian Schröder
-
-  def probability
-    probs = Hash.new(0.0)
-    size = 0.0
-    each do |e|
-      probs[e] += 1.0
-      size += 1.0
-    end
-    probs.keys.each{ |e| probs[e] /= size }
-    probs
-  end
-
-  #--
-  # Old Definition ...
-  #
-  #   def probability
-  #     arr = self.to_a
-  #     probHash = Hash.new
-  #     size = arr.size.to_f
-  #     arr.uniq.each do |i|
-  #       ct = arr.inject(0) do |mem,obj|
-  #         obj.eql?(i) ? (mem+1) : mem
-  #       end
-  #       probHash[i] = ct.to_f/size
-  #     end
-  #     probHash
-  #   end
-  #++
-
-end
-

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

@@ -1,30 +0,0 @@
-class Array
-
-  unless method_defined?(:product) # 1.8.7+
-
-    # Provides the cartesian product of two or more arrays.
-    #
-    #   a = [1,2].product([4,5])
-    #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
-    #
-    # CREDIT: Thomas Hafner
-
-    def product(*enums)
-      enums.unshift self
-      result = [[]]
-      while [] != enums
-        t, result = result, []
-        b, *enums = enums
-        t.each do |a|
-          b.each do |n|
-            result << a + [n]
-          end
-        end
-      end
-      result
-    end
-
-  end
-
-end
-

data/src/core/facets/array/pull.rb

@@ -1,30 +0,0 @@
-class Array
-
-  # Alias for shift which removes an object off first slot of an array.
-  # This is the opposite of pop.
-  alias_method :pull, :shift
-
-  # Peek at the top of the stack (the end of the array).
-  #
-  #   a = [1, 2, 3]
-  #   a.peek          #=> 3
-  #   a               #=> [1, 2, 3]
-  #
-  # Or provide an index to inspect the array from back to front.
-  def peek(i=0)
-    i = -(i + 1)
-    fetch(i)
-  end
-
-  # Put an object on the bottom of the stack (front of the array).
-  #
-  #   a = [2, 3]
-  #   a.poke(1)
-  #   a               #=> [1, 2, 3]
-  #
-  # Or supply an index and #poke works like #insert.
-  def poke(x, i=0)
-    insert(i,x)
-  end
-
-end

data/src/core/facets/array/recurse.rb

@@ -1,29 +0,0 @@
-class Array
-
-  # Apply a block to array, and recursively apply that block
-  # to each sub-array or +types+.
-  #
-  #   arr = ["a", ["b", "c", nil], nil]
-  #   arr.recurse{ |a| a.compact! }
-  #   #=> ["a", ["b", "c"]]
-  #
-  def recurse(*types, &block)
-    types = [self.class] if types.empty?
-    a = inject([]) do |array, value|
-      case value
-      when *types
-        array << value.recurse(*types, &block)
-      else
-        array << value
-      end
-      array
-    end
-    yield a
-  end
-
-  # In place form of #recurse.
-  def recurse!(&block)
-    replace(recurse(&block))
-  end
-
-end

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

@@ -1,47 +0,0 @@
-require 'facets/functor'
-require 'facets/enumerable/recursively'
-
-class Array
-
-  # Apply a method to array, and recursively apply that method
-  # to each sub-array or +types+.
-  #
-  #   arr = ["a", ["b", "c"]]
-  #   arr.recursively.map{ |v| v.to_sym }
-  #   #=> [:a, [:b, :c]]
-  #
-  # By default the sub-types are passed thru uneffected. Passing a block
-  # to #recursively changes this.
-  #
-  #   arr = ["a", ["b", "c"]]
-  #   arr.recursively{ |a| a.reverse }.map{ |v| v.to_sym }
-  #   #=> [:a, [:c, :b]]
-  #
-  # TODO: Return Enumerator if no +yld+ block is given ?
-  def recursively(*types, &block)
-    Recursor.new(self, *types, &block)
-  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{ |a| a }
-  ##     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