piggly-nsd 2.3.3

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

data/lib/piggly/task.rb

@@ -0,0 +1,215 @@
+require "rake"
+require "rake/tasklib"
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), ".."))
+require "piggly"
+
+module Piggly
+
+  class AbstractTask < Rake::TaskLib
+    attr_accessor :name,          # Name of the test task
+                  :verbose,
+                  :ruby_opts
+
+    attr_accessor :procedures,    # List of procedure names or regular expressions, match all by default
+                  :cache_root,    # Where to store cache data
+                  :piggly_opts,
+                  :piggly_path    # Path to bin/piggly
+
+    def initialize(name = :piggly)
+      @name        = name
+      @verbose     = false
+      @ruby_opts   = []
+
+      @procedures  = []
+      @cache_root  = nil
+      @piggly_path = File.expand_path("#{File.dirname(__FILE__)}/../../bin/piggly")
+      @piggly_opts = []
+
+      yield self if block_given?
+      define
+    end
+
+  private
+
+    def quote(value)
+      case value
+      when Regexp
+        quote(value.inspect)
+      else
+        %{"#{value}"}
+      end
+    end
+
+  end
+
+  class TraceTask < AbstractTask
+    def initialize(name = :trace)
+      super(name)
+    end
+
+  private
+
+    def define
+      desc 'Trace stored procedures'
+      task @name do
+        RakeFileUtils.verbose(@verbose) do
+          opts  = []
+          opts << "trace"
+          opts.concat(["--cache-root", @cache_root]) if @cache_root
+
+          case @procedures
+          when String then opts.concat(["--name", @procedures])
+          when Regexp then opts.concat(["--name", @procedures.inspect])
+          when Array
+            @procedures.each do |p|
+              case p
+              when String then opts.concat(["--name", p])
+              when Regexp then opts.concat(["--name", p.inspect])
+              end
+            end
+          end
+
+          opts.concat(@piggly_opts)
+        # ruby(opts.join(" "))
+          Command.main(opts)
+        end
+      end
+    end
+  end
+
+  class UntraceTask < AbstractTask
+    def initialize(name = :untrace)
+      super(name)
+    end
+
+  private
+
+    def define
+      desc 'Untrace stored procedures'
+      task @name do
+        RakeFileUtils.verbose(@verbose) do
+        # opts  = @ruby_opts.clone
+        # opts << (@piggly_path ? quote(@piggly_path) : "-S piggly")
+          opts  = []
+          opts << "untrace"
+          opts.concat(["--cache-root", @cache_root]) if @cache_root
+
+          case @procedures
+          when String then opts.concat(["--name", @procedures])
+          when Regexp then opts.concat(["--name", @procedures.inspect])
+          when Array
+            @procedures.each do |p|
+              case p
+              when String then opts.concat(["--name", p])
+              when Regexp then opts.concat(["--name", p.inspect])
+              end
+            end
+          end
+
+          opts.concat(@piggly_opts)
+        # ruby(opts.join(" "))
+          Command.main(opts)
+        end
+      end
+    end
+  end
+
+  class ReportTask < AbstractTask
+    attr_accessor :report_root,   # Where to store reports (default piggly/report)
+                  :accumulate,    # Accumulate coverage from the previous run (default false)
+                  :trace_file
+
+    def initialize(name = :report)
+      @accumulate  = false
+      @trace_file  = nil
+      @report_root = nil
+      super(name)
+    end
+
+  private
+
+    def define
+      desc 'Generate piggly report'
+      task @name do
+        RakeFileUtils.verbose(@verbose) do
+        # opts  = @ruby_opts.clone
+        # opts << (@piggly_path ? quote(@piggly_path) : "-S piggly")
+          opts  = []
+          opts << "report"
+          opts << "--accumulate" if @accumulate
+          opts.concat(["--trace-file",  @trace_file])
+          opts.concat(["--cache-root",  @cache_root]) if @cache_root
+          opts.concat(["--report-root", @report_root]) if @report_root
+
+          case @procedures
+          when String then opts.concat(["--name", @procedures])
+          when Regexp then opts.concat(["--name", @procedures.inspect])
+          when Array
+            @procedures.each do |p|
+              case p
+              when String then opts.concat(["--name", p])
+              when Regexp then opts.concat(["--name", p.inspect])
+              end
+            end
+          end
+
+          opts.concat(@piggly_opts)
+        # ruby(opts.join(" "))
+          Command.main(opts)
+        end
+      end
+    end
+  end
+
+  class TestTask < AbstractTask
+    attr_accessor :test_files,    # List of ruby test files to load
+                  :report_root,   # Where to store reports (default piggly/report)
+                  :accumulate     # Accumulate coverage from the previous run (default false)
+
+    def initialize(name = :piggly)
+      @report_root = nil
+      @test_files  = []
+      @accumulate  = false
+      super(name)
+    end
+
+  private
+
+    def define
+      desc 'Run piggly tests' + (@name == :piggly ? '' : " for #{@name}")
+      task @name do
+        RakeFileUtils.verbose(@verbose) do
+          opts  = @ruby_opts.clone
+          opts << (@piggly_path ? quote(@piggly_path) : "-S piggly")
+          opts << "test"
+          opts << "--accumulate" if @accumulate
+          opts << "--cache-root #{quote @cache_root}" if @cache_root
+          opts << "--report-root #{quote @report_root}" if @report_root
+
+          case @procedures
+          when String then opts << "--name #{quote @procedures}"
+          when Regexp then opts << "--name #{quote @procedures.inspect}"
+          when Array
+            @procedures.each do |p|
+              case p
+              when String then opts << "--name #{quote p}"
+              when Regexp then opts << "--name #{quote p.inspect}"
+              end
+            end
+          end
+
+          opts.concat(@piggly_opts)
+
+          unless (@test_files || []).empty?
+            opts << "--"
+            opts.concat(@test_files.map{|x| quote(x) })
+          end
+
+          ruby(opts.join(" "))
+        end
+      end
+    end
+  end
+
+end

data/lib/piggly/util/blankslate.rb

@@ -0,0 +1,114 @@
+unless defined? BlankSlate
+  #--
+  # Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
+  # All rights reserved.
+
+  # Permission is granted for use, copying, modification, distribution,
+  # and distribution of modified versions of this work as long as the
+  # above copyright notice is included.
+  #++
+
+  ######################################################################
+  # BlankSlate provides an abstract base class with no predefined
+  # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+  # BlankSlate is useful as a base class when writing classes that
+  # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+  #
+  class BlankSlate
+    class << self
+
+      # Hide the method named +name+ in the BlankSlate class.  Don't
+      # hide +instance_eval+ or any method beginning with "__".
+      def hide(name)
+        if instance_methods.include?(name.to_s) and
+          name !~ /^(__|instance_eval)/
+          @hidden_methods ||= {}
+          @hidden_methods[name.to_sym] = instance_method(name)
+          undef_method name
+        end
+      end
+
+      def find_hidden_method(name)
+        @hidden_methods ||= {}
+        @hidden_methods[name] || superclass.find_hidden_method(name)
+      end
+
+      # Redefine a previously hidden method so that it may be called on a blank
+      # slate object.
+      def reveal(name)
+        bound_method = nil
+        unbound_method = find_hidden_method(name)
+        fail "Don't know how to reveal method '#{name}'" unless unbound_method
+        define_method(name) do |*args|
+          bound_method ||= unbound_method.bind(self)
+          bound_method.call(*args)
+        end
+      end
+    end
+
+    instance_methods.each { |m| hide(m) }
+  end
+
+  ######################################################################
+  # Since Ruby is very dynamic, methods added to the ancestors of
+  # BlankSlate <em>after BlankSlate is defined</em> will show up in the
+  # list of available BlankSlate methods.  We handle this by defining a
+  # hook in the Object and Kernel classes that will hide any method
+  # defined after BlankSlate has been loaded.
+  #
+  module Kernel
+    class << self
+      alias_method :blank_slate_method_added, :method_added
+
+      # Detect method additions to Kernel and remove them in the
+      # BlankSlate class.
+      def method_added(name)
+        result = blank_slate_method_added(name)
+        return result if self != Kernel
+        BlankSlate.hide(name)
+        result
+      end
+    end
+  end
+
+  ######################################################################
+  # Same as above, except in Object.
+  #
+  class Object
+    class << self
+      alias_method :blank_slate_method_added, :method_added
+
+      # Detect method additions to Object and remove them in the
+      # BlankSlate class.
+      def method_added(name)
+        result = blank_slate_method_added(name)
+        return result if self != Object
+        BlankSlate.hide(name)
+        result
+      end
+
+      def find_hidden_method(name)
+        nil
+      end
+    end
+  end
+
+  ######################################################################
+  # Also, modules included into Object need to be scanned and have their
+  # instance methods removed from blank slate.  In theory, modules
+  # included into Kernel would have to be removed as well, but a
+  # "feature" of Ruby prevents late includes into modules from being
+  # exposed in the first place.
+  #
+  class Module
+    alias blankslate_original_append_features append_features
+    def append_features(mod)
+      result = blankslate_original_append_features(mod)
+      return result if mod != Object
+      instance_methods.each do |name|
+        BlankSlate.hide(name)
+      end
+      result
+    end
+  end
+end

data/lib/piggly/util/cacheable.rb

@@ -0,0 +1,19 @@
+module Piggly
+  module Util
+    module Cacheable
+
+      def cache_path(file)
+        # Up to the last capitalized word of the class name
+        classdir = self.class.name[/^(?:.+::)?(.+?)([A-Z][^A-Z]+)?$/, 1]
+
+        # md5 the full path to prevent collisions
+        full = ::File.expand_path(file)
+        hash = Digest::MD5.hexdigest(::File.dirname(full))
+        base = ::File.basename(file)
+
+        @config.mkpath(::File.join(@config.cache_root, classdir), base)
+      end
+
+    end
+  end
+end

data/lib/piggly/util/enumerable.rb

@@ -0,0 +1,44 @@
+module Piggly
+  module Util
+    module Enumerable
+
+      # Count number of elements, optionally filtered by a block
+      def self.count(enum)
+        if block_given?
+          enum.inject(0){|count,e| yield(e) ? count + 1 : count }
+        else
+          enum.length
+        end
+      end
+
+      # Compute sum of elements, optionally transformed by a block
+      def self.sum(enum, default = 0, &block)
+        enum = enum.to_a
+        return default if enum.empty?
+
+        head, *tail = enum
+
+        if block_given?
+          tail.inject(yield(head)){|sum,e| sum + yield(e) }
+        else
+          tail.inject(head){|sum,e| sum + e }
+        end
+      end
+
+      # Collect an elements into disjoint sets, grouped by result of the block
+      def self.group_by(enum, collection = Hash.new{|h,k| h[k] = [] })
+        enum.inject(collection) do |hash, item|
+          hash[yield(item)] << item
+          hash
+        end
+      end
+
+      def self.index_by(enum, collection = Hash.new)
+        enum.inject(collection) do |hash, item|
+          hash.update(yield(item) => item)
+        end
+      end
+
+    end
+  end
+end

data/lib/piggly/util/file.rb

@@ -0,0 +1,17 @@
+module Piggly
+  module Util
+    module File
+
+      # True if target file is older (by mtime) than any source file
+      def self.stale?(target, *sources)
+        if ::File.exist?(target)
+          oldest = ::File.mtime(target)
+          sources.any?{|x| ::File.mtime(x) > oldest }
+        else
+          true
+        end
+      end
+
+    end
+  end
+end