facets 1.1.0 → 1.2.0

data/lib/facets/more/tuple.rb

@@ -0,0 +1,170 @@
+#--
+# Tuple
+#
+# 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.
+#
+# ==========================================================================
+#  Revision History:
+# ==========================================================================
+#
+#  2005-11-16 trans
+#    Improved comparison operators to convert non-tuple parameters
+#    into Tuples.
+#
+#  2005.04.24 trans
+#    Adjusted to use Tuple::[] instead of ::new, which now takes a single
+#    argument, either an Array or a String which it splits.
+#
+#  2005.04.24 trans
+#    Created.
+#
+# ==========================================================================
+#
+#  TODO: Thead Safety/Improve multiton.
+#
+#++
+
+#:title: Tuple
+#
+# A Tuple is essentially an Array that is Multiton and Comaparable.
+# A Tuple can be made using #[] as one builds an array, or
+# using the #new method passing in an array or a string parameters
+# with elements divided by any non-alphanumeric character.
+#
+# == Usage
+#
+#   t1 = Tuple[1,2,3]
+#   t2 = Tuple[2,3,4]
+#
+#   t1 < t2   #=> true
+#   t1 > t2   #=> false
+#
+#   t1 = Tuple.new('1.2.3')
+#   t2 = Tuple.new('1-2-3')
+#
+#   t1 == t2  #=> true
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+#
+
+class ::Tuple < ::Array
+
+  include ::Comparable
+
+  def initialize(args, divider=nil)
+    super()
+    @divider = divider || ':'
+    self.concat args
+  end
+
+  def to_s ; join(@divider) ; end
+
+  def to_t ; self ; end
+  def to_tuple ; self ; 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 ==( other ) ; super( other.to_t ) ; end
+  def  >( other ) ; super( other.to_t ) ; end
+  def  <( other ) ; super( other.to_t ) ; end
+  def >=( other ) ; super( other.to_t ) ; end
+  def <=( other ) ; super( other.to_t ) ; end
+
+  # class-level -----------------------------------------------
+
+  @tuples = {}
+
+  class << self
+
+    alias_method :instance, :new
+
+    def new( arg )
+      case arg
+      when Array, Tuple
+        div = nil
+      else
+        div = /\W/.match(arg)[0]
+        args = arg.to_s.split(/\W/).collect { |e| e.to_i }
+      end
+      @tuples[args] ||= instance(args, div)
+    end
+
+    def []( *args )
+      @tuples[args] ||= instance(args)
+    end
+
+    # Parses a constraint returning the operation, and the
+    # tuple to compare against.
+    def decipher_constraint( constraint )
+      if md = %r{^(=~|~>|<=|>=|==|=|<|>)(.*)$}.match( constraint.strip )
+        opr = md[1]
+        opr = '=~' if opr == '~>'
+        opr = '==' if opr == '='
+        val = instance(md[2])
+      else
+        opr = '=='
+        val = instance(constraint.strip)
+      end
+      return opr, val
+    end
+
+  end #class << self
+
+end
+
+# Conveniently turn a string into a tuple.
+
+class ::String
+
+  def to_t
+    ::Tuple.new(self)
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin test
+
+  require 'test/unit'
+
+  class TC_Tuple < Test::Unit::TestCase 
+
+    def setup
+      @t1 = Tuple[1,2,3]
+      @t2 = Tuple[2,4,5]
+    end
+
+    def test_compare
+      assert( @t1 < @t2 )
+      assert( @t2 > @t1 )
+    end
+
+  end
+
+=end
+

data/lib/facets/more/typecast.rb

@@ -0,0 +1,280 @@
+#--
+# TypeCast
+#
+# Copyright (c) 2004,2005 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.
+#
+# ==========================================================================
+#  Revision History
+# ==========================================================================
+#
+# * Empty
+#
+# ==========================================================================
+#
+# TODO : look to implement to_int, to_mailtext, to_r, to_rfc822text and to_str
+#++
+
+#:title: TypeCast
+#
+# Provides a generic simple type conversion utility. All the ruby core
+# conversions are available by default.
+#
+# 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.
+#
+# == Usage
+#
+#  "1234".cast_to Float     => 1234.0  (Float)
+#  Time.cast_from("6:30")   => 1234.0   (Time)
+#
+# == FAQ
+#
+# Why didn't you name the `cast_to` method to `to` ?
+# 
+#   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
+#
+# == Author(s)
+#
+# * Jonas Pfenniger
+#
+
+require 'facet/string/methodize'
+
+class Object
+
+  # Cast an object to another
+  #
+  #    1234.cast_to(String)  => "1234"
+  #
+  def cast_to(klass, options={})
+    klass.cast_from(self, options)
+  end
+
+  # Cast on object from another
+  #
+  #   String.cast_from(1234) => "1234"
+  #
+  def cast_from(object, options={})
+    method_to = "cast_to_#{self.name.methodize}".to_sym
+    if object.respond_to?( method_to )
+      retval = object.send(method_to, options)
+      return retval unless retval == nil
+    end
+
+    method_from = "cast_from_#{object.class.name.methodize}".to_sym
+    if respond_to?( method_from )
+      retval = send(method_from, object, options)
+      return retval unless retval == nil
+    end
+  end
+end
+
+# Extend the ruby core
+# --
+class Array
+  class << self
+    def cast_from(object, options={})
+      retval = super
+      return retval unless retval == nil
+      return object.to_a if object.respond_to? :to_a
+    end
+  end
+end
+
+class Float
+  class << self
+    def cast_from(object, options={})
+      retval = super
+      return retval unless retval == nil
+      return object.to_f if object.respond_to? :to_f
+    end
+  end
+end
+
+class Integer
+  class << self
+    def cast_from(object, options={})
+      retval = super
+      return retval unless retval == nil
+      return object.to_i if object.respond_to? :to_i
+    end
+  end
+end
+
+class String
+  class << self
+    def cast_from(object, options={})
+      retval = super
+      return retval unless retval == nil
+      return object.to_s if object.respond_to? :to_s
+    end
+  end
+end
+
+class Symbol
+  class << self
+    def cast_from(object, options={})
+      super
+      return object.to_sym if object.respond_to? :to_sym
+    end
+  end
+end
+
+# Extensions
+
+require 'facet/string/modulize'
+class Class
+  class << self
+
+    # "string".cast_to Class         #=> String 
+    def cast_from_string(string, options={})
+      string = string.to_s.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
+
+    # :logger__error.cast_to Class   #=> Logger::Error
+    alias :cast_from_symbol :cast_from_string
+  end
+end
+
+class Time
+  class << self
+    def cast_from_string(string, options={})
+      parse(string)
+    rescue
+      nil
+    end
+  end
+end
+
+class StringIO
+  class << self
+
+    # options :
+    #   :mode => see StringIO.new
+    def cast_from_string(string, options={})
+      new(string,options[:mode])
+    end
+  end
+end
+
+module URI
+  class << self
+    def cast_from_string(string, options={})
+      URI.parse(string)
+    end
+  end
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TestClass
+    attr_accessor :my_var
+    def initialize(my_var); @my_var = my_var; end
+
+    def cast_to_string(options={})
+      @my_var
+    end
+
+    class << self
+      def cast_from_string(string, options={})
+        self.new( string )
+      end
+    end
+  end
+
+  class TC_TypeCast < Test::Unit::TestCase
+
+    def setup
+      @test_string = "this is a test"
+      @test_class = TestClass.new(@test_string)
+    end
+
+    def test_to_string
+      assert_equal( '1234', 1234.cast_to(String) )
+    end
+
+    def test_custom_to_string
+      assert_equal( @test_string, @test_class.cast_to(String) )
+    end
+
+    def test_custom_from_string
+      assert_equal( @test_class.my_var, @test_string.cast_to(TestClass).my_var )
+    end
+
+    def test_string_to_class
+      assert_equal( Test::Unit::TestCase, "Test::Unit::TestCase".cast_to(Class) )
+    end
+
+    def test_string_to_time
+      assert_equal( "Mon Oct 10 00:00:00 CEST 2005", "10-10-2005".cast_to(Time).to_s )
+    end
+
+    def test_no_converter
+      assert_equal( nil,  "sdfjljsldfjslk".cast_to( DateTime  ))
+    end
+  end
+
+=end

data/lib/facets/more/uninheritable.rb

@@ -0,0 +1,90 @@
+#--
+# Uninheritable
+#
+# Copyright (c) 2003 Austin Ziegler
+#
+# 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.
+#
+# ==========================================================================
+#  Revision History
+# ==========================================================================
+#
+#  2003.9.17  Austin Ziegler
+#    - Minor modifications to documentation.
+#
+# ==========================================================================
+#++
+
+#:title: Uninheritable
+#
+# Allows an object to declare itself as unable to be subclassed. The
+# technique behind this is very simple (redefinition of #inherited), so this
+# just provides an easier way to do the same thing with a consistent error
+# message.
+#
+# == Usage
+#
+#   class A
+#     extend Uninheritable
+#   end
+#
+#   class B < A; end # => raises TypeError
+#
+# == Author(s)
+#
+# * Austin Ziegler
+#
+
+module Uninheritable
+  # Redefines a class's #inherited definition to prevent subclassing of the
+  # class extended by this module.
+  def inherited(klass)
+    raise TypeError, "Class #{self} cannot be subclassed."
+  end
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+require 'test/unit'
+
+class TC_Uninheritable < Test::Unit::TestCase
+
+  class Cannot
+    extend Uninheritable
+  end
+
+  class Can
+  end
+
+  def test_module
+    assert_nothing_raised {
+      self.instance_eval <<-EOS
+        class A < Can; end
+      EOS
+    }
+    assert_raises(TypeError, "Class Cannot cannot be subclassed.") do
+      self.instance_eval <<-EOS
+        class B < Cannot; end
+      EOS
+    end
+  end
+
+end
+
+=end