piggly 1.2.1 → 2.0.0

data/lib/piggly/reporter/index.rb

@@ -0,0 +1,108 @@
+module Piggly
+  module Reporter
+
+    class Index < Base
+
+      def initialize(config, profile)
+        @config, @profile = config, profile
+      end
+
+      def report(procedures, index)
+        io = File.open("#{report_path}/index.html", "w")
+
+        html(io) 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
+              aggregate("PL/pgSQL Coverage Summary", @profile.summary)
+              table(procedures.sort_by{|p| index.label(p) }, index)
+              timestamp
+            end
+          end
+        end
+      ensure
+        io.close
+      end
+
+    private
+
+      def table(procedures, index)
+        tag :table, :class => "summary sortable" do
+          tag :tr do
+            tag :th, "Procedure"
+            tag :th, "Blocks"
+            tag :th, "Loops"
+            tag :th, "Branches"
+            tag :th, "Block Coverage"
+            tag :th, "Loop Coverage"
+            tag :th, "Branch Coverage"
+          end
+
+          procedures.each_with_index do |procedure, k|
+            summary = @profile.summary(procedure)
+            row     = k.modulo(2) == 0 ? "even" : "odd"
+            label   = index.label(procedure)
+
+            tag :tr, :class => row do
+              unless summary.include?(:block) or summary.include?(:loop) or summary.include?(:branch)
+                # Parser couldn't parse this file
+                tag :td, label, :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, label, :href => procedure.identifier + ".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 percent(pct)
+        if pct
+          tag :table, :align => "center" do
+            tag :tr do
+              tag :td, "%0.2f%%&nbsp;" % pct, :class => "num"
+
+              style =
+                case pct.to_f
+                when 0...50;  "low"
+                when 0...100; "mid"
+                else          "high"
+                end
+
+              tag :td, :class => "graph" do
+                if pct
+                  tag :table, :align => "right", :class => "graph #{style}" 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
+    end
+
+  end
+end

data/lib/piggly/reporter/procedure.rb

@@ -0,0 +1,104 @@
+module Piggly
+  module Reporter
+
+    class Procedure < Base
+
+      def initialize(config, profile)
+        @config, @profile = config, profile
+      end
+
+      def report(procedure)
+        io = File.open(report_path(procedure.source_path(@config), ".html"), "w")
+
+        begin
+          compiler = Compiler::CoverageReport.new(@config)
+          data     = compiler.compile(procedure, @profile)
+
+          html(io) do
+            tag :html, :xmlns => "http://www.w3.org/1999/xhtml" do
+              tag :head do
+                tag :title, "Code Coverage: #{procedure.name}"
+                tag :link, :rel => "stylesheet", :type => "text/css", :href => "piggly.css"
+                tag :script, "<!-- -->", :type => "text/javascript", :src => "highlight.js"
+              end
+
+              tag :body do
+                aggregate(procedure.name, @profile.summary(procedure))
+
+                tag :div, :class => "listing" do
+                  tag :table do
+                    tag :tr do
+                      tag :td, "&nbsp;", :class => "signature"
+                      tag :td, signature(procedure), :class => "signature"
+                    end
+
+                    tag :tr do
+                      tag :td, data[:lines].to_a.map{|n| %[<a href="#L#{n}" id="L#{n}">#{n}</a>] }.join("\n"), :class => "lines"
+                      tag :td, data[:html], :class => "code"
+                    end
+                  end
+                end
+
+                toc(@profile[procedure])
+
+                timestamp
+              end
+            end
+          end
+        ensure
+          io.close
+        end
+      end
+
+    private
+
+      def signature(procedure)
+        string = "<span class='tK'>CREATE FUNCTION</span> <b><span class='tI'>#{procedure.name}</span></b>"
+
+        if procedure.arg_names.size <= 1
+          string   << " ( "
+          separator = ", "
+          spacer    = " "
+        else
+          string   << "\n\t( "
+          separator = ",\n\t  "
+          spacer    = "\t"
+        end
+
+        arguments = procedure.arg_types.zip(procedure.arg_modes, procedure.arg_names).map do |atype, amode, aname|
+          amode &&= "<span class='tK'>#{amode.upcase}</span>#{spacer}"
+          aname &&= "<span class='tI'>#{aname}</span>#{spacer}"
+          "#{amode}#{aname}<span class='tD'>#{atype}</span>"
+        end.join(separator)
+
+        string << arguments << " )"
+        string << "\n<span class='tK'>RETURNS#{procedure.setof ? ' SETOF' : ''}</span>"
+        string << " <span class='tD'>#{procedure.type.shorten}</span>"
+        string << "\n  <span class='tK'>SECURITY DEFINER</span>" if procedure.secdef
+        string << "\n  <span class='tK'>STRICT</span>" if procedure.strict
+        string << "\n  <span class='tK'>#{procedure.volatility.upcase}</span>"
+
+        string
+      end
+
+      def toc(tags)
+        todo = tags.reject{|t| t.complete? }
+        
+        tag :div, :class => 'toc' do
+          tag :a, 'Index', :href => 'index.html'
+
+          tag :ol do
+            todo.each do |t|
+              tag(:li, :class => t.type) do
+                tag :a, t.description, :href => "#T#{t.id}",
+                  :onMouseOver => "highlight('T#{t.id}')"
+              end
+            end
+          end unless todo.empty?
+        end
+      end
+
+    end
+
+  end
+end

data/lib/piggly/reporter/resources/highlight.js

@@ -0,0 +1,21 @@
+
+var lastId = null;
+var lastBg = null;
+
+function highlight(id) {
+  var el = document.getElementById(id);
+  if (el) {
+    if (lastId)
+      unhighlight(lastId, lastBg);
+
+    lastId = id;
+    lastBg = el.style.backgroundColor;
+
+    el.style.backgroundColor = 'yellow';
+  }
+}
+
+function unhighlight(id, bg) {
+  var el = document.getElementById(id);
+  if (el) { el.style.backgroundColor = bg; }
+}

data/lib/piggly/reporter/{piggly.css → resources/piggly.css}

@@ -1,22 +1,30 @@
+/* default piggly style sheet */
+
 * { margin: 0; padding: 0; }
 
 body
 {
   color: #000;
   background-color: #fff;
-  padding: 8px;
+  padding: 50px;
 }
 
 a img { border: 0; }
 
-div.timestamp { clear: both; }
+div.timestamp
+{
+  clear: both;
+  font-family: "Consolas", "DejaVu Sans Mono", "Monaco", "Nimbus Mono L", "Courier New";
+  font-style: italic;
+  font-size: 9pt;
+}
 
 div.toc
 {
   width: 200px;
   height: 150px;
   border: 1px solid #c00;
-  background-color: #fee;
+  background-color: #fdd;
   padding: 5px;
   position: fixed;
   overflow: auto;
@@ -41,6 +49,21 @@ div.listing
 }
 
 div.listing table { border-collapse: collapse; }
+div.listing td.signature
+{
+  vertical-align: top;
+  padding: 2px 4px;
+  white-space: pre;
+
+  margin: 0;
+  overflow: visible;
+  
+  border-bottom: 1px solid silver; 
+  background-color: #ffffe0;
+  color: #000;
+  font-family: "Consolas", "DejaVu Sans Mono", "Monaco", "Nimbus Mono L", "Courier New";
+  font-size: 9pt;
+}
 div.listing td.code
 {
   vertical-align: top;
@@ -54,7 +77,7 @@ div.listing td.code
   overflow: visible;
   
   color: #000;
-  font-family: "DejaVu Sans Mono", "Monaco", "Consolas", "Nimbus Mono L", "Courier New";
+  font-family: "Consolas", "DejaVu Sans Mono", "Monaco", "Nimbus Mono L", "Courier New";
   font-size: 9pt;
 }
 
@@ -70,23 +93,40 @@ div.listing td.lines
 
   background-color: #def;
   font-size: 9pt;
-  font-family: "DejaVu Sans Mono", "Monaco", "Consolas", "Nimbus Mono L", "Courier New";
+  font-family: "Consolas", "DejaVu Sans Mono", "Monaco", "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; }
+p.summary
+{ 
+  font-weight: bold;
+  font-family: "Tahoma", "Trebuchet MS", "Arial", sans-serif;
+  margin-bottom: 1em;
+}
+
+table.summary { margin-bottom: 2em; }
+table.summary th { padding: 5px; border-bottom: 1px solid silver; font-weight: bold; font-size: 12px; background-color: #eee; }
 table.summary td { padding: 5px; font-size: 10pt; }
 
-table.summary td.file  { text-align: left; border: 0; }
+table.summary tr.odd   { border-bottom: 1px solid #eee; }
+table.summary tr.even  { border-bottom: 1px solid #eee; }
+table.summary td.file  { text-align: left; }
 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.count { max-width: 50px;  min-width: 50px;  text-align: center; }
+table.summary td.pct   { max-width: 100px; min-width: 100px; }
 
-table.summary td.pct td.num   { padding: 0; max-width: 50px; min-width: 50px; text-align: right; border: 0; }
+table.summary td.pct td.num   { padding: 0; max-width: 50px; min-width: 50px; text-align: right; border: 0; font-size: 10px; }
 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.graph td.uncovered { border: 0; padding: 0; }
+table.low   td.uncovered { background-color: #c00; }
+table.mid   td.uncovered { background-color: #fc0; }
+table.high  td.uncovered { background-color: #093; }
+
+table.graph td.covered { border: 0; padding: 0; }
+table.low   td.covered { background-color: #f66; }
+table.mid   td.covered { background-color: #ffc; }
+table.high  td.covered { background-color: #390; }
 
 table.summary
 {

data/lib/piggly/tags.rb

@@ -0,0 +1,280 @@
+module Piggly
+  #
+  # Coverage is tracked by attaching these compiler-generated tags to various nodes in a stored
+  # procedure's parse tree. These tags each have a unique string identifier which is printed by
+  # various parts of the recompiled stored procedure, and the output is then recognized by
+  # Profile.notice_processor, which calls #ping on the tag corresponding to the printed string.
+  #
+  # After test execution is complete, each AST is walked and Tag values attached to NodeClass
+  # values are used to produce the coverage report
+  #
+  module Tags
+
+    class AbstractTag
+      PATTERN = /[0-9a-f]{16}/
+
+      attr_accessor :id
+
+      def initialize(prefix = nil, id = nil)
+        @id = Digest::MD5.hexdigest(prefix.to_s + (id || object_id).to_s).slice(0, 16)
+      end
+
+      alias to_s id
+
+      # Defined here in case ActiveSupport hasn't defined it on Object
+      def tap
+        yield self
+        self
+      end
+    end
+
+    class EvaluationTag < AbstractTag
+      attr_reader :ran
+     
+      def initialize(*args)
+        clear
+        super
+      end
+
+      def type
+        :block
+      end
+
+      def ping(value)
+        @ran = true
+      end
+
+      def style
+        "c#{@ran ? "1" : "0"}"
+      end
+      
+      def to_f
+        @ran ? 100.0 : 0.0
+      end
+
+      def complete?
+        @ran
+      end
+
+      def description
+        @ran ? "full coverage" : "never evaluated"
+      end
+
+      # Resets code coverage
+      def clear
+        @ran = false
+      end
+
+      def ==(other)
+        @id == other.id and @ran == other.ran
+      end
+    end
+
+    #
+    # Tracks a contiguous sequence of statements
+    #
+    class BlockTag < EvaluationTag
+    end
+
+    #
+    # Tracks procedure calls, raise exception, exits, returns
+    #
+    class UnconditionalBranchTag < EvaluationTag
+      # Aggregate this coverage data with conditional branches
+      def type
+        :branch
+      end
+    end
+
+    #
+    # Tracks if, catch, case branch, continue when, and exit when statements
+    # where the coverage consists of the condition evaluating true and false
+    #
+    class ConditionalBranchTag < AbstractTag
+      attr_reader :true, :false
+
+      def initialize(*args)
+        clear
+        super
+      end
+
+      def type
+        :branch
+      end
+
+      def ping(value)
+        case value
+        when "t"; @true  = true
+        when "f"; @false = true
+        end
+      end
+
+      def style
+        "b#{@true ? 1 : 0}#{@false ? 1 : 0 }"
+      end
+
+      def to_f
+        (@true and @false) ? 100.0 : (@true or @false) ? 50.0 : 0.0
+      end
+
+      def complete?
+        @true and @false
+      end
+
+      def description
+        if @true and @false
+          "full coverage"
+        elsif @true
+          "never evaluates false"
+        elsif @false
+          "never evaluates true"
+        else
+          "never evaluated"
+        end
+      end
+
+      def clear
+        @true, @false  = false
+      end
+
+      def ==(other)
+        @id == other.id and @true == other.true and @false == other.false
+      end
+    end
+
+    #
+    # Tracks loops where coverage consists of iterating once, iterating more
+    # than once, passing through, and at least one full iteration
+    #
+    class AbstractLoopTag < AbstractTag
+      def self.states
+        { # Never terminates normally (so @pass must be false)
+          0b0000 => "never evaluated",
+          0b0001 => "iterations always terminate early. loop always iterates more than once",
+          0b0010 => "iterations always terminate early. loop always iterates only once",
+          0b0011 => "iterations always terminate early",
+          # Terminates normally (one of @pass, @once, @twice must be true)
+          0b1001 => "loop always iterates more than once",
+          0b1010 => "loop always iterates only once",
+          0b1011 => "loop never passes through",
+          0b1100 => "loop always passes through",
+          0b1101 => "loop never iterates only once",
+          0b1110 => "loop never iterates more than once",
+          0b1111 => "full coverage" }
+      end
+
+      attr_reader :pass, :once, :twice, :ends, :count
+
+      def initialize(*args)
+        clear
+        super
+      end
+
+      def type
+        :loop
+      end
+
+      def style
+        "l#{[@pass, @once, @twice, @ends].map{|b| b ? 1 : 0}}"
+      end
+
+      def to_f
+        # Value space:
+        #    (1,2,X)  - loop iterated at least twice and terminated normally
+        #    (1,X)    - loop iterated only once and terminated normally
+        #    (0,X)    - loop never iterated and terminated normally (pass-thru)
+        #    ()       - loop condition was never executed
+        #
+        # These combinations are ignored, because coverage will probably not reveal bugs
+        #    (1,2)    - loop iterated at least twice but terminated early
+        #    (1)      - loop iterated only once but terminated early
+        100 * (Util::Enumerable.count([@pass, @once, @twice, @ends]){|x| x } / 4.0)
+      end
+
+      def complete?
+        @pass and @once and @twice and @ends
+      end
+
+      def description
+        self.class.states.fetch(n = state, "unknown tag state: #{n}")
+      end
+
+      # Returns state represented as a 4-bit integer
+      def state
+        [@ends,@pass,@once,@twice].reverse.inject([0,0]){|(k,n), bit| [k + 1, n | (bit ? 1 : 0) << k] }.last
+      end
+
+      def clear
+        @pass  = false
+        @once  = false
+        @twice = false
+        @ends  = false
+        @count = 0
+      end
+
+      def ==(other)
+        @id    == other.id   and
+        @ends  == other.ends and
+        @pass  == other.pass and
+        @once  == other.once and
+        @twice == other.twice
+      end
+    end
+
+    #
+    # Tracks loops that have a boolean condition in the loop statement (WHILE loops)
+    #
+    class ConditionalLoopTag < AbstractLoopTag
+      def ping(value)
+        case value
+        when "t"
+          # Loop iterated
+          @count += 1
+        else
+          # Loop terminated
+          case @count
+          when 0; @pass  = true
+          when 1; @once  = true
+          else;   @twice = true
+          end
+          @count = 0
+
+          # This isn't accurate. there needs to be a signal at the end
+          # of the loop body to indicate it was reached. Otherwise its
+          # possible each iteration restarts early with CONTINUE
+          @ends  = true
+        end
+      end
+    end
+
+    #
+    # Tracks loops that don't have a boolean condition in the loop statement (LOOP and FOR loops)
+    #
+    class UnconditionalLoopTag < AbstractLoopTag
+      def self.states
+        super.merge \
+          0b0100 => "loop always passes through"
+      end
+
+      def ping(value)
+        case value
+        when "t"
+          # start of iteration
+          @count += 1
+        when "@"
+          # end of iteration
+          @ends = true
+        when "f"
+          # loop exit
+          case @count
+          when 0; @pass = true
+          when 1; @once = true
+          else;  @twice = true
+          end
+          @count = 0
+        end
+      end
+    end
+
+  end
+end