predicate 2.4.0 → 2.5.0

data/lib/predicate/processors/to_s.rb

@@ -57,6 +57,14 @@ class Predicate
       "#{apply(sexpr.identifier)} INTERSECTS #{to_literal(sexpr.values)}"
     end
 
+    def on_subset(sexpr)
+      "#{apply(sexpr.identifier)} IS SUBSET OF #{to_literal(sexpr.values)}"
+    end
+
+    def on_superset(sexpr)
+      "#{apply(sexpr.identifier)} IS SUPERSET OF #{to_literal(sexpr.values)}"
+    end
+
     def on_literal(sexpr)
       to_literal(sexpr.last)
     end
@@ -69,16 +77,36 @@ class Predicate
       "#{apply(sexpr.left)} =~ #{apply(sexpr.right)}"
     end
 
+    def on_empty(sexpr)
+      "EMPTY(#{commalist(sexpr.body)})"
+    end
+
+    def on_size(sexpr)
+      "SIZE(#{commalist(sexpr.body)})"
+    end
+
+    #jeny(predicate) def on_${op_name}(sexpr)
+    #jeny(predicate)   "${OP_NAME}(#{commalist(sexpr.body)})"
+    #jeny(predicate) end
+
     def on_native(sexpr)
       sexpr.last.inspect
     end
 
+    def on_var(sexpr)
+      "#{sexpr.semantics}(#{sexpr.formaldef})"
+    end
+
     def on_missing(sexpr)
       raise "Unimplemented: #{sexpr.first}"
     end
 
   protected
 
+    def commalist(of)
+      of.map{|o| apply(o) }.join(',')
+    end
+
     def to_literal(x)
       case x
       when Placeholder then "$#{x.object_id}"

data/lib/predicate/processors/unqualifier.rb

@@ -11,6 +11,10 @@ class Predicate
       raise NotSupportedError
     end
 
+    def on_var(sexpr)
+      raise NotSupportedError
+    end
+
     alias :on_missing :copy_and_apply
 
   end

data/lib/predicate/sequel/to_sequel.rb

@@ -112,8 +112,11 @@ class Predicate
       def on_unsupported(sexpr)
         raise NotSupportedError, "Unsupported predicate #{sexpr}"
       end
+      alias :on_var :on_unsupported
       alias :on_native :on_unsupported
       alias :on_intersect :on_unsupported
+      alias :on_subset :on_unsupported
+      alias :on_superset :on_unsupported
     end
     include Methods
   end # class ToSequel

data/lib/predicate/sugar.rb

@@ -0,0 +1,47 @@
+class Predicate
+  module Sugar
+
+    [ :eq, :neq, :lt, :lte, :gt, :gte ].each do |m|
+      define_method(m) do |left, right=nil|
+        return comp(m, left) if TupleLike===left && right.nil?
+        super(left, right)
+      end
+    end
+
+    def between(middle, lower_bound, upper_bound)
+      _factor_predicate [:and, [:gte, sexpr(middle), sexpr(lower_bound)],
+                               [:lte, sexpr(middle), sexpr(upper_bound)]]
+    end
+
+    def match(left, right, options = nil)
+      super(left, right, options)
+    end
+
+    def min_size(left, right)
+      unless right.is_a?(Integer)
+        raise ArgumentError, "Integer expected, got #{right}"
+      end
+      if RUBY_VERSION >= "2.6"
+        has_size(left, Range.new(right,nil))
+      else
+        has_size(left, Range.new(right,(2**32-1)))
+      end
+    end
+
+    def max_size(left, right)
+      unless right.is_a?(Integer)
+        raise ArgumentError, "Integer expected, got #{right}"
+      end
+      has_size(left, 0..right)
+    end
+
+    def is_null(operand)
+      eq(operand, nil)
+    end
+
+    #jeny(sugar) def ${op_name}(*args)
+    #jeny(sugar)   TODO
+    #jeny(sugar) end
+
+  end # module Sugar
+end # class Predicate

data/lib/predicate/version.rb

@@ -1,7 +1,7 @@
 class Predicate
   module Version
     MAJOR = 2
-    MINOR = 4
+    MINOR = 5
     TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"

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