finitio 0.4.1 → 0.5.0

data/spec/{unit/system → system}/test_get_type.rb

@@ -14,7 +14,7 @@ module Finitio
       let(:name){ "intType" }
 
       it 'should return the type' do
-        subject.should eq(intType)
+        expect(subject).to eq(intType)
       end
     end
 
@@ -22,7 +22,7 @@ module Finitio
       let(:name){ "noSuchOne" }
 
       it 'should return nil' do
-        subject.should be_nil
+        expect(subject).to be_nil
       end
     end
 

data/spec/test_finitio.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+describe Finitio do
+
+  it "should have a version number" do
+    expect(Finitio.const_defined?(:VERSION)).to eq(true)
+  end
+
+end

data/spec/{unit/type → type}/ad_type/test_default_name.rb

@@ -5,8 +5,7 @@ module Finitio
     subject{ type.default_name }
 
     let(:type){
-      AdType.new(Color, rgb: [intType,   Color.method(:rgb), Finitio::IDENTITY ],
-                        hex: [floatType, Color.method(:hex), Finitio::IDENTITY ])
+      AdType.new(Color, [])
     }
 
     it{ should eq('Color') }

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

@@ -2,9 +2,16 @@ require 'spec_helper'
 module Finitio
   describe AdType, 'dress' do
 
+    let(:rgb){
+      Contract.new(intType, ->(i){ Color.new(i,i,i) }, Finitio::IDENTITY, :rgb)
+    }
+
+    let(:hex){
+      Contract.new(floatType, ->(f){ Color.new(f.to_i,f.to_i,f.to_i) }, Finitio::IDENTITY, :hex)
+    }
+
     let(:type){
-      AdType.new(Color, rgb: [intType,   ->(i){ i*2 }, Finitio::IDENTITY ],
-                        hex: [floatType, ->(f){ f*3 }, Finitio::IDENTITY ])
+      AdType.new(Color, [rgb, hex])
     }
 
     subject{
@@ -20,34 +27,37 @@ module Finitio
     context 'with an integer' do
       let(:arg){ 12 }
 
-      it{ should eq(24) }
+      it{ should eq(Color.new(12,12,12)) }
     end
 
     context 'with a float' do
       let(:arg){ 12.0 }
 
-      it{ should eq(36.0) }
+      it{ should eq(Color.new(12,12,12)) }
     end
 
     context 'with an unrecognized' do
       let(:arg){ "foo" }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error(TypeError, "Invalid value `foo` for Color")
+        }.to raise_error(TypeError, "Invalid Color `foo`")
       end
     end
 
     context 'when the upper raises an error' do
+      let(:rgb){
+        Contract.new(intType, ->(t){ raise ArgumentError }, Finitio::IDENTITY, :rgb)
+      }
       let(:type){
-        AdType.new(Color, rgb: [ intType, ->(t){ raise ArgumentError }, Finitio::IDENTITY ])
+        AdType.new(Color, [ rgb ])
       }
 
       it 'should hide the error' do
         err = type.dress(12) rescue $!
-        err.should be_a(TypeError)
-        err.message.should eq("Invalid value `12` for Color")
+        expect(err).to be_a(TypeError)
+        expect(err.message).to eq("Invalid Color `12`")
       end
     end
 

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

@@ -2,20 +2,20 @@ require 'spec_helper'
 module Finitio
   describe AdType, "include?" do
 
-    let(:type){ AdType.new(Color, {}) }
+    let(:type){ AdType.new(Color, []) }
 
     subject{ type.include?(arg) }
 
     context 'when not included' do
       let(:arg){ "12" }
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
     context 'when included' do
       let(:arg){ blueviolet }
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
   end

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

@@ -2,17 +2,24 @@ require 'spec_helper'
 module Finitio
   describe AdType, 'initialize' do
 
+    let(:rgb){
+      Contract.new(intType, Color.method(:rgb), Finitio::IDENTITY, :rgb)
+    }
+
+    let(:hex){
+      Contract.new(floatType, Color.method(:hex), Finitio::IDENTITY, :hex)
+    }
+
     subject{
-      AdType.new(Color, rgb: [intType,   Color.method(:rgb), Finitio::IDENTITY ],
-                        hex: [floatType, Color.method(:hex), Finitio::IDENTITY ])
+      AdType.new(Color, [rgb, hex])
     }
 
     context 'with valid arguments' do
       it{ should be_a(AdType) }
 
       it 'should set the instance variables' do
-        subject.ruby_type.should be(Color)
-        subject.contracts.should be_a(Hash)
+        expect(subject.ruby_type).to be(Color)
+        expect(subject.contracts).to be_a(Array)
       end
     end
 
@@ -20,9 +27,9 @@ module Finitio
       subject{ AdType.new("foo", {}) }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error(ArgumentError, 'Module expected, got `foo`')
+        }.to raise_error(ArgumentError, 'Module expected, got `foo`')
       end
     end
 
@@ -30,9 +37,9 @@ module Finitio
       subject{ AdType.new(Object, "bar") }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error(ArgumentError, 'Hash expected, got `bar`')
+        }.to raise_error(ArgumentError, '[Contract] expected, got `bar`')
       end
     end
 

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

@@ -5,13 +5,13 @@ module Finitio
     subject{ type.name }
 
     context 'when provided' do
-      let(:type){ AdType.new(Color, {}, "Foo") }
+      let(:type){ AdType.new(Color, [], "Foo") }
 
       it{ should eq('Foo') }
     end
 
     context 'when not provided' do
-      let(:type){ AdType.new(Color, {}) }
+      let(:type){ AdType.new(Color, []) }
 
       it{ should eq('Color') }
     end

data/spec/type/alias_type/test_default_name.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Finitio
+  describe AliasType, "default_name" do
+
+    let(:type){ AliasType.new(intType, 'Alias') }
+
+    it{ expect(type.default_name).to eq('Alias') }
+
+  end
+end

data/spec/type/alias_type/test_delegation.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module Finitio
+  describe AliasType, "delegation pattern" do
+
+    let(:type){ AliasType.new(intType, 'Alias') }
+
+    it 'should delegate hash' do
+      expect(type.hash).to eq(intType.hash)
+    end
+
+    it 'should delegate ==' do
+      expect(intType == type).to eq(true)
+      expect(type == intType).to eq(true)
+    end
+
+    it 'should delegate dress' do
+      expect(type.dress(12)).to eq(12)
+    end
+
+    it 'should delegate include?' do
+      expect(type.include?(12)).to eq(true)
+    end
+
+    it 'should delegate to_s' do
+      expect(type.to_s).to eq(intType.to_s)
+    end
+
+  end
+end

data/spec/type/alias_type/test_name.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Finitio
+  describe AliasType, "name" do
+
+    let(:type){ AliasType.new(intType, 'Alias') }
+
+    it{ expect(type.name).to eq('Alias') }
+
+  end
+end

data/spec/{unit/type → type}/any_type/test_default_name.rb

@@ -5,7 +5,7 @@ module Finitio
     let(:type){ AnyType.new }
 
     it 'uses Any' do
-      type.default_name.should eq("Any")
+      expect(type.default_name).to eq("Any")
     end
 
   end

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

@@ -7,19 +7,19 @@ module Finitio
     let(:fltType) { BuiltinType.new(Float)   }
 
     it 'should apply structural equality' do
-      (anyType == anyType2).should be_true
+      expect(anyType == anyType2).to eq(true)
     end
 
     it 'should apply distinguish different types' do
-      (anyType == fltType).should be_false
+      expect(anyType == fltType).to eq(false)
     end
 
     it 'should be a total function, with nil for non types' do
-      (anyType == 12).should be_false
+      expect(anyType == 12).to eq(false)
     end
 
     it 'should implement hash accordingly' do
-      (anyType.hash == anyType2.hash).should be_true
+      expect(anyType.hash == anyType2.hash).to eq(true)
     end
 
   end

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

@@ -9,13 +9,13 @@ module Finitio
     context 'with nil' do
       let(:arg){ nil }
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
     context 'when an Integer' do
       let(:arg){ 12 }
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
   end

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

@@ -8,7 +8,7 @@ module Finitio
       let(:type){ AnyType.new }
 
       it 'uses the default name' do
-        subject.should eq("Any")
+        expect(subject).to eq("Any")
       end
     end
 
@@ -16,7 +16,7 @@ module Finitio
       let(:type){ AnyType.new("foo") }
 
       it 'uses the specified name' do
-        subject.should eq("foo")
+        expect(subject).to eq("foo")
       end
     end
 

data/spec/{unit/type → type}/builtin_type/test_default_name.rb

@@ -5,7 +5,7 @@ module Finitio
     let(:type){ BuiltinType.new(Integer, "int") }
 
     it 'uses the ruby name' do
-      type.default_name.should eq("Integer")
+      expect(type.default_name).to eq("Integer")
     end
 
   end

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

@@ -20,12 +20,12 @@ module Finitio
       }
 
       it 'should raise an Error' do
-        subject.should be_a(TypeError)
-        subject.message.should eq("Invalid value `12.0` for int")
+        expect(subject).to be_a(TypeError)
+        expect(subject.message).to eq("Invalid int `12.0`")
       end
 
       it 'should have no location' do
-        subject.location.should eq('')
+        expect(subject.location).to eq('')
       end
     end
 

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

@@ -7,19 +7,19 @@ module Finitio
     let(:fltType) { BuiltinType.new(Float)   }
 
     it 'should apply structural equality' do
-      (intType == intType2).should be_true
+      expect(intType == intType2).to eq(true)
     end
 
     it 'should apply distinguish different types' do
-      (intType == fltType).should be_false
+      expect(intType == fltType).to eq(false)
     end
 
     it 'should be a total function, with nil for non types' do
-      (intType == 12).should be_false
+      expect(intType == 12).to eq(false)
     end
 
     it 'should implement hash accordingly' do
-      (intType.hash == intType2.hash).should be_true
+      expect(intType.hash == intType2.hash).to eq(true)
     end
 
   end

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

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

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

@@ -5,7 +5,7 @@ module Finitio
     let(:type){ BuiltinType.new(Integer) }
 
     it 'should set instance variables' do
-      type.ruby_type.should be(Integer)
+      expect(type.ruby_type).to be(Integer)
     end
 
   end

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

@@ -8,7 +8,7 @@ module Finitio
       let(:type){ BuiltinType.new(Integer) }
 
       it 'uses the default name' do
-        subject.should eq("Integer")
+        expect(subject).to eq("Integer")
       end
     end
 
@@ -16,7 +16,7 @@ module Finitio
       let(:type){ BuiltinType.new(Integer, "int") }
 
       it 'uses the specified name' do
-        subject.should eq("int")
+        expect(subject).to eq("int")
       end
     end
 

data/spec/type/multi_relation_type/test_default_name.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Finitio
+  describe MultiRelationType, "default_name" do
+
+    let(:heading){
+      Heading.new([
+        Attribute.new(:a, byte),
+        Attribute.new(:b, byte, false)
+      ])
+    }
+
+    subject{ type.default_name }
+
+    let(:type){ MultiRelationType.new(heading) }
+
+    it{ should eq("{{a: Byte, b :? Byte}}") }
+
+  end
+end

data/spec/type/multi_relation_type/test_dress.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+module Finitio
+  describe MultiRelationType, "dress" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:r, byte),
+                   Attribute.new(:g, byte),
+                   Attribute.new(:b, byte, false)])
+    }
+
+    let(:type){
+      MultiRelationType.new(heading, "colors")
+    }
+
+    subject{ type.dress(arg)  }
+
+    context 'with a valid array of Hashes' do
+      let(:arg){
+        [
+          { "r" => 12, "g" => 13, "b" => 255 },
+          { "r" => 12, "g" => 15, "b" => 198 }
+        ]
+      }
+      let(:expected){
+        [
+          { r: 12, g: 13, b: 255 },
+          { r: 12, g: 15, b: 198 }
+        ]
+      }
+
+      it 'should coerce to an Enumerable of tuples' do
+        expect(subject).to be_a(Enumerable)
+        expect(subject.to_a).to eq(expected)
+      end
+    end
+
+    context 'with a valid array of Hashes with some optional missing' do
+      let(:arg){
+        [
+          { "r" => 12, "g" => 13, "b" => 255 },
+          { "r" => 12, "g" => 15 }
+        ]
+      }
+      let(:expected){
+        [
+          { r: 12, g: 13, b: 255 },
+          { r: 12, g: 15 }
+        ]
+      }
+
+      it 'should coerce to an Enumerable of tuples' do
+        expect(subject).to be_a(Enumerable)
+        expect(subject.to_a).to eq(expected)
+      end
+    end
+
+    context 'with an empty array' do
+      let(:arg){
+        []
+      }
+      let(:expected){
+        []
+      }
+
+      it 'should coerce to an Enumerable of tuples' do
+        expect(subject).to be_a(Enumerable)
+        expect(subject.to_a).to eq(expected)
+      end
+    end
+
+    context 'when raising an error' do
+
+      subject do
+        type.dress(arg) rescue $!
+      end
+
+      context 'with something else than an Array' do
+        let(:arg){
+          "foo"
+        }
+
+        it 'should raise a TypeError' do
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid colors `foo`")
+        end
+
+        it 'should have no cause' do
+          expect(subject.cause).to be_nil
+        end
+
+        it 'should have an empty location' do
+          expect(subject.location).to eq('')
+        end
+      end
+
+      context 'with Array of non-tuples' do
+        let(:arg){
+          ["foo"]
+        }
+
+        it 'should raise a TypeError' do
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid {r: Byte, g: Byte, b :? Byte} `foo`")
+        end
+
+        it 'should have no cause' do
+          expect(subject.cause).to be_nil
+        end
+
+        it 'should have the correct location' do
+          expect(subject.location).to eq('0')
+        end
+      end
+
+      context 'with a wrong tuple' do
+        let(:arg){
+          [
+            { "r" => 12, "g" => 13, "b" => 255 },
+            { "r" => 12, "b" => 13 }
+          ]
+        }
+
+        it 'should raise a TypeError' do
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Missing attribute `g`")
+        end
+
+        it 'should have no cause' do
+          expect(subject.cause).to be_nil
+        end
+
+        it 'should have the correct location' do
+          expect(subject.location).to eq('1')
+        end
+      end
+
+      context 'with a tuple with extra attribute' do
+        let(:arg){
+          [
+            { "r" => 12, "g" => 13, "b" => 255 },
+            { "r" => 12, "g" => 13, "f" => 13 }
+          ]
+        }
+
+        it 'should raise a TypeError' do
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Unrecognized attribute `f`")
+        end
+
+        it 'should have no cause' do
+          expect(subject.cause).to be_nil
+        end
+
+        it 'should have the correct location' do
+          expect(subject.location).to eq('1')
+        end
+      end
+
+      context 'with a wrong tuple attribute' do
+        let(:arg){
+          [
+            { "r" => 12, "g" => 13, "b" => 255  },
+            { "r" => 12, "g" => 13, "b" => 12.0 }
+          ]
+        }
+
+        it 'should raise a TypeError' do
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid Byte `12.0`")
+        end
+
+        it 'should have a cause' do
+          expect(subject.cause).not_to be_nil
+        end
+
+        it 'should have the correct location' do
+          expect(subject.location).to eq('1/b')
+        end
+      end
+
+      context 'with a duplicate tuple' do
+        let(:arg){
+          [
+            { "r" => 12, "g" => 13, "b" => 255 },
+            { "r" => 12, "g" => 192, "b" => 13 },
+            { "r" => 12, "g" => 13, "b" => 255 }
+          ]
+        }
+
+        it 'should raise a TypeError' do
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Duplicate tuple")
+        end
+
+        it 'should have no cause' do
+          expect(subject.cause).to be_nil
+        end
+
+        it 'should have the correct location' do
+          expect(subject.location).to eq('2')
+        end
+      end
+    end
+
+  end
+end