finitio 0.4.1 → 0.5.0

data/spec/unit/heading/test_equality.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Finitio
-  describe Heading, "equality" do
-
-    let(:h1){ Heading.new([Attribute.new(:r, intType), Attribute.new(:b, intType)]) }
-    let(:h2){ Heading.new([Attribute.new(:b, intType), Attribute.new(:r, intType)]) }
-    let(:h3){ Heading.new([Attribute.new(:b, intType)])                             }
-
-    it 'should apply structural equality' do
-      (h1 == h2).should be_true
-      (h2 == h1).should be_true
-    end
-
-    it 'should apply distinguish different types' do
-      (h1 == h3).should be_false
-      (h2 == h3).should be_false
-    end
-
-    it 'should be a total function, with nil for non types' do
-      (h1 == 12).should be_nil
-    end
-
-    it 'should implement hash accordingly' do
-      [h1, h2].map(&:hash).uniq.size.should eq(1)
-    end
-
-  end
-end

data/spec/unit/heading/test_to_name.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-module Finitio
-  describe Heading, "to_name" do
-
-    subject{ Heading.new(attributes).to_name }
-
-    context 'with no attribute' do
-      let(:attributes){
-        [ ]
-      }
-
-      it{ should eq('') }
-    end
-
-    context 'with one attribute' do
-      let(:attributes){
-        [ Attribute.new(:red, intType) ]
-      }
-
-      it{ should eq('red: intType') }
-    end
-
-    context 'with multiple attributes' do
-      let(:attributes){
-        [ Attribute.new(:red, intType), Attribute.new(:blue, floatType) ]
-      }
-
-      it{ should eq('red: intType, blue: floatType') }
-    end
-
-  end
-end

data/spec/unit/syntax/nodes/test_attribute.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Finitio
-  describe Syntax, "attribute" do
-
-    subject{
-      Syntax.parse(input, root: "attribute")
-    }
-
-    describe 'compilation result' do
-      let(:compiled){
-        subject.compile(type_factory)
-      }
-
-      context 'a: .Integer' do
-        let(:input){ 'a: .Integer' }
-
-        it 'compiles to an Attribute' do
-          compiled.should be_a(Attribute)
-          compiled.name.should eq(:a)
-          compiled.type.should be_a(BuiltinType)
-          compiled.type.ruby_type.should be(Integer)
-        end
-      end
-    end
-
-    describe 'AST' do
-      let(:ast){
-        subject.to_ast
-      }
-
-      let(:input){ 'a: .Integer' }
-
-      it{ ast.should eq([:attribute, "a", [:builtin_type, "Integer"]]) }
-    end
-    
-
-  end
-end

data/spec/unit/syntax/nodes/test_relation_type.rb

@@ -1,59 +0,0 @@
-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
-          compiled.should be_a(RelationType)
-          compiled.heading.should be_empty
-        end
-      end
-
-      context '{{a: .Integer}}' do
-        let(:input){ '{{a: .Integer}}' }
-
-        it 'compiles to a RelationType' do
-          compiled.should be_a(RelationType)
-          compiled.heading.size.should eq(1)
-        end
-      end
-
-      context '{{a: .Integer, b: .Float}}' do
-        let(:input){ '{{a: .Integer, b: .Float}}' }
-
-        it 'compiles to a RelationType' do
-          compiled.should be_a(RelationType)
-          compiled.heading.size.should eq(2)
-        end
-      end
-    end
-
-    describe "AST" do
-      let(:input){ '{{a: .Integer}}' }
-
-      let(:ast){ subject.to_ast }
-
-      it{
-        ast.should eq([
-          :relation_type,
-          [
-            :heading,
-            [ :attribute, "a", [:builtin_type, "Integer" ]]
-          ]
-        ])
-      }
-    end
-
-  end
-end

data/spec/unit/syntax/nodes/test_tuple_type.rb

@@ -1,59 +0,0 @@
-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
-          compiled.should be_a(TupleType)
-          compiled.heading.should be_empty
-        end
-      end
-
-      context '{a: .Integer}' do
-        let(:input){ '{a: .Integer}' }
-
-        it 'compiles to a TupleType' do
-          compiled.should be_a(TupleType)
-          compiled.heading.size.should eq(1)
-        end
-      end
-
-      context '{a: .Integer, b: .Float}' do
-        let(:input){ '{a: .Integer, b: .Float}' }
-
-        it 'compiles to a TupleType' do
-          compiled.should be_a(TupleType)
-          compiled.heading.size.should eq(2)
-        end
-      end
-    end
-
-    describe "AST" do
-      let(:input){ '{a: .Integer}' }
-
-      let(:ast){ subject.to_ast }
-
-      it{
-        ast.should eq([
-          :tuple_type,
-          [
-            :heading,
-            [ :attribute, "a", [:builtin_type, "Integer" ]]
-          ]
-        ])
-      }
-    end
-
-  end
-end

data/spec/unit/syntax/nodes/test_type_def.rb

@@ -1,33 +0,0 @@
-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
-    }
-
-    let(:input){ 'Int = .Integer' }
-
-    it 'add the type to the system' do
-      compiled
-      sys["Int"].should be_a(BuiltinType)
-    end
-
-    it 'has the expected AST' do
-      ast.should eq([:type_def, "Int", [:builtin_type, "Integer"]])
-    end
-
-  end
-end

data/spec/unit/test_finitio.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-describe Finitio do
-
-  it "should have a version number" do
-    Finitio.const_defined?(:VERSION).should be_true
-  end
-
-  it 'should have DSL methods' do
-    t = Finitio.type(Fixnum){|i| i>=0 }
-    t.should be_a(Finitio::SubType)
-    t.dress(12).should eq(12)
-    ->{ t.dress(-12) }.should raise_error(Finitio::TypeError)
-  end
-
-end

data/spec/unit/type/sub_type/test_equality.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-module Finitio
-  describe SubType, "equality" do
-
-    let(:c1){ ->(i){ i>0   } }
-    let(:c2){ ->(i){ i<255 } }
-
-    let(:type) { SubType.new(intType, default: c1)      }
-    let(:type2){ SubType.new(intType, default: c1)      }
-    let(:type3){ SubType.new(intType, another_name: c1) }
-    let(:type4){ SubType.new(intType, default: c2)      }
-    let(:type5){ SubType.new(floatType, default: c1)    }
-
-    it 'should apply structural equality' do
-      (type == type2).should be_true
-      (type == type3).should be_true
-    end
-
-    it 'should apply distinguish different types' do
-      (type == type4).should be_false
-      (type == type5).should be_false
-    end
-
-    it 'should be a total function, with nil for non types' do
-      (type == 12).should be_false
-    end
-
-    it 'should implement hash accordingly' do
-      (type.hash == type2.hash).should be_true
-      (type.hash == type3.hash).should be_true
-    end
-
-  end
-end

data/spec/unit/type/sub_type/test_initialize.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-module Finitio
-  describe SubType, "initialize" do
-
-    let(:c1){ ->(i){ i>0 } }
-    let(:c2){ ->(i){ i<255 } }
-
-    let(:sub){ SubType.new(intType, positive: c1, small: c2) }
-
-    it 'sets the variable instances' do
-      sub.super_type.should eq(intType)
-      sub.constraints.should eq(positive: c1, small: c2)
-    end
-
-  end
-end