myrrha 1.2.2 → 2.0.0

data/lib/myrrha/errors.rb

@@ -0,0 +1,12 @@
+module Myrrha
+
+  # Raised when a coercion fails
+  class Error < StandardError
+    attr_reader :cause
+    def initialize(msg, cause = $!)
+      super(msg)
+      @cause = cause
+    end
+  end
+
+end # module Myrrha

data/lib/myrrha/loader.rb

@@ -1 +0,0 @@
-

data/lib/myrrha/to_ruby_literal.rb

@@ -73,4 +73,4 @@ class Object
     block_given? ? yield : Myrrha.to_ruby_literal(self)
   end
 
-end if Myrrha.core_ext?
+end if Myrrha.core_ext?

data/lib/myrrha/version.rb

@@ -1,9 +1,9 @@
 module Myrrha
   module Version
 
-    MAJOR = 1
-    MINOR = 2
-    TINY  = 2
+    MAJOR = 2
+    MINOR = 0
+    TINY  = 0
 
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')

data/myrrha.noespec

@@ -1,6 +1,6 @@
 template-info:
-  name: "ruby"
-  version: 1.7.0
+  name: rubygem.noe
+  version: 1.7.4
   manifest:
     tasks/debug_mail.txt:
       safe-override: false
@@ -10,7 +10,7 @@ variables:
   upper:
     Myrrha
   version:
-    1.2.2
+    2.0.0
   summary: |-
     Myrrha provides the coercion framework which is missing to Ruby.
   description: |-

data/spec/coercions/test_append.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 module Myrrha
   describe "Coercions#append" do
     let(:rules){ Coercions.new }
-    
+
     it "should return the rules" do
       rules.append{|r| }.should eq(rules)
     end
-      
+
   end
-end
+end

data/spec/coercions/test_belongs_to.rb

@@ -2,20 +2,26 @@ require 'spec_helper'
 module Myrrha
   describe "Coercions#belongs_to?" do
     let(:rules){ Coercions.new }
-    
+
+    before(:all) do
+      class Coercions
+        public :belongs_to?
+      end
+    end
+
     specify "with a class" do
       rules.belongs_to?(12, Integer).should be_true
     end
-      
+
     specify "with a superclass" do
       rules.belongs_to?(12, Numeric).should be_true
     end
-      
+
     specify "with a proc or arity 1" do
       rules.belongs_to?(12, lambda{|x| x>10}).should be_true
       rules.belongs_to?(12, lambda{|x| x<10}).should be_false
     end
-      
+
     specify "with a proc or arity 2" do
       got = nil
       l = lambda{|x,t| got = t; t == l }
@@ -24,6 +30,6 @@ module Myrrha
       rules.belongs_to?(12, l, :nosuch).should be_false
       got.should eq(:nosuch)
     end
-      
+
   end
-end
+end

data/spec/coercions/test_convert.rb

@@ -2,16 +2,16 @@ require 'spec_helper'
 module Myrrha
   describe "Coercions#convert" do
     let(:graph){ Coercions.new }
-    
+
     subject{ graph.send(:convert, "value", String, converter) }
-      
+
     describe "when passed a proc of arity 2" do
       let(:converter){ lambda{|v,t| [v,t]} }
       it{ should eq(["value", String]) }
     end
-      
+
     describe "when passed an object that respond to call" do
-      let(:converter){ 
+      let(:converter){
         o = Object.new
         def o.call(arg, t); [arg, t]; end
         o
@@ -20,4 +20,4 @@ module Myrrha
     end
 
   end
-end
+end

data/spec/coercions/test_delegate.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Myrrha
+  describe Coercions, "delegate" do
+    let(:rules){ Coercions.new }
+
+    context 'without block' do
+      before{ rules.delegate(:to_a) }
+
+      it "should delegate if the method exists" do
+        rules.apply([1, 2, 3]).should eq([1, 2, 3])
+      end
+
+      it "should not delegate if the method does not exist" do
+        lambda{
+          rules.apply(self)
+        }.should raise_error(Myrrha::Error)
+      end
+    end
+
+    context 'with a block' do
+      before{ rules.delegate(:to_a){|v,_| v.to_a.reverse} }
+
+      it "should delegate if the method exists" do
+        rules.apply([1, 2, 3]).should eq([3,2,1])
+      end
+
+      it "should not delegate if the method does not exist" do
+        lambda{
+          rules.apply(self)
+        }.should raise_error(Myrrha::Error)
+      end
+    end
+
+  end
+end

data/spec/coercions/test_subdomain.rb

@@ -2,11 +2,17 @@ require 'spec_helper'
 module Myrrha
   describe "Coercions#subdomain?" do
     let(:r){ Coercions.new }
-    
+
+    before(:all) do
+      class Coercions
+        public :subdomain?
+      end
+    end
+
     specify {
       r.subdomain?(Symbol, Object).should be_true
       r.subdomain?(Class, Module).should be_true
     }
-    
+
   end
-end
+end

data/spec/domain/impl/test_behavior.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Myrrha
+  describe Domain, 'when included' do
+
+    let(:point){
+      Class.new{
+        include Myrrha::Domain::Impl.new([:r, :theta])
+
+        coercions do |c|
+          c.upon(NilClass)     {|v,t| new(0.0,0.0)                   }
+          c.coercion(String)   {|v,t| new(*v.split(',').map(&:to_f)) }
+          c.coercion(TrueClass){|v,t| throw :nextrule                }
+          c.fallback(TrueClass){|v,t| new(1.0, 1.0)                  }
+        end
+      }
+    }
+
+    let(:origin){ point.new(0.0, 0.0) }
+    let(:oneone){ point.new(1.0, 1.0) }
+
+    it 'installs the domain component names' do
+      point.component_names.should eq([:r, :theta])
+    end
+
+    it 'installs the component readers' do
+      origin.r.should eq(0.0)
+      origin.theta.should eq(0.0)
+    end
+
+    it 'has coercions properly installed' do
+      point.coercions.main_target_domain.should eq(point)
+    end
+
+    it 'supports expected coercions' do
+      point.coerce(nil).should eq(origin)
+      point.coerce(true).should eq(oneone)
+      point.coerce("2.0,3.0").should eq(point.new(2.0, 3.0))
+    end
+
+  end
+end

data/spec/domain/impl/test_value_methods.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+module Myrrha
+  module Domain
+    class Impl
+      describe ValueMethods do
+
+        let(:domain){
+          Class.new{
+            def self.component_names
+              [:a, :b]
+            end
+            include ValueMethods
+            attr_reader :a, :b
+            def initialize(a, b)
+              @a, @b = a, b
+            end
+          }
+        }
+
+        let(:object){ domain.new(1, 2) }
+
+        describe "==" do
+          subject{ object == other }
+
+          context 'with itself' do
+            let(:other){ object }
+            it{ should be_true }
+          end
+
+          context 'with dupped' do
+            let(:other){ object.dup }
+            it{ should be_true }
+          end
+
+          context 'with equivalent' do
+            let(:other){ domain.new(1, 2) }
+            it{ should be_true }
+          end
+
+          context 'with equivalent of a subclass' do
+            let(:other){ Class.new(domain).new(1, 2) }
+            it{ should be_true }
+          end
+
+          context 'with non equivalent' do
+            let(:other){ domain.new(1, 3) }
+            it{ should be_false }
+          end
+
+          context 'with other class' do
+            let(:other){ self }
+            it{ should be_false }
+          end
+        end
+
+        describe "eql?" do
+          subject{ object.eql?(other) }
+
+          context 'with itself' do
+            let(:other){ object }
+            it{ should be_true }
+          end
+
+          context 'with dupped' do
+            let(:other){ object.dup }
+            it{ should be_true }
+          end
+
+          context 'with equivalent' do
+            let(:other){ domain.new(1, 2) }
+            it{ should be_true }
+          end
+
+          context 'with equivalent of a subclass' do
+            let(:other){ Class.new(domain).new(1, 2) }
+            it{ should be_false }
+          end
+
+          context 'with non equivalent' do
+            let(:other){ domain.new(1, 3) }
+            it{ should be_false }
+          end
+
+          context 'with other class' do
+            let(:other){ self }
+            it{ should be_false }
+          end
+        end
+
+        describe "hash" do
+          subject{ object.hash }
+
+          it 'should be consistent with equal' do
+            subject.should eq(domain.new(1,2).hash)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/domain/sbyc/test_behavior.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+module Myrrha
+  module Domain
+    describe SByC, 'when used by extension' do
+
+      class NegInt < Integer
+        extend Myrrha::Domain::SByC.new(Integer, [], lambda{|i| i<0})
+      end
+
+      specify("#name") {
+        NegInt.name.should eq("Myrrha::Domain::NegInt")
+      }
+
+      specify("#new") {
+        NegInt.new(-12).should eq(-12)
+        lambda {
+          NegInt.new(12)
+        }.should raise_error(ArgumentError)
+      }
+
+      specify("#superclass"){
+        NegInt.superclass.should eql(Integer)
+      }
+
+      specify("#superdomain_of?"){
+        NegInt.superdomain_of?(Object).should be_false
+        NegInt.superdomain_of?(Integer).should be_false
+      }
+
+      specify("#coercions"){
+        NegInt.coercions.should be_a(Myrrha::Coercions)
+        NegInt.coercions.main_target_domain.should eq(NegInt)
+      }
+
+      it "should be usable in a case" do
+        [-12, 12].map{|i|
+          case i
+          when NegInt  then :negint
+          when Integer then :integer
+          end
+        }.should eq([:negint, :integer])
+      end
+
+    end
+  end
+end

data/spec/domain/test_sbyc.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+module Myrrha
+  module Domain
+    describe ".sbyc" do
+    
+      specify "the basic contract" do
+        subject = Myrrha::Domain.sbyc{|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.sbyc(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.sbyc(Integer){|i| i > 0}
+        specify("#name") {
+          PosInt.name.should eq("Myrrha::Domain::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.sbyc(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
+end