facets 0.6.3

data/lib/facet/array/first&last.rb

@@ -0,0 +1,47 @@
+class Array
+  # Change the first element.
+  #
+  #   require 'facet/array/first&last='
+  #
+  #   a = ["a","y","z"]
+  #   a.first = "x"
+  #   p a           #=> ["x","y","z"]
+  #
+  def first=(x)
+    self[0] = x
+  end
+  
+  # Alias for unshift, which _pushes_
+  # an element onto the front of an array.
+  #
+  #   require 'facet/array/first&last='
+  #
+  #   a = ["a","y","z"]
+  #   a.first! "x"
+  #   p a           #=> ["x","a","y","z"]
+  #
+  alias_method( :first!, :unshift)
+  
+  # Change the last element.
+  #
+  #   require 'facet/array/first&last='
+  #
+  #   a = [1,2,5]
+  #   a.last = 3
+  #   p a           #=> [1,2,3]
+  #
+  def last=(x)
+    self[-1] = x
+  end
+  
+  # Alias for push.
+  #
+  #   require 'facet/array/first&last='
+  #
+  #   a = [1,2]
+  #   a.last! 3
+  #   p a           #=> [1,2,3]
+  #  
+  alias_method( :last!, :push)
+  
+end

data/lib/facet/array/get.rb

@@ -0,0 +1,15 @@
+class Array
+  # Fetch values given a start index and a length.
+  #
+  #   require 'facet/array/get'
+  #
+  #   [1,2,3,4].get(0,2)  #=> [1,2]
+  #   [1,2,3,4].get(2,2)  #=> [3,4]
+  #
+  def get( start, len=1 )
+    a = []
+    len.times { |i| a << self.at(start+i) }
+    a
+  end 
+end
+

data/lib/facet/array/head&tail.rb

@@ -0,0 +1,33 @@
+class Array
+  # Like #first but returns the first element
+  # in an array.
+  #
+  #   [1,2,3].head  #=> [1]
+  #
+  def head
+    slice(0,1)
+  end
+  # Returns an array from second element to last element.
+  #
+  #   [1,2,3].foot  #=> [2,3]
+  #
+  def tail
+    slice(1,length-1)
+  end
+  # Returns array of first element upto,
+  # but not including, the last element.
+  #
+  #   [1,2,3].body  #=> [1,2]
+  #
+  def body
+    slice(0,length-1)
+  end
+  # Like #last but returns the last element
+  # in an array.
+  #
+  #   [1,2,3].foot  #=> [3]
+  #
+  def foot
+    slice(-1,1)
+  end
+end 

data/lib/facet/array/last_index.rb

@@ -0,0 +1,15 @@
+class Array
+
+  # Returns the last index of the array. 
+  # Returns nil is array has no elements.
+  #
+  #   require 'facet/array/last_index'
+  #
+  #   [1,2,3,4,5].last_index  #=> 4
+  #
+  def last_index
+    return nil if self.length == 0
+    self.length - 1
+  end
+
+end

data/lib/facet/array/middle.rb

@@ -0,0 +1,18 @@
+class Array
+  # 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.
+  #
+  #   require 'facet/array/middle'
+  #
+  #   [1,2,3,4,5].middle        #=> 3
+  #   [1,2,3,4,5,6].middle      #=> 4
+  #   [1,2,3,4,5,6].middle(-1)  #=> 3
+  #
+  # 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 middle(offset=0)
+    self.at( (self.length / 2) + offset )
+  end
+end

data/lib/facet/array/pos.rb

@@ -0,0 +1,17 @@
+class Array
+  # Returns positive index of an element
+  # based on cardinal positions 1 to n and n to -1.
+  #
+  #   require 'facet/array/pos'
+  #
+  #   [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
+      self.length + i
+    end
+  end
+end

data/lib/facet/array/pull.rb

@@ -0,0 +1,21 @@
+class Array
+  # Alias for shift.
+  #
+  #   require 'facet/array/pull'
+  #
+  #   a=[1,2,3]
+  #   a.pull      #=> 1
+  #   a           #=> [2,3]
+  # 
+  alias_method( :pull, :shift )
+  
+  # Alias for unshift.
+  #
+  #   require 'facet/array/pull'
+  #
+  #   a=[1,2,3]
+  #   a.put(9)   #=> [9,1,2,3]
+  #   a          #=> [9,1,2,3]
+  # 
+  alias_method( :put, :unshift )
+end

data/lib/facet/array/range.rb

@@ -0,0 +1,22 @@
+class Array
+  # Returns the index range between two elements.
+  # If no elements are given, returns the range
+  # from first to last.
+  #
+  #   require 'facet/array/range'
+  #
+  #   ['a','b','c','d'].range            #=> 0..3
+  #   ['a','b','c','d'].range('b','d')   #=> 1..2
+  #
+  #--
+  # This could surely use a little error catching code (todo).
+  #++
+  def range(a=nil,z=nil)
+    if !a
+      0..self.length-1
+    else
+      index(a)..index(z)
+    end
+  end
+  alias_method( :index_range, :range )
+end

data/lib/facet/array/rotate.rb

@@ -0,0 +1,38 @@
+class Array 
+  # Rotates an array's elements from back to front n times.
+  #
+  #   require 'facet/array/rotate'
+  #
+  #   [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]
+  #
+  def rotate(n=1)
+    self.dup.rotate!(n)
+  end
+  
+  # Same as #rotate, but acts in place.
+  #
+  #   require 'facet/array/rotate'
+  #
+  #   a = [1,2,3]
+  #   a.rotate
+  #   a  #=> [3,1,2]
+  #
+  def rotate!(n=1)
+    n = n.to_i
+    return self if n == 0
+    if n > 1
+      n.times{ unshift(pop) }
+    else
+      n.times{ push(shift) }
+    end
+    self
+  end
+  
+end

data/lib/facet/array/select!.rb

@@ -0,0 +1,13 @@
+class Array
+  # As with #select but modifies the Array in place.
+  #
+  #   require 'facet/array/select!'
+  #
+  #   a = [1,2,3,4,5,6,7,8,9,10]
+  #   a.select!{ |e| e % 2 == 0 }
+  #   a  #=> [2,4,6,8,10]
+  #
+  def select!  # :yield:
+    reject!{ |e| not yield(e) }
+  end   
+end

data/lib/facet/array/shuffle.rb

@@ -0,0 +1,37 @@
+class Array
+
+  # Randomize the order of an array.
+  #
+  #   require 'facet/array/shuffle'
+  #
+  #   [1,2,3,4].shuffle  #=> [2,4,1,3]
+  #
+  def shuffle
+    dup.shuffle!
+    #sort_by{Kernel.rand}
+  end
+  
+  # As with #shuffle but modifies the array in place.
+  # The algorithm used here is known as a Fisher-Yates shuffle.
+  #
+  #   require 'facet/array/shuffle'
+  #
+  #   a = [1,2,3,4]
+  #   a.shuffle!
+  #   a  #=> [2,4,1,3]
+  #
+  #--
+  # Credit goes to Niel Spring.
+  #++
+  def shuffle!
+    s = size
+    each_index do |j|
+      i = Kernel.rand(s-j)
+      #self[j], self[j+i] = self[j+i], self[j]
+      tmp = self[j]
+      self[j] = self[j+i]
+      self[j+i] = tmp
+    end
+    self
+  end
+end

data/lib/facet/array/store.rb

@@ -0,0 +1,4 @@
+class Array
+  # Alias for #[]=.
+  alias_method( :store, :[]= )
+end 

data/lib/facet/array/thru.rb

@@ -0,0 +1,18 @@
+class Array
+  # Fetch values from a start index thru an end index.
+  #
+  #   require 'facet/array/upto'
+  #
+  #   [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 << self.at(i)
+      i += 1
+    end
+    a
+  end
+end

data/lib/facet/array/to_b.rb

@@ -0,0 +1,6 @@
+class Array
+  # Boolean conversion for not empty?
+  def to_b
+    ! self.empty?
+  end
+end

data/lib/facet/array/to_h.rb

@@ -0,0 +1,30 @@
+class Array
+  
+  # Produces a hash for an Array, or two arrays.
+  #
+  # If no parameter is given, to_h expects
+  # the receiving array to be associative.
+  #
+  #   require 'facet/array/to_h'
+  #
+  #   a1 = [ [:a,1], [:b,2] ]
+  #   a1.to_h  #=> { :a=>1, :b=>2 }
+  #
+  # If an array is given it is considered values
+  # and zipped with the receiver, to produce the hash.
+  #
+  #   a1 = [ :a, :b ]
+  #   a2 = [ 1, 2 ]
+  #   a1.to_h(a2)  #=> { :a=>1, :b=>2 }
+  #
+  def to_h(values=nil)
+    h = {}
+    if values
+      keys.size.times{ |i| h[at(i)] = values.at(i) }
+    else
+      each{ |e| h[e.first] = e.slice(1..-1) }
+    end
+    return h
+  end
+
+end

data/lib/facet/binding.rb

@@ -0,0 +1,15 @@
+
+# base
+require "facet/binding/eval"
+require "facet/binding/self"
+require "facet/binding/caller"
+
+# commmon
+require "facet/binding/defined?"
+require "facet/binding/called"
+
+# uncommon
+#require "facet/binding/class"
+#require "facet/binding/local_variables"
+#require "facet/binding/lineno"
+#require "facet/binding/delegate!"

data/lib/facet/binding/called.rb

@@ -0,0 +1,29 @@
+
+require 'facet/binding/caller'
+
+class Binding
+  # Retreive the current running method.
+  #
+  #   require 'facet/binding/called'
+  #
+  #   def tester; p called; end
+  #   tester  #=> :tester
+  #
+  def called
+    name = /\`([^\']+)\'/.match(caller(1).first)[1]
+    return name.to_sym
+  end
+  # There is a lot of debate on what the hell to call this.
+  # +method_name+ differs for called only by the fact that it
+  # returns a string, rather then a symbol.
+  #
+  #   require 'facet/binding/called'
+  #
+  #   def tester; p method_name; end
+  #   tester  #=> "tester"
+  #
+  def method_name
+    name = /\`([^\']+)\'/.match(caller(1).first)[1]
+    return name
+  end
+end

data/lib/facet/binding/caller.rb

@@ -0,0 +1,10 @@
+
+require 'facet/binding/eval'
+
+class Binding
+  # Returns the call stack, same format as Kernel##caller()
+  def caller( skip = 0 )
+    eval( "caller( #{skip} )" )
+  end
+end
+

data/lib/facet/binding/defined?.rb

@@ -0,0 +1,9 @@
+
+require 'facet/binding/eval'
+
+class Binding
+  # Returns the nature of something, nil if that thing is not defined.
+  def defined?( x )
+    eval( "defined? #{x}" )
+  end
+end 

data/lib/facet/binding/delegate!.rb

@@ -0,0 +1,19 @@
+
+class Binding
+  # All missing methods delegate to binding's eval(self).
+  #--
+  # This is an expiremental idea.
+  #++
+  def delegate!
+    (class << self; self; end).class_eval {
+      #alias_method( :method_missing_without_delegate, :method_missing )
+      def method_missing(sym, *args, &blk)
+        if send(:self).respond_to?(sym)
+          send(:self).send(sym, *args, &blk)
+        else
+          super
+        end
+      end
+    }
+  end 
+end