qrb 0.1.0

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Qrb
+  describe SetType, 'initialize' do
+
+    subject{
+      SetType.new(intType)
+    }
+
+    context 'with valid arguments' do
+      it{ should be_a(SetType) }
+
+      it 'should set the instance variables' do
+        subject.elm_type.should eq(intType)
+      end
+    end
+
+    context 'with invalid arguments' do
+      subject{ SetType.new("foo") }
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error(ArgumentError, 'Qrb::Type expected, got `foo`')
+      end
+    end
+
+  end
+end

data/spec/unit/type/set_type/test_name.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Qrb
+  describe SetType, 'name' do
+
+    subject{ type.name }
+
+    context 'when not specified' do
+      let(:type){
+        SetType.new(intType)
+      }
+
+      it{ should eq('{intType}') }
+    end
+
+    context 'when specified' do
+      let(:type){
+        SetType.new(intType, "foo")
+      }
+
+      it{ should eq('foo') }
+    end
+
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Qrb
+  describe SubType, "default_name" do
+
+    let(:type){ SubType.new(intType, posint: ->(i){}) }
+
+    subject{ type.default_name }
+
+    it 'uses the first constraint name' do
+      subject.should eq("Posint")
+    end
+
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'spec_helper'
+module Qrb
+  describe SubType, "dress" do
+
+    let(:type){ SubType.new(intType, {default: ->(i){ i>0 }, small: ->(i){ i<255 }}, "byte") }
+
+    subject{ type.dress(arg) }
+
+    context 'with an valid Integer' do
+      let(:arg){ 12 }
+
+      it{ should be(arg) }
+    end
+
+    context 'when raising an Error' do
+
+      subject do
+        type.dress(arg) rescue $!
+      end
+
+      context 'with a Float' do
+        let(:arg){ 12.0 }
+
+        it 'should raise an Error' do
+          subject.should be_a(TypeError)
+          subject.message.should eq("Invalid value `12.0` for byte")
+        end
+
+        it "should have the proper cause from super type's up" do
+          subject.cause.should be_a(TypeError)
+          subject.cause.message.should eq("Invalid value `12.0` for intType")
+        end
+
+        it "should have an empty location" do
+          subject.location.should eq('')
+        end
+      end
+
+      context 'with a negative integer' do
+        let(:arg){ -12 }
+
+        it 'should raise an Error' do
+          subject.should be_a(TypeError)
+          subject.message.should eq("Invalid value `-12` for byte")
+        end
+
+        it "should have no cause" do
+          subject.cause.should be_nil
+        end
+
+        it "should have an empty location" do
+          subject.location.should eq('')
+        end
+      end
+
+      context 'with a non small integer' do
+        let(:arg){ 1000 }
+
+        it 'should raise an Error' do
+          subject.should be_a(TypeError)
+          subject.message.should eq("Invalid value `1000` for byte (not small)")
+        end
+
+        it "should have no cause" do
+          subject.cause.should be_nil
+        end
+
+        it "should have an empty location" do
+          subject.location.should eq('')
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Qrb
+  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_include.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Qrb
+  describe SubType, "include?" do
+
+    let(:type){ SubType.new(intType, {default: ->(i){ i>0 }, small: ->(i){ i<255 }}, "byte") }
+
+    subject{ type.include?(arg) }
+
+    context 'when included on int' do
+      let(:arg){ 12 }
+
+      it{ should be_true }
+    end
+
+    context 'when not included on int (I)' do
+      let(:arg){ -12 }
+
+      it{ should be_false }
+    end
+
+    context 'when not included on int (II)' do
+      let(:arg){ 255 }
+
+      it{ should be_false }
+    end
+
+    context 'when not included' do
+      let(:arg){ "12" }
+
+      it{ should be_false }
+    end
+
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Qrb
+  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

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Qrb
+  describe SubType, "name" do
+
+    subject{ type.name }
+
+    context 'when provided' do
+      let(:type){ SubType.new(intType, {posint: ->(i){}}, "Foo") }
+
+      it 'uses the specified one' do
+        subject.should eq("Foo")
+      end
+    end
+
+    context 'when not provided' do
+      let(:type){ SubType.new(intType, posint: ->(i){}) }
+
+      it 'uses the first constraint name' do
+        subject.should eq("Posint")
+      end
+    end
+
+  end
+end

data/spec/unit/type/tuple_type/test_default_name.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Qrb
+  describe TupleType, "default_name" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, byte)])
+    }
+
+    subject{ TupleType.new(heading).default_name }
+
+    it{ should eq("{a: Byte}") }
+
+  end
+end

data/spec/unit/type/tuple_type/test_dress.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+module Qrb
+  describe TupleType, "dress" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:r, byte),
+                   Attribute.new(:g, byte),
+                   Attribute.new(:b, byte)])
+    }
+
+    let(:type){
+      TupleType.new(heading, "color")
+    }
+
+    subject{ type.dress(arg)  }
+
+    context 'with a valid Hash' do
+      let(:arg){
+        { "r" => 12, "g" => 13, "b" => 255 }
+      }
+
+      it 'should coerce to a tuple' do
+        subject.should eq(r: 12, g: 13, b: 255)
+      end
+    end
+
+    context 'when raising an error' do
+
+      subject do
+        type.dress(arg) rescue $!
+      end
+
+      context 'with something else than a Hash' do
+        let(:arg){
+          "foo"
+        }
+
+        it 'should raise a TypeError' do
+          subject.should be_a(TypeError)
+          subject.message.should eq("Invalid value `foo` for color")
+        end
+
+        it 'should have no cause' do
+          subject.cause.should be_nil
+        end
+
+        it 'should have an empty location' do
+          subject.location.should eq('')
+        end
+      end
+
+      context 'with a missing attribute' do
+        let(:arg){
+          { "r" => 12, "g" => 13 }
+        }
+
+        it 'should raise a TypeError' do
+          subject.should be_a(TypeError)
+          subject.message.should eq("Missing attribute `b`")
+        end
+
+        it 'should have no cause' do
+          subject.cause.should be_nil
+        end
+
+        it 'should have an empty location' do
+          subject.location.should eq('')
+        end
+      end
+
+      context 'with an extra attribute' do
+        let(:arg){
+          { "r" => 12, "g" => 13, "b" => 255, "extr" => 165 }
+        }
+
+        it 'should raise a TypeError' do
+          subject.should be_a(TypeError)
+          subject.message.should eq("Unrecognized attribute `extr`")
+        end
+
+        it 'should have no cause' do
+          subject.cause.should be_nil
+        end
+
+        it 'should have an empty location' do
+          subject.location.should eq('')
+        end
+      end
+
+      context 'with an invalid attribute' do
+        let(:arg){
+          { "r" => 12.0, "g" => 13, "b" => 255 }
+        }
+
+        it 'should raise a TypeError' do
+          subject.should be_a(TypeError)
+          subject.message.should eq("Invalid value `12.0` for Byte")
+        end
+
+        it 'should have the correct cause' do
+          subject.cause.should be_a(TypeError)
+          subject.cause.message.should eq("Invalid value `12.0` for intType")
+        end
+
+        it 'should have the correct location' do
+          subject.location.should eq("r")
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Qrb
+  describe TupleType, "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)])                             }
+
+    let(:type1)  { TupleType.new(h1) }
+    let(:type2)  { TupleType.new(h2) }
+    let(:type3)  { TupleType.new(h3) }
+
+    it 'should apply structural equality' do
+      (type1 == type2).should be_true
+      (type2 == type1).should be_true
+    end
+
+    it 'should apply distinguish different types' do
+      (type1 == type3).should be_false
+      (type2 == type3).should be_false
+    end
+
+    it 'should be a total function, with nil for non types' do
+      (type1 == 12).should be_false
+    end
+
+    it 'should implement hash accordingly' do
+      [type1, type2].map(&:hash).uniq.size.should eq(1)
+    end
+
+  end
+end

data/spec/unit/type/tuple_type/test_include.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Qrb
+  describe TupleType, "include?" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, intType)])
+    }
+
+    let(:type){ TupleType.new(heading) }
+
+    subject{ type.include?(arg) }
+
+    context 'when a valid hash' do
+      let(:arg){ {a: 12} }
+
+      it{ should be_true }
+    end
+
+    context 'when an invalid hash (too many attributes)' do
+      let(:arg){ {a: 12, b: 15} }
+
+      it{ should be_false }
+    end
+
+    context 'when an invalid hash (too few attributes)' do
+      let(:arg){ {b: 12} }
+
+      it{ should be_false }
+    end
+
+    context 'when an invalid hash (wrong type)' do
+      let(:arg){ {a: 12.0} }
+
+      it{ should be_false }
+    end
+
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Qrb
+  describe TupleType, "initialize" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, intType)])
+    }
+
+    context 'with a valid heading' do
+      subject{ TupleType.new(heading) }
+
+      it{ should be_a(TupleType) }
+
+      it 'correctly sets the instance variable' do
+        subject.heading.should eq(heading)
+      end
+    end
+
+    context 'with an invalid heading' do
+      subject{ TupleType.new("foo") }
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error(ArgumentError, "Heading expected, got `foo`")
+      end
+    end
+
+  end
+end

data/spec/unit/type/tuple_type/test_name.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Qrb
+  describe TupleType, "name" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, byte)])
+    }
+
+    subject{ type.name }
+
+    context 'when not provided' do
+      let(:type){ TupleType.new(heading) }
+
+      it{ should eq("{a: Byte}") }
+    end
+
+    context 'when provided' do
+      let(:type){ TupleType.new(heading, "Color") }
+
+      it{ should eq("Color") }
+    end
+
+  end
+end

data/spec/unit/type/union_type/test_default_name.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+module Qrb
+  describe UnionType, "default_name" do
+
+    subject{ type.default_name }
+
+    let(:type){ UnionType.new([intType, floatType]) }
+
+    it{ should eq('intType|floatType') }
+
+  end
+end

data/spec/unit/type/union_type/test_dress.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+module Qrb
+  describe UnionType, "dress" do
+
+    let(:type)      { UnionType.new([intType, floatType], "union") }
+
+    subject{ type.dress(arg) }
+
+    context 'with an Integer' do
+      let(:arg){ 12 }
+
+      it{ should be(arg) }
+    end
+
+    context 'with a Float' do
+      let(:arg){ 12.0 }
+
+      it{ should be(arg) }
+    end
+
+    context 'with a String' do
+      let(:arg){ "foo" }
+
+      subject{
+        type.dress(arg) rescue $!
+      }
+
+      it 'should raise an Error' do
+        subject.should be_a(TypeError)
+        subject.message.should eq("Invalid value `foo` for union")
+      end
+
+      it 'should have no cause' do
+        subject.cause.should be_nil
+      end
+
+      it 'should have an empty location' do
+        subject.location.should eq('')
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Qrb
+  describe UnionType, "equality" do
+
+    let(:uType)  { UnionType.new([intType, floatType]) }
+    let(:uType2) { UnionType.new([floatType, intType]) }
+    let(:uType3) { UnionType.new([floatType, intType]) }
+    let(:uType4) { UnionType.new([intType])            }
+
+    it 'should apply structural equality' do
+      (uType  == uType2).should be_true
+      (uType  == uType3).should be_true
+      (uType2 == uType3).should be_true
+    end
+
+    it 'should apply distinguish different types' do
+      (uType == uType4).should be_false
+      (uType == intType).should be_false
+    end
+
+    it 'should be a total function, with nil for non types' do
+      (uType == 12).should be_false
+    end
+
+    it 'should implement hash accordingly' do
+      [uType, uType2, uType3].map(&:hash).uniq.size.should eq(1)
+    end
+
+  end
+end

data/spec/unit/type/union_type/test_include.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Qrb
+  describe UnionType, "include?" do
+
+    let(:type){ UnionType.new([intType, floatType]) }
+
+    subject{ type.include?(arg) }
+
+    context 'when not included' do
+      let(:arg){ "12" }
+
+      it{ should be_false }
+    end
+
+    context 'when included on int' do
+      let(:arg){ 12 }
+
+      it{ should be_true }
+    end
+
+    context 'when included on float' do
+      let(:arg){ 12.0 }
+
+      it{ should be_true }
+    end
+
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Qrb
+  describe UnionType, "initialize" do
+
+    context 'with valid candidates' do
+      let(:union){ UnionType.new([intType, floatType]) }
+
+      it 'sets the variable instances' do
+        union.candidates.should eq([intType, floatType])
+      end
+    end
+
+    context 'with invalid candidates' do
+      let(:union){ UnionType.new(["bar"]) }
+
+      it 'should raise an error' do
+        ->{
+          union
+        }.should raise_error(ArgumentError, %Q{[Qrb::Type] expected, got ["bar"]})
+      end
+    end
+
+  end
+end

data/spec/unit/type/union_type/test_name.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Qrb
+  describe UnionType, "name" do
+
+    subject{ type.name }
+
+    context 'when not provided' do
+      let(:type){ UnionType.new([intType, floatType]) }
+
+      it{ should eq('intType|floatType') }
+    end
+
+    context 'when provided' do
+      let(:type){ UnionType.new([intType, floatType], "union") }
+
+      it{ should eq('union') }
+    end
+
+  end
+end