facets 0.6.3

data/lib/facet/binding/eval.rb

@@ -0,0 +1,10 @@
+class Binding
+  # Evaluate a Ruby source code string (or block) in the binding context
+  def eval( str ) #='', &blk )
+    #if block_given?
+    #  Kernel.eval( self, &blk )
+    #elsif str
+      Kernel.eval( str, self )
+    #end    
+  end 
+end

data/lib/facet/binding/lineno.rb

@@ -0,0 +1,13 @@
+
+require 'facet/binding/eval'
+
+class Binding
+  # returns file name
+  def filename
+    eval( "__FILE__" )
+  end
+  # returns line number
+  def lineno
+    eval( "__LINE__" )
+  end
+end 

data/lib/facet/binding/local_variables.rb

@@ -0,0 +1,39 @@
+
+require 'facet/binding/eval'
+
+class Binding
+
+  # Returns the local variables defined in the binding context
+  #
+  #   require 'facet/binding/local_variables'
+  #
+  #   a = 2
+  #   binding.local_varibales  #=> ["a"]
+  #
+  def local_variables()
+    eval( "local_variables" )
+  end
+    
+  # Returns the value of some variable.
+  #
+  #   require 'facet/binding/local_variables'
+  #
+  #   a = 2
+  #   binding["a"]  #=> 2
+  #
+  def []( x )
+    eval( x.to_s )
+  end
+  
+  # Set the value of a local variable.
+  #
+  #   require 'facet/binding/local_variables'
+  #
+  #   binding["a"] = 4
+  #   a  #=> 4
+  #
+  def []=( l, v )
+    eval( "proc {|v| #{l} = v}").call( v )
+  end
+
+end 

data/lib/facet/binding/self.rb

@@ -0,0 +1,10 @@
+
+require 'facet/binding/eval'
+
+class Binding
+  # Returns the self in the binding context.
+  def self()
+    @self ||= eval( "self" )
+    @self
+  end 
+end

data/lib/facet/class.rb

@@ -0,0 +1,7 @@
+
+# base
+
+# common
+require "facet/class/cattr"
+
+# uncommon

data/lib/facet/class/cattr.rb

@@ -0,0 +1,82 @@
+
+class Class
+
+  # Creates a class-variable attr_reader that can
+  # be accessed both on an instance and class level.
+  #
+  #   require 'facet/class/attributes'
+  #
+  #   class MyClass
+  #     @@a = 10
+  #     cattr_reader :a
+  #   end
+  #   MyClass.a           #=> 10
+  #   mc = MyClass.new
+  #   mc.a                #=> 10
+  #
+  def cattr_reader(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        if ! defined? @@#{sym}
+          @@#{sym} = nil
+        end
+        def self.#{sym}
+          @@#{sym}
+        end
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
+    end
+  end
+
+  # Creates a class-variable attr_writer that can
+  # be accessed both on an instance and class level.
+  #
+  #   require 'facet/class/attributes'
+  #
+  #   class MyClass
+  #     cattr_writer :a
+  #     def a
+  #       @@a
+  #     end
+  #   end
+  #   MyClass.a = 10
+  #   mc = MyClass.new
+  #   mc.a                #=> 10
+  #
+  def cattr_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        if ! defined? @@#{sym}
+          @@#{sym} = nil
+        end
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+        def #{sym}=(obj)
+          self.class.#{sym}=(obj)
+        end
+      EOS
+    end
+  end
+
+  # Creates a class-variable attr_accessor that can
+  # be accessed both on an instance and class level.
+  #
+  #   require 'facet/class/attributes'
+  #
+  #   class MyClass
+  #     cattr_accessor :a
+  #   end
+  #   MyClass.a = 10
+  #   MyClass.a           #=> 10
+  #   mc = MyClass.new
+  #   mc.a                #=> 10
+  #
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+
+end

data/lib/facet/comparable.rb

@@ -0,0 +1,7 @@
+
+# base
+
+# common
+require 'facet/comparable/bound_by'
+
+# uncommon

data/lib/facet/comparable/bound_by.rb

@@ -0,0 +1,41 @@
+#--
+# Credit goes to Florian Gross.
+#++
+module Comparable
+  # Returns the value or the given upper or lower bound
+  # if the value falls outside of them.
+  #
+  #   require 'facet/comparable/bound_by'
+  #
+  #   4.bound_by(2,7)  #=> 4
+  #   9.bound_by(2,7)  #=> 7
+  #   1.bound_by(2,7)  #=> 2
+  #
+  def bound_by(lower, upper)
+    return lower if self < lower
+    return upper if self > upper
+    return self
+  end
+  
+  # Returns the lower of self or x.
+  #
+  #   require 'facet/numeric/bound_by'
+  #
+  #   4.at_least(5)  #=> 5
+  #   6.at_least(5)  #=> 6
+  #
+  def at_least(x)
+    (self >= x) ? self : x
+  end
+  
+  # Returns the greater of self or x.
+  #
+  #   require 'facet/numeric/bound_by'
+  #
+  #   4.at_most(5)  #=> 4
+  #   6.at_most(5)  #=> 5
+  #
+  def at_most(x)
+    (self <= x) ? self : x
+  end
+end 

data/lib/facet/continuation.rb

@@ -0,0 +1,8 @@
+
+# base
+
+# common
+require 'facet/continuation/create'
+
+# uncommon
+

data/lib/facet/continuation/create.rb

@@ -0,0 +1,51 @@
+class Continuation
+  # Creates a continuation in a way that is easier to use than callcc.
+  # On the initial call this will return the created Continuation and
+  # the arguments you gave to Continuation.create in an Array. If you
+  # then issue .call() on the Continuation execution will jump back to
+  # the point of time where you initially invoked Continuation.create,
+  # but this time it will return the Continuation and the arguments
+  # you supplied in an Array.
+  #
+  # You can supply a block instead of default arguments which will
+  # cause that block to be executed once and its result to be returned
+  # along side the created Continuation, but this form is confusing
+  # and does only rarely make sense.
+  #
+  #   # Count from 0 to 10
+  #   cc, counter = Continuation.create(0)
+  #   puts counter
+  #   cc.call(counter + 1) if counter < 10
+  #
+  #   # Implement something similar to Array#inject using Continuations.
+  #   # For simplicity's sake, this is not fully compatible with the real
+  #   # inject. Make sure that you understand Array#inject before you try
+  #   # to understand this.
+  #   class Array
+  #     def cc_inject(value = nil)
+  #       copy = self.clone
+  #       cc, result, item = Continuation.create(value, nil)
+  #       next_item = copy.shift
+  #       if result and item
+  #         # Aggregate the result using the block.
+  #         cc.call(yield(result, item), next_item)
+  #       elsif next_item
+  #         # item not yet set and Array is not empty:
+  #         # This means we did not get a value and thus need to use the
+  #         # first item from the Array before we can start using the
+  #         # block to aggregate the result.
+  #         cc.call(next_item, result)
+  #       end
+  #
+  #       return result
+  #    end
+  #  end
+  #  [1,2,3,4,5].cc_inject { |acc, n| acc + n } # => 15
+  #
+  def create(*args, &block)
+    args = [args] if not args.nil? and not args.is_a? Array # 1.6.8 compatibility
+    cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
+    result ||= args
+    return *[cc, *result]
+  end
+end

data/lib/facet/enumerable.rb

@@ -0,0 +1,17 @@
+
+# base
+require "facet/enumerable/collect_with_counter"
+
+# common
+require "facet/enumerable/each_slice"
+require "facet/enumerable/every"
+require "facet/enumerable/to_hash"
+require "facet/enumerable/graph"
+
+# uncommon (not required)
+#require "facet/enumerable/cross"
+#require "facet/enumerable/none?"
+#require "facet/enumerable/one?"
+#require "facet/enumerable/partition_by"
+#require "facet/enumerable/per"
+#require "facet/enumerable/**"

data/lib/facet/enumerable/**.rb

@@ -0,0 +1,13 @@
+require 'facet/enumerable/cross'
+module Enumerable
+  # Operator alias for cross-product.
+  #
+  #   require 'facet/enumerable/cross'
+  #
+  #   a = [1,2] ** [4,5]
+  #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
+  #
+  def **(enum)
+    Enumerable.cross(self, enum)
+  end
+end 

data/lib/facet/enumerable/collect_with_counter.rb

@@ -0,0 +1,25 @@
+module Enumerable
+  # Same as #collect but with an iteration counter.
+  #
+  #   require 'facet/enumerable/collect_with_counter'
+  #
+  #   a = [1,2,3].collect_with_counter{ |e,i| e*i }
+  #   a  #=> [0,2,6]
+  #
+  #--
+  # Why the term counter? There may be a change in Ruby 2.0
+  # to use this word instead of index --while index will
+  # still be used for Array, since theat is the proper meaning
+  # in that context. In the mean time, aliases are provided.
+  #++
+  def collect_with_counter
+    r = []
+    each_index do |i|
+      r << yield(self[i], i)
+    end
+    r
+  end
+  alias_method( :map_with_counter, :collect_with_counter )
+  alias_method( :collect_with_index, :collect_with_counter )
+  alias_method( :map_with_index, :collect_with_counter )
+end

data/lib/facet/enumerable/cross.rb

@@ -0,0 +1,79 @@
+#--
+# Cross product adapted from code by Michael Neuman.
+#++
+require 'generator'
+
+module Enumerable
+
+  #  Provides the cross-product of two or more Enumerables.
+  #  This is the class-level method. The instance method
+  #  calls on this.
+  #
+  #    require 'facet/enumerable/cross'
+  #
+  #    Enumerable.cross([1,2], [4], ["apple", "banana"])
+  #    #=> [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
+  #
+  #    Enumerable.cross([1,2], [3,4])
+  #    #=> [[1, 3], [1, 4], [2, 3], [2, 4]]
+  #
+  def self.cross(*enums, &block)
+    raise if enums.empty?
+    gens = enums.map{|e| Generator.new(e)}
+    return [] if gens.any? {|g| g.end?}
+    sz = gens.size
+    res = []
+    tuple = Array.new(sz)
+
+    loop do
+      # fill tuple
+      (0 ... sz).each { |i| 
+        tuple[i] = gens[i].current 
+      }
+      if block.nil?
+        res << tuple.dup
+      else
+        block.call(tuple.dup)
+      end
+
+      # step forward
+      gens[-1].next
+      (sz-1).downto(0) { |i|
+        if gens[i].end?
+          if i > 0
+            gens[i].rewind
+            gens[i-1].next
+          else
+            return res
+          end
+        end
+      }
+    end
+  end
+  
+  # The instance level cross-product method.
+  #
+  #   require 'facet/enumerable/cross'
+  #
+  #   a = []
+  #   [1,2].cross([4,5]){|elem| a << elem }
+  #   a  #=> [[1, 4],[1, 5],[2, 4],[2, 5]]
+  #  
+  def cross(*enums, &block)
+    Enumerable.cross(self, *enums, &block)
+  end
+  
+end
+
+
+=begin
+# --- dev testing ---
+
+if __FILE__ == $0
+  p Enumerable.cross([1,2], [4], ["apple", "banana"])
+
+  [1,2,3].cross([4,5,6]) {|elem| p elem }
+
+  p Enumerable.cross([1,2], [3,4])
+end
+=end

data/lib/facet/enumerable/each_slice.rb

@@ -0,0 +1,60 @@
+module Enumerable
+  # Iterate through slices. If slicing _step_ is not
+  # given, the the arity if the block is used.
+  #
+  #   require 'facet/enumerable/each_slice'
+  #
+  #   x = []
+  #   [1,2,3,4].each_slice(2){ |a,b| x << [a,b] }
+  #   x  #=> [ [1,2], [3,4] ]
+  #
+  #   x = []
+  #   [1,2,3,4,5,6].each_slice(3){ |a| x << a }
+  #   x  #=> [ [1,2,3], [4,5,6] ]
+  #
+  def each_slice(step=nil, &yld)
+    if step
+      cnt = step
+      n = length / cnt
+      n += 1 if length % cnt > 0
+      n.times { |i|
+        yld.call(*self.slice(i*cnt,cnt))
+      }
+      return cnt
+    else
+      cnt = yld.arity.abs
+      n = length / cnt
+      n += 1 if length % cnt > 0
+      n.times { |i|
+        yld.call(*self.slice(i*cnt,cnt))
+      }
+      return cnt
+    end  
+  end
+  
+  # Alias for #each_slice.
+  alias_method( :each_by, :each_slice )
+end
+
+
+class Array
+  # Iterates over +n+ elements at a time. If +n+ is
+  # not given then the arity of the block determines the 
+  # slicing quantity.
+  #
+  #   require 'facet/array/each_slice'
+  #
+  #   [1, 2, 3, 4].each_slice(2){ |a,b| ... }
+  #
+  # This is a specialized version Enumerable#each_slice
+  # but optimized specifically for Array.
+  def each_slice(n=nil, &yld)
+    n = yld.arity.abs unless n
+    i=0
+    while i < self.length
+      yld.call(*self.slice(i,n))
+      i+=n
+    end
+  end
+  alias_method( :each_by, :each_slice )
+end