piggly-nsd 2.3.3

data/lib/piggly/parser/nodes.rb

@@ -0,0 +1,378 @@
+NodeClass = Treetop::Runtime::SyntaxNode
+
+class NodeClass
+  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
+  # back to original text_value if none was set.
+
+  attr_accessor :source_text
+
+  def source_text
+    @source_text || text_value
+  end
+
+  #
+  # Return a newly created Tag value, but only the tag.id is attached to the tree. The
+  # reason that is we maintain the Tags in a separate collection (to avoid a full traversal
+  # just to get the list of tags later), and we can retrieve the Tag associated with this
+  # node by its tag_id.
+  #
+  def tag(prefix = nil, id = nil)
+    unless defined? @tag_id
+      if named?(:body)
+        Piggly::Tags::BlockTag.new(prefix, id)
+      else
+        Piggly::Tags::EvaluationTag.new(prefix, id)
+      end.tap{|tag| @tag_id = tag.id }
+    end
+  end
+
+  def tag_id
+    @tag_id or raise RuntimeError, "Node is not tagged"
+  end
+
+  def tagged?
+    defined? @tag_id
+  end
+
+  # overridden in subclasses
+  def expression?; false end
+  def branch?; false end
+  def block?; false end
+  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
+
+  # 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)
+    end
+  end
+end
+
+module Piggly
+  module Parser
+    module Nodes
+
+      # ...;
+      class Statement < NodeClass
+        def statement?
+          true
+        end
+
+        def terminal?
+          false
+        end
+      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
+
+        def terminal?
+          false
+        end
+      end
+
+      # DECLARE declaration BEGIN body END;
+      class Block < Statement
+        def block?
+          true
+        end
+      end
+
+      # Branches with child 'cond' (Expression) will get a ConditionalBranchTag
+      class Branch < Statement
+        def branch?
+          true
+        end
+      end
+
+      # IF boolean-cond THEN body
+      class If < Branch
+        def if?
+          true
+        end
+
+        def terminal?
+          false
+        end
+      end
+
+      # ELSE body END
+      class Else < NodeClass
+        def else?
+          true
+        end
+
+        def terminal?
+          false
+        end
+      end
+
+      # EXCEPTION WHEN boolean-cond THEN body
+      class Catch < Branch
+      end
+
+      # WHEN match-expr THEN body
+      class CaseWhen < Branch
+      end
+
+      # WHEN boolean-cond THEN body
+      class CondWhen < Branch
+      end
+
+      # CONTINUE label WHEN boolean-cond;
+      class ContinueWhen < Branch
+      end
+
+      # EXIT label WHEN boolean-cond;
+      class ExitWhen < Branch
+      end
+
+      class UnconditionalBranch < Statement
+      end
+
+      # RETURN expr
+      class Return < UnconditionalBranch
+      end
+
+      # EXIT label
+      class Exit < UnconditionalBranch
+      end
+
+      # CONTINUE label
+      class Continue < UnconditionalBranch
+      end
+
+      # RAISE EXCEPTION expr
+      class Throw < UnconditionalBranch
+      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 var IN expr LOOP body END
+      class ForLoop < Loop
+        def for?
+          true
+        end
+      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
+
+      # CASE WHEN ...
+      class Cond < Statement
+      end
+
+      # lval := rval
+      class Assignment < Statement
+        def assignment?
+          true
+        end
+      end
+
+      # Lval of assignment (rval is an Expression)
+      class Assignable < NodeClass
+      end
+
+      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
+
+      # 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
+
+      # 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
+
+        def whitespace?
+          true
+        end
+      end
+
+      class Token < Terminal
+        def token?
+          true
+        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 TIdentifier < Token
+        def style; "tI"; end
+        def identifier?
+          true
+        end
+      end
+
+      class TDatatype < Token
+        def style; "tD"; end
+        def datatype?
+          true
+        end
+      end
+
+      class TString < Token
+        def style; "tS"; end
+        def string?
+          true
+        end
+      end
+
+      class TDollarQuoteMarker < Token
+        def style; "tM"; end
+      end
+
+      class TComment < Token
+        def style; "tC"; end
+        def comment?
+          true
+        end
+      end
+
+      class TLabel < Token
+        def style; "tL"; end
+        def label?
+          true
+        end
+      end
+
+      class TextNode < Terminal
+      end
+      
+      # Stub nodes have no children, or content
+      class StubNode < Terminal
+        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
+
+    end
+  end
+end

data/lib/piggly/parser/traversal.rb

@@ -0,0 +1,50 @@
+module Piggly
+  module Parser
+
+    #
+    # Routines for traversing a tree; assumes base class defines elements
+    # as a method that returns a list of child nodes
+    #
+    module Traversal
+      def inject(init) # :yields: NodeClass => init
+        if elements
+          elements.inject(yield(init, self)) do |state, e|
+            e.inject(state){|succ, n| yield(succ, n) }
+          end
+        else
+          yield(init, self)
+        end
+      end
+
+      def count # :yields: NodeClass => boolean
+        inject(0){|sum, e| yield(e) ? sum + 1 : sum }
+      end
+
+      def find # :yields: NodeClass => boolean
+        found = false
+        catch :done do
+          inject(nil) do |_,e|
+            if yield(e)
+              found = e
+              throw :done
+            end
+          end
+        end
+        found
+      end
+
+      def select # :yields: NodeClass => boolean
+        inject([]){|list,e| yield(e) ? list << e : list }
+      end
+
+      def flatten # :yields: NodeClass
+        if block_given?
+          inject([]){|list,e| list << yield(e) }
+        else
+          inject([]){|list,e| list << e }
+        end
+      end
+    end
+
+  end
+end

data/lib/piggly/parser/treetop_ruby19_patch.rb

@@ -0,0 +1,21 @@
+# UTF-8 encoding support for Treetop parser
+# This patch ensures that Treetop parsers properly handle UTF-8 encoded strings
+
+require 'treetop/runtime'
+
+module Treetop
+  module Runtime
+    # Patch CompiledParser to handle UTF-8 strings properly
+    class CompiledParser
+      alias_method :original_prepare_to_parse, :prepare_to_parse
+      
+      def prepare_to_parse(input)
+        # Ensure input is treated as UTF-8
+        if input.respond_to?(:force_encoding) && input.encoding != Encoding::UTF_8
+          input = input.dup.force_encoding('UTF-8')
+        end
+        original_prepare_to_parse(input)
+      end
+    end
+  end
+end

data/lib/piggly/parser.rb

@@ -0,0 +1,69 @@
+module Piggly
+
+  #
+  # Pl/pgSQL Parser, returns a tree of NodeClass values (see nodes.rb)
+  #
+  module Parser
+
+    autoload :Nodes,      "piggly/parser/nodes"
+    autoload :Traversal,  "piggly/parser/traversal"
+
+    class Failure < RuntimeError; end
+
+    class << self
+      # Returns lazy parse tree (only parsed when the value is needed)
+      def parse(string)
+        Util::Thunk.new do
+          p = parser
+
+          begin
+            # Ensure input is UTF-8 encoded
+            input = string.dup.force_encoding('UTF-8')
+            # Downcase input for case-insensitive parsing
+            input = input.downcase
+            tree = p.parse(input)
+            tree or raise Failure, "#{p.failure_reason}"
+          ensure
+            # Restore the original string after parsing
+            input.replace(string)
+          end
+        end
+      end
+
+      def parser_path;  "#{File.dirname(__FILE__)}/parser/parser.rb"  end
+      def grammar_path; "#{File.dirname(__FILE__)}/parser/grammar.tt" end
+      def nodes_path;   "#{File.dirname(__FILE__)}/parser/nodes.rb"   end
+
+      # Returns treetop parser (recompiled as needed)
+      def parser
+        return @parser if @parser
+        
+        load_support
+
+        # @todo: Compare with the version of treetop
+        if Util::File.stale?(parser_path, grammar_path)
+          # Regenerate the parser when the grammar is updated
+          Treetop::Compiler::GrammarCompiler.new.compile(grammar_path, parser_path)
+          # Remove existing constant before loading to avoid warnings
+          Object.send(:remove_const, :PigglyParser) if Object.const_defined?(:PigglyParser)
+          Object.send(:remove_const, :PigglyParserParser) if Object.const_defined?(:PigglyParserParser)
+          load parser_path
+          @parser = nil  # Clear cache when regenerating
+        else
+          require parser_path unless defined?(::PigglyParser::Parser)
+        end
+
+        @parser ||= ::PigglyParser::Parser.new
+      end
+    
+    private
+
+      def load_support
+        require "treetop"
+        require "piggly/parser/treetop_ruby19_patch"
+        require "piggly/parser/nodes"
+      end
+    end
+
+  end
+end

data/lib/piggly/profile.rb

@@ -0,0 +1,108 @@
+module Piggly
+
+  #
+  # Collection of all Tags
+  #
+  class Profile
+
+    def initialize
+      @by_id        = {}
+      @by_cache     = {}
+      @by_procedure = {}
+    end
+
+    # Register a procedure and its list of tags
+    def add(procedure, tags, cache = nil)
+      tags.each{|t| @by_id[t.id] = t }
+      @by_cache[cache] = tags unless cache.nil?
+      @by_procedure[procedure.oid] = tags
+    end
+
+    def [](object)
+      case object
+      when String
+        @by_id[object] or
+          raise "No tag with id #{object}"
+      when Dumper::ReifiedProcedure,
+           Dumper::SkeletonProcedure
+        @by_procedure[object.oid] or
+          raise "No tags for procedure #{object.signature}"
+      end
+    end
+
+    # Record the execution of a coverage tag
+    def ping(tag_id, value=nil)
+      self[tag_id].ping(value)
+    end
+
+    # Summarizes coverage for each type of tag (branch, block, loop)
+    #   @return [Hash<Symbol, Hash[:count => Integer, :percent => Float]>]
+    def summary(procedure = nil)
+      tags =
+        if procedure
+          if @by_procedure.include?(procedure.oid)
+            @by_procedure[procedure.oid]
+          else
+            []
+          end
+        else
+          @by_id.values
+        end
+
+      grouped = Util::Enumerable.group_by(tags){|x| x.type }
+
+      summary = Hash.new{|h,k| h[k] = Hash.new }
+      grouped.each do |type, ts|
+        summary[type][:count]   = ts.size
+        summary[type][:percent] = Util::Enumerable.sum(ts){|x| x.to_f } / ts.size
+      end
+
+      summary
+    end
+
+    # Resets each tag's coverage stats
+    def clear
+      @by_id.values.each{|x| x.clear }
+    end
+
+    # Write coverage stats to the disk cache
+    def store
+      @by_cache.each{|cache, tags| cache[:tags] = tags }
+    end
+
+    def empty?(tags)
+      tags.all?{|t| t.to_f.zero? }
+    end
+
+    # @return [String]
+    def difference(procedure, tags)
+      current  = Util::Enumerable.group_by(@by_procedure[procedure.oid]){|x| x.type }
+      previous = Util::Enumerable.group_by(tags){|x| x.type }
+
+      current.default  = []
+      previous.default = []
+
+      (current.keys | previous.keys).map do |type|
+        pct = Util::Enumerable.sum(current[type]){|x| x.to_f } / current[type].size -
+              Util::Enumerable.sum(previous[type]){|x| x.to_f } / previous[type].size
+
+        "#{"%+0.1f" % pct}% #{type}"
+      end.join(", ")
+    end
+
+    # Build a notice processor function that records each tag execution
+    #   @return [Proc]
+    def notice_processor(config, stderr = $stderr)
+      pattern = /#{config.trace_prefix} (#{Tags::AbstractTag::PATTERN})(?: (.))?/
+
+      lambda do |message|
+        if m = pattern.match(message)
+          ping(m.captures[0], m.captures[1])
+        else
+          stderr.puts("unknown trace: #{message}")
+        end
+      end
+    end
+  end
+
+end