piggly 1.2.0

data/lib/piggly/compiler/tags.rb

@@ -0,0 +1,244 @@
+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
+  #
+  class Tag
+    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 < Tag
+    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
+  end
+
+  #
+  # Sequence of statements
+  #
+  class BlockTag < EvaluationTag
+  end
+
+  #
+  # Procedure calls, raise exception, exits, returns
+  #
+  class UnconditionalBranchTag < EvaluationTag
+    # aggregate this coverage data with conditional branches
+    def type
+      :branch
+    end
+  end
+
+  class LoopConditionTag < Tag
+    STATES = { # never terminates normally (so @pass must be false)
+               0b0000 => 'condition was never evaluated',
+               0b0001 => 'condition never evaluates false (terminates early). loop always iterates more than once',
+               0b0010 => 'condition never evaluates false (terminates early). loop always iterates only once',
+               0b0011 => 'condition never evaluates false (terminates 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' }
+
+    attr_reader :pass, :once, :twice, :ends, :count
+
+    def initialize(*args)
+      clear
+      super
+    end
+
+    def type
+      :loop
+    end
+
+    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
+
+    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 adding tests for them will probably not reveal bugs
+      #    (1,2)    - loop iterated at least twice but terminated early
+      #    (1)      - loop iterated only once but terminated early
+      100 * ([@pass, @once, @twice, @ends].count{|x| x } / 4.0)
+    end
+
+    def complete?
+      @pass and @once and @twice and @ends
+    end
+
+    def description
+      # weird hack so ForCollectionTag uses its separate constant
+      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
+  end
+
+  class ForCollectionTag < LoopConditionTag
+    STATES = LoopConditionTag::STATES.merge \
+      0b0001 => 'loop always iterates more than once and always terminates early.',
+      0b0010 => 'loop always iterates only once and always terminates early.',
+      0b0011 => 'loop always terminates early',
+      0b0100 => 'loop always passes through'
+
+    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
+
+  class BranchConditionTag < Tag
+    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
+  end
+
+end

data/lib/piggly/compiler/trace.rb

@@ -0,0 +1,91 @@
+module Piggly
+
+  #
+  # Walks the parse tree, attaching Tag values and rewriting source code to ping them.
+  #
+  class TraceCompiler
+    include FileCache
+    include CompilerCache
+
+    attr_accessor :nodes
+
+    def self.compile(tree, args)
+      new(args.fetch(:path)).send(:compile, tree)
+    end
+
+    def self.compiler_path
+      __FILE__
+    end
+
+    def initialize(path)
+      # create unique prefix for each file, prepended to each node's tag
+      @prefix = File.expand_path(path)
+      @tags   = []
+    end
+
+    #
+    # Destructively modifies +tree+ (by attaching tags) and returns the tree
+    # along with the modified source code, and the list of tags. The tag list
+    # is passed along to Profile to compute coverage information. The tree is
+    # passed to PrettyCompiler
+    #
+    def compile(tree)
+      puts "Compiling #{@prefix}"
+      return 'code.sql' => traverse(tree),
+             'tree'     => tree,
+             'tags'     => @tags,
+             'prefix'   => @prefix
+    end
+
+    def traverse(node)
+      if node.terminal? or node.expression?
+        node.source_text
+      else
+        if node.respond_to?(:condStub) and node.respond_to?(:cond)
+          # preserve opening parenthesis and whitespace before injecting code. this way 
+          # IF(test) becomes IF(piggly_cond(TAG, test)) instead of IFpiggly_cond(TAG, (test))
+          pre, cond = node.cond.expr.text_value.match(/\A(\(?[\t\n\r ]*)(.+)\z/m).captures
+          node.cond.source_text = ""
+          
+          @tags << node.cond.tag(@prefix)
+
+          node.condStub.source_text  = "#{pre}piggly_cond($PIGGLY$#{node.cond.tag_id}$PIGGLY$, #{cond})"
+          node.condStub.source_text << traverse(node.cond.tail) # preserve trailing whitespace
+        end
+
+        if node.respond_to?(:bodyStub)
+          if node.respond_to?(:exitStub) and node.respond_to?(:cond)
+            @tags << node.body.tag(@prefix)
+            @tags << node.cond.tag(@prefix)
+
+            # a hack to simulate a loop conditional statement in ForLoop. signal condition was true
+            # when body is executed. when exit stub is reached, signal condition was false
+            node.bodyStub.source_text  = "perform piggly_cond($PIGGLY$#{node.cond.tag_id}$PIGGLY$, true);#{node.indent(:bodySpace)}"
+            node.bodyStub.source_text << "perform piggly_branch($PIGGLY$#{node.body.tag_id}$PIGGLY$);#{node.indent(:bodySpace)}"
+
+            if node.respond_to?(:doneStub)
+              # signal the end of an iteration was reached
+              node.doneStub.source_text  = "#{node.indent(:bodySpace)}perform piggly_signal($PIGGLY$#{node.cond.tag_id}$PIGGLY$, $PIGGLY$@$PIGGLY$);"
+              node.doneStub.source_text << node.body.indent
+            end
+
+            # signal the loop terminated
+            node.exitStub.source_text  = "\n#{node.indent}perform piggly_cond($PIGGLY$#{node.cond.tag_id}$PIGGLY$, false);"
+          elsif node.respond_to?(:body)
+            # no condition:
+            #   BEGIN ... END;
+            #   LOOP ... END;
+            #   ... ELSE ... END;
+            #   CONTINUE label;
+            #   EXIT label;
+            @tags << node.body.tag(@prefix)
+            node.bodyStub.source_text = "perform piggly_branch($PIGGLY$#{node.body.tag_id}$PIGGLY$);#{node.indent(:bodySpace)}"
+          end
+        end
+
+        # traverse children (in which we just injected code)
+        node.elements.map{|e| traverse(e) }.join
+      end
+    end
+  end
+end

data/lib/piggly/compiler.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), *%w[compiler cache])
+require File.join(File.dirname(__FILE__), *%w[compiler tags])
+require File.join(File.dirname(__FILE__), *%w[compiler trace])
+require File.join(File.dirname(__FILE__), *%w[compiler pretty])
+require File.join(File.dirname(__FILE__), *%w[compiler queue])

data/lib/piggly/config.rb

@@ -0,0 +1,43 @@
+module Piggly
+  class Config
+
+    def self.config_accessor(hash)
+      hash.keys.each do |name|
+        self.class.send(:define_method, name) do
+          instance_variable_get("@#{name}") || hash[name]
+        end
+        self.class.send(:define_method, "#{name}=") do |value|
+          instance_variable_set("@#{name}", value)
+        end
+      end
+    end
+
+    config_accessor :cache_root   => File.expand_path(File.join(Dir.pwd, 'piggly', 'cache')),
+                    :report_root  => File.expand_path(File.join(Dir.pwd, 'piggly', 'reports')),
+                    :piggly_root  => PIGGLY_ROOT,
+                    :trace_prefix => 'PIGGLY',
+                    :aggregate    => false
+
+    def self.path(root, file=nil)
+      if file
+        file[%r{^\.\.|^\/|^(?:[A-Z]:)?/}i] ?
+          file : # ../path, /path, or D:\path that isn't relative to root
+          File.join(root, file)
+      else
+        root
+      end
+    end
+
+    def self.mkpath(root, file=nil)
+      if file.nil?
+        FileUtils.makedirs(root)
+        root
+      else
+        path = path(root, file)
+        FileUtils.makedirs(File.dirname(path))
+        path
+      end
+    end
+
+  end
+end

data/lib/piggly/filecache.rb

@@ -0,0 +1,40 @@
+class File
+
+  # True if target file is older (by mtime) than any source file
+  def self.stale?(target, *sources)
+    if exists?(target)
+      oldest = mtime(target)
+      sources.any?{|x| mtime(x) > oldest }
+    else
+      true
+    end
+  end
+
+end
+
+module Piggly
+  module FileCache
+    def self.included(subclass)
+      subclass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # Maps source path to cache path, like /home/user/foo.sql => piggly/cache/#{MD5('/home/user')}/#{BaseClass}/foo.sql
+      def cache_path(file)
+        # up to the last capitalized word of the class name
+        subdir = name[/^(?:.+::)?(.+?)([A-Z][^A-Z]+)?$/, 1]
+        root   = File.join(Config.cache_root, subdir)
+
+        # md5 the full path to prevent collisions
+        full = File.expand_path(file)
+        base = File.basename(full)
+        hash = Digest::MD5.hexdigest(File.dirname(full))
+
+        Config.mkpath(File.join(Config.cache_root, hash, subdir), base)
+      end
+
+    end
+
+  end
+end

data/lib/piggly/installer.rb

@@ -0,0 +1,95 @@
+module Piggly
+  class Installer
+
+    # Compiles the procedures in +file+ with instrumentation and installs them
+    def self.trace_proc(file)
+      # recompile with instrumentation if needed
+      cache = Piggly::TraceCompiler.cache(file)
+
+      # install instrumented code
+      connection.exec cache['code.sql']
+
+      # map tag messages to tag objects
+      Profile.add(file, cache['tags'], cache)
+    end
+
+    # Reinstalls the original stored procedures in +file+
+    def self.untrace_proc(file)
+      connection.exec File.read(file)
+    end
+
+    # Installs necessary instrumentation support
+    def self.install_trace
+      # record trace messages
+      connection.set_notice_processor(&Profile.notice_processor)
+
+      # install tracing functions
+      connection.exec <<-SQL
+        -- signals that a conditional expression was executed
+        CREATE OR REPLACE FUNCTION piggly_cond(message varchar, value boolean)
+          RETURNS boolean AS $$
+        BEGIN
+          IF value THEN
+            RAISE WARNING '#{Config.trace_prefix} % t', message;
+          ELSE
+            RAISE WARNING '#{Config.trace_prefix} % f', message;
+          END IF;
+          RETURN value;
+        END $$ LANGUAGE 'plpgsql' VOLATILE;
+      SQL
+
+      connection.exec <<-SQL
+        -- generic signal
+        CREATE OR REPLACE FUNCTION piggly_signal(message varchar, signal varchar)
+          RETURNS void AS $$
+        BEGIN
+          RAISE WARNING '#{Config.trace_prefix} % %', message, signal;
+        END $$ LANGUAGE 'plpgsql' VOLATILE;
+      SQL
+
+      connection.exec <<-SQL
+        -- signals that a (sub)expression was executed. handles '' and NULL value
+        CREATE OR REPLACE FUNCTION piggly_expr(message varchar, value varchar)
+          RETURNS varchar AS $$
+        BEGIN
+          RAISE WARNING '#{Config.trace_prefix} %', message;
+          RETURN value;
+        END $$ LANGUAGE 'plpgsql' VOLATILE;
+      SQL
+
+      connection.exec <<-SQL
+        -- signals that a (sub)expression was executed. handles all other types
+        CREATE OR REPLACE FUNCTION piggly_expr(message varchar, value anyelement)
+          RETURNS anyelement AS $$
+        BEGIN
+          RAISE WARNING '#{Config.trace_prefix} %', message;
+          RETURN value;
+        END $$ LANGUAGE 'plpgsql' VOLATILE;
+      SQL
+
+      connection.exec <<-SQL
+        -- signals that a branch was taken
+        CREATE OR REPLACE FUNCTION piggly_branch(message varchar)
+          RETURNS void AS $$
+        BEGIN
+          RAISE WARNING '#{Config.trace_prefix} %', message;
+        END $$ LANGUAGE 'plpgsql' VOLATILE;
+      SQL
+    end
+
+    # Uninstalls instrumentation support
+    def self.uninstall_trace
+      connection.set_notice_processor
+      connection.exec "DROP FUNCTION IF EXISTS piggly_cond(varchar, boolean);"
+      connection.exec "DROP FUNCTION IF EXISTS piggly_expr(varchar, varchar);"
+      connection.exec "DROP FUNCTION IF EXISTS piggly_expr(varchar, anyelement);"
+      connection.exec "DROP FUNCTION IF EXISTS piggly_branch(varchar);"
+    end
+
+    # Returns the active PGConn
+    def self.connection
+      ActiveRecord::Base.connection.raw_connection
+    end
+
+  end
+end