qrb 0.1.0

data/spec/unit/type_factory/dsl/test_adt.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+module Qrb
+  describe TypeFactory, "DSL#adt" do
+
+    let(:factory){ TypeFactory.new }
+
+    let(:contracts){
+      { rgb: [intType,   Color.method(:rgb) ],
+        hex: [floatType, Color.method(:hex) ]}
+    }
+
+    shared_examples_for "The <Color> type" do
+
+      it{ should be_a(AdType) }
+
+      it 'should have the correct ruby type' do
+        subject.ruby_type.should be(Color)
+      end
+
+      it 'should have the two contracts' do
+        subject.contracts.keys.should eq([:rgb, :hex])
+      end
+    end
+
+    before do
+      subject
+    end
+
+    context 'when used with the standard signature' do
+      subject{
+        factory.adt(Color, contracts)
+      }
+
+      it_should_behave_like "The <Color> type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("Color")
+      end
+    end
+
+    context 'when used with a name' do
+      subject{
+        factory.adt(Color, contracts, "MyColor")
+      }
+
+      it_should_behave_like "The <Color> type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("MyColor")
+      end
+    end
+
+  end
+end

data/spec/unit/type_factory/dsl/test_attribute.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Qrb
+  describe TypeFactory, "DSL#attribute" do
+
+    let(:factory){ TypeFactory.new }
+
+    shared_examples_for "The a:Integer attribute" do
+
+      it{ should be_a(Attribute) }
+
+      it 'should have the correct name' do
+        subject.name.should eq(:a)
+      end
+
+      it 'should have the correct type' do
+        subject.type.should eq(intType)
+      end
+    end
+
+    context 'when used with a ruby class' do
+      subject{
+        factory.attribute(:a, Integer)
+      }
+
+      it_should_behave_like "The a:Integer attribute"
+    end
+
+    context 'when used with a type' do
+      subject{
+        factory.attribute(:a, intType)
+      }
+
+      it_should_behave_like "The a:Integer attribute"
+    end
+
+  end
+end

data/spec/unit/type_factory/dsl/test_attributes.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Qrb
+  describe TypeFactory, "DSL#attributes" do
+
+    let(:factory){ TypeFactory.new }
+
+    shared_examples_for "The a:Integer, b:Float attributes" do
+
+      it{ should be_a(Array) }
+
+      it 'should be the correct pair' do
+        subject.should eq([ Attribute.new(:a, intType), Attribute.new(:b, floatType) ])
+      end
+    end
+
+    context 'when used with ruby classes' do
+      subject{
+        factory.attributes(a: Integer, b: Float)
+      }
+
+      it_should_behave_like "The a:Integer, b:Float attributes"
+    end
+
+    context 'when used with types' do
+      subject{
+        factory.attributes(a: intType, b: floatType)
+      }
+
+      it_should_behave_like "The a:Integer, b:Float attributes"
+    end
+
+    context 'when used with a mix of both types' do
+      subject{
+        factory.attributes(a: Integer, b: floatType)
+      }
+
+      it_should_behave_like "The a:Integer, b:Float attributes"
+    end
+
+  end
+end

data/spec/unit/type_factory/dsl/test_builtin.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+module Qrb
+  describe TypeFactory, "DSL#builtin" do
+
+    let(:factory){ TypeFactory.new }
+
+    shared_examples_for "The Integer builtin type" do
+
+      it{ should be_a(BuiltinType) }
+
+      it 'should have the correct ruby type' do
+        subject.ruby_type.should be(Integer)
+      end
+    end
+
+    before do
+      subject
+    end
+
+    context 'when used with a ruby class and no name' do
+      subject{
+        factory.builtin(Integer)
+      }
+
+      it_should_behave_like "The Integer builtin type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("Integer")
+      end
+    end
+
+    context 'when used with a ruby class and a name' do
+      subject{
+        factory.builtin(Integer, "Int")
+      }
+
+      it_should_behave_like "The Integer builtin type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("Int")
+      end
+    end
+
+  end
+end

data/spec/unit/type_factory/dsl/test_relation.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+module Qrb
+  describe TypeFactory, "DSL#relation" do
+
+    let(:factory){ TypeFactory.new }
+
+    let(:heading){
+      Heading.new([ Attribute.new(:a, intType) ])
+    }
+
+    shared_examples_for "The Relation[a: Int] type" do
+
+      it{ should be_a(RelationType) }
+
+      it 'should have the correct heading' do
+        subject.heading.should eq(heading)
+      end
+    end
+
+    before do
+      subject
+    end
+
+    context 'when used with the standard signature' do
+      subject{
+        factory.relation(heading, "MyRelation")
+      }
+
+      it_should_behave_like "The Relation[a: Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("MyRelation")
+      end
+    end
+
+    context 'when used with a tuple type' do
+      subject{
+        factory.relation(TupleType.new(heading), "MyRelation")
+      }
+
+      it_should_behave_like "The Relation[a: Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("MyRelation")
+      end
+    end
+
+    context 'when used with a hash and ruby classes' do
+      subject{
+        factory.relation(a: Integer)
+      }
+
+      it_should_behave_like "The Relation[a: Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("{{a: Integer}}")
+      end
+    end
+
+    context 'when used with a hash and a name' do
+      subject{
+        factory.relation({a: Integer}, "MyRelation")
+      }
+
+      it_should_behave_like "The Relation[a: Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("MyRelation")
+      end
+    end
+
+    context 'when used with a hash and types' do
+      subject{
+        factory.relation(a: intType)
+      }
+
+      it_should_behave_like "The Relation[a: Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("{{a: intType}}")
+      end
+    end
+
+  end
+end

data/spec/unit/type_factory/dsl/test_seq.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+module Qrb
+  describe TypeFactory, "DSL#seq" do
+
+    let(:factory){ TypeFactory.new }
+
+    shared_examples_for "The Seq[Int] type" do
+
+      it{ should be_a(SeqType) }
+
+      it 'should have the correct element type' do
+        subject.elm_type.should eq(intType)
+      end
+    end
+
+    before do
+      subject
+    end
+
+    context 'when used with a ruby class' do
+      subject{
+        factory.seq(Integer)
+      }
+
+      it_should_behave_like "The Seq[Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("[Integer]")
+      end
+    end
+
+    context 'when used with a type' do
+      subject{
+        factory.seq(intType)
+      }
+
+      it_should_behave_like "The Seq[Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("[intType]")
+      end
+    end
+
+    context 'when used with an explicit name' do
+      subject{
+        factory.seq(intType, "MySeq")
+      }
+
+      it_should_behave_like "The Seq[Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("MySeq")
+      end
+    end
+
+  end
+end

data/spec/unit/type_factory/dsl/test_set.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+module Qrb
+  describe TypeFactory, "DSL#set" do
+
+    let(:factory){ TypeFactory.new }
+
+    shared_examples_for "The Set[Int] type" do
+
+      it{ should be_a(SetType) }
+
+      it 'should have the correct element type' do
+        subject.elm_type.should eq(intType)
+      end
+    end
+
+    before do
+      subject
+    end
+
+    context 'when used with a ruby class' do
+      subject{
+        factory.set(Integer)
+      }
+
+      it_should_behave_like "The Set[Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("{Integer}")
+      end
+    end
+
+    context 'when used with a type' do
+      subject{
+        factory.set(intType)
+      }
+
+      it_should_behave_like "The Set[Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("{intType}")
+      end
+    end
+
+    context 'when used with an explicit name' do
+      subject{
+        factory.set(intType, "MySet")
+      }
+
+      it_should_behave_like "The Set[Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("MySet")
+      end
+    end
+
+  end
+end

data/spec/unit/type_factory/dsl/test_subtype.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+module Qrb
+  describe TypeFactory, "DSL#subtype" do
+
+    let(:factory){ TypeFactory.new }
+
+    let(:constraints){
+      { predicate: 1..10 }
+    }
+
+    shared_examples_for "The PosInt type" do
+
+      it{ should be_a(SubType) }
+
+      it 'should have the BuiltinType(Integer) super type' do
+        subject.super_type.should be_a(BuiltinType)
+        subject.super_type.ruby_type.should be(Integer)
+      end
+
+      it 'should have the correct constraint' do
+        ->{
+          subject.dress(-12)
+        }.should raise_error(TypeError)
+      end
+    end
+
+    shared_examples_for "The SmallInt structural type" do
+
+      it{ should be_a(SubType) }
+
+      it 'should have the BuiltinType(Integer) super type' do
+        subject.super_type.should be_a(BuiltinType)
+        subject.super_type.ruby_type.should be(Integer)
+      end
+
+      it 'should have the correct constraints' do
+        subject.constraints.should eq(constraints)
+      end
+    end
+
+    before do
+      subject
+    end
+
+    context 'when used with a type' do
+      subject{
+        supertype = BuiltinType.new(Integer)
+        factory.subtype(supertype, constraints)
+      }
+
+      it_should_behave_like "The SmallInt structural type"
+    end
+
+    context 'when used with a ruby class' do
+      subject{
+        factory.subtype(Integer, constraints)
+      }
+
+      it_should_behave_like "The SmallInt structural type"
+    end
+
+    context 'when used with a constraints shorthand' do
+      subject{
+        factory.subtype(Integer, 1..10)
+      }
+
+      it_should_behave_like "The SmallInt structural type"
+    end
+
+    context 'when used with a constraint block' do
+      subject{
+        factory.subtype(Integer){|i| i >=0 }
+      }
+
+      it_should_behave_like "The PosInt type"
+    end
+
+    context 'when used with a name' do
+      subject{
+        factory.subtype(Integer, constraints, "SmallInt")
+      }
+
+      it_should_behave_like "The SmallInt structural type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("SmallInt")
+      end
+    end
+
+  end
+end

data/spec/unit/type_factory/dsl/test_tuple.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+module Qrb
+  describe TypeFactory, "DSL#tuple" do
+
+    let(:factory){ TypeFactory.new }
+
+    let(:heading){
+      Heading.new([ Attribute.new(:a, intType) ])
+    }
+
+    shared_examples_for "The Tuple[a: Int] type" do
+
+      it{ should be_a(TupleType) }
+
+      it 'should have the correct heading' do
+        subject.heading.should eq(heading)
+      end
+    end
+
+    before do
+      subject
+    end
+
+    context 'when used with the standard signature' do
+      subject{
+        factory.tuple(heading, "MyTuple")
+      }
+
+      it_should_behave_like "The Tuple[a: Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("MyTuple")
+      end
+    end
+
+    context 'when used with a hash and ruby classes' do
+      subject{
+        factory.tuple(a: Integer)
+      }
+
+      it_should_behave_like "The Tuple[a: Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("{a: Integer}")
+      end
+    end
+
+    context 'when used with a hash and a name' do
+      subject{
+        factory.tuple({a: Integer}, "MyTuple")
+      }
+
+      it_should_behave_like "The Tuple[a: Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("MyTuple")
+      end
+    end
+
+    context 'when used with a hash and types' do
+      subject{
+        factory.tuple(a: intType)
+      }
+
+      it_should_behave_like "The Tuple[a: Int] type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("{a: intType}")
+      end
+    end
+
+  end
+end

data/spec/unit/type_factory/dsl/test_union.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+module Qrb
+  describe TypeFactory, "DSL#union" do
+
+    let(:factory){ TypeFactory.new }
+
+    shared_examples_for "The Int|Float union type" do
+
+      it{ should be_a(UnionType) }
+
+      it 'should have the correct candidates' do
+        subject.candidates.should eq([intType, floatType])
+      end
+    end
+
+    before do
+      subject
+    end
+
+    context 'when used with the standard signature' do
+      subject{
+        factory.union([Integer, Float], 'MyUnion')
+      }
+
+      it_should_behave_like "The Int|Float union type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("MyUnion")
+      end
+    end
+
+    context 'when used with the standard signature and no name' do
+      subject{
+        factory.union([Integer, Float])
+      }
+
+      it_should_behave_like "The Int|Float union type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("Integer|Float")
+      end
+    end
+
+    context 'when used with a list of ruby classes' do
+      subject{
+        factory.union(Integer, Float)
+      }
+
+      it_should_behave_like "The Int|Float union type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("Integer|Float")
+      end
+    end
+
+    context 'when used with a list of types' do
+      subject{
+        factory.union(intType, floatType)
+      }
+
+      it_should_behave_like "The Int|Float union type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("intType|floatType")
+      end
+    end
+
+    context 'when used with a mix of both' do
+      subject{
+        factory.union(Integer, floatType)
+      }
+
+      it_should_behave_like "The Int|Float union type"
+
+      it 'should have the correct name' do
+        subject.name.should eq("Integer|floatType")
+      end
+    end
+
+  end
+end

data/spec/unit/type_factory/factory/test_builtin.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Qrb
+  describe TypeFactory, "Factory#builtin" do
+
+    let(:factory){ TypeFactory.new }
+
+    context 'when use with a ruby class' do
+      subject{ factory.type(Integer) }
+
+      it{ should eq(intType) }
+    end
+
+    context 'when use with a ruby class and a name' do
+      subject{ factory.type(Integer, "Int") }
+
+      it{ should eq(intType) }
+
+      it 'should have the correct name' do
+        subject.name.should eq("Int")
+      end
+    end
+
+  end
+end

data/spec/unit/type_factory/factory/test_seq_type.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+module Qrb
+  describe TypeFactory, "Factory#seq" do
+
+    let(:factory){ TypeFactory.new }
+
+    context 'for sequences of scalars' do
+      let(:expected){ SeqType.new(intType) }
+
+      context 'when used with [Class]' do
+        subject{ factory.type([Integer]) }
+
+        it{ should eq(expected) }
+      end
+
+      context 'when used with [Class] and a name' do
+        subject{ factory.type([Integer], "MySeq") }
+
+        it{ should eq(expected) }
+
+        it 'should have the correct name' do
+          subject.name.should eq("MySeq")
+        end
+      end
+    end
+
+    context 'for pseudo-relations' do
+      subject{
+        factory.type([{r: Integer}], "MySeq")
+      }
+
+      let(:expected){
+        factory.seq(factory.tuple(r: Integer))
+      }
+
+      it{ should eq(expected) }
+
+      it 'should have the correct name' do
+        subject.name.should eq("MySeq")
+      end
+    end
+
+  end
+end