finitio 0.4.1 → 0.5.0

data/spec/attribute/test_initialize.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Finitio
+  describe Attribute, "initialize" do
+
+    context 'when implicitely required' do
+      subject{ Attribute.new(:red, intType) }
+
+      it 'should correctly set the instance variables' do
+        expect(subject.name).to eq(:red)
+        expect(subject.type).to eq(intType)
+        expect(subject).to be_required
+      end
+    end
+
+    context 'when not required' do
+      subject{ Attribute.new(:red, intType, false) }
+
+      it 'should correctly set the instance variables' do
+        expect(subject.name).to eq(:red)
+        expect(subject.type).to eq(intType)
+        expect(subject).not_to be_required
+      end
+    end
+
+  end
+end

data/spec/attribute/test_optional.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Finitio
+  describe Attribute, "optional?" do
+
+    it 'is false by default' do
+      expect(Attribute.new(:red, intType)).not_to be_optional
+    end
+
+    it 'is is the reverse of required' do
+      expect(Attribute.new(:red, intType, false)).to be_optional
+    end
+
+    it 'is is the reverse of !required' do
+      expect(Attribute.new(:red, intType, true)).not_to be_optional
+    end
+
+  end
+end

data/spec/attribute/test_required.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Finitio
+  describe Attribute, "required?" do
+
+    it 'is true by default' do
+      expect(Attribute.new(:red, intType)).to be_required
+    end
+
+    it 'is can be set to true' do
+      expect(Attribute.new(:red, intType, true)).to be_required
+    end
+
+    it 'is can be set to false' do
+      expect(Attribute.new(:red, intType, false)).not_to be_required
+    end
+
+  end
+end

data/spec/attribute/test_to_name.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Finitio
+  describe Attribute, "to_name" do
+
+    subject{ attr.to_name }
+
+    context 'when required' do
+      let(:attr){ Attribute.new(:red, intType) }
+
+      it{ should eq("red: intType") }
+    end
+
+    context 'when not required' do
+      let(:attr){ Attribute.new(:red, intType, false) }
+
+      it{ should eq("red :? intType") }
+    end
+
+  end
+end

data/spec/constraint/test_anonymous.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Finitio
+  describe Constraint, "anonymous?" do
+
+    subject{ constraint.anonymous? }
+
+    context 'with an unnamed constraint' do
+      let(:constraint){ Constraint.new(byte_full) }
+
+      it{ should eq(true) }
+    end
+
+    context 'with a named constraint' do
+      let(:constraint){ Constraint.new(byte_full, :byte) }
+
+      it{ should eq(false) }
+    end
+
+  end
+end

data/spec/constraint/test_equality.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+module Finitio
+  describe Constraint, "==" do
+
+    def constraint(proc, name = nil)
+      Constraint.new(proc, name)
+    end
+
+    it 'recognizes same procs' do
+      expect(constraint(byte_min)).to eq(constraint(byte_min))
+    end
+
+    it 'recognizes non constraints' do
+      expect(constraint(byte_min)).not_to eq(nil)
+      expect(constraint(byte_min)).not_to eq(1)
+    end
+
+    it 'recognizes non equivalent constraints' do
+      expect(constraint(byte_min)).not_to eq(constraint(byte_max))
+    end
+
+    it 'does not take name into accound' do
+      expect(constraint(byte_min, :foo)).to eq(constraint(byte_min, :bar))
+    end
+
+    it 'implements hash accordingly' do
+      c1 = constraint(byte_min)
+      c2 = constraint(byte_min)
+      expect(c1.hash).to eq(c2.hash)
+    end
+
+    it 'is smart enough to have different hash codes for different constraints' do
+      c1 = constraint(byte_min)
+      c2 = constraint(byte_max)
+      expect(c1.hash).not_to eq(c2.hash)
+    end
+
+  end
+end

data/spec/constraint/test_name.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Finitio
+  describe Constraint, "name" do
+
+    subject{ constraint.name }
+
+    context 'with an unnamed constraint' do
+      let(:constraint){ Constraint.new(byte_full) }
+
+      it{ should eq(:default) }
+    end
+
+    context 'with a named constraint' do
+      let(:constraint){ Constraint.new(byte_full, :byte) }
+
+      it{ should eq(:byte) }
+    end
+
+  end
+end

data/spec/constraint/test_named.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Finitio
+  describe Constraint, "named?" do
+
+    subject{ constraint.named? }
+
+    context 'with an unnamed constraint' do
+      let(:constraint){ Constraint.new(byte_full) }
+
+      it{ should eq(false) }
+    end
+
+    context 'with a named constraint' do
+      let(:constraint){ Constraint.new(byte_full, :byte) }
+
+      it{ should eq(true) }
+    end
+
+  end
+end

data/spec/constraint/test_triple_equal.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+module Finitio
+  describe Constraint, "===" do
+
+    let(:constraint){ Constraint.new(byte_full) }
+
+    it 'delegates to the proc' do
+      expect(constraint.===(17)).to eq(true)
+      expect(constraint.===(1700)).to eq(false)
+    end
+
+  end
+end

data/spec/finitio/test_parse.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+describe Finitio, "parse" do
+
+  context 'with a string' do
+    subject{
+      Finitio.parse <<-EOF
+        Posint = .Fixnum( i | i>=0 )
+        Point  = { x: Posint, y: Posint }
+      EOF
+    }
+
+    it{ should be_a(Finitio::Syntax::System) }
+  end
+
+  context 'with a Path' do
+    subject{
+      Finitio.parse(Path.dir/"system.fio")
+    }
+
+    it{ should be_a(Finitio::Syntax::System) }
+  end
+
+end

data/spec/{unit/qrb/test_parse.rb → finitio/test_system.rb}

@@ -1,9 +1,9 @@
 require 'spec_helper'
-describe Finitio, "parse" do
+describe Finitio, "system" do
 
   context 'with a string' do
     subject{
-      Finitio.parse <<-EOF
+      Finitio.system <<-EOF
         Posint = .Fixnum( i | i>=0 )
         Point  = { x: Posint, y: Posint }
       EOF
@@ -12,20 +12,20 @@ describe Finitio, "parse" do
     it{ should be_a(Finitio::System) }
 
     it 'should have the expected types' do
-      subject["Posint"].should be_a(Finitio::SubType)
-      subject["Point"].should be_a(Finitio::TupleType)
+      expect(subject["Posint"]).to be_a(Finitio::SubType)
+      expect(subject["Point"]).to be_a(Finitio::TupleType)
     end
   end
 
   context 'with a Path' do
     subject{
-      Finitio.parse(Path.dir/"system.q")
+      Finitio.system(Path.dir/"system.fio")
     }
 
     it{ should be_a(Finitio::System) }
 
     it 'should have the expected types' do
-      subject["Posint"].should be_a(Finitio::SubType)
+      expect(subject["Posint"]).to be_a(Finitio::SubType)
     end
   end
 

data/spec/heading/test_allow_extra.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Finitio
+  describe Heading, "allow_extra" do
+
+    let(:r){ Attribute.new(:r, intType) }
+
+    def heading(attributes, options = nil)
+      Heading.new(attributes, options)
+    end
+
+    it 'is false by default' do
+      expect(heading([r])).not_to be_allow_extra
+    end
+
+    it 'can be set to true' do
+      expect(heading([r], allow_extra: true)).to be_allow_extra
+    end
+
+    it 'can be set to false explicitely' do
+      expect(heading([r], allow_extra: false)).not_to be_allow_extra
+    end
+
+  end
+end

data/spec/{unit/heading → heading}/test_each.rb

@@ -9,7 +9,7 @@ module Finitio
     context 'without a block' do
 
       it 'should return an enumerator' do
-        h.each.should be_a(Enumerator)
+        expect(h.each).to be_a(Enumerator)
       end
     end
 
@@ -20,7 +20,7 @@ module Finitio
         h.each do |attr|
           seen << attr
         end
-        seen.should eq([a, b])
+        expect(seen).to eq([a, b])
       end
     end
 

data/spec/heading/test_equality.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Finitio
+  describe Heading, "equality" do
+
+    let(:r)      { Attribute.new(:r, intType)        }
+    let(:b)      { Attribute.new(:b, intType)        }
+    let(:maybe_r){ Attribute.new(:r, intType, false) }
+
+    def heading(attributes, options = nil)
+      Heading.new(attributes, options)
+    end
+
+    it 'does not put significance to attributes ordering' do
+      expect(heading([r, b])).to eq(heading([b, r]))
+    end
+
+    it 'distinguishes between different attribute sets' do
+      expect(heading([r])).not_to eq(heading([b]))
+    end
+
+    it 'distinguishes between attribute obligations' do
+      expect(heading([r])).not_to eq(heading([maybe_r]))
+    end
+
+    it 'distinguishes between extra allowance' do
+      h1 = heading([r], allow_extra: true)
+      h2 = heading([r], allow_extra: false)
+      expect(h1).not_to eq(h2)
+    end
+
+    it 'distinguishes between attribute types' do
+      a1 = Attribute.new(:r, intType)
+      a2 = Attribute.new(:r, floatType)
+      expect(heading([a1])).not_to eq(heading([a2]))
+    end
+
+  end
+end

data/spec/heading/test_hash.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Finitio
+  describe Heading, "hash" do
+
+    let(:r)      { Attribute.new(:r, intType)        }
+    let(:b)      { Attribute.new(:b, intType)        }
+    let(:maybe_r){ Attribute.new(:r, intType, false) }
+
+    def heading(attributes, options = nil)
+      Heading.new(attributes, options)
+    end
+
+    it 'returns same code on equal headings' do
+      expect(heading([r]).hash).to eq(heading([r]).hash)
+    end
+
+    it 'does not put significance to attributes ordering' do
+      expect(heading([r, b]).hash).to eq(heading([b, r]).hash)
+    end
+
+    it 'is good enough to distinguish between attribute obligations' do
+      expect(heading([r]).hash).not_to eq(heading([maybe_r]).hash)
+    end
+
+    it 'is good enough to distinguish between extra allowance' do
+      h1 = heading([r], allow_extra: true)
+      h2 = heading([r], allow_extra: false)
+      expect(h1.hash).not_to eq(h2.hash)
+    end
+
+    it 'is be good enough to distinguish between different headings' do
+      a1 = Attribute.new(:r, intType)
+      a2 = Attribute.new(:r, floatType)
+      expect(heading([a1]).hash).not_to eq(heading([a2]).hash)
+    end
+
+  end
+end

data/spec/heading/test_hash_get.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Finitio
+  describe Heading, "[]" do
+
+    let(:a){ Attribute.new(:a, intType) }
+    let(:h){ Heading.new([a]) }
+
+    it 'returns the attribute by name' do
+      expect(h[:a]).to be(a)
+    end
+
+    it 'returns nil if no such attribute' do
+      expect(h[:b]).to be_nil
+    end
+
+  end
+end

data/spec/{unit/heading → heading}/test_initialize.rb

@@ -26,9 +26,9 @@ module Finitio
       }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error(ArgumentError, "Attribute names must be unique")
+        }.to raise_error(ArgumentError, "Attribute names must be unique")
       end
     end
 

data/spec/heading/test_multi.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+module Finitio
+  describe Heading, "multi?" do
+
+    let(:red){
+      Attribute.new(:red, intType)
+    }
+
+    let(:blue){
+      Attribute.new(:blue, floatType)
+    }
+
+    let(:maybe_blue){
+      Attribute.new(:blue, floatType, false)
+    }
+
+    subject{ Heading.new(attributes, options).multi? }
+
+    let(:options){ nil }
+
+    context 'with no attribute' do
+      let(:attributes){
+        [ ]
+      }
+
+      it{ should eq(false) }
+    end
+
+    context 'with required attributes only' do
+      let(:attributes){
+        [ red, blue ]
+      }
+
+      it{ should eq(false) }
+    end
+
+    context 'with some optional attributes' do
+      let(:attributes){
+        [ red, maybe_blue ]
+      }
+
+      it{ should eq(true) }
+    end
+
+    context 'with allow_extra set to true' do
+      let(:attributes){
+        [ red, blue ]
+      }
+      let(:options){
+        {allow_extra: true}
+      }
+
+      it{ should eq(true) }
+    end
+
+  end
+end