qrb 0.1.0

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "spacing" do
+
+    subject{
+      Syntax.parse(input, root: "spacing")
+    }
+
+    [
+      '    ',
+      "\n",
+      "  \t\n",
+      "   # foo\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_sub_type.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "sub_type" do
+
+    subject{
+      Syntax.parse(input, root: "sub_type")
+    }
+
+    let(:compiled){
+      subject.compile(type_factory)
+    }
+
+    context '.Integer( i | i >= 0 )' do
+      let(:input){ '.Integer( i | i >= 0 )' }
+
+      it 'compiles to a SubType' do
+        compiled.should be_a(SubType)
+        compiled.super_type.should be_a(BuiltinType)
+        compiled.super_type.ruby_type.should be(Integer)
+      end
+    end
+
+    context '.Integer( i | positive: i >= 0 )' do
+      let(:input){ '.Integer( i | positive: i >= 0 )' }
+
+      it 'compiles to a SubType' do
+        compiled.should be_a(SubType)
+        compiled.super_type.should be_a(BuiltinType)
+        compiled.super_type.ruby_type.should be(Integer)
+      end
+
+      it 'has the correct constraints' do
+        compiled.constraints.keys.should eq([:positive])
+      end
+    end
+
+    context '.Integer( i | positive: i >= 0, ... )' do
+      let(:input){ '.Integer( i | positive: i >= 0, small: i <= 255 )' }
+
+      it 'compiles to a SubType' do
+        compiled.should be_a(SubType)
+        compiled.super_type.should be_a(BuiltinType)
+        compiled.super_type.ruby_type.should be(Integer)
+      end
+
+      it 'has the correct constraints' do
+        compiled.constraints.keys.should eq([:positive, :small])
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "tuple_type" do
+
+    subject{
+      Syntax.parse(input, root: "tuple_type")
+    }
+
+    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 '{a: .Integer}' do
+      let(:input){ '{a: .Integer}' }
+
+      it 'compiles to a TupleType' do
+        compiled.should be_a(TupleType)
+        compiled.heading.size.should eq(1)
+      end
+    end
+
+    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(2)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, "union_type" do
+
+    subject{
+      Syntax.parse(input, root: "union_type")
+    }
+
+    let(:compiled){
+      subject.compile(type_factory)
+    }
+
+    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]))
+      end
+    end
+
+  end
+end

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

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

data/spec/unit/syntax/test_compile_type.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Qrb
+  describe Syntax, '.compile' do
+
+    let(:source){
+      <<-EOF
+        {
+          name: .String,
+          color: { red: .Integer, green: .Integer, blue: .Integer },
+          sex: .String( s | s =~ /^M|F$/ )
+        }
+      EOF
+    }
+
+    subject do
+      Syntax.compile_type(source)
+    end
+
+    it{ should be_a(Type) }
+
+  end
+end

data/spec/unit/system/test_add_type.rb

@@ -0,0 +1,47 @@
+require 'rspec'
+module Qrb
+  describe System, "add_type" do
+
+    let(:system){ System.new }
+
+    subject{ system.add_type(type) }
+
+    context 'with a valid type' do
+      let(:type){ intType }
+
+      it 'should return the created type' do
+        subject.should be(type)
+      end
+
+      it 'should add the type' do
+        subject
+        system[type.name].should be(type)
+      end
+    end
+
+    context 'with an invalid type' do
+      let(:type){ "foo" }
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error(ArgumentError, "Qrb::Type expected, got `foo`")
+      end
+    end
+
+    context 'with a duplicate type name' do
+      let(:type){ intType }
+
+      before do
+        system.add_type(type)
+      end
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error(Qrb::Error, "Duplicate type name `intType`")
+      end
+    end
+
+  end
+end

data/spec/unit/system/test_dsl.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Qrb
+  describe System, "initialize" do
+
+    let(:system){ System.new }
+
+    context 'for building a tuple type' do
+      subject{
+        system.tuple(r: Integer)
+      }
+      
+      it{ should be_a(TupleType) }
+    end
+
+    context 'for building a sub type' do
+      subject{
+        system.subtype(Integer){|i| i>=0 }
+      }
+
+      it{ should be_a(SubType) }
+
+      it 'should apply the constraint' do
+        ->{
+          subject.dress(-9)
+        }.should raise_error(TypeError)
+      end
+    end
+
+  end
+end

data/spec/unit/system/test_dup.rb

@@ -0,0 +1,30 @@
+require 'rspec'
+module Qrb
+  describe System, "dup" do
+
+    let(:system){ System.new }
+
+    before do
+      system.add_type(intType)
+    end
+
+    subject{ system.dup }
+
+    it{ should be_a(System) }
+
+    it 'should not be the same object' do
+      subject.should_not be(system)
+    end
+
+    it 'should have intType' do
+      subject['intType'].should eq(intType)
+    end
+
+    it 'should not share internals with the original' do
+      subject.add_type(floatType)
+      subject['floatType'].should_not be_nil
+      system['floatType'].should be_nil
+    end
+
+  end
+end

data/spec/unit/system/test_fetch.rb

@@ -0,0 +1,42 @@
+require 'rspec'
+module Qrb
+  describe System, "fetch" do
+
+    let(:system){ System.new }
+
+    before do
+      system.add_type(intType)
+    end
+
+    subject{ system.fetch(name) }
+
+    context 'with an existing type name' do
+      let(:name){ "intType" }
+
+      it 'should return the type' do
+        subject.should eq(intType)
+      end
+    end
+
+    context 'with a non existing type name and no block' do
+      let(:name){ "noSuchOne" }
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error(KeyError, /noSuchOne/)
+      end
+    end
+
+    context 'with a non existing type name and a block' do
+      subject{
+        system.fetch("noSuchOne"){ "bar" }
+      }
+
+      it 'should yield the block' do
+        subject.should eq("bar")
+      end
+    end
+
+  end
+end

data/spec/unit/system/test_get_type.rb

@@ -0,0 +1,30 @@
+require 'rspec'
+module Qrb
+  describe System, "[]" do
+
+    let(:system){ System.new }
+
+    before do
+      system.add_type(intType)
+    end
+
+    subject{ system[name] }
+
+    context 'with an existing type name' do
+      let(:name){ "intType" }
+
+      it 'should return the type' do
+        subject.should eq(intType)
+      end
+    end
+
+    context 'with a non existing type name' do
+      let(:name){ "noSuchOne" }
+
+      it 'should return nil' do
+        subject.should be_nil
+      end
+    end
+
+  end
+end

data/spec/unit/system/test_initialize.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Qrb
+  describe System, "initialize" do
+
+    subject{ System.new }
+
+    it{ should be_a(System) }
+
+  end
+end

data/spec/unit/test_qrb.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+describe Qrb do
+
+  it "should have a version number" do
+    Qrb.const_defined?(:VERSION).should be_true
+  end
+
+  it 'should have DSL methods' do
+    t = Qrb.type(Fixnum){|i| i>=0 }
+    t.should be_a(Qrb::SubType)
+    t.dress(12).should eq(12)
+    ->{ t.dress(-12) }.should raise_error(Qrb::TypeError)
+  end
+
+end

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+module Qrb
+  describe AdType, "default_name" do
+
+    subject{ type.default_name }
+
+    let(:type){
+      AdType.new(Color, rgb: [intType,   Color.method(:rgb) ],
+                        hex: [floatType, Color.method(:hex) ])
+    }
+
+    it{ should eq('Color') }
+
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'spec_helper'
+module Qrb
+  describe AdType, 'dress' do
+
+    let(:type){
+      AdType.new(Color, rgb: [intType,   ->(i){ i*2 } ],
+                        hex: [floatType, ->(f){ f*3 } ])
+    }
+
+    subject{
+      type.dress(arg)
+    }
+
+    context 'with a color' do
+      let(:arg){ Color.new(12, 13, 15) }
+
+      it{ should be(arg) }
+    end
+
+    context 'with an integer' do
+      let(:arg){ 12 }
+
+      it{ should eq(24) }
+    end
+
+    context 'with a float' do
+      let(:arg){ 12.0 }
+
+      it{ should eq(36.0) }
+    end
+
+    context 'with an unrecognized' do
+      let(:arg){ "foo" }
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error(TypeError, "Invalid value `foo` for Color")
+      end
+    end
+
+    context 'when the upper raises an error' do
+      let(:type){
+        AdType.new(Color, rgb: [ intType, ->(t){ raise ArgumentError } ])
+      }
+
+      it 'should hide the error' do
+        err = type.dress(12) rescue $!
+        err.should be_a(TypeError)
+        err.message.should eq("Invalid value `12` for Color")
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Qrb
+  describe AdType, "include?" do
+
+    let(:type){ AdType.new(Color, {}) }
+
+    subject{ type.include?(arg) }
+
+    context 'when not included' do
+      let(:arg){ "12" }
+
+      it{ should be_false }
+    end
+
+    context 'when included' do
+      let(:arg){ blueviolet }
+
+      it{ should be_true }
+    end
+
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+module Qrb
+  describe AdType, 'initialize' do
+
+    subject{
+      AdType.new(Color, rgb: [intType,   Color.method(:rgb) ],
+                        hex: [floatType, Color.method(:hex) ])
+    }
+
+    context 'with valid arguments' do
+      it{ should be_a(AdType) }
+
+      it 'should set the instance variables' do
+        subject.ruby_type.should be(Color)
+        subject.contracts.should be_a(Hash)
+      end
+    end
+
+    context 'with invalid arguments (I)' do
+      subject{ AdType.new("foo", {}) }
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error(ArgumentError, 'Module expected, got `foo`')
+      end
+    end
+
+    context 'with invalid arguments (II)' do
+      subject{ AdType.new(Object, "bar") }
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error(ArgumentError, 'Hash expected, got `bar`')
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Qrb
+  describe AdType, "name" do
+
+    subject{ type.name }
+
+    context 'when provided' do
+      let(:type){ AdType.new(Color, {}, "Foo") }
+
+      it{ should eq('Foo') }
+    end
+
+    context 'when not provided' do
+      let(:type){ AdType.new(Color, {}) }
+
+      it{ should eq('Color') }
+    end
+
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+module Qrb
+  describe BuiltinType, "default_name" do
+
+    let(:type){ BuiltinType.new(Integer, "int") }
+
+    it 'uses the ruby name' do
+      type.default_name.should eq("Integer")
+    end
+
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+module Qrb
+  describe BuiltinType, "dress" do
+
+    let(:type){ BuiltinType.new(Integer, 'int') }
+
+    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 }
+
+      subject{
+        type.dress(arg) rescue $!
+      }
+
+      it 'should raise an Error' do
+        subject.should be_a(TypeError)
+        subject.message.should eq("Invalid value `12.0` for int")
+      end
+
+      it 'should have no location' do
+        subject.location.should eq('')
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Qrb
+  describe BuiltinType, "equality" do
+
+    let(:intType) { BuiltinType.new(Integer) }
+    let(:intType2){ BuiltinType.new(Integer) }
+    let(:fltType) { BuiltinType.new(Float)   }
+
+    it 'should apply structural equality' do
+      (intType == intType2).should be_true
+    end
+
+    it 'should apply distinguish different types' do
+      (intType == fltType).should be_false
+    end
+
+    it 'should be a total function, with nil for non types' do
+      (intType == 12).should be_false
+    end
+
+    it 'should implement hash accordingly' do
+      (intType.hash == intType2.hash).should be_true
+    end
+
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Qrb
+  describe BuiltinType, "include?" do
+
+    let(:type){ BuiltinType.new(Integer) }
+
+    subject{ type.include?(arg) }
+
+    context 'when not included' do
+      let(:arg){ "12" }
+
+      it{ should be_false }
+    end
+
+    context 'when included' do
+      let(:arg){ 12 }
+
+      it{ should be_true }
+    end
+
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+module Qrb
+  describe BuiltinType, "initialize" do
+
+    let(:type){ BuiltinType.new(Integer) }
+
+    it 'should set instance variables' do
+      type.ruby_type.should be(Integer)
+    end
+
+  end
+end