predicator 0.4.0 → 1.0.0

data/lib/predicator/parser.y

@@ -1,57 +1,83 @@
-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 tBLANK tPRESENT
+
+token TRUE FALSE LPAREN RPAREN LBRACKET RBRACKET
+      BANG NOT DOT COMMA AT AND OR
+      EQ GT LT BETWEEN IN
+      INTEGER STRING IDENTIFIER
+
 rule
   predicate
     : boolean_predicate
     | logical_predicate
-    | relation_predicate
-    | method_predicate
-    | tLPAREN predicate tRPAREN { val[1] }
-    | value tBETWEEN value tAND value { Predicator::Predicates::Between.new val[0], val[2], val[4] }
+    | 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] }
-    ;
-  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] }
-    ;
-  method_predicate
-    : value tDOT tBLANK         { Predicator::Predicates::Method.new val[0], val[2] }
-    | value tDOT tPRESENT       { Predicator::Predicates::Method.new val[0], val[2] }
+    : 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 }
     ;
-  value
-    : scalar
-    | variable
+  group_predicate
+    : LPAREN predicate RPAREN   { AST::Group.new val[1] }
+    ;
+  comparison_predicate
+    : value EQ value                { AST::Equal.new val.first, val.last }
+    | value GT value                { AST::GreaterThan.new val.first, val.last }
+    | value LT value                { AST::LessThan.new val.first, val.last }
+    | value BETWEEN value AND value { AST::Between.new val.first, val[2], val.last }
+    | value IN array                { AST::In.new val.first, val.last }
+    | value NOT IN array            { AST::NotIn.new val.first, val.last }
     ;
-  scalar
-    : string
-    | literal
+  array
+    : LBRACKET array_contents RBRACKET { AST::Array.new val[1] }
     ;
-  string
-    : tSTRING   { val[0] }
+  array_contents
+    : literal
+    | array_contents COMMA literal  { [val.first, val.last].flatten }
+    ;
+  value
+    : literal
+    | variable
     ;
   literal
-    : tFLOAT    { val[0].to_f }
-    | tINTEGER  { val[0].to_i }
-    | tDATE     { Date.new *val[0] }
+    : STRING                    { AST::String.new val.first }
+    | INTEGER                   { AST::Integer.new val.first.to_i }
     ;
   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.4.0"
+  VERSION = "1.0.0"
 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,100 @@
+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 binary node
+        node.children.each do |c|
+          @edges << "#{node.object_id} -> #{c.object_id};"
+        end
+        super
+      end
+
+      alias_method :ternary, :binary
+
+      def unary node
+        @edges << "#{node.object_id} -> #{node.left.object_id};"
+        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_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,117 @@
+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
+        super
+        @instructions.push ["compare", "EQ"]
+      end
+
+      def visit_GT node
+        super
+        @instructions.push ["compare", "GT"]
+      end
+
+      def visit_LT node
+        super
+        @instructions.push ["compare", "LT"]
+      end
+
+      def visit_BETWEEN node
+        super
+        @instructions.push ["compare", "BETWEEN"]
+      end
+
+      def visit_IN node
+        super
+        @instructions.push ["compare", "IN"]
+      end
+
+      def visit_NOTIN node
+        super
+        @instructions.push ["compare", "NOTIN"]
+      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 terminal node
+        @instructions.push ["lit", node.symbol]
+      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

data/lib/predicator/visitors/string.rb

@@ -0,0 +1,60 @@
+module Predicator
+  module Visitors
+    class String < Visitor
+      private
+
+      def terminal node
+        node.left.to_s
+      end
+
+      def visit_STRING node
+        "'#{node.left}'"
+      end
+
+      def visit_ARRAY node
+        contents = node.left.map{ |item| visit item }.join(", ")
+        "[#{contents}]"
+      end
+
+      def visit_NOT node
+        "!#{visit node.left}"
+      end
+
+      def visit_GROUP node
+        "(#{visit node.left})"
+      end
+
+      def visit_EQ node
+        [visit(node.left), " = ", visit(node.right)].join
+      end
+
+      def visit_GT node
+        [visit(node.left), " > ", visit(node.right)].join
+      end
+
+      def visit_LT node
+        [visit(node.left), " < ", visit(node.right)].join
+      end
+
+      def visit_AND node
+        [visit(node.left), " and ", visit(node.right)].join
+      end
+
+      def visit_OR node
+        [visit(node.left), " or ", visit(node.right)].join
+      end
+
+      def visit_BETWEEN node
+        [visit(node.left), " between ", visit(node.middle), " and ", visit(node.right)].join
+      end
+
+      def visit_IN node
+        [visit(node.left), " in ", visit(node.right)].join
+      end
+
+      def visit_NOTIN node
+        [visit(node.left), " not in ", visit(node.right)].join
+      end
+    end
+  end
+end

data/lib/predicator/visitors/visitor.rb

@@ -0,0 +1,48 @@
+module Predicator
+  module Visitors
+    class Visitor
+      DISPATCH_CACHE = Hash.new { |h,k|
+        h[k] = "visit_#{k}"
+      }
+
+      def accept node
+        visit node
+      end
+
+      private
+
+      def visit node
+        send DISPATCH_CACHE[node.type], node
+      end
+
+      def visit_children node
+        node.children.each {|child| visit child}
+      end
+
+      def visit_NOT node;   visit_children node; end
+      def visit_GROUP node; visit_children node; end
+      def visit_BOOL node;  visit_children node; end
+
+      def visit_EQ node;    visit_children node; end
+      def visit_GT node;    visit_children node; end
+      def visit_LT node;    visit_children node; end
+      def visit_AND node;   visit_children node; end
+      def visit_OR node;    visit_children node; end
+      def visit_IN node;    visit_children node; end
+      def visit_NOTIN node; visit_children node; end
+
+      def visit_BETWEEN node; visit_children node; end
+
+      def terminal node; end
+      def visit_TRUE node;      terminal node; end
+      def visit_FALSE node;     terminal node; end
+      def visit_INTEGER node;   terminal node; end
+      def visit_STRING node;    terminal node; end
+      def visit_VARIABLE node;  terminal node; end
+
+      def visit_ARRAY node
+        node.left.each{ |item| visit item }
+      end
+    end
+  end
+end