predicator 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5fb315c811b1933aee5a9e373019e46be91ea240
-  data.tar.gz: f89434cbd64dcfb65ec62452839386175f530147
+  metadata.gz: b778c45c3885f3fd113cc8b71b20980774d3a694
+  data.tar.gz: be582dd047eb0d20e7380b1d7c5edd83d2d589c1
 SHA512:
-  metadata.gz: 3e6698af9ad44e8a5c98bfdd7ee6d8d8b504129e37c9357c9845865334cfcedc5abfb577d198ca04de6ffc92d1dd5795f1950703c86e19ad625209f6cffe03a2
-  data.tar.gz: fcbf8a75dc46c7040898fd598155b905907fc10ff3249e42c5e571ea47616d082458b6df02a4a2aa8046e2dda414a0bada7ed344b70894ee41c2f43c1cd47fcc
+  metadata.gz: 25f7894b6db4c564eb15d0c2ef2fb4fb785ca5a030abf930da4e8a4eb6b3d3b591e70298cb256373ca7e52e4b62290b40858e66f0c37924296ce8a2f628146bc
+  data.tar.gz: bbb3843e12ec3d86f7ec27279ecf7eae7a8962fb47f88b59cd9521095eb89f26dccee8cbcc1cf62190139ea88f9eaf8c73e2f6d614dfe14b6eb2d612219cd7af

data/.rubocop.yml

@@ -0,0 +1,46 @@
+AllCops:
+  TargetRubyVersion: 2.3
+  DisabledByDefault: true
+  Exclude:
+    - "lib/predicator/parser.rb" #generated file
+    - "lib/predicator/lexer.rex.rb" #generated file
+
+Bundler/DuplicatedGem:
+  Enabled: true
+Lint:
+  Enabled: true
+Performance:
+  Enabled: true
+Security:
+  Enabled: true
+
+# Single quotes being faster is hardly measurable and only affects parse time.
+# Enforcing double quotes reduces the times where you need to change them
+# when introducing an interpolation. Use single quotes only if their semantics
+# are needed.
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+# Seattle style
+Style/MethodDefParentheses:
+  EnforcedStyle: require_no_parentheses
+
+# Allow regex argument in Seattle style
+Lint/AmbiguousRegexpLiteral:
+  Enabled: false
+
+# Allow block argument in Seattle style
+Lint/AmbiguousOperator:
+  Enabled: false
+
+# No long classes
+Style/ClassLength:
+  Enabled: true
+  Exclude:
+    - "test/**/*.rb"
+    - "lib/predicator/visitors/instructions.rb"
+    - "lib/predicator/evaluator.rb"
+
+Lint/HandleExceptions:
+  Exclude:
+    - lib/tasks/**/*.rake

data/HISTORY.md

@@ -1,3 +1,11 @@
+### 1.2.0 / 2018-09-13
+
+* Adds type casting to comparisons
+* Adds date type and predicates
+* Adds "from now" and "ago" relative dates
+* Adds "present" and "blank" predicates
+* Adds "starts with" and "ends with" string comparisons
+
 ### 1.1.0 / 2017-12-06
 
 * Rescues errors when comparing invalid types

data/README.md

@@ -1,24 +1,47 @@
 [![Gem Version](https://badge.fury.io/rb/predicator.svg)](http://badge.fury.io/rb/predicator)
 [![Build Status](https://travis-ci.org/predicator/predicator.svg?branch=master)](https://travis-ci.org/predicator/predicator)
-[![Dependency Status](https://img.shields.io/gemnasium/johnnyt/predicator.svg)](https://gemnasium.com/johnnyt/predicator)
 [![Coverage Status](https://coveralls.io/repos/github/predicator/predicator/badge.svg?branch=master)](https://coveralls.io/github/predicator/predicator?branch=master)
 
 # Predicator
 
-Predicator is a predicate engine.
+Predicator is a safe (does not eval code), admin or business user facing predicate engine. It turns a string predicate like `"score > 600 or (score > 580 and monthly_income > 9000)"` along with a supplied context into a `true` or `false`. This predicate can be stored as an attribute of a model (ex: an Offer model could store a predicate indicating if it is available to a customer).
 
 ## Usage
 
-Example usage:
+Simple usage:
 
 ```ruby
 require "predicator"
 
-Predicator.evaluate "age > 21" # false
+Predicator.evaluate "score > 600 or (score > 580 and income > 9000)", score: 590 # false
 
-Predicator.evaluate "age > 21", age: 10 # false
+Predicator.evaluate "score > 600 or (score > 580 and income > 9000)", score: 590, income: 9500 # true
+```
+
+Example usage with a model:
 
-Predicator.evaluate "age > 21", age: 50 # true
+```ruby
+class Customer
+  ...
+  def to_hash
+    {
+      ...
+      score: score,
+      income: income,
+      ...
+    }
+  end
+end
+
+class Offer
+  attr_accessor :available_predicate
+  
+  ...
+  
+  def available_to? customer
+    Predicator.evaluate available_predicate, customer.to_hash
+  end
+end
 ```
 
 ## Installation
@@ -40,10 +63,9 @@ Or install it yourself as:
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.
-Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Then, run `rake test` (or just `rake`) to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`.
-To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/lib/predicator/ast.rb

@@ -21,10 +21,6 @@ module Predicator
         Visitors::Instructions.new.accept self
       end
 
-      def to_predicate
-        Visitors::Predicate.new.accept self
-      end
-
       def to_s
         Visitors::String.new.accept self
       end
@@ -51,7 +47,7 @@ module Predicator
       def variable?; true; end
     end
 
-    %w[ True False Integer String ].each do |t|
+    %w[ True False Integer String Date Duration Blank Present ].each do |t|
       class_eval <<-eoruby, __FILE__, __LINE__ + 1
         class #{t} < Literal;
           def type; :#{t.upcase}; end
@@ -63,8 +59,12 @@ module Predicator
       def children; [left] end
     end
 
-    class Array < Unary
-      def type; :ARRAY; end
+    class IntegerArray < Unary
+      def type; :INTARRAY; end
+    end
+
+    class StringArray < Unary
+      def type; :STRARRAY; end
     end
 
     class Not < Unary
@@ -75,6 +75,14 @@ module Predicator
       def type; :GROUP; end
     end
 
+    class DateFromNow < Unary
+      def type; :DATEFROMNOW; end
+    end
+
+    class DateAgo < Unary
+      def type; :DATEAGO; end
+    end
+
     class Binary < Node
       attr_accessor :right
 
@@ -86,24 +94,64 @@ module Predicator
       def children; [left, right] end
     end
 
-    class Equal < Binary
-      def type; :EQ; end
+    class IntegerEqual < Binary
+      def type; :INTEQ; end
+    end
+
+    class StringEqual < Binary
+      def type; :STREQ; end
+    end
+
+    class DateEqual < Binary
+      def type; :DATEQ; end
+    end
+
+    class IntegerGreaterThan < Binary
+      def type; :INTGT; end
+    end
+
+    class StringGreaterThan < Binary
+      def type; :STRGT; end
+    end
+
+    class DateGreaterThan < Binary
+      def type; :DATGT; end
+    end
+
+    class IntegerLessThan < Binary
+      def type; :INTLT; end
+    end
+
+    class StringLessThan < Binary
+      def type; :STRLT; end
     end
 
-    class GreaterThan < Binary
-      def type; :GT; end
+    class DateLessThan < Binary
+      def type; :DATLT; end
     end
 
-    class LessThan < Binary
-      def type; :LT; end
+    class IntegerIn < Binary
+      def type; :INTIN; end
     end
 
-    class In < Binary
-      def type; :IN; end
+    class StringIn < Binary
+      def type; :STRIN; end
     end
 
-    class NotIn < Binary
-      def type; :NOTIN; end
+    class IntegerNotIn < Binary
+      def type; :INTNOTIN; end
+    end
+
+    class StringNotIn < Binary
+      def type; :STRNOTIN; end
+    end
+
+    class StringStartsWith < Binary
+      def type; :STRSTARTSWITH; end
+    end
+
+    class StringEndsWith < Binary
+      def type; :STRENDSWITH; end
     end
 
     class And < Binary
@@ -126,8 +174,12 @@ module Predicator
       def children; [left, middle, right] end
     end
 
-    class Between < Ternary
-      def type; :BETWEEN; end
+    class IntegerBetween < Ternary
+      def type; :INTBETWEEN; end
+    end
+
+    class DateBetween < Ternary
+      def type; :DATBETWEEN; end
     end
 
     class BooleanVariable < Unary

data/lib/predicator/evaluator.rb

@@ -1,3 +1,5 @@
+require "date"
+
 module Predicator
   class Evaluator
     attr_reader :instructions, :stack, :context
@@ -24,18 +26,19 @@ module Predicator
 
     def process instruction
       case instruction.first
-      when "not"
-        stack.push !stack.pop
-      when "jfalse"
-        jump_if_false instruction.last
-      when "jtrue"
-        jump_if_true instruction.last
-      when "lit", "array"
-        stack.push instruction.last
-      when "load"
-        stack.push context[instruction.last]
-      when "to_bool"
-        stack.push !!stack.pop
+      when "not"             then stack.push !stack.pop
+      when "jfalse"          then jump_if_false instruction.last
+      when "jtrue"           then jump_if_true instruction.last
+      when "lit", "array"    then stack.push instruction.last
+      when "load"            then stack.push context[instruction.last]
+      when "to_bool"         then stack.push !!stack.pop
+      when "to_int"          then stack.push to_int(stack.pop)
+      when "to_str"          then stack.push to_str(stack.pop)
+      when "to_date"         then stack.push to_date(stack.pop)
+      when "date_ago"        then stack.push date_ago(stack.pop)
+      when "date_from_now"   then stack.push date_from_now(stack.pop)
+      when "blank"           then stack.push blank?(stack.pop)
+      when "present"         then stack.push !blank?(stack.pop)
       when "compare"
         if instruction.last == "BETWEEN"
           compare_BETWEEN
@@ -45,6 +48,36 @@ module Predicator
       end
     end
 
+    def to_int val
+      if val.nil? || (val.is_a?(String) && val.empty?)
+        nil
+      else
+        val.to_i
+      end
+    end
+
+    def to_str val
+      val.nil? ? nil : val.to_s
+    end
+
+    def to_date val
+      val.nil? ? nil : Date.parse(val)
+    end
+
+    def date_ago seconds
+      past_time = Time.now - seconds
+      to_date past_time.strftime "%Y-%m-%d"
+    end
+
+    def date_from_now seconds
+      future_time = Time.now + seconds
+      to_date future_time.strftime "%Y-%m-%d"
+    end
+
+    def blank? val
+      val.respond_to?(:empty?) ? !!val.empty? : !val
+    end
+
     def jump_if_false offset
       if stack[-1] == false
         adjusted_offset = offset - 1
@@ -71,7 +104,7 @@ module Predicator
       else
         stack.push send("compare_#{comparison}", left, right)
       end
-    rescue
+    rescue StandardError
       stack.push false
     end
 
@@ -95,6 +128,14 @@ module Predicator
       !right.include? left
     end
 
+    def compare_STARTSWITH left, right
+      left.start_with? right
+    end
+
+    def compare_ENDSWITH left, right
+      left.end_with? right
+    end
+
     def compare_BETWEEN
       max = stack.pop
       min = stack.pop
@@ -105,7 +146,7 @@ module Predicator
         result = val.between? min, max
         stack.push result
       end
-    rescue
+    rescue StandardError
       stack.push false
     end
   end

data/lib/predicator/lexer.rex

@@ -21,6 +21,15 @@ macro
   EQ          /=/
   GT          />/
   LT          /</
+  ENDSWITH    /ends with/
+  STARTSWITH  /starts with/
+  BEGINSWITH  /begins with/
+  BLANK       /is blank/
+  PRESENT     /is present/
+  AGO         /ago/
+  FROMNOW     /from now/
+  DATE        /\d{4}[-|\/]\d{2}[-|\/]\d{2}/i
+  DURATION    /\d+d/
   INTEGER     /[+-]?\d(_?\d)*\b/
   STRING      /(["'])(?:\\?.)*?\1/
   IDENTIFIER  /[a-z][A-Za-z0-9_]*\b/
@@ -43,6 +52,15 @@ rule
   /#{EQ}/          { [:EQ, text] }
   /#{GT}/          { [:GT, text] }
   /#{LT}/          { [:LT, text] }
+  /#{AGO}/         { [:AGO, text] }
+  /#{FROMNOW}/     { [:FROMNOW, text] }
+  /#{ENDSWITH}/    { [:ENDSWITH, text] }
+  /#{STARTSWITH}/  { [:STARTSWITH, text] }
+  /#{BEGINSWITH}/  { [:STARTSWITH, text] }
+  /#{BLANK}/       { [:BLANK, text] }
+  /#{PRESENT}/     { [:PRESENT, text] }
+  /#{DATE}/        { [:DATE, text] }
+  /#{DURATION}/    { [:DURATION, text] }
   /#{INTEGER}/     { [:INTEGER, text] }
   /#{STRING}/      { [:STRING, text[1...-1]] }
   /#{IDENTIFIER}/  { [:IDENTIFIER, text] }

data/lib/predicator/lexer.rex.rb

@@ -26,6 +26,15 @@ class Predicator::Lexer
   EQ         = /=/
   GT         = />/
   LT         = /</
+  ENDSWITH   = /ends with/
+  STARTSWITH = /starts with/
+  BEGINSWITH = /begins with/
+  BLANK      = /is blank/
+  PRESENT    = /is present/
+  AGO        = /ago/
+  FROMNOW    = /from now/
+  DATE       = /\d{4}[-|\/]\d{2}[-|\/]\d{2}/i
+  DURATION   = /\d+d/
   INTEGER    = /[+-]?\d(_?\d)*\b/
   STRING     = /(["'])(?:\\?.)*?\1/
   IDENTIFIER = /[a-z][A-Za-z0-9_]*\b/
@@ -131,6 +140,24 @@ class Predicator::Lexer
             action { [:GT, text] }
           when text = ss.scan(/#{LT}/) then
             action { [:LT, text] }
+          when text = ss.scan(/#{AGO}/) then
+            action { [:AGO, text] }
+          when text = ss.scan(/#{FROMNOW}/) then
+            action { [:FROMNOW, text] }
+          when text = ss.scan(/#{ENDSWITH}/) then
+            action { [:ENDSWITH, text] }
+          when text = ss.scan(/#{STARTSWITH}/) then
+            action { [:STARTSWITH, text] }
+          when text = ss.scan(/#{BEGINSWITH}/) then
+            action { [:STARTSWITH, text] }
+          when text = ss.scan(/#{BLANK}/) then
+            action { [:BLANK, text] }
+          when text = ss.scan(/#{PRESENT}/) then
+            action { [:PRESENT, text] }
+          when text = ss.scan(/#{DATE}/) then
+            action { [:DATE, text] }
+          when text = ss.scan(/#{DURATION}/) then
+            action { [:DURATION, text] }
           when text = ss.scan(/#{INTEGER}/) then
             action { [:INTEGER, text] }
           when text = ss.scan(/#{STRING}/) then