qrb 0.2.0 → 0.3.0

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "any_type" do
+
+    subject{
+      Syntax.parse(source, root: "any_type")
+    }
+
+    let(:source){ "." }
+
+    describe "compilation result" do
+      let(:compiled){
+        subject.compile(type_factory)
+      }
+
+      it 'compiles to an AnyType' do
+        compiled.should be_a(AnyType)
+      end
+    end
+
+    describe "AST" do
+      let(:ast){
+        subject.to_ast
+      }
+
+      it{ ast.should eq([:any_type]) }
+    end
+
+  end
+end

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

@@ -6,20 +6,33 @@ module Qrb
       Syntax.parse(input, root: "attribute")
     }
 
-    let(:compiled){
-      subject.compile(type_factory)
-    }
+    describe 'compilation result' do
+      let(:compiled){
+        subject.compile(type_factory)
+      }
 
-    context 'a: .Integer' do
-      let(:input){ 'a: .Integer' }
+      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)
+        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_builtin_type.rb

@@ -6,26 +6,38 @@ module Qrb
       Syntax.parse(source, root: "builtin_type")
     }
 
-    let(:compiled){
-      subject.compile(type_factory)
-    }
+    describe "compilation result" do
+      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 an unqualified class name' do
-      let(:source){ ".Integer" }
+      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(Integer)
+        it 'compiles to a BuiltinType' do
+          compiled.should be_a(BuiltinType)
+          compiled.ruby_type.should be(::Qrb::Type)
+        end
       end
     end
 
-    context 'when a qualified class name' do
+    describe "AST" do
       let(:source){ ".Qrb::Type" }
 
-      it 'compiles to a BuiltinType' do
-        compiled.should be_a(BuiltinType)
-        compiled.ruby_type.should be(::Qrb::Type)
-      end
+      let(:ast){
+        subject.to_ast
+      }
+
+      it{ ast.should eq([:builtin_type, "Qrb::Type"]) }
     end
 
   end

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

@@ -10,6 +10,10 @@ module Qrb
       subject.compile(type_factory)
     }
 
+    let(:ast){
+      subject.to_ast
+    }
+
     context '(i | i >= 0)' do
       let(:input){ '(i | i >= 0)' }
 
@@ -21,6 +25,16 @@ module Qrb
         compiled[:predicate].call(12).should be_true
         compiled[:predicate].call(-12).should be_false
       end
+
+      it 'has the expected AST' do
+        ast.should eq([
+          [
+            :constraint,
+            "default",
+            [:fn, [:parameters, "i"], [:source, "i >= 0"]]
+          ]
+        ])
+      end
     end
 
   end

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

@@ -10,6 +10,10 @@ module Qrb
       subject.compile("a")
     }
 
+    let(:ast){
+      subject.to_ast('a')
+    }
+
     context 'a >= 10' do
       let(:input){ 'a >= 10' }
 
@@ -17,6 +21,14 @@ module Qrb
         compiled.should be_a(Hash)
         compiled.keys.should eq([:predicate])
       end
+
+      it 'has the expected AST' do
+        ast.should eq([
+          :constraint,
+          "default",
+          [:fn, [:parameters, "a"], [:source, "a >= 10"]]
+        ])
+      end
     end
 
     context 'foo: a >= 10' do
@@ -26,6 +38,14 @@ module Qrb
         compiled.should be_a(Hash)
         compiled.keys.should eq([:foo])
       end
+
+      it 'has the expected AST' do
+        ast.should eq([[
+          :constraint,
+          "foo",
+          [:fn, [:parameters, "a"], [:source, "a >= 10"]]
+        ]])
+      end
     end
 
     context 'foo: a >= 10, bar: a <= 255' do
@@ -35,6 +55,21 @@ module Qrb
         compiled.should be_a(Hash)
         compiled.keys.should eq([:foo, :bar])
       end
+
+      it 'has the expected AST' do
+        ast.should eq([
+          [
+            :constraint,
+            "foo",
+            [:fn, [:parameters, "a"], [:source, "a >= 10"]]
+          ],
+          [
+            :constraint,
+            "bar",
+            [:fn, [:parameters, "a"], [:source, "a <= 255"]]
+          ]
+        ])
+      end
     end
 
     context 'foo: a >= 10, foo: a <= 255' do

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

@@ -10,6 +10,10 @@ module Qrb
       compiled.values.first
     }
 
+    let(:ast){
+      subject.to_ast
+    }
+
     context 'No converter and a class' do
       let(:input){ '<rgb> {r: .Integer, g: .Integer, b: .Integer}' }
 
@@ -21,8 +25,23 @@ module Qrb
         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)
+        contract[0].should be_a(TupleType)
+        contract[1].should be_a(Method)
+        contract[2].should be_a(Proc)
+      end
+
+      it 'has expected AST' do
+        ast.should eq([
+          :contract,
+          "rgb",
+          [:tuple_type,
+            [:heading,
+              [:attribute, "r", [:builtin_type, "Integer"]],
+              [:attribute, "g", [:builtin_type, "Integer"]],
+              [:attribute, "b", [:builtin_type, "Integer"]]
+            ]
+          ]
+        ])
       end
     end
 
@@ -37,8 +56,23 @@ module Qrb
         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)
+        contract[0].should be_a(TupleType)
+        contract[1].should be(Qrb::IDENTITY)
+        contract[2].should be(Qrb::IDENTITY)
+      end
+
+      it 'has expected AST' do
+        ast.should eq([
+          :contract,
+          "rgb",
+          [:tuple_type,
+            [:heading,
+              [:attribute, "r", [:builtin_type, "Integer"]],
+              [:attribute, "g", [:builtin_type, "Integer"]],
+              [:attribute, "b", [:builtin_type, "Integer"]]
+            ]
+          ]
+        ])
       end
     end
 
@@ -56,6 +90,44 @@ module Qrb
         contract.first.should be_a(BuiltinType)
         contract.last.should be_a(Proc)
       end
+
+      it 'has expected AST' do
+        ast.should eq([
+          :contract,
+          "iso",
+          [:builtin_type, "String"],
+          [:inline_pair,
+            [:fn, [:parameters, "s"], [:source, "DateTime.parse(s)"]],
+            [:fn, [:parameters, "d"], [:source, "d.to_s"]]
+          ]
+        ])
+      end
+    end
+
+    context 'A contract with external dressers' do
+      let(:input){ '<iso> .String .ExternalContract' }
+
+      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[0].should be_a(BuiltinType)
+        contract[1].should be_a(Method)
+        contract[2].should be_a(Method)
+      end
+
+      it 'has expected AST' do
+        ast.should eq([
+          :contract,
+          "iso",
+          [:builtin_type, "String"],
+          [:external_pair, "ExternalContract"]
+        ])
+      end
     end
 
   end

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

@@ -6,36 +6,53 @@ module Qrb
       Syntax.parse(input, root: "heading")
     }
 
-    let(:compiled){
-      subject.compile(type_factory)
-    }
+    describe "compilation result" do
+      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 'empty heading' do
-      let(:input){ '  ' }
+      context 'a: .Integer' do
+        let(:input){ 'a: .Integer' }
 
-      it 'compiles to a Heading' do
-        compiled.should be_a(Heading)
-        compiled.to_name.should eq('')
+        it 'compiles to a Heading' do
+          compiled.should be_a(Heading)
+          compiled.to_name.should eq('a: Integer')
+        end
       end
-    end
 
-    context 'a: .Integer' do
-      let(:input){ 'a: .Integer' }
+      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')
+        it 'compiles to a Heading' do
+          compiled.should be_a(Heading)
+          compiled.to_name.should eq('a: Integer, b: Float')
+        end
       end
     end
 
-    context 'a: .Integer, b: .Float' do
+    describe "AST" 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
+      let(:ast){
+        subject.to_ast
+      }
+
+      it{
+        ast.should eq([
+          :heading,
+          [ :attribute, "a", [:builtin_type, "Integer" ]],
+          [ :attribute, "b", [:builtin_type, "Float" ]]
+        ])
+      }
     end
-
   end
 end

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

@@ -10,6 +10,10 @@ module Qrb
       subject.compile("a")
     }
 
+    let(:ast){
+      subject.to_ast('a')
+    }
+
     context 'a >= 10' do
       let(:input){ 'foo: a >= 10' }
 
@@ -25,6 +29,14 @@ module Qrb
         compiled[:foo].call(12).should be_true
         compiled[:foo].call(9).should be_false
       end
+
+      it 'has the expected AST' do
+        ast.should eq([
+          :constraint,
+          "foo",
+          [:fn, [:parameters, "a"], [:source, "a >= 10"]]
+        ])
+      end
     end
 
   end

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

@@ -6,35 +6,53 @@ module Qrb
       Syntax.parse(input, root: "relation_type")
     }
 
-    let(:compiled){
-      subject.compile(type_factory)
-    }
+    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 'empty heading' do
-      let(:input){ '{{ }}' }
+      context '{{a: .Integer}}' do
+        let(:input){ '{{a: .Integer}}' }
 
-      it 'compiles to a RelationType' do
-        compiled.should be_a(RelationType)
-        compiled.heading.should be_empty
+        it 'compiles to a RelationType' do
+          compiled.should be_a(RelationType)
+          compiled.heading.size.should eq(1)
+        end
       end
-    end
 
-    context '{{a: .Integer}}' do
-      let(:input){ '{{a: .Integer}}' }
+      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(1)
+        it 'compiles to a RelationType' do
+          compiled.should be_a(RelationType)
+          compiled.heading.size.should eq(2)
+        end
       end
     end
 
-    context '{{a: .Integer, b: .Float}}' do
-      let(:input){ '{{a: .Integer, b: .Float}}' }
+    describe "AST" do
+      let(:input){ '{{a: .Integer}}' }
 
-      it 'compiles to a RelationType' do
-        compiled.should be_a(RelationType)
-        compiled.heading.size.should eq(2)
-      end
+      let(:ast){ subject.to_ast }
+
+      it{
+        ast.should eq([
+          :relation_type,
+          [
+            :heading,
+            [ :attribute, "a", [:builtin_type, "Integer" ]]
+          ]
+        ])
+      }
     end
 
   end