piggly 1.2.1 → 2.0.0

data/lib/piggly.rb

@@ -1,18 +1,20 @@
-unless defined?(PIGGLY_ROOT)
-  PIGGLY_ROOT = File.join(File.dirname(__FILE__), 'piggly')
-end
-
-require 'fileutils'
-require 'digest/md5'
-require File.join(PIGGLY_ROOT, 'version')
-require File.join(PIGGLY_ROOT, 'config')
-require File.join(PIGGLY_ROOT, 'filecache')
-require File.join(PIGGLY_ROOT, 'compiler')
-require File.join(PIGGLY_ROOT, 'parser')
-require File.join(PIGGLY_ROOT, 'profile')
-require File.join(PIGGLY_ROOT, 'installer')
-require File.join(PIGGLY_ROOT, 'reporter')
-require File.join(PIGGLY_ROOT, 'util')
+require "erb"
+require "yaml"
+require "optparse"
+require "fileutils"
+require "digest/md5"
+require "set"
 
-# used to generate MD5 tags for AST nodes
-$PIGGLY_GENTAG = 0
+module Piggly
+  autoload :VERSION,    "piggly/version"
+  autoload :Config,     "piggly/config"
+  autoload :Command,    "piggly/command"
+  autoload :Compiler,   "piggly/compiler"
+  autoload :Dumper,     "piggly/dumper"
+  autoload :Parser,     "piggly/parser"
+  autoload :Profile,    "piggly/profile"
+  autoload :Installer,  "piggly/installer"
+  autoload :Reporter,   "piggly/reporter"
+  autoload :Tags,       "piggly/tags"
+  autoload :Util,       "piggly/util"
+end

data/lib/piggly/command.rb

@@ -0,0 +1,9 @@
+module Piggly
+  module Command
+    autoload :Base,     "piggly/command/base"
+    autoload :Report,   "piggly/command/report"
+    autoload :Test,     "piggly/command/test"
+    autoload :Trace,    "piggly/command/trace"
+    autoload :Untrace,  "piggly/command/untrace"
+  end
+end

data/lib/piggly/command/base.rb

@@ -0,0 +1,148 @@
+module Piggly
+  module Command
+
+    class Base
+    end
+
+    class << Base
+
+      def main(argv)
+        cmd, argv = command(argv)
+
+        if cmd.nil?
+          abort "usage: #{$0} {test|report|trace|untrace} --help"
+        else
+          cmd.main(argv)
+        end
+      end
+
+    private
+
+      # @return [(Class, Array<String>)]
+      def command(argv)
+        return if argv.empty?
+        head, *tail = argv
+
+        case head.downcase
+        when "report";  [Report,  tail]
+        when "test";    [Test,    tail]
+        when "trace";   [Trace,   tail]
+        when "untrace"; [Untrace, tail]
+        end
+      end
+
+      # @return [PGconn]
+      def connect(config)
+        require "pg"
+        require "erb"
+
+        files = Array(config.database_yml ||
+          %w(piggly/database.yml
+             config/database.yml
+             piggly/database.json
+             config/database.json))
+
+        path = files.find{|x| File.exists?(x) } or
+          raise "No database config files found: #{files.join(", ")}"
+
+        specs =
+          if File.extname(path) == ".json"
+            require "json"
+            JSON.load(ERB.new(IO.read(path)).result)
+          else
+            require "yaml"
+            YAML.load(ERB.new(IO.read(path)).result)
+          end
+
+        spec = (specs.is_a?(Hash) and specs[config.connection_name]) or
+          raise "Database '#{config.connection_name}' is not configured in #{path}"
+
+        PGconn.connect(spec["host"], spec["port"], nil, nil,
+          spec["database"], spec["username"], spec["password"])
+      end
+
+      # @return [Enumerable<SkeletonProcedure>]
+      def filter(config, index)
+        if config.filters.empty?
+          index.procedures
+        else
+          head, _ = config.filters
+
+          start =
+            case head.first
+            when :+; []
+            when :-; index.procedures
+            end
+
+          config.filters.inject(start) do |s, pair|
+            case pair.first
+            when :+
+              s | index.procedures.select(&pair.last)
+            when :-
+              s.reject(&pair.last)
+            end
+          end
+        end
+      end
+
+      def o_accumulate(config)
+        lambda{|x| config.accumulate = x }
+      end
+
+      def o_cache_root(config)
+        lambda{|x| config.cache_root = x }
+      end
+
+      def o_report_root(config)
+        lambda{|x| config.report_root = x }
+      end
+
+      def o_include_paths(config)
+        lambda{|x| config.include_paths.concat(x.split(":")) }
+      end
+
+      def o_database_yml(config)
+        lambda{|x| config.database_yml = x }
+      end
+
+      def o_connection_name(config)
+        lambda{|x| config.connection_name = x }
+      end
+
+      def o_version(config)
+        lambda { puts "piggly #{VERSION} #{VERSION::RELEASE_DATE}"; exit! }
+      end
+
+      def o_dry_run(config)
+        lambda { config.dry_run = true }
+      end
+
+      def o_select(config)
+        lambda do |x|
+          filter =
+            if m = x.match(%r{^/([^/]+)/$})
+              lambda{|p| p.name.to_s.match(m.captures.first) }
+            else
+              lambda{|p| p.name.to_s === x }
+            end
+
+          config.filters << [:+, filter]
+        end
+      end
+
+      def o_reject(config)
+        lambda do |x|
+          filter =
+            if m = x.match(%r{^/([^/]+)/$})
+              lambda{|p| p.name.to_s.match(m.captures.first) }
+            else
+              lambda{|p| p.name.to_s === x }
+            end
+
+          config.filters << [:-, filter]
+        end
+      end
+    end
+
+  end
+end

data/lib/piggly/command/report.rb

@@ -0,0 +1,162 @@
+module Piggly
+  module Command
+
+    #
+    # This command reads a given file (or STDIN) which is expected to contain messages like the
+    # pattern Profile::PATTERN, which is probbaly "WARNING:  PIGGLY 0123456789abcdef".
+    #
+    # Lines in the input that match this pattern are profiled and used to generate a report
+    #
+    class Report < Base
+    end
+
+    class << Report
+      def main(argv)
+        require "pp"
+        io, config = configure(argv)
+
+        profile = Profile.new
+        index   = Dumper::Index.new(config)
+
+        procedures = filter(config, index)
+
+        if procedures.empty?
+          if filters.empty?
+            abort "no stored procedures in the cache"
+          else
+            abort "no stored procedures in the cache matched your criteria"
+          end
+        elsif config.dry_run?
+          puts procedures.map{|p| p.signature }
+          exit 0
+        end
+
+        profile_procedures(config, procedures, profile)
+        clear_coverage(config, profile)
+
+        read_profile(config, io, profile)
+        store_coverage(profile)
+
+        create_index(config, index, procedures, profile)
+        create_reports(config, procedures, profile)
+      end
+
+      # Adds the given procedures to Profile
+      #
+      def profile_procedures(config, procedures, profile)
+        # register each procedure in the Profile
+        compiler = Compiler::TraceCompiler.new(config)
+        procedures.each do |p|
+          result = compiler.compile(p)
+          profile.add(p, result[:tags], result)
+        end
+      end
+
+      # Clear coverage after procedures have been loaded
+      #
+      def clear_coverage(config, profile)
+        unless config.accumulate?
+          puts "clearing previous coverage"
+          profile.clear
+        end
+      end
+
+      # Reads +io+ for lines matching Profile::PATTERN and records coverage
+      #
+      def read_profile(config, io, profile)
+        np = profile.notice_processor(config)
+        io.each{|line| np.call(line) }
+      end
+
+      # Store the coverage Profile on disk
+      #
+      def store_coverage(profile)
+        puts "storing coverage profile"
+        profile.store
+      end
+
+      # Create the report's index.html
+      #
+      def create_index(config, index, procedures, profile)
+        puts "creating index"
+        reporter = Reporter::Index.new(config, profile)
+        reporter.install("resources/piggly.css", "resources/sortable.js", "resources/highlight.js")
+        reporter.report(procedures, index)
+      end
+
+      # Create each procedures' HTML report page
+      #
+      def create_reports(config, procedures, profile)
+        puts "creating reports"
+        queue = Util::ProcessQueue.new
+
+        compiler = Compiler::TraceCompiler.new(config)
+        reporter = Reporter::Procedure.new(config, profile)
+
+        Parser.parser
+
+        procedures.each do |p|
+          queue.add do
+            unless compiler.stale?(p)
+              data = compiler.compile(p)
+              path = reporter.report_path(p.source_path(config), ".html")
+
+              unless profile.empty?(data[:tags])
+                changes = ": #{profile.difference(p, data[:tags])}"
+              end
+
+              puts "reporting coverage for #{p.name}#{changes}"
+            # pp data[:tags]
+            # pp profile[p]
+            # puts
+
+              reporter.report(p)
+            end
+          end
+        end
+
+        queue.execute
+      end
+
+      def configure(argv, config = Config.new)
+        io = $stdin
+        p  = OptionParser.new do |o|
+          o.on("-t", "--dry-run",           "only print the names of matching procedures", &o_dry_run(config))
+          o.on("-s", "--select PATTERN",    "select procedures matching PATTERN", &o_select(config))
+          o.on("-r", "--reject PATTERN",    "ignore procedures matching PATTERN", &o_reject(config))
+          o.on("-c", "--cache-root PATH",   "local cache directory", &o_cache_root(config))
+          o.on("-o", "--report-root PATH",  "report output directory", &o_report_root(config))
+          o.on("-a", "--accumulate",        "accumulate data from the previous run", &o_accumulate(config))
+          o.on("-V", "--version",           "show version", &o_version(config))
+          o.on("-h", "--help",              "show this message") { abort o.to_s }
+          o.on("-f", "--input PATH",        "read trace messages from PATH") do |path|
+            io = if path == "-"
+                   $stdin
+                 else
+                   File.open(path, "rb")
+                 end
+          end
+        end
+
+        begin
+          p.parse! argv
+          
+          if io.eql?($stdin) and $stdin.tty?
+            raise OptionParser::MissingArgument,
+              "stdin must be a pipe, or use --input PATH"
+          end
+
+          return io, config
+        rescue OptionParser::InvalidOption,
+               OptionParser::InvalidArgument,
+               OptionParser::MissingArgument
+          puts p
+          puts
+          puts $!
+          exit! 1
+        end
+      end
+    end
+
+  end
+end

data/lib/piggly/command/test.rb

@@ -0,0 +1,157 @@
+module Piggly
+  module Command
+
+    #
+    # This command handles all the setup and teardown for running Ruby tests, that can
+    # otherwise be accomplished in a more manual fashion, using the other commands. It
+    # assumes that the test files will automatically establish a connection to the correct
+    # database when they are loaded (this is the case for Rails).
+    #
+    module Test
+      class << self
+
+        def main(argv)
+          benchmark do
+            tests, filters = parse_options(argv)
+            profile = Profile.new
+
+            # don't let rspec get these when loading spec files
+            ARGV.clear
+
+            load_tests(tests)
+            Command.connect_to_database
+
+            procedures = dump_procedures(filters)
+
+            if procedures.empty?
+              abort "No stored procedures in the database#{' matched your criteria' if filters.any?}"
+            end
+
+            result =
+              begin
+                trace(procedures)
+                clear_coverage
+                execute_tests
+              ensure
+                untrace(procedures)
+              end
+
+            create_index(procedures)
+            create_reports(procedures)
+            store_coverage
+
+            exit! result # avoid running tests again
+          end
+        end
+
+      private
+
+        def benchmark
+          start = Time.now
+          value = yield
+          puts " > Completed in #{'%0.2f' % (Time.now - start)} seconds"
+          return value
+        end
+
+        #
+        # Parses command-line options
+        #
+        def parse_options(argv)
+          filters = []
+
+          opts = OptionParser.new do |opts|
+            opts.on("-I", "--include PATHS", "Prepend paths to $LOAD_PATH (colon separated list)", &Command.method(:opt_include_path))
+            opts.on("-o", "--report-root PATH", "Report output directory", &Command.method(:opt_report_root))
+            opts.on("-c", "--cache-root PATH", "Local cache directory", &Command.method(:opt_cache_root))
+
+            opts.on("-n", "--name PATTERN", "Trace stored procedures matching PATTERN") do |opt|
+              if m = opt.match(%r{^/(.+)/$})
+                filters << lambda{|p| p.name.match(m.captures.first) }
+              else
+                filters << lambda{|p| p.name === opt }
+              end
+            end
+       
+            opts.on("-a", "--aggregate", "Aggregate data from the previous run", &Command.method(:opt_aggregate))
+            opts.on("-V", "--version", "Show version", &Command.method(:opt_version))
+            opts.on("-h", "--help", "Show this message") do
+              puts opts
+              exit! 0
+            end
+          end
+
+          begin
+            opts.parse! argv
+            raise OptionParser::MissingArgument, "no tests specified" if argv.empty?
+          rescue OptionParser::InvalidOption,
+                 OptionParser::InvalidArgument,
+                 OptionParser::MissingArgument
+            puts opts
+            puts
+            puts $!
+
+            exit! 1
+          end
+
+          test_paths = argv.map{|p| Dir[p] }.flatten.sort
+
+          return test_paths, filters
+        end
+
+        def load_tests(tests)
+          puts "Loading #{tests.size} test files"
+          benchmark { tests.each{|file| load file }}
+        end
+
+        #
+        # Writes all stored procedures in the database to disk
+        #
+        def dump_procedures(filters)
+          Command::Trace.dump_procedures(filters)
+        end
+
+        #
+        # Compiles all the stored procedures on disk and installs them
+        #
+        def trace(procedures)
+          benchmark { Command::Trace.trace(procedures) }
+        end
+
+        def clear_coverage
+          Command::Report.clear_coverage
+        end
+
+        def execute_tests
+          if defined? ::Test::Unit::AutoRunner
+            ::Test::Unit::AutoRunner.run
+          elsif defined? ::RSpec::Core
+            ::Rspec::Core::Runner.run(ARGV, $stderr, $stdout)
+          elsif defined? ::Spec::Runner
+            ::Spec::Runner.run
+          elsif defined? ::MiniTest::Unit
+            ::MiniTest::Unit.new.run(ARGV)
+          else
+            raise "Neither Test::Unit, MiniTest, nor RSpec were detected"
+          end
+        end
+
+        def store_coverage(profile)
+          benchmark { Command::Report.store_coverage(profile) }
+        end
+
+        def untrace(procedures)
+          benchmark { Command::Untrace.untrace(procedures) }
+        end
+
+        def create_index(procedures, profile)
+          benchmark { Command::Report.create_index(procedures, profile) }
+        end
+
+        def create_reports(procedures, profile)
+          benchmark { Command::Report.create_reports(procedures, profile) }
+        end
+
+      end
+    end
+  end
+end