predicator 0.3.0 → 1.2.1

data/lib/predicator/parser.y

@@ -1,52 +1,120 @@
-class Predicator::GeneratedParser
+class Predicator::Parser
+
 options no_result_var
-prechigh
-  right tBANG
-  left  tAND tOR
-preclow
-token tTRUE tFALSE tSTRING tFLOAT tINTEGER tDATE tIDENTIFIER tAND tOR tBETWEEN
-      tDOT tLPAREN tRPAREN tBANG tEQ tNEQ tLEQ tGEQ tLT tGT
+
+token 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
+
 rule
   predicate
-    : relation_predicate
-    | boolean_predicate
+    : boolean_predicate
     | logical_predicate
-    | value tBETWEEN value tAND value { Predicator::Predicates::Between.new val[0], val[2], val[4] }
-    | tLPAREN predicate tRPAREN
-    ;
-  relation_predicate
-    : value tEQ value           { Predicator::Predicates::Equal.new val[0], val[2] }
-    | value tGT value           { Predicator::Predicates::GreaterThan.new val[0], val[2] }
-    | value tLT value           { Predicator::Predicates::LessThan.new val[0], val[2] }
-    | value tGEQ value          { Predicator::Predicates::GreaterThanOrEqual.new val[0], val[2] }
-    | value tLEQ value          { Predicator::Predicates::LessThanOrEqual.new val[0], val[2] }
-    | value tNEQ value          { Predicator::Predicates::NotEqual.new val[0], val[2] }
+    | group_predicate
+    | comparison_predicate
     ;
   boolean_predicate
-    : tTRUE                     { Predicator::Predicates::True.new }
-    | tFALSE                    { Predicator::Predicates::False.new }
+    : TRUE                      { AST::True.new true }
+    | FALSE                     { AST::False.new false }
+    | variable                  { AST::BooleanVariable.new val.first }
     ;
   logical_predicate
-    : predicate tAND predicate  { Predicator::Predicates::And.new [val[0], val[2]] }
-    | predicate tOR predicate   { Predicator::Predicates::Or.new [val[0], val[2]] }
-    | tBANG predicate           { Predicator::Predicates::Not.new val[0] }
+    : BANG predicate            { AST::Not.new val.last }
+    | predicate AND predicate   { AST::And.new val.first, val.last }
+    | predicate OR predicate    { AST::Or.new val.first, val.last }
+    | variable PRESENT          { AST::Present.new val.first }
+    | variable BLANK            { AST::Blank.new val.first }
+    ;
+  group_predicate
+    : LPAREN predicate RPAREN   { AST::Group.new val[1] }
+    ;
+  comparison_predicate
+    : integer_comparison_predicate
+    | string_comparison_predicate
+    | date_comparison_predicate
+    ;
+  integer_comparison_predicate
+    : variable EQ integer                      { AST::IntegerEqual.new val.first, val.last }
+    | variable GT integer                      { AST::IntegerGreaterThan.new val.first, val.last }
+    | variable LT integer                      { AST::IntegerLessThan.new val.first, val.last }
+    | variable BETWEEN integer AND integer     { AST::IntegerBetween.new val.first, val[2], val.last }
+    | variable IN integer_array                { AST::IntegerIn.new val.first, val.last }
+    | variable NOT IN integer_array            { AST::IntegerNotIn.new val.first, val.last }
+    ;
+  string_comparison_predicate
+    : variable EQ string                       { AST::StringEqual.new val.first, val.last }
+    | variable GT string                       { AST::StringGreaterThan.new val.first, val.last }
+    | variable LT string                       { AST::StringLessThan.new val.first, val.last }
+    | variable IN string_array                 { AST::StringIn.new val.first, val.last }
+    | variable NOT IN string_array             { AST::StringNotIn.new val.first, val.last }
+    | variable STARTSWITH string               { AST::StringStartsWith.new val.first, val.last }
+    | variable ENDSWITH string                 { AST::StringEndsWith.new val.first, val.last }
     ;
-  value
-    : scalar
-    | variable
+  date_comparison_predicate
+    : variable EQ date                         { AST::DateEqual.new val.first, val.last }
+    | variable GT date                         { AST::DateGreaterThan.new val.first, val.last }
+    | variable LT date                         { AST::DateLessThan.new val.first, val.last }
+    | variable BETWEEN date AND date           { AST::DateBetween.new val.first, val[2], val.last }
     ;
-  scalar
+  integer_array
+    : LBRACKET integer_array_contents RBRACKET { AST::IntegerArray.new val[1] }
+    ;
+  integer_array_contents
+    : integer
+    | integer_array_contents COMMA integer     { [val.first, val.last].flatten }
+    ;
+  string_array
+    : LBRACKET string_array_contents RBRACKET  { AST::StringArray.new val[1] }
+    ;
+  string_array_contents
     : string
-    | literal
+    | string_array_contents COMMA string       { [val.first, val.last].flatten }
+    ;
+  integer
+    : INTEGER                   { AST::Integer.new val.first.to_i }
     ;
   string
-    : tSTRING   { val[0] }
+    : STRING                    { AST::String.new val.first }
+    ;
+  date
+    : DATE                      { AST::Date.new val.first }
+    | duration AGO              { AST::DateAgo.new val.first }
+    | duration FROMNOW          { AST::DateFromNow.new val.first }
     ;
-  literal
-    : tFLOAT    { val[0].to_f }
-    | tINTEGER  { val[0].to_i }
-    | tDATE     { Date.new *val[0] }
+  duration
+    : DURATION                  { AST::Duration.new val.first }
     ;
   variable
-    : tIDENTIFIER tDOT tIDENTIFIER { Predicator::Variable.new val[0], val[2] }
+    : IDENTIFIER                { AST::Variable.new val.first }
+    | variable DOT IDENTIFIER   { AST::Variable.new [val.first, val.last].flatten.join(".") }
     ;
+end
+
+---- inner
+    def initialize
+      @lexer = Lexer.new
+    end
+
+    def parse string
+      @lexer.parse string
+      do_parse
+    end
+
+    def next_token
+      @lexer.next_token
+    end
+
+    def on_error type, val, values
+      super
+    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
+
+---- header
+require "predicator/lexer.rex"
+require "predicator/visitors"
+require "predicator/ast"

data/lib/predicator/version.rb

@@ -1,3 +1,3 @@
 module Predicator
-  VERSION = "0.3.0"
+  VERSION = "1.2.1"
 end

data/lib/predicator/visitors.rb

@@ -0,0 +1,5 @@
+require "predicator/visitors/visitor"
+require "predicator/visitors/each"
+require "predicator/visitors/dot"
+require "predicator/visitors/string"
+require "predicator/visitors/instructions"

data/lib/predicator/visitors/dot.rb

@@ -0,0 +1,113 @@
+module Predicator
+  module Visitors
+    class Dot < Visitor
+      attr_reader :nodes, :edges
+
+      def initialize
+        @nodes = []
+        @edges = []
+      end
+
+      def accept node
+        super
+        <<-eodot
+digraph parse_tree {
+  size="8,5"
+  node [shape = none];
+  edge [dir = none];
+  #{@nodes.join "\n  "}
+  #{@edges.join "\n  "}
+}
+        eodot
+      end
+
+      private
+
+      def visit_children node
+        node.children.each do |c|
+          @edges << "#{node.object_id} -> #{c.object_id};"
+        end
+        super
+      end
+
+      def visit_EQ node
+        @nodes << "#{node.object_id} [label=\"=\"];"
+        super
+      end
+
+      def visit_GT node
+        @nodes << "#{node.object_id} [label=\">\"];"
+        super
+      end
+
+      def visit_LT node
+        @nodes << "#{node.object_id} [label=\"<\"];"
+        super
+      end
+
+      def visit_BETWEEN node
+        @nodes << "#{node.object_id} [label=\"between\"];"
+        super
+      end
+
+      def visit_AND node
+        @nodes << "#{node.object_id} [label=\"and\"];"
+        super
+      end
+
+      def visit_OR node
+        @nodes << "#{node.object_id} [label=\"or\"];"
+        super
+      end
+
+      def visit_NOT node
+        @nodes << "#{node.object_id} [label=\"!\"];"
+        super
+      end
+
+      def visit_GROUP node
+        @nodes << "#{node.object_id} [label=\"( )\"];"
+        super
+      end
+
+      def visit_DATEAGO node
+        @nodes << "#{node.object_id} [label=\"ago\"];"
+        super
+      end
+
+      def visit_DATEFROMNOW node
+        @nodes << "#{node.object_id} [label=\"from now\"];"
+        super
+      end
+
+      def visit_STRSTARTSWITH node
+        @nodes << "#{node.object_id} [label=\"starts with\"];"
+        super
+      end
+
+      def visit_STRENDSWITH node
+        @nodes << "#{node.object_id} [label=\"ends with\"];"
+        super
+      end
+
+      def visit_STRING node
+        value = node.left
+        @nodes << "#{node.object_id} [label=\"'#{value}'\"];"
+      end
+
+      def terminal node
+        value = node.left.to_s
+        @nodes << "#{node.object_id} [label=\"#{value}\"];"
+      end
+
+      def add_source source, parent
+        ast = Predicator.parse source
+        vis = Dot.new
+        vis.accept ast
+        @nodes += vis.nodes
+        @edges += vis.edges
+        @edges << "#{parent.object_id} -> #{ast.object_id};"
+      end
+    end
+  end
+end

data/lib/predicator/visitors/each.rb

@@ -0,0 +1,16 @@
+module Predicator
+  module Visitors
+    class Each < Visitor
+      attr_reader :block
+
+      def initialize block
+        @block = block
+      end
+
+      def visit node
+        super
+        block.call node
+      end
+    end
+  end
+end

data/lib/predicator/visitors/instructions.rb

@@ -0,0 +1,183 @@
+module Predicator
+  module Visitors
+    class Instructions < Visitor
+      attr_reader :instructions
+
+      def initialize instructions=[]
+        @instructions = instructions
+        @label_locations = {}
+      end
+
+      def accept ast
+        super
+        update_jumps
+        remove_labels
+        @instructions
+      end
+
+      private
+
+      def visit_AND node
+        visit node.left
+        @instructions.push jump_instruction("false", node)
+        visit node.right
+        @instructions.push label_instruction(node)
+      end
+
+      def visit_OR node
+        visit node.left
+        @instructions.push jump_instruction("true", node)
+        visit node.right
+        @instructions.push label_instruction(node)
+      end
+
+      def visit_NOT node
+        super
+        @instructions.push ["not"]
+      end
+
+      def visit_EQ node
+        visit node.left
+        add_typecast_to_instructions node
+        visit node.right
+        @instructions.push ["compare", "EQ"]
+      end
+
+      def visit_GT node
+        visit node.left
+        add_typecast_to_instructions node
+        visit node.right
+        @instructions.push ["compare", "GT"]
+      end
+
+      def visit_LT node
+        visit node.left
+        add_typecast_to_instructions node
+        visit node.right
+        @instructions.push ["compare", "LT"]
+      end
+
+      def visit_BETWEEN node
+        visit node.left
+        add_typecast_to_instructions node
+        visit node.middle
+        visit node.right
+        @instructions.push ["compare", "BETWEEN"]
+      end
+
+      def visit_IN node
+        visit node.left
+        add_typecast_to_instructions node
+        visit node.right
+        @instructions.push ["compare", "IN"]
+      end
+
+      def visit_NOTIN node
+        visit node.left
+        add_typecast_to_instructions node
+        visit node.right
+        @instructions.push ["compare", "NOTIN"]
+      end
+
+      def visit_STRSTARTSWITH node
+        visit node.left
+        add_typecast_to_instructions node
+        visit node.right
+        @instructions.push ["compare", "STARTSWITH"]
+      end
+
+      def visit_STRENDSWITH node
+        visit node.left
+        add_typecast_to_instructions node
+        visit node.right
+        @instructions.push ["compare", "ENDSWITH"]
+      end
+
+      def visit_ARRAY node
+        contents = node.left.map{ |item| item.left }
+        @instructions.push ["array", contents]
+      end
+
+      def visit_VARIABLE node
+        @instructions.push ["load", node.symbol]
+      end
+
+      def visit_BOOL node
+        super
+        @instructions.push ["to_bool"]
+      end
+
+      def visit_DATE node
+        @instructions.push ["lit", node.symbol]
+        @instructions.push ["to_date"]
+      end
+
+      def visit_DATEAGO node
+        visit node.left
+        @instructions.push ["date_ago"]
+      end
+
+      def visit_DATEFROMNOW node
+        visit node.left
+        @instructions.push ["date_from_now"]
+      end
+
+      def visit_DURATION node
+        as_seconds = node.symbol.to_i * 24 * 60 * 60
+        @instructions.push ["lit", as_seconds]
+      end
+
+      def visit_BLANK node
+        visit node.left
+        @instructions.push ["blank"]
+      end
+
+      def visit_PRESENT node
+        visit node.left
+        @instructions.push ["present"]
+      end
+
+      def terminal node
+        @instructions.push ["lit", node.symbol]
+      end
+
+      def add_typecast_to_instructions node
+        type = case node.right.type.to_s
+               when /INT/  then "to_int"
+               when /STR/  then "to_str"
+               when /DATE/ then "to_date"
+               end
+        @instructions.push [type]
+      end
+
+      def jump_instruction condition, node
+        ["j#{condition}", node.object_id.to_s]
+      end
+
+      def label_instruction node
+        label = node.object_id.to_s
+        @label_locations[label] = @instructions.size
+        ["label", label]
+      end
+
+      def update_jumps
+        @instructions.each_with_index do |inst, idx|
+          next unless inst.first =~ /^j/
+          label = inst.pop
+          offset = calculate_offset idx, @label_locations[label]
+          inst.push offset
+        end
+      end
+
+      def calculate_offset from_idx, to_idx
+        offset = to_idx - from_idx
+        num_labels = @instructions[from_idx...to_idx].count{ |i| i.first == "label" }
+        offset - num_labels
+      end
+
+      def remove_labels
+        @instructions.delete_if{ |inst| inst.first == "label" }
+      end
+    end
+  end
+end