finitio 0.4.1 → 0.5.0

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

@@ -18,13 +18,13 @@ module Finitio
       let(:input){ '.Integer( i | i >= 0 )' }
 
       it 'compiles to a SubType' do
-        compiled.should be_a(SubType)
-        compiled.super_type.should be_a(BuiltinType)
-        compiled.super_type.ruby_type.should be(Integer)
+        expect(compiled).to be_a(SubType)
+        expect(compiled.super_type).to be_a(BuiltinType)
+        expect(compiled.super_type.ruby_type).to be(Integer)
       end
 
       it 'has the expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :sub_type,
           [:builtin_type, "Integer"],
           [:constraint, "default", [:fn, [:parameters, "i"], [:source, "i >= 0"]]]
@@ -36,17 +36,17 @@ module Finitio
       let(:input){ '.Integer( i | positive: i >= 0 )' }
 
       it 'compiles to a SubType' do
-        compiled.should be_a(SubType)
-        compiled.super_type.should be_a(BuiltinType)
-        compiled.super_type.ruby_type.should be(Integer)
+        expect(compiled).to be_a(SubType)
+        expect(compiled.super_type).to be_a(BuiltinType)
+        expect(compiled.super_type.ruby_type).to be(Integer)
       end
 
       it 'has the correct constraints' do
-        compiled.constraints.keys.should eq([:positive])
+        expect(compiled.constraints.map(&:name)).to eq([:positive])
       end
 
       it 'has the expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :sub_type,
           [:builtin_type, "Integer"],
           [:constraint, "positive", [:fn, [:parameters, "i"], [:source, "i >= 0"]]]
@@ -58,17 +58,17 @@ module Finitio
       let(:input){ '.Integer( i | positive: i >= 0, small: i <= 255 )' }
 
       it 'compiles to a SubType' do
-        compiled.should be_a(SubType)
-        compiled.super_type.should be_a(BuiltinType)
-        compiled.super_type.ruby_type.should be(Integer)
+        expect(compiled).to be_a(SubType)
+        expect(compiled.super_type).to be_a(BuiltinType)
+        expect(compiled.super_type.ruby_type).to be(Integer)
       end
 
       it 'has the correct constraints' do
-        compiled.constraints.keys.should eq([:positive, :small])
+        expect(compiled.constraints.map(&:name)).to eq([:positive, :small])
       end
 
       it 'has the expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :sub_type,
           [:builtin_type, "Integer"],
           [:constraint, "positive", [:fn, [:parameters, "i"], [:source, "i >= 0"]]],

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

@@ -14,7 +14,7 @@ module Finitio
       let(:input){ "Int = .Integer\n{r: Int}" }
 
       it 'has the expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :system,
           [:type_def, "Int", [:builtin_type, "Integer"]],
           [:tuple_type, [:heading, [:attribute, "r", [:type_ref, "Int"]]]]
@@ -26,7 +26,7 @@ module Finitio
       let(:input){ "Int = .Integer" }
 
       it 'has the expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :system,
           [:type_def, "Int", [:builtin_type, "Integer"]]
         ])
@@ -37,7 +37,7 @@ module Finitio
       let(:input){ "{r: .Integer}" }
 
       it 'has the expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :system,
           [:tuple_type, [:heading, [:attribute, "r", [:builtin_type, "Integer"]]]]
         ])

data/spec/syntax/nodes/test_tuple_type.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+module Finitio
+  describe Syntax, "tuple_type" do
+
+    subject{
+      Syntax.parse(input, root: "tuple_type")
+    }
+
+    describe "compilation result" do
+      let(:compiled){
+        subject.compile(type_factory)
+      }
+
+      context 'empty heading' do
+        let(:input){ '{ }' }
+
+        it 'compiles to a TupleType' do
+          expect(compiled).to be_a(TupleType)
+          expect(compiled.heading).to be_empty
+        end
+      end
+
+      context '{a: .Integer}' do
+        let(:input){ '{a: .Integer}' }
+
+        it 'compiles to a TupleType' do
+          expect(compiled).to be_a(TupleType)
+          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 TupleType' do
+          expect(compiled).to be_a(TupleType)
+          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 MultiTupleType' do
+          expect(compiled).to be_a(MultiTupleType)
+          expect(compiled.heading.size).to eq(2)
+        end
+      end
+
+      context '{a: .Integer, ...}' do
+        let(:input){ '{a: .Integer, ...}' }
+
+        it 'compiles to a MultiTupleType' do
+          expect(compiled).to be_a(MultiTupleType)
+          expect(compiled.heading.size).to eq(1)
+          expect(compiled.heading).to be_allow_extra
+        end
+      end
+    end
+
+    describe "AST" do
+      let(:ast){ subject.to_ast }
+
+      context '{a: .Integer}' do
+        let(:input){ '{a: .Integer}' }
+
+        it{
+          expect(ast).to eq([
+            :tuple_type,
+            [
+              :heading,
+              [ :attribute, "a", [:builtin_type, "Integer" ]]
+            ]
+          ])
+        }
+      end
+
+      context '{a :? .Integer}' do
+        let(:input){ '{a :? .Integer}' }
+
+        it{
+          expect(ast).to eq([
+            :multi_tuple_type,
+            [
+              :heading,
+              [ :attribute, "a", [:builtin_type, "Integer" ], false]
+            ]
+          ])
+        }
+      end
+    end
+
+  end
+end

data/spec/syntax/nodes/test_type_def.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+module Finitio
+  describe Syntax, "type_def" do
+
+    subject{
+      Syntax.parse(input, root: "type_def")
+    }
+
+    let(:sys){
+      system
+    }
+
+    let(:compiled){
+      subject.compile(sys)
+    }
+
+    let(:ast){
+      subject.to_ast
+    }
+
+    context 'when referening an anonymous type' do
+      let(:input){ 'Int = .Integer' }
+
+      it 'add the type to the system' do
+        compiled
+        expect(sys["Int"]).to be_a(BuiltinType)
+      end
+
+      it 'has the expected AST' do
+        expect(ast).to eq([:type_def, "Int", [:builtin_type, "Integer"]])
+      end
+    end
+
+    context 'when making an alias' do
+      let(:legacy) {
+        BuiltinType.new(Integer, "Int")
+      }
+
+      let(:input){ 'Alias = Int' }
+
+      before do
+        sys.add_type(legacy)
+      end
+
+      it 'add the type to the system' do
+        compiled
+        expect(sys["Alias"]).to be_a(AliasType)
+        expect(sys["Alias"]).to eq(legacy)
+      end
+
+      it 'has the expected AST' do
+        expect(ast).to eq([:type_def, "Alias", [:type_ref, "Int"]])
+      end
+    end
+
+  end
+end

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

@@ -25,12 +25,12 @@ module Finitio
     let(:input){ 'Int' }
 
     it 'compiles to a the BuiltinType' do
-      compiled.should be_a(BuiltinType)
-      compiled.name.should eq("Int")
+      expect(compiled).to be_a(BuiltinType)
+      expect(compiled.name).to eq("Int")
     end
 
     it 'has the expected AST' do
-      ast.should eq([:type_ref, "Int"])
+      expect(ast).to eq([:type_ref, "Int"])
     end
 
   end

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

@@ -15,8 +15,8 @@ module Finitio
         let(:input){ '.Integer|.Float' }
 
         it 'compiles to a UnionType' do
-          compiled.should be_a(UnionType)
-          compiled.should eq(UnionType.new([intType, floatType]))
+          expect(compiled).to be_a(UnionType)
+          expect(compiled).to eq(UnionType.new([intType, floatType]))
         end
       end
     end
@@ -26,7 +26,7 @@ module Finitio
 
       let(:ast){ subject.to_ast }
 
-      it{ ast.should eq([
+      it{ expect(ast).to eq([
           :union_type,
           [:builtin_type, "Integer"],
           [:builtin_type, "Float"]

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

@@ -17,21 +17,21 @@ module Finitio
     context 'a >= 10' do
       let(:input){ 'a >= 10' }
 
-      it 'compiles to an Hash' do
-        compiled.should be_a(Hash)
+      it 'compiles to an Constraint' do
+        expect(compiled).to be_a(Constraint)
       end
 
-      it 'has expected keys' do
-        compiled.keys.should eq([:predicate])
+      it 'is anonymous' do
+        expect(compiled).to be_anonymous
       end
 
       it 'should be the correct Proc' do
-        compiled[:predicate].call(12).should be_true
-        compiled[:predicate].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,
           "default",
           [:fn, [:parameters, "a"], [:source, "a >= 10"]]

data/spec/syntax/test_compile.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Finitio
+  describe Syntax, '.compile' do
+
+    subject do
+      Syntax.compile(source)
+    end
+
+    context 'with a single main type' do
+      let(:source){
+        <<-EOF.strip
+        .Integer
+        EOF
+      }
+
+      it{ should be_a(System) }
+
+      it 'should have main type' do
+        expect(subject.main).to be_a(BuiltinType)
+        expect(subject['Main']).to be(subject.main)
+      end
+    end
+
+    context 'with a single main alias type' do
+      let(:source){
+        <<-EOF.strip
+        Int = .Integer
+        Int
+        EOF
+      }
+
+      it{ should be_a(System) }
+
+      it 'should have main type' do
+        expect(subject.main).to be_a(AliasType)
+        expect(subject['Main']).to be(subject.main)
+      end
+    end
+
+  end
+end

data/spec/{unit/syntax → syntax}/test_compile_type.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 module Finitio
-  describe Syntax, '.compile' do
+  describe Syntax, '.compile_type' do
 
     let(:source){
       <<-EOF.strip

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

@@ -10,12 +10,12 @@ module Finitio
       let(:type){ intType }
 
       it 'should return the created type' do
-        subject.should be(type)
+        expect(subject).to be(type)
       end
 
       it 'should add the type' do
         subject
-        system[type.name].should be(type)
+        expect(system[type.name]).to be(type)
       end
     end
 
@@ -23,9 +23,9 @@ module Finitio
       let(:type){ "foo" }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error(ArgumentError, "Finitio::Type expected, got `foo`")
+        }.to raise_error(ArgumentError, "Unable to factor a Finitio::Type from `foo`")
       end
     end
 
@@ -37,9 +37,9 @@ module Finitio
       end
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error(Finitio::Error, "Duplicate type name `intType`")
+        }.to raise_error(Finitio::Error, "Duplicate type name `intType`")
       end
     end
 

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

@@ -20,9 +20,9 @@ module Finitio
       it{ should be_a(SubType) }
 
       it 'should apply the constraint' do
-        ->{
+        expect{
           subject.dress(-9)
-        }.should raise_error(TypeError)
+        }.to raise_error(TypeError)
       end
     end
 

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

@@ -13,17 +13,17 @@ module Finitio
     it{ should be_a(System) }
 
     it 'should not be the same object' do
-      subject.should_not be(system)
+      expect(subject).not_to be(system)
     end
 
     it 'should have intType' do
-      subject['intType'].should eq(intType)
+      expect(subject['intType']).to eq(intType)
     end
 
     it 'should not share internals with the original' do
       subject.add_type(floatType)
-      subject['floatType'].should_not be_nil
-      system['floatType'].should be_nil
+      expect(subject['floatType']).not_to be_nil
+      expect(system['floatType']).to be_nil
     end
 
   end

data/spec/{unit/system → system}/test_fetch.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,9 +22,9 @@ module Finitio
       let(:name){ "noSuchOne" }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error(KeyError, /noSuchOne/)
+        }.to raise_error(KeyError, /noSuchOne/)
       end
     end
 
@@ -34,7 +34,7 @@ module Finitio
       }
 
       it 'should yield the block' do
-        subject.should eq("bar")
+        expect(subject).to eq("bar")
       end
     end