mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/core/facets/module/rename_method.rb

@@ -0,0 +1,20 @@
+class Module
+
+  private
+
+  # Aliases a method and undefines the original.
+  #
+  #   rename_method( :to_method, :from_method  )
+  #
+  #  CREDIT: Trans
+
+  def rename_method( to_sym, from_sym )
+    raise ArgumentError, "method #{from_sym} does not exist" unless method_defined?( from_sym )
+    alias_method( to_sym, from_sym )
+    undef_method( from_sym )
+  end
+
+  alias_method :rename,   :rename_method
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/revise.rb

@@ -0,0 +1,62 @@
+require 'facets/module/redirect_method'
+require 'facets/module/redefine_method'
+require 'facets/module/rename_method'
+require 'facets/module/wrap_method'
+
+class Module
+
+  # Return a new module based on another.
+  # This includes the original module into the new one.
+  #
+  #  CREDIT: Trans
+
+  def revise(&blk)
+    base = self
+    nm = Module.new{ include base }
+    nm.class_eval(&blk)
+    nm
+  end
+
+  alias_method :revisal, :revise
+
+  # Using integrate is just like using include except the
+  # module included is a reconstruction of the one given
+  # altered by the commands given in the block.
+  #
+  # Convenient commands available are: #rename, #redef,
+  # #remove, #nodef and #wrap. But any module method
+  # can be used.
+  #
+  #   module W
+  #     def q ; "q" ; end
+  #     def y ; "y" ; end
+  #   end
+  #
+  #   class X
+  #     integrate W do
+  #       nodef :y
+  #     end
+  #   end
+  #
+  #   x = X.new
+  #   x.q  #=> "q"
+  #   x.y  #=> missing method error
+  #
+  # This is like #revisal, but #revisal only
+  # returns the reconstructred module. It does not
+  # include it.
+  #
+  #  CREDIT: Trans
+
+  def integrate(mod, &block)
+    #include mod.revisal( &blk )
+    m = Module.new{ include mod }
+    m.class_eval(&block)
+    include m
+  end
+
+  alias_method :remove, :remove_method
+  alias_method :nodef,  :undef_method
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/spacename.rb

@@ -0,0 +1,25 @@
+class Module
+
+  # Returns the name of module's container module.
+  #
+  #   module Example
+  #     class Demo
+  #     end
+  #   end
+  #
+  #   Demo.name         #=> "Example::Demo"
+  #   Demo.spacename    #=> "Example"
+  #
+  # This used to be called +dirname+.
+  #
+  # See also Module#basename.
+  #
+  #  CREDIT: Trans
+
+  def spacename
+    name[0...(name.rindex('::') || 0)]
+    #name.gsub(/::[^:]*$/, '')
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/wrap_method.rb

@@ -0,0 +1,28 @@
+class Module
+
+  #private  # (we'll leave this one public for AOP-like uses).
+
+  # Creates a new method wrapping the previous of
+  # the same name. Reference to the old method
+  # is passed into the new definition block
+  # as the first parameter.
+  #
+  #   wrap_method( sym ) { |old_meth, *args|
+  #     old_meth.call
+  #     ...
+  #   }
+  #
+  # Keep in mind that this can not be used to wrap methods
+  # that take a block.
+  #
+  #   CREDIT: Trans
+
+  def wrap_method( sym, &blk )
+    old = instance_method(sym)
+    define_method(sym) { |*args| blk.call(old.bind(self), *args) }
+  end
+
+  alias_method :wrap, :wrap_method
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/nilclass.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/nilclass/ergo.rb

@@ -0,0 +1 @@
+require 'facets/kernel/ergo'

data/lib/gems/facets-2.4.5/lib/core/facets/nilclass/to_f.rb

@@ -0,0 +1,17 @@
+class NilClass
+
+  unless defined? to_f
+
+    # Allows <tt>nil</tt> to respond to #to_f.
+    # Always returns <tt>0</tt>.
+    #
+    #   nil.to_f   #=> 0.0
+    #
+    #   CREDIT: Matz
+
+    def to_f; 0.0; end
+
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/numeric.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/numeric/approx.rb

@@ -0,0 +1,15 @@
+class Numeric
+
+  # Determines if another number is approximately equal
+  # within a given _n_th degree. Defaults to 100ths
+  # if the degree is not specified.
+  #
+  #  CREDIT: Trans
+
+  def approx?(x, n=0.01)
+    return(self == x) if n == 0
+    (self - x).abs <= n
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/numeric/distance.rb

@@ -0,0 +1,14 @@
+class Numeric
+
+  # Returns the distance between self an another value.
+  # This is the same as #- but it provides an alternative
+  # for common naming between variant classes.
+  #
+  #   4.distance(3)  #=> 1
+
+  def distance(other)
+    self - other
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/numeric/round.rb

@@ -0,0 +1,72 @@
+class Numeric
+
+  # Conceptually, rounding is expected to apply to floating point numbers.
+  # However it can actually be applied to pretty much and Numeric object.
+  # For example, one could round an Integer to the nearest kilo. So the
+  # actual round.rb lib is in the numeric folder, but we'll add this 
+  # here for convenience.
+  #
+  # See Float#round_at.
+
+  def round_at(*args)
+    to_f.round_at(*args)
+  end
+
+  # See Float#round_to.
+
+  def round_to(*args)
+    to_f.round_to(*args)
+  end
+
+end
+
+class Integer
+
+  # See Float#round_at.
+
+  def round_at(*args)
+    to_f.round_at(*args)
+  end
+
+  # See Float#round_to.
+
+  def round_to(*args)
+    to_f.round_to(*args)
+  end
+
+end
+
+class Float
+
+  # Float#round_off is simply an alias for Float#round.
+  #alias_method :round_off, :round
+
+  # Rounds to the given decimal position.
+  #
+  #   4.555.round_at(0)  #=> 5.0
+  #   4.555.round_at(1)  #=> 4.6
+  #   4.555.round_at(2)  #=> 4.56
+  #   4.555.round_at(3)  #=> 4.555
+  #
+  #   CREDIT: Trans
+
+  def round_at( d ) #d=0
+    (self * (10.0 ** d)).round.to_f / (10.0 ** d)
+  end
+
+  # Rounds to the nearest _n_th degree.
+  #
+  #   4.555.round_to(1)     #=> 5.0
+  #   4.555.round_to(0.1)   #=> 4.6
+  #   4.555.round_to(0.01)  #=> 4.56
+  #   4.555.round_to(0)     #=> 4.555
+  #
+  #   CREDIT: Trans
+
+  def round_to( n ) #n=1
+    return self if n == 0
+    (self * (1.0 / n)).round.to_f / (1.0 / n)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/proc.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/proc/bind.rb

@@ -0,0 +1,22 @@
+class Proc
+
+  # Bind a Proc to an object returning a Method.
+  #
+  # NOTE: This version comes from Rails. The old Facets
+  #       version used thread.rb, but I no longer think
+  #       the implementaiton is thread critical. Please
+  #       make a bug report if this proves wrong.
+
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self; end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/proc/compose.rb

@@ -0,0 +1,42 @@
+class Proc
+
+  # Returns a new proc that is the functional
+  # composition of two procs, in order.
+  #
+  #   a = lambda { |x| x + 4 }
+  #   b = lambda { |y| y / 2 }
+  #
+  #   a.compose(b).call(4)  #=> 6
+  #   b.compose(a).call(4)  #=> 4
+  #
+  #   CREDIT: Dave
+
+  def compose(g)
+    raise ArgumentError, "arity count mismatch" unless arity == g.arity
+    lambda{ |*a| self[ *g[*a] ] }
+  end
+
+  # Operator for Proc#compose and Integer#times_collect/of.
+  #
+  #   a = lambda { |x| x + 4 }
+  #   b = lambda { |y| y / 2 }
+  #
+  #   (a * b).call(4)  #=> 6
+  #   (b * a).call(4)  #=> 4
+  #
+  #   CREDIT: Dave
+
+  def *(x)
+    if Integer===x
+      # collect times
+      c = []
+      x.times{|i| c << call(i)}
+      c
+    else
+      # compose procs
+      lambda{|*a| self[x[*a]]}
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/proc/curry.rb

@@ -0,0 +1,31 @@
+class Proc
+
+  # Curry Proc object into new Proc object.
+  #
+  # TODO: Utilize Ruby 1.9's #curry method.
+
+  def curry(*args)
+    if args.empty?
+      idx = (0...arity).to_a
+    else
+      raise ArgumentError, "argument count is greater than arity (#{args.size} > #{arity})" if args.size > arity
+      raise ArgumentError, "arguments must be unique indexes" if args.uniq != args
+      raise ArgumentError, "arguments must be indexes" if args.any?{ |a| !Fixnum===a }
+      idx = (0...arity).to_a
+      idx = args + (idx - args)  
+    end
+
+    rec = ''
+    idx.each do |i|
+      rec << "proc { |a#{i}| "
+    end
+    rec << "self["
+    rec << (0...arity).to_a.collect{|i| "a#{i}"}.join(',')
+    rec << "]"
+    rec << "}" * arity
+
+    instance_eval rec
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/proc/to_method.rb

@@ -0,0 +1,33 @@
+require 'facets/proc/bind'
+
+class Proc
+
+  # Convert Proc to method.
+  #
+  #   plusproc = lambda { |x| x + 1 }
+  #   plusproc.to_method(self, 'foo')
+  #   X.new.foo(1)  #=> 2
+
+  def to_method(object, name=nil)
+    #object = object || eval("self", self)
+    block, time = self, Time.now
+    method_name = name || "__bind_#{time.to_i}_#{time.usec}"
+    begin
+      (class << object; self; end).class_eval do
+        define_method(method_name, &block)
+        method = instance_method(method_name)
+        remove_method(method_name) unless name
+        method
+      end.bind(object)
+    rescue TypeError
+      object.class.class_eval do
+        define_method(method_name, &block)
+        method = instance_method(method_name)
+        remove_method(method_name) unless name
+        method
+      end.bind(object)
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/proc/update.rb

@@ -0,0 +1,9 @@
+class Proc
+
+  # Use a Proc as an observable.
+  #
+  #  CREDIT: Tim Pease
+
+  alias_method :update, :call
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/range.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/range/combine.rb

@@ -0,0 +1,47 @@
+class Range
+
+  # Combine ranges.
+  #
+  #   (1..2).combine(2..4)   #=> [1..4]
+  #   (1..2).combine(3..4)   #=> [1..2, 3..4]
+  #
+  #   TODO: Incorporate end-sentinal inclusion vs. exclusion.
+  #
+  #   CREDIT: Trans
+
+  def combine(*intervals)
+    Range.combine(self, *intervals)
+  end
+
+  # Combine intervals.
+  #
+  #   Range.combine(1..2, 2..4)   #=> [1..4]
+  #   Range.combine(1..2, 3..4)   #=> [1..2, 3..4]
+  #
+  #   CREDIT: Trans
+
+  def self.combine(*intervals)
+    intype = intervals.first.class
+    result = []
+
+    intervals = intervals.collect do |i|
+      [i.first, i.last]
+    end
+
+    intervals.sort.each do |(from, to)|  #inject([]) do |result,
+      if result.empty? or from > result.last[1]
+        result << [from, to]
+      elsif to > result.last[1]
+        result.last[1] = to
+      end
+      #result
+    end
+
+    if intype <= Range
+      result.collect{ |i| ((i.first)..(i.last)) }
+    else
+      result
+    end
+  end
+
+end