predicator 0.3.0 → 1.2.1

data/lib/predicator/evaluator.rb

@@ -0,0 +1,153 @@
+require "date"
+
+module Predicator
+  class Evaluator
+    attr_reader :instructions, :stack, :context
+
+    def initialize instructions, context_data={}
+      @instructions = instructions
+      @context = context_for context_data
+      @stack = []
+      @ip = 0
+    end
+
+    def context_for context_data
+      return context_data unless context_data.kind_of? Hash
+      Context.new context_data
+    end
+
+    def result
+      while @ip < instructions.length
+        process @instructions[@ip]
+        @ip += 1
+      end
+      stack.pop
+    end
+
+    def process instruction
+      case instruction.first
+      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
+        else
+          compare instruction.last
+        end
+      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
+        @ip += adjusted_offset
+      else
+        stack.pop
+      end
+    end
+
+    def jump_if_true offset
+      if stack[-1] == true
+        adjusted_offset = offset - 1
+        @ip += adjusted_offset
+      else
+        stack.pop
+      end
+    end
+
+    def compare comparison
+      right = stack.pop
+      left = stack.pop
+      if left.nil? || right.nil?
+        stack.push false
+      else
+        stack.push send("compare_#{comparison}", left, right)
+      end
+    rescue StandardError
+      stack.push false
+    end
+
+    def compare_EQ left, right
+      left == right
+    end
+
+    def compare_GT left, right
+      left > right
+    end
+
+    def compare_LT left, right
+      left < right
+    end
+
+    def compare_IN left, right
+      right.include? left
+    end
+
+    def compare_NOTIN left, right
+      !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
+      val = stack.pop
+      if max.nil? || min.nil? || val.nil?
+        stack.push false
+      else
+        result = val.between? min, max
+        stack.push result
+      end
+    rescue StandardError
+      stack.push false
+    end
+  end
+end

data/lib/predicator/lexer.rex

@@ -0,0 +1,69 @@
+class Predicator::Lexer
+options
+  lineno
+  column
+macro
+  SPACE       /[ \t\r\n]/
+  LPAREN      /\(/
+  RPAREN      /\)/
+  LBRACKET    /\[/
+  RBRACKET    /\]/
+  TRUE        /true\b/
+  FALSE       /false\b/
+  BETWEEN     /between\b/
+  IN          /in\b/
+  BANG        /!/
+  NOT         /not\b/
+  DOT         /\./
+  COMMA       /,/
+  AND         /and\b/
+  OR          /or\b/
+  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/
+rule
+  /#{SPACE}/       # ignore space
+  /#{LPAREN}/      { [:LPAREN, text] }
+  /#{RPAREN}/      { [:RPAREN, text] }
+  /#{LBRACKET}/    { [:LBRACKET, text] }
+  /#{RBRACKET}/    { [:RBRACKET, text] }
+  /#{TRUE}/        { [:TRUE, text] }
+  /#{FALSE}/       { [:FALSE, text] }
+  /#{BETWEEN}/     { [:BETWEEN, text] }
+  /#{IN}/          { [:IN, text] }
+  /#{BANG}/        { [:BANG, text] }
+  /#{NOT}/         { [:NOT, text] }
+  /#{DOT}/         { [:DOT, text] }
+  /#{COMMA}/       { [:COMMA, text] }
+  /#{AND}/         { [:AND, text] }
+  /#{OR}/          { [:OR, text] }
+  /#{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] }
+inner
+  def do_parse; end
+end

data/lib/predicator/lexer.rex.rb

@@ -0,0 +1,187 @@
+# encoding: UTF-8
+#--
+# This file is automatically generated. Do not modify it.
+# Generated by: oedipus_lex version 2.5.0.
+# Source: lib/predicator/lexer.rex
+#++
+
+class Predicator::Lexer
+  require 'strscan'
+
+  SPACE      = /[ \t\r\n]/
+  LPAREN     = /\(/
+  RPAREN     = /\)/
+  LBRACKET   = /\[/
+  RBRACKET   = /\]/
+  TRUE       = /true\b/
+  FALSE      = /false\b/
+  BETWEEN    = /between\b/
+  IN         = /in\b/
+  BANG       = /!/
+  NOT        = /not\b/
+  DOT        = /\./
+  COMMA      = /,/
+  AND        = /and\b/
+  OR         = /or\b/
+  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/
+
+  class LexerError < StandardError ; end
+  class ScanError < LexerError ; end
+
+  attr_accessor :lineno
+  attr_accessor :filename
+  attr_accessor :ss
+  attr_accessor :state
+
+  alias :match :ss
+
+  def matches
+    m = (1..9).map { |i| ss[i] }
+    m.pop until m[-1] or m.empty?
+    m
+  end
+
+  def action
+    yield
+  end
+
+  attr_accessor :old_pos
+
+  def column
+    idx = ss.string.rindex("\n", old_pos) || -1
+    old_pos - idx - 1
+  end
+
+  def scanner_class
+    StringScanner
+  end unless instance_methods(false).map(&:to_s).include?("scanner_class")
+
+  def parse str
+    self.ss     = scanner_class.new str
+    self.lineno = 1
+    self.state  ||= nil
+
+    do_parse
+  end
+
+  def parse_file path
+    self.filename = path
+    open path do |f|
+      parse f.read
+    end
+  end
+
+  def location
+    [
+      (filename || "<input>"),
+      lineno,
+      column,
+    ].compact.join(":")
+  end
+
+  def next_token
+
+    token = nil
+
+    until ss.eos? or token do
+      self.lineno += 1 if ss.peek(1) == "\n"
+      self.old_pos = ss.pos
+      token =
+        case state
+        when nil then
+          case
+          when ss.skip(/#{SPACE}/) then
+            # do nothing
+          when text = ss.scan(/#{LPAREN}/) then
+            action { [:LPAREN, text] }
+          when text = ss.scan(/#{RPAREN}/) then
+            action { [:RPAREN, text] }
+          when text = ss.scan(/#{LBRACKET}/) then
+            action { [:LBRACKET, text] }
+          when text = ss.scan(/#{RBRACKET}/) then
+            action { [:RBRACKET, text] }
+          when text = ss.scan(/#{TRUE}/) then
+            action { [:TRUE, text] }
+          when text = ss.scan(/#{FALSE}/) then
+            action { [:FALSE, text] }
+          when text = ss.scan(/#{BETWEEN}/) then
+            action { [:BETWEEN, text] }
+          when text = ss.scan(/#{IN}/) then
+            action { [:IN, text] }
+          when text = ss.scan(/#{BANG}/) then
+            action { [:BANG, text] }
+          when text = ss.scan(/#{NOT}/) then
+            action { [:NOT, text] }
+          when text = ss.scan(/#{DOT}/) then
+            action { [:DOT, text] }
+          when text = ss.scan(/#{COMMA}/) then
+            action { [:COMMA, text] }
+          when text = ss.scan(/#{AND}/) then
+            action { [:AND, text] }
+          when text = ss.scan(/#{OR}/) then
+            action { [:OR, text] }
+          when text = ss.scan(/#{EQ}/) then
+            action { [:EQ, text] }
+          when text = ss.scan(/#{GT}/) then
+            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
+            action { [:STRING, text[1...-1]] }
+          when text = ss.scan(/#{IDENTIFIER}/) then
+            action { [:IDENTIFIER, text] }
+          else
+            text = ss.string[ss.pos .. -1]
+            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
+          end
+        else
+          raise ScanError, "undefined state at #{location}: '#{state}'"
+        end # token = case state
+
+      next unless token # allow functions to trigger redo w/ nil
+    end # while
+
+    raise LexerError, "bad lexical result at #{location}: #{token.inspect}" unless
+      token.nil? || (Array === token && token.size >= 2)
+
+    # auto-switch state
+    self.state = token.last if token && token.first == :state
+
+    token
+  end # def next_token
+    def do_parse; end
+end # class

data/lib/predicator/parser.rb

@@ -1,41 +1,442 @@
-require "date"
-
-require "predicator/generated_parser"
-require "predicator/lexer"
-require "predicator/variable"
-
-require "predicator/predicates/relation"
-require "predicator/predicates/equal"
-require "predicator/predicates/not_equal"
-require "predicator/predicates/greater_than"
-require "predicator/predicates/less_than"
-require "predicator/predicates/greater_than_or_equal"
-require "predicator/predicates/less_than_or_equal"
-require "predicator/predicates/between"
-require "predicator/predicates/true"
-require "predicator/predicates/false"
-require "predicator/predicates/and"
-require "predicator/predicates/or"
-require "predicator/predicates/not"
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.14
+# from Racc grammer file "".
+#
 
+require 'racc/parser.rb'
+
+require "predicator/lexer.rex"
+require "predicator/visitors"
+require "predicator/ast"
 module Predicator
-  class ParseError < StandardError; end
+  class Parser < Racc::Parser
 
-  class Parser < GeneratedParser
-    def next_token
-      @lexer.next_token
+    def initialize
+      @lexer = Lexer.new
     end
 
     def parse string
-      @lexer = Lexer.new string
+      @lexer.parse string
       do_parse
     end
 
+    def next_token
+      @lexer.next_token
+    end
+
     def on_error type, val, values
       super
-    rescue Racc::ParseError => e
+    rescue Racc::ParseError
       trace = values.each_with_index.map{|l, i| "#{' ' * i}#{l}"}
       raise ParseError, "\nparse error on value #{val.inspect}\n#{trace.join("\n")}"
     end
-  end
+
+##### State transition tables begin ###
+
+racc_action_table = [
+     6,     7,    10,     6,     7,    10,     9,    15,    31,     9,
+     6,     7,    10,     6,     7,    10,     9,    16,    17,     9,
+    16,    17,    14,    16,    17,    14,    52,     6,     7,    10,
+    25,    28,    14,     9,    53,    14,    20,    21,    22,    23,
+    24,    18,    19,    37,    57,    38,    39,    41,    38,    14,
+    26,    27,    16,    17,    37,    38,    56,    39,    41,    37,
+    38,    60,    39,    41,    37,    38,    70,    39,    41,    72,
+    71,    16,    17,    73,    58,    59,    37,    38,    39,    41,
+    61,    52,    37,    37,    38 ]
+
+racc_action_check = [
+     0,     0,     0,     9,     9,     9,     0,     1,    15,     9,
+    10,    10,    10,    16,    16,    16,    10,    29,    29,    16,
+     1,     1,     0,    32,    32,     9,    24,    17,    17,    17,
+     8,     8,    10,    17,    25,    16,     8,     8,     8,     8,
+     8,     8,     8,    23,    30,    26,    23,    23,    27,    17,
+     8,     8,    30,    30,    20,    20,    28,    20,    20,    21,
+    21,    48,    21,    21,    22,    22,    62,    22,    22,    64,
+    62,    33,    33,    64,    40,    40,    52,    52,    61,    61,
+    49,    53,    60,    71,    73 ]
+
+racc_action_pointer = [
+    -2,     7,   nil,   nil,   nil,   nil,   nil,   nil,    21,     1,
+     8,   nil,   nil,   nil,   nil,     8,    11,    25,   nil,   nil,
+    32,    37,    42,    21,    20,    15,    22,    25,    32,     4,
+    39,   nil,    10,    58,   nil,   nil,   nil,   nil,   nil,   nil,
+    47,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    48,    67,
+   nil,   nil,    54,    75,   nil,   nil,   nil,   nil,   nil,   nil,
+    60,    53,    59,   nil,    62,   nil,   nil,   nil,   nil,   nil,
+   nil,    61,   nil,    61,   nil,   nil ]
+
+racc_action_default = [
+   -48,   -48,    -1,    -2,    -3,    -4,    -5,    -6,    -7,   -48,
+   -48,   -14,   -15,   -16,   -46,   -48,   -48,   -48,   -11,   -12,
+   -48,   -48,   -48,   -48,   -48,   -48,   -48,   -48,   -48,    -8,
+   -48,    76,    -9,   -10,   -17,   -23,   -30,   -40,   -41,   -42,
+   -48,   -45,   -18,   -24,   -31,   -19,   -25,   -32,   -48,   -48,
+   -21,   -26,   -48,   -48,   -28,   -29,   -47,   -13,   -43,   -44,
+   -48,   -48,   -48,   -35,   -48,   -38,   -22,   -27,   -20,   -33,
+   -34,   -48,   -37,   -48,   -36,   -39 ]
+
+racc_goto_table = [
+    35,    43,    46,    62,    50,    51,    54,    55,    34,    42,
+    45,    48,     1,    36,    44,    47,    49,    64,   nil,   nil,
+   nil,    29,    30,   nil,   nil,   nil,   nil,   nil,    32,    33,
+   nil,   nil,    65,    66,    67,   nil,   nil,   nil,   nil,   nil,
+    63,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    68,   nil,
+   nil,   nil,   nil,    75,    69,   nil,   nil,   nil,   nil,    74 ]
+
+racc_goto_check = [
+    12,    12,    12,    15,    11,    13,    12,    12,    10,    10,
+    10,    10,     1,    14,    14,    14,    14,    16,   nil,   nil,
+   nil,     1,     1,   nil,   nil,   nil,   nil,   nil,     1,     1,
+   nil,   nil,    12,    11,    13,   nil,   nil,   nil,   nil,   nil,
+    10,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    10,   nil,
+   nil,   nil,   nil,    12,    14,   nil,   nil,   nil,   nil,    10 ]
+
+racc_goto_pointer = [
+   nil,    12,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   -12,   -20,   -20,   -19,    -7,   -49,   -35,   nil ]
+
+racc_goto_default = [
+   nil,   nil,     2,     3,     4,     5,     8,    11,    12,    13,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,    40 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 32, :_reduce_none,
+  1, 32, :_reduce_none,
+  1, 32, :_reduce_none,
+  1, 32, :_reduce_none,
+  1, 33, :_reduce_5,
+  1, 33, :_reduce_6,
+  1, 33, :_reduce_7,
+  2, 34, :_reduce_8,
+  3, 34, :_reduce_9,
+  3, 34, :_reduce_10,
+  2, 34, :_reduce_11,
+  2, 34, :_reduce_12,
+  3, 35, :_reduce_13,
+  1, 36, :_reduce_none,
+  1, 36, :_reduce_none,
+  1, 36, :_reduce_none,
+  3, 38, :_reduce_17,
+  3, 38, :_reduce_18,
+  3, 38, :_reduce_19,
+  5, 38, :_reduce_20,
+  3, 38, :_reduce_21,
+  4, 38, :_reduce_22,
+  3, 39, :_reduce_23,
+  3, 39, :_reduce_24,
+  3, 39, :_reduce_25,
+  3, 39, :_reduce_26,
+  4, 39, :_reduce_27,
+  3, 39, :_reduce_28,
+  3, 39, :_reduce_29,
+  3, 40, :_reduce_30,
+  3, 40, :_reduce_31,
+  3, 40, :_reduce_32,
+  5, 40, :_reduce_33,
+  3, 42, :_reduce_34,
+  1, 46, :_reduce_none,
+  3, 46, :_reduce_36,
+  3, 44, :_reduce_37,
+  1, 47, :_reduce_none,
+  3, 47, :_reduce_39,
+  1, 41, :_reduce_40,
+  1, 43, :_reduce_41,
+  1, 45, :_reduce_42,
+  2, 45, :_reduce_43,
+  2, 45, :_reduce_44,
+  1, 48, :_reduce_45,
+  1, 37, :_reduce_46,
+  3, 37, :_reduce_47 ]
+
+racc_reduce_n = 48
+
+racc_shift_n = 76
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :TRUE => 2,
+  :FALSE => 3,
+  :LPAREN => 4,
+  :RPAREN => 5,
+  :LBRACKET => 6,
+  :RBRACKET => 7,
+  :BANG => 8,
+  :NOT => 9,
+  :DOT => 10,
+  :COMMA => 11,
+  :AT => 12,
+  :AND => 13,
+  :OR => 14,
+  :EQ => 15,
+  :GT => 16,
+  :LT => 17,
+  :BETWEEN => 18,
+  :IN => 19,
+  :PRESENT => 20,
+  :BLANK => 21,
+  :INTEGER => 22,
+  :STRING => 23,
+  :IDENTIFIER => 24,
+  :DATE => 25,
+  :DURATION => 26,
+  :AGO => 27,
+  :FROMNOW => 28,
+  :STARTSWITH => 29,
+  :ENDSWITH => 30 }
+
+racc_nt_base = 31
+
+racc_use_result_var = false
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "TRUE",
+  "FALSE",
+  "LPAREN",
+  "RPAREN",
+  "LBRACKET",
+  "RBRACKET",
+  "BANG",
+  "NOT",
+  "DOT",
+  "COMMA",
+  "AT",
+  "AND",
+  "OR",
+  "EQ",
+  "GT",
+  "LT",
+  "BETWEEN",
+  "IN",
+  "PRESENT",
+  "BLANK",
+  "INTEGER",
+  "STRING",
+  "IDENTIFIER",
+  "DATE",
+  "DURATION",
+  "AGO",
+  "FROMNOW",
+  "STARTSWITH",
+  "ENDSWITH",
+  "$start",
+  "predicate",
+  "boolean_predicate",
+  "logical_predicate",
+  "group_predicate",
+  "comparison_predicate",
+  "variable",
+  "integer_comparison_predicate",
+  "string_comparison_predicate",
+  "date_comparison_predicate",
+  "integer",
+  "integer_array",
+  "string",
+  "string_array",
+  "date",
+  "integer_array_contents",
+  "string_array_contents",
+  "duration" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+# reduce 1 omitted
+
+# reduce 2 omitted
+
+# reduce 3 omitted
+
+# reduce 4 omitted
+
+def _reduce_5(val, _values)
+ AST::True.new true 
+end
+
+def _reduce_6(val, _values)
+ AST::False.new false 
+end
+
+def _reduce_7(val, _values)
+ AST::BooleanVariable.new val.first 
+end
+
+def _reduce_8(val, _values)
+ AST::Not.new val.last 
+end
+
+def _reduce_9(val, _values)
+ AST::And.new val.first, val.last 
+end
+
+def _reduce_10(val, _values)
+ AST::Or.new val.first, val.last 
+end
+
+def _reduce_11(val, _values)
+ AST::Present.new val.first 
+end
+
+def _reduce_12(val, _values)
+ AST::Blank.new val.first 
+end
+
+def _reduce_13(val, _values)
+ AST::Group.new val[1] 
+end
+
+# reduce 14 omitted
+
+# reduce 15 omitted
+
+# reduce 16 omitted
+
+def _reduce_17(val, _values)
+ AST::IntegerEqual.new val.first, val.last 
+end
+
+def _reduce_18(val, _values)
+ AST::IntegerGreaterThan.new val.first, val.last 
+end
+
+def _reduce_19(val, _values)
+ AST::IntegerLessThan.new val.first, val.last 
 end
+
+def _reduce_20(val, _values)
+ AST::IntegerBetween.new val.first, val[2], val.last 
+end
+
+def _reduce_21(val, _values)
+ AST::IntegerIn.new val.first, val.last 
+end
+
+def _reduce_22(val, _values)
+ AST::IntegerNotIn.new val.first, val.last 
+end
+
+def _reduce_23(val, _values)
+ AST::StringEqual.new val.first, val.last 
+end
+
+def _reduce_24(val, _values)
+ AST::StringGreaterThan.new val.first, val.last 
+end
+
+def _reduce_25(val, _values)
+ AST::StringLessThan.new val.first, val.last 
+end
+
+def _reduce_26(val, _values)
+ AST::StringIn.new val.first, val.last 
+end
+
+def _reduce_27(val, _values)
+ AST::StringNotIn.new val.first, val.last 
+end
+
+def _reduce_28(val, _values)
+ AST::StringStartsWith.new val.first, val.last 
+end
+
+def _reduce_29(val, _values)
+ AST::StringEndsWith.new val.first, val.last 
+end
+
+def _reduce_30(val, _values)
+ AST::DateEqual.new val.first, val.last 
+end
+
+def _reduce_31(val, _values)
+ AST::DateGreaterThan.new val.first, val.last 
+end
+
+def _reduce_32(val, _values)
+ AST::DateLessThan.new val.first, val.last 
+end
+
+def _reduce_33(val, _values)
+ AST::DateBetween.new val.first, val[2], val.last 
+end
+
+def _reduce_34(val, _values)
+ AST::IntegerArray.new val[1] 
+end
+
+# reduce 35 omitted
+
+def _reduce_36(val, _values)
+ [val.first, val.last].flatten 
+end
+
+def _reduce_37(val, _values)
+ AST::StringArray.new val[1] 
+end
+
+# reduce 38 omitted
+
+def _reduce_39(val, _values)
+ [val.first, val.last].flatten 
+end
+
+def _reduce_40(val, _values)
+ AST::Integer.new val.first.to_i 
+end
+
+def _reduce_41(val, _values)
+ AST::String.new val.first 
+end
+
+def _reduce_42(val, _values)
+ AST::Date.new val.first 
+end
+
+def _reduce_43(val, _values)
+ AST::DateAgo.new val.first 
+end
+
+def _reduce_44(val, _values)
+ AST::DateFromNow.new val.first 
+end
+
+def _reduce_45(val, _values)
+ AST::Duration.new val.first 
+end
+
+def _reduce_46(val, _values)
+ AST::Variable.new val.first 
+end
+
+def _reduce_47(val, _values)
+ AST::Variable.new [val.first, val.last].flatten.join(".") 
+end
+
+def _reduce_none(val, _values)
+  val[0]
+end
+
+  end   # class Parser
+  end   # module Predicator