myrrha 1.0.0 → 1.1.0

data/CHANGELOG.md

@@ -1,5 +1,75 @@
+# 1.1.0 / 2011-07-28
+
+## Enhancements to coerce()
+
+* Added coercion rules from Symbol/String to Module/Class
+
+      coerce("Integer", Class)          # => Integer
+      coerce(:Integer, Class)           # => Integer
+      coerce("Myrrha::Version", Module) # => Myrrha::Version
+      [... and so on ...]
+
+* Added following coercion rules for Booleans
+
+      coerce("true", TrueClass)         # => true 
+      coerce("false", FalseClass)       # => false 
+
+* Added coercion rule from any Object to String through ruby's String(). Note 
+  that even with this coercion rule, coerce(nil, String) returns nil as that 
+  rule has higher priority.
+      
+* require('time') is automatically issued when trying to coerce a String to 
+  a Time. Time.parse is obviously needed.   
+
+* Myrrha::Boolean (Boolean with core extensions) is now a factored domain (see
+  below). Therefore, it is now a true Class instance. 
+
+## Enhancements to the general coercion mechanism
+
+* An optimistic coercion is tried when a rule is encountered whose target 
+  domain is a super domain of the requested one. Coercion only succeeds if
+  the coerced value correctly belongs to the latter domain. Example:
+  
+      rules = Myrrha.coercions do |r|
+        r.coercion String, Numeric, lambda{|s,t| Integer(s)} 
+      end 
+      rules.coerce("12", Integer) # => 12 in 1.1.0 while it failed in 1.0.0
+      rules.coerce("12", Float)   # => Myrrha::Error
+
+* You can now specify a coercion path, through an array of domains. For 
+  example (completely contrived, of course):
+
+      rules = Myrrha.coercions do |r|
+        r.coercion String,  Symbol, lambda{|s,t| s.to_sym }
+        r.coercion Float,   String, lambda{|s,t| s.to_s   }
+        r.coercion Integer, Float,  lambda{|s,t| Float(s) }
+        r.coercion Integer, Symbol, [Float, String] 
+      end
+      rules.coerce(12, Symbol)      # => :"12.0" as Symbol(String(Float(12)))
+
+* You can now define domains through specialization by constraint (sbyc) on ruby 
+  classes, using Myrrha.domain:
+  
+      # Create a positive integer domain, as ... positive integers
+      PosInt = Myrrha.domain(Integer){|i| i > 0 }
+  
+  Created domain is a real Class instance, that correctly responds to :=== 
+  and :superclass. The feature is mainly introduced for supporting the following 
+  kind of coercion scenarios (see README for more about this):
+  
+      rules = Myrrha.coercions do |r|
+        r.coercion String, Integer, lambda{|s,t| Integer(s)}  
+      end 
+      rules.coerce("12",  PosInt) # => 12
+      rules.coerce("-12", PosInt) # => ArgumentError, "Invalid value -12 for PosInt"  
+
+## Bug fixes
+
+* Fixed Coercions#dup when a set of rules has a main target domain. This fixes
+  the duplication of ToRubyLiteral rules, among others.
+
 # 1.0.0 / 2011-07-22
 
-* Enhancements
+## Enhancements
 
   * Birthday!

data/Gemfile.lock

@@ -1,12 +1,12 @@
 PATH
   remote: .
   specs:
-    myrrha (1.0.0)
+    myrrha (1.1.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    bluecloth (2.0.11)
+    bluecloth (2.1.0)
     diff-lcs (1.1.2)
     highline (1.6.2)
     noe (1.3.0)
@@ -31,7 +31,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  bluecloth (~> 2.0.9)
+  bluecloth (~> 2.1.0)
   bundler (~> 1.0)
   myrrha!
   noe (~> 1.3.0)

data/README.md

@@ -1,4 +1,4 @@
-# Myrrha
+# Myrrha (v1.1.0)
 
 ## Description
 
@@ -17,15 +17,15 @@ a numeric, a boolean, a date, a time, an URI, and so on.
     # Bug fixes (tiny) do not even add new default rules to coerce and 
     # to\_ruby\_literal. Minor version can, which could break your code. 
     # Therefore, please always use:
-    gem "alf", "~> 1.0.0"
+    gem "myrrha", "~> 1.0.0"
 
 ## Links
 
-* http://rubydoc.info/github/blambeau/myrrha/master/frames (read this file there!)
+* http://www.rubydoc.info/gems/myrrha/1.1.0/file/README.md (read this file there!)
 * http://github.com/blambeau/myrrha (source code)
 * http://rubygems.org/gems/myrrha (download)
 
-## The missing <code>coerce()</code>
+## The <code>coerce()</code> feature
 
     Myrrha.coerce(:anything, Domain)
     coerce(:anything, Domain)                    # with core extensions
@@ -48,34 +48,71 @@ possible and even straightforward:
     end
     # => [12, true, #<Date: 2011-07-20 (...)>]
 
-### Example
+### Implemented coercions
+
+Implemented coercions are somewhat conservative, and only use a subset of what 
+ruby provides here and there. This is to avoid strangeness ala PHP... The 
+general philosophy is to provide the natural coercions we apply everyday.
+
+The master rules are
+
+* <code>coerce(value, Domain)</code> return <code>value</code> if 
+  <code>belongs_to?(value, Domain)</code> is true (see last section below)
+* <code>coerce(value, Domain)</code> returns <code>Domain.coerce(value)</code>
+  if the latter method exists.
+* <code>coerce("any string", Domain)</code> returns <code>Domain.parse(value)</code>
+  if the latter method exists.
+
+The specific implemented rules are 
 
     require 'myrrha/with_core_ext'
     require 'myrrha/coerce'
     
-    # it works on numerics
+    # NilClass -> _Anything_ returns nil, always
+    coerce(nil, Integer)              # => nil
+    
+    # Object -> String, via ruby's String()
+    coerce("hello", String)           # => "hello"
+    coerce(:hello, String)            # => "hello"
+
+    # String -> Numeric, through ruby's Integer() and Float()
     coerce("12", Integer)             # => 12
     coerce("12.0", Float)             # => 12.0
     
-    # but also on regexp (through Regexp.compile)
+    # String -> Numeric is smart enough:
+    coerce("12", Numeric)             # => 12 (Integer)
+    coerce("12.0", Numeric)           # => 12.0 (Float)
+    
+    # String -> Regexp, through Regexp.compile
     coerce("[a-z]+", Regexp)          # => /[a-z]+/
     
-    # and, yes, on Boolean (sorry Matz!)
+    # String -> Symbol, through to_sym
+    coerce("hello", Symbol)           # => :hello 
+    
+    # String -> Boolean (hum, sorry Matz!)
     coerce("true", Boolean)           # => true
     coerce("false", Boolean)          # => false
+    coerce("true", TrueClass)         # => true
+    coerce("false", FalseClass)       # => false
   
-    # and on date and time (through Date/Time.parse)  
+    # String -> Date, through Date.parse  
     require 'date'
-    require 'time'
     coerce("2011-07-20", Date)        # => #<Date: 2011-07-20 (4911525/2,0,2299161)>  
+    
+    # String -> Time, through Time.parse (just in time issuing of require('time'))
     coerce("2011-07-20 10:57", Time)  # => 2011-07-20 10:57:00 +0200
     
-    # why not on URI?
+    # String -> URI, through URI.parse
     require 'uri'
     coerce('http://google.com', URI)  # => #<URI::HTTP:0x8281ce0 URL:http://google.com>    
 
-    # on nil, it always returns nil
-    coerce(nil, Integer)              # => nil
+    # String -> Class and Module through constant lookup
+    coerce("Integer", Class)          # => Integer
+    coerce("Myrrha::Version", Module) # => Myrrha::Version
+    
+    # Symbol -> Class and Module through constant lookup
+    coerce(:Integer, Class)           # => Integer
+    coerce(:Enumerable, Module)       # => Enumerable
 
 ### No core extension? no problem!
 
@@ -133,7 +170,7 @@ might be intrusive. Why not using your own set of coercion rules?
     MyRules.apply(:hello, Foo) 
     # =>  #<Foo:0x8b7d254 @arg=:hello>
 
-## The missing <code>to\_ruby\_literal()</code>
+## The <code>to\_ruby\_literal()</code> feature
 
     Myrrha.to_ruby_literal([:anything]) 
     [:anything].to_ruby_literal                  # with core extensions
@@ -291,7 +328,41 @@ which PRE holds are executed in order, until one succeed (chain of
 responsibility design pattern). This means that coercions always execute in 
 <code>O(number of rules)</code>.
 
-### <code>belongs\_to?</code> and <code>subdomain?</code> 
+### Specifying converters
+
+A converter is the third (resp. second) element specified in a coercion rules
+(resp. an upon or fallback rule). A converter is generally a Proc of arity 2,
+which is passed the source value and requested target domain.
+
+    Myrrha.coercions do |r|
+      r.coercion String, Numeric, lambda{|value,requested_domain|
+        # this is converter code
+      }
+    end
+    convert("12", Integer)
+    
+A converter may also be specified as an array of domains. In this case, it is
+assumed that they for a path inside the convertion graph. Consider for example
+the following coercion rules (contrived example)
+
+    rules = Myrrha.coercions do |r|
+      r.coercion String,  Symbol, lambda{|s,t| s.to_sym }   # 1
+      r.coercion Float,   String, lambda{|s,t| s.to_s   }   # 2
+      r.coercion Integer, Float,  lambda{|s,t| Float(s) }   # 3
+      r.coercion Integer, Symbol, [Float, String]           # 4
+    end
+    
+The last rule specifies a convertion path, through intermediate domains. The 
+complete rule specifies that applying the following path will work
+
+    Integer -> Float -> String -> Symbol
+            #3       #2        #1
+ 
+Indeed,
+
+    rules.coerce(12, Symbol)      # => :"12.0" 
+  
+### Semantics of <code>belongs\_to?</code> and <code>subdomain?</code> 
 
 The pseudo-code given above relies on two main abstractions. Suppose the user 
 makes a call to <code>coerce(value, requested_domain)</code>:
@@ -305,6 +376,8 @@ makes a call to <code>coerce(value, requested_domain)</code>:
 
 * <code>subdomain?(SourceDomain,TargetDomain)</code> is true iif
   * <code>SourceDomain == TargetDomain</code> yields true
+  * TargetDomain respond to <code>:superdomain_of?</code> and answers true on 
+    SourceDomain 
   * SourceDomain and TargetDomain are both classes and the latter is a super 
     class of the former 
     
@@ -334,4 +407,55 @@ makes a call to <code>coerce(value, requested_domain)</code>:
         # this is your last change, an Myrrha::Error will be raised if you fail
       end
       
-    end    
+    end
+
+### Factoring domains through specialization by constraint
+
+Specialization by constraint (SByC) is a theory of types for which the following
+rules hold:
+
+* A type (aka domain) is a set of values
+* A sub-type is a subset
+* A sub-type can therefore be specified through a predicate on the super domain
+
+For example, "positive integers" is a sub type of "integers" where the predicate
+is "value > 0". 
+
+Myrrha comes with a small feature allowing you to create types 'ala' SByC:
+
+    PosInt = Myrrha.domain(Integer){|i| i > 0}
+    PosInt.name       # => "PosInt"
+    PosInt.class      # => Class
+    PosInt.superclass # => Integer
+    PosInt.ancestors  # => [PosInt, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
+    PosInt === 10     # => true
+    PosInt === -1     # => false
+    PosInt.new(10)    # => 10
+    PosInt.new(-10)   # => ArgumentError, "Invalid value -10 for PosInt"
+    
+Note that the feature is very limited, and is not intended to provide a truly
+coherent typing framework. For example:
+
+    10.is_a?(PosInt)    # => false
+    10.kind_of?(PosInt) # => false 
+      
+Instead, Myrrha domains are only provided as an helper to build sound coercions 
+rules easily while 1) keeping a Class-based approach to source and target 
+domains and 2) having friendly error messages 3) really supporting true 
+reasoning on types and value:
+
+    # Only a rule that converts String to Integer
+    rules = Myrrha.coercions do |r|
+      r.coercion String, Integer, lambda{|s,t| Integer(s)}  
+    end 
+    
+    # it succeeds on both integers and positive integers
+    rules.coerce("12", Integer)   # => 12
+    rules.coerce("12", PosInt)    # => 12
+    
+    # and correctly fails in each case!
+    rules.coerce("-12", Integer)  # => -12
+    rules.coerce("-12", PosInt)   # => ArgumentError, "Invalid value -12 for PosInt"
+    
+    
+    

data/examples/coerce.rb

@@ -1,26 +1,46 @@
 require 'myrrha/with_core_ext'
 require 'myrrha/coerce'
 
-# it works on numerics
+# NilClass -> _Anything_ returns nil, always
+coerce(nil, Integer)              # => nil
+
+# Object -> String, via ruby's String()
+coerce("hello", String)           # => "hello"
+coerce(:hello, String)            # => "hello"
+
+# String -> Numeric, through ruby's Integer() and Float()
 coerce("12", Integer)             # => 12
 coerce("12.0", Float)             # => 12.0
 
-# but also on regexp (through Regexp.compile)
+# String -> Numeric is smart enough:
+coerce("12", Numeric)             # => 12 (Integer)
+coerce("12.0", Numeric)           # => 12.0 (Float)
+
+# String -> Regexp, through Regexp.compile
 coerce("[a-z]+", Regexp)          # => /[a-z]+/
 
-# and, yes, on Boolean (sorry Matz!)
+# String -> Symbol, through to_sym
+coerce("hello", Symbol)           # => :hello 
+
+# String -> Boolean (hum, sorry Matz!)
 coerce("true", Boolean)           # => true
 coerce("false", Boolean)          # => false
 
-# and on date and time (through Date/Time.parse)  
+# String -> Date, through Date.parse  
 require 'date'
-require 'time'
 coerce("2011-07-20", Date)        # => #<Date: 2011-07-20 (4911525/2,0,2299161)>  
+
+# String -> Time, through Time.parse (just in time issuing of require('time'))
 coerce("2011-07-20 10:57", Time)  # => 2011-07-20 10:57:00 +0200
 
-# why not on URI?
+# String -> URI, through URI.parse
 require 'uri'
-coerce('http://google.com', URI)  # => #<URI::HTTP:0x8281ce0 URL:http://google.com>
+coerce('http://google.com', URI)  # => #<URI::HTTP:0x8281ce0 URL:http://google.com>    
+
+# String -> Class and Module through constant lookup
+coerce("Integer", Class)          # => Integer
+coerce("Myrrha::Version", Module) # => Myrrha::Version
 
-# on nil, it always returns nil
-coerce(nil, Integer)              # => nil
+# Symbol -> Class and Module through constant lookup
+coerce(:Integer, Class)           # => Integer
+coerce(:Enumerable, Module)       # => Enumerable

data/examples/sbyc_domain.rb

@@ -0,0 +1,38 @@
+require 'myrrha'
+
+PosInt = Myrrha.domain(Integer){|i| i>0}
+
+###
+  
+PosInt.class
+PosInt.superclass
+PosInt.ancestors
+PosInt === 10
+PosInt === -1
+PosInt.new(10)
+begin
+  PosInt.new(-10)
+  raise "Unexpected case: PosInt.new(-10) succeeds"
+rescue ArgumentError => ex
+  puts ex.message
+end
+
+###
+
+10.is_a?(PosInt)
+10.kind_of?(PosInt)
+
+###
+
+rules = Myrrha.coercions do |r|
+  r.coercion String, Integer, lambda{|s,t| Integer(s)}  
+end 
+rules.coerce("12", Integer)
+rules.coerce("12", PosInt)
+rules.coerce("-12", Integer)
+begin
+  rules.coerce("-12", PosInt)
+  raise "Unexpected case: rules.coerce('-12', PosInt) succeeds"
+rescue Myrrha::Error => ex
+  puts ex.message
+end

data/lib/myrrha.rb

@@ -8,6 +8,23 @@ module Myrrha
   #
   class Error < StandardError; end
   
+  #
+  # Creates a domain instance by specialization by constraint
+  #
+  # @param [Class] superdom the superdomain of the created domain
+  # @param [Proc] pred the domain predicate
+  # @return [Class] the created domain
+  #
+  def self.domain(superdom = Object, subdoms=nil, &pred) 
+    dom = Class.new(superdom).extend(Domain)
+    dom.instance_eval {
+      @sub_domains = subdoms 
+      @super_domain = superdom
+      @predicate = pred
+    }
+    dom
+  end
+  
   #
   # Builds a set of coercions rules. 
   #
@@ -26,6 +43,58 @@ module Myrrha
   end
     
   # 
+  # Encapsulates class methods of created domains
+  #
+  module Domain
+    
+    #
+    # Creates a new instance of this domain
+    #
+    def new(*args)
+      if (args.size == 1) && (superclass === args.first)
+        if self === args.first
+          args.first
+        else
+          raise ArgumentError, "Invalid value #{args.join(' ')} for #{self}"
+        end
+      elsif superclass.respond_to?(:new)
+        new(super(*args))
+      else
+        raise ArgumentError, "Invalid value #{args.join(' ')} for #{self}"
+      end
+    end
+    
+    # (see Class.superclass)
+    def superclass
+      @super_domain
+    end
+    
+    #
+    # Checks if `value` belongs to this domain
+    # 
+    def ===(value)
+      (superclass === value) && @predicate.call(value)
+    end
+    
+    #
+    # Returns true if clazz if an explicit sub domain of self or if it's the
+    # case in Ruby.
+    #
+    def superdomain_of?(child)
+      Array(@sub_domains).include?(child)
+    end
+    
+    #
+    # Returns the specialization by constraint predicate
+    #
+    # @return [Proc] the domain predicate
+    #  
+    def predicate
+      @predicate
+    end
+    
+  end # module Domain
+    
   # Defines a set of coercion rules
   #
   class Coercions
@@ -36,11 +105,12 @@ module Myrrha
     #
     # Creates an empty list of coercion rules
     #
-    def initialize(upons = [], rules = [], fallbacks = [])
+    def initialize(upons = [], rules = [], fallbacks = [], main_target_domain = nil)
       @upons = upons
       @rules = rules
       @fallbacks = fallbacks
       @appender = :<<
+      @main_target_domain = main_target_domain
       yield(self) if block_given?
     end
     
@@ -183,11 +253,16 @@ module Myrrha
       error = nil
       each_rule do |from,to,converter|
         next unless from.nil? or belongs_to?(value, from, target_domain)
-        next unless to.nil?   or subdomain?(to, target_domain)
         begin
-          catch(:nextrule){
-            return convert(value, target_domain, converter)
-          }
+          catch(:nextrule) do
+            if to.nil? or subdomain?(to, target_domain)
+              got = convert(value, target_domain, converter)
+              return got
+            elsif subdomain?(target_domain, to)
+              got = convert(value, to, converter)
+              return got if belongs_to?(got, target_domain)
+            end
+          end
         rescue => ex
           error = ex.message unless error
         end
@@ -233,10 +308,15 @@ module Myrrha
     #         otherwise.
     #
     def subdomain?(child, parent)
-      return true if child == parent
-      (child.respond_to?(:superclass) && child.superclass) ? 
-        subdomain?(child.superclass, parent) :
+      if child == parent
+        true
+      elsif parent.respond_to?(:superdomain_of?)
+        parent.superdomain_of?(child)
+      elsif child.respond_to?(:superclass) && child.superclass 
+        subdomain?(child.superclass, parent)
+      else 
         false
+      end
     end
     
     #
@@ -246,7 +326,7 @@ module Myrrha
     # @return [Coercions] a copy of this set of rules
     # 
     def dup
-      Coercions.new(@upons.dup, @rules.dup, @fallbacks.dup)
+      Coercions.new(@upons.dup, @rules.dup, @fallbacks.dup, main_target_domain)
     end
     
     private
@@ -273,6 +353,9 @@ module Myrrha
     def convert(value, target_domain, converter)
       if converter.respond_to?(:call)
         converter.call(value, target_domain)
+      elsif converter.is_a?(Array)
+        path = converter + [target_domain]
+        path.inject(value){|cur,ndom| coerce(cur, ndom)}
       else
         raise ArgumentError, "Unable to use #{converter} for coercing"
       end

data/lib/myrrha/coerce.rb

@@ -2,29 +2,12 @@ require 'myrrha'
 module Myrrha
   
   #
-  # Defines the missing Boolean type.
+  # Defines the missing Boolean as a Myrrha's domain
   #
-  # This module mimics a Ruby missing Boolean type. 
-  #
-  module Boolean
+  Boolean = Myrrha.domain(Object, [TrueClass, FalseClass]){|x| 
+    (x==true) || (x==false)
+  }
 
-    #
-    # Returns Object, as the superclass of Boolean
-    #
-    # @return [Class] Object
-    #
-    def self.superclass; Object; end
-      
-    #
-    # Returns true if `val` is <code>true</code> or <code>false</code>, false 
-    # otherwise.
-    #
-    def self.===(val)
-      (val == true) || (val == false)
-    end
-    
-  end # module Boolean
-  
   #
   # Coerces _s_ to a Boolean
   #
@@ -48,6 +31,14 @@ module Myrrha
   # Defines basic coercions for Ruby, mostly from String 
   Coerce = coercions do |g|
     
+    # Returns a constant denoted by `s`
+    def g.constant_lookup(s, target_domain)
+      found = (s.split('::') - [""]).inject(Kernel){|cur,n| 
+        cur.const_get(n.to_sym)
+      }
+      belongs_to?(found, target_domain) ? found : throw(:nextrule)
+    end
+    
     # NilClass should return immediately
     g.upon(NilClass) do |s,t| 
       nil
@@ -59,12 +50,18 @@ module Myrrha
     end
     
     # Specific basic rules
-    g.coercion String, Integer, lambda{|s,t| Integer(s)        }
-    g.coercion String,   Float, lambda{|s,t| Float(s)          }
-    g.coercion String, Boolean, lambda{|s,t| Boolean(s)        }
-    g.coercion Integer,  Float, lambda{|s,t| Float(s)          }
-    g.coercion String,  Symbol, lambda{|s,t| s.to_sym          }
-    g.coercion String,  Regexp, lambda{|s,t| Regexp.compile(s) }
+    g.coercion Object,  String, lambda{|s,t| String(s)                     }
+    g.coercion String, Integer, lambda{|s,t| Integer(s)                    }
+    g.coercion String,   Float, lambda{|s,t| Float(s)                      }
+    g.coercion String, Boolean, lambda{|s,t| Boolean(s)                    }
+    g.coercion Integer,  Float, lambda{|s,t| Float(s)                      }
+    g.coercion String,  Symbol, lambda{|s,t| s.to_sym                      }
+    g.coercion String,  Regexp, lambda{|s,t| Regexp.compile(s)             }
+    g.coercion Symbol,   Class, lambda{|s,t| g.constant_lookup(s.to_s, t)  }
+    g.coercion Symbol,  Module, lambda{|s,t| g.constant_lookup(s.to_s, t)  }
+    g.coercion String,   Class, lambda{|s,t| g.constant_lookup(s, t)       }
+    g.coercion String,  Module, lambda{|s,t| g.constant_lookup(s, t)       }
+    g.coercion String,    Time, lambda{|s,t| require 'time'; Time.parse(s) }
       
     # By default, we try to invoke :parse on the class 
     g.fallback(String) do |s,t| 

data/lib/myrrha/version.rb

@@ -2,7 +2,7 @@ module Myrrha
   module Version
   
     MAJOR = 1
-    MINOR = 0
+    MINOR = 1
     TINY  = 0
   
     def self.to_s

data/myrrha.gemspec

@@ -127,7 +127,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency("bundler", "~> 1.0")
   s.add_development_dependency("rspec", "~> 2.6.0")
   s.add_development_dependency("yard", "~> 0.7.2")
-  s.add_development_dependency("bluecloth", "~> 2.0.9")
+  s.add_development_dependency("bluecloth", "~> 2.1.0")
   s.add_development_dependency("wlang", "~> 0.10.1")
   s.add_development_dependency("noe", "~> 1.3.0")
   

data/myrrha.noespec

@@ -9,7 +9,7 @@ variables:
   upper:
     Myrrha
   version:
-    1.0.0
+    1.1.0
   summary: |-
     Myrrha provides the coercion framework which is missing to Ruby, IMHO.
   description: |-
@@ -29,7 +29,7 @@ variables:
     - {name: bundler,      version: "~> 1.0",    groups: [development]}
     - {name: rspec,        version: "~> 2.6.0",  groups: [development]}
     - {name: yard,         version: "~> 0.7.2",  groups: [development]}
-    - {name: bluecloth,    version: "~> 2.0.9",  groups: [development]}
+    - {name: bluecloth,    version: "~> 2.1.0",  groups: [development]}
     - {name: wlang,        version: "~> 0.10.1", groups: [development]}
     - {name: noe,          version: "~> 1.3.0",  groups: [development]}
   rake_tasks:

data/spec/coercions/test_dup.rb

@@ -16,6 +16,13 @@ module Myrrha
       dupped.coerce("12", Float).should eql(12.0)
       lambda{ rules.coerce("12", Float) }.should raise_error(Myrrha::Error)
     end
+    
+    it "should not forget main_target_domain" do
+      rules = Coercions.new do |r|
+        r.main_target_domain = Integer
+      end
+      rules.dup.main_target_domain.should eql(Integer)
+    end
       
   end
 end

data/spec/coercions/test_subdomain.rb

@@ -1,11 +1,12 @@
 require 'spec_helper'
 module Myrrha
   describe "Coercions#subdomain?" do
-    let(:graph){ Coercions.new }
+    let(:r){ Coercions.new }
     
     specify {
-      graph.subdomain?(Symbol, Object).should be_true
+      r.subdomain?(Symbol, Object).should be_true
+      r.subdomain?(Class, Module).should be_true
     }
-      
+    
   end
 end

data/spec/myrrha/test_coercions.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+describe "Myrrha.coercions" do
+  
+  it "should support using user-defined domains" do
+    name = Myrrha.domain{|s| s.is_a?(Symbol)}
+    rules = Myrrha.coercions do |r|
+      r.coercion String, name, lambda{|s,t| s.to_sym}
+      r.coercion name, String, lambda{|s,t| s.to_s}
+    end
+    rules.coerce("hello", name).should eq(:hello)
+    rules.coerce(:hello, String).should eq("hello")
+  end
+  
+end

data/spec/myrrha/test_domain.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+module Myrrha
+  describe "#domain" do
+    
+    specify "the basic contract" do
+      subject = Myrrha.domain{|s| s == 12}
+      subject.should be_a(Class) 
+      subject.superclass.should eq(Object)
+      (subject === 12).should be_true
+      (subject === 13).should be_false
+    end
+    
+    specify "with a ruby superclass" do
+      subject = Myrrha.domain(Integer){|i| i > 0}
+      subject.should be_a(Class) 
+      subject.superclass.should eq(Integer)
+      (subject === 12).should be_true
+      (subject === 0).should be_false
+    end
+    
+    describe "A factored sub domain of Integer" do
+      PosInt = Myrrha.domain(Integer){|i| i > 0}
+      specify("#name") {
+        PosInt.name.should eq("Myrrha::PosInt")
+      }
+      specify("#new") {
+        PosInt.new(12).should eq(12)
+        lambda {
+          PosInt.new(0)
+        }.should raise_error(ArgumentError)
+      }
+      specify("#superclass"){
+        PosInt.superclass.should eql(Integer)
+      }
+      specify("#superdomain_of?"){
+        PosInt.superdomain_of?(Object).should be_false
+        PosInt.superdomain_of?(Integer).should be_false
+      }
+      it "should be usable in a case" do
+        [-12, 12].collect{|i|
+          case i
+          when PosInt
+            :posint
+          when Integer
+            :integer
+          end
+        }.should eq([:integer, :posint])
+      end
+    end
+      
+    describe "A factored sub domain of a user-defined Class" do
+      class Color
+        attr_reader :r
+        attr_reader :g
+        attr_reader :b
+        def initialize(r,g,b)
+          raise ArgumentError unless [r,g,b].all?{|i| i.is_a?(Integer)}
+          @r, @g, @b = r, g, b
+        end
+      end
+      RedToZero = Myrrha.domain(Color){|c| c.r == 0}
+      specify("#===") {
+        (RedToZero === Color.new(0,1,1)).should be_true
+        (RedToZero === Color.new(1,1,1)).should be_false
+      }
+      specify("#new") {
+        RedToZero.new(Color.new(0,1,1)).should be_a(Color)
+        RedToZero.new(0, 1, 1).should be_a(Color)
+        lambda{
+          RedToZero.new(Color.new(1,1,1))
+        }.should raise_error(ArgumentError)
+        lambda{
+          RedToZero.new(1, 1, 1)
+        }.should raise_error(ArgumentError)
+      }
+    end
+    
+  end
+end

data/spec/spec_helper.rb

@@ -3,7 +3,6 @@ require 'myrrha/with_core_ext'
 require 'myrrha/coerce'
 require 'myrrha/to_ruby_literal'
 require 'date'
-require 'time'
 require 'shared/a_value'
 
 unless defined?(SAFE_VALUES)

data/spec/test_coerce.rb

@@ -8,6 +8,18 @@ describe "::Ruby's coercion " do
     end
   end
   
+  describe "to String" do
+    specify "from Integer" do
+      coerce(12,     String).should eql("12")
+    end
+    specify "from String" do
+      coerce("12",   String).should eql("12")
+    end
+    specify "from NilClass" do
+      coerce(nil,   String).should be_nil
+    end
+  end
+  
   describe "to Integer" do
     specify "from Integer" do
       coerce(12,     Integer).should eql(12)
@@ -62,6 +74,20 @@ describe "::Ruby's coercion " do
       lambda{coerce("abc", Boolean)}.should raise_error(Myrrha::Error)
     end
   end
+  
+  describe "to TrueClass" do
+    specify "from String" do
+      coerce("true", TrueClass).should eql(true)
+      lambda{ coerce("false", TrueClass) }.should raise_error(Myrrha::Error)
+    end
+  end
+  
+  describe "to FalseClass" do
+    specify "from String" do
+      coerce("false", FalseClass).should eql(false)
+      lambda{ coerce("true", FalseClass) }.should raise_error(Myrrha::Error)
+    end
+  end
 
   describe "to Date" do
     let(:expected){ Date.parse("2011-07-20") }
@@ -102,6 +128,38 @@ describe "::Ruby's coercion " do
       coerce("http://www.google.com/", URI).should eql(URI.parse("http://www.google.com/"))
     end
   end
+
+  describe "to Module" do
+    specify "from String" do
+      coerce("Kernel", Module).should eql(Kernel)
+      coerce("::Kernel", Module).should eql(Kernel)
+      coerce("Myrrha::Version", Module).should eql(Myrrha::Version)
+      coerce("::Myrrha::Version", Module).should eql(Myrrha::Version)
+      coerce("Myrrha::Coercions", Module).should eql(Myrrha::Coercions)
+    end
+    specify "from Symbol" do
+      coerce(:Kernel, Module).should eql(Kernel)
+    end
+    it "should raise error if not a module" do
+      lambda{
+        coerce("Myrrha::VERSION", Module)
+      }.should raise_error(Myrrha::Error)
+    end
+  end
+  
+  describe "to Class" do
+    specify "from String" do
+      coerce("Myrrha::Coercions", Class).should eql(Myrrha::Coercions)
+    end
+    specify "from Symbol" do
+      coerce(:Integer, Class).should eql(Integer)
+    end
+    it "should raise error if not a module" do
+      lambda{
+        coerce("Myrrha::Version", Class)
+      }.should raise_error(Myrrha::Error)
+    end
+  end
   
   specify "to a class that respond to coerce" do
     class Coerceable

data/spec/test_myrrha.rb

@@ -84,4 +84,41 @@ describe Myrrha do
     rules.coerce("hello", Symbol).should eq(:HELLO)
   end
   
+  it "should used superdomain rules in an optimistic strategy" do
+    rules = Myrrha.coercions do |c|
+      c.coercion String, Numeric, lambda{|s,t| Integer(s)}
+    end
+    rules.coerce("12", Integer).should eql(12)
+    lambda{ rules.coerce("12", Float) }.should raise_error(Myrrha::Error)
+  end
+  
+  describe "path convertions" do
+    let(:rules){
+      Myrrha.coercions do |c|
+        c.coercion Integer, String, lambda{|s,t| s.to_s}
+        c.coercion String,  Float,  lambda{|s,t| Float(s)}
+        c.coercion Integer, Float,  [String]
+        c.coercion Float,   String, lambda{|s,t| s.to_s} 
+        c.coercion String,  Symbol, lambda{|s,t| s.to_sym}
+        c.coercion Integer, Symbol, [Float, String]
+      end
+    }
+    it "should work with a simple and single" do
+      rules.coerce(12, Float).should eql(12.0)
+    end
+    it "should work with a complex and multiple path" do
+      rules.coerce(12, Symbol).should eql(:"12.0")
+    end
+  end
+  
+  specify "path convertions (from CHANGELOG)" do
+    rules = Myrrha.coercions do |r|
+      r.coercion String,  Symbol, lambda{|s,t| s.to_sym }
+      r.coercion Float,   String, lambda{|s,t| s.to_s   }
+      r.coercion Integer, Float,  lambda{|s,t| Float(s) }
+      r.coercion Integer, Symbol, [Float, String] 
+    end
+    rules.coerce(12, Symbol).should eql(:"12.0") 
+  end
+  
 end

data/tasks/examples.rake

@@ -6,6 +6,7 @@ task :examples do
       print '.'
     else
       print '*'
+      raise "Example #{file} failed." 
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: myrrha
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-22 00:00:00.000000000Z
+date: 2011-07-28 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &77746150 !ruby/object:Gem::Requirement
+  requirement: &85576310 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *77746150
+  version_requirements: *85576310
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &77745820 !ruby/object:Gem::Requirement
+  requirement: &85575520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *77745820
+  version_requirements: *85575520
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &77745530 !ruby/object:Gem::Requirement
+  requirement: &85574670 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 2.6.0
   type: :development
   prerelease: false
-  version_requirements: *77745530
+  version_requirements: *85574670
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &77745240 !ruby/object:Gem::Requirement
+  requirement: &85573700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,21 +54,21 @@ dependencies:
         version: 0.7.2
   type: :development
   prerelease: false
-  version_requirements: *77745240
+  version_requirements: *85573700
 - !ruby/object:Gem::Dependency
   name: bluecloth
-  requirement: &77744950 !ruby/object:Gem::Requirement
+  requirement: &85572820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.0.9
+        version: 2.1.0
   type: :development
   prerelease: false
-  version_requirements: *77744950
+  version_requirements: *85572820
 - !ruby/object:Gem::Dependency
   name: wlang
-  requirement: &77744660 !ruby/object:Gem::Requirement
+  requirement: &85550940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,10 +76,10 @@ dependencies:
         version: 0.10.1
   type: :development
   prerelease: false
-  version_requirements: *77744660
+  version_requirements: *85550940
 - !ruby/object:Gem::Dependency
   name: noe
-  requirement: &77744360 !ruby/object:Gem::Requirement
+  requirement: &85550220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -87,7 +87,7 @@ dependencies:
         version: 1.3.0
   type: :development
   prerelease: false
-  version_requirements: *77744360
+  version_requirements: *85550220
 description: ! "Myrrha provides the coercion framework which is missing to Ruby, IMHO.
   Coercions\nare simply defined as a set of rules for converting values from source
   to target\ndomains (in an abstract sense). As a typical and useful example, it comes
@@ -113,6 +113,7 @@ files:
 - examples/String#toXXX.rb
 - examples/examples_helper.rb
 - examples/coerce_foo2.rb
+- examples/sbyc_domain.rb
 - examples/to_ruby_literal_foo3.rb
 - examples/to_ruby_literal_noext.rb
 - examples/coerce_foo3.rb
@@ -123,6 +124,8 @@ files:
 - lib/myrrha/version.rb
 - lib/myrrha.rb
 - spec/spec_helper.rb
+- spec/myrrha/test_coercions.rb
+- spec/myrrha/test_domain.rb
 - spec/test_myrrha.rb
 - spec/test_to_ruby_literal.rb
 - spec/test_value.rb
@@ -164,7 +167,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -508754947
+      hash: -900430961
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -173,15 +176,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -508754947
+      hash: -900430961
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.5
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Myrrha provides the coercion framework which is missing to Ruby, IMHO.
 test_files:
 - spec/spec_helper.rb
+- spec/myrrha/test_coercions.rb
+- spec/myrrha/test_domain.rb
 - spec/test_myrrha.rb
 - spec/test_to_ruby_literal.rb
 - spec/test_value.rb