qrb 0.2.0 → 0.3.0

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

@@ -6,19 +6,33 @@ module Qrb
       Syntax.parse(input, root: "seq_type")
     }
 
-    let(:compiled){
-      subject.compile(type_factory)
-    }
+    describe "compilation result" do
+      let(:compiled){
+        subject.compile(type_factory)
+      }
 
-    context '[.Integer]' do
-      let(:input){ '[.Integer]' }
+      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)
+        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
 
+    describe "AST" do
+      let(:input){ '[.Integer]' }
+
+      let(:ast){ subject.to_ast }
+
+      it{ ast.should eq([
+          :seq_type,
+          [:builtin_type, "Integer"]
+        ])
+      }
+    end
+
   end
 end

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

@@ -6,19 +6,33 @@ module Qrb
       Syntax.parse(input, root: "set_type")
     }
 
-    let(:compiled){
-      subject.compile(type_factory)
-    }
+    describe "compilation result" do
+      let(:compiled){
+        subject.compile(type_factory)
+      }
 
-    context '{.Integer}' do
-      let(:input){ '{.Integer}' }
+      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)
+        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
 
+    describe "AST" do
+      let(:input){ '{.Integer}' }
+
+      let(:ast){ subject.to_ast }
+
+      it{ ast.should eq([
+          :set_type,
+          [:builtin_type, "Integer"]
+        ])
+      }
+    end
+
   end
 end

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

@@ -10,6 +10,10 @@ module Qrb
       subject.compile(type_factory)
     }
 
+    let(:ast){
+      subject.to_ast
+    }
+
     context '.Integer( i | i >= 0 )' do
       let(:input){ '.Integer( i | i >= 0 )' }
 
@@ -18,6 +22,14 @@ module Qrb
         compiled.super_type.should be_a(BuiltinType)
         compiled.super_type.ruby_type.should be(Integer)
       end
+
+      it 'has the expected AST' do
+        ast.should eq([
+          :sub_type,
+          [:builtin_type, "Integer"],
+          [:constraint, "default", [:fn, [:parameters, "i"], [:source, "i >= 0"]]]
+        ])
+      end
     end
 
     context '.Integer( i | positive: i >= 0 )' do
@@ -32,6 +44,14 @@ module Qrb
       it 'has the correct constraints' do
         compiled.constraints.keys.should eq([:positive])
       end
+
+      it 'has the expected AST' do
+        ast.should eq([
+          :sub_type,
+          [:builtin_type, "Integer"],
+          [:constraint, "positive", [:fn, [:parameters, "i"], [:source, "i >= 0"]]]
+        ])
+      end
     end
 
     context '.Integer( i | positive: i >= 0, ... )' do
@@ -46,6 +66,15 @@ module Qrb
       it 'has the correct constraints' do
         compiled.constraints.keys.should eq([:positive, :small])
       end
+
+      it 'has the expected AST' do
+        ast.should eq([
+          :sub_type,
+          [:builtin_type, "Integer"],
+          [:constraint, "positive", [:fn, [:parameters, "i"], [:source, "i >= 0"]]],
+          [:constraint, "small",    [:fn, [:parameters, "i"], [:source, "i <= 255"]]]
+        ])
+      end
     end
 
   end

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

@@ -0,0 +1,48 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "system" do
+
+    subject{
+      Syntax.parse(input, root: "system")
+    }
+
+    let(:ast){
+      subject.to_ast
+    }
+
+    context 'with definitions and a type' do
+      let(:input){ "Int = .Integer\n{r: Int}" }
+
+      it 'has the expected AST' do
+        ast.should eq([
+          :system,
+          [:type_def, "Int", [:builtin_type, "Integer"]],
+          [:tuple_type, [:heading, [:attribute, "r", [:type_ref, "Int"]]]]
+        ])
+      end
+    end
+
+    context 'with definitions only' do
+      let(:input){ "Int = .Integer" }
+
+      it 'has the expected AST' do
+        ast.should eq([
+          :system,
+          [:type_def, "Int", [:builtin_type, "Integer"]]
+        ])
+      end
+    end
+
+    context 'with a type only' do
+      let(:input){ "{r: .Integer}" }
+
+      it 'has the expected AST' do
+        ast.should eq([
+          :system,
+          [:tuple_type, [:heading, [:attribute, "r", [:builtin_type, "Integer"]]]]
+        ])
+      end
+    end
+
+  end
+end

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

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

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "type_def" do
+
+    subject{
+      Syntax.parse(input, root: "type_def")
+    }
+
+    let(:sys){
+      system
+    }
+
+    let(:compiled){
+      subject.compile(sys)
+    }
+
+    let(:ast){
+      subject.to_ast
+    }
+
+    let(:input){ 'Int = .Integer' }
+
+    it 'add the type to the system' do
+      compiled
+      sys["Int"].should be_a(BuiltinType)
+    end
+
+    it 'has the expected AST' do
+      ast.should eq([:type_def, "Int", [:builtin_type, "Integer"]])
+    end
+
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "type_ref" do
+
+    subject{
+      Syntax.parse(input, root: "type_ref")
+    }
+
+    let(:sys){
+      system
+    }
+
+    let(:compiled){
+      subject.compile(sys)
+    }
+
+    let(:ast){
+      subject.to_ast
+    }
+
+    before do
+      sys.add_type(BuiltinType.new(Integer, "Int"))
+    end
+
+    let(:input){ 'Int' }
+
+    it 'compiles to a the BuiltinType' do
+      compiled.should be_a(BuiltinType)
+      compiled.name.should eq("Int")
+    end
+
+    it 'has the expected AST' do
+      ast.should eq([:type_ref, "Int"])
+    end
+
+  end
+end

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

@@ -6,18 +6,33 @@ module Qrb
       Syntax.parse(input, root: "union_type")
     }
 
-    let(:compiled){
-      subject.compile(type_factory)
-    }
+    describe "compilation result" do
+      let(:compiled){
+        subject.compile(type_factory)
+      }
 
-    context '.Integer|.Float' do
-      let(:input){ '.Integer|.Float' }
+      context '.Integer|.Float' do
+        let(:input){ '.Integer|.Float' }
 
-      it 'compiles to a UnionType' do
-        compiled.should be_a(UnionType)
-        compiled.should eq(UnionType.new([intType, floatType]))
+        it 'compiles to a UnionType' do
+          compiled.should be_a(UnionType)
+          compiled.should eq(UnionType.new([intType, floatType]))
+        end
       end
     end
 
+    describe "AST" do
+      let(:input){ '.Integer|.Float' }
+
+      let(:ast){ subject.to_ast }
+
+      it{ ast.should eq([
+          :union_type,
+          [:builtin_type, "Integer"],
+          [:builtin_type, "Float"]
+        ])
+      }
+    end
+
   end
 end

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

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

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

@@ -5,8 +5,8 @@ module Qrb
     subject{ type.default_name }
 
     let(:type){
-      AdType.new(Color, rgb: [intType,   Color.method(:rgb) ],
-                        hex: [floatType, Color.method(:hex) ])
+      AdType.new(Color, rgb: [intType,   Color.method(:rgb), Qrb::IDENTITY ],
+                        hex: [floatType, Color.method(:hex), Qrb::IDENTITY ])
     }
 
     it{ should eq('Color') }

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

@@ -3,8 +3,8 @@ module Qrb
   describe AdType, 'dress' do
 
     let(:type){
-      AdType.new(Color, rgb: [intType,   ->(i){ i*2 } ],
-                        hex: [floatType, ->(f){ f*3 } ])
+      AdType.new(Color, rgb: [intType,   ->(i){ i*2 }, Qrb::IDENTITY ],
+                        hex: [floatType, ->(f){ f*3 }, Qrb::IDENTITY ])
     }
 
     subject{
@@ -41,7 +41,7 @@ module Qrb
 
     context 'when the upper raises an error' do
       let(:type){
-        AdType.new(Color, rgb: [ intType, ->(t){ raise ArgumentError } ])
+        AdType.new(Color, rgb: [ intType, ->(t){ raise ArgumentError }, Qrb::IDENTITY ])
       }
 
       it 'should hide the error' do

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

@@ -3,8 +3,8 @@ module Qrb
   describe AdType, 'initialize' do
 
     subject{
-      AdType.new(Color, rgb: [intType,   Color.method(:rgb) ],
-                        hex: [floatType, Color.method(:hex) ])
+      AdType.new(Color, rgb: [intType,   Color.method(:rgb), Qrb::IDENTITY ],
+                        hex: [floatType, Color.method(:hex), Qrb::IDENTITY ])
     }
 
     context 'with valid arguments' do