finitio 0.4.1 → 0.5.0

data/spec/heading/test_to_name.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+module Finitio
+  describe Heading, "to_name" do
+
+    let(:red)       { Attribute.new(:red,  intType)        }
+    let(:blue)      { Attribute.new(:blue, intType)        }
+    let(:maybe_blue){ Attribute.new(:blue, intType, false) }
+
+    let(:heading){ Heading.new(attributes) }
+
+    subject{ heading.to_name }
+
+    context 'with no attribute' do
+      let(:attributes){
+        [ ]
+      }
+
+      it{ should eq('') }
+    end
+
+    context 'with one attribute' do
+      let(:attributes){
+        [ red ]
+      }
+
+      it{ should eq('red: intType') }
+    end
+
+    context 'with multiple attributes' do
+      let(:attributes){
+        [ red, blue ]
+      }
+
+      it{ should eq('red: intType, blue: intType') }
+    end
+
+    context 'with some optional attributes' do
+      let(:attributes){
+        [ red, maybe_blue ]
+      }
+
+      it{ should eq('red: intType, blue :? intType') }
+    end
+
+    context 'when allowing extra' do
+      let(:heading){ Heading.new([red], allow_extra: true) }
+
+      it{ should eq('red: intType, ...') }
+    end
+
+    context 'when allowing extra only' do
+      let(:heading){ Heading.new([], allow_extra: true) }
+
+      it{ should eq('...') }
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -56,8 +56,24 @@ module SpecHelpers
     Finitio::BuiltinType.new(NilClass, "nilType")
   end
 
+  def byte_full
+    @byte_full ||= Finitio::Constraint.new(->(i){ i>=0 && i<=255 }, :byte)
+  end
+
+  def byte_min
+    @byte_min ||= Finitio::Constraint.new(->(i){ i>=0 }, :byte_min)
+  end
+
+  def byte_max
+    @byte_max ||= Finitio::Constraint.new(->(i){ i<=255 }, :byte_max)
+  end
+
+  def positive
+    @positive ||= Finitio::Constraint.new(->(i){ i>=0 }, :positive)
+  end
+
   def byte
-    Finitio::SubType.new(intType, byte: ->(i){ i>=0 && i<=255 })
+    Finitio::SubType.new(intType, [byte_full])
   end
 
   def type_factory

data/spec/syntax/expr/test_free_variables.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+module Finitio
+  module Syntax
+    describe Expr, "free_variables" do
+
+      def fv(src)
+        Syntax.parse(src, { root: :expr, memoize: true }).free_variables
+      end
+
+      context "on literals" do
+
+        it 'returns an empty array' do
+          expect(fv("true")).to eq([])
+        end
+      end
+
+      context "on a single identifier" do
+
+        it 'works' do
+          expect(fv("foo")).to eq(["foo"])
+        end
+      end
+        
+      context "on a comparison" do
+
+        it 'works' do
+          expect(fv("foo == bar")).to eq(["foo", "bar"])
+        end
+      end
+
+      context "on a function call" do
+
+        it 'works' do
+          expect(fv("foo(bar)")).to eq(["bar"])
+        end
+      end
+
+      context "on a OO call" do
+
+        it 'works' do
+          expect(fv("foo.bar")).to eq(["foo"])
+        end
+      end
+    end
+  end
+end

data/spec/syntax/expr/test_to_proc_source.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+module Finitio
+  module Syntax
+    describe Expr, "to_proc_source" do
+
+      def source(src)
+        Syntax.parse(src, { root: :expr, memoize: true }).to_proc_source
+      end
+
+      context "on literals" do
+
+        it 'returns an empty array' do
+          expect(source("true")).to eq("true")
+        end
+      end
+
+      context "on a single identifier" do
+
+        it 'works' do
+          expect(source("foo")).to eq("foo")
+        end
+      end
+        
+      context "on a comparison" do
+
+        it 'works' do
+          expect(source("foo == bar")).to eq(%Q{foo.==(bar)})
+        end
+      end
+
+      context "on a OO call" do
+
+        it 'works' do
+          expect(source("foo.bar")).to eq(%Q{foo.fetch(:bar)})
+        end
+
+        it 'works' do
+          expect(source("foo.bar.baz")).to eq(%Q{foo.fetch(:bar).fetch(:baz)})
+        end
+      end
+    end
+  end
+end

data/spec/{unit/syntax → syntax}/nodes/test_ad_type.rb

@@ -18,17 +18,17 @@ module Finitio
       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])
+        expect(compiled).to be_a(AdType)
+        expect(compiled.ruby_type).to be(Color)
+        expect(compiled.contract_names).to eq([:rgb])
       end
 
       it 'should behave as expected' do
-        compiled.dress(r: 138, g: 43, b: 226).should eq(blueviolet)
+        expect(compiled.dress(r: 138, g: 43, b: 226)).to eq(blueviolet)
       end
 
       it 'has expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :ad_type,
           "Color",
           [:contract,
@@ -54,17 +54,17 @@ module Finitio
       }
 
       it 'compiles to an AdType' do
-        compiled.should be_a(AdType)
-        compiled.ruby_type.should be(Color)
-        compiled.contract_names.should eq([:rgb, :hex])
+        expect(compiled).to be_a(AdType)
+        expect(compiled.ruby_type).to be(Color)
+        expect(compiled.contract_names).to eq([:rgb, :hex])
       end
 
       it 'should behave as expected' do
-        compiled.dress("#8A2BE2").should eq(blueviolet)
+        expect(compiled.dress("#8A2BE2")).to eq(blueviolet)
       end
 
       it 'has expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :ad_type,
           "Color",
           [:contract,
@@ -89,20 +89,20 @@ module Finitio
       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])
+        expect(compiled).to be_a(AdType)
+        expect(compiled.ruby_type).to be_nil
+        expect(compiled.contract_names).to eq([:as])
       end
 
       it 'should behave as expected' do
-        compiled.dress(r: 12).should eq(r: 12)
-        ->{
+        expect(compiled.dress(r: 12)).to eq(r: 12)
+        expect{
           compiled.dress("foo")
-        }.should raise_error(TypeError)
+        }.to raise_error(TypeError)
       end
 
       it 'has expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :ad_type,
           nil,
           [:contract,
@@ -121,9 +121,9 @@ module Finitio
       let(:input){ '.Color <rgb> {r: .Integer}, <rgb> .String' }
 
       it 'raises an error' do
-        ->{
+        expect{
           compiled
-        }.should raise_error(Error, "Duplicate contract name `rgb`")
+        }.to raise_error(Error, "Duplicate contract name `rgb`")
       end
     end
 
@@ -131,23 +131,23 @@ module Finitio
       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])
+        expect(compiled).to be_a(AdType)
+        expect(compiled.ruby_type).to be(DateTime)
+        expect(compiled.contract_names).to eq([:iso])
       end
 
       it 'should behave as expected' do
-        compiled.dress("2014-01-19T12:00").should be_a(DateTime)
+        expect(compiled.dress("2014-01-19T12:00")).to 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")
+        expect(err).to be_a(TypeError)
+        expect(err.message).to eq("Invalid DateTime `foo`")
       end
 
       it 'has expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           :ad_type,
           "DateTime",
           [:contract,

data/spec/{unit/syntax → syntax}/nodes/test_any_type.rb

@@ -14,7 +14,7 @@ module Finitio
       }
 
       it 'compiles to an AnyType' do
-        compiled.should be_a(AnyType)
+        expect(compiled).to be_a(AnyType)
       end
     end
 
@@ -23,7 +23,7 @@ module Finitio
         subject.to_ast
       }
 
-      it{ ast.should eq([:any_type]) }
+      it{ expect(ast).to eq([:any_type]) }
     end
 
   end

data/spec/syntax/nodes/test_attribute.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+module Finitio
+  describe Syntax, "attribute" do
+
+    subject{
+      Syntax.parse(input, root: "attribute")
+    }
+
+    describe 'compilation result' do
+      let(:compiled){
+        subject.compile(type_factory)
+      }
+
+      context 'a: .Integer' do
+        let(:input){ 'a: .Integer' }
+
+        it 'compiles to an mandatory Attribute' do
+          expect(compiled).to be_a(Attribute)
+          expect(compiled.name).to eq(:a)
+          expect(compiled.type).to be_a(BuiltinType)
+          expect(compiled.type.ruby_type).to be(Integer)
+          expect(compiled).to be_required
+        end
+      end
+
+      context 'a :? .Integer' do
+        let(:input){ 'a :? .Integer' }
+
+        it 'compiles to an optional Attribute' do
+          expect(compiled).to be_a(Attribute)
+          expect(compiled.name).to eq(:a)
+          expect(compiled.type).to be_a(BuiltinType)
+          expect(compiled.type.ruby_type).to be(Integer)
+          expect(compiled).not_to be_required
+        end
+      end
+    end
+
+    describe 'AST' do
+      let(:ast){
+        subject.to_ast
+      }
+
+      context 'a: .Integer' do
+        let(:input){ 'a: .Integer' }
+
+        it{ expect(ast).to eq([:attribute, "a", [:builtin_type, "Integer"]]) }
+      end
+
+      context 'a :? .Integer' do
+        let(:input){ 'a :? .Integer' }
+
+        it{ expect(ast).to eq([:attribute, "a", [:builtin_type, "Integer"], false]) }
+      end
+
+      context '_ : .Integer' do
+        let(:input){ '_ : .Integer' }
+
+        it{ expect(ast).to eq([:attribute, "_", [:builtin_type, "Integer"]]) }
+      end
+
+    end
+    
+  end
+end

data/spec/{unit/syntax → syntax}/nodes/test_builtin_type.rb

@@ -15,8 +15,8 @@ module Finitio
         let(:source){ ".Integer" }
 
         it 'compiles to a BuiltinType' do
-          compiled.should be_a(BuiltinType)
-          compiled.ruby_type.should be(Integer)
+          expect(compiled).to be_a(BuiltinType)
+          expect(compiled.ruby_type).to be(Integer)
         end
       end
 
@@ -24,8 +24,8 @@ module Finitio
         let(:source){ ".Finitio::Type" }
 
         it 'compiles to a BuiltinType' do
-          compiled.should be_a(BuiltinType)
-          compiled.ruby_type.should be(::Finitio::Type)
+          expect(compiled).to be_a(BuiltinType)
+          expect(compiled.ruby_type).to be(::Finitio::Type)
         end
       end
     end
@@ -37,7 +37,7 @@ module Finitio
         subject.to_ast
       }
 
-      it{ ast.should eq([:builtin_type, "Finitio::Type"]) }
+      it{ expect(ast).to eq([:builtin_type, "Finitio::Type"]) }
     end
 
   end

data/spec/{unit/syntax → syntax}/nodes/test_comment.rb

@@ -17,7 +17,7 @@ module Finitio
         let(:input){ source }
 
         it 'should parse' do
-          subject.should eq(source)
+          expect(subject).to eq(source)
         end
       end
     end

data/spec/{unit/syntax → syntax}/nodes/test_constraint_def.rb

@@ -17,17 +17,12 @@ module Finitio
     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
+      it 'compiles to an Array' do
+        expect(compiled).to be_a(Array)
       end
 
       it 'has the expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           [
             :constraint,
             "default",

data/spec/{unit/syntax → syntax}/nodes/test_constraints.rb

@@ -17,30 +17,33 @@ module Finitio
     context 'a >= 10' do
       let(:input){ 'a >= 10' }
 
-      it 'compiles to an Hash' do
-        compiled.should be_a(Hash)
-        compiled.keys.should eq([:predicate])
+      it 'compiles to an Array' do
+        expect(compiled).to be_a(Array)
+        expect(compiled.size).to eq(1)
+        expect(compiled.first).to be_a(Constraint)
       end
 
       it 'has the expected AST' do
-        ast.should eq([
+        expect(ast).to eq([[
           :constraint,
           "default",
           [:fn, [:parameters, "a"], [:source, "a >= 10"]]
-        ])
+        ]])
       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])
+      it 'compiles to an Array' do
+        expect(compiled).to be_a(Array)
+        expect(compiled.size).to eq(1)
+        expect(compiled.first).to be_a(Constraint)
+        expect(compiled.map(&:name)).to eq([:foo])
       end
 
       it 'has the expected AST' do
-        ast.should eq([[
+        expect(ast).to eq([[
           :constraint,
           "foo",
           [:fn, [:parameters, "a"], [:source, "a >= 10"]]
@@ -51,13 +54,15 @@ module Finitio
     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])
+      it 'compiles to an Array' do
+        expect(compiled).to be_a(Array)
+        expect(compiled.size).to eq(2)
+        expect(compiled.first).to be_a(Constraint)
+        expect(compiled.map(&:name)).to eq([:foo, :bar])
       end
 
       it 'has the expected AST' do
-        ast.should eq([
+        expect(ast).to eq([
           [
             :constraint,
             "foo",
@@ -75,10 +80,10 @@ module Finitio
     context 'foo: a >= 10, foo: a <= 255' do
       let(:input){ 'foo: a >= 10, foo: a <= 255' }
 
-      it 'compiles to an Hash' do
-        ->{
+      it 'raises an error' do
+        expect{
           compiled
-        }.should raise_error("Duplicate constraint name `foo`")
+        }.to raise_error("Duplicate constraint name `foo`")
       end
     end