predicate 2.3.0 → 2.5.0

data/spec/dsl/test_evaluate.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe 'Predicate in a curried form' do
+
+  context 'with a variable name' do
+    it 'supports tautology, contradiction' do
+      p = Predicate.currying(:x){ tautology }
+      expect(p).to eql(Predicate.tautology)
+
+      p = Predicate.currying(:x){ contradiction }
+      expect(p).to eql(Predicate.contradiction)
+    end
+
+    it 'support comparison operators' do
+      p = Predicate.currying(:x){
+        gt(0) & lt(12)
+      }
+      expect(p.evaluate(x: 0)).to be_falsy
+      expect(p.evaluate(x: 1)).to be_truthy
+      expect(p.evaluate(x: 11)).to be_truthy
+      expect(p.evaluate(x: 12)).to be_falsy
+    end
+
+    it 'supports between shortcut' do
+      p = Predicate.currying(:x){
+        between(1, 11)
+      }
+      expect(p.evaluate(x: 0)).to be_falsy
+      expect(p.evaluate(x: 1)).to be_truthy
+      expect(p.evaluate(x: 11)).to be_truthy
+      expect(p.evaluate(x: 12)).to be_falsy
+    end
+
+    it 'supports match' do
+      p = Predicate.currying(:x){
+        match(/a/)
+      }
+      expect(p.evaluate(x: "zzz")).to be_falsy
+      expect(p.evaluate(x: "abc")).to be_truthy
+    end
+  end
+
+  context 'without a variable name' do
+    it 'applies to the object passed' do
+      p = Predicate.currying{
+        gt(0) & lt(12)
+      }
+      expect(p.evaluate(0)).to be_falsy
+      expect(p.evaluate(1)).to be_truthy
+      expect(p.evaluate(11)).to be_truthy
+      expect(p.evaluate(12)).to be_falsy
+    end
+  end
+
+  context 'on shortcuts' do
+    it 'applies to the object passed' do
+      p = Predicate.currying{
+        min_size(5)
+      }
+      expect(p.evaluate("1")).to be_falsy
+      expect(p.evaluate("013456789")).to be_truthy
+    end
+  end
+
+end

data/spec/dsl/test_respond_to_missing.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+class Predicate
+  describe Dsl do
+    subject{
+      Predicate::Dsl.new(:x)
+    }
+
+    it 'respond to negated forms' do
+      [
+        :notSize,
+        :notEq
+      ].each do |m|
+        expect(subject.send(:respond_to_missing?, m)).to eql(true)
+      end
+    end
+
+    it 'respond to camelCased forms' do
+      [
+        :hasSize
+      ].each do |m|
+        expect(subject.send(:respond_to_missing?, m)).to eql(true)
+      end
+    end
+
+    it 'respond false otherwise' do
+      [
+        :nosuchone,
+        :notsuchone
+      ].each do |m|
+        expect(subject.send(:respond_to_missing?, m)).to eql(false)
+      end
+    end
+  end
+end

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_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/eq/test_and.rb

@@ -26,5 +26,11 @@ class Predicate
       it{ should be_a(And) }
     end
 
+    context 'with an IN having a placeholder' do
+      let(:right){ Factory.in(:x, Factory.placeholder) }
+
+      it{ should be_a(And) }
+    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/nodes/qualified_identifier/test_and_split.rb

@@ -8,7 +8,7 @@ class Predicate
     subject{ predicate.and_split(list) }
 
     context 'when included' do
-      let(:list){ [:id, :name] }
+      let(:list){ [:"t.id", :name] }
 
       it{ should eq([predicate, tautology]) }
     end

data/spec/nodes/qualified_identifier/test_free_variables.rb

@@ -6,7 +6,7 @@ class Predicate
 
     subject{ expr.free_variables }
 
-    it{ should eq([:id]) }
+    it{ should eq([:"t.id"]) }
 
   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") }