piggly 1.2.1 → 2.0.0

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.exists?(target)
+          oldest = ::File.mtime(target)
+          sources.any?{|x| ::File.mtime(x) > oldest }
+        else
+          true
+        end
+      end
+
+    end
+  end
+end

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/version.rb

@@ -1,15 +1,15 @@
 module Piggly
   module VERSION
-    MAJOR = 1
-    MINOR = 2
-    TINY  = 1
+    MAJOR = 2
+    MINOR = 0
+    TINY  = 0
 
-    STRING = [MAJOR, MINOR, TINY].join('.')
-
-    RELEASE_DATE = '2010-04-22'
+    RELEASE_DATE = "2016-05-03"
+  end
 
-    def self.to_s
-      STRING
+  class << VERSION
+    def to_s
+      [VERSION::MAJOR, VERSION::MINOR, VERSION::TINY].join(".")
     end
   end
 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/{compiler → examples/compiler}/trace_spec.rb

@@ -1,63 +1,13 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require 'spec_helper'
 require 'ostruct'
 
 module Piggly
 
-# MockSyntaxNode
-class N < OpenStruct
-  def self.terminal(value)
-    new :value     => value,
-        :terminal? => true
-  end
-
-  def self.space
-    terminal(' ')
-  end
-
-  def self.node(*children)
-    new :elements => children
-  end
-
-  class Branch < N
-    def elements
-      children[0..-3] + [stubNode] + children[-2..-1]
-    end
-  end
-
-  def self.branch(*children)
-    raise ArgumentError unless children.size > 2
-    Branch.new(:body     => children[-2],
-               :stubNode => terminal(''),
-               :children => children)
-  end
-
-  def initialize(hash)
-    super({:terminal? => false}.update(hash))
-  end
-
-  def trace?
-    respond_to?(:stubNode)
-  end
-
-  def interval(start=0)
-    @start ||= start
-    @stop  ||= if terminal?
-                 @start + value.size
-               else
-                 # recursively compute intervals
-                 elements.inject(@start) do |prev, e|
-                   e.interval(prev).end
-                 end
-               end
-    @start...@stop
-  end
-end
-
 =begin
-describe TraceCompiler, "with terminal root node" do
+describe Compiler::Trace, "with terminal root node" do
   before do
     @tree     = N.terminal('code')
-    @compiler = TraceCompiler.new('file.sql')
+    @compiler = Compiler::Trace.new('file.sql')
   end
 
   it "compiles to original terminal" do
@@ -74,7 +24,7 @@ describe TraceCompiler, "with terminal root node" do
   end
 end
 
-describe TraceCompiler, "with regular root node" do
+describe Compiler::Trace, "with regular root node" do
   before do
     @tree = N.node N.terminal('statement'),
                    N.terminal('statement'),
@@ -82,7 +32,7 @@ describe TraceCompiler, "with regular root node" do
                           N.terminal('statement')),
                    N.terminal('statement'),
                    N.terminal('statement')
-    @compiler = TraceCompiler.new('file.sql')
+    @compiler = Compiler::Trace.new('file.sql')
   end
 
   it "compiles" do
@@ -100,7 +50,7 @@ describe TraceCompiler, "with regular root node" do
   end
 end
 
-describe TraceCompiler, "root node contains branches" do
+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),
@@ -115,7 +65,7 @@ describe TraceCompiler, "root node contains branches" do
                             N.node(N.terminal('consequence'), N.space),
                             N.terminal('end if;'))
     @tree.interval # force computation
-    @compiler = TraceCompiler.new('file.sql')
+    @compiler = Compiler::Trace.new('file.sql')
   end
 
   it "flattens" do