domain 0.0.1 → 1.0.0.rc1

data/lib/domain/version.rb

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

data/spec/factory/reuse_domain/test_new.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Domain
+  describe Reuse, "new" do
+
+    it 'returns an instance when correct reused instance' do
+      List.new([1, 2, 3]).should be_a(List)
+    end
+
+    it 'returns an instance when correct reused instance and valid predicate' do
+      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/reuse_domain/test_predicate.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Domain
+  describe Reuse, "predicate" do
+
+    it 'returns a Proc' do
+      Tuple.predicate.should be_a(Proc)
+    end
+
+  end
+end

data/spec/factory/reuse_domain/test_recoat.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Domain
+  describe Reuse, "recoat" do
+
+    let(:object){ List.new([1, 2, 3]) }
+
+    describe "map" do
+      subject{ object.map{|x| x*2} }
+
+      it{ should be_a(List) }
+      it{ should eq(List.new([2, 4, 6])) }
+    end
+
+    describe "reject" do
+      subject{ object.reject{|x| x%2 == 0} }
+
+      it{ should be_a(List) }
+      it{ should eq(List.new([1, 3])) }
+    end
+
+  end
+end

data/spec/factory/reuse_domain/test_reuse.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Domain
+  describe Reuse, "reuse" do
+
+    let(:object){ List.new([1, 2, 3]) }
+
+    describe "size" do
+      subject{ object.size }
+
+      it{ should eq(3) }
+    end
+
+    describe "empty?" do
+      subject{ object.empty? }
+
+      it{ should be_false }
+    end
+
+  end
+end

data/spec/factory/reuse_domain/test_values.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Domain
+  describe Reuse, "values" do
+
+    let(:object)        { List.new([1, 2, 3]) }
+    let(:another_object){ List.new([2, 3, 4]) }
+
+    it_should_behave_like 'a value object'
+
+  end
+end

data/spec/factory/sbyc_domain/test_new.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Domain
+  describe SByC, "new" do
+
+    it 'returns the value when it satisfies the predicate' do
+      NegInt.new(-12).should eq(-12)
+    end
+
+    it 'raises an argument error when the value does not satisfy the predicate' do
+      lambda{
+        NegInt.new(12)
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'raises an argument error when the value is not a superclazz value' do
+      lambda{
+        NegInt.new("bla")
+      }.should raise_error(ArgumentError)
+    end
+
+  end
+end

data/spec/factory/sbyc_domain/test_predicate.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Domain
+  describe SByC, "predicate" do
+
+    it 'returns a Proc' do
+      Boolean.predicate.should be_a(Proc)
+    end
+
+  end
+end

data/spec/factory/sbyc_domain/test_sub_domains.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Domain
+  describe SByC, "sub_domains" do
+
+    it 'returns the sub domains passed at construction' do
+      Boolean.sub_domains.should eq([TrueClass, FalseClass])
+    end
+
+    it 'defaults an empty array' do
+      NegInt.sub_domains.should eq([])
+    end
+
+  end
+end

data/spec/factory/sbyc_domain/test_super_domain.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Domain
+  describe SByC, "super_domain" do
+
+    it 'returns the super domain passed at construction' do
+      NegInt.super_domain.should be(Integer)
+    end
+
+  end
+end

data/spec/factory/sbyc_domain/test_super_domain_of.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Domain
+  describe SByC, "super_domain_of?" do
+
+    it 'returns true when a super domain' do
+      Boolean.should be_super_domain_of(TrueClass)
+    end
+
+    it 'returns false on itself' do
+      Boolean.should_not be_super_domain_of(Boolean)
+    end
+
+    it 'returns false when not a super domain' do
+      Boolean.should_not be_super_domain_of(Integer)
+    end
+
+  end
+end

data/spec/factory/sbyc_domain/test_triple_equal.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+module Domain
+  describe SByC, "===" do
+
+    it 'returns true when a proper value' do
+      (Boolean === true).should be_true
+      (Boolean === false).should be_true
+    end
+
+    it 'returns false when not a value' do
+      (Boolean === 1).should be_false
+    end
+
+    it 'returns false when a superclass value that satisfies the predicate' do
+      (NegInt === -1).should be_true
+    end
+
+    it 'returns false when a superclass value that do not satisfy the predicate' do
+      (NegInt === 1).should be_false
+    end
+
+  end
+end

data/spec/factory/scalar_domain/test_component_reader.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Domain
+  describe Scalar, "component reader" do
+
+    let(:point){ Point.new(1, 2) }
+
+    it 'has a `x` reader' do
+      point.x.should eq(1)
+    end
+
+    it 'has a `y` reader' do
+      point.y.should eq(2)
+    end
+
+  end
+end

data/spec/factory/scalar_domain/test_hash.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Domain
+  describe Scalar, "hash" do
+
+    let(:point){ Point.new(1, 2) }
+
+    subject{ point.hash }
+
+    it 'should equal the hash of an equivalent point' do
+      subject.should eq(Point.new(1,2).hash)
+    end
+
+  end
+end

data/spec/factory/scalar_domain/test_to_hash.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Domain
+  describe Scalar, "to_hash" do
+
+    let(:point){ Point.new(1, 2) }
+
+    subject{ point.to_hash }
+
+    it 'returns a hash with component values' do
+      subject.should eq(:x => 1, :y => 2)
+    end
+
+  end
+end

data/spec/factory/scalar_domain/test_values.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Domain
+  describe Scalar, "values" do
+
+    let(:object)        { Point.new(1, 2) }
+    let(:another_object){ Point.new(2, 3) }
+
+    it_should_behave_like 'a value object'
+
+  end
+end

data/spec/factory/test_sbyc.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+describe Domain, "sbyc" do
+
+  subject{ Domain.sbyc(Integer){|i| i > 0} }
+
+  it_should_behave_like 'a domain class'
+
+  it 'should recognize positive integers' do
+    (subject === 10).should be_true
+  end
+
+  it 'should not recognize negative integers' do
+    (subject === -10).should be_false
+  end
+
+end

data/spec/factory/test_scalar.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+describe Domain, "scalar" do
+
+  subject{ Domain.scalar(:x, :y) }
+
+  it_should_behave_like 'a domain class'
+
+  it 'should create a class that accepts two components' do
+    point = subject.new(1, 2)
+    point.x.should eq(1)
+    point.y.should eq(2)
+  end
+
+end

data/spec/factory/test_union.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+describe Domain, "union" do
+
+  subject{ Domain.union(TrueClass, FalseClass) }
+
+  it_should_behave_like 'a domain class'
+
+  it 'should recognize true and false' do
+    (subject === true).should be_true
+    (subject === false).should be_true
+  end
+
+  it 'should not recognize non booleans' do
+    (subject === -10).should be_false
+  end
+
+end

data/spec/factory/union_domain/test_new.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Domain
+  describe Union, "new" do
+
+    it 'returns the value when it satisfies the predicate' do
+      Boolean.new(true).should be(true)
+      Boolean.new(false).should be(false)
+    end
+
+    it 'raises an argument error when the value is not a superclazz value' do
+      lambda{
+        Boolean.new("12")
+      }.should raise_error(ArgumentError)
+    end
+
+  end
+end

data/spec/factory/union_domain/test_predicate.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Domain
+  describe Union, "predicate" do
+
+    it 'returns a Proc' do
+      Boolean.predicate.should be_a(Proc)
+    end
+
+    it 'is satisfied when a valid value' do
+      Boolean.predicate.call(true).should be_true
+    end
+
+    it 'is not satisfied when an invalid value' do
+      Boolean.predicate.call("12").should be_false
+    end
+
+  end
+end

data/spec/factory/union_domain/test_sub_domains.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Domain
+  describe Union, "sub_domains" do
+
+    it 'returns the sub domains passed at construction' do
+      Boolean.sub_domains.should eq([TrueClass, FalseClass])
+    end
+
+  end
+end

data/spec/factory/union_domain/test_super_domain.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Domain
+  describe Union, "super_domain" do
+
+    it 'returns the super domain passed at construction' do
+      Boolean.super_domain.should be(Object)
+    end
+
+  end
+end

data/spec/factory/union_domain/test_super_domain_of.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Domain
+  describe Union, "super_domain_of?" do
+
+    it 'returns true when a super domain' do
+      Boolean.should be_super_domain_of(TrueClass)
+    end
+
+    it 'returns false on itself' do
+      Boolean.should_not be_super_domain_of(Boolean)
+    end
+
+    it 'returns false when not a super domain' do
+      Boolean.should_not be_super_domain_of(Integer)
+    end
+
+  end
+end

data/spec/factory/union_domain/test_triple_equal.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+module Domain
+  describe Union, "===" do
+
+    it 'returns true when a proper value' do
+      (Boolean === true).should be_true
+      (Boolean === false).should be_true
+    end
+
+    it 'returns false when not a value' do
+      (Boolean === 1).should be_false
+    end
+
+  end
+end

data/spec/fixtures/boolean.rb

@@ -0,0 +1,3 @@
+class Boolean
+  extend Domain::Union.new(TrueClass, FalseClass)
+end

data/spec/fixtures/list.rb

@@ -0,0 +1,6 @@
+class List
+  extend Domain::Reuse.new(Array)
+
+  reuse :size, :empty?
+  recoat :map, :select, :reject
+end