piggly 1.2.1 → 2.0.0

data/lib/piggly/parser/traversal.rb

@@ -1,48 +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 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) }
+    #
+    # 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
-      else
-        yield(init, self)
       end
-    end
 
-    def count # :yields: NodeClass => boolean
-      fold_down(0){|sum, e| yield(e) ? sum + 1 : sum }
-    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
-        fold_down(nil) do |_,e|
-          if yield(e)
-            found = e
-            throw :done
+      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
-      found
-    end
 
-    def select # :yields: NodeClass => boolean
-      fold_down([]){|list,e| yield(e) ? list << e : list }
-    end
+      def select # :yields: NodeClass => boolean
+        inject([]){|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 }
+      def flatten # :yields: NodeClass
+        if block_given?
+          inject([]){|list,e| list << yield(e) }
+        else
+          inject([]){|list,e| list << e }
+        end
       end
     end
-  end
 
+  end
 end

data/lib/piggly/parser/treetop_ruby19_patch.rb

@@ -10,7 +10,7 @@ module Treetop
             super
           end
         end
-      end if RUBY_VERSION > '1.9.0'
+      end if RUBY_VERSION >= '1.9.0'
 
     end
   end

data/lib/piggly/profile.rb

@@ -4,84 +4,105 @@ module Piggly
   # Collection of all Tags
   #
   class Profile
-    PATTERN = /WARNING:  #{Config.trace_prefix} (#{Tag::PATTERN})(?: (.))?/
 
-    class << self
+    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
 
-      # 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])
+    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
-            STDERR.puts message
+            []
           end
+        else
+          @by_id.values
         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
+      grouped = Util::Enumerable.group_by(tags){|x| x.type }
 
-      # Each tag indexed by unique ID
-      def by_id
-        @by_id ||= Hash.new
+      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
 
-      # Each tag grouped by source file path
-      def by_file
-        @by_file ||= Hash.new
-      end
+      summary
+    end
 
-      # Each tag grouped by FileCache
-      def by_cache
-        @by_cache ||= Hash.new
-      end
+    # Resets each tag's coverage stats
+    def clear
+      @by_id.values.each{|x| x.clear }
+    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
+    # Write coverage stats to the disk cache
+    def store
+      @by_cache.each{|cache, tags| cache[:tags] = tags }
+    end
 
-      # Summarizes coverage for each type of tag (branch, block, loop)
-      def summary(file = nil)
-        summary = Hash.new{|h,k| h[k] = Hash.new }
+    def empty?(tags)
+      tags.all?{|t| t.to_f.zero? }
+    end
 
-        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
+    # @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 }
 
-        grouped.each do |type, ts|
-          summary[type][:count]   = ts.size
-          summary[type][:percent] = ts.sum{|t| t.to_f } / ts.size
-        end
+      current.default  = []
+      previous.default = []
 
-        summary
-      end
+      (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
 
-      # Resets each tag's coverage stats
-      def clear
-        by_id.values.each{|t| t.clear }
-      end
+        "#{"%+0.1f" % pct}% #{type}"
+      end.join(", ")
+    end
 
-      # Write each tag's coverage stats to the disk cache
-      def store
-        by_cache.each{|cache, tags| cache[:tags] = tags }
-      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(message)
+        end
+      end
     end
   end
+
 end

data/lib/piggly/reporter.rb

@@ -1,21 +1,8 @@
 module Piggly
-  class Reporter
-
-    def self.report_path(file=nil, ext=nil)
-      Piggly::Config.mkpath(Config.report_root, ext ? File.basename(file).sub(/\.[^.]+$/i, ext) : file)
-    end
-
-    # Copy each file to Config.report_root
-    def self.install(*files)
-      files.each do |file|
-        src = File.join(File.dirname(__FILE__), 'reporter', file)
-        dst = report_path(file)
-
-        File.open(dst, 'w') {|f| f.write File.read(src) }
-      end
-    end
-
+  module Reporter
+    autoload :HtmlDsl,    "piggly/reporter/html_dsl"
+    autoload :Base,       "piggly/reporter/base"
+    autoload :Index,      "piggly/reporter/index"
+    autoload :Procedure,  "piggly/reporter/procedure"
   end
 end
-
-require File.join(File.dirname(__FILE__), *%w[reporter html])

data/lib/piggly/reporter/base.rb

@@ -0,0 +1,103 @@
+module Piggly
+  module Reporter
+
+    class Base
+      include HtmlDsl
+
+      def initialize(config)
+        @config = config
+      end
+
+      # Copy each file to @config.report_root
+      def install(*files)
+        files.each do |name|
+          src = File.join(File.dirname(__FILE__), name)
+          dst = report_path(name)
+
+          File.open(dst, "w"){|io| io.write(File.read(src)) }
+        end
+      end
+
+      def report_path(file=nil, ext=nil)
+        unless file.nil?
+          # Remove the original extension from +file+ and add given extension
+          @config.mkpath(@config.report_root, ext ?
+            File.basename(file, ".*") + ext :
+            File.basename(file))
+        else
+          @config.mkpath(@config.report_root)
+        end
+      end
+
+    private
+
+      def aggregate(label, summary)
+        tag :p, label, :class => "summary"
+        tag :table, :class => "summary sortable" do
+          tag :tr do
+            tag :th, "Blocks"
+            tag :th, "Loops"
+            tag :th, "Branches"
+            tag :th, "Block Coverage"
+            tag :th, "Loop Coverage"
+            tag :th, "Branch Coverage"
+          end
+
+          tag :tr, :class => "even" do
+            unless summary.include?(:block) or summary.include?(:loop) or summary.include?(:branch)
+              # Parser couldn't parse this file
+              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, (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
+
+      def percent(pct)
+        if pct
+          tag :table, :align => "center" do
+            tag :tr do
+              tag :td, "%0.2f%% " % 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
+
+      def timestamp
+        tag :div, "Generated by piggly #{Piggly::VERSION} at #{Time.now.strftime("%B %d, %Y %H:%M %Z")}", :class => "timestamp"
+      end
+    end
+
+  end
+end

data/lib/piggly/reporter/html_dsl.rb

@@ -0,0 +1,63 @@
+module Piggly
+  module Reporter
+
+    #
+    # Markup DSL
+    #
+    module HtmlDsl
+      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)
+          string.fast_xs
+        end
+      elsif "".respond_to?(:to_xs)
+        def e(string)
+          string.to_xs
+        end
+      else
+        def e(string)
+          string.gsub(HTML_PATTERN) {|c| HTML_REPLACE[c] }
+        end
+      end
+    end
+
+  end
+end