qrb 0.1.0

data/spec/unit/heading/test_equality.rb

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Qrb
+  describe Heading, "initialize" do
+
+    subject{ Heading.new(attributes) }
+
+    context 'with no attribute' do
+      let(:attributes){
+        [ ]
+      }
+
+      it{ should be_a(Heading) }
+    end
+
+    context 'with valid attributes' do
+      let(:attributes){
+        [ Attribute.new(:red, intType) ]
+      }
+
+      it{ should be_a(Heading) }
+    end
+
+    context 'with invalid attributes' do
+      let(:attributes){
+        [ Attribute.new(:red, intType), Attribute.new(:red, intType) ]
+      }
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error(ArgumentError, "Attribute names must be unique")
+      end
+    end
+
+  end
+end

data/spec/unit/heading/test_size.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Qrb
+  describe Heading, "size" do
+
+    let(:r){ Attribute.new(:red, intType) }
+    let(:g){ Attribute.new(:green, intType) }
+    let(:b){ Attribute.new(:blue, intType) }
+
+    subject{ heading.size }
+
+    context 'on an empty heading' do
+      let(:heading){ Heading.new([]) }
+
+      it{ should eq(0) }
+    end
+
+    context 'on an singleton heading' do
+      let(:heading){ Heading.new([r]) }
+
+      it{ should eq(1) }
+    end
+
+    context 'on an big heading' do
+      let(:heading){ Heading.new([r, g, b]) }
+
+      it{ should eq(3) }
+    end
+
+  end
+end

data/spec/unit/heading/test_to_name.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Qrb
+  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/qrb/test_parse.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+describe Qrb, "parse" do
+
+  subject{
+    Qrb.parse <<-EOF
+      Posint = .Fixnum( i | i>=0 )
+      Point  = { x: Posint, y: Posint }
+    EOF
+  }
+
+  it{ should be_a(Qrb::System) }
+
+  it 'should have the expected types' do
+    subject["Posint"].should be_a(Qrb::SubType)
+    subject["Point"].should be_a(Qrb::TupleType)
+  end
+
+end

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

@@ -0,0 +1,94 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "ad_type" do
+
+    subject{
+      Syntax.parse(input, root: "ad_type")
+    }
+
+    let(:compiled){
+      subject.compile(type_factory)
+    }
+
+    context 'One contract' do
+      let(:input){ '.Color <rgb> {r: .Integer, g: .Integer, b: .Integer}' }
+
+      it 'compiles to an AdType' do
+        compiled.should be_a(AdType)
+        compiled.ruby_type.should be(Color)
+        compiled.contract_names.should eq([:rgb])
+      end
+
+      it 'should behave as expected' do
+        compiled.dress(r: 138, g: 43, b: 226).should eq(blueviolet)
+      end
+    end
+
+    context 'Two contracts' do
+      let(:input){
+        <<-TYPE.strip
+        .Color <rgb> {r: .Integer, g: .Integer, b: .Integer},
+               <hex> .String
+        TYPE
+      }
+
+      it 'compiles to an AdType' do
+        compiled.should be_a(AdType)
+        compiled.ruby_type.should be(Color)
+        compiled.contract_names.should eq([:rgb, :hex])
+      end
+
+      it 'should behave as expected' do
+        compiled.dress("#8A2BE2").should eq(blueviolet)
+      end
+    end
+
+    context 'No ruby class' do
+      let(:input){ '<as> {r: .Integer}' }
+
+      it 'compiles to an AdType' do
+        compiled.should be_a(AdType)
+        compiled.ruby_type.should be_nil
+        compiled.contract_names.should eq([:as])
+      end
+
+      it 'should behave as expected' do
+        compiled.dress(r: 12).should eq(r: 12)
+        ->{
+          compiled.dress("foo")
+        }.should raise_error(TypeError)
+      end
+    end
+
+    context 'Duplicate contract name' do
+      let(:input){ '.Color <rgb> {r: .Integer}, <rgb> .String' }
+
+      it 'raises an error' do
+        ->{
+          compiled
+        }.should raise_error(Error, "Duplicate contract name `rgb`")
+      end
+    end
+
+    context 'A contract with explicit converters' do
+      let(:input){ '.DateTime <iso> .String \( s | DateTime.parse(s) ) \( d | d.to_s )' }
+
+      it 'compiles to an AdType' do
+        compiled.should be_a(AdType)
+        compiled.ruby_type.should be(DateTime)
+        compiled.contract_names.should eq([:iso])
+      end
+
+      it 'should behave as expected' do
+        compiled.dress("2014-01-19T12:00").should be_a(DateTime)
+      end
+
+      it 'should hide errors' do
+        err = compiled.dress("foo") rescue $!
+        err.should be_a(TypeError)
+        err.message.should eq("Invalid value `foo` for DateTime")
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "attribute" do
+
+    subject{
+      Syntax.parse(input, root: "attribute")
+    }
+
+    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
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "builtin_type" do
+
+    subject{
+      Syntax.parse(source, root: "builtin_type")
+    }
+
+    let(:compiled){
+      subject.compile(type_factory)
+    }
+
+    context 'when an unqualified class name' do
+      let(:source){ ".Integer" }
+
+      it 'compiles to a BuiltinType' do
+        compiled.should be_a(BuiltinType)
+        compiled.ruby_type.should be(Integer)
+      end
+    end
+
+    context 'when a qualified class name' do
+      let(:source){ ".Qrb::Type" }
+
+      it 'compiles to a BuiltinType' do
+        compiled.should be_a(BuiltinType)
+        compiled.ruby_type.should be(::Qrb::Type)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "comment" do
+
+    subject{
+      Syntax.parse(input, root: "comment")
+    }
+
+    [
+      '#',
+      "#\n",
+      "# \n",
+      '# foo bar',
+      "# foo bar\n",
+    ].each do |source|
+      context "when `#{source}`" do
+        let(:input){ source }
+
+        it 'should parse' do
+          subject.should eq(source)
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "constraint_def" do
+
+    subject{
+      Syntax.parse(input, root: "constraint_def")
+    }
+
+    let(:compiled){
+      subject.compile(type_factory)
+    }
+
+    context '(i | i >= 0)' do
+      let(:input){ '(i | i >= 0)' }
+
+      it 'compiles to an Hash' do
+        compiled.should be_a(Hash)
+      end
+
+      it 'compiled to the correct proc' do
+        compiled[:predicate].call(12).should be_true
+        compiled[:predicate].call(-12).should be_false
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "constraints" do
+
+    subject{
+      Syntax.parse(input, root: "constraints")
+    }
+
+    let(:compiled){
+      subject.compile("a")
+    }
+
+    context 'a >= 10' do
+      let(:input){ 'a >= 10' }
+
+      it 'compiles to an Hash' do
+        compiled.should be_a(Hash)
+        compiled.keys.should eq([:predicate])
+      end
+    end
+
+    context 'foo: a >= 10' do
+      let(:input){ 'foo: a >= 10' }
+
+      it 'compiles to an Hash' do
+        compiled.should be_a(Hash)
+        compiled.keys.should eq([:foo])
+      end
+    end
+
+    context 'foo: a >= 10, bar: a <= 255' do
+      let(:input){ 'foo: a >= 10, bar: a <= 255' }
+
+      it 'compiles to an Hash' do
+        compiled.should be_a(Hash)
+        compiled.keys.should eq([:foo, :bar])
+      end
+    end
+
+    context 'foo: a >= 10, foo: a <= 255' do
+      let(:input){ 'foo: a >= 10, foo: a <= 255' }
+
+      it 'compiles to an Hash' do
+        ->{
+          compiled
+        }.should raise_error("Duplicate constraint name `foo`")
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "contract" do
+
+    subject{
+      Syntax.parse(input, root: "contract")
+    }
+
+    let(:contract){
+      compiled.values.first
+    }
+
+    context 'No converter and a class' do
+      let(:input){ '<rgb> {r: .Integer, g: .Integer, b: .Integer}' }
+
+      let(:compiled){
+        subject.compile(type_factory, Color)
+      }
+
+      it 'compiles to the expected Hash' do
+        compiled.should be_a(Hash)
+        compiled.keys.should eq([:rgb])
+        contract.should be_a(Array)
+        contract.first.should be_a(TupleType)
+        contract.last.should be_a(Method)
+      end
+    end
+
+    context 'No converter and no class' do
+      let(:input){ '<rgb> {r: .Integer, g: .Integer, b: .Integer}' }
+
+      let(:compiled){
+        subject.compile(type_factory, nil)
+      }
+
+      it 'compiles to the expected Hash' do
+        compiled.should be_a(Hash)
+        compiled.keys.should eq([:rgb])
+        contract.should be_a(Array)
+        contract.first.should be_a(TupleType)
+        contract.last.should be(Qrb::IDENTITY)
+      end
+    end
+
+    context 'A contract with explicit converters' do
+      let(:input){ '<iso> .String \( s | DateTime.parse(s) ) \( d | d.to_s )' }
+
+      let(:compiled){
+        subject.compile(type_factory, nil)
+      }
+
+      it 'compiles to the expected Hash' do
+        compiled.should be_a(Hash)
+        compiled.keys.should eq([:iso])
+        contract.should be_a(Array)
+        contract.first.should be_a(BuiltinType)
+        contract.last.should be_a(Proc)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "expression" do
+
+    subject{
+      Syntax.parse(input, root: "expression")
+    }
+
+    let(:compiled){
+      subject.compile("a")
+    }
+
+    context 'a >= 10' do
+      let(:input){ 'a >= 10' }
+
+      it 'compiles to an Proc' do
+        compiled.should be_a(Proc)
+      end
+
+      it 'should be the correct Proc' do
+        compiled.call(12).should be_true
+        compiled.call(9).should be_false
+      end
+    end
+
+    context '(a >= 10)' do
+      let(:input){ '(a >= 10)' }
+
+      it 'compiles to an Proc' do
+        compiled.should be_a(Proc)
+      end
+    end
+
+    context 'acall(a)' do
+      let(:input){ 'acall(a)' }
+
+      it 'compiles to an Proc' do
+        compiled.should be_a(Proc)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "heading" do
+
+    subject{
+      Syntax.parse(input, root: "heading")
+    }
+
+    let(:compiled){
+      subject.compile(type_factory)
+    }
+
+    context 'empty heading' do
+      let(:input){ '  ' }
+
+      it 'compiles to a Heading' do
+        compiled.should be_a(Heading)
+        compiled.to_name.should eq('')
+      end
+    end
+
+    context 'a: .Integer' do
+      let(:input){ 'a: .Integer' }
+
+      it 'compiles to a Heading' do
+        compiled.should be_a(Heading)
+        compiled.to_name.should eq('a: Integer')
+      end
+    end
+
+    context 'a: .Integer, b: .Float' do
+      let(:input){ 'a: .Integer, b: .Float' }
+
+      it 'compiles to a Heading' do
+        compiled.should be_a(Heading)
+        compiled.to_name.should eq('a: Integer, b: Float')
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "named_constraint" do
+
+    subject{
+      Syntax.parse(input, root: "named_constraint")
+    }
+
+    let(:compiled){
+      subject.compile("a")
+    }
+
+    context 'a >= 10' do
+      let(:input){ 'foo: a >= 10' }
+
+      it 'compiles to an Hash' do
+        compiled.should be_a(Hash)
+      end
+
+      it 'has expected keys' do
+        compiled.keys.should eq([:foo])
+      end
+
+      it 'should be the correct Proc' do
+        compiled[:foo].call(12).should be_true
+        compiled[:foo].call(9).should be_false
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "relation_type" do
+
+    subject{
+      Syntax.parse(input, root: "relation_type")
+    }
+
+    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
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "seq_type" do
+
+    subject{
+      Syntax.parse(input, root: "seq_type")
+    }
+
+    let(:compiled){
+      subject.compile(type_factory)
+    }
+
+    context '[.Integer]' do
+      let(:input){ '[.Integer]' }
+
+      it 'compiles to a SeqType' do
+        compiled.should be_a(SeqType)
+        compiled.elm_type.should be_a(BuiltinType)
+        compiled.elm_type.ruby_type.should be(Integer)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "set_type" do
+
+    subject{
+      Syntax.parse(input, root: "set_type")
+    }
+
+    let(:compiled){
+      subject.compile(type_factory)
+    }
+
+    context '{.Integer}' do
+      let(:input){ '{.Integer}' }
+
+      it 'compiles to a SeqType' do
+        compiled.should be_a(SetType)
+        compiled.elm_type.should be_a(BuiltinType)
+        compiled.elm_type.ruby_type.should be(Integer)
+      end
+    end
+
+  end
+end