predicate 2.3.3 → 2.7.0

data/spec/dsl/test_dsl.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+class Predicate
+  describe Dsl do
+    subject{
+      Predicate::Dsl.new(:x).instance_eval(&bl)
+    }
+
+    context 'when used on a comparison op' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ eq(6) }
+        }
+
+        it { expect(subject).to eq(Predicate.eq(:x, 6))}
+      end
+
+      context 'non curried' do
+        let(:bl){
+          Proc.new{ eq(:y, 6) }
+        }
+
+        it { expect(subject).to eq(Predicate.eq(:y, 6))}
+      end
+    end
+
+    context 'when used on between' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ between(2, 6) }
+        }
+
+        it { expect(subject).to eq(Predicate.gte(:x, 2) & Predicate.lte(:x, 6))}
+      end
+
+      context 'non curried' do
+        let(:bl){
+          Proc.new{ between(:y, 2, 6) }
+        }
+
+        it { expect(subject).to eq(Predicate.gte(:y, 2) & Predicate.lte(:y, 6))}
+      end
+    end
+
+    context 'when used on a sugar op' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ min_size(6) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:x, Range.new(6, nil)))}
+      end
+
+      context 'curried' do
+        let(:bl){
+          Proc.new{ min_size(:y, 6) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:y, Range.new(6, nil)))}
+      end
+    end if RUBY_VERSION >= "2.6"
+
+    context 'when used on match' do
+      context 'curryied' do
+        let(:bl){
+          Proc.new{ match(/a-z/) }
+        }
+
+        it { expect(subject).to eq(Predicate.match(:x, /a-z/, {}))}
+      end
+
+      context 'curryied with options' do
+        let(:bl){
+          Proc.new{ match(/a-z/, {case_sensitive: false}) }
+        }
+
+        it { expect(subject).to eq(Predicate.match(:x, /a-z/, {case_sensitive: false}))}
+      end
+
+      context 'non curried' do
+        let(:bl){
+          Proc.new{ match(:y, /a-z/) }
+        }
+
+        it { expect(subject).to eq(Predicate.match(:y, /a-z/, {}))}
+      end
+
+      context 'non curried with options' do
+        let(:bl){
+          Proc.new{ match(:y, /a-z/, {case_sensitive: false}) }
+        }
+
+        it { expect(subject).to eq(Predicate.match(:y, /a-z/, {case_sensitive: false}))}
+      end
+    end
+
+    context 'when used on size' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ size(1..10) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:x, 1..10))}
+      end
+
+      context 'curried with Integer' do
+        let(:bl){
+          Proc.new{ size(10) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:x, 10))}
+      end
+
+      context 'not curried' do
+        let(:bl){
+          Proc.new{ size(:y, 1..10) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:y, 1..10))}
+      end
+
+      context 'not curried with Integer' do
+        let(:bl){
+          Proc.new{ size(:y, 10) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:y, 10))}
+      end
+    end
+
+    context 'when used with some camelCase' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ hasSize(1..10) }
+        }
+
+        it { expect(subject).to eq(Predicate.has_size(:x, 1..10))}
+      end
+    end
+
+    context 'when used with full text versions and their negation' do
+      context 'less_than' do
+        let(:bl){
+          Proc.new{ less_than(:x, 1) }
+        }
+
+        it { expect(subject).to eq(Predicate.lt(:x, 1))}
+      end
+
+      context 'lessThan' do
+        let(:bl){
+          Proc.new{ lessThan(:x, 1) }
+        }
+
+        it { expect(subject).to eq(Predicate.lt(:x, 1))}
+      end
+
+      context 'notLessThan' do
+        let(:bl){
+          Proc.new{ notLessThan(:x, 1) }
+        }
+
+        it { expect(subject).to eq(!Predicate.lt(:x, 1))}
+      end
+    end
+
+    context 'when used with a negated form' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ notSize(1..10) }
+        }
+
+        it { expect(subject).to eq(!Predicate.has_size(:x, 1..10))}
+      end
+    end
+
+    context 'when used on null' do
+      context 'curried' do
+        let(:bl){
+          Proc.new{ null() }
+        }
+
+        it { expect(subject).to eq(Predicate.eq(:x, nil))}
+      end
+
+      context 'negated' do
+        let(:bl){
+          Proc.new{ notNull() }
+        }
+
+        it { expect(subject).to eq(Predicate.neq(:x, nil))}
+      end
+
+      context 'not curried' do
+        let(:bl){
+          Proc.new{ null(:y) }
+        }
+
+        it { expect(subject).to eq(Predicate.eq(:y, nil))}
+      end
+    end
+
+  end
+end

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_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/postgres/test_factory.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+class Predicate
+  describe 'pg_factory' do
+
+    subject{
+      predicate
+    }
+
+    let(:predicate) {
+      Predicate.tautology
+    }
+
+    it_should_behave_like "a predicate"
+
+    context 'pg_array_literal' do
+      let(:predicate) do
+        Predicate.pg_array_literal([12])
+      end
+    end
+
+    context 'pg_array_empty' do
+      let(:predicate) do
+        Predicate.pg_array_empty(:x)
+      end
+    end
+
+    context 'pg_array_overlaps' do
+      let(:predicate) do
+        Predicate.pg_array_overlaps(:x, [1,2,3])
+      end
+
+      it 'has expected free variables' do
+        expect(subject.free_variables).to eql([:x])
+      end
+    end
+
+    context 'pg_array_overlaps (2)' do
+      let(:predicate) do
+        Predicate.pg_array_overlaps(:x, :y)
+      end
+
+      it 'has expected free variables' do
+        expect(subject.free_variables).to eql([:x, :y])
+      end
+    end
+  end
+end