finitio 0.4.1 → 0.5.0

data/spec/{unit/syntax → syntax}/nodes/test_contract.rb

@@ -6,10 +6,6 @@ module Finitio
       Syntax.parse(input, root: "contract")
     }
 
-    let(:contract){
-      compiled.values.first
-    }
-
     let(:ast){
       subject.to_ast
     }
@@ -21,17 +17,16 @@ module Finitio
         subject.compile(type_factory, Color)
       }
 
-      it 'compiles to the expected Hash' do
-        compiled.should be_a(Hash)
-        compiled.keys.should eq([:rgb])
-        contract.should be_a(Array)
-        contract[0].should be_a(TupleType)
-        contract[1].should be_a(Method)
-        contract[2].should be_a(Proc)
+      it 'compiles to the expected Contract' do
+        expect(compiled).to be_a(Contract)
+        expect(compiled.name).to eq(:rgb)
+        expect(compiled.infotype).to be_a(TupleType)
+        expect(compiled.dresser).to be_a(Method)
+        expect(compiled.undresser).to be_a(Proc)
       end
 
       it 'has expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :contract,
           "rgb",
           [:tuple_type,
@@ -52,17 +47,16 @@ module Finitio
         subject.compile(type_factory, nil)
       }
 
-      it 'compiles to the expected Hash' do
-        compiled.should be_a(Hash)
-        compiled.keys.should eq([:rgb])
-        contract.should be_a(Array)
-        contract[0].should be_a(TupleType)
-        contract[1].should be(Finitio::IDENTITY)
-        contract[2].should be(Finitio::IDENTITY)
+      it 'compiles to the expected Contract' do
+        expect(compiled).to be_a(Contract)
+        expect(compiled.name).to eq(:rgb)
+        expect(compiled.infotype).to be_a(TupleType)
+        expect(compiled.dresser).to be(Finitio::IDENTITY)
+        expect(compiled.undresser).to be(Finitio::IDENTITY)
       end
 
       it 'has expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :contract,
           "rgb",
           [:tuple_type,
@@ -83,16 +77,16 @@ module Finitio
         subject.compile(type_factory, nil)
       }
 
-      it 'compiles to the expected Hash' do
-        compiled.should be_a(Hash)
-        compiled.keys.should eq([:iso])
-        contract.should be_a(Array)
-        contract.first.should be_a(BuiltinType)
-        contract.last.should be_a(Proc)
+      it 'compiles to the expected Contract' do
+        expect(compiled).to be_a(Contract)
+        expect(compiled.name).to eq(:iso)
+        expect(compiled.infotype).to be_a(BuiltinType)
+        expect(compiled.dresser).to be_a(Proc)
+        expect(compiled.undresser).to be_a(Proc)
       end
 
       it 'has expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :contract,
           "iso",
           [:builtin_type, "String"],
@@ -111,17 +105,16 @@ module Finitio
         subject.compile(type_factory, nil)
       }
 
-      it 'compiles to the expected Hash' do
-        compiled.should be_a(Hash)
-        compiled.keys.should eq([:iso])
-        contract.should be_a(Array)
-        contract[0].should be_a(BuiltinType)
-        contract[1].should be_a(Method)
-        contract[2].should be_a(Method)
+      it 'compiles to the expected Contract' do
+        expect(compiled).to be_a(Contract)
+        expect(compiled.name).to eq(:iso)
+        expect(compiled.infotype).to be_a(BuiltinType)
+        expect(compiled.dresser).to be_a(Method)
+        expect(compiled.undresser).to be_a(Method)
       end
 
       it 'has expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :contract,
           "iso",
           [:builtin_type, "String"],

data/spec/{unit/syntax → syntax}/nodes/test_expression.rb

@@ -14,12 +14,12 @@ module Finitio
       let(:input){ 'a >= 10' }
 
       it 'compiles to an Proc' do
-        compiled.should be_a(Proc)
+        expect(compiled).to be_a(Proc)
       end
 
       it 'should be the correct Proc' do
-        compiled.call(12).should be_true
-        compiled.call(9).should be_false
+        expect(compiled.call(12)).to eq(true)
+        expect(compiled.call(9)).to eq(false)
       end
     end
 
@@ -27,7 +27,7 @@ module Finitio
       let(:input){ '(a >= 10)' }
 
       it 'compiles to an Proc' do
-        compiled.should be_a(Proc)
+        expect(compiled).to be_a(Proc)
       end
     end
 
@@ -35,7 +35,15 @@ module Finitio
       let(:input){ 'acall(a)' }
 
       it 'compiles to an Proc' do
-        compiled.should be_a(Proc)
+        expect(compiled).to be_a(Proc)
+      end
+    end
+
+    context 's =~ /^(test)$/' do
+      let(:input){ 's =~ /^(test)$/' }
+
+      it 'compiles to an Proc' do
+        expect(compiled).to be_a(Proc)
       end
     end
 

data/spec/{unit/syntax → syntax}/nodes/test_heading.rb

@@ -15,8 +15,8 @@ module Finitio
         let(:input){ '  ' }
 
         it 'compiles to a Heading' do
-          compiled.should be_a(Heading)
-          compiled.to_name.should eq('')
+          expect(compiled).to be_a(Heading)
+          expect(compiled.to_name).to eq('')
         end
       end
 
@@ -24,8 +24,8 @@ module Finitio
         let(:input){ 'a: .Integer' }
 
         it 'compiles to a Heading' do
-          compiled.should be_a(Heading)
-          compiled.to_name.should eq('a: Integer')
+          expect(compiled).to be_a(Heading)
+          expect(compiled.to_name).to eq('a: Integer')
         end
       end
 
@@ -33,8 +33,26 @@ module Finitio
         let(:input){ 'a: .Integer, b: .Float' }
 
         it 'compiles to a Heading' do
-          compiled.should be_a(Heading)
-          compiled.to_name.should eq('a: Integer, b: Float')
+          expect(compiled).to be_a(Heading)
+          expect(compiled.to_name).to eq('a: Integer, b: Float')
+        end
+      end
+
+      context 'a: .Integer, b :? .Float' do
+        let(:input){ 'a: .Integer, b :? .Float' }
+
+        it 'compiles to a Heading' do
+          expect(compiled).to be_a(Heading)
+          expect(compiled.to_name).to eq('a: Integer, b :? Float')
+        end
+      end
+
+      context 'a: .Integer, ...' do
+        let(:input){ 'a: .Integer, ...' }
+
+        it 'compiles to a Heading' do
+          expect(compiled).to be_a(Heading)
+          expect(compiled.to_name).to eq('a: Integer, ...')
         end
       end
     end
@@ -47,7 +65,7 @@ module Finitio
       }
 
       it{
-        ast.should eq([
+        expect(ast).to eq([
           :heading,
           [ :attribute, "a", [:builtin_type, "Integer" ]],
           [ :attribute, "b", [:builtin_type, "Float" ]]

data/spec/syntax/nodes/test_metadata.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Finitio
+  describe Syntax, "metadata" do
+
+    let(:match){
+      Syntax.parse(input, root: "metadata")
+    }
+
+    describe "value" do
+      subject{
+        match.value
+      }
+
+      context 'simple description' do
+        let(:input){ '/- Hello World -/' }
+
+        it{ should eq({description: "Hello World"}) }
+      end
+
+      context 'tuple' do
+        let(:input){ '/- label: "Hello World" -/' }
+
+        it{ should eq({label: "Hello World"}) }
+      end
+    end
+
+  end
+end

data/spec/{unit/syntax → syntax}/nodes/test_named_constraint.rb

@@ -14,24 +14,24 @@ module Finitio
       subject.to_ast('a')
     }
 
-    context 'a >= 10' do
+    context 'foo: a >= 10' do
       let(:input){ 'foo: a >= 10' }
 
-      it 'compiles to an Hash' do
-        compiled.should be_a(Hash)
+      it 'compiles to a Constraint' do
+        expect(compiled).to be_a(Constraint)
       end
 
-      it 'has expected keys' do
-        compiled.keys.should eq([:foo])
+      it 'has expected name' do
+        expect(compiled.name).to eq(:foo)
       end
 
       it 'should be the correct Proc' do
-        compiled[:foo].call(12).should be_true
-        compiled[:foo].call(9).should be_false
+        expect(compiled.===(12)).to eq(true)
+        expect(compiled.===(9)).to eq(false)
       end
 
       it 'has the expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :constraint,
           "foo",
           [:fn, [:parameters, "a"], [:source, "a >= 10"]]

data/spec/syntax/nodes/test_relation_type.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+module Finitio
+  describe Syntax, "relation_type" do
+
+    subject{
+      Syntax.parse(input, root: "relation_type")
+    }
+
+    describe "compilation result" do
+      let(:compiled){
+        subject.compile(type_factory)
+      }
+
+      context 'empty heading' do
+        let(:input){ '{{ }}' }
+
+        it 'compiles to a RelationType' do
+          expect(compiled).to be_a(RelationType)
+          expect(compiled.heading).to be_empty
+        end
+      end
+
+      context '{{a: .Integer}}' do
+        let(:input){ '{{a: .Integer}}' }
+
+        it 'compiles to a RelationType' do
+          expect(compiled).to be_a(RelationType)
+          expect(compiled.heading.size).to eq(1)
+        end
+      end
+
+      context '{{a: .Integer, b: .Float}}' do
+        let(:input){ '{{a: .Integer, b: .Float}}' }
+
+        it 'compiles to a RelationType' do
+          expect(compiled).to be_a(RelationType)
+          expect(compiled.heading.size).to eq(2)
+        end
+      end
+
+      context '{{a: .Integer, b :? .Float}}' do
+        let(:input){ '{{a: .Integer, b :? .Float}}' }
+
+        it 'compiles to a MultiRelationType' do
+          expect(compiled).to be_a(MultiRelationType)
+          expect(compiled.heading.size).to eq(2)
+        end
+      end
+    end
+
+    describe "AST" do
+      let(:ast){ subject.to_ast }
+
+      context '{{a: .Integer}}' do
+        let(:input){ '{{a: .Integer}}' }
+
+        it{
+          expect(ast).to eq([
+            :relation_type,
+            [
+              :heading,
+              [ :attribute, "a", [:builtin_type, "Integer" ]]
+            ]
+          ])
+        }
+      end
+
+      context '{{a :? .Integer}}' do
+        let(:input){ '{{a :? .Integer}}' }
+
+        it{
+          expect(ast).to eq([
+            :multi_relation_type,
+            [
+              :heading,
+              [ :attribute, "a", [:builtin_type, "Integer" ], false]
+            ]
+          ])
+        }
+      end
+    end
+
+  end
+end

data/spec/{unit/syntax → syntax}/nodes/test_seq_type.rb

@@ -15,9 +15,9 @@ module Finitio
         let(:input){ '[.Integer]' }
 
         it 'compiles to a SeqType' do
-          compiled.should be_a(SeqType)
-          compiled.elm_type.should be_a(BuiltinType)
-          compiled.elm_type.ruby_type.should be(Integer)
+          expect(compiled).to be_a(SeqType)
+          expect(compiled.elm_type).to be_a(BuiltinType)
+          expect(compiled.elm_type.ruby_type).to be(Integer)
         end
       end
     end
@@ -27,7 +27,7 @@ module Finitio
 
       let(:ast){ subject.to_ast }
 
-      it{ ast.should eq([
+      it{ expect(ast).to eq([
           :seq_type,
           [:builtin_type, "Integer"]
         ])

data/spec/{unit/syntax → syntax}/nodes/test_set_type.rb

@@ -15,9 +15,9 @@ module Finitio
         let(:input){ '{.Integer}' }
 
         it 'compiles to a SeqType' do
-          compiled.should be_a(SetType)
-          compiled.elm_type.should be_a(BuiltinType)
-          compiled.elm_type.ruby_type.should be(Integer)
+          expect(compiled).to be_a(SetType)
+          expect(compiled.elm_type).to be_a(BuiltinType)
+          expect(compiled.elm_type.ruby_type).to be(Integer)
         end
       end
     end
@@ -27,7 +27,7 @@ module Finitio
 
       let(:ast){ subject.to_ast }
 
-      it{ ast.should eq([
+      it{ expect(ast).to eq([
           :set_type,
           [:builtin_type, "Integer"]
         ])

data/spec/{unit/syntax → syntax}/nodes/test_spacing.rb

@@ -16,7 +16,7 @@ module Finitio
         let(:input){ source }
 
         it 'should parse' do
-          subject.should eq(source)
+          expect(subject).to eq(source)
         end
       end
     end

data/spec/syntax/nodes/test_struct_type.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Finitio
+  describe Syntax, "struct_type" do
+
+    subject{
+      Syntax.parse(input, root: "struct_type")
+    }
+
+    describe "compilation result" do
+      let(:compiled){
+        subject.compile(type_factory)
+      }
+
+      context '<.Integer, .Float>' do
+        let(:input){ '<.Integer, .Float>' }
+
+        it 'compiles to a StructType' do
+          expect(compiled).to be_a(StructType)
+          expect(compiled.component_types).to eq([intType, floatType])
+        end
+      end
+    end
+
+    describe "AST" do
+      let(:input){ '<.Integer, .Float>' }
+
+      let(:ast){ subject.to_ast }
+
+      it{ expect(ast).to eq([
+          :struct_type,
+          [:builtin_type, "Integer"],
+          [:builtin_type, "Float"]
+        ])
+      }
+    end
+
+  end
+end