piggly-nsd 2.3.3

data/lib/piggly/util/process_queue.rb

@@ -0,0 +1,96 @@
+module Piggly
+  module Util
+
+    #
+    # Executes blocks in parallel subprocesses
+    #
+    class ProcessQueue
+
+      def self.concurrent=(count)
+        @concurrent = count
+      end
+
+      def self.concurrent
+        @concurrent || 1
+      end
+
+      def initialize(concurrent = self.class.concurrent)
+        @concurrent, @items = concurrent, []
+      end
+
+      def concurrent=(value)
+        @concurrent = value
+      end
+
+      def size
+        @items.size
+      end
+
+      def queue(&block)
+        @items << block
+      end
+
+      alias add queue
+
+      def execute
+        # Test if fork is supported
+        forkable =
+          begin
+            Process.wait(Process.fork { exit! 60 })
+            raise unless $?.exitstatus.to_i == 60
+            true
+          rescue Exception
+            false
+          end
+
+        if forkable
+          concurrently
+        else
+          serially
+        end
+      end
+
+    protected
+
+      def serially
+        $stderr.puts "ProcessQueue running serially"
+
+        while block = @items.shift
+          block.call
+        end
+      end
+
+      def concurrently
+        $stderr.puts "ProcessQueue running concurrently"
+        active = 0
+
+        # enable enterprise ruby feature
+        GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly=)
+
+        while block = @items.shift
+          if active >= @concurrent
+            pid = Process.wait
+            active -= 1
+          end
+
+          # use exit! to avoid auto-running any test suites
+          Process.fork do
+            begin
+              block.call
+              exit! 0
+            rescue Exception
+              $stderr.puts $!
+              $stderr.puts "\t" + $!.backtrace.join("\n\t")
+              exit! 1
+            end
+          end
+
+          active += 1
+        end
+
+        Process.waitall
+      end
+
+    end
+  end
+end

data/lib/piggly/util/thunk.rb

@@ -0,0 +1,39 @@
+module Piggly
+  module Util
+
+    # @todo: Ruby 1.9 BasicObject
+    begin
+      BlankSlate
+    rescue NameError
+      require "piggly/util/blankslate"
+    end
+
+    #
+    # Wraps a computation and delays its evaluation until
+    # a message is sent to it. Computation can be forced by
+    # calling `force!`
+    #
+    class Thunk < BlankSlate
+      def initialize(&block)
+        @block = block
+      end
+
+      def force!
+        unless @block.nil?
+          @value = @block.call
+          @block = nil
+        end
+
+        @value
+      end
+
+      def thunk?
+        true
+      end
+
+      def method_missing(name, *args, &block)
+        force!.send(name, *args, &block)
+      end
+    end
+  end
+end

data/lib/piggly/util.rb

@@ -0,0 +1,9 @@
+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/version.rb

@@ -0,0 +1,15 @@
+module Piggly
+  module VERSION
+    MAJOR = 2
+    MINOR = 3
+    TINY  = 3
+
+    RELEASE_DATE = "2025-12-12"
+  end
+
+  class << VERSION
+    def to_s
+      [VERSION::MAJOR, VERSION::MINOR, VERSION::TINY].join(".")
+    end
+  end
+end

data/lib/piggly.rb

@@ -0,0 +1,20 @@
+require "erb"
+require "yaml"
+require "optparse"
+require "fileutils"
+require "digest/md5"
+require "set"
+
+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/spec/examples/compiler/cacheable_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+module Piggly
+
+=begin
+  describe Util::Cacheable do
+    before do
+      @compiler = Class.new { include Piggly::Util::Cacheable }
+      @compiler.stub(:name).and_return('TestCompiler')
+    end
+
+    describe "stale?" do
+      it "compares cache_path with source path and cache_sources" do
+        @compiler.stub(:cache_sources).
+          and_return(%w(parser.rb grammar.tt nodes.rb))
+
+        @compiler.should_receive(:cache_path).
+          with('source.sql').
+          and_return('source.cache')
+
+        Util::File.should_receive(:stale?).
+          with('source.cache', 'source.sql', 'parser.rb', 'grammar.tt', 'nodes.rb')
+
+        @compiler.stale?('source.sql')
+      end
+    end
+
+    describe "cache" do
+      before do
+        @procedure = mock('procedure')
+        @procedure.stub(:source_path).and_return('source path')
+        @procedure.stub(:source).and_return('SOURCE CODE')
+        @procedure.stub(:name).and_return('f')
+      end
+
+      context "when cache is stale" do
+        before do
+          @compiler.should_receive(:stale?).
+            and_return(true)
+
+          File.should_receive(:read).
+            with(@procedure.source_path).
+            and_return(@procedure.source)
+        end
+
+        it "parses the procedure source" do
+          @compiler.stub(:compile).
+            and_return(mock('result').as_null_object)
+          Compiler::Cacheable::CacheDirectory.stub(:lookup).
+            and_return(mock('cache').as_null_object)
+
+          Parser.should_receive(:parse).
+            with(@procedure.source)
+
+          @compiler.cache(@procedure)
+        end
+
+        it "passes the parse tree and transient arguments to the compiler" do
+          tree  = mock('parse tree').as_null_object
+          args  = %w(a b c)
+          block = lambda{|a,b| b }
+
+          Parser.stub(:parse).and_return(tree)
+          Compiler::Cacheable::CacheDirectory.stub(:lookup).
+            and_return(mock('cache').as_null_object)
+
+          # calling cache method below should pass the parse tree plus any
+          # arguments given to cache along to the abstract 'compile' method
+          @compiler.should_receive(:compile).
+            with(tree, *args.push(block)).
+            and_return(mock('result').as_null_object)
+
+          @compiler.cache(@procedure, *args, &block)
+        end
+
+        it "updates the cache with the results from the compiler" do
+          cache  = mock('cache')
+          result = mock('result')
+
+          Parser.stub(:parse).
+            and_return(mock('parse tree').as_null_object)
+          @compiler.should_receive(:compile).
+            # with parse tree
+            and_return(result)
+
+          Compiler::Cacheable::CacheDirectory.should_receive(:lookup).
+            and_return(cache)
+          cache.should_receive(:replace).
+            with(result)
+
+          @compiler.cache(@procedure)
+        end
+
+        it "returns the cache object" do
+          Parser.stub(:parse).
+            and_return(mock('parse tree').as_null_object)
+          @compiler.should_receive(:compile).
+            and_return(mock('result'))
+
+          cache = mock('cache')
+          cache.stub(:replace)
+
+          Compiler::Cacheable::CacheDirectory.should_receive(:lookup).
+            and_return(cache)
+          
+          @compiler.cache(@procedure).should == cache
+        end
+      end
+
+      context "when cache is fresh" do
+        before do
+          @compiler.should_receive(:stale?).
+            and_return(false)
+        end
+
+        it "returns the cached results from disk" do
+          cache = mock('cache')
+          
+          Compiler::Cacheable::CacheDirectory.should_receive(:lookup).
+            and_return(cache)
+          
+          @compiler.cache(@procedure).should == cache
+        end
+      end
+    end
+  end
+
+  describe Compiler::Cacheable::CacheDirectory do
+    before do
+      @cache = Compiler::Cacheable::CacheDirectory.new('directory-path')
+    end
+
+    describe "[]=" do
+      it "stores the new entry" do
+        @cache.stub(:write)
+        @cache[:foo] = 'data'
+        @cache[:foo].should == 'data'
+        @cache['foo'].should == 'data'
+      end
+
+      it "writes through to disk" do
+        @cache.should_receive(:write).
+          with('foo' => 'data')
+        @cache['foo'] = 'data'
+      end
+    end
+
+    describe "update" do
+      it "stores new entries" do
+        @cache.stub(:write)
+        @cache.update(:abc => 'abacus', :xyz => 'xylophone')
+        @cache[:abc].should == 'abacus'
+        @cache[:xyz].should == 'xylophone'
+        @cache['abc'].should == 'abacus'
+        @cache['xyz'].should == 'xylophone'
+      end
+
+      it "stores updated entries"
+      it "writes through to disk"
+    end
+
+    describe "replace" do
+      it "stores new entries"
+      it "stores updated entries"
+      it "removes previous entries"
+      it "writes through to disk"
+    end
+
+    describe "clear" do
+      it "removes all entries"
+      it "writes through to disk"
+    end
+
+    describe "[]" do
+      context "when entry is not already in memory" do
+        it "reads the entry from disk"
+        it "stores the entry in memory"
+        it "returns the associated value"
+      end
+
+      context "when entry is already in memory" do
+        it "does not read the entry from disk"
+        it "returns the associated value"
+      end
+    end
+
+  end
+=end
+
+end

data/spec/examples/compiler/report_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Piggly
+
+  describe Compiler::CoverageReport do
+    describe "compile" do
+      context "when trace cache is stale" do
+        it "does not request the trace compiler output"
+        it "returns nil"
+      end
+
+      context "when trace cache is fresh" do
+        it "recurses the children of non-terminal node"
+        it "does not recurse terminal nodes"
+
+        it "marks tagged terminal nodes"
+        it "does not mark untagged terminal nodes"
+
+        it "marks tagged non-terminal nodes"
+        it "does not mark untagged non-terminal nodes"
+      end
+    end
+  end
+
+end

data/spec/examples/compiler/trace_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'ostruct'
+
+module Piggly
+
+=begin
+describe Compiler::Trace, "with terminal root node" do
+  before do
+    @tree     = N.terminal('code')
+    @compiler = Compiler::Trace.new('file.sql')
+  end
+
+  it "compiles to original terminal" do
+    code, _ = @compiler.compile(@tree)
+    code.should eql('code')
+  end
+
+  it "compiles to single block sequence" do
+    code, data = @compiler.compile(@tree)
+    blocks = data[:blocks].flatten
+
+    blocks.size.should eql(1)
+    blocks.first.should eql([:root, 0..code.size - 1])
+  end
+end
+
+describe Compiler::Trace, "with regular root node" do
+  before do
+    @tree = N.node N.terminal('statement'),
+                   N.terminal('statement'),
+                   N.node(N.terminal('statement'),
+                          N.terminal('statement')),
+                   N.terminal('statement'),
+                   N.terminal('statement')
+    @compiler = Compiler::Trace.new('file.sql')
+  end
+
+  it "compiles" do
+    code, _ = @compiler.compile(@tree)
+    code.should eql('statement' * 6)
+  end
+
+  it "flattens" do
+    code, data = @compiler.compile(@tree)
+    blocks  = data[:blocks].flatten
+    blocks.size.should eql(1)
+
+    # compiled code has no added instrumentation
+    blocks.first.should eql([:root, 0..code.size - 1])
+  end
+end
+
+describe Compiler::Trace, "root node contains branches" do
+  before do
+    @tree = N.node N.node(N.terminal('statement-1;'),         N.space),
+                   N.branch(N.node(N.terminal('if-1'),        N.space),
+                            N.node(N.terminal('condition'),   N.space),
+                            N.node(N.terminal('then'),        N.space),
+                            N.node(N.terminal('consequence'), N.space),
+                            N.node(N.terminal('end if;'),     N.space)),
+                   N.node(N.terminal('statement-2;'),         N.space),
+                   N.branch(N.node(N.terminal('if-2'),        N.space),
+                            N.node(N.terminal('condition'),   N.space),
+                            N.node(N.terminal('then'),        N.space),
+                            N.node(N.terminal('consequence'), N.space),
+                            N.terminal('end if;'))
+    @tree.interval # force computation
+    @compiler = Compiler::Trace.new('file.sql')
+  end
+
+  it "flattens" do
+    code, data = @compiler.compile(@tree)
+    blocks = data[:blocks].flatten
+
+    first = blocks.select{|id, interval| id == 1 }.map{|e| e.last }
+    first.size.should eql(1)
+    'consequence'.size.should eql(first[0].end - first[0].begin)
+
+    second = blocks.select{|id, interval| id == 2 }.map{|e| e.last }
+    second.size.should eql(1)
+    'consequence'.size.should eql(second[0].end - second[0].begin)
+
+    roots = blocks.select{|id, interval| id == :root }.map{|e| e.last }
+    roots.size.should eql(3) # root <consequence> root <consequence> root
+
+    # compiled code size = source code size + instrumentation code size
+    roots.first.begin.should eql(0)
+    roots.last.end.should eql(code.size - ("raise notice 'PIGGLY-file.sql-n';\n".size * 2) - 1)
+  end
+
+  it "compiles" do
+    code, _ = @compiler.compile(@tree)
+    code.should eql(%w[statement-1;
+                       if-1 condition then
+                         raise notice 'PIGGLY-file.sql-1';\n
+                         consequence
+                       end if;
+                       statement-2;
+                       if-2 condition then
+                         raise notice 'PIGGLY-file.sql-2';\n
+                         consequence
+                       end if;].join(' ').gsub('\n ', "\n"))
+  end
+
+  it "prepends Config.trace_prefix to raise statements" do
+    Config.trace_prefix = 'PREFIX'
+    
+    code, _ = @compiler.compile(@tree)
+    code.should eql(%w[statement-1;
+                       if-1 condition then
+                         raise notice 'PREFIX-file.sql-1';\n
+                         consequence
+                       end if;
+                       statement-2;
+                       if-2 condition then
+                         raise notice 'PREFIX-file.sql-2';\n
+                         consequence
+                       end if;].join(' ').gsub('\n ', "\n"))
+  end
+end
+=end
+
+end

data/spec/examples/config_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module Piggly
+
+describe Config do
+  before do
+    @config = Config.new
+  end
+
+  it "has class accessors and mutators" do
+    expect(@config).to respond_to(:cache_root)
+    expect(@config).to respond_to(:cache_root=)
+    expect(@config).to respond_to(:report_root)
+    expect(@config).to respond_to(:report_root=)
+    expect(@config).to respond_to(:trace_prefix)
+    expect(@config).to respond_to(:trace_prefix=)
+  end
+
+  it "has default values" do
+  # @config.cache_root = nil
+    expect(@config.cache_root).not_to be_nil
+    expect(@config.cache_root).to match(/cache$/)
+
+  # @config.report_root = nil
+    expect(@config.report_root).not_to be_nil
+    expect(@config.report_root).to match(/reports$/)
+
+  # @config.trace_prefix = nil
+    expect(@config.trace_prefix).not_to be_nil
+    expect(@config.trace_prefix).to eq('PIGGLY')
+  end
+  
+  describe "path" do
+    it "doesn't reparent absolute paths" do
+      expect(@config.path('/tmp', '/usr/bin/ps')).to eq('/usr/bin/ps')
+      expect(@config.path('A:/data/tmp', 'C:/USER/tmp')).to eq('C:/USER/tmp')
+      expect(@config.path('/tmp/data', '../data.txt')).to eq('../data.txt')
+    end
+    
+    it "reparents relative paths" do
+      expect(@config.path('/tmp', 'note.txt')).to eq('/tmp/note.txt')
+    end
+    
+    it "doesn't require path parameter" do
+      expect(@config.path('/tmp')).to eq('/tmp')
+    end
+  end
+  
+  describe "mkpath" do
+    it "creates root if doesn't exist" do
+      expect(FileUtils).to receive(:makedirs).with('x/y').once.and_return(true)
+      @config.mkpath('x/y', 'z')
+    end
+
+    it "throws an error on path components that exist as files" do
+      skip "Test requires /etc/passwd to exist (Unix-specific)" if RUBY_PLATFORM =~ /mingw|mswin|windows/i
+      expect { @config.mkpath('/etc/passwd/file') }.to raise_error(Errno::EEXIST)
+    end
+  end
+end
+
+end
+