mack-facets 0.8.1 → 0.8.2

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

@@ -0,0 +1,325 @@
+# = 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

@@ -0,0 +1,261 @@
+# = 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
+