facets 2.4.4 → 2.4.5

data/lib/core/facets/file/write.rb

@@ -1,31 +1,9 @@
-class File
-
-  # Append to a file.
-  #
-  #   CREDIT: George Moschovitis
-
-  def self.append( file, str )
-    File.open( file, 'ab' ) { |f|
-      f << str
-    }
-  end
+# DEPRECATE
+require 'facets/file/create'
+require 'facets/file/append'
+require 'facets/file/writelines'
 
-  # Creates a new file, or overwrites an existing file,
-  # and writes a string into it. Can also take a block
-  # just like File#open, which is yielded _after_ the
-  # string is writ.
-  #
-  #   str = 'The content for the file'
-  #   File.create('myfile.txt', str)
-  #
-  #   CREDIT: George Moschovitis
-
-  def self.create(path, str='', &blk)
-    File.open(path, 'wb') do |f|
-      f << str
-      blk.call(f) if blk
-    end
-  end
+class File
 
   # Writes the given data to the given path and closes the file.  This is
   # done in binary mode, complementing <tt>IO.read</tt> in standard Ruby.
@@ -40,25 +18,5 @@ class File
     end
   end
 
-  # Writes the given array of data to the given path and closes the file.
-  # This is done in binary mode, complementing <tt>IO.readlines</tt> in
-  # standard Ruby.
-  #
-  # Note that +readlines+ (the standard Ruby method) returns an array of lines
-  # <em>with newlines intact</em>, whereas +writelines+ uses +puts+, and so
-  # appends newlines if necessary.  In this small way, +readlines+ and
-  # +writelines+ are not exact opposites.
-  #
-  # Returns +nil+.
-  #
-  #   CREDIT: Noah Gibbs
-  #   CREDIT: Gavin Sinclair
-
-  def self.writelines(path, data)
-    File.open(path, "wb") do |file|
-      file.puts(data)
-    end
-  end
-
 end
 

data/lib/core/facets/file/writelines.rb

@@ -0,0 +1,24 @@
+class File
+
+  # Writes the given array of data to the given path and closes the file.
+  # This is done in binary mode, complementing <tt>IO.readlines</tt> in
+  # standard Ruby.
+  #
+  # Note that +readlines+ (the standard Ruby method) returns an array of lines
+  # <em>with newlines intact</em>, whereas +writelines+ uses +puts+, and so
+  # appends newlines if necessary.  In this small way, +readlines+ and
+  # +writelines+ are not exact opposites.
+  #
+  # Returns +nil+.
+  #
+  #   CREDIT: Noah Gibbs
+  #   CREDIT: Gavin Sinclair
+
+  def self.writelines(path, data)
+    File.open(path, "wb") do |file|
+      file.puts(data)
+    end
+  end
+
+end
+

data/lib/core/facets/hash/op.rb

@@ -1,85 +1,7 @@
-class Hash
-
-  # Hash intersection. Two hashes intersect
-  # when their pairs are equal.
-  #
-  #   {:a=>1,:b=>2} & {:a=>1,:c=>3}  #=> {:a=>1}
-  #
-  # A hash can also be intersected with an array
-  # to intersect keys only.
-  #
-  #   {:a=>1,:b=>2} & [:a,:c]  #=> {:a=>1}
-  #
-  # The later form is similar to #pairs_at. The differ only
-  # in that #pairs_at will return a nil value for a key
-  # not in the hash, but #& will not.
-  #
-  #   CREDIT: Trans
-
-  def &(other)
-    case other
-    when Array
-      k = (keys & other)
-      Hash[*(k.zip(values_at(*k)).flatten)]
-    else
-      x = (to_a & other.to_a).inject([]) do |a, kv|
-        a.concat kv; a
-      end
-      Hash[*x]
-    end
-  end
-
-  # Operator for #reverse_merge.
-  #
-  #   CREDIT: Trans
-
-  def |(other)
-    other.merge(self)
-  end
-
-  # Operator for #merge.
-  #
-  #   CREDIT: Trans
-
-  def +(other)
-    merge(other)
-  end
-
-  # Operator for remove hash paris. If another hash is given
-  # the pairs are only removed if both key and value are equal.
-  # If an array is given then matching keys are removed.
-  #
-  #   CREDIT: Trans
-
-  def -(other)
-    h = self.dup
-    if other.respond_to?(:to_ary)
-      other.to_ary.each do |k|
-        h.delete(k)
-      end
-    else
-      other.each do |k,v|
-        if h.key?(k)
-          h.delete(k) if v == h[k]
-        end
-      end
-    end
-    h
-  end
-
-  # Like merge operator '+' but merges in reverse order.
-  #
-  #   h1 = { :a=>1 }
-  #   h2 = { :a=>2, :b=>3 }
-  #
-  #   h1 + h2  #=> { :a=>2, :b=>3 }
-  #   h1 * h2  #=> { :a=>1, :b=>3 }
-  #
-  #   CREDIT: Trans
-
-  def *(other)
-    other.merge(self)
-  end
-
-end
+require 'facets/hash/op_and'
+require 'facets/hash/op_or'
+require 'facets/hash/op_add'
+require 'facets/hash/op_sub'
+require 'facets/hash/op_mul'
+require 'facets/hash/op_push'
 

data/lib/core/facets/hash/op_add.rb

@@ -0,0 +1,12 @@
+class Hash
+
+  # Operator for #merge.
+  #
+  #   CREDIT: Trans
+
+  def +(other)
+    merge(other)
+  end
+
+end
+

data/lib/core/facets/hash/op_and.rb

@@ -0,0 +1,33 @@
+class Hash
+
+  # Hash intersection. Two hashes intersect
+  # when their pairs are equal.
+  #
+  #   {:a=>1,:b=>2} & {:a=>1,:c=>3}  #=> {:a=>1}
+  #
+  # A hash can also be intersected with an array
+  # to intersect keys only.
+  #
+  #   {:a=>1,:b=>2} & [:a,:c]  #=> {:a=>1}
+  #
+  # The later form is similar to #pairs_at. The differ only
+  # in that #pairs_at will return a nil value for a key
+  # not in the hash, but #& will not.
+  #
+  #   CREDIT: Trans
+
+  def &(other)
+    case other
+    when Array
+      k = (keys & other)
+      Hash[*(k.zip(values_at(*k)).flatten)]
+    else
+      x = (to_a & other.to_a).inject([]) do |a, kv|
+        a.concat kv; a
+      end
+      Hash[*x]
+    end
+  end
+
+end
+

data/lib/core/facets/hash/op_mul.rb

@@ -0,0 +1,18 @@
+class Hash
+
+  # Like merge operator '+' but merges in reverse order.
+  #
+  #   h1 = { :a=>1 }
+  #   h2 = { :a=>2, :b=>3 }
+  #
+  #   h1 + h2  #=> { :a=>2, :b=>3 }
+  #   h1 * h2  #=> { :a=>1, :b=>3 }
+  #
+  #   CREDIT: Trans
+
+  def *(other)
+    other.merge(self)
+  end
+
+end
+

data/lib/core/facets/hash/op_or.rb

@@ -0,0 +1,12 @@
+class Hash
+
+  # Operator for #reverse_merge.
+  #
+  #   CREDIT: Trans
+
+  def |(other)
+    other.merge(self)
+  end
+
+end
+

data/lib/core/facets/hash/op_sub.rb

@@ -0,0 +1,26 @@
+class Hash
+
+  # Operator for remove hash paris. If another hash is given
+  # the pairs are only removed if both key and value are equal.
+  # If an array is given then matching keys are removed.
+  #
+  #   CREDIT: Trans
+
+  def -(other)
+    h = self.dup
+    if other.respond_to?(:to_ary)
+      other.to_ary.each do |k|
+        h.delete(k)
+      end
+    else
+      other.each do |k,v|
+        if h.key?(k)
+          h.delete(k) if v == h[k]
+        end
+      end
+    end
+    h
+  end
+
+end
+

data/lib/core/facets/indexable.rb

@@ -7,7 +7,7 @@
 # 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
+# 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.
@@ -37,7 +37,7 @@ module Indexable
   # in a new array.
   #
   #   [1,2,3].head  #=> [1]
-
+  #
   def head
     slice(0,1)
   end
@@ -45,7 +45,7 @@ module Indexable
   # Returns an array from second element to last element.
   #
   #   [1,2,3].tail  #=> [2,3]
-
+  #
   def tail
     slice(1,length-1)
   end
@@ -54,7 +54,7 @@ module Indexable
   # in an array.
   #
   #   [1,2,3].foot  #=> [3]
-
+  #
   def foot
     slice(-1,1)
   end
@@ -67,7 +67,7 @@ module Indexable
   #--
   # Better name for this? (bulk, perhaps?)
   #++
-
+  #
   def body
     slice(0,size-1)
   end
@@ -85,7 +85,7 @@ module Indexable
   # 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
@@ -98,7 +98,7 @@ module Indexable
   #   [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 )
@@ -112,7 +112,7 @@ module Indexable
   #
   #   [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
@@ -126,7 +126,7 @@ module Indexable
   # Returns first _n_ elements.
   #
   #   "Hello World".first(3)  #=> "Hel"
-
+  #
   def first(n=1)
     slice(0, n.to_i)
   end
@@ -134,7 +134,7 @@ module Indexable
   # Returns last _n_ elements.
   #
   #   "Hello World".last(3)  #=> "rld"
-
+  #
   def last(n=1)
     n = n.to_i
     return self if n > size
@@ -146,7 +146,7 @@ module Indexable
   #   a = ["a","y","z"]
   #   a.first = "x"
   #   p a           #=> ["x","y","z"]
-
+  #
   def first=(x)
     splice(0,x)
   end
@@ -166,7 +166,7 @@ module Indexable
   #   a = [1,2,3]
   #   a.first!      #=> 1
   #   a             #=> [2,3]
-
+  #
   def first!
     splice(0)
   end
@@ -176,7 +176,7 @@ module Indexable
   #   a = [1,2,3]
   #   a.last!       #=> 3
   #   a             #=> [1,2]
-
+  #
   def last!
     splice(-1)
   end
@@ -188,7 +188,7 @@ module Indexable
   #   [1,2,3,4,5].ends  #=> 4
   #
   # This nearly equivalent to +size - 1+.
-
+  #
   def ends
     return nil if size == 0
     size - 1
@@ -199,7 +199,7 @@ module Indexable
   #
   #   [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
@@ -208,20 +208,28 @@ module Indexable
     end
   end
 
-  # Returns the index of the first element to satisfy the block
-  # condition. This is simply #index with a block.
+  # Returns the index of the first element equal to the
+  # given object or satisfying the block condition.
   #
-  #   [1,2,3,4].index_of { |e| e == 3 }  #=> 2
-  #   [1,2,3,4].index_of { |e| e > 3 }   #=> 3
+  #   [1,2,3,4].index{ |e| e == 3 }  #=> 2
+  #   [1,2,3,4].index{ |e| e > 3 }   #=> 3
   #
-  # TODO: Remove Array#index_of when Ruby 1.9 adds block to #index.
-
-  def index_of(obj=nil,&blk)
-    return index(obj) unless block_given?
-    i=0; i+=1 until yield(self[i])
-    return i
+  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.
@@ -230,7 +238,7 @@ module Indexable
   #
   #   ['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)