piggly 1.2.1 → 2.0.0

data/lib/piggly/task.rb

@@ -1,64 +1,215 @@
-require 'rake'
-require 'rake/tasklib'
+require "rake"
+require "rake/tasklib"
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), ".."))
+require "piggly"
 
 module Piggly
-  class Task < Rake::TaskLib
+
+  class AbstractTask < Rake::TaskLib
     attr_accessor :name,          # Name of the test task
-                  :libs,          # List of paths added to $LOAD_PATH before running tests
-                  :test_files,    # List of ruby test files to load
-                  :proc_files,    # List of pl/pgsql stored procedures to compile
                   :verbose,
-                  :warning,       # Execute ruby -w if true
-                  :report_dir,    # Where to store reports (default piggly/report)
-                  :cache_root,    # Where to store compiler cache (default piggly/cache)
-                  :aggregate,     # Accumulate coverage from the previous run (default false)
+                  :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 (default searches with ruby -S)
+                  :piggly_path    # Path to bin/piggly
 
     def initialize(name = :piggly)
-      @name = name
-      @libs = %w[]
-      @verbose    = false
-      @warning    = false
-      @test_files = []
-      @proc_files = []
-      @ruby_opts  = []
-      @report_dir = 'piggly/report'
-      @cache_root = 'piggly/cache'
-      @piggly_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'piggly'))
-      @piggly_opts = ''
-      @aggregate   = false
+      @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
 
-    # create tasks defined by this task lib
+  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 'Run piggly tests' + (@name == :piggly ? '' : " for #{@name}")
+      desc 'Trace stored procedures'
       task @name do
-        @piggly_opts << "--aggregate" if @aggregate
+        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
-          run_code  = (piggly_path.nil?) ? '-S piggly' : quote(piggly_path)
-          opts = @ruby_opts.clone
-          opts.push "-I#{Array(@libs).join(File::PATH_SEPARATOR)}"
-          opts.push run_code
-          opts.push '-w' if @warning
-
-          ruby opts.join(' ') + ' ' +
-               @piggly_opts   + ' ' +
-               %{-o #{quote @report_dir} } +
-               %{-c #{quote @cache_root} } +
-               proc_files.map{|s| %[-s "#{s}" ] }.join +
-               test_files.map{|f| quote(f) }.join(' ')
+        # 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 quote(string)
-      %{"#{string}"}
+    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.rb

@@ -1,28 +1,9 @@
-module Enumerable
-
-  # Count number of elements, optionally filtered by a block
-  def count
-    if block_given?
-      inject(0){|count, x| count + (yield(x) ? 1 : 0) }
-    else
-      size
-    end
-  end unless method_defined?(:count)
-
-  # Sum elements, optionally transformed by a block
-  def sum(init = 0)
-    if block_given?
-      inject(init){|sum, e| sum + yield(e) }
-    else
-      inject(init){|sum, e| sum + e }
-    end
-  end unless method_defined?(:sum)
-
-  def group_by(collection = Hash.new{|h,k| h[k] = [] })
-    inject(collection) do |hash, item|
-      hash[yield(item)] << item
-      hash
-    end
-  end unless method_defined?(:group_by)
-
+module Piggly
+  module Util
+    autoload :ProcessQueue, "piggly/util/process_queue"
+    autoload :Thunk,        "piggly/util/thunk"
+    autoload :Cacheable,    "piggly/util/cacheable"
+    autoload :Enumerable,   "piggly/util/enumerable"
+    autoload :File,         "piggly/util/file"
+  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