piggly 1.2.0

data/spec/compiler/tags_spec.rb

@@ -0,0 +1,285 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module Piggly
+
+describe Tag do
+end
+
+describe EvaluationTag do
+end
+
+describe BlockTag do
+end
+
+describe UnconditionalBranchTag do
+end
+
+describe LoopConditionTag do
+end
+
+describe ForCollectionTag do
+  before do
+    @tag = ForCollectionTag.new('for-loop')
+  end
+
+  it "detects state 00 (0b0000)" do
+    # - terminates normally
+    # - pass through
+    # - iterate only once
+    # - iterate more than once
+    @tag.state.should == 0b0000
+  end
+
+  it "detects state 01 (0b0001)" do
+    # - terminates normally
+    # - pass through
+    # - iterate only once
+    # + iterate more than once
+
+    # two iterations
+    @tag.ping('t')
+    @tag.ping('t')
+    @tag.ping('f')
+
+    @tag.state.should == 0b0001
+  end
+
+  it "detects state 02 (0b0010)" do
+    # - terminates normally
+    # - pass through
+    # + iterate only once
+    # - iterate more than once
+
+    # one iteration
+    @tag.ping('t')
+    @tag.ping('f')
+
+    @tag.state.should == 0b0010
+  end
+
+  it "detects state 03 (0b0011)" do
+    # - terminates normally
+    # - pass through
+    # + iterate only once
+    # + iterate more than once
+
+    # one iteration
+    @tag.ping('t')
+    @tag.ping('f')
+
+    # two iterations
+    @tag.ping('t')
+    @tag.ping('t')
+    @tag.ping('f')
+
+    @tag.state.should == 0b0011
+  end
+
+  it "detects state 04 (0b0100)" do
+    # - terminates normally
+    # + pass through
+    # - iterate only once
+    # - iterate more than once
+
+    # zero iterations
+    @tag.ping('f')
+
+    @tag.state.should == 0b0100
+  end
+
+  it "detects state 05 (0b0101)" do
+    # - terminates normally
+    # + pass through
+    # - iterate only once
+    # + iterate more than once
+
+    # zero iterations
+    @tag.ping('f')
+
+    # two iterations
+    @tag.ping('t')
+    @tag.ping('t')
+    @tag.ping('f')
+
+    @tag.state.should == 0b0101
+  end
+
+  it "detects state 06 (0b0110)" do
+    # - terminates normally
+    # + pass through
+    # + iterate only once
+    # - iterate more than once
+
+    # zero iterations
+    @tag.ping('f')
+
+    # one iteration
+    @tag.ping('t')
+    @tag.ping('f')
+
+    @tag.state.should == 0b0110
+  end
+
+  it "detects state 07 (0b0111)" do
+    # - terminates normally
+    # + pass through
+    # + iterate only once
+    # + iterate more than once
+    
+    # zero iterations
+    @tag.ping('f')
+
+    # one iteration
+    @tag.ping('t')
+    @tag.ping('f')
+
+    # two iterations
+    @tag.ping('t')
+    @tag.ping('t')
+    @tag.ping('f')
+
+    @tag.state.should == 0b0111
+  end
+
+  it "detects state 08 (0b1000)" do
+    # + terminates normally
+    # - pass through
+    # - iterate only once
+    # - iterate more than once
+
+    # TODO invalid
+    @tag.ping('@')
+
+    @tag.state.should == 0b1000
+  end
+
+  it "detects state 09 (0b1001)" do
+    # + terminates normally
+    # - pass through
+    # - iterate only once
+    # + iterate more than once
+
+    # iterate twice
+    @tag.ping('t')
+    @tag.ping('@')
+    @tag.ping('t')
+    @tag.ping('@')
+    @tag.ping('f')
+
+    @tag.state.should == 0b1001
+  end
+
+  it "detects state 10 (0b1010)" do
+    # + terminates normally
+    # - pass through
+    # + iterate only once
+    # - iterate more than once
+
+    # iterate once
+    @tag.ping('t')
+    @tag.ping('@')
+    @tag.ping('f')
+
+    @tag.state.should == 0b1010
+  end
+
+  it "detects state 11 (0b1011)" do
+    # + terminates normally
+    # - pass through
+    # + iterate only once
+    # + iterate more than once
+
+    # iterate once
+    @tag.ping('t')
+    @tag.ping('@')
+    @tag.ping('f')
+
+    # iterate twice
+    @tag.ping('t')
+    @tag.ping('@')
+    @tag.ping('t')
+    @tag.ping('@')
+    @tag.ping('f')
+
+    @tag.state.should == 0b1011
+  end
+
+  it "detects state 12 (0b1100)" do
+    # + terminates normally
+    # + pass through
+    # - iterate only once
+    # - iterate more than once
+
+    # TODO invalid
+    @tag.ping('@')
+    @tag.ping('f')
+
+    @tag.state.should == 0b1100
+  end
+
+  it "detects state 13 (0b1101)" do
+    # + terminates normally
+    # + pass through
+    # - iterate only once
+    # + iterate more than once
+
+    # iterate twice
+    @tag.ping('t')
+    @tag.ping('@')
+    @tag.ping('t')
+    @tag.ping('@')
+    @tag.ping('f')
+
+    # pass through
+    @tag.ping('f')
+
+    @tag.state.should == 0b1101
+  end
+
+  it "detects state 14 (0b1110)" do
+    # + terminates normally
+    # + pass through
+    # + iterate only once
+    # - iterate more than once
+    
+    # pass through
+    @tag.ping('f')
+
+    # iterate once
+    @tag.ping('t')
+    @tag.ping('@')
+    @tag.ping('f')
+
+    @tag.state.should == 0b1110
+  end
+
+  it "detects state 15 (0b1111)" do
+    # + terminates normally
+    # + pass through
+    # + iterate only once
+    # + iterate more than once
+
+    # pass through
+    @tag.ping('f')
+
+    # iterate once
+    @tag.ping('t')
+    @tag.ping('@')
+    @tag.ping('f')
+
+    # iterate twice
+    @tag.ping('t')
+    @tag.ping('@')
+    @tag.ping('t')
+    @tag.ping('@')
+    @tag.ping('f')
+
+    @tag.state.should == 0b1111
+  end
+
+end
+
+describe BranchConditionTag do
+end
+
+end

data/spec/compiler/trace_spec.rb

@@ -0,0 +1,173 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '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
+  before do
+    @tree     = N.terminal('code')
+    @compiler = TraceCompiler.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 TraceCompiler, "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 = TraceCompiler.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 TraceCompiler, "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 = TraceCompiler.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/config_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+module Piggly
+
+describe Config do
+  it "has class accessors and mutators" do
+    Config.should respond_to(:cache_root)
+    Config.should respond_to(:cache_root=)
+    Config.should respond_to(:report_root)
+    Config.should respond_to(:report_root=)
+    Config.should respond_to(:trace_prefix)
+    Config.should respond_to(:trace_prefix=)
+  end
+
+  it "has default values" do
+    Config.cache_root = nil
+    Config.cache_root.should_not be_nil
+    Config.cache_root.should =~ /cache$/
+
+    Config.report_root = nil
+    Config.report_root.should_not be_nil
+    Config.report_root.should =~ /reports$/
+
+    Config.trace_prefix = nil
+    Config.trace_prefix.should_not be_nil
+    Config.trace_prefix.should == 'PIGGLY'
+  end
+  
+  describe "path" do
+    it "doesn't reparent absolute paths" do
+      Config.path('/tmp', '/usr/bin/ps').should == '/usr/bin/ps'
+      Config.path('A:/data/tmp', 'C:/USER/tmp').should == 'C:/USER/tmp'
+      Config.path('/tmp/data', '../data.txt').should == '../data.txt'
+    end
+    
+    it "reparents relative paths" do
+      Config.path('/tmp', 'note.txt').should == '/tmp/note.txt'
+    end
+    
+    it "doesn't require path parameter" do
+      Config.path('/tmp').should == '/tmp'
+    end
+  end
+  
+  describe "mkpath" do
+    it "creates root if doesn't exist" do
+      FileUtils.stub!(:makedirs).and_return(true)
+      FileUtils.should_receive(:makedirs).with('x/y').once
+      Config.mkpath('x/y', 'z')
+    end
+
+    it "throws an error on path components that exist as files" do
+      lambda { Config.mkpath('/etc/passwd/file') }.should raise_error(Errno::EEXIST)
+    end
+  end
+end
+
+end

data/spec/filecache_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+module Piggly
+
+  describe File, "cache invalidation" do
+    before do
+      mtime = Hash['a' => 1,  'b' => 2,  'c' => 3]
+      File.stub!(:mtime).and_return{|f| mtime.fetch(f) }
+      File.stub!(:exists?).and_return{|f| mtime.include?(f) }
+    end
+
+    it "invalidates non-existant cache file" do
+      File.stale?('d', 'a').should == true
+      File.stale?('d', 'a', 'b').should == true
+    end
+
+    it "performs validation using file mtimes" do
+      File.stale?('c', 'b').should_not be_true
+      File.stale?('c', 'a').should_not be_true
+      File.stale?('c', 'b', 'a').should_not be_true
+      File.stale?('c', 'a', 'b').should_not be_true
+
+      File.stale?('b', 'a').should_not be_true
+      File.stale?('b', 'c').should be_true
+      File.stale?('b', 'a', 'c').should be_true
+      File.stale?('b', 'c', 'a').should be_true
+
+      File.stale?('a', 'b').should be_true
+      File.stale?('a', 'c').should be_true
+      File.stale?('a', 'b', 'c').should be_true
+      File.stale?('a', 'c', 'b').should be_true
+    end
+
+    it "assumes sources exist" do
+      lambda{ File.stale?('a', 'd') }.should raise_error(StandardError)
+      lambda{ File.stale?('c', 'a', 'x') }.should raise_error(StandardError)
+    end
+  end  
+
+  class ExampleClass; include FileCache; end
+  class ExampleCacheClass; include FileCache; end
+  class PigglyExampleClassHTML; include FileCache; end
+  class PigglyExampleHTMLClass; include FileCache; end
+  class HTMLPiggly; include FileCache; end
+  class ExampleRedefined
+    include FileCache
+    def self.cache_path(file)
+      'redefined'
+    end
+  end
+
+  describe FileCache do
+    it "installs class methods" do
+      ExampleClass.should respond_to(:cache_path)
+    end
+    
+    it "uses class name as cache subdirectory" do
+      Config.cache_root = '/'
+      FileUtils.should_receive(:makedirs).at_least(:once)
+
+      ExampleClass.cache_path('a.ext').should           =~ %r(/Example/a.ext$)
+      ExampleCacheClass.cache_path('a.ext').should      =~ %r(/ExampleCache/a.ext$)
+      PigglyExampleClassHTML.cache_path('a.ext').should =~ %r(/PigglyExampleClassHTML/a.ext$)
+      PigglyExampleHTMLClass.cache_path('a.ext').should =~ %r(/PigglyExampleHTML/a.ext$)
+      HTMLPiggly.cache_path('a.ext').should             =~ %r(/HTML/a.ext$)
+      ExampleRedefined.cache_path('a.ext').should       == 'redefined'
+    end
+  end
+
+end