alf-core 0.14.0 → 0.15.0

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

@@ -13,7 +13,7 @@ shared_examples_for "a comparison factory method" do
   context 'with a Hash operand (singleton)' do
     subject{ self.send(method, :x => :y) }
     let(:expected){
-      [method, [:var_ref, :x], [:var_ref, :y]]
+      [method, [:identifier, :x], [:identifier, :y]]
     }
 
     it_should_behave_like "a predicate AST node"
@@ -24,8 +24,8 @@ shared_examples_for "a comparison factory method" do
     subject{ self.send(method, :x => :y, :v => 2) }
     let(:expected){
       [:and,
-        [method, [:var_ref, :x], [:var_ref, :y]],
-        [method, [:var_ref, :v], [:literal, 2]]]
+        [method, [:identifier, :x], [:identifier, :y]],
+        [method, [:identifier, :v], [:literal, 2]]]
     }
 
     it_should_behave_like "a predicate AST node"

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

@@ -7,7 +7,7 @@ module Alf
 
       it{ should be_a(And) }
 
-      it{ should eq([:and, [:gte, [:var_ref, :x], [:literal, 2]], [:lte, [:var_ref, :x], [:literal, 3]]]) }
+      it{ should eq([:and, [:gte, [:identifier, :x], [:literal, 2]], [:lte, [:identifier, :x], [:literal, 3]]]) }
 
     end
   end

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

@@ -15,8 +15,8 @@ module Alf
         let(:h){ {:x => 12, :y => :z} }
         let(:expected){
           [:and,
-            [:eq, [:var_ref, :x], [:literal, 12]],
-            [:eq, [:var_ref, :y], [:var_ref, :z]]]
+            [:eq, [:identifier, :x], [:literal, 12]],
+            [:eq, [:identifier, :y], [:identifier, :z]]]
         }
 
         it_should_behave_like "a predicate AST node"
@@ -29,7 +29,7 @@ module Alf
 
         it_should_behave_like "a predicate AST node"
         it{ should be_a(Eq) }
-        it{ should eq([:eq, [:var_ref, :x], [:literal, 12]]) }
+        it{ should eq([:eq, [:identifier, :x], [:literal, 12]]) }
       end
 
     end

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

@@ -26,7 +26,7 @@ module Alf
       context "on Symbol" do
         let(:arg){ :name }
 
-        it{ should be_a(VarRef) }
+        it{ should be_a(Identifier) }
       end
 
       context "on Proc" do
@@ -36,9 +36,9 @@ module Alf
       end
 
       context "on Array" do
-        let(:arg){ [:var_ref, :name] }
+        let(:arg){ [:identifier, :name] }
 
-        it{ should be_a(VarRef) }
+        it{ should be_a(Identifier) }
       end
 
       context "on 12" do

data/spec/unit/alf-predicate/factory/{test_var_ref.rb → test_identifier.rb}

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

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

@@ -7,7 +7,7 @@ module Alf
 
       it{ should be_a(In) }
 
-      it{ should eq([:in, [:var_ref, :x], [2, 3]]) }
+      it{ should eq([:in, [:identifier, :x], [2, 3]]) }
 
     end
   end

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

@@ -4,12 +4,17 @@ module Alf
     describe Factory, 'native' do
       include Factory
 
-      let(:proc){ lambda{} }
       subject{ native(proc) }
 
-      it_should_behave_like "a predicate AST node"
-      it{ should be_a(Native) }
-      it{ should eql([: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

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

@@ -0,0 +1,17 @@
+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/grammar/test_match.rb

@@ -25,15 +25,15 @@ module Alf
         end
       end
 
-      context "var_ref" do
-        subject{ Grammar[:var_ref] }
+      context "identifier" do
+        subject{ Grammar[:identifier] }
 
         it 'matches a valid ast' do
-          subject.should be_match([:var_ref, :id])
+          subject.should be_match([:identifier, :id])
         end
 
         it 'does not match an invalid ast' do
-          subject.should_not be_match([:var_ref, 12])
+          subject.should_not be_match([:identifier, 12])
         end
       end
 
@@ -50,7 +50,7 @@ module Alf
         subject{ Grammar[:in] }
 
         it 'matches valid ASTs' do
-          subject.should be_match([:in, [:var_ref, :x], [2, 3]])
+          subject.should be_match([:in, [:identifier, :x], [2, 3]])
         end
         it 'does not match invalid ASTs' do
           subject.should_not be_match([:in, :x])
@@ -61,10 +61,10 @@ module Alf
         subject{ Grammar[:eq] }
 
         it 'matches valid ASTs' do
-          subject.should be_match([:eq, [:var_ref, :age], [:literal, 12]])
+          subject.should be_match([:eq, [:identifier, :age], [:literal, 12]])
         end
         it 'does not match invalid ASTs' do
-          subject.should_not be_match([:neq, [:var_ref, :age], [:literal, 12]])
+          subject.should_not be_match([:neq, [:identifier, :age], [:literal, 12]])
         end
       end
 
@@ -72,10 +72,10 @@ module Alf
         subject{ Grammar[:neq] }
 
         it 'matches valid ASTs' do
-          subject.should be_match([:neq, [:var_ref, :age], [:literal, 12]])
+          subject.should be_match([:neq, [:identifier, :age], [:literal, 12]])
         end
         it 'does not match invalid ASTs' do
-          subject.should_not be_match([:eq, [:var_ref, :age], [:literal, 12]])
+          subject.should_not be_match([:eq, [:identifier, :age], [:literal, 12]])
         end
       end
 

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

@@ -8,8 +8,8 @@ module Alf
       let(:contradiction){
         [:contradiction, false]
       }
-      let(:var_ref){
-        [:var_ref, :name]
+      let(:identifier){
+        [:identifier, :name]
       }
 
       before do
@@ -28,10 +28,10 @@ module Alf
         it{ should be_a(Contradiction) }
       end
 
-      describe "var_ref" do
-        let(:expr){ [:var_ref, :name] }
+      describe "identifier" do
+        let(:expr){ [:identifier, :name] }
 
-        it{ should be_a(VarRef) }
+        it{ should be_a(Identifier) }
       end
 
       describe "and" do
@@ -53,37 +53,37 @@ module Alf
       end
 
       describe "eq" do
-        let(:expr){ [:eq, var_ref, var_ref] }
+        let(:expr){ [:eq, identifier, identifier] }
 
         it{ should be_a(Eq) }
       end
 
       describe "neq" do
-        let(:expr){ [:neq, var_ref, var_ref] }
+        let(:expr){ [:neq, identifier, identifier] }
 
         it{ should be_a(Neq) }
       end
 
       describe "gt" do
-        let(:expr){ [:gt, var_ref, var_ref] }
+        let(:expr){ [:gt, identifier, identifier] }
 
         it{ should be_a(Gt) }
       end
 
       describe "gte" do
-        let(:expr){ [:gte, var_ref, var_ref] }
+        let(:expr){ [:gte, identifier, identifier] }
 
         it{ should be_a(Gte) }
       end
 
       describe "lt" do
-        let(:expr){ [:lt, var_ref, var_ref] }
+        let(:expr){ [:lt, identifier, identifier] }
 
         it{ should be_a(Lt) }
       end
 
       describe "lte" do
-        let(:expr){ [:lte, var_ref, var_ref] }
+        let(:expr){ [:lte, identifier, identifier] }
 
         it{ should be_a(Lte) }
       end

data/spec/unit/alf-predicate/nodes/{var_ref → identifier}/test_and_split.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 module Alf
   class Predicate
-    describe VarRef, "and_split" do
+    describe Identifier, "and_split" do
 
-      let(:predicate){ Factory.var_ref(:id) }
+      let(:predicate){ Factory.identifier(:id) }
       let(:tautology){ Factory.tautology    }
 
       subject{ predicate.and_split(list) }

data/spec/unit/alf-predicate/nodes/{var_ref → identifier}/test_free_variables.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 module Alf
   class Predicate
-    describe VarRef, "free_variables" do
+    describe Identifier, "free_variables" do
 
-      let(:expr){ Factory.var_ref(:id) }
+      let(:expr){ Factory.identifier(:id) }
 
       subject{ expr.free_variables }
 

data/spec/unit/alf-predicate/nodes/identifier/test_name.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe Identifier, "name" do
+
+      let(:expr){ Factory.identifier(:id) }
+
+      subject{ expr.name }
+
+      it{ should eq(:id) }
+
+    end
+  end
+end

data/spec/unit/alf-predicate/nodes/qualified_identifier/test_and_split.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe QualifiedIdentifier, "and_split" do
+
+      let(:predicate){ Factory.qualified_identifier(:t, :id) }
+      let(:tautology){ Factory.tautology    }
+
+      subject{ predicate.and_split(list) }
+
+      context 'when included' do
+        let(:list){ AttrList[:id, :name] }
+
+        it{ should eq([predicate, tautology]) }
+      end
+
+      context 'when not include' do
+        let(:list){ AttrList[:name] }
+
+        it{ should eq([tautology, predicate]) }
+      end
+
+    end
+  end
+end

data/spec/unit/alf-predicate/nodes/qualified_identifier/test_free_variables.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe QualifiedIdentifier, "free_variables" do
+
+      let(:expr){ Factory.qualified_identifier(:t, :id) }
+
+      subject{ expr.free_variables }
+
+      it{ should eq(AttrList[:id]) }
+
+    end
+  end
+end

data/spec/unit/alf-predicate/nodes/qualified_identifier/test_name.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe QualifiedIdentifier, "name" do
+
+      let(:expr){ Factory.qualified_identifier(:t, :id) }
+
+      subject{ expr.name }
+
+      it{ should eq(:id) }
+
+    end
+  end
+end

data/spec/unit/alf-predicate/nodes/qualified_identifier/test_qualifier.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe QualifiedIdentifier, "qualified" do
+
+      let(:expr){ Factory.qualified_identifier(:t, :id) }
+
+      subject{ expr.qualifier }
+
+      it{ should eq(:t) }
+
+    end
+  end
+end

data/spec/unit/alf-predicate/predicate/test_and_split.rb

@@ -18,14 +18,14 @@ module Alf
         it{ should eq([p.tautology, pred]) }
       end
 
-      context "on var_ref (included)" do
-        let(:pred){ p.var_ref(:x) }
+      context "on identifier (included)" do
+        let(:pred){ p.identifier(:x) }
 
         it{ should eq([ pred, p.tautology ]) }
       end
 
-      context "on var_ref (excluded)" do
-        let(:pred){ p.var_ref(:y) }
+      context "on identifier (excluded)" do
+        let(:pred){ p.identifier(:y) }
 
         it{ should eq([ p.tautology, pred ]) }
       end

data/spec/unit/alf-predicate/predicate/test_bool_and.rb

@@ -27,7 +27,7 @@ module Alf
         let(:right){ Predicate.coerce(y: 3) }
 
         it 'should be a expected' do
-          subject.to_ruby_code.should eq("(self.x == 2) && (self.y == 3)")
+          subject.to_ruby_code.should eq("->(t){ (t.x == 2) && (t.y == 3) }")
         end
       end
 

data/spec/unit/alf-predicate/predicate/test_bool_not.rb

@@ -20,7 +20,7 @@ module Alf
       context "on not" do
         let(:pred){ Predicate.not(:x) }
 
-        it{ should eq(Predicate.var_ref(:x)) }
+        it{ should eq(Predicate.identifier(:x)) }
       end
 
       context "on comp" do

data/spec/unit/alf-predicate/predicate/test_bool_or.rb

@@ -27,7 +27,7 @@ module Alf
         let(:right){ Predicate.coerce(y: 3) }
 
         it 'should be a expected' do
-          subject.to_ruby_code.should eq("(self.x == 2) || (self.y == 3)")
+          subject.to_ruby_code.should eq("->(t){ (t.x == 2) || (t.y == 3) }")
         end
       end
 

data/spec/unit/alf-predicate/predicate/test_coerce.rb

@@ -31,8 +31,8 @@ module Alf
         let(:arg){ :status }
 
         specify{
-          subject.expr.should be_a(VarRef)
-          subject.expr.var_name.should eq(arg)
+          subject.expr.should be_a(Identifier)
+          subject.expr.name.should eq(arg)
         }
       end
 
@@ -48,10 +48,11 @@ module Alf
       describe "from String" do
         let(:arg){ "status == 10" }
 
-        specify{
-          subject.expr.should be_a(Native)
-          subject.to_proc.to_ruby_literal.should eq("lambda{ status == 10 }")
-        }
+        it 'raises an error' do
+          lambda{
+            subject
+          }.should raise_error(ArgumentError)
+        end
       end
 
       describe "from Hash (single)" do
@@ -59,7 +60,7 @@ module Alf
 
         specify{
           subject.expr.should be_a(Eq)
-          subject.expr.should eq([:eq, [:var_ref, :status], [:literal, 10]])
+          subject.expr.should eq([:eq, [:identifier, :status], [:literal, 10]])
         }
       end
 
@@ -68,7 +69,7 @@ module Alf
 
         specify{
           subject.expr.should be_a(Eq)
-          subject.expr.should eq([:eq, [:var_ref, :status], [:literal, 10]])
+          subject.expr.should eq([:eq, [:identifier, :status], [:literal, 10]])
         }
       end