mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/core/facets/array/delete.rb

@@ -0,0 +1,61 @@
+class Array
+
+  # Inverse of #delete_if.
+  #
+  #   [1,2,3].delete_unless{ |x| x < 2 }
+  #   => [1,2]
+  #
+  #  CREDIT: Daniel Schierbeck
+
+  def delete_unless(&block)
+    delete_if { |element| not block.call(element) }
+  end
+
+  # Delete multiple values from array.
+  #
+  #   a = [1,2,3,4]
+  #   a.delete_values(1,2)   #=> [1,2]
+  #   a                      #=> [3,4]
+  #
+  # CREDIT: Trans
+
+  def delete_values(*values)
+    d = []
+    values.each{ |v| d << delete(v) }
+    d
+  end
+
+  # Delete multiple values from array given
+  # indexes or index range.
+  #
+  #   a = [1,2,3,4]
+  #   a.delete_values_at(1,2)   #=> [2,3]
+  #   a                         #=> [1,4]
+  #   a = [1,2,3,4]
+  #   a.delete_values_at(0..2)  #=> [1,2,3]
+  #   a                         #=> [4]
+  #
+  # NOTE: It would be nice to see #delete_at incorporate this
+  # funcitonaility.
+  #
+  #  CREDIT: Trans
+
+  def delete_values_at(*selectors)
+    idx = []
+    selectors.each{ |i|
+      case i
+      when Range
+        idx.concat( i.to_a )
+      else
+        idx << i.to_i
+      end
+    }
+    idx.uniq!
+    dvals = values_at(*idx)
+    idx = (0...size).to_a - idx
+    self.replace( values_at(*idx) )
+    return dvals
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/array/index.rb

@@ -0,0 +1,48 @@
+class Array
+
+  if RUBY_VERSION < '1.9'
+
+    alias_method :_facets_index, :index
+
+    # Allows #index to accept a block.
+    #
+    # OVERRIDE! This is one of the bery 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
+
+
+=begin :spec:
+
+  require 'quarry/spec'
+
+  Quarry.spec "Array" do
+
+    the_method "index" do
+
+      finds "an element" do
+        i = [1,2,3].index{ |e| e == 2 }
+        i.assert == 1
+      end
+
+      terminates "when no element is found" do
+        i = [1,2,3].index{ |e| e == 5 }
+        i.assert == nil
+      end
+
+    end
+
+  end
+
+=end
+

data/lib/gems/facets-2.4.5/lib/core/facets/array/indexable.rb

@@ -0,0 +1,73 @@
+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"
+  #   p 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]
+  #   a.last! 3
+  #   p a           #=> [1,2,3]
+  #
+  #  CREDIT: Trans
+
+  alias_method :last!, :pop
+
+  #
+  #
+
+  #alias_method :/, :[]
+
+=begin
+  # TODO Probably not best to overide store and fetch operators. Rename?
+
+  # Modifies #[] to also accept an array of indexes.
+  #
+  #   a = ['a','b','c','d','e','f']
+  #
+  #   a[[1]]      #=> ['b']
+  #   a[[1,1]]    #=> ['b','b']
+  #   a[[1,-1]]   #=> ['b','f']
+  #   a[[0,2,4]]  #=> ['a','c','e']
+  #
+  def [](*args)
+    return values_at(*args.at(0)) if Array === args.at(0)
+    return slice(*args)
+  end
+
+  # Modifies #[]= to accept an array of indexes for assignment.
+  #
+  #   a = ['a','b','c','d']
+  #
+  #   a[[1,-1]] = ['m','n']    #=> ['m','n']
+  #   a                        #=> ['a','m','c','n']
+  #
+  def []=(*args)
+    if Array === args.at(0)
+      idx,vals = args.at(0),args.at(1)
+      idx.each_with_index{ |a,i| store(a,vals.at(i)) }
+      return values_at( *idx )
+    else
+      return store(*args)
+    end
+  end
+
+end
+=end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/array/merge.rb

@@ -0,0 +1,21 @@
+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/lib/gems/facets-2.4.5/lib/core/facets/array/not_empty.rb

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

data/lib/gems/facets-2.4.5/lib/core/facets/array/only.rb

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

data/lib/gems/facets-2.4.5/lib/core/facets/array/pad.rb

@@ -0,0 +1,41 @@
+class Array
+
+  # Pad an array with a given <tt>value</tt> upto 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/lib/gems/facets-2.4.5/lib/core/facets/array/permutation.rb

@@ -0,0 +1,30 @@
+unless (RUBY_VERSION[0,3] == '1.9')
+
+  class Array
+
+    # 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.
+    #
+    #  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/lib/gems/facets-2.4.5/lib/core/facets/array/product.rb

@@ -0,0 +1,57 @@
+unless (RUBY_VERSION[0,3] == '1.9')
+
+  class Array
+
+    # Provides the cross-product of two or more Enumerables.
+    # This is the class-level method. The instance method
+    # calls on this.
+    #
+    #   Enumerable.cartesian_product([1,2], [4], ["apple", "banana"])
+    #   #=> [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
+    #
+    #   Enumerable.cartesian_product([1,2], [3,4])
+    #   #=> [[1, 3], [1, 4], [2, 3], [2, 4]]
+    #
+    #   a = []
+    #   [1,2].cart([4,5]){|elem| a << elem }
+    #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
+    #
+    #  CREDIT: Thomas Hafner
+
+    def product(*enums, &block)
+      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
+      if block_given?
+        result.each{ |e| block.call(e) }
+      else
+        result
+      end
+    end
+
+  end
+
+end
+
+
+class Array
+
+  # Operator alias for cross-product.
+  #
+  #   a = [1,2] ** [4,5]
+  #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
+  #
+  #  CREDIT: Trans
+
+  alias_method :**, :product
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/array/recursively.rb

@@ -0,0 +1,30 @@
+class Array
+
+  # Apply a block to hash, and recursively apply that block
+  # to each subhash.
+  #
+  #   arr = ["a", ["b", "c", nil], nil]
+  #   arr.recursively{|a| a.compact! }
+  #   => ["a", ["b", "c"]]
+  #
+  # TODO: Can this be generalized in Enumerbale?
+
+  def recursively(&block)
+    a = inject([]) do |array, value|
+      if value.is_a?(Array)
+        array << value.recursively(&block)
+      else
+        array << value
+      end
+      array
+    end
+    yield a
+  end
+
+  # In place form of #recursively.
+
+  def recursively!(&block)
+    replace(recursively(&block))
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/array/rotate.rb

@@ -0,0 +1,42 @@
+class Array
+
+  # Rotates an array's elements from back to front n times.
+  #
+  #   [1,2,3].rotate      #=> [3,1,2]
+  #   [3,1,2].rotate      #=> [2,3,1]
+  #   [3,1,2].rotate      #=> [1,2,3]
+  #   [1,2,3].rotate(3)   #=> [1,2,3]
+  #
+  # A negative parameter reverses the order from front to back.
+  #
+  #   [1,2,3].rotate(-1)  #=> [2,3,1]
+  #
+  #  CREDIT: Florian Gross
+  #  CREDIT: Thomas Sawyer
+
+  def rotate(n=1)
+    self.dup.rotate!(n)
+  end
+
+  # Same as #rotate, but acts in place.
+  #
+  #   a = [1,2,3]
+  #   a.rotate!
+  #   a  #=> [3,1,2]
+  #
+  #  CREDIT: Florian Gross
+  #  CREDIT: Thomas Sawyer
+
+  def rotate!(n=1)
+    n = n.to_int
+    return self if (n == 0 or self.empty?)
+    if n > 0
+      n.abs.times{ self.unshift( self.pop ) }
+    else
+      n.abs.times{ self.push( self.shift ) }
+    end
+    self
+  end
+
+end
+