platypus 1.0.0

data/HISTORY

@@ -0,0 +1,19 @@
+= Change History
+
+# == 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.
+#
+
+== 1.0.0 // 2009-07-07
+
+This is the initial stand-alone release of TypeCast,
+spun-off from Ruby Facets.
+
+* 1 Major Enhancement
+
+    * Happy Birthday!
+

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010 Thomas Sawyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/NOTES.rdoc

@@ -0,0 +1,6 @@
+= Developer's Notes
+
+== 2010-05-27 | Alias for +Overloadable#overload+
+
+I am not sure if I like +con+, +sig+ or +over+ better as a short alias for +overload+. I thought of +con+ becuase of it's double meaning as Latin for 'with' and as an abbreviation for 'conditional'. But it seems esoteric in practice, perhaps b/c it would be too general a term if we were programming in Spanish. While +over+ probably makes the most sense in terms of being an abbreviated form of +overload+, +sig+ is the same number of characters as +def+ and conveys some additional semantics which applies to method overloading --the *signature*.
+

data/PROFILE

@@ -0,0 +1,24 @@
+--- 
+title  : Platypus
+suite  : rubyworks 
+summary: Type Casting System
+license: MIT
+created: 2004-01-01
+
+copyright:
+  Copyright (c) 2004 Thomas Sawyer
+
+authors:
+  - Thomas Sawyer
+  - Jonas Pfenniger
+
+description:
+  Provides a complete double-dispatch type conversion system,
+  method overloadability and psuedo-classes.
+
+resources:
+  homepage: http://rubyworks.github.com/platypus
+  development: http://github.com/rubyworks/platypus
+  repository: http://rubyworks.github.com/platypus.git
+  forum: http://googlegroups/group/rubyworks-mailinglist
+

data/README

@@ -0,0 +1,94 @@
+= Platypus
+     _   ___
+    / \ /   \
+    \. |: cc|
+     (.|:,---,
+     (.|: \ c|
+     (.    y-'
+      \ _ /
+       m m
+
+* home: http://rubyworks.github.com/platypus
+* work: http://github.com/rubyworks/platypus
+
+
+== DESCRIPTION
+
+Platypus provides a generalized type conversion system,
+method overloading and psuedo-classes.
+
+
+== RELEASE NOTES
+
+Please see HISTORY file.
+
+
+== SYNOPSIS
+
+=== Type Conversion
+
+   "1234".to(Float)    => 1234.0  (Float)
+
+   Time.from("6:30")   => 1234.0  (Time)
+
+=== Method Overloading
+
+To overload a method use the #overload method to define
+new functionality based on a specified type interface.
+
+   class X
+     include Overloadable
+
+     def x
+       "hello"
+     end
+
+     sig Integer
+
+     def x(i)
+       i
+     end
+
+     sig String, String
+
+     def x(s1, s2)
+       [s1, s2]
+     end
+   end
+
+=== Psuedo-Classes
+
+  class KiloType < Type
+    x % 1000 == 0
+  end
+
+  KiloType === 1000
+  KiloType === 2000
+
+
+== INSTALLATION
+
+To install with RubyGems simply open a console and type:
+
+  $ gem install typecast
+
+Site installation can be achieved with Setup.rb (gem install setup),
+then download the tarball package and type:
+
+  $ tar -xvzf typecast-1.0.0.tgz
+  $ cd typecast-1.0.0
+  $ sudo setup.rb all
+
+Windows users use 'ruby setup.rb all'.
+
+
+== COPYING
+
+Copyright (c) 2010 Thomas Sawyer
+
+This program is ditributed unser the terms of the Ruby license.
+
+See LICENSE or COPYING file for details.
+
+#--
+*-* mode: rdoc *-*

data/REQUIRE

@@ -0,0 +1,6 @@
+development:
+- syckle
+
+development/test:
+- qed
+

data/VERSION

@@ -0,0 +1,5 @@
+name : platypus
+major: 1
+minor: 0
+patch: 0
+date : 2010-05-27

data/lib/platypus.rb

@@ -0,0 +1,4 @@
+require 'platypus/typecast'
+require 'platypus/overload'
+require 'platypus/type'
+

data/lib/platypus/core_ext.rb

@@ -0,0 +1,8 @@
+module Kernel
+
+  def case?(*matchers)
+    matchers.all?{ |m| m === self }
+  end unless method_defined?(:case?)
+
+end
+

data/lib/platypus/overload.rb

@@ -0,0 +1,98 @@
+# The Obverloadable mixin allows you to easily
+# overload methods based on method signitures.
+#
+module Overloadable
+
+  #
+  def self.append_features(base)
+    if Module==base
+      super(base)
+    else
+      base.extend(self)
+    end
+  end
+
+  # Setup an overload state.
+  def overload(*signature)
+    (@overload_stack ||= []) << signature
+  end
+
+  # Short alias for +overload+.
+  alias_method :sig, :overload
+
+  #
+  def method_added(name)
+    return if $skip
+
+    @overload_stack  ||= []
+    @overload_method ||= {}
+
+    signature = @overload_stack.pop
+
+    if !method_defined?("#{name}:origin")
+      $skip = true
+      if signature
+        define_method("#{name}:origin"){|*a| raise ArgumentError }
+      else
+        alias_method("#{name}:origin", name)
+      end
+      $skip = false
+    end
+
+    if signature
+      @overload_module ||= Module.new
+
+      include @overload_module
+
+      signature = Signature[*signature]
+      @overload_method[name] ||= []
+      @overload_method[name] << signature
+
+      signame = "#{name}:#{signature.key}"
+
+      alias_method(signame, name)
+
+      sigs = @overload_method[name]
+      $skip = true
+      define_method(name) do |*args|
+        #sigs.sort.each do |sig|
+        s = sigs.find{ |sig| sig.match?(args) }
+        if s
+          __send__("#{name}:#{s.key}", *args)
+        else
+          __send__("#{name}:origin", *args)
+        end
+      end
+      $skip = false
+    end
+
+  end
+
+  #
+  class Signature < Array
+    def key
+      hash #Marshal.dump(self)
+    end
+
+    #
+    def match?(args)
+      return false unless size == args.size
+      size.times do |i|
+        return false unless self[i] === args[i]
+      end
+      true
+    end
+
+    #
+    def <=>(other)
+      cmp = (size <=> other.size)
+      return cmp if cmp && cmp != 0
+      size.times do |i|
+        cmp = (self[i] <=> other[i])
+        return cmp if cmp && cmp != 0
+      end
+      0
+    end
+  end
+
+end

data/lib/platypus/type.rb

@@ -0,0 +1,153 @@
+require 'platypus/core_ext'
+
+# Base class for Euphoria-like Types.
+#
+#   class KiloType < Type
+#     condition do |x|
+#       x.case? Integer
+#       x.kind_of?(Integer)
+#       x.respond_to?(:succ)
+#       x > 1000
+#     end
+#   end
+#
+# Becuase the +x.something?+ is so common, TypeCast provides
+# special "magic-dot" method to make defining these
+# conditions more concise.
+#
+#   class KiloType < Type
+#     x.case? Integer
+#     x.kind_of?(Integer)
+#     x.respond_to?(:succ)
+#     x > 1000
+#   end
+#
+# While TypeCasts are not actual types in the sense they
+# are not actual classes. They can be used for conversion
+# by defining a "from_{class}" class method. In doing so
+# you should make sure the result of the conversion conforms
+# to the typecast. You can use the TypeCast.validate method
+# to make that a bit easier. For instance:
+#
+#   class KiloType
+#     def from_string(str)
+#       validate(str.to_i)
+#     end
+#   end
+#
+# TypeCast also provides a helper DSL method that handles
+# this for you.
+#
+#   class KiloType
+#     conversion String do |str|
+#       str.to_i
+#     end
+#   end
+#
+# This will define a method equivalent to the prior example.
+
+class Type
+
+  # Activeate/Deactivate type-checking globally (NOT USED YET).
+  def self.check(on_or_off=nil)
+    @check = on_or_off unless on_or_off.nil?
+    @check
+  end
+
+  def self.validate(obj)
+    raise TypeError unless self === obj
+    return obj
+  end
+
+  #
+  def self.condition(&block)
+    @index ||= index
+    @index = @index.succ
+    define_method("condition_#{@index}", &block)
+    #@conditions << block
+  end
+
+  #
+  def self.conversion(klass, &block)
+    name = klass.name.downcase.gsub('::', '_')
+    (class << self; self; end).class_eval do
+      define_method("from_#{name}") do |from|
+        r = block.call(from)
+        validate(r)
+      end
+    end
+  end
+
+  #
+  def self.x
+    @x ||= Conditions.new(self)
+  end
+
+  #
+  class Conditions
+    instance_methods.each{ |x| private x unless x.to_s =~ /^__/ }
+
+    def initialize(type)
+      @type = type
+    end
+
+    #def __conditions__
+    #  @__conditions__ ||= []
+    #end
+
+    def method_missing(s, *a, &b)
+      @type.condition do |x|
+        x.__send__(s, *a, &b)
+      end
+      #__conditions__ << [s, a, b]
+    end
+  end
+
+  #
+  #def initialize(*matchers, &validate)
+  #  @matchers = matchers
+  #  @validate = validate
+  #end
+
+  #
+  def self.index
+    methods = instance_methods.select{ |m| m.to_s =~ /^condition_/ }
+    indexes = methods.map{ |m| m.split('_')[1].to_i }
+    indexes.max || 0
+  end
+
+  def self.conditions
+    #x.__conditions__ + (@conditions || []) + (defined?(super) ? super : [])
+    instance_methods.select{ |m| m.to_s =~ /^condition_/ }
+  end
+
+  #
+  def self.===(obj)
+    #conditions.all? do |s, a, b|
+    #  obj.__send__(s, *a, &b)
+    #end
+    instance = new
+    conditions.all? do |method|
+      instance.__send__(method, obj)
+    end
+  end
+
+  #
+  #def match?(argument)
+  #  @matchers.all? do |matcher|
+  #    case matcher
+  #    when Symbol
+  #      argument.send(:respond_to?, matcher) }
+  #    else
+  #      matcher === argument
+  #    end
+  #  end
+  #end
+
+  #
+  #def valid?(obj)
+  #  @validate[obj] if @validate
+  #end
+
+end
+

data/lib/platypus/typecast.rb

@@ -0,0 +1,57 @@
+require 'set'
+
+class Class
+
+  def typecasts
+    @typecasts ||= {}
+  end
+
+  # Define a type cast.
+  def typecast(target_class, *specifics, &block)
+    set = (specifics.empty? ? nil : Set.new(specifics))
+    typecasts[target_class] ||= {}
+    typecasts[target_class][set] = block
+  end
+
+  # Convert +source+ to an instance of the class.
+  def from(source, specifics={})
+    set  = (specifics.empty? ? nil : Set.new(specifics.keys))
+    base = ancestors.find{ |anc| source.class.typecasts.key?(anc) }
+    if base
+      cast = source.class.typecasts[base]
+      if block = cast[set]
+        if block.arity == 1
+          return block.call(source)
+        else
+          return block.call(source, specifics)
+        end
+      end
+    end
+    raise TypeError
+  end
+
+end
+
+
+class Object
+  # Convert an object to an instance of given +target_class+.
+  def to(target_class, specifics={})
+    target_class.from(self, specifics)
+  end
+end
+
+
+class String #:nodoc:
+  typecast Integer do |string|
+    Integer(string)
+  end
+end
+
+class Time #:nodoc:
+  # This method will require the 'time.rb' Time extensions.
+  typecast String do
+    require 'time'
+    parse(string)
+  end
+end
+

data/test/test_overload.rb

@@ -0,0 +1,173 @@
+require 'platypus/overload'
+
+#
+class TC_Overload_01 < Test::Unit::TestCase
+
+  class X
+    include Overloadable
+
+    def x
+      "hello"
+    end
+
+    overload Array
+
+    def x(x)
+      [Array, x]
+    end
+
+    overload Symbol
+
+    def x(x)
+      [Symbol, x]
+    end
+  end
+
+  def setup
+    @x = X.new
+  end
+
+  def test_x
+    assert_equal( "hello", @x.x )
+  end
+
+  def test_a
+    assert_equal( [Array, [1]], @x.x([1]) )
+  end
+
+  def test_s
+    assert_equal( [Symbol, :a], @x.x(:a) )
+  end
+
+end
+
+#
+class TC_Overload_02 < Test::Unit::TestCase
+
+  class X
+    include Overloadable
+
+    def x
+      "hello"
+    end
+
+    overload Integer
+
+    def x(i)
+      i
+    end
+
+    overload String, String
+
+    def x(s1, s2)
+      [s1, s2]
+    end
+
+  end
+
+  def setup
+    @x = X.new
+  end
+
+  def test_x
+    assert_equal( "hello", @x.x )
+  end
+
+  def test_i
+    assert_equal( 1, @x.x(1) )
+  end
+
+  def test_s
+    assert_equal( ["a","b"], @x.x("a","b") )
+  end
+
+end
+
+#
+class TC_Overload_03 < Test::Unit::TestCase
+
+  class SubArray < Array
+  end
+
+  class SubSubArray < SubArray
+  end
+  
+  class X
+    include Overloadable
+
+    def x
+      "hello"
+    end
+
+    overload Integer
+
+    def x(i)
+      i
+    end
+    
+    overload Symbol
+
+    def x(s)
+      s
+    end
+    
+    overload String, String
+
+    def x(s1, s2)
+      [s1, s2]
+    end
+
+    overload Symbol, String
+
+    def x(s1, s2)
+      [s1, s2]
+    end
+    
+    overload Array
+
+    def x(a)
+      "array"
+    end
+
+  end
+
+  def setup
+    @x = X.new
+  end
+
+  def test_x
+    assert_equal( "hello", @x.x )
+  end
+
+  def test_i
+    assert_equal( 1, @x.x(1) )
+  end
+
+  def test_strings
+    assert_equal( ["a","b"], @x.x("a","b") )
+  end
+
+  def test_symbol_string
+    assert_equal( [:a,"b"], @x.x(:a,"b") )
+  end
+
+  def test_sym
+    assert_equal( :sym, @x.x(:sym) )
+  end
+  
+  def test_subarray
+    assert_equal("array", @x.x([]))
+    assert_equal("array", @x.x(SubArray.new))
+    assert_equal("array", @x.x(SubSubArray.new))
+  end
+  
+  #def test_raise
+  #  assert_raise ArgumentError do
+  #     X.module_eval do
+  #      overload 42
+  #    end
+  #  end
+  #end
+
+end
+

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: platypus
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Thomas Sawyer
+- Jonas Pfenniger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-27 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Provides a complete double-dispatch type conversion system, method overloadability and psuedo-classes.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/platypus/core_ext.rb
+- lib/platypus/overload.rb
+- lib/platypus/type.rb
+- lib/platypus/typecast.rb
+- lib/platypus.rb
+- test/test_overload.rb
+- PROFILE
+- LICENSE
+- README
+- HISTORY
+- NOTES.rdoc
+- REQUIRE
+- VERSION
+has_rdoc: true
+homepage: http://rubyworks.github.com/platypus
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Platypus API
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: platypus
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Type Casting System
+test_files: 
+- test/test_overload.rb