finitio 0.4.1 → 0.5.0

data/spec/{unit/type → type}/sub_type/test_include.rb

@@ -2,32 +2,32 @@ require 'spec_helper'
 module Finitio
   describe SubType, "include?" do
 
-    let(:type){ SubType.new(intType, {default: ->(i){ i>0 }, small: ->(i){ i<255 }}, "byte") }
+    let(:type){ SubType.new(intType, [byte_min, byte_max], "byte") }
 
     subject{ type.include?(arg) }
 
     context 'when included on int' do
       let(:arg){ 12 }
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
     context 'when not included on int (I)' do
       let(:arg){ -12 }
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
     context 'when not included on int (II)' do
-      let(:arg){ 255 }
+      let(:arg){ 256 }
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
     context 'when not included' do
       let(:arg){ "12" }
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
   end

data/spec/type/sub_type/test_initialize.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+module Finitio
+  describe SubType, "initialize" do
+
+    let(:sub){ SubType.new(intType, [byte_min, byte_max]) }
+
+    it 'sets the variable instances' do
+      expect(sub.super_type).to eq(intType)
+      expect(sub.constraints).to eq([byte_min, byte_max])
+    end
+
+  end
+end

data/spec/{unit/type → type}/sub_type/test_name.rb

@@ -5,18 +5,18 @@ module Finitio
     subject{ type.name }
 
     context 'when provided' do
-      let(:type){ SubType.new(intType, {posint: ->(i){}}, "Foo") }
+      let(:type){ SubType.new(intType, [positive], "Foo") }
 
       it 'uses the specified one' do
-        subject.should eq("Foo")
+        expect(subject).to eq("Foo")
       end
     end
 
     context 'when not provided' do
-      let(:type){ SubType.new(intType, posint: ->(i){}) }
+      let(:type){ SubType.new(intType, [positive]) }
 
       it 'uses the first constraint name' do
-        subject.should eq("Posint")
+        expect(subject).to eq("Positive")
       end
     end
 

data/spec/{unit/type → type}/tuple_type/test_dress.rb

@@ -20,7 +20,7 @@ module Finitio
       }
 
       it 'should coerce to a tuple' do
-        subject.should eq(r: 12, g: 13, b: 255)
+        expect(subject).to eq(r: 12, g: 13, b: 255)
       end
     end
 
@@ -36,16 +36,16 @@ module Finitio
         }
 
         it 'should raise a TypeError' do
-          subject.should be_a(TypeError)
-          subject.message.should eq("Invalid value `foo` for color")
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid color `foo`")
         end
 
         it 'should have no cause' do
-          subject.cause.should be_nil
+          expect(subject.cause).to be_nil
         end
 
         it 'should have an empty location' do
-          subject.location.should eq('')
+          expect(subject.location).to eq('')
         end
       end
 
@@ -55,16 +55,16 @@ module Finitio
         }
 
         it 'should raise a TypeError' do
-          subject.should be_a(TypeError)
-          subject.message.should eq("Missing attribute `b`")
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Missing attribute `b`")
         end
 
         it 'should have no cause' do
-          subject.cause.should be_nil
+          expect(subject.cause).to be_nil
         end
 
         it 'should have an empty location' do
-          subject.location.should eq('')
+          expect(subject.location).to eq('')
         end
       end
 
@@ -74,16 +74,16 @@ module Finitio
         }
 
         it 'should raise a TypeError' do
-          subject.should be_a(TypeError)
-          subject.message.should eq("Unrecognized attribute `extr`")
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Unrecognized attribute `extr`")
         end
 
         it 'should have no cause' do
-          subject.cause.should be_nil
+          expect(subject.cause).to be_nil
         end
 
         it 'should have an empty location' do
-          subject.location.should eq('')
+          expect(subject.location).to eq('')
         end
       end
 
@@ -93,17 +93,17 @@ module Finitio
         }
 
         it 'should raise a TypeError' do
-          subject.should be_a(TypeError)
-          subject.message.should eq("Invalid value `12.0` for Byte")
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid Byte `12.0`")
         end
 
         it 'should have the correct cause' do
-          subject.cause.should be_a(TypeError)
-          subject.cause.message.should eq("Invalid value `12.0` for intType")
+          expect(subject.cause).to be_a(TypeError)
+          expect(subject.cause.message).to eq("Invalid intType `12.0`")
         end
 
         it 'should have the correct location' do
-          subject.location.should eq("r")
+          expect(subject.location).to eq("r")
         end
       end
     end

data/spec/{unit/type → type}/tuple_type/test_equality.rb

@@ -11,21 +11,21 @@ module Finitio
     let(:type3)  { TupleType.new(h3) }
 
     it 'should apply structural equality' do
-      (type1 == type2).should be_true
-      (type2 == type1).should be_true
+      expect(type1 == type2).to eq(true)
+      expect(type2 == type1).to eq(true)
     end
 
     it 'should apply distinguish different types' do
-      (type1 == type3).should be_false
-      (type2 == type3).should be_false
+      expect(type1 == type3).to eq(false)
+      expect(type2 == type3).to eq(false)
     end
 
     it 'should be a total function, with nil for non types' do
-      (type1 == 12).should be_false
+      expect(type1 == 12).to eq(false)
     end
 
     it 'should implement hash accordingly' do
-      [type1, type2].map(&:hash).uniq.size.should eq(1)
+      expect([type1, type2].map(&:hash).uniq.size).to eq(1)
     end
 
   end

data/spec/{unit/type → type}/tuple_type/test_include.rb

@@ -13,25 +13,25 @@ module Finitio
     context 'when a valid hash' do
       let(:arg){ {a: 12} }
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
     context 'when an invalid hash (too many attributes)' do
       let(:arg){ {a: 12, b: 15} }
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
     context 'when an invalid hash (too few attributes)' do
       let(:arg){ {b: 12} }
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
     context 'when an invalid hash (wrong type)' do
       let(:arg){ {a: 12.0} }
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
   end

data/spec/{unit/type → type}/tuple_type/test_initialize.rb

@@ -12,7 +12,7 @@ module Finitio
       it{ should be_a(TupleType) }
 
       it 'correctly sets the instance variable' do
-        subject.heading.should eq(heading)
+        expect(subject.heading).to eq(heading)
       end
     end
 
@@ -20,11 +20,11 @@ module Finitio
       subject{ TupleType.new("foo") }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error(ArgumentError, "Heading expected, got `foo`")
+        }.to raise_error(ArgumentError, "Heading expected, got `foo`")
       end
     end
 
   end
-end
+end

data/spec/{unit/type → type}/union_type/test_dress.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 module Finitio
   describe UnionType, "dress" do
 
-    let(:type)      { UnionType.new([intType, floatType], "union") }
+    let(:type){ UnionType.new([intType, floatType], "union") }
 
     subject{ type.dress(arg) }
 
@@ -26,16 +26,17 @@ module Finitio
       }
 
       it 'should raise an Error' do
-        subject.should be_a(TypeError)
-        subject.message.should eq("Invalid value `foo` for union")
+        expect(subject).to be_a(TypeError)
+        expect(subject.message).to eq("Invalid union `foo`")
       end
 
-      it 'should have no cause' do
-        subject.cause.should be_nil
+      it 'should have a cause' do
+        expect(subject.cause).to be_a(TypeError)
+        expect(subject.cause.message).to eq("Invalid intType `foo`")
       end
 
       it 'should have an empty location' do
-        subject.location.should eq('')
+        expect(subject.location).to eq('')
       end
     end
 

data/spec/{unit/type → type}/union_type/test_equality.rb

@@ -8,22 +8,22 @@ module Finitio
     let(:uType4) { UnionType.new([intType])            }
 
     it 'should apply structural equality' do
-      (uType  == uType2).should be_true
-      (uType  == uType3).should be_true
-      (uType2 == uType3).should be_true
+      expect(uType  == uType2).to eq(true)
+      expect(uType  == uType3).to eq(true)
+      expect(uType2 == uType3).to eq(true)
     end
 
     it 'should apply distinguish different types' do
-      (uType == uType4).should be_false
-      (uType == intType).should be_false
+      expect(uType == uType4).to eq(false)
+      expect(uType == intType).to eq(false)
     end
 
     it 'should be a total function, with nil for non types' do
-      (uType == 12).should be_false
+      expect(uType == 12).to eq(false)
     end
 
     it 'should implement hash accordingly' do
-      [uType, uType2, uType3].map(&:hash).uniq.size.should eq(1)
+      expect([uType, uType2, uType3].map(&:hash).uniq.size).to eq(1)
     end
 
   end

data/spec/{unit/type → type}/union_type/test_include.rb

@@ -9,19 +9,19 @@ module Finitio
     context 'when not included' do
       let(:arg){ "12" }
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
     context 'when included on int' do
       let(:arg){ 12 }
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
     context 'when included on float' do
       let(:arg){ 12.0 }
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
   end

data/spec/{unit/type → type}/union_type/test_initialize.rb

@@ -6,7 +6,7 @@ module Finitio
       let(:union){ UnionType.new([intType, floatType]) }
 
       it 'sets the variable instances' do
-        union.candidates.should eq([intType, floatType])
+        expect(union.candidates).to eq([intType, floatType])
       end
     end
 
@@ -14,9 +14,9 @@ module Finitio
       let(:union){ UnionType.new(["bar"]) }
 
       it 'should raise an error' do
-        ->{
+        expect{
           union
-        }.should raise_error(ArgumentError, %Q{[Finitio::Type] expected, got ["bar"]})
+        }.to raise_error(ArgumentError, %Q{[Finitio::Type] expected, got ["bar"]})
       end
     end
 

data/spec/{unit/type_factory → type_factory}/dsl/test_adt.rb

@@ -14,11 +14,11 @@ module Finitio
       it{ should be_a(AdType) }
 
       it 'should have the correct ruby type' do
-        subject.ruby_type.should be(Color)
+        expect(subject.ruby_type).to be(Color)
       end
 
       it 'should have the two contracts' do
-        subject.contracts.keys.should eq([:rgb, :hex])
+        expect(subject.contracts.map(&:name)).to eq([:rgb, :hex])
       end
     end
 
@@ -34,7 +34,7 @@ module Finitio
       it_should_behave_like "The <Color> type"
 
       it 'should have the correct name' do
-        subject.name.should eq("Color")
+        expect(subject.name).to eq("Color")
       end
     end
 
@@ -46,7 +46,7 @@ module Finitio
       it_should_behave_like "The <Color> type"
 
       it 'should have the correct name' do
-        subject.name.should eq("MyColor")
+        expect(subject.name).to eq("MyColor")
       end
     end
 

data/spec/{unit/type_factory → type_factory}/dsl/test_any.rb

@@ -20,7 +20,7 @@ module Finitio
       it{ should be_a(AnyType) }
 
       it 'should have the name' do
-        subject.name.should eq('foo')
+        expect(subject.name).to eq('foo')
       end
     end
 

data/spec/{unit/type_factory → type_factory}/dsl/test_attribute.rb

@@ -9,11 +9,11 @@ module Finitio
       it{ should be_a(Attribute) }
 
       it 'should have the correct name' do
-        subject.name.should eq(:a)
+        expect(subject.name).to eq(:a)
       end
 
       it 'should have the correct type' do
-        subject.type.should eq(intType)
+        expect(subject.type).to eq(intType)
       end
     end
 
@@ -23,6 +23,8 @@ module Finitio
       }
 
       it_should_behave_like "The a:Integer attribute"
+
+      it{ should be_required }
     end
 
     context 'when used with a type' do
@@ -31,6 +33,18 @@ module Finitio
       }
 
       it_should_behave_like "The a:Integer attribute"
+
+      it{ should be_required }
+    end
+
+    context 'when used for an optional attribute' do
+      subject{
+        factory.attribute(:a, intType, false)
+      }
+
+      it_should_behave_like "The a:Integer attribute"
+
+      it{ should_not be_required }
     end
 
   end