piggly 1.2.1 → 2.0.0

data/spec/examples/util/file_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Piggly::Util
+
+  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  
+
+end

data/spec/examples/util/process_queue_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Piggly
+
+  describe Util::ProcessQueue do
+    context "when empty" do
+    end
+
+    context "when less than @max items pending" do
+    end
+
+    context "when more than @max items pending" do
+    end
+  end
+
+end

data/spec/examples/util/thunk_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module Piggly
+
+  describe Util::Thunk do
+
+    context "not already evaluated" do
+      before do
+        @work  = mock('computation')
+        @thunk = Util::Thunk.new { @work.evaluate }
+      end
+
+      it "responds to thunk? without evaluating" do
+        @work.should_not_receive(:evaluate)
+        @thunk.thunk?.should be_true
+      end
+
+      it "evaluates when force! is explicitly called" do
+        @work.should_receive(:evaluate).and_return(@work)
+        @thunk.force!.should == @work
+      end
+
+      it "evaluates when some other method is called" do
+        @work.should_receive(:evaluate).and_return(@work)
+        @work.should_receive(:something).and_return(@work)
+        @thunk.something.should == @work
+      end
+    end
+
+    context "previously evaluated" do
+      before do
+        @work = mock('computation')
+        @work.stub(:evaluate).and_return(@work)
+
+        @thunk = Util::Thunk.new { @work.evaluate }
+        @thunk.force!
+      end
+
+      it "responds to thunk? without evaluating" do
+        @work.should_not_receive(:evaluate)
+        @thunk.thunk?.should be_true
+      end
+
+      it "should not re-evaluate when force! is called" do
+        @work.should_not_receive(:evaluate)
+        @thunk.force!
+      end
+
+      it "should not re-evaluate when some other method is called" do
+        @work.should_not_receive(:evaluate)
+        @work.should_receive(:something).and_return(@work)
+        @thunk.something.should == @work
+      end
+    end
+
+  end
+
+end

data/spec/issues/007_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+module Piggly
+  describe "github issue #7" do
+    include GrammarHelper
+
+    it "can loop over dynamic query results" do
+      node = parse(:stmtForLoop, "FOR r IN EXECUTE 'SELECT * FROM pg_user;' LOOP END LOOP;")
+      node.should be_statement
+
+      cond = node.find{|e| e.named?(:cond) }
+      cond.source_text.should == "EXECUTE 'SELECT * FROM pg_user;' "
+      cond.should be_sql
+    end
+
+    it "can loop over dynamic query results when query contains the word 'LOOP'" do
+      node = parse(:stmtForLoop, "FOR r IN EXECUTE 'SELECT * FROM pg_user.LOOP;' LOOP END LOOP;")
+      node.should be_statement
+
+      cond = node.find{|e| e.named?(:cond) }
+      cond.source_text.should == "EXECUTE 'SELECT * FROM pg_user.LOOP;' "
+      cond.should be_sql
+    end
+  end
+end

data/spec/issues/008_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+module Piggly
+
+  describe "github issue #8" do
+    include GrammarHelper
+
+    context "with declare" do
+      it "doesn't require a space before the := symbol" do
+        node, rest = parse_some(:stmtDeclare, "declare a text:= 10; begin")
+      # node.count{|e| e.assignment? }.should == 1
+        rest.should == "begin"
+      end
+
+      it "doesn't require a space after the := symbol" do
+        node, rest = parse_some(:stmtDeclare, "declare a text :=10;")
+        rest.should == ""
+      # node.count{|e| e.assignment? }.should == 1
+      end
+
+      it "doesn't require a space after the := symbol" do
+        node, rest = parse_some(:stmtDeclare, "declare a text :=10; begin")
+      # node.count{|e| e.assignment? }.should == 1
+        rest.should == "begin"
+      end
+
+      it "allows escaped strings" do
+        node, rest = parse_some(:stmtDeclare, "declare a text :=E'\\001abc'; begin")
+      # node.count{|e| e.assignment? }.should == 1
+        rest.should == "begin"
+      end
+
+      it "allows escaped octal characters" do
+        node, rest = parse_some(:stmtDeclare, "declare a text :=E'\\001abc'; begin")
+      # node.count{|e| e.assignment? }.should == 1
+        rest.should == "begin"
+      end
+    end
+
+    context "without declare" do
+      it "doesn't require a space before the := symbol" do
+        node, rest = parse_some(:statement, "a:= 10; begin")
+        node.count{|e| e.assignment? }.should == 1
+        rest.should == "begin"
+      end
+
+      it "doesn't require a space after the := symbol" do
+        node = parse(:statement, "a :=10;")
+        node.should be_statement
+        node.count{|e| e.assignment? }.should == 1
+      end
+
+      it "doesn't require a space after the := symbol" do
+        node, rest = parse_some(:statement, "a :=10; begin")
+        node.count{|e| e.assignment? }.should == 1
+        rest.should == "begin"
+      end
+
+      it "allows escaped strings" do
+        node, rest = parse_some(:statement, "a :=E'\\001abc'; begin")
+        node.count{|e| e.assignment? }.should == 1
+        rest.should == "begin"
+      end
+
+      it "allows escaped octal characters" do
+        node, rest = parse_some(:statement, "a :=E'\\001abc'; begin")
+        node.count{|e| e.assignment? }.should == 1
+        rest.should == "begin"
+      end
+    end
+
+  end
+end

data/spec/issues/018_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+module Piggly
+  describe "github issue #18" do
+    include GrammarHelper
+
+      it "can parse the example" do
+        body = <<-SQL
+          DECLARE
+            schema TEXT = 'pg_catalog';
+            r RECORD;
+          BEGIN
+            FOR r IN EXECUTE 'SELECT * FROM ' || quote_ident(schema) || 'pg_user;'
+            LOOP
+              -- do nothing
+            END LOOP;
+          END;
+        SQL
+
+        node = parse(:start, body)
+        node.count{|e| e.for? }.should == 1
+        node.count{|e| e.comment? }.should == 1
+      end
+  end
+end

data/spec/spec_helper.rb

@@ -1,25 +1,31 @@
-require 'rubygems'
-require 'spec'
+begin
+  require "spec"
+rescue LoadError
+  require "rspec"
+end
 
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'piggly'))
+require "ostruct"
+require File.expand_path("#{File.dirname(__FILE__)}/../lib/piggly")
 
 #Dir[File.join(File.dirname(__FILE__), 'mocks', '*')].each do |m|
 #  require File.expand_path(m)
 #end
 
+# load runtime dependencies
+Piggly::Parser.parser
+
 module Piggly
   module GrammarHelper
 
     COMMENTS = ["abc defghi", "abc -- abc", "quote's", "a 'str'"]
 
-    SQLWORDS = %w[select insert update delete drop alter
-                  commit begin rollback set start vacuum]
+    SQLWORDS = %w[select insert update delete drop alter commit set start]
 
-    KEYWORDS = %w[as := = alias begin by close constant continue
+    KEYWORDS = %w[as := = alias begin by constant continue
                   cursor debug declare diagnostics else elsif elseif
-                  end exception execute exit fetch for from get if
-                  in info insert into is log loop move not notice
-                  null open or perform raise rename result_oid return
+                  end exception execute exit for from get if
+                  in info insert into is log loop not notice
+                  null or raise rename result_oid return
                   reverse row_count scroll strict then to type warning
                   when while]
 
@@ -45,6 +51,244 @@ module Piggly
       string.replace input
     end
   end
+
+  # mock NodeClass
+  class N < OpenStruct
+    # Constructs a terminal
+    def self.terminal(text, hash = {})
+      new({:text_value => text,
+           :terminal?  => true}.update(hash))
+    end
+
+    def self.keyword(text)
+      terminal(text)
+    end
+
+    # Create a tSpace node
+    def self.space(text = ' ')
+      terminal(text)
+    end
+
+    # Constructs an inline tComment
+    def self.inline_comment(text)
+      terminal("/* #{text} */",
+               :content  => text,
+               :elements => ['/*', " #{text} ", '*/'])
+    end
+
+    # Constructs a rest-of-the-line comment
+    def self.line_comment(text)
+      terminal("-- #{text}\n",
+               :content  => text,
+               :elements => ['--', " #{text}", "\n"])
+    end
+
+    # Constructs a stubNode
+    def self.stub
+      terminal("")
+    end
+
+    # Constructs an expressionUntil-type node
+    def self.expr(code)
+      Node.new :head => ' ',
+               :expr => code,
+               :tail => ' ',
+               :elements => [:head, :expr, :tail]
+    end
+
+    # Constructs a sequence (of statements usually)
+    def self.sequence(*elements)
+      Node.new :elements  => elements
+    end
+
+    # Constructs BEGIN/END block or ELSE block
+    def self.block(declare, statements)
+      Node.new :bodySpace => ' ',
+               :bodyStub  => stub,
+               :body      => sequence(*statements),
+               :elements  => [keyword('begin'), :bodySpace, :bodyStub, :body, keyword('end'), terminal(';')]
+    end
+    
+    # Construct a CASE with a match expression
+    def self.case(expression, *whens)
+      Node.new :expr     => expr(expression),
+               :cases    => whens,
+               :elements => [keyword('case'), space, :expr, :cases, keyword('end'), space, keyword('case'), terminal(';')]
+    end
+
+    # Construct a CASE with no match expression
+    def self.cond(*whens)
+      Node.new :cases    => whens,
+               :elements => [keyword('case'), space, :cases, keyword('end'), space, keyword('case'), terminal(';')]
+    end
+
+    # Constructs a WHEN branch for a CASE with a match expression
+    def self.casewhen(pattern, *statements)
+      Node.new :condSpace => space,
+               :cond      => expr(pattern),
+               :bodySpace => space,
+               :body      => sequence(*statements),
+               :elements  => [keyword('when'), :condSpace, :cond, keyword('then'), :bodySpace, :bodyStub, :body]
+    end
+
+    # Constructs a WHEN branch for a CASE with no match expression
+    def self.condwhen(expression, *statements)
+      Node.new :condSpace => space,
+               :condStub  => stub,
+               :cond      => expr(expression),
+               :bodySpace => space,
+               :body      => sequence(*statements),
+               :elements  => [keyword('when'), :condSpace, :condStub, :cond, keyword('then'), :bodySpace, :bodyStub, :body]
+    end
+
+    # Constructs an IF or ELSIF
+    def self.if(cond, body, other)
+      Node.new :condSpace => nil,
+               :condStub  => stub,
+               :cond      => expr(cond),
+               :bodySpace => ' ',
+               :bodyStub  => stub,
+               :body      => body,
+               :else      => other,
+               :elements  => [keyword('if'), :condSpace, :condStub, :cond, keyword('then'), :bodySpace, :body, :else, keyword('end'), space, keyword('if'), terminal(';')]
+    end
+
+    # Constructs an unconditional LOOP
+    def self.loop(*statements)
+      Node.new :bodySpace => space,
+               :bodyStub  => stub,
+               :body      => sequence(*statements),
+               :doneStub  => stub,
+               :elements  => [keyword('loop'), :bodySpace, :bodyStub, :body, :doneStub, keyword('end'), space, keyword('loop'), terminal(';'), :exitStub]
+    end
+
+    # Constructs a WHILE loop
+    def self.while(condition, *statements)
+      Node.new :condSpace => space,
+               :condStub  => stub,
+               :cond      => expr(condition),
+               :bodySpace => space,
+               :bodyStub  => stub,
+               :body      => sequence(*statements),
+               :exitStub  => stub,
+               :elements  => [keyword('while'), :condSpace, :condStub, :cond, keyword('loop'), :bodySpace, :bodyStub, :body, keyword('end'), space, keyword('loop'), terminal(';')]
+    end
+
+    # Constructs a FOR loop
+    def self.for(idents, iterator, *statements)
+      Node.new :condSpace => space,
+               :cond      => expr(iterator),
+               :bodySpace => space,
+               :bodyStub  => stub,
+               :body      => sequence(*statements),
+               :doneStub  => stub,
+               :exitStub  => stub,
+               :elements  => [keyword('for'), space, idents, keyword('in'), :condSpace, :cond, keyword('loop'), :bodySpace, :bodyStub, :body, :doneStub, keyword('end'), space, keyword('loop'), terminal(';'), :exitStub]
+    end
+
+    # Constructs an EXIT statement
+    def self.exit(condition = nil)
+      if condition
+        Node.new :body      => keyword('exit'),
+                 :condSpace => space,
+                 :condStub  => stub,
+                 :cond      => expr(condition),
+                 :elements  => [:body, space, keyword('when'), :condSpace, :condStub, :cond, terminal(';')]
+      else
+        Node.new :bodyStub  => stub,
+                 :body      => keyword('exit'),
+                 :elements  => [:bodyStub, :body, ';']
+      end
+    end
+
+    # Constructs a CONTINUE statement
+    def self.continue(condition = nil)
+      if condition
+        Node.new :body      => keyword('continue'),
+                 :condSpace => space,
+                 :condStub  => stub,
+                 :cond      => expr(condition),
+                 :elements  => [:body, space, keyword('when'), :condSpace, :condStub, :cond, terminal(';')]
+      else
+        Node.new :bodyStub  => stub,
+                 :body      => keyword('exit'),
+                 :elements  => [:bodyStub, :body, ';']
+      end
+    end
+
+    # Constructs a RETURN statement
+    def self.return(value)
+      Node.new :bodyStub => stubNode,
+               :body     => sequence(keyword('return'), expr(value)),
+               :elements => [:bodyStub, :body]
+    end
+
+    # Constructs a RAISE statement
+    def self.raise(level, message)
+      if level == 'exception'
+        Node.new :bodyStub => stubNode,
+                 :body     => sequence(keyword('raise'), space, keyword('exception'), space, expr(message), terminal(';')),
+                 :elements => [:bodyStub, :body]
+      else
+        Node.new :elements => [keyword('raise'), space, keyword(level), space, expr(message), terminal(';')]
+      end
+    end
+
+    class Node < N
+      def initialize(hash)
+        if elements = hash[:elements]
+          elements.map!{|e| e.is_a?(Symbol) ? hash.fetch(e) : e }
+        end
+
+        super(hash)
+      end
+
+      def text_value
+        @text_value ||= elements.inject('') do |string, e|
+          string << e.text_value
+        end
+      end
+    end
+
+    def initialize(hash)
+      super({:parent      => nil,
+             :terminal?   => false,
+             :expression? => false,
+             :branch?     => false,
+             :block?      => false,
+             :stub?       => false,
+             :loop?       => false,
+             :for?        => false,
+             :while?      => false,
+             :style       => nil,
+             :sourceText  => nil }.update(hash))
+
+      elements.each{|c| c.parent = self } if elements
+    end
+
+    # Recursively compute the byte-offsets within the source text
+    def interval(start=0)
+      @start ||= start
+      @stop  ||= if terminal?
+                   @start + text_value.size
+                 else
+                   # recursively compute intervals
+                   elements.inject(@start) do |prev, e|
+                     e.interval(prev).end
+                   end
+                 end
+      @start...@stop
+    end
+
+    def source_text
+      @source_text || text_value
+    end
+
+    def tap
+      yield self
+      self
+    end
+  end
 end
 
 module Enumerable