facets 2.9.3 → 3.0.0

data/lib/core/facets/numeric/round_at.rb

@@ -1 +0,0 @@
-require 'facets/numeric/round'

data/lib/core/facets/object/replace.rb

@@ -1,43 +0,0 @@
-class Object
-
-  # Replace state of object with the state of another object of the
-  # same class (or superclass).
-  #
-  #   class ReplaceExample
-  #     attr_reader :a, :b
-  #     def initialize(a,b)
-  #       @a, @b = a, b
-  #     end
-  #   end
-  #
-  #   obj1 = ReplaceExample.new(1,2)
-  #   obj1.a  #=> 1
-  #   obj1.b  #=> 2
-  #
-  #   obj2 = ReplaceExample.new(3,4)
-  #   obj2.a  #=> 3
-  #   obj2.b  #=> 4
-  #
-  #   obj1.replace(obj2)
-  #   obj1.a  #=> 3
-  #   obj1.b  #=> 4
-  #
-  # This is very similar to <code>instance.update</code>, but it is limited
-  # by the class of objects, in the same manner as Array#replace.
-  def replace(source)
-    raise ArgumentError, "not a #{self.class} -- #{source}" unless source.is_a?(self.class)
-    instance_variables.each do |iv|
-      instance_variable_set(iv, source.instance_variable_get(iv))
-    end
-  end
-
-end
-
-class Struct
-
-  # Struct#replace can take any +source+ that responds to #each_pair.
-  def replace(source)
-    source.each_pair{ |k,v| send(k.to_s + "=", v) }
-  end
-
-end

data/lib/core/facets/objectspace/reflect.rb

@@ -1,62 +0,0 @@
-require 'facets/functor'
-
-module ObjectSpace
-
-  # Reflection ensures that information about an object
-  # is actual according to Ruby's Kernel definitions, just
-  # in case such methods have been overridden.
-  #
-  #  ObjectSpace.reflect("object").object_id
-  #
-  # There is also a global short-cut for this method to ease
-  # meta-programming with it.
-  #
-  #   $ref["object"].class
-  #
-  # Typically theis method will be used to gather the object's
-  # id, as in the example given, or it's class, but any Kernel
-  # method can be used.
-  #
-  # Care should be taken in utilizing this technique. In most
-  # cases it is not needed, but in certain cases is useful
-  # for improving the robustness of meta-programming solutions.
-  #
-  # Note that this is also equivalent to using +as(Kernel)+ ...
-  #
-  #   "object".as(Kernel).object_id
-  #
-  # But obviously, in this case there is the risk that #as has
-  # be overridden too.
-  #
-  def self.reflect(obj)
-    ## TODO: use this after 1.8.6 support discontinued
-    ## Functor.new do |op, *a, &b|
-    ##   Kernel.instance_method(op).bind(obj).call(*a, &b)
-    ## end
-    Reflector.new(obj)
-  end
-
-  #
-  class Reflector #:nodoc:
-    instance_methods(true).each{ |m| private m unless /^(__|object_id$)/ =~ m.to_s }
-
-    def initialize(obj)
-      @obj = obj
-    end
-
-    def method_missing(op, *args, &yld)
-      Kernel.instance_method(op).bind(@obj).call(*args, &yld)
-    end
-  end
-
-end
-
-# Shorcut for +ObjectSpace.reflect+.
-$ref = lambda do |obj|
-  ## TODO: use this after 1.8.6 support discontinued
-  ## Functor.new do |meth, *a, &b|
-  ##  Kernel.instance_method(meth).bind(obj).call(*a, &b)
-  ## end
-  ObjectSpace.reflect(obj)
-end
-

data/lib/core/facets/proc/curry.rb

@@ -1,32 +0,0 @@
-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 prok.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
-
-    pro = self
-    rec = ''
-    idx.each do |i|
-      rec << "proc { |a#{i}| "
-    end
-    rec << "pro["
-    rec << (0...arity).to_a.collect{|i| "a#{i}"}.join(',')
-    rec << "]"
-    rec << "}" * arity
-
-    instance_eval rec
-  end
-
-end
-

data/lib/core/facets/string/bytes.rb

@@ -1,21 +0,0 @@
-class String
-
-  unless method_defined?(:bytes) # 1.8.7+
-
-    # Upacks string into bytes.
-    #
-    # Note, this is not 100% compatible with 1.8.7+
-    # which returns an enumerator instead of an array.
-    #
-    def bytes(&blk)
-      if block_given?
-        self.unpack('C*').each(&blk)
-      else
-        self.unpack('C*')
-      end
-    end
-
-  end
-
-end
-

data/lib/core/facets/string/each_char.rb

@@ -1,31 +0,0 @@
-class String
-
-  unless method_defined?(:each_char) # 1.9
-
-    require 'strscan'
-
-    # Yields a single-character string for each character in the string.
-    # When $KCODE = 'UTF8', multi-byte characters are yielded appropriately.
-    #
-    #   a = ''
-    #   "HELLO".each_char{ |c| a << "#{c.downcase}" }
-    #   a  #=> 'hello'
-    #
-    def each_char # :yield:
-      scanner, char = StringScanner.new(self), /./mu
-      loop{ yield(scanner.scan(char) || break) }
-    end
-
-    #--
-    # Iterates through each character. This is a little faster than
-    # using #chars b/c it does not create the intermediate array...
-    #
-    #   def each_char  # :yield:
-    #     size.times{ |i| yield(self[i,1]) }
-    #   end
-    #++
-
-  end
-
-end
-

data/lib/core/facets/string/end_with.rb

@@ -1 +0,0 @@
-require 'facets/string/start_with'

data/lib/core/facets/string/lines.rb

@@ -1,19 +0,0 @@
-class String
-
-  unless method_defined?(:lines)  # 1.8.7+
-
-    # Returns an array of characters.
-    #
-    #   "abc\n123".lines.to_a  #=> ["abc\n","123"]
-    #
-    def lines(&blk)
-      if block_given?
-        each_line(&blk) #scan(/$.*?\n/).each(&blk)
-      else
-        Enumerator.new(self, :lines) #.split(/\n/)
-      end
-    end
-
-  end
-
-end

data/lib/core/facets/string/random_binary.rb

@@ -1,10 +0,0 @@
-class String
-
-  # Generate a random binary string of +n_bytes+ size.
-  #
-  # CREDIT: Guido De Rosa
-  def self.random_binary(n_bytes)
-    ( Array.new(n_bytes){ rand(0x100) } ).pack('c*') 
-  end
-
-end

data/lib/core/facets/string/start_with.rb

@@ -1,60 +0,0 @@
-#--
-# = Developer's Notes
-#
-# Old definition of start_with? written by Lucas Carlson
-# and Blaine Cook was ...
-#
-#   index(prefix) == 0
-# 
-# I like the simplicity of this definition, but I could not
-# find a way define #end_with? in similar terms and still
-# accept regular expressions for the suffix. So I had to use
-# Regexp match. On th upside, we can get MatchData
-# which might be more useful.
-#++
-
-class String
-
-  #unless method_defined?(:start_with?) # 1.8.7+
-
-    # Does a string start with the given prefix?
-    #
-    #   "hello".start_with?("he")    #=> true
-    #   "hello".start_with?("to")    #=> false
-    #
-    # Note: This definition is better than standard Ruby's
-    # becuase it handles regular expressions.
-    #
-    # CREDIT: Juris Galang
-
-    def start_with?(prefix)
-      prefix = Regexp.escape(prefix.to_s) unless Regexp===prefix
-      /^#{prefix}/.match(self) ? true : false
-    end
-
-  #end
-
-  #unless method_defined?(:end_with?) # 1.8.7+
-
-    # Does a string end with the given suffix?
-    #
-    #   "hello".end_with?("lo")    #=> true
-    #   "hello".end_with?("to")    #=> false
-    #
-    # Note: This definition is better than standard Ruby's
-    # becuase it handles regular expressions.
-    #
-    # CREDIT: Juris Galang
-
-    def end_with?(suffix)
-      suffix = Regexp.escape(suffix.to_s) unless Regexp===suffix
-      /#{suffix}$/.match(self) ? true : false
-    end
-
-  #end
-
-  alias_method :starts_with?, :start_with?
-  alias_method :ends_with?  , :end_with?
-
-end
-

data/lib/core/facets/symbol/to_proc.rb

@@ -1,33 +0,0 @@
-class Symbol
-
-  unless method_defined?(:to_proc)  # 1.8.7+
-
-    # Turn a symbol into a proc calling the method to which it refers.
-    #
-    #   up = :upcase.to_proc
-    #   up.call("hello")  #=> 'HELLO'
-    #
-    # More useful is the fact that this allows <tt>&</tt>
-    # to be used to coerce Symbol into Proc.
-    #
-    #   %w{foo bar qux}.map(&:upcase)   #=> ["FOO","BAR","QUX"]
-    #   [1, 2, 3].inject(&:+)           #=> 6
-    #
-    # TODO: This will be deprecated as of Ruby 1.9, since it will become standard Ruby.
-    #
-    # CREDIT: Florian Gross (orignal), Nobuhiro Imai (current)
-
-    def to_proc
-      Proc.new{|*args| args.shift.__send__(self, *args)}
-    end
-
-    # Old Definition...
-    #
-    #   def to_proc
-    #     proc { |obj, *args| obj.send(self, *args) }
-    #   end
-    #
-  end
-
-end
-

data/lib/core/facets/to_hash.rb

@@ -1,336 +0,0 @@
-require 'facets/enumerator'
-require 'facets/hash/dearray_values'
-
-class Array
-
-  # Converts an array into a hash. Converting an array
-  # into a hash is not a one-to-one conversion, for this
-  # reason #to_h examines at the array being converted
-  # and then dispatches the conversion to the most sutiable
-  # specialized function. There are three possiblities for this.
-  #
-  # If the array is a collection of perfect pairs, like that
-  # which Hash#to_a generates, then conversion is handled by 
-  # #to_h_flat.
-  #
-  #   a = [ [:a,1], [:b,2] ]
-  #   a.to_h  #=> { :a=>1, :b=>2 }
-  #
-  # If the array contains only arrays, but are not perfect pairs,
-  # then #to_h_multi is called.
-  #
-  #   a = [ [:a,1,2], [:b,2], [:c], [:d] ]
-  #   a.to_h  #=> { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-  #
-  # If the array contians objects other then arrays then
-  # the #to_h_splat method is called.
-  #
-  #   a = [ [:a,1,2], 2, :b, [:c,3], 9 ]
-  #   a.to_h  #=> { [:a,1,2]=>2, :b=>[:c,3], 9=>nil } 
-  #
-  # Finally, a particular dispatch can be forced by 
-  # specifying the +mode+ of conversion, eg. +:multi+,
-  # +:splat+, +:flat+, +:assoc+, etc.
-  #
-  # Setting +mode+ to +true+ is the same as setting it +:multi+.
-  # This has been left in for backward compatability.
-  #
-  # NOTE: The use of a +values+ parameter has been deprecated
-  # because that functionality is as simple as ...
-  #
-  #   array1.zip(array2).to_h
-  #
-  # CREDIT: Robert Klemme, Trans
-  #
-  #--
-  # The +True+ option in the case statement provides some
-  # backward compatability with the previous versions of this
-  # method.
-  #++
-
-  def to_h(mode=nil)
-    case mode
-    when :splat
-      return to_h_splat
-    when :flat
-      return to_h_flat
-    when :multi, true
-      return to_h_multi
-    when :assoc
-      return to_h_assoc
-    else
-      return to_h_auto
-    end
-  end
-
-  # Converts an array into a hash. Converting an array
-  # into a hash is not a one-to-one conversion, for this
-  # reason #to_h examines at the array being converted
-  # and then dispatches the conversion to the most sutiable
-  # specialized function. There are three possiblities for this.
-  #
-  # If the array is a collection of perfect pairs, like that
-  # which Hash#to_a generates, then conversion is handled by 
-  # #to_h_flat.
-  #
-  #   a = [ [:a,1], [:b,2] ]
-  #   a.to_h_auto  #=> { :a=>1, :b=>2 }
-  #
-  # If the array contains only arrays, but are not perfect pairs,
-  # then #to_h_multi is called.
-  #
-  #   a = [ [:a,1,2], [:b,2], [:c], [:d] ]
-  #   a.to_h_auto  #=> { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-  #
-  # If the array contians objects other then arrays then
-  # the #to_h_splat method is called.
-  #
-  #   a = [ [:a,1,2], 2, :b, [:c,3], 9 ]
-  #   a.to_h_auto  #=> { [:a,1,2]=>2, :b=>[:c,3], 9=>nil } 
-  #
-  def to_h_auto
-    pairs = true
-    mixed = false
-
-    each do |e|
-      case e
-      when Array
-        pairs = false if e.size > 2
-      else
-        mixed = true
-      end
-    end
-
-    if mixed
-      to_h_splat
-    elsif pairs
-      to_h_flat
-    else
-      to_h_multi
-    end
-  end
-
-  # This is equivalent to Hash[*array], but it will pad
-  # the array with a +nil+ object if there are not an even number
-  # of elements.
-  #
-  #   a = [:a,1,:b,2,:c]
-  #   a.to_h_splat  #=> { :a=>1, :b=>2, :c=>nil }
-  #
-  def to_h_splat
-    a = dup
-    a << nil if a.size % 2 == 1
-    Hash[*a]
-  end
-
-  # This is equivalent to Hash[*array.flatten], but it will pad
-  # the array with a +nil+ object if there are not an even number
-  # of elements.
-  #
-  #   a = [:a,1,[:b,2,:c]]
-  #   a.to_h_flat  #=> { :a=>1, :b=>2, :c=>nil }
-  #
-  def to_h_flat
-    a = flatten
-    a << nil if a.size % 2 == 1
-    Hash[*a]
-  end
-
-  #--
-  #def to_h_flat
-  #  each_slice(2).inject({}) {|ha,(k,v)| ha[k]=v; ha}
-  #end 
-  #++
-
-  # When a mixed or multi-element accociative array
-  # is used, the result is as follows:
-  #
-  #   a = [ [:a,1,2], [:b,2], [:c], :d ]
-  #   a.to_h  #=> { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-  #
-  # If the first entry of any subelements are the same, then
-  # the value will be set to the last occuring value.
-  #
-  #   a = [ :x, [:x], [:x,1,2], [:x,3], [:x,4] ]
-  #   a.to_h_assoc  #=> { :x=>[4] }
-  #
-  def to_h_assoc
-    h = {}
-    each do |k,*v| 
-      h[k] = v
-    end
-    h
-  end
-
-  # When a mixed or multi-element accociative array
-  # is used, the result is as follows:
-  #
-  #   a = [ [:a,1,2], [:b,2], [:c], :d ]
-  #   a.to_h  #=> { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
-  #
-  # If the first entry of the subelements is the same, then
-  # the values will be merged using #concat.
-  #
-  #   a = [ [:a,1,2], [:a,3], [:a,4], [:a], :a ]
-  #   a.to_h_multi  #=> { :a=>[1,2,3,4] }
-  #
-  def to_h_multi
-    h = {}
-    each do |k,*v| 
-      h[k] ||= []
-      h[k].concat(v)
-    end
-    h
-  end
-
-  #--
-  #def to_h_multi
-  #  inject({}) {|h,a| h[a.first] = a[1..-1]; h}
-  #end
-
-  # Is this a good idea?
-  #def to_hash
-  #  h = {}
-  #  each_with_index do |v, i|
-  #    h[i] = v
-  #  end
-  #  h
-  #end
-  #++
-
-end
-
-class Hash
-
-  # Return a rehashing of _self_.
-  #
-  #   {"a"=>1,"b"=>2}.to_h  #=> {"b"=>2,"a"=>1}
-  #
-  # CREDIT: Forian Gross
-
-  def to_h; rehash; end
-
-  unless method_defined?(:to_hash) # 1.9.?+
-    # Returns _self_.
-    def to_hash; self; end
-  end
-
-end
-
-module Enumerable
-
-  # Convert an Enumerable object into a hash by first
-  # turning it into an array.
-  #
-  # CREDIT: Trans
-
-  def to_h(mode=nil)
-    to_a.to_h(mode)
-  end
-
-  def to_h_auto
-    to_a.to_h_auto
-  end
-
-  def to_h_splat
-    to_a.to_h_splat
-  end
-
-  def to_h_flat
-    to_a.to_h_flat
-  end
-
-  def to_h_assoc
-    to_a.to_h_assoc
-  end
-
-  def to_h_multi
-    to_a.to_h_multi
-  end
-
-  #--
-  #def to_hash
-  #  to_a.to_hash
-  #end
-  #++
-
-end
-
-class NilClass
-
-  # Allows <tt>nil</tt> to create an empty hash,
-  # similar to #to_a and #to_s.
-  #
-  #   nil.to_h    #=> {}
-  #
-  # CREDIT: Trans
-
-  def to_h; {}; end
-
-end
-
-
-class Enumerator
-
-  # Convert an Enumerator object into a hash.
-  # This is equivalent to Array#to_h.
-  #
-  #   e1 = [[1,:a],[2,:b],[3,:c]].to_enum
-  #   e1.to_h #=> { 1=>:a, 2=>:b, 3=>:c }
-  #
-  #   e2 = [1,2,3,4,5].to_enum
-  #   e2.to_h  #=> {5=>nil, 1=>2, 3=>4}
-  #
-  #   e3 = [1,2,1,3,1,5].to_enum
-  #   e3.to_h #=> {1=>5}
-  #
-  # CREDIT: Sandor Szücs
-
-  def to_h(mode=nil)
-    to_a.to_h(mode)
-  end
-
-  # This is equivalent to Array#to_h_auto.
-  #
-  def to_h_auto
-    to_a.to_h_auto
-  end
-
-  # This is equivalent to Array#to_h_splat.
-  #
-  def to_h_splat
-    to_a.to_h_splat
-  end
-
-  # This is equivalent to Array#to_h_flat.
-  #
-  def to_h_flat
-    to_a.to_h_flat
-  end
-
-  # This is equivalent to Array#to_h_assoc.
-  #
-  def to_h_assoc
-    to_a.to_h_assoc
-  end
-
-  # This is equivalent to Array#to_h_multi.
-  #
-  def to_h_multi
-    to_a.to_h_multi
-  end
-
-end
-
-class Struct
-
-  # Returns a hash containing the names and values
-  # for all instance settings in the Struct.
-  def to_h
-    h = {}
-    each_pair{ |k,v| h[k] = v }
-    h
-  end
-
-end
-