mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/core/facets/hash/weave.rb

@@ -0,0 +1,81 @@
+class Hash
+
+  # Weave is a very uniqe hash operator. I is designed
+  # to merge to complex hashes in according to sensible,
+  # regular pattern. The effect is akin to inheritance.
+  #
+  # Two hashes are weaved together to produce a new hash.
+  # The two hashes need to be compatible according to the
+  # following rules for each node:
+  #
+  #   <tt>
+  #   hash,   hash    => hash (recursive +)
+  #   hash,   array   => error
+  #   hash,   value   => error
+  #   array,  hash    => error
+  #   array,  array   => array + array
+  #   array,  value   => array << value
+  #   value,  hash    => error
+  #   value,  array   => array.unshift(valueB)
+  #   value1, value2  => value2
+  #   </tt>
+  #
+  # Here is a basic example:
+  #
+  #   h1 = { :a => 1, :b => [ 1 ], :c => { :x => 1 } }
+  #   => {:b=>[1], :c=>{:x=>1}, :a=>1}
+  #
+  #   h2 = { :a => 2, :b => [ 2 ], :c => { :x => 2 } }
+  #   => {:b=>[2], :c=>{:x=>2}, :a=>2}
+  #
+  #   h1.weave(h2)
+  #   => {:b=>[1, 2], :c=>{:x=>2}, :a=>2}
+  #
+  # Weave follows the most expected pattern of unifying two complex
+  # hashes. It is especially useful for implementing overridable
+  # configuration schemes.
+  #
+  #   CREDIT: Thomas Sawyer
+
+  def weave(h)
+    raise ArgumentError, "Hash expected" unless h.kind_of?(Hash)
+    s = self.clone
+    h.each { |k,node|
+      node_is_hash = node.kind_of?(Hash)
+      node_is_array = node.kind_of?(Array)
+      if s.has_key?(k)
+        self_node_is_hash = s[k].kind_of?(Hash)
+        self_node_is_array = s[k].kind_of?(Array)
+        if self_node_is_hash
+          if node_is_hash
+            s[k] = s[k].weave(node)
+          elsif node_is_array
+            raise ArgumentError, 'Incompatible hash addition' #self[k] = node
+          else
+            raise ArgumentError, 'Incompatible hash addition' #self[k] = node
+          end
+        elsif self_node_is_array
+          if node_is_hash
+            raise ArgumentError, 'Incompatible hash addition' #self[k] = node
+          elsif node_is_array
+            s[k] += node
+          else
+            s[k] << node
+          end
+        else
+          if node_is_hash
+            raise ArgumentError, 'Incompatible hash addition' #self[k] = node
+          elsif node_is_array
+            s[k].unshift( node )
+          else
+            s[k] = node
+          end
+        end
+      else
+        s[k] = node
+      end
+    }
+    s
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/hash/zipnew.rb

@@ -0,0 +1,2 @@
+require 'facets/hash/autonew'
+

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

@@ -0,0 +1,251 @@
+# = Indexable
+#
+# Indexable is a mixin that provides index based methods,
+# working soley with four methods: #index, #slice, #splice
+# and #size.
+#
+# These methods work in harmony. Where #index returns a
+# position of a given element, #slice returns elements
+# for given positions. #splice is like #slice but replaces
+# the given position with new values. This method is not
+# part of ruby core, but it generally just an alias for #[]=,
+# just as #slice is an alias of #[]. #size of course simply
+# returns the total length of the indexable object.
+#
+# == Authors
+#
+# * Thomas Sawyer
+
+
+# = Indexable
+#
+# Indexable is a mixin that provides index based methods,
+# working soley with four methods: #index, #slice, #splice
+# and #size.
+#
+# These methods work in harmony. Where #index returns a
+# position of a given element, #slice returns elements
+# for given positions. #splice is like #slice but replaces
+# the given position with new values. This mehtod is not
+# part of ruby core, but it generally just an alias for #[]=,
+# just as #slice is an alias of #[]. #size of course simply
+# returns the total length of the indexable object.
+#
+module Indexable
+
+  # Like #first but returns the first element
+  # in a new array.
+  #
+  #   [1,2,3].head  #=> [1]
+  #
+  def head
+    slice(0,1)
+  end
+
+  # Returns an array from second element to last element.
+  #
+  #   [1,2,3].tail  #=> [2,3]
+  #
+  def tail
+    slice(1,length-1)
+  end
+
+  # Like #last, returning the last element
+  # in an array.
+  #
+  #   [1,2,3].foot  #=> [3]
+  #
+  def foot
+    slice(-1,1)
+  end
+
+  # Returns an array of the first element upto,
+  # but not including, the last element.
+  #
+  #   [1,2,3].body  #=> [1,2]
+  #
+  #--
+  # Better name for this? (bulk, perhaps?)
+  #++
+  #
+  def body
+    slice(0,size-1)
+  end
+
+  # Returns the middle element of an array, or the element offset
+  # from middle if the parameter is given. Even-sized arrays,
+  # not having an exact middle, return the middle-right element.
+  #
+  #   [1,2,3,4,5].mid        #=> 3
+  #   [1,2,3,4,5,6].mid      #=> 4
+  #   [1,2,3,4,5,6].mid(-1)  #=> 3
+  #   [1,2,3,4,5,6].mid(-2)  #=> 2
+  #   [1,2,3,4,5,6].mid(1)   #=> 5
+  #
+  # In other words, If there are an even number of elements the
+  # higher-indexed of the two center elements is indexed as
+  # orgin (0).
+  #
+  def mid(offset=0)
+    slice((size / 2) + offset)
+  end
+
+  # Returns the middle element(s) of an array. Even-sized arrays,
+  # not having an exact middle, returns a two-element array
+  # of the two middle elements.
+  #
+  #   [1,2,3,4,5].middle        #=> 3
+  #   [1,2,3,4,5,6].middle      #=> [3,4]
+  #
+  # In contrast to #mid which utilizes an offset.
+  #
+  def middle
+    if size % 2 == 0
+     slice( (size / 2) - 1, 2 )
+     #[slice((size / 2) - 1, 1), slice(size / 2, 1)]
+    else
+      slice(size / 2)
+    end
+  end
+
+  # Fetch values from a start index thru an end index.
+  #
+  #   [1,2,3,4,5].thru(0,2)  #=> [1,2,3]
+  #   [1,2,3,4,5].thru(2,4)  #=> [3,4,5]
+  #
+  def thru(from, to)
+    a = []
+    i = from
+    while i <= to
+      a << slice(i)
+      i += 1
+    end
+    a
+  end
+
+  # Returns first _n_ elements.
+  #
+  #   "Hello World".first(3)  #=> "Hel"
+  #
+  def first(n=1)
+    slice(0, n.to_i)
+  end
+
+  # Returns last _n_ elements.
+  #
+  #   "Hello World".last(3)  #=> "rld"
+  #
+  def last(n=1)
+    n = n.to_i
+    return self if n > size
+    slice(-n, n) #slice(-n..-1)
+  end
+
+  # Change the first element.
+  #
+  #   a = ["a","y","z"]
+  #   a.first = "x"
+  #   p a           #=> ["x","y","z"]
+  #
+  def first=(x)
+    splice(0,x)
+  end
+
+  # Change the last element.
+  #
+  #   a = [1,2,5]
+  #   a.last = 3
+  #   p a           #=> [1,2,3]
+
+  def last=(x)
+    splice(-1,x)
+  end
+
+  # Remove and return the first element.
+  #
+  #   a = [1,2,3]
+  #   a.first!      #=> 1
+  #   a             #=> [2,3]
+  #
+  def first!
+    splice(0)
+  end
+
+  # Remove and return the last element.
+  #
+  #   a = [1,2,3]
+  #   a.last!       #=> 3
+  #   a             #=> [1,2]
+  #
+  def last!
+    splice(-1)
+  end
+
+  # A shorting of "ends at", returns the
+  # last index of the indexable object.
+  # Returns nil if there are no elements.
+  #
+  #   [1,2,3,4,5].ends  #=> 4
+  #
+  # This nearly equivalent to +size - 1+.
+  #
+  def ends
+    return nil if size == 0
+    size - 1
+  end
+
+  # Returns the positive ordinal index given
+  # a cardinal position, 1 to n or -n to -1.
+  #
+  #   [1,2,3,4,5].pos(1)   #=> 0
+  #   [1,2,3,4,5].pos(-1)  #=> 4
+  #
+  def pos(i)
+    if i > 0
+      return i - 1
+    else
+      size + i
+    end
+  end
+
+  # Returns the index of the first element equal to the
+  # given object or satisfying the block condition.
+  #
+  #   [1,2,3,4].index{ |e| e == 3 }  #=> 2
+  #   [1,2,3,4].index{ |e| e > 3 }   #=> 3
+  #
+  def index(obj=nil, &block)
+    if block_given?
+      size.times do |i|
+        return i if yield(slice(i))
+      end
+    else
+      size.times do |i|
+        return i if obj == slice(i)
+      end
+    end
+    nil
+  end
+
+  # to be deprecated
+  alias_method :index_of, :index
+
+  # TODO Maybe #range could use a little error catch code (todo).
+
+  # Returns the index range between two elements.
+  # If no elements are given, returns the range
+  # from first to last.
+  #
+  #   ['a','b','c','d'].range            #=> 0..3
+  #   ['a','b','c','d'].range('b','d')   #=> 1..2
+  #
+  def range(a=nil,z=nil)
+    if !a
+      0..(size-1)
+    else
+      index(a)..index(z)
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/integer.rb

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/integer/even.rb

@@ -0,0 +1 @@
+require 'facets/integer/odd'

data/lib/gems/facets-2.4.5/lib/core/facets/integer/factorial.rb

@@ -0,0 +1,30 @@
+class Integer
+
+  # Calculate the factorial of an integer.
+  #
+  #   2.factorial  #=> 2
+  #   3.factorial  #=> 6
+  #   3.factorial  #=> 24
+  #
+  #  CREDIT: Malte Milatz
+
+  def factorial
+    return 1 if zero?
+    f = 1
+    2.upto(self) { |n| f *= n }
+    f
+  end
+
+  alias_method( :fac, :factorial )
+
+  #-- OLD CODE
+  #def factorial
+  #  return 1 if self == 0
+  #  #self == 0 ? 1 : ( self * (self-1).factorial )
+  #  f = (1..self.abs).inject { |state, item| state * item }
+  #  return self < 0 ? -f : f
+  #end
+  #++
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/integer/multiple.rb

@@ -0,0 +1,15 @@
+class Integer
+
+  # Is is a multiple of a given number?
+  #
+  #   7.multiple?(2)  #=> false
+  #   8.multiple?(2)  #=> true
+  #
+  #  CREDIT: Trans
+
+  def multiple?(number)
+    self % number == 0
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/integer/odd.rb

@@ -0,0 +1,35 @@
+class Integer
+
+  if RUBY_VERSION < '1.9'
+
+    # Returns true if this integer is odd, false otherwise.
+    #
+    #   2.odd?            #=> false
+    #   3.odd?            #=> true
+    #
+    #   -99.odd?          # -> true
+    #   -98.odd?          # -> false
+    #
+    #  CREDIT: Daniel Schierbeck
+
+    def odd?
+      #self % 2 == 1
+      self & 1 == 1
+    end
+
+    # Returns true if this integer is even, false otherwise.
+    #
+    #   2.even?  #=> true
+    #   3.even?  #=> false
+    #
+    #   CREDIT: Daniel Schierbeck
+
+    def even?
+      #self % 2 == 0
+      self & 1 == 0
+    end
+
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/integer/of.rb

@@ -0,0 +1,18 @@
+class Integer
+
+  # Like #times but returns a collection of the yield results.
+  #
+  #   a = 3.of { |i| "#{i+1}" }
+  #   a => [ "1", "2", "3" ]
+  #
+
+  def of(&block)
+    Array.new(self, &block)
+  end
+
+  # Time warn aliases for #of.
+  alias_method :times_collect, :of
+  alias_method :times_map, :of
+
+end
+