alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-predicate/factory/shared/a_predicate_ast_node.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-shared_examples_for "a predicate AST node" do
-
-  it{ should be_a(Sexpr) }
-
-  it{ should be_a(Alf::Predicate::Expr) }
-
-  specify{
-    (subject.tautology? == subject.is_a?(Alf::Predicate::Tautology)).should be_true
-  }
-
-  specify{
-    (subject.contradiction? == subject.is_a?(Alf::Predicate::Contradiction)).should be_true
-  }
-
-  specify{
-    subject.free_variables.should be_a(Alf::AttrList) unless subject.is_a?(Alf::Predicate::Native)
-  }
-
-end

data/spec/unit/alf-predicate/factory/test_and.rb

@@ -1,15 +0,0 @@
-require_relative 'shared/a_predicate_ast_node'
-module Alf
-  class Predicate
-    describe Factory, 'and' do
-      include Factory
-
-      subject{ self.and(true, true) }
-
-      it_should_behave_like "a predicate AST node"
-      it{ should be_a(And) }
-      it{ should eql([:and, tautology, tautology]) }
-
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_between.rb

@@ -1,14 +0,0 @@
-require_relative "shared/a_comparison_factory_method"
-module Alf
-  class Predicate
-    describe Factory, 'between' do
-
-      subject{ Factory.between(:x, 2, 3) }
-
-      it{ should be_a(And) }
-
-      it{ should eq([:and, [:gte, [:identifier, :x], [:literal, 2]], [:lte, [:identifier, :x], [:literal, 3]]]) }
-
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_comp.rb

@@ -1,37 +0,0 @@
-require_relative 'shared/a_predicate_ast_node'
-module Alf
-  class Predicate
-    describe Factory, 'comp' do
-
-      subject{ Factory.comp(:eq, h) }
-
-      context "when the hash is empty" do
-        let(:h){ {} }
-
-        it{ should eq(Factory.tautology) }
-      end
-
-      context "when the hash is singleton" do
-        let(:h){ {:x => 12, :y => :z} }
-        let(:expected){
-          [:and,
-            [:eq, [:identifier, :x], [:literal, 12]],
-            [:eq, [:identifier, :y], [:identifier, :z]]]
-        }
-
-        it_should_behave_like "a predicate AST node"
-        it{ should be_a(And) }
-        it{ should eq(expected) }
-      end
-
-      context "when the hash is not singelton" do
-        let(:h){ {:x => 12} }
-
-        it_should_behave_like "a predicate AST node"
-        it{ should be_a(Eq) }
-        it{ should eq([:eq, [:identifier, :x], [:literal, 12]]) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_contradiction.rb

@@ -1,13 +0,0 @@
-require_relative 'shared/a_predicate_ast_node'
-module Alf
-  class Predicate
-    describe Factory, 'contradiction' do
-      include Factory
-
-      subject{ contradiction }
-
-      it_should_behave_like "a predicate AST node"
-      it{ should be_a(Contradiction) }
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_eq.rb

@@ -1,11 +0,0 @@
-require_relative "shared/a_comparison_factory_method"
-module Alf
-  class Predicate
-    describe Factory, 'eq' do
-      let(:method){ :eq }
-      let(:node_class){ Eq }
-
-      it_should_behave_like "a comparison factory method"
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_factor_predicate.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Factory, "_factor_predicate" do
-
-      subject{ Factory._factor_predicate(arg) }
-
-      context "on Expr" do
-        let(:arg){ Grammar.sexpr([:literal, 12]) }
-
-        it{ should be(arg) }
-      end
-
-      context "on true" do
-        let(:arg){ true }
-
-        it{ should be_a(Tautology) }
-      end
-
-      context "on false" do
-        let(:arg){ false }
-
-        it{ should be_a(Contradiction) }
-      end
-
-      context "on Symbol" do
-        let(:arg){ :name }
-
-        it{ should be_a(Identifier) }
-      end
-
-      context "on Proc" do
-        let(:arg){ lambda{} }
-
-        it{ should be_a(Native) }
-      end
-
-      context "on Array" do
-        let(:arg){ [:identifier, :name] }
-
-        it{ should be_a(Identifier) }
-      end
-
-      context "on 12" do
-        let(:arg){ 12 }
-
-        it{ should be_a(Literal) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_gt.rb

@@ -1,11 +0,0 @@
-require_relative "shared/a_comparison_factory_method"
-module Alf
-  class Predicate
-    describe Factory, 'gt' do
-      let(:method){ :gt }
-      let(:node_class){ Gt }
-
-      it_should_behave_like "a comparison factory method"
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_gte.rb

@@ -1,11 +0,0 @@
-require_relative "shared/a_comparison_factory_method"
-module Alf
-  class Predicate
-    describe Factory, 'gte' do
-      let(:method){ :gte }
-      let(:node_class){ Gte }
-
-      it_should_behave_like "a comparison factory method"
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_identifier.rb

@@ -1,15 +0,0 @@
-require_relative 'shared/a_predicate_ast_node'
-module Alf
-  class Predicate
-    describe Factory, 'identifier' do
-      include Factory
-
-      subject{ identifier(:name) }
-
-      it_should_behave_like "a predicate AST node"
-      it{ should be_a(Identifier) }
-      it{ should eql([:identifier, :name]) }
-
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_in.rb

@@ -1,14 +0,0 @@
-require_relative "shared/a_comparison_factory_method"
-module Alf
-  class Predicate
-    describe Factory, 'in' do
-
-      subject{ Factory.in(:x, [2, 3]) }
-
-      it{ should be_a(In) }
-
-      it{ should eq([:in, [:identifier, :x], [2, 3]]) }
-
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_literal.rb

@@ -1,15 +0,0 @@
-require_relative 'shared/a_predicate_ast_node'
-module Alf
-  class Predicate
-    describe Factory, 'literal' do
-      include Factory
-
-      subject{ literal(12) }
-
-      it_should_behave_like "a predicate AST node"
-      it{ should be_a(Literal) }
-      it{ should eql([:literal, 12]) }
-
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_lt.rb

@@ -1,11 +0,0 @@
-require_relative "shared/a_comparison_factory_method"
-module Alf
-  class Predicate
-    describe Factory, 'lt' do
-      let(:method){ :lt }
-      let(:node_class){ Lt }
-
-      it_should_behave_like "a comparison factory method"
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_lte.rb

@@ -1,11 +0,0 @@
-require_relative "shared/a_comparison_factory_method"
-module Alf
-  class Predicate
-    describe Factory, 'lte' do
-      let(:method){ :lte }
-      let(:node_class){ Lte }
-
-      it_should_behave_like "a comparison factory method"
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_native.rb

@@ -1,21 +0,0 @@
-require_relative 'shared/a_predicate_ast_node'
-module Alf
-  class Predicate
-    describe Factory, 'native' do
-      include Factory
-
-      subject{ native(proc) }
-
-      context 'with a proc' do
-        let(:proc){ ->{} }
-
-        it_should_behave_like "a predicate AST node"
-
-        it{ should be_a(Native) }
-
-        it{ should eql([:native, proc]) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_neq.rb

@@ -1,11 +0,0 @@
-require_relative "shared/a_comparison_factory_method"
-module Alf
-  class Predicate
-    describe Factory, 'neq' do
-      let(:method){ :neq }
-      let(:node_class){ Neq }
-
-      it_should_behave_like "a comparison factory method"
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_not.rb

@@ -1,15 +0,0 @@
-require_relative 'shared/a_predicate_ast_node'
-module Alf
-  class Predicate
-    describe Factory, 'not' do
-      include Factory
-
-      subject{ self.not(true) }
-
-      it_should_behave_like "a predicate AST node"
-      it{ should be_a(Not) }
-      it{ should eql([:not, tautology]) }
-
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_or.rb

@@ -1,15 +0,0 @@
-require_relative 'shared/a_predicate_ast_node'
-module Alf
-  class Predicate
-    describe Factory, 'or' do
-      include Factory
-
-      subject{ self.or(true, true) }
-
-      it_should_behave_like "a predicate AST node"
-      it{ should be_a(Or) }
-      it{ should eql([:or, tautology, tautology]) }
-
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_qualified_identifier.rb

@@ -1,17 +0,0 @@
-require_relative 'shared/a_predicate_ast_node'
-module Alf
-  class Predicate
-    describe Factory, 'qualified_identifier' do
-      include Factory
-
-      subject{ qualified_identifier(:t, :name) }
-
-      it_should_behave_like "a predicate AST node"
-
-      it{ should be_a(QualifiedIdentifier) }
-
-      it{ should eql([:qualified_identifier, :t, :name]) }
-
-    end
-  end
-end

data/spec/unit/alf-predicate/factory/test_tautology.rb

@@ -1,14 +0,0 @@
-require_relative 'shared/a_predicate_ast_node'
-module Alf
-  class Predicate
-    describe Factory, 'tautology' do
-      include Factory
-
-      subject{ tautology }
-
-      it_should_behave_like "a predicate AST node"
-      it{ should be_a(Tautology) }
-
-    end
-  end
-end

data/spec/unit/alf-predicate/grammar/test_match.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Grammar, 'match?' do
-
-      context "tautology" do
-        subject{ Grammar[:tautology] }
-
-        it 'matches a tautology' do
-          subject.should be_match([:tautology, true])
-        end
-        it 'does no match a wrong one' do
-          subject.should_not be_match([:tautology, false])
-        end
-      end
-
-      context "contradiction" do
-        subject{ Grammar[:contradiction] }
-
-        it 'matches a tautology' do
-          subject.should be_match([:contradiction, false])
-        end
-        it 'does no match a wrong one' do
-          subject.should_not be_match([:contradiction, true])
-        end
-      end
-
-      context "identifier" do
-        subject{ Grammar[:identifier] }
-
-        it 'matches a valid ast' do
-          subject.should be_match([:identifier, :id])
-        end
-
-        it 'does not match an invalid ast' do
-          subject.should_not be_match([:identifier, 12])
-        end
-      end
-
-      context "literal" do
-        subject{ Grammar[:literal] }
-
-        it 'matches valid ASTs' do
-          subject.should be_match([:literal, 12])
-          subject.should be_match([:literal, true])
-        end
-      end
-
-      context "in" do
-        subject{ Grammar[:in] }
-
-        it 'matches valid ASTs' do
-          subject.should be_match([:in, [:identifier, :x], [2, 3]])
-        end
-        it 'does not match invalid ASTs' do
-          subject.should_not be_match([:in, :x])
-        end
-      end
-
-      context "eq" do
-        subject{ Grammar[:eq] }
-
-        it 'matches valid ASTs' do
-          subject.should be_match([:eq, [:identifier, :age], [:literal, 12]])
-        end
-        it 'does not match invalid ASTs' do
-          subject.should_not be_match([:neq, [:identifier, :age], [:literal, 12]])
-        end
-      end
-
-      context "neq" do
-        subject{ Grammar[:neq] }
-
-        it 'matches valid ASTs' do
-          subject.should be_match([:neq, [:identifier, :age], [:literal, 12]])
-        end
-        it 'does not match invalid ASTs' do
-          subject.should_not be_match([:eq, [:identifier, :age], [:literal, 12]])
-        end
-      end
-
-      context "native" do
-        subject{ Grammar[:native] }
-
-        it 'matches valid ASTs' do
-          subject.should be_match([:native, lambda{}])
-        end
-        it 'does not match invalid ASTs' do
-          subject.should_not be_match([:native, 12])
-        end
-      end
-
-    end
-  end
-end