domain 1.0.0.rc1 → 1.0.0.rc2

data/domain.noespec

@@ -7,7 +7,7 @@ variables:
   upper:
     Domain
   version:
-    1.0.0.rc1
+    1.0.0.rc2
   summary: |-
     Provide tools for implementing domains (aka data types)
   description: |-

data/lib/domain.rb

@@ -10,4 +10,6 @@ module Domain
   include API
   extend  Factory
 
+  TRUE_PREDICATE = lambda{|*args,&bl| true }
+
 end # module Domain

data/lib/domain/api.rb

@@ -1,16 +1,6 @@
 module Domain
   module API
 
-    # Returns the domain predicate, nil if no such predicate
-    #
-    # @return [Proc]
-    #   the domain predicate (possibly nil)
-    #
-    # @api public
-    def predicate
-      nil
-    end
-
     # Returns the super domain of `self`.
     #
     # @return [Class]
@@ -44,5 +34,18 @@ module Domain
       sub_domains.include?(dom)
     end
 
+    # Raises a type error for `args`.
+    #
+    # @param [Array] args
+    #   arguments passed to `new` or another factory method
+    # @raise TypeError
+    #
+    # @api protected
+    def domain_error!(first, *args)
+      first = [first]+args unless args.empty?
+      raise TypeError, "Can't convert `#{first.inspect}` into #{self}", caller
+    end
+    protected :domain_error!
+
   end # module API
 end # module Domain

data/lib/domain/factory/reuse.rb

@@ -2,23 +2,25 @@ module Domain
   module Reuse
 
     def self.new(reuse_domain, predicate = nil, &bl)
-      ImplDomain.new [ Methods, class_module(predicate || bl) ],
-                     [ instance_module(reuse_domain) ]
+      predicate = predicate || bl || Domain::TRUE_PREDICATE
+      DomainFactory.factor [ Helpers, class_module(reuse_domain, predicate) ],
+                           [ instance_module(reuse_domain) ]
     end
 
-    def self.class_module(predicate)
-      Module.new{ define_method(:predicate){ predicate } }
+    def self.class_module(reuse_domain, predicate)
+      Module.new{
+        define_method(:predicate) do
+          predicate
+        end
+        define_method(:domain_check!) do |i|
+          domain_error!(i) unless reuse_domain===i && predicate.call(i)
+        end
+      }
     end
 
     def self.instance_module(reuse_domain)
       Module.new{
         define_method(:initialize) do |arg|
-          unless reuse_domain===arg
-            raise ArgumentError, "#{reuse_domain} expected, got `#{arg.inspect}`"
-          end
-          if self.class.predicate && !self.class.predicate.call(arg)
-            raise ArgumentError, "Invalid value `#{arg.inspect}` for `#{self}`"
-          end
           @reused_instance = arg
         end
         define_method(:reused_instance) do
@@ -29,25 +31,21 @@ module Domain
       }
     end
 
-    module Methods
+    module Helpers
 
       def reuse(*methods)
         methods.each do |m|
-          define_method(m) do |*args, &bl|
-            reused_instance.send(m, *args, &bl)
-          end
+          define_method(m){|*args, &bl| reused_instance.send(m, *args, &bl)}
         end
       end
 
       def recoat(*methods)
         methods.each do |m|
-          define_method(m) do |*args, &bl|
-            self.class.new reused_instance.send(m, *args, &bl)
-          end
+          define_method(m){|*args, &bl| self.class.new reused_instance.send(m, *args, &bl)}
         end
       end
 
-    end # module Methods
+    end # module Helpers
 
   end # module Reuse
 end # module Domain

data/lib/domain/factory/sbyc.rb

@@ -2,8 +2,32 @@ module Domain
   module SByC
 
     def self.new(super_domain = Object, predicate = nil, &bl)
-      FakeDomain.new(super_domain, [], predicate || bl)
+      predicate = predicate || bl || Domain::TRUE_PREDICATE
+      DomainFactory.factor [ Methods, class_module(super_domain, predicate) ]
     end
 
+    def self.class_module(super_domain, predicate)
+      Module.new{
+        define_method(:super_domain){ super_domain }
+        define_method(:predicate)   { predicate    }
+      }
+    end
+
+    module Methods
+
+      # Creates a new instance of this domain
+      def new(first = nil, *args)
+        return first if args.empty? && self===first
+        return new super(first, *args) if superclass.respond_to?(:new) && (superclass != Object)
+        domain_error!(first, *args)
+      end
+
+      # Checks if `value` belongs to this domain
+      def ===(value)
+        superclass===value && predicate.call(value)
+      end
+
+    end # module Methods
+
   end # module SByC
 end # module Domain

data/lib/domain/factory/scalar.rb

@@ -2,7 +2,7 @@ module Domain
   module Scalar
 
     def self.new(*component_names)
-      ImplDomain.new [], instance_module(component_names)
+      DomainFactory.factor [], instance_module(component_names)
     end
 
     def self.instance_module(component_names)

data/lib/domain/factory/union.rb

@@ -2,10 +2,34 @@ module Domain
   module Union
 
     def self.new(*sub_domains)
-      FakeDomain.new(Object, sub_domains, lambda{|t| sub_domains.any?{|d| d===t } })
+      DomainFactory.factor [ Methods, class_module(sub_domains) ]
     end
 
+    def self.class_module(sub_domains)
+      Module.new{
+        define_method(:sub_domains){ sub_domains }
+      }
+    end
+
+    module Methods
+
+      # Creates a new instance of this domain
+      def new(first = nil, *args)
+        return first if args.empty? && self===first
+        return new super(first, *args) if superclass.respond_to?(:new) && (superclass != Object)
+        domain_error!(first, *args)
+      end
+
+      def predicate
+        lambda{|value| sub_domains.any?{|d| d===value } }
+      end
+
+      # Checks if `value` belongs to this domain
+      def ===(value)
+        predicate.call(value)
+      end
+
+    end # module Methods
+
   end # class Union
 end # module Domain
-
-    

data/lib/domain/support.rb

@@ -1,3 +1,2 @@
 require_relative 'support/equalizer'
-require_relative 'support/fake_domain'
-require_relative 'support/impl_domain'
+require_relative 'support/domain_factory'

data/lib/domain/support/domain_factory.rb

@@ -0,0 +1,21 @@
+module Domain
+  module DomainFactory
+
+    def self.factor(c_methods = [], i_methods = [])
+      i_methods, c_methods = Array(i_methods), Array(c_methods).unshift(Domain)
+      Module.new{
+        # include all class methods first
+        c_methods.each{|c_m| include(c_m) }
+
+        # Ensure that classes that are extended will include all instance methods
+        define_singleton_method(:extend_object) do |obj|
+          if obj.is_a?(Class)
+            obj.module_eval{ i_methods.each{|i_m| include(i_m) } }
+          end
+          super(obj)
+        end
+      }
+    end
+
+  end # module DomainFactory
+end # module Domain

data/lib/domain/version.rb

@@ -3,7 +3,7 @@ module Domain
 
     MAJOR = 1
     MINOR = 0
-    TINY  = "0.rc1"
+    TINY  = "0.rc2"
 
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')

data/spec/factory/reuse_domain/test_domain_check.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Domain
+  describe Reuse, "domain_check!" do
+
+    it 'raises an ArgumentError when not correct reused instance' do
+      lambda{
+        List.domain_check!('foo')
+      }.should raise_error(TypeError)
+    end
+
+    it 'raises an ArgumentError when the predicate is not satisfied' do
+      lambda{
+        Tuple.domain_check!("foo" => :bar)
+      }.should raise_error(TypeError)
+    end
+
+  end
+end

data/spec/factory/reuse_domain/test_new.rb

@@ -10,17 +10,5 @@ module Domain
       Tuple.new(:foo => "bar").should be_a(Tuple)
     end
 
-    it 'raises an ArgumentError when not correct reused instance' do
-      lambda{
-        List.new("foo")
-      }.should raise_error(ArgumentError)
-    end
-
-    it 'raises an ArgumentError when the predicate is not satisfied' do
-      lambda{
-        Tuple.new("foo" => :bar)
-      }.should raise_error(ArgumentError)
-    end
-
   end
 end

data/spec/factory/sbyc_domain/test_new.rb

@@ -6,16 +6,16 @@ module Domain
       NegInt.new(-12).should eq(-12)
     end
 
-    it 'raises an argument error when the value does not satisfy the predicate' do
+    it 'raises a type error when the value does not satisfy the predicate' do
       lambda{
         NegInt.new(12)
-      }.should raise_error(ArgumentError)
+      }.should raise_error(TypeError)
     end
 
-    it 'raises an argument error when the value is not a superclazz value' do
+    it 'raises a type error when the value is not a superclazz value' do
       lambda{
         NegInt.new("bla")
-      }.should raise_error(ArgumentError)
+      }.should raise_error(TypeError)
     end
 
   end

data/spec/factory/union_domain/test_new.rb

@@ -7,10 +7,10 @@ module Domain
       Boolean.new(false).should be(false)
     end
 
-    it 'raises an argument error when the value is not a superclazz value' do
+    it 'raises a type when the value is not a superclazz value' do
       lambda{
         Boolean.new("12")
-      }.should raise_error(ArgumentError)
+      }.should raise_error(TypeError)
     end
 
   end

data/spec/fixtures/attr_list.rb

@@ -0,0 +1,12 @@
+module OrderedSet
+  extend Domain::Reuse::Helpers
+
+  reuse  :size
+  recoat :map
+end
+
+class AttrList
+  extend Domain::Reuse.new(Array)
+  include OrderedSet
+
+end

data/spec/shared/a_domain_class.rb

@@ -2,7 +2,6 @@ shared_examples_for 'a domain class' do
 
   it{ should be_a(Class)  }
 
-  it{ should respond_to(:predicate) }
   it{ should respond_to(:sub_domains) }
   it{ should respond_to(:super_domain) }
 

data/spec/spec_helper.rb

@@ -9,6 +9,7 @@ require_relative 'fixtures/boolean'
 require_relative 'fixtures/point'
 require_relative 'fixtures/list'
 require_relative 'fixtures/tuple'
+require_relative 'fixtures/attr_list'
 
 module Domain
 

data/spec/test_fixtures.rb

@@ -19,3 +19,13 @@ describe List do
   subject{ List }
   it_should_behave_like 'a domain class'
 end
+
+describe AttrList do
+  subject{ AttrList }
+
+  it_should_behave_like 'a domain class'
+
+  it 'should have OrderedSet helpers' do
+    AttrList.new([1, 2, 3]).map{|x| x*2}.should eq(AttrList.new([2, 4, 6]))
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: domain
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc1
+  version: 1.0.0.rc2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-27 00:00:00.000000000 Z
+date: 2012-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -66,9 +66,8 @@ files:
 - lib/domain/factory/union.rb
 - lib/domain/factory.rb
 - lib/domain/loader.rb
+- lib/domain/support/domain_factory.rb
 - lib/domain/support/equalizer.rb
-- lib/domain/support/fake_domain.rb
-- lib/domain/support/impl_domain.rb
 - lib/domain/support.rb
 - lib/domain/version.rb
 - lib/domain.rb
@@ -76,6 +75,7 @@ files:
 - Manifest.txt
 - Rakefile
 - README.md
+- spec/factory/reuse_domain/test_domain_check.rb
 - spec/factory/reuse_domain/test_new.rb
 - spec/factory/reuse_domain/test_predicate.rb
 - spec/factory/reuse_domain/test_recoat.rb
@@ -100,6 +100,7 @@ files:
 - spec/factory/union_domain/test_super_domain.rb
 - spec/factory/union_domain/test_super_domain_of.rb
 - spec/factory/union_domain/test_triple_equal.rb
+- spec/fixtures/attr_list.rb
 - spec/fixtures/boolean.rb
 - spec/fixtures/list.rb
 - spec/fixtures/neg_int.rb
@@ -139,6 +140,7 @@ signing_key:
 specification_version: 3
 summary: Provide tools for implementing domains (aka data types)
 test_files:
+- spec/factory/reuse_domain/test_domain_check.rb
 - spec/factory/reuse_domain/test_new.rb
 - spec/factory/reuse_domain/test_predicate.rb
 - spec/factory/reuse_domain/test_recoat.rb
@@ -163,6 +165,7 @@ test_files:
 - spec/factory/union_domain/test_super_domain.rb
 - spec/factory/union_domain/test_super_domain_of.rb
 - spec/factory/union_domain/test_triple_equal.rb
+- spec/fixtures/attr_list.rb
 - spec/fixtures/boolean.rb
 - spec/fixtures/list.rb
 - spec/fixtures/neg_int.rb

data/lib/domain/support/fake_domain.rb

@@ -1,38 +0,0 @@
-module Domain
-  module FakeDomain
-
-    def self.new(super_domain, sub_domains, predicate)
-      Module.new{
-        include Domain, Methods
-        define_method(:super_domain){ super_domain }
-        define_method(:sub_domains) { sub_domains  }
-        define_method(:predicate)   { predicate    }
-      }
-    end
-
-    module Methods
-
-      # Creates a new instance of this domain
-      def new(*args)
-        if (args.size == 1) && self===args.first
-          return args.first
-        elsif superclass.respond_to?(:new) && (superclass != Object)
-          return new super(*args)
-        end
-        args_error_on_new(args)
-      end
-
-      # Checks if `value` belongs to this domain
-      def ===(value)
-        value.is_a?(superclass) && predicate && predicate.call(value)
-      end
-
-    private
-
-      def args_error_on_new(args)
-        raise ArgumentError, "Invalid value #{args.join(' ')} for #{self}", caller
-      end
-
-    end # module Methods
-  end # module FakeDomain
-end # module Domain

data/lib/domain/support/impl_domain.rb

@@ -1,17 +0,0 @@
-module Domain
-  module ImplDomain
-
-    def self.new(c_methods = [], i_methods = [])
-      i_methods = Array(i_methods)
-      c_methods = Array(c_methods).unshift(Domain)
-      Module.new{
-        c_methods.each{|c_m| include(c_m)}
-        define_singleton_method(:extend_object) do |obj|
-          obj.module_eval{ i_methods.each{|i_m| include(i_m)} } if obj.is_a?(Class)
-          super(obj)
-        end
-      }
-    end
-
-  end # module ImplDomain
-end # module Domain