piggly 1.2.1 → 2.0.0

data/lib/piggly/compiler/pretty.rb

@@ -1,67 +0,0 @@
-require File.join(File.dirname(__FILE__), *%w(.. reporter))
-
-module Piggly
-
-  #
-  # Produces HTML output to report coverage of tagged nodes in the tree
-  #
-  class PrettyCompiler
-    include Piggly::HtmlTag
-
-    def self.compile(path, profile)
-      new(profile).send(:compile, path)
-    end
-
-    def initialize(profile)
-      @profile = profile
-    end
-
-  private
-
-    def compile(path)
-      lines = File.read(path).count("\n") + 1
-
-      # recompile (should be cache hit) to identify tagged nodes
-      data = TraceCompiler.cache(path)
-      html = traverse(data['tree'])
-
-      return 'html'  => html,
-             'lines' => 1..lines,
-             'tags'  => data['tags']
-    end
-
-    def traverse(node, string='')
-      if node.terminal?
-        # terminals (leaves) are never tagged
-        if node.style
-          string << '<span class="' << node.style << '">' << e(node.text_value) << '</span>'
-        else
-          string << e(node.text_value)
-        end
-      else
-        # non-terminals never write their text_value
-        node.elements.each do |child|
-          if child.tagged?
-
-            # retreive the profiled tag
-            tag = @profile.by_id[child.tag_id]
-
-            if tag.complete?
-              string << '<span class="' << tag.style << '" id="T' << tag.id << '">'
-            else
-              string << '<span class="' << tag.style << '" id="T' << tag.id << '" title="' << tag.description << '">'
-            end
-
-            traverse(child, string)
-            string << '</span>'
-          else
-            traverse(child, string)
-          end
-        end
-      end
-
-      string
-    end
-
-  end
-end

data/lib/piggly/compiler/queue.rb

@@ -1,46 +0,0 @@
-module Piggly
-
-  #
-  # Executes blocks in parallel subprocesses
-  #
-  class Queue
-
-    def self.children=(value)
-      @children = value
-    end
-
-    # add a compile job to the queue
-    def self.queue(&block)
-      (@queue ||= []) << block
-    end
-
-    def self.child
-      queue { yield }
-    end
-
-    # start scheduler thread
-    def self.start
-      @active     = 0
-      @children ||= 1
-      @queue    ||= []
-
-      while block = @queue.shift
-        if @active >= @children
-          pid = Process.wait
-          @active -= 1
-        end
-
-        # enable enterprise ruby feature
-        GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly=)
-
-        # use exit! to avoid auto-running any test suites
-        pid = Process.fork{ block.call; exit! 0 }
-
-        @active += 1
-      end
-
-      Process.waitall
-    end
-
-  end
-end

data/lib/piggly/compiler/tags.rb

@@ -1,244 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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