piggly 1.2.0

data/lib/piggly/parser/traversal.rb

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

data/lib/piggly/parser/treetop_ruby19_patch.rb

@@ -0,0 +1,17 @@
+module Treetop
+  module Runtime
+    class CompiledParser
+
+      class Regexp < ::Regexp
+        def initialize(*args)
+          if args.size == 1
+            super(args.first, nil, 'n')
+          else
+            super
+          end
+        end
+      end if RUBY_VERSION > '1.9.0'
+
+    end
+  end
+end

data/lib/piggly/parser.rb

@@ -0,0 +1,67 @@
+module Piggly
+
+  #
+  # Pl/pgSQL Parser, returns a tree of NodeClass values (see nodes.rb)
+  #
+  class Parser
+    include FileCache
+
+    class Failure < RuntimeError; end
+
+    # Returns parse tree
+    def self.parse(string)
+      p = parser
+
+      begin
+        # downcase input for case-insensitive parsing,
+        # then restore original string after parsing
+        input = string.downcase
+        tree = p.parse(input)
+        tree or raise Failure, "#{p.failure_reason}"
+      rescue Failure
+        $!.backtrace.clear
+        raise
+      ensure
+        input.replace string
+      end
+    end
+
+    def self.parser_path;  File.join(File.dirname(__FILE__), 'parser', 'parser.rb')  end
+    def self.grammar_path; File.join(File.dirname(__FILE__), 'parser', 'grammar.tt') end
+    def self.nodes_path;   File.join(File.dirname(__FILE__), 'parser', 'nodes.rb')   end
+
+    def self.stale?(source)
+      File.stale?(cache_path(source), source, grammar_path, parser_path, nodes_path)
+    end
+
+    def self.cache(source)
+      cache = cache_path(source)
+
+      if stale?(source)
+        tree = parse(File.read(source))
+        File.open(cache, 'w+') do |f|
+          Marshal.dump(tree, f)
+          tree
+        end
+      else
+        _ = parser # ensure parser libraries, like nodes.rb, are loaded
+        Marshal.load(File.read(cache))
+      end
+    end
+
+    # Returns treetop parser (recompiled as needed)
+    def self.parser
+      require 'treetop'
+      require 'piggly/parser/treetop_ruby19_patch'
+      require nodes_path
+
+      if File.stale?(parser_path, grammar_path)
+        Treetop::Compiler::GrammarCompiler.new.compile(grammar_path, parser_path)
+      end
+
+      require parser_path
+      ::PigglyParser.new
+    end
+
+  end
+end

data/lib/piggly/profile.rb

@@ -0,0 +1,87 @@
+module Piggly
+
+  #
+  # Collection of all Tags
+  #
+  class Profile
+    PATTERN = /WARNING:  #{Config.trace_prefix} (#{Tag::PATTERN})(?: (.))?/
+
+    class << self
+
+      # Build a notice processor function that records each tag execution
+      def notice_processor
+        proc do |message|
+          if m = PATTERN.match(message)
+            ping(m.captures[0], m.captures[1])
+          else
+            STDERR.puts message
+          end
+        end
+      end
+
+      # Register a source file (path) with its list of tags
+      def add(path, tags, cache = nil)
+        tags.each{|t| by_id[t.id] = t }
+        by_file[path]  = tags
+        by_cache[cache] = tags if cache
+      end
+
+      # Each tag indexed by unique ID
+      def by_id
+        @by_id ||= Hash.new
+      end
+
+      # Each tag grouped by source file path
+      def by_file
+        @by_file ||= Hash.new
+      end
+
+      # Each tag grouped by FileCache
+      def by_cache
+        @by_cache ||= Hash.new
+      end
+
+      # Record the execution of a coverage tag
+      def ping(tag_id, value=nil)
+        if tag = by_id[tag_id]
+          tag.ping(value)
+        else
+          raise "No tag with id #{tag_id}, perhaps the proc was not compiled with Piggly::Installer.trace_proc, or it has been recompiled with new tag IDs."
+        end
+      end
+
+      # Summarizes coverage for each type of tag (branch, block, loop)
+      def summary(file = nil)
+        summary = Hash.new{|h,k| h[k] = Hash.new }
+
+        if file
+          if by_file.include?(file)
+            grouped = by_file[file].group_by{|t| t.type }
+          else
+            grouped = {}
+          end
+        else
+          grouped = map.group_by{|t| t.type }
+        end
+
+        grouped.each do |type, ts|
+          summary[type][:count]   = ts.size
+          summary[type][:percent] = ts.sum{|t| t.to_f } / ts.size
+        end
+
+        summary
+      end
+
+      # Resets each tag's coverage stats
+      def clear
+        by_id.values.each{|t| t.clear }
+      end
+
+      # Write each tag's coverage stats to the disk cache
+      def store
+        by_cache.each{|cache, tags| cache[:tags] = tags }
+      end
+
+    end
+  end
+end

data/lib/piggly/reporter/html.rb

@@ -0,0 +1,207 @@
+module Piggly
+
+  #
+  # Markup DSL
+  #
+  module HtmlTag
+    unless defined? HTML_REPLACE
+      HTML_REPLACE = { '&' => '&amp;', '"' => '&quot;', '>' => '&gt;', '<' => '&lt;' }
+      HTML_PATTERN = /[&"<>]/
+    end
+
+    def html(output = '')
+      begin
+        @htmltag_output, htmltag_output = output, @htmltag_output
+        # TODO: doctype
+        yield
+      ensure
+        # restore
+        @htmltag_output = htmltag_output
+      end
+    end
+
+    def tag(name, content = nil, attributes = {})
+      if content.is_a?(Hash) and attributes.empty?
+        content, attributes = nil, content
+      end
+
+      attributes = attributes.inject('') do |string, pair|
+        k, v = pair
+        string << %[ #{k}="#{v}"]
+      end
+
+      if content.nil?
+        if block_given?
+          @htmltag_output << "<#{name}#{attributes}>"
+          yield
+          @htmltag_output << "</#{name}>"
+        else
+          @htmltag_output << "<#{name}#{attributes}/>"
+        end
+      else
+        @htmltag_output << "<#{name}#{attributes}>#{content.to_s}</#{name}>"
+      end
+    end
+
+    if ''.respond_to?(:fast_xs)
+      def e(string)
+        e.fast_xs
+      end
+    elsif ''.respond_to?(:to_xs)
+      def e(string)
+        e.to_xs
+      end
+    else
+      def e(string)
+        string.gsub(HTML_PATTERN) {|c| HTML_REPLACE[c] }
+      end
+    end
+  end
+
+  class HtmlReporter < Reporter
+    extend HtmlTag
+
+    def self.output(path, data, summary)
+      File.open(report_path(path, '.html'), 'w') do |f|
+        html(f) do
+
+          tag :html, :xmlns => 'http://www.w3.org/1999/xhtml' do
+            tag :head do
+              tag :title, "Code Coverage: #{File.basename(path)}"
+              tag :link, :rel => 'stylesheet', :type => 'text/css', :href => 'piggly.css'
+            end
+
+            tag :body do
+              table(path)
+
+              tag :br
+              tag :div, :class => 'listing' do
+                tag :table do
+                  tag :tr do
+                    tag :td, data.fetch('lines').to_a.map{|n| %[<a href="#L#{n}" id="L#{n}">#{n}</a>] }.join("\n"), :class => 'lines'
+                    tag :td, data.fetch('html'), :class => 'code'
+                  end
+                end
+              end
+
+              toc(data.fetch('tags'))
+            end
+          end
+
+        end
+      end
+    end
+
+    def self.toc(tags)
+      todo = tags.reject{|t| t.complete? }
+      
+      tag :div, :class => 'toc' do
+        tag :a, 'Index', :href => 'index.html'
+
+        unless todo.empty?
+          tag :ol do
+            todo.each do |t|
+              tag(:li, :class => t.type) { tag :a, t.description, :href => "#T#{t.id}" }
+            end
+          end
+        end
+      end
+    end
+
+    def self.timestamp
+      tag :div, "Generated by piggly #{Piggly::VERSION} at #{Time.now.strftime('%B %d, %Y %H:%M %Z')}", :class => 'timestamp'
+    end
+
+    def self.table(*files)
+      tag :table, :class => 'summary sortable' do
+        tag :tr do
+          tag :th, 'File'
+          tag :th, 'Blocks'
+          tag :th, 'Loops'
+          tag :th, 'Branches'
+          tag :th, 'Block Coverage'
+          tag :th, 'Loop Coverage'
+          tag :th, 'Branch Coverage'
+        end
+
+        files.each_with_index do |name, index|
+          summary = Profile.summary(name)
+          row     = index.modulo(2) == 0 ? 'even' : 'odd'
+
+          tag :tr, :class => row do
+            unless summary.include?(:block) or summary.include?(:loop) or summary.include?(:branch)
+              # PigglyParser couldn't parse this file
+              tag :td, File.basename(name), :class => 'file fail'
+              tag(:td, :class => 'count') { tag :span, -1, :style => 'display:none' }
+              tag(:td, :class => 'count') { tag :span, -1, :style => 'display:none' }
+              tag(:td, :class => 'count') { tag :span, -1, :style => 'display:none' }
+              tag(:td, :class => 'pct') { tag :span, -1, :style => 'display:none' }
+              tag(:td, :class => 'pct') { tag :span, -1, :style => 'display:none' }
+              tag(:td, :class => 'pct') { tag :span, -1, :style => 'display:none' }
+            else
+              tag(:td, :class => 'file') { tag :a, File.basename(name), :href => File.basename(name, '.*') + '.html' }
+              tag :td, (summary[:block][:count]  || 0), :class => 'count'
+              tag :td, (summary[:loop][:count]   || 0), :class => 'count'
+              tag :td, (summary[:branch][:count] || 0), :class => 'count'
+              tag(:td, :class => 'pct') { percent(summary[:block][:percent])  }
+              tag(:td, :class => 'pct') { percent(summary[:loop][:percent])   }
+              tag(:td, :class => 'pct') { percent(summary[:branch][:percent]) }
+            end
+          end
+
+        end
+      end
+    end
+
+    def self.percent(pct)
+      if pct
+        tag :table, :align => 'center' do
+          tag :tr do
+
+            tag :td, '%0.2f%%&nbsp;' % pct, :class => 'num'
+            tag :td, :class => 'graph' do
+              if pct
+                tag :table, :align => 'right', :class => 'graph' do
+                  tag :tr do
+                    tag :td, :class => 'covered', :width => (pct/2.0).to_i
+                    tag :td, :class => 'uncovered', :width => ((100-pct)/2.0).to_i
+                  end
+                end
+              end
+            end
+
+          end
+        end
+      else
+        tag :span, -1, :style => 'display:none'
+      end
+    end
+
+    class Index < HtmlReporter
+      extend HtmlTag
+
+      def self.output(sources)
+        File.open(File.join(report_path, 'index.html'), 'w') do |f|
+          html(f) do
+
+            tag :html do
+              tag :head do
+                tag :title, 'Piggly PL/pgSQL Code Coverage'
+                tag :link, :rel => 'stylesheet', :type => 'text/css', :href => 'piggly.css'
+                tag :script, '<!-- -->', :type => 'text/javascript', :src => 'sortable.js'
+              end
+
+              tag :body do
+                table(*sources.sort)
+                tag :br
+                timestamp
+              end
+            end
+
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/piggly/reporter/piggly.css

@@ -0,0 +1,187 @@
+* { margin: 0; padding: 0; }
+
+body
+{
+  color: #000;
+  background-color: #fff;
+  padding: 8px;
+}
+
+a img { border: 0; }
+
+div.timestamp { clear: both; }
+
+div.toc
+{
+  width: 200px;
+  height: 150px;
+  border: 1px solid #c00;
+  background-color: #fee;
+  padding: 5px;
+  position: fixed;
+  overflow: auto;
+  bottom: 10px;
+  right: 10px;
+  font-family: "Tahoma", "Trebuchet MS", "Arial", sans-serif;
+}
+div.toc ol { margin-left: 1.6em; }
+div.toc  a { color: #c00; }
+div.toc li { font-size: 75%; }
+div.toc li.branch { }
+div.toc li.block  { }
+div.toc li.loop   { }
+
+/* main container for line numbers and code */
+div.listing
+{
+  background-color: #f9f9f9;
+  border: 1px solid silver;
+  margin: 0 0 1.5em 0;
+  overflow: auto;
+}
+
+div.listing table { border-collapse: collapse; }
+div.listing td.code
+{
+  vertical-align: top;
+  padding: 2px 4px;
+  white-space: pre;
+
+  margin: 0;
+  width: 100%;
+  float: none;
+  clear: none;
+  overflow: visible;
+  
+  color: #000;
+  font-family: "DejaVu Sans Mono", "Monaco", "Consolas", "Nimbus Mono L", "Courier New";
+  font-size: 9pt;
+}
+
+/* line numbers */
+div.listing td.lines
+{
+  vertical-align: top;
+  padding: 2px 4px;
+  white-space: pre;
+
+  text-align: right;
+  overflow: visible;
+
+  background-color: #def;
+  font-size: 9pt;
+  font-family: "DejaVu Sans Mono", "Monaco", "Consolas", "Nimbus Mono L", "Courier New";
+}
+div.listing td.lines a { color: grey; text-decoration: none; }
+
+table.summary th { padding: 5px; border: 1px solid silver; font-weight: bold; font-size: 12px; background-color: #def; }
+table.summary td { padding: 5px; font-size: 10pt; }
+
+table.summary td.file  { text-align: left; border: 0; }
+table.summary td.fail  { font-weight: bold; color: #f00; }
+table.summary td.count { max-width: 50px;  min-width: 50px;  text-align: right; border: 1px solid silver; }
+table.summary td.pct   { max-width: 100px; min-width: 100px; text-align: right; border: 0; }
+
+table.summary td.pct td.num   { padding: 0; max-width: 50px; min-width: 50px; text-align: right; border: 0; }
+table.summary td.pct td.graph { padding: 0; max-width: 50px; min-width: 50px; text-align: right; border: 0; }
+
+table.graph td.uncovered { background-color: #669; border: 0px; padding: 0px; }
+table.graph td.covered   { background-color: #ccf; border: 0px; padding: 0px; }
+
+table.summary
+{
+  font-family: "Tahoma", "Trebuchet MS", "Arial", sans-serif;
+  width: 100%;
+  border-spacing: 0;
+  border-collapse: collapse;
+} 
+
+table.summary td.pct table
+{
+  font-size: 85%;
+  font-family: "Tahoma", "Trebuchet MS", "Arial", sans-serif;
+  padding: 0;
+  border-spacing: 0;
+  border-collapse: collapse;
+}
+
+table.graph
+{
+  min-width: 50px;
+  max-width: 50px;
+  padding: 0px;
+  border: 1px solid #000;
+  border-spacing: 0px;
+  height: 10px;
+}
+
+/* SYNTAX HIGHLIGHTING */
+
+/* identifier */
+  .tI { color: #666; }
+
+/* data type */
+  .tD { color: #cc3; font-style: italic; }
+
+/* keyword */
+  .tK { color: #f30; }
+
+/* comment */
+  .tC { color: #66f; font-style: italic; }
+
+/* sql statement */
+  .tQ { color: #6c3; font-style: italic; }
+
+/* string literal */
+  .tS { color: #390; }
+
+/* label */
+  .tL { color: #630; font-style: italic; }
+
+/* dollar quote marker */
+  .tM { }
+
+/* tagged code blocks */
+.b { display: block; width: 100%; margin: 0; padding: 0; }
+.i { display: inline; }
+
+/* line with incomplete coverage */
+.lU
+{
+  display: block;
+  background: #fdd;
+
+  margin: 0px;
+  padding: 0px;
+  border: none;
+  border-left: 2px solid #f00;
+}
+
+/* block execution: yes, no */
+.c0 { font-weight: bold; }
+.c1 { }
+
+/* loop coverage */
+.l0000 { font-weight: bold; }
+.l0001 { font-weight: bold; }
+.l0010 { font-weight: bold; }
+.l0100 { font-weight: bold; }
+.l0011 { font-weight: bold; }
+.l0101 { font-weight: bold; }
+.l0110 { font-weight: bold; }
+.l0111 { font-weight: bold; }
+.l1000 { font-weight: bold; }
+.l1001 { font-weight: bold; }
+.l1010 { font-weight: bold; }
+.l1100 { font-weight: bold; }
+.l1011 { font-weight: bold; }
+.l1101 { font-weight: bold; }
+.l1110 { font-weight: bold; }
+.l1111 { }
+
+/* branch decisions: true, false */
+.b00 { font-weight: bold; } /* never evaluated */
+.b01 { font-weight: bold; color: #060; } /* never evaluates true  */
+.b10 { font-weight: bold; color: #900; } /* never evaluates false */
+.b11 { }
+