mack-facets 0.8.2 → 0.8.3

data/lib/gems/facets-2.4.5/lib/more/facets/tuple.rb

@@ -1,325 +0,0 @@
-# = Tuple
-#
-# Tuple is essentially an Array, but Comaparable and Immutable.
-#
-# A tuple can be made using #new or #[] just as one builds an array,
-# or using the #to_t method on a string or array. With a string tuple
-# remembers the first non-alphanumeric character as the tuple divider.
-#
-# == Usage
-#
-#   t1 = Tuple[1,2,3]
-#   t2 = Tuple[2,3,4]
-#
-#   t1 < t2   #=> true
-#   t1 > t2   #=> false
-#
-#   t1 = '1.2.3'.to_t
-#   t2 = '1-2-3'.to_t
-#
-#   puts t1  #=> 1.2.3
-#   puts t2  #=> 1-2-3
-#
-#   t1 == t2  #=> true
-#
-# Keep in mind that Tuple[1,2,3] is not the same as Tuple['1','2','3'].
-#
-# == Todo
-#
-# * The #hash method needs a touch-up.
-#
-# * There are a few more methods yet to borrow from Array.
-#   Consider how #+, #-, etc. ought to work.
-#
-# == Author
-#
-# * Thomas Sawyer
-#
-# == Copying
-#
-# Copyright (c) 2005 Thomas Sawyer
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or
-# redistribute this software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-require 'facets/multiton'
-
-# = Tuple
-#
-# A tuple can be made using #new or #[] just as one builds an array,
-# or using the #to_t method on a string or array. With a string tuple
-# remembers the first non-alphanumeric character as the tuple divider.
-#
-# == Usage
-#
-#   t1 = Tuple[1,2,3]
-#   t2 = Tuple[2,3,4]
-#
-#   t1 < t2   #=> true
-#   t1 > t2   #=> false
-#
-#   t1 = '1.2.3'.to_t
-#   t2 = '1-2-3'.to_t
-#
-#   puts t1  #=> 1.2.3
-#   puts t2  #=> 1-2-3
-#
-#   t1 == t2  #=> true
-#
-# Keep in mind that Tuple[1,2,3] is not the same as Tuple['1','2','3'].
-
-class Tuple
-
-  include ::Multiton
-  include ::Enumerable
-  include ::Comparable
-
-  def self.multiton_id(arg=0, default=0, &block)
-    if block_given?
-      values = []
-      arg.times { |i| values << block[i] }
-    elseif Integer === arg
-      values = [ default ] * arg
-    else
-      values = arg.to_ary
-    end
-    values
-  end
-
-  def initialize(arg=0, default=0, &blk)
-    if block_given?
-      @values = []
-      arg.times { |i| @values << blk[i] }
-    elseif Integer === arg
-      @values = [ default ] * arg
-    else
-      @values = arg.to_ary
-    end
-    @default = default
-    @divider = '.'
-  end
-
-  attr_accessor :default
-
-  def divider( set=nil )
-    return @divider unless set
-    @divider = set
-    self
-  end
-
-protected
-
-  def values() @values end
-
-public
-
-  def inspect() to_a.inspect end
-
-  def to_t()     self end
-  def to_tuple() self end
-
-  def to_a()   Array(@values) end
-  def to_ary() Array(@values) end
-
-  def to_s( divider=nil )
-    @values.join(divider||@divider)
-  end
-
-  def size()   @values.size end
-  def length() @values.size end
-
-  def empty?()
-    return true if @values.empty?
-    return true if @values == [ @default ] * @values.size
-    false
-  end
-
-  def each( &block )
-    @values.each( &block )
-  end
-
-  def each_index( &block )
-    @values.each_index( &block )
-  end
-
-  def [](i)
-    @values.fetch(i,@default)
-  end
-
-  def []=(i,v)
-    @values[i] = v
-  end
-
-  def index()  @values.index end
-  def rindex() @values.rindex end
-
-  # Unlike Array, Tuple#<< cannot act in place
-  # becuase Tuple's are immutable.
-  def <<( obj )
-    self.class.instance( to_a << obj )
-  end
-
-  def pop() Tuple.instance( to_a.pop ) end
-
-  def push( obj ) Tuple.instance( to_a.push(obj) ) end
-
-  # Pulls a value off the beginning of a tuple.
-  # This method is otherwsie known as #shift.
-  def pull() Tuple.instance( to_a.shift ) end
-
-  # Stands for "Put On Top". This method is the opposite of #pull and is
-  # otherwise known as #unshift.
-  def pot( obj ) Tuple.instance( to_a.unshift(obj) ) end
-
-  alias_method :unshift, :pot
-  alias_method :shift, :pull
-
-  # Returns true if two tuple references are for the
-  # very same tuple.
-  def eql?( other )
-    return true if object_id == other.object_id
-    #return true if values.eql? other.values
-  end
-
-  def <=>( other )
-    other = other.to_t
-    [size, other.size].max.times do |i|
-      c = self[i] <=> other[i]
-      return c if c != 0
-    end
-    0
-  end
-
-  # For pessimistic constraint (like '~>' in gems)
-  def =~( other )
-    other = other.to_t
-    upver = other.dup
-    upver[0] += 1
-    self >= other and self < upver
-  end
-
-  def first() @values.first end
-  def last()  @values.last end
-
-  # These are useful for using a Tuple as a version.
-  def major() @values.first end
-  def minor() @values.at(1) end
-  def teeny() @values.at(2) end
-
-  # Unique hash value.
-  def hash
-    # TODO This needs to take into account the default
-    #      and maybe the divider too.
-    to_a.hash
-  end
-
-  # class-level -----------------------------------------------
-
-  class << self
-
-    def []( *args )
-      instance( args )
-    end
-
-    # Translates a string in the form on a set of numerical and/or
-    # alphanumerical characters separated by non-word characters (eg \W+)
-    # into a Tuple. The values of the tuple will be converted to integers
-    # if they are purely numerical.
-    #
-    #   Tuple.cast_from_string('1.2.3a')  #=> [1,2,"3a"]
-    #
-    # It you would like to control the interpretation of each value
-    # as it is added to the tuple you can supply a block.
-    #
-    #   Tuple.cast_from_string('1.2.3a'){ |v| v.upcase }  #=> ["1","2","3A"]
-    #
-    # This method is called by String#to_t.
-
-    def cast_from_string( str, &yld )
-      args = str.to_s.split(/\W+/)
-      div = /\W+/.match( str.to_s )[0]
-      if block_given?
-        args = args.collect{ |a| yld[a] }
-      else
-        args = args.collect { |i| /^[0-9]+$/ =~ i ? i.to_i : i }
-      end
-      self.instance( args ).divider( div )
-    end
-
-    #
-
-    def cast_from_array( arr )
-      self.instance( arr )
-    end
-
-    # Parses a constraint returning the operation as a lambda.
-
-    def constraint_to_lambda( constraint, &yld )
-      op, val = *parse_constraint( constraint, &yld )
-      lambda { |t| t.send(op, val) }
-    end
-
-    def parse_constraint( constraint, &yld )
-      constraint = constraint.strip
-      re = %r{^(=~|~>|<=|>=|==|=|<|>)?\s*(\d+(:?[-.]\d+)*)$}
-      if md = re.match( constraint )
-        if op = md[1]
-          op = '=~' if op == '~>'
-          op = '==' if op == '='
-          val = cast_from_string( md[2], &yld ) #instance( md[2] )
-        else
-          op = '=='
-          val = cast_from_string( constraint, &yld ) #instance( constraint )
-        end
-      else
-        raise ArgumentError, "invalid constraint"
-      end
-      return op, val
-    end
-
-  end
-
-end
-
-
-# Conveniently turn a string into a tuple.
-
-class ::String
-
-  # Translates a string in the form on a set of numerical and/or
-  # alphanumerical characters separated by non-word characters (eg \W+)
-  # into a Tuple. The values of the tuple will be converted to integers
-  # if they are purely numerical.
-  #
-  #   '1.2.3a'.to_t  #=> [1,2,"3a"]
-  #
-  # It you would like to control the interpretation of each value
-  # as it is added to the tuple you can supply a block.
-  #
-  #   '1.2.3a'.to_t { |v| v.upcase }  #=> ["1","2","3A"]
-  #
-  # This method calls Tuple.cast_from_string.
-
-  def to_t( &yld )
-    Tuple.cast_from_string( self, &yld )
-  end
-
-end
-
-
-# Convert and array into a tuple.
-
-class ::Array
-
-  def to_t
-    Tuple.cast_from_array( self )
-  end
-
-end
-

data/lib/gems/facets-2.4.5/lib/more/facets/typecast.rb

@@ -1,261 +0,0 @@
-# = TypeCast
-#
-# Provides a generic simple type conversion utility. All the ruby core
-# conversions are available by default.
-#
-#   "1234".cast_to Float     => 1234.0  (Float)
-#   Time.cast_from("6:30")   => 1234.0   (Time)
-#
-# To implement a new type conversion, you have two choices, take:
-#
-#  class CustomType
-#    def initialize(my_var)
-#      @my_var = my_var
-#    end
-#  end
-#
-# Define a to_class_name instance method
-#
-#  class CustomType
-#    def to_string
-#      my_var.to_s
-#    end
-#  end
-#
-#  c = CustomType.new 1234
-#  s.cast_to String   =>  "1234" (String)
-#
-# Define a from_class_name class method
-#
-#  class CustomType
-#    def self.from_string(str)
-#      self.new(str)
-#    end
-#  end
-#
-#  "1234".cast_to CustomType  =>  #<CustomType:0xb7d1958c @my_var="1234">
-#
-# Those two methods are equivalent in the result. It was coded like that to
-# avoid the pollution of core classes with tons of to_* methods.
-#
-# The standard methods to_s, to_f, to_i, to_a and to_sym are also used by
-# this system if available.
-#
-# == Faq
-#
-# Q. Why didn't you name the `cast_to` method to `to` ?
-#
-# A. Even if it would make the syntax more friendly, I suspect it could cause
-# a lot of collisions with already existing code. The goal is that each
-# time you call cast_to, you either get your result, either a
-# TypeCastException
-#
-# == Authors
-#
-# * Jonas Pfenniger
-# 
-# == History
-#
-# * 2006-06-06 3v1l_d4y:
-#   * Removed transformation options.
-#   * Removed StringIO typecast. It is not required by default.
-#   * Added TypeCastException for better error reporting while coding.
-#
-# == Todo
-#
-# * Consider how this might fit in with method signitures, overloading,
-#   and expiremental euphoria-like type system.
-#
-# * Look to implement to_int, to_mailtext, to_r, to_rfc822text and to_str.
-#
-# == Copying
-#
-#   Copyright (c) 2004 Jonas Pfenniger
-#
-#   Ruby License
-#
-#   This module is free software. You may use, modify, and/or redistribute this
-#   software under the same terms as Ruby.
-#
-#   This program is distributed in the hope that it will be useful, but WITHOUT
-#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-#   FOR A PARTICULAR PURPOSE.
-
-require 'time'
-require 'facets/string/methodize'
-require 'facets/string/camelcase' #modulize'
-
-# = Typecast
-#
-# Provides a generic simple type conversion utility. All the ruby core
-# conversions are available by default.
-#
-#   "1234".cast_to Float     => 1234.0  (Float)
-#   Time.cast_from("6:30")   => 1234.0   (Time)
-#
-# To implement a new type conversion, you have two choices, take:
-#
-#  class CustomType
-#    def initialize(my_var)
-#      @my_var = my_var
-#    end
-#  end
-#
-# Define a to_class_name instance method
-#
-#  class CustomType
-#    def to_string
-#      my_var.to_s
-#    end
-#  end
-#
-#  c = CustomType.new 1234
-#  s.cast_to String   =>  "1234" (String)
-#
-# Define a from_class_name class method
-#
-#  class CustomType
-#    def self.from_string(str)
-#      self.new(str)
-#    end
-#  end
-#
-#  "1234".cast_to CustomType  =>  #<CustomType:0xb7d1958c @my_var="1234">
-#
-# Those two methods are equivalent in the result. It was coded like that to
-# avoid the pollution of core classes with tons of to_* methods.
-#
-# The standard methods to_s, to_f, to_i, to_a and to_sym are also used by
-# this system if available.
-#
-# == Faq
-#
-# Q. Why didn't you name the `cast_to` method to `to` ?
-#
-# A. Even if it would make the syntax more friendly, I suspect it could cause
-# a lot of collisions with already existing code. The goal is that each
-# time you call cast_to, you either get your result, either a
-# TypeCastException
-#
-module TypeCast
-
-  # Typecast method extensions for Object class.
-
-  module Object
-    # Cast an object to another
-    #
-    #    1234.cast_to(String)  => "1234"
-    #
-    def cast_to(klass)
-      klass.cast_from(self)
-    end
-  end
-
-  # Typecast method extensions for Class class.
-
-  module Class
-    # Cast on object from another.
-    #
-    #   String.cast_from(1234) => "1234"
-    #
-    def cast_from(object)
-      method_to = "to_#{self.name.methodize}".to_sym
-      if object.respond_to? method_to
-        retval = object.send(method_to)
-        return retval
-      end
-      method_from = "from_#{object.class.name.methodize}".to_sym
-      if respond_to? method_from
-        retval = send(method_from, object)
-        return retval
-      end
-      raise TypeCastException, "TypeCasting from #{object.class.name} to #{self.name} not supported"
-    end
-  end
-
-end
-
-# TypeCast Exception error.
-#
-class TypeCastException < Exception; end
-
-class Object #:nodoc:
-  include TypeCast::Object
-end
-
-class Class #:nodoc:
-  include TypeCast::Class
-end
-
-class Array #:nodoc:
-  def self.cast_from(object)
-    return super
-  rescue TypeCastException
-    return object.to_a if object.respond_to? :to_a
-    raise
-  end
-end
-
-class Float #:nodoc:
-  def self.cast_from(object)
-    return super
-  rescue TypeCastException
-    return object.to_f if object.respond_to? :to_f
-    raise
-  end
-end
-
-class Integer #:nodoc:
-  def self.cast_from(object)
-    return super
-  rescue TypeCastException
-    return object.to_i if object.respond_to? :to_i
-    raise
-  end
-end
-
-class String #:nodoc:
-  def self.cast_from(object)
-    return super
-  rescue TypeCastException
-    return object.to_s if object.respond_to? :to_s
-    raise
-  end
-end
-
-class Symbol #:nodoc:
-  def self.cast_from(object)
-    return super
-  rescue TypeCastException
-    return object.to_sym if object.respond_to? :to_sym
-    raise
-  end
-end
-
-# Special Extensions
-
-class Class #:nodoc:
-  # "string".cast_to Class         #=> String
-  def self.from_string(string)
-    string = string.to_s.camelcase #modulize
-    base   = string.sub!(/^::/, '') ? Object : (self.kind_of?(Module) ? self : self.class )
-    klass  = string.split(/::/).inject(base){ |mod, name| mod.const_get(name) }
-    return klass if klass.kind_of? Class
-    nil
-  rescue
-    nil
-  end
-
-  class << self
-    alias_method :from_symbol, :from_string
-  end
-end
-
-class Time #:nodoc:
-  def self.from_string(string, options={})
-    parse(string)
-  rescue
-    nil
-  end
-end
-