predicate 2.3.2 → 2.6.0

data/spec/dsl/test_to_skake_case.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+class Predicate
+  describe Dsl, "to_snake_case" do
+
+    def snake(str)
+      Dsl.new.__send__(:to_snake_case, str)
+    end
+
+    it 'works on snake case already' do
+      {
+        "snake" => "snake",
+        "snake_case" => "snake_case"
+      }.each_pair do |k,v|
+        expect(snake(k)).to eq(v)
+      end
+    end
+
+    it 'works on camelCase already' do
+      {
+        "camelCase" => "camel_case",
+        "theCamelCase" => "the_camel_case"
+      }.each_pair do |k,v|
+        expect(snake(k)).to eq(v)
+      end
+    end
+
+    it 'works on PascalCase already' do
+      {
+        "PascalCase" => "pascal_case",
+        "ThePascalCase" => "the_pascal_case"
+      }.each_pair do |k,v|
+        expect(snake(k)).to eq(v)
+      end
+    end
+
+  end
+end

data/spec/factory/shared/a_comparison_factory_method.rb

@@ -1,6 +1,7 @@
 require_relative 'a_predicate_ast_node'
 shared_examples_for "a comparison factory method" do
   include Predicate::Factory
+  include Predicate::Sugar
 
   context 'with two operands' do
     subject{ self.send(method, true, true) }

data/spec/factory/test_${op_name}.rb.jeny

@@ -0,0 +1,12 @@
+#jeny(predicate)
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, '${op_name}' do
+    include Factory
+    subject{ ${op_name}(TODO) }
+
+    it_should_behave_like "a predicate AST node"
+
+    it{ should be_a(${OpName}) }
+  end
+end

data/spec/factory/test_comp.rb

@@ -10,7 +10,15 @@ class Predicate
       it{ should eq(Factory.tautology) }
     end
 
-    context "when the hash is singleton" do
+    context "when the hash is a 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
+
+    context "when the hash is not singleton" do
       let(:h){ {:x => 12, :y => :z} }
       let(:expected){
         [:and,
@@ -23,12 +31,27 @@ class Predicate
       it{ should eq(expected) }
     end
 
-    context "when the hash is not singelton" do
-      let(:h){ {:x => 12} }
+    context "when the value is a Regexp" do
+      let(:rx){ /[a-z]+/ }
+      let(:h){ {:x => /[a-z]+/} }
 
       it_should_behave_like "a predicate AST node"
-      it{ should be_a(Eq) }
-      it{ should eq([:eq, [:identifier, :x], [:literal, 12]]) }
+      it{ should be_a(Match) }
+      it{ should eq([:match, [:identifier, :x], [:literal, rx]]) }
+    end
+
+    context "when the hash mixes value types" do
+      let(:rx){ /[a-z]+/ }
+      let(:h){ {:x => 12, :y => rx} }
+      let(:expected){
+        [:and,
+          [:eq, [:identifier, :x], [:literal, 12]],
+          [:match, [:identifier, :y], [:literal, rx]]]
+      }
+
+      it_should_behave_like "a predicate AST node"
+      it{ should be_a(And) }
+      it{ should eq(expected) }
     end
 
   end

data/spec/factory/test_empty.rb

@@ -0,0 +1,11 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'empty' do
+    include Factory
+    subject{ empty(:x) }
+
+    it_should_behave_like "a predicate AST node"
+
+    it{ should be_a(Empty) }
+  end
+end

data/spec/factory/test_has_size.rb

@@ -0,0 +1,11 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'has_size' do
+    include Factory
+    subject{ has_size(:x, 1..10) }
+
+    it_should_behave_like "a predicate AST node"
+
+    it{ should be_a(HasSize) }
+  end
+end

data/spec/factory/test_match.rb

@@ -2,6 +2,7 @@ require_relative 'shared/a_predicate_ast_node'
 class Predicate
   describe Factory, 'match' do
     include Factory
+    include Sugar
 
     context 'without options' do
       subject{ match(:name, "London") }

data/spec/factory/test_set_ops.rb

@@ -0,0 +1,18 @@
+require_relative "shared/a_comparison_factory_method"
+class Predicate
+  [
+    [ :intersect, Intersect ],
+    [ :subset, Subset ],
+    [ :superset, Superset ],
+  ].each do |op_name, op_class|
+    describe Factory, op_name do
+
+      subject{ Factory.send(op_name, :x, [2, 3]) }
+
+      it{ should be_a(op_class) }
+
+      it{ should eq([op_name, [:identifier, :x], [:literal, [2, 3]]]) }
+
+    end
+  end
+end

data/spec/factory/test_var.rb

@@ -0,0 +1,22 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'var' do
+    include Factory
+
+    context 'when used with a string' do
+      subject{ var("a.b.c", :dig) }
+
+      it_should_behave_like "a predicate AST node"
+      it{ should be_a(Var) }
+      it{ should eql([:var, "a.b.c", :dig]) }
+    end
+
+    context 'when used with an array' do
+      subject{ var([:a, :b, :c], :dig) }
+
+      it_should_behave_like "a predicate AST node"
+      it{ should be_a(Var) }
+      it{ should eql([:var, [:a, :b, :c], :dig]) }
+    end
+  end
+end

data/spec/factory/test_vars.rb

@@ -0,0 +1,27 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'vars' do
+    include Factory
+
+    context 'when used without semantics' do
+      subject{ vars("a.b.c", "d.e.f") }
+
+      it 'works as expected' do
+        expect(subject).to be_a(Array)
+        expect(subject.size).to eql(2)
+        expect(subject.all?{|p| p.is_a?(Var) && p.semantics == :dig })
+      end
+    end
+
+    context 'when used with semantics' do
+      subject{ vars("a.b.c", "d.e.f", :jsonpath) }
+
+      it 'works as expected' do
+        expect(subject).to be_a(Array)
+        expect(subject.size).to eql(2)
+        expect(subject.all?{|p| p.is_a?(Var) && p.semantics == :jsonpath })
+      end
+    end
+
+  end
+end

data/spec/nodes/${op_name}.jeny/test_evaluate.rb.jeny

@@ -0,0 +1,19 @@
+#jeny(predicate)
+require 'spec_helper'
+class Predicate
+  describe ${OpName}, "evaluate" do
+
+    let(:predicate){ Factory.${op_name}(TODO) }
+
+    subject{ predicate.evaluate(context) }
+
+    context "on TODO" do
+      let(:context){ TODO }
+
+      it 'works as expected' do
+        TODO
+      end
+    end
+
+  end
+end

data/spec/nodes/empty/test_evaluate.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+class Predicate
+  describe Empty, "evaluate" do
+
+    let(:predicate){ Factory.empty(:x) }
+
+    subject{ predicate.evaluate(context) }
+
+    context "on an empty array" do
+      let(:context){ { x: [] } }
+
+      it{ expect(subject).to eq(true) }
+    end
+
+    context "on a non empty array" do
+      let(:context){ { x: [1, 2, 3] } }
+
+      it{ expect(subject).to eq(false) }
+    end
+
+    context "on a empty string" do
+      let(:context){ { x: "" } }
+
+      it{ expect(subject).to eq(true) }
+    end
+
+    context "on a non empty string" do
+      let(:context){ { x: "1233" } }
+
+      it{ expect(subject).to eq(false) }
+    end
+
+    context "on an object that does not respond to empty?" do
+      let(:context){ { x: 14567 } }
+
+      it{
+        expect{ subject }.to raise_error(TypeError, "Expected 14567 to respond to empty?")
+      }
+    end
+
+  end
+end

data/spec/nodes/has_size/test_evaluate.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+class Predicate
+  describe HasSize, "evaluate" do
+
+    let(:predicate){
+      Factory.has_size(:x, y)
+    }
+
+    subject{ predicate.evaluate(context) }
+
+    context 'against a Range' do
+      let(:y){ 1..10 }
+
+      context "on a match x" do
+        let(:context){ { x: "1234567" } }
+
+        it{ expect(subject).to eq(true) }
+      end
+
+      context "on a non matching x" do
+        let(:context){ { x: "1234567891011" } }
+
+        it{ expect(subject).to eq(false) }
+      end
+    end
+
+    context 'against an Integer' do
+      let(:y){ 10 }
+
+      context "on a match x" do
+        let(:context){ { x: "0123456789" } }
+
+        it{ expect(subject).to eq(true) }
+      end
+
+      context "on a non matching x" do
+        let(:context){ { x: "1234567891011" } }
+
+        it{ expect(subject).to eq(false) }
+      end
+    end
+
+  end
+end

data/spec/predicate/test_and_split.rb

@@ -83,5 +83,23 @@ class Predicate
       it{ should eq([ pred, p.tautology ]) }
     end
 
+    context "on intersect" do
+      let(:pred){ p.intersect(:x, [1, 2]) }
+
+      it{ should eq([ pred, p.tautology ]) }
+    end
+
+    context "on subset" do
+      let(:pred){ p.subset(:x, [1, 2]) }
+
+      it{ should eq([ pred, p.tautology ]) }
+    end
+
+    context "on superset" do
+      let(:pred){ p.superset(:x, [1, 2]) }
+
+      it{ should eq([ pred, p.tautology ]) }
+    end
+
   end
 end

data/spec/predicate/test_attr_split.rb

@@ -47,6 +47,24 @@ class Predicate
       it{ should eq({ x: pred }) }
     end
 
+    context "on intersect" do
+      let(:pred){ p.intersect(:x, [2]) }
+
+      it{ should eq({ x: pred }) }
+    end
+
+    context "on subset" do
+      let(:pred){ p.subset(:x, [2]) }
+
+      it{ should eq({ x: pred }) }
+    end
+
+    context "on superset" do
+      let(:pred){ p.superset(:x, [2]) }
+
+      it{ should eq({ x: pred }) }
+    end
+
     context "on match" do
       let(:pred){ p.match(:x, "London") }
 

data/spec/predicate/test_constant_variables.rb

@@ -37,14 +37,36 @@ class Predicate
     describe "on an intersect with one value" do
       let(:p){ Predicate.intersect(:x, [2]) }
 
-      # TODO: is that correct?
       it{ expect(subject).to eql([]) }
     end
 
     describe "on an intersect with a placeholder" do
       let(:p){ Predicate.intersect(:x, Predicate.placeholder) }
 
-      # TODO: is that correct?
+      it{ expect(subject).to eql([]) }
+    end
+
+    describe "on an subset with one value" do
+      let(:p){ Predicate.subset(:x, [2]) }
+
+      it{ expect(subject).to eql([]) }
+    end
+
+    describe "on an subset with a placeholder" do
+      let(:p){ Predicate.subset(:x, Predicate.placeholder) }
+
+      it{ expect(subject).to eql([]) }
+    end
+
+    describe "on an superset with one value" do
+      let(:p){ Predicate.superset(:x, [2]) }
+
+      it{ expect(subject).to eql([]) }
+    end
+
+    describe "on an superset with a placeholder" do
+      let(:p){ Predicate.superset(:x, Predicate.placeholder) }
+
       it{ expect(subject).to eql([]) }
     end
 

data/spec/predicate/test_constants.rb

@@ -119,6 +119,30 @@ class Predicate
       it{ should eq({}) }
     end
 
+    context "on subset" do
+      let(:pred){ p.subset(:x, [4,8]) }
+
+      it{ should eq({}) }
+    end
+
+    context "on subset with placeholder" do
+      let(:pred){ p.subset(:x, p.placeholder) }
+
+      it{ should eq({}) }
+    end
+
+    context "on superset" do
+      let(:pred){ p.superset(:x, [4,8]) }
+
+      it{ should eq({}) }
+    end
+
+    context "on superset with placeholder" do
+      let(:pred){ p.superset(:x, p.placeholder) }
+
+      it{ should eq({}) }
+    end
+
     context "on or (two eqs)" do
       let(:pred){ p.eq(:x, 2) | p.eq(:y, 4) }
 

data/spec/predicate/test_evaluate.rb

@@ -40,7 +40,7 @@ class Predicate
 
     context 'on a factored predicate' do
       let(:predicate){
-        Predicate.new(Factory.lte(:x => 2))
+        Predicate.lte(:x => 2)
       }
 
       describe "on x == 2" do
@@ -80,7 +80,7 @@ class Predicate
       end
     end
 
-    context 'on an intersect predicate' do
+    context 'on an intersect predicate, with array literal' do
       let(:predicate){
         Predicate.intersect(:x, [8,9])
       }
@@ -98,6 +98,168 @@ class Predicate
       end
     end
 
+    context 'on an intersect predicate, with two variables' do
+      let(:predicate){
+        Predicate.intersect(:x, :y)
+      }
+
+      describe "on x == [2]" do
+        let(:scope){ { :x => [2], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == [9,12]" do
+        let(:scope){ { :x => [9,12], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+    end
+
+    context 'on an subset predicate, with an array literal' do
+      let(:predicate){
+        Predicate.subset(:x, [8,9])
+      }
+
+      describe "on x == [2]" do
+        let(:scope){ { :x => [2] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == []" do
+        let(:scope){ { :x => [] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [9]" do
+        let(:scope){ { :x => [9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [8, 9]" do
+        let(:scope){ { :x => [8, 9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [8, 9, 10]" do
+        let(:scope){ { :x => [8, 9, 19] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+    end
+
+    context 'on an subset predicate, with two variables' do
+      let(:predicate){
+        Predicate.subset(:x, :y)
+      }
+
+      describe "on x == [2]" do
+        let(:scope){ { :x => [2], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == []" do
+        let(:scope){ { :x => [], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [9]" do
+        let(:scope){ { :x => [9], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [8, 9]" do
+        let(:scope){ { :x => [8, 9], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [8, 9, 10]" do
+        let(:scope){ { :x => [8, 9, 19], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+    end
+
+    context 'on an superset predicate, with an array literal' do
+      let(:predicate){
+        Predicate.superset(:x, [8,9])
+      }
+
+      describe "on x == [2]" do
+        let(:scope){ { :x => [2] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == []" do
+        let(:scope){ { :x => [] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == [9]" do
+        let(:scope){ { :x => [9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == [8, 9]" do
+        let(:scope){ { :x => [8, 9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [8, 9, 10]" do
+        let(:scope){ { :x => [8, 9, 19] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+    end
+
+    context 'on an superset predicate, with two variables' do
+      let(:predicate){
+        Predicate.superset(:x, :y)
+      }
+
+      describe "on x == [2]" do
+        let(:scope){ { :x => [2], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == []" do
+        let(:scope){ { :x => [], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == [9]" do
+        let(:scope){ { :x => [9], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == [8, 9]" do
+        let(:scope){ { :x => [8, 9], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [8, 9, 10]" do
+        let(:scope){ { :x => [8, 9, 19], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+    end
+
     context 'on a match against a string' do
       let(:predicate){
         Predicate.match(:x, "12")
@@ -228,12 +390,52 @@ class Predicate
 
     context 'has a call alias' do
       let(:predicate){
-        Predicate.new(Factory.gte(:x => 0))
+        Predicate.gte(:x => 0)
       }
 
       let(:scope){ { x: 2 } }
 
       it{ expect(predicate.call(scope)).to be(true) }
     end
+
+    context "on a var, build with a dotted string" do
+      let(:predicate){
+        Predicate.var("x.0.y")
+      }
+
+      let(:scope){ { x: [{ y: 2 }] } }
+
+      it{ expect(predicate.call(scope)).to eql(2) }
+    end
+
+    context "on a var, build with a . string" do
+      let(:predicate){
+        Predicate.var(".")
+      }
+
+      let(:scope){ { x: [{ y: 2 }] } }
+
+      it{ expect(predicate.call(scope)).to be(scope) }
+    end
+
+    context "on a var, build with an array for terms" do
+      let(:predicate){
+        Predicate.var([:x, 0, :y])
+      }
+
+      let(:scope){ { x: [{ y: 2 }] } }
+
+      it{ expect(predicate.call(scope)).to eql(2) }
+    end
+
+    context "on a var, build with an empty array" do
+      let(:predicate){
+        Predicate.var([])
+      }
+
+      let(:scope){ { x: [{ y: 2 }] } }
+
+      it{ expect(predicate.call(scope)).to be(scope) }
+    end
   end
 end

data/spec/predicate/test_free_variables.rb

@@ -9,6 +9,6 @@ class Predicate
 
       it{ should eq([:x]) }
     end
-    
+
   end
 end