finitio 0.7.0.pre.rc2 → 0.9.0

data/spec/type/relation_type/test_suppremum.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+module Finitio
+  describe RelationType, "suppremum" do
+
+    subject{
+      left.suppremum(right)
+    }
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, intType),
+                   Attribute.new(:b, stringType)])
+    }
+
+    let(:left){
+      RelationType.new(heading)
+    }
+
+    context 'when right is not a tuple type' do
+      let(:right){
+        stringType
+      }
+
+      it 'builds a union type' do
+        expect(subject).to be_a(UnionType)
+        expect(subject.candidates).to eql([left, right])
+      end
+    end
+
+    context 'when right is an equal tuple type' do
+      let(:right){
+        RelationType.new(heading)
+      }
+
+      it 'keeps left' do
+        expect(subject).to be(left)
+      end
+    end
+
+    context 'when right is an non-equal tuple type but compatible with RelationType' do
+      let(:heading2){
+        Heading.new([Attribute.new(:a, nilType),
+                     Attribute.new(:b, stringType)])
+      }
+
+      let(:right){
+        RelationType.new(heading2)
+      }
+
+      it 'builds the suppremum as expected' do
+        expect(subject).to be_a(RelationType)
+        expect(subject.heading[:a].type).to eql(UnionType.new [intType,nilType])
+        expect(subject.heading[:b].type).to eql(stringType)
+      end
+    end
+
+    context 'when right is an non-equal tuple type yielding a MultiRelationType' do
+      let(:heading2){
+        Heading.new([Attribute.new(:c, nilType),
+                     Attribute.new(:b, stringType)])
+      }
+
+      let(:right){
+        RelationType.new(heading2)
+      }
+
+      it 'builds the suppremum as expected' do
+        expect(subject).to be_a(MultiRelationType)
+        expect(subject.heading[:a].type).to eql(intType)
+        expect(subject.heading[:a].required).to eql(false)
+        expect(subject.heading[:b].type).to eql(stringType)
+        expect(subject.heading[:b].required).to eql(true)
+        expect(subject.heading[:c].type).to eql(nilType)
+        expect(subject.heading[:c].required).to eql(false)
+      end
+    end
+
+    context 'when right is an non-equal tuple type yielding a MultiRelationType II' do
+      let(:heading2){
+        Heading.new([Attribute.new(:a, nilType, false),
+                     Attribute.new(:b, stringType)])
+      }
+
+      let(:right){
+        MultiRelationType.new(heading2)
+      }
+
+      it 'builds the suppremum as expected' do
+        expect(subject).to be_a(MultiRelationType)
+        expect(subject.heading[:a].type).to eql(UnionType.new [intType,nilType])
+        expect(subject.heading[:a].required).to eql(false)
+        expect(subject.heading[:b].type).to eql(stringType)
+      end
+
+      it 'works the other way round too' do
+        subject = right.suppremum(left)
+        expect(subject).to be_a(MultiRelationType)
+        expect(subject.heading[:a].type).to eql(UnionType.new [intType,nilType])
+        expect(subject.heading[:a].required).to eql(false)
+        expect(subject.heading[:b].type).to eql(stringType)
+      end
+    end
+
+  end
+end

data/spec/type/seq_type/test_suppremum.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+module Finitio
+  describe SeqType, "suppremum" do
+
+    subject{
+      left.suppremum(right)
+    }
+
+    let(:left) {
+      SeqType.new(intType)
+    }
+
+    context 'when right is equal' do
+      let(:right) {
+        SeqType.new(intType)
+      }
+
+      it 'keeps left' do
+        expect(subject).to be(left)
+      end
+    end
+
+    context 'when right is a set type of same element type' do
+      let(:right) {
+        SetType.new(intType)
+      }
+
+      it 'keeps left' do
+        expect(subject).to eql(SeqType.new(intType))
+      end
+    end
+
+    context 'when right is not a seq type' do
+      let(:right) {
+        stringType
+      }
+
+      it 'builds a UnionType' do
+        expect(subject).to eql(UnionType.new [left, right])
+      end
+    end
+
+    context 'when right is a seq type of a different element type' do
+      let(:right) {
+        SeqType.new(floatType)
+      }
+
+      it 'builds a SeqType[UnionType]' do
+        expect(subject).to eql(SeqType.new(UnionType.new [intType, floatType]))
+      end
+    end
+
+  end
+end

data/spec/type/set_type/test_suppremum.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+module Finitio
+  describe SetType, "suppremum" do
+
+    subject{
+      left.suppremum(right)
+    }
+
+    let(:left) {
+      SetType.new(intType)
+    }
+
+    context 'when right is equal' do
+      let(:right) {
+        SetType.new(intType)
+      }
+
+      it 'keeps left' do
+        expect(subject).to be(left)
+      end
+    end
+
+    context 'when right is not a seq type' do
+      let(:right) {
+        stringType
+      }
+
+      it 'builds a UnionType' do
+        expect(subject).to eql(UnionType.new [left, right])
+      end
+    end
+
+    context 'when right is a set type of same element type' do
+      let(:right) {
+        SeqType.new(intType)
+      }
+
+      it 'keeps right' do
+        expect(subject).to eql(SetType.new intType)
+      end
+    end
+
+    context 'when right is a seq type of a different element type' do
+      let(:right) {
+        SetType.new(floatType)
+      }
+
+      it 'builds a SetType[UnionType]' do
+        expect(subject).to eql(SetType.new(UnionType.new [intType, floatType]))
+      end
+    end
+
+  end
+end

data/spec/type/test_suppremum.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+module Finitio
+  describe Type, "suppremum" do
+
+    subject{
+      left.suppremum(right)
+    }
+
+    let(:left){
+      intType
+    }
+
+    context 'when both are equal' do
+      let(:right){
+        intType
+      }
+
+      it 'works' do
+        expect(subject).to be(left)
+      end
+    end
+
+    context 'when they are different' do
+      let(:right){
+        nilType
+      }
+
+      it 'works' do
+        expect(subject).to be_a(UnionType)
+        expect(subject.candidates).to eql([left, right])
+      end
+    end
+
+    context 'when one is any' do
+      let(:right){
+        anyType
+      }
+
+      it 'works' do
+        expect(subject).to eql(anyType)
+      end
+
+      it 'works the other way round' do
+        expect(anyType.suppremum(left)).to eql(anyType)
+      end
+    end
+
+  end
+end

data/spec/type/test_unconstrained.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+module Finitio
+  describe Type, "unconstrained" do
+
+    subject{
+      type.unconstrained
+    }
+
+    context "on Any" do
+      let(:type){
+        ANY_TYPE
+      }
+
+      it 'returns the type itself by default' do
+        expect(subject).to be(type)
+      end
+    end
+
+    context "on a Builtin" do
+      let(:type){
+        intType
+      }
+
+      it 'returns the type itself by default' do
+        expect(subject).to be(type)
+      end
+    end
+
+    context 'on a sub type' do
+      let(:type){
+        pos_byte
+      }
+
+      it 'returns the most unconstrained super type' do
+        expect(subject).to be(intType)
+      end
+    end
+
+    context 'on an alias type' do
+      let(:type){
+        AliasType.new(pos_byte, "alias")
+      }
+
+      it 'returns an alias on the most unconstrained super type' do
+        expect(subject).to be_a(AliasType)
+        expect(subject.target).to be(intType)
+        expect(subject.name).to eql("alias")
+      end
+    end
+
+    context 'on an proxy type' do
+      let(:type){
+        ProxyType.new("pos_byte", pos_byte)
+      }
+
+      it 'returns the most unconstrained super type' do
+        expect(subject).to be(intType)
+      end
+    end
+
+    context 'on an seq type' do
+      let(:type){
+        SeqType.new(pos_byte)
+      }
+
+      it 'returns the most unconstrained super type' do
+        expect(subject).to be_a(SeqType)
+        expect(subject.elm_type).to be(intType)
+      end
+    end
+
+    context 'on an set type' do
+      let(:type){
+        SetType.new(pos_byte)
+      }
+
+      it 'returns the most unconstrained super type' do
+        expect(subject).to be_a(SetType)
+        expect(subject.elm_type).to be(intType)
+      end
+    end
+
+    context 'on an tuple type' do
+      let(:type){
+        TupleType.new(Heading.new [Attribute.new(:i, pos_byte)])
+      }
+
+      it 'returns the most unconstrained super type' do
+        expect(subject).to be_a(TupleType)
+        expect(subject.heading[:i].type).to be(intType)
+      end
+    end
+
+    context 'on an relation type' do
+      let(:type){
+        RelationType.new(Heading.new [Attribute.new(:i, pos_byte)])
+      }
+
+      it 'returns the most unconstrained super type' do
+        expect(subject).to be_a(RelationType)
+        expect(subject.heading[:i].type).to be(intType)
+      end
+    end
+
+    context 'on an union type' do
+      let(:type){
+        UnionType.new([pos_byte])
+      }
+
+      it 'returns the most unconstrained super type' do
+        expect(subject).to be_a(UnionType)
+        expect(subject.candidates).to eql([intType])
+      end
+    end
+
+    context 'on an struct type' do
+      let(:type){
+        StructType.new([pos_byte])
+      }
+
+      it 'returns the most unconstrained super type' do
+        expect(subject).to be_a(StructType)
+        expect(subject.component_types).to eql([intType])
+      end
+    end
+
+    context 'on a high-order type' do
+      let(:type){
+        HighOrderType.new(["V"], pos_byte)
+      }
+
+      it 'returns the most unconstrained super type' do
+        expect(subject).to be_a(HighOrderType)
+        expect(subject.defn).to be(intType)
+      end
+    end
+
+    context 'on an AD type' do
+      let(:type){
+        AdType.new(Color, [rgb_contract])
+      }
+
+      it 'returns the most unconstrained super type' do
+        expect(subject).to be_a(AdType)
+        expect(subject.contracts).to eql([rgb_contract.unconstrained])
+      end
+    end
+
+  end
+end

data/spec/type/tuple_type/test_suppremum.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+module Finitio
+  describe TupleType, "suppremum" do
+
+    subject{
+      left.suppremum(right)
+    }
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, intType),
+                   Attribute.new(:b, stringType)])
+    }
+
+    let(:left){
+      TupleType.new(heading)
+    }
+
+    context 'when right is not a tuple type' do
+      let(:right){
+        stringType
+      }
+
+      it 'builds a union type' do
+        expect(subject).to be_a(UnionType)
+        expect(subject.candidates).to eql([left, right])
+      end
+    end
+
+    context 'when right is an equal tuple type' do
+      let(:h2){
+        Heading.new([Attribute.new(:c, intType),
+                     Attribute.new(:d, stringType)])
+      }
+      let(:right) {
+        TupleType.new(h2)
+      }
+
+      it 'builds a union type' do
+        expect(subject).to be_a(UnionType)
+        expect(subject.candidates).to eql([left, right])
+      end
+    end
+
+    context 'when right is a completely different tuple type' do
+      let(:right){
+        TupleType.new(heading)
+      }
+
+      it 'keeps left' do
+        expect(subject).to be(left)
+      end
+    end
+
+    context 'when right is an non-equal tuple type but compatible with TupleType' do
+      let(:heading2){
+        Heading.new([Attribute.new(:a, nilType),
+                     Attribute.new(:b, stringType)])
+      }
+
+      let(:right){
+        TupleType.new(heading2)
+      }
+
+      it 'builds the suppremum as expected' do
+        expect(subject).to be_a(TupleType)
+        expect(subject.heading[:a].type).to eql(UnionType.new [intType,nilType])
+        expect(subject.heading[:b].type).to eql(stringType)
+      end
+    end
+
+    context 'when right is an non-equal tuple type yielding a MultiTupleType' do
+      let(:heading2){
+        Heading.new([Attribute.new(:c, nilType),
+                     Attribute.new(:b, stringType)])
+      }
+
+      let(:right){
+        TupleType.new(heading2)
+      }
+
+      it 'builds the suppremum as expected' do
+        expect(subject).to be_a(MultiTupleType)
+        expect(subject.heading[:a].type).to eql(intType)
+        expect(subject.heading[:a].required).to eql(false)
+        expect(subject.heading[:b].type).to eql(stringType)
+        expect(subject.heading[:b].required).to eql(true)
+        expect(subject.heading[:c].type).to eql(nilType)
+        expect(subject.heading[:c].required).to eql(false)
+      end
+    end
+
+    context 'when right is an non-equal tuple type yielding a MultiTupleType II' do
+      let(:heading2){
+        Heading.new([Attribute.new(:a, nilType, false),
+                     Attribute.new(:b, stringType)])
+      }
+
+      let(:right){
+        MultiTupleType.new(heading2)
+      }
+
+      it 'builds the suppremum as expected' do
+        expect(subject).to be_a(MultiTupleType)
+        expect(subject.heading[:a].type).to eql(UnionType.new [intType,nilType])
+        expect(subject.heading[:a].required).to eql(false)
+        expect(subject.heading[:b].type).to eql(stringType)
+      end
+
+      it 'works the other way round too' do
+        subject = right.suppremum(left)
+        expect(subject).to be_a(MultiTupleType)
+        expect(subject.heading[:a].type).to eql(UnionType.new [intType,nilType])
+        expect(subject.heading[:a].required).to eql(false)
+        expect(subject.heading[:b].type).to eql(stringType)
+      end
+    end
+
+  end
+end