piggly 1.2.1 → 2.0.0

data/lib/piggly/parser/nodes.rb

@@ -1,9 +1,7 @@
-require File.join(File.dirname(__FILE__), 'traversal')
-
 NodeClass = Treetop::Runtime::SyntaxNode
 
 class NodeClass
-  include Piggly::NodeTraversal
+  include Piggly::Parser::Traversal
 
   # The 'text_value' method can be used to read the parse tree as Treetop
   # originally read it. The 'source_text' method returns redefined value or falls
@@ -11,11 +9,6 @@ class NodeClass
 
   attr_accessor :source_text
 
-  def value
-    puts "NodeClass#value is deprecated: #{caller.first}"
-    text_value
-  end
-
   def source_text
     @source_text || text_value
   end
@@ -29,9 +22,9 @@ class NodeClass
   def tag(prefix = nil, id = nil)
     unless defined? @tag_id
       if named?(:body)
-        Piggly::BlockTag.new(prefix, id)
+        Piggly::Tags::BlockTag.new(prefix, id)
       else
-        Piggly::EvaluationTag.new(prefix, id)
+        Piggly::Tags::EvaluationTag.new(prefix, id)
       end.tap{|tag| @tag_id = tag.id }
     end
   end
@@ -41,7 +34,7 @@ class NodeClass
   end
 
   def tagged?
-    not @tag_id.nil?
+    defined? @tag_id
   end
 
   # overridden in subclasses
@@ -51,38 +44,31 @@ class NodeClass
   def stub?; false end
   def loop?; false end
   def for?; false end
+  def while?; false end
   def style; nil end
+  def comment?; false end
+  def whitespace?; false end
+  def token?; false end
+  def string?; false end
+  def datatype?; false end
+  def identifier?; false end
+  def assignment?; false end
+  def sql?; false end
+  def statement?; false; end
+  def if?; false; end
+  def else?; false; end
+  def label?; false; end
+  def keyword?; false; end
 
   def indent(method = nil)
     if method and respond_to?(method)
       send(method).text_value[/\n[\t ]*\z/]
     else
       text_value[/\n[\t ]*\z/]
-    end
+    end || ""
   end
 
-  alias o_inspect inspect
-
-  def inspect(indent = '')
-    if terminal?
-        em = extension_modules
-        interesting_methods = methods-[em.last ? em.last.methods : nil]-self.class.instance_methods
-        im = interesting_methods.size > 0 ? " (#{interesting_methods.join(",")})" : ""
-        tv = text_value
-        tv = "...#{tv[-20..-1]}" if tv.size > 20
-
-        indent +
-        self.class.to_s.sub(/.*:/,'') +
-          em.map{|m| "+"+m.to_s.sub(/.*:/,'')}*"" +
-          " offset=#{interval.first}" +
-          ", #{tv.inspect}" +
-          im
-    else
-      o_inspect(indent)
-    end
-  end
-
-  # true if node is called 'label' in parent node
+  # True if node is called `label` by the parent node
   def named?(label)
     if p = parent
       p.respond_to?(label) and p.send(label).equal?(self)
@@ -91,229 +77,302 @@ class NodeClass
 end
 
 module Piggly
+  module Parser
+    module Nodes
+
+      # ...;
+      class Statement < NodeClass
+        def statement?
+          true
+        end
+
+        def terminal?
+          false
+        end
+      end
 
-  # CREATE OR REPLACE ...
-  class Procedure < NodeClass
-  end
+      class Expression < NodeClass
+        def expression?
+          true
+        end
+
+        def tag(prefix = nil, id = nil)
+          unless defined? @tag_id
+            if named?(:cond)
+              if parent.while?
+                # This node is the conditional in a WHILE loop
+                Tags::ConditionalLoopTag.new(prefix, id)
+              elsif parent.loop?
+                # This node is the conditional in a loop
+                Tags::UnconditionalLoopTag.new(prefix, id)
+              elsif parent.branch?
+                # This node is a conditional in a branch
+                Tags::ConditionalBranchTag.new(prefix, id)
+              else
+                Tags::EvaluationTag.new(prefix, id)
+              end
+            else
+              Tags::EvaluationTag.new(prefix, id)
+            end.tap{|tag| @tag_id = tag.id }
+          end
+        end
 
-  # ...;
-  class Statement < NodeClass
-  end
+        def terminal?
+          false
+        end
+      end
 
-  class Expression < NodeClass
-    def expression?
-      true
-    end
+      # DECLARE declaration BEGIN body END;
+      class Block < Statement
+        def block?
+          true
+        end
+      end
 
-    def tag(prefix = nil, id = nil)
-      unless defined? @tag_id
-        if named?(:cond)
-          if parent.for?
-            # this object is the conditional statement in a FOR loop
-            Piggly::ForCollectionTag.new(prefix, id)
-          elsif parent.loop?
-            # this object is the conditional statement in a WHILE loop
-            Piggly::LoopConditionTag.new(prefix, id)
-          elsif parent.branch?
-            Piggly::BranchConditionTag.new(prefix, id)
-          end
-        else
-          Piggly::Evaluation.new(prefix, id)
-        end.tap{|tag| @tag_id = tag.id }
+      # Branches with child 'cond' (Expression) will get a ConditionalBranchTag
+      class Branch < Statement
+        def branch?
+          true
+        end
       end
-    end
-  end
 
-  # DECLARE declaration BEGIN body END;
-  class Block < Statement
-    def block?
-      true
-    end
-  end
+      # IF boolean-cond THEN body
+      class If < Branch
+        def if?
+          true
+        end
 
-  # Branches with child 'cond' (Expression) will get a BranchCondTag
-  class Branch < Statement
-    def branch?
-      true
-    end
-  end
+        def terminal?
+          false
+        end
+      end
 
-  # IF boolean-cond THEN body
-  class If < Branch
-  end
+      # ELSE body END
+      class Else < NodeClass
+        def else?
+          true
+        end
 
-  # ELSE body END
-  class Else < NodeClass
-  end
+        def terminal?
+          false
+        end
+      end
 
-  # EXCEPTION WHEN boolean-cond THEN body
-  class Catch < Branch
-  end
+      # EXCEPTION WHEN boolean-cond THEN body
+      class Catch < Branch
+      end
 
-  # WHEN match-expr THEN body
-  class CaseWhen < Branch
-  end
+      # WHEN match-expr THEN body
+      class CaseWhen < Branch
+      end
 
-  # WHEN boolean-cond THEN body
-  class CondWhen < Branch
-  end
+      # WHEN boolean-cond THEN body
+      class CondWhen < Branch
+      end
 
-  # CONTINUE label WHEN boolean-cond;
-  class ContinueWhen < Branch
-  end
+      # CONTINUE label WHEN boolean-cond;
+      class ContinueWhen < Branch
+      end
 
-  # EXIT label WHEN boolean-cond;
-  class ExitWhen < Branch
-  end
+      # EXIT label WHEN boolean-cond;
+      class ExitWhen < Branch
+      end
 
-  class UnconditionalBranch < Statement
-  end
+      class UnconditionalBranch < Statement
+      end
 
-  # RETURN expr
-  class Return < UnconditionalBranch
-  end
+      # RETURN expr
+      class Return < UnconditionalBranch
+      end
 
-  # EXIT label
-  class Exit < UnconditionalBranch
-  end
+      # EXIT label
+      class Exit < UnconditionalBranch
+      end
 
-  # CONTINUE label
-  class Continue < UnconditionalBranch
-  end
+      # CONTINUE label
+      class Continue < UnconditionalBranch
+      end
 
-  # RAISE EXCEPTION expr
-  class Throw < UnconditionalBranch
-  end
+      # RAISE EXCEPTION expr
+      class Throw < UnconditionalBranch
+      end
 
-  # Loops with child 'cond' (Expression/Sql) will get a LoopCondTag
-  class Loop < Statement
-    def loop?
-      true
-    end
-  end
+      # Loops that have a child named :cond (which should be either an Expression
+      # or Sql node) will get a LoopCondTag from the #tag method
+      class Loop < Statement
+        def loop?
+          true
+        end
+      end
 
-  # FOR boolean-cond LOOP body END
-  class ForLoop < Loop
-    def for?; true end
-  end
+      # FOR var IN expr LOOP body END
+      class ForLoop < Loop
+        def for?
+          true
+        end
+      end
 
-  # WHILE boolean-cond LOOP body END
-  class WhileLoop < Loop
-  end
+      # FOREACH var IN ARRAY expr LOOP body END
+      class ForEachLoop < Loop
+        def for?
+          true
+        end
+      end
 
+      # WHILE boolean-cond LOOP body END
+      class WhileLoop < Loop
+        def while?
+          true
+        end
+      end
 
-  # RAISE NOTICE expr
-  class Raise < Statement
-  end
 
-  # CASE search-expr WHEN ...
-  class Case < Statement
-  end
+      # RAISE NOTICE expr
+      class Raise < Statement
+      end
 
-  # CASE WHEN ...
-  class Cond < Statement
-  end
+      # CASE search-expr WHEN ...
+      class Case < Statement
+      end
 
-  # lval := rval
-  class Assignment < Statement
-  end
+      # CASE WHEN ...
+      class Cond < Statement
+      end
 
-  # Lval of assignment (rval is an Expression)
-  class Assignable < NodeClass
-  end
+      # lval := rval
+      class Assignment < Statement
+        def assignment?
+          true
+        end
+      end
 
-  class Sql < Statement
-    def style; 'tQ'; end
+      # Lval of assignment (rval is an Expression)
+      class Assignable < NodeClass
+      end
 
-    def tag(prefix = nil, id = nil)
-      unless defined? @tag_id
-        if named?(:cond) and parent.for?
-          # this object is the conditional statement in a FOR loop
-          Piggly::ForCollectionTag.new(prefix, id)
-        else
-          Piggly::EvaluationTag.new(prefix, id)
-        end.tap{|tag| @tag_id = tag.id }
+      class Sql < Expression
+        def style; "tQ"; end
+
+        def sql?
+          true
+        end
+
+        def tag(prefix = nil, id = nil)
+          unless defined? @tag_id
+            if named?(:cond) and parent.for?
+              # This node is the conditional in a FOR loop
+              Tags::UnconditionalLoopTag.new(prefix, id)
+            else
+              Tags::EvaluationTag.new(prefix, id)
+            end.tap{|tag| @tag_id = tag.id }
+          end
+        end
       end
-    end
-  end
 
-  # Tokens have no children
-  class Token < NodeClass
-    def initialize(input, interval, elements = nil)
-      # prevent children from being assigned
-      super(input, interval, nil)
-    end
+      # Terminals have no children
+      class Terminal < NodeClass
+        def initialize(input, interval, elements = nil)
+          # Third argument nil prevents children from being assigned
+          super(input, interval, nil)
+        end
 
-    def terminal?
-      true
-    end
-  end
+        def terminal?
+          true
+        end
+      end
 
-  # This seems like it should be a Token, but it may contain TComment children
-  # that should be highlighted differently than the enclosing whitespace
-  class TWhitespace < NodeClass
-  end
+      # This seems like it should be a Token, but it may contain TComment children
+      # that should be highlighted differently than the enclosing whitespace
+      class TWhitespace < NodeClass
+        def terminal?
+          false
+        end
 
-  class TKeyword < Token
-    def style; 'tK'; end
-  end
+        def whitespace?
+          true
+        end
+      end
 
-  class TIdentifier < Token
-    def style; 'tI'; end
-  end
+      class Token < Terminal
+        def token?
+          true
+        end
+      end
 
-  class TDatatype < Token
-    def style; 'tD'; end
-  end
+      class TKeyword < Token
+        def style; "tK"; end
+
+        def keyword?
+          true
+        end
+
+        def tag(prefix = nil, id = nil)
+          unless defined? @tag_id
+            if named?(:cond) and parent.loop?
+              Tags::UnconditionalLoopTag.new(prefix, id)
+            else
+              Tags::EvaluationTag.new(prefix, id)
+            end
+          end.tap{|tag| @tag_id = tag.id }
+        end
+      end
 
-  class TString < Token
-    def style; 'tS'; end
-  end
+      class TIdentifier < Token
+        def style; "tI"; end
+        def identifier?
+          true
+        end
+      end
 
-  class TDollarQuoteMarker < Token
-    def style; 'tM'; end
-  end
+      class TDatatype < Token
+        def style; "tD"; end
+        def datatype?
+          true
+        end
+      end
 
-  class TComment < Token
-    def style; 'tC'; end
-  end
+      class TString < Token
+        def style; "tS"; end
+        def string?
+          true
+        end
+      end
 
-  class TLabel < Token
-    def style; 'tL'; end
-  end
+      class TDollarQuoteMarker < Token
+        def style; "tM"; end
+      end
 
-  # Text nodes have no children
-  class TextNode < NodeClass
-    def initialize(input, interval, elements = nil)
-      # prevent children from being assigned
-      super(input, interval, nil)
-    end
+      class TComment < Token
+        def style; "tC"; end
+        def comment?
+          true
+        end
+      end
 
-    def terminal?
-      true
-    end
-  end
-  
-  # Stub nodes have no children, or content
-  class StubNode < NodeClass
-    def initialize(input, interval, elements = nil)
-      # prevent children from being assigned
-      super(input, interval, nil)
-    end
+      class TLabel < Token
+        def style; "tL"; end
+        def label?
+          true
+        end
+      end
 
-    def terminal?
-      true
-    end
+      class TextNode < Terminal
+      end
+      
+      # Stub nodes have no children, or content
+      class StubNode < Terminal
+        def stub?
+          true
+        end
+      end
 
-    def stub?
-      true
-    end
-  end
+      class NotImplemented < NodeClass
+        def parent=(object)
+          # this would go in the constructor, but parent is set from outside
+          raise Failure, "Grammar does not implement #{object.source_text} at line #{input.line_of(object.interval.first)}"
+        end
+      end
 
-  class NotImplemented < NodeClass
-    def parent=(object)
-      # this would go in the constructor, but parent is set from outside
-      raise Piggly::Parser::Failure, "Grammar does not implement #{object.source_text} at line #{input.line_of(object.interval.first)}"
     end
   end
 end