piggly 1.2.1 → 2.0.0

data/spec/{grammar → examples/grammar}/statements/assignment_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require 'spec_helper'
 
 module Piggly
 
@@ -6,13 +6,13 @@ module Piggly
     include GrammarHelper
 
     describe "assignment statements" do
-      it "parses successfully" do
+      it "parse successfully" do
         node = parse(:statement, "a := 10;")
-        node.should be_a(Statement)
-        node.count{|e| e.is_a? Assignment }.should == 1
-        node.count{|e| e.is_a? Assignable }.should == 1
-        node.find{|e| e.named? :lval }.should be_a(Assignable)
-        node.find{|e| e.named? :rval }.should be_a(Expression)
+        node.should be_statement
+        node.count{|e| e.assignment? }.should == 1
+
+        node.find{|e| e.named? :lval }.should be_a(Parser::Nodes::Assignable)
+        node.find{|e| e.named? :rval }.should be_expression
       end
 
       it "must end with a semicolon" do
@@ -22,18 +22,18 @@ module Piggly
 
       it "can use := or =" do
         a = parse(:statement, "a := 10;")
-        a.should be_a(Statement)
-        a.count{|e| e.is_a? Assignment }.should == 1
+        a.should be_statement
+        a.count{|e| e.assignment? }.should == 1
 
         b = parse(:statement, "a = 10;")
-        b.should be_a(Statement)
-        b.count{|e| e.is_a? Assignment }.should == 1
+        b.should be_statement
+        b.count{|e| e.assignment? }.should == 1
       end
 
       it "can assign strings" do
         node = parse(:statement, "a := 'string';")
         rval = node.find{|e| e.named? :rval }
-        rval.count{|e| e.is_a? TString }.should == 1
+        rval.count{|e| e.string? }.should == 1
       end
 
       it "can assign value expressions containing comments" do
@@ -42,14 +42,14 @@ module Piggly
          'a := 10 /* comment */ + 10;'].test_each do |s|
           node = parse(:statement, s)
           rval = node.find{|e| e.named? :rval }
-          rval.count{|e| e.is_a? TComment }.should == 1
+          rval.count{|e| e.comment? }.should == 1
         end
       end
 
       it "can assign value expressions containing strings" do
         node = parse(:statement, "a := 'Hello,' || space || 'world';")
         rval = node.find{|e| e.named? :rval }
-        rval.count{|e| e.is_a? TString }.should == 2
+        rval.count{|e| e.string? }.should == 2
       end
 
       it "can assign value expressions containing comments and strings" do
@@ -62,7 +62,7 @@ module Piggly
                 GROUP BY /* pk ; 'abc' */ fk);
         SQL
         rval = node.find{|e| e.named? :rval }
-        rval.count{|e| e.is_a? TString }.should == 2
+        rval.count{|e| e.string? }.should == 2
       end
     end
 

data/spec/examples/grammar/statements/declaration_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Piggly
+
+  describe Parser, "statements" do
+    include GrammarHelper
+
+    describe "single variable declarations" do
+      it "parse successfully" do
+        node = parse(:stmtDeclare, "declare t text;")
+        node.count{|e| e.identifier? }.should == 1
+        node.count{|e| e.datatype? }.should == 1
+      end
+
+      it "allows an initial assignment" do
+        node = parse(:stmtDeclare, "declare a text := 10;")
+      end
+    end
+
+  end
+end

data/spec/{grammar → examples/grammar}/statements/exception_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require 'spec_helper'
 
 module Piggly
   describe Parser, "control structures" do
@@ -8,21 +8,21 @@ module Piggly
       describe "raise" do
         it "parses successfully" do
           node, rest = parse_some(:statement, "RAISE EXCEPTION 'message';")
-          node.should be_a(Statement)
+          node.should be_statement
           rest.should == ''
         end
 
         it "handles exception" do
           node = parse(:statement, "RAISE EXCEPTION 'message';")
-          node.count{|e| e.is_a?(Throw) }.should == 1
-          node.count{|e| e.is_a?(Raise) }.should == 0
+          node.count{|e| e.is_a?(Parser::Nodes::Throw) }.should == 1
+          node.count{|e| e.is_a?(Parser::Nodes::Raise) }.should == 0
         end
 
         it "handles events" do
           %w(WARNING LOG INFO NOTICE DEBUG).each do |event|
             node = parse(:statement, "RAISE #{event} 'message';")
-            node.count{|e| e.is_a?(Throw) }.should == 0
-            node.count{|e| e.is_a?(Raise) }.should == 1
+            node.count{|e| e.is_a?(Parser::Nodes::Throw) }.should == 0
+            node.count{|e| e.is_a?(Parser::Nodes::Raise) }.should == 1
           end
         end
       end
@@ -34,17 +34,17 @@ module Piggly
 
         it "parses successfully" do
           node, rest = parse_some(:statement, @text)
-          node.should be_a(Statement)
+          node.should be_statement
           rest.should == ''
         end
 
         it "has Catch node" do
           node = parse(:statement, @text)
-          catches = node.select{|e| e.is_a?(Catch) }
+          catches = node.select{|e| e.is_a?(Parser::Nodes::Catch) }
           catches.size.should == 2
 
-          catches[0].count{|e| e.named?(:cond) and e.is_a?(Expression) }.should == 1
-          catches[1].count{|e| e.named?(:cond) and e.is_a?(Expression) }.should == 1
+          catches[0].count{|e| e.named?(:cond) and e.expression? }.should == 1
+          catches[1].count{|e| e.named?(:cond) and e.expression? }.should == 1
         end
       end
     end

data/spec/{grammar → examples/grammar}/statements/if_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require 'spec_helper'
 
 module Piggly
 
@@ -14,112 +14,125 @@ module Piggly
 
         it "parses successfully" do
           node, rest = parse_some(:statement, 'IF cond THEN a := 10; END IF;')
-          node.should be_a(Statement)
+          node.should be_statement
           rest.should == ''
         end
 
         it "does not have an Else node" do
           node = parse(:statement, 'IF cond THEN a := 10; END IF;')
-          node.count{|e| e.is_a?(Else) }.should == 0
+          node.count{|e| e.else? }.should == 0
           node.count{|e| e.named?(:else) and not e.empty? }.should == 0
         end
 
         it "has a 'cond' Expression" do
           node = parse(:statement, 'IF cond THEN a := 10; END IF;')
           node.count{|e| e.named?(:cond) }.should == 1
-          node.find{|e| e.named?(:cond) }.should be_a(Expression)
+          node.find{|e| e.named?(:cond) }.should be_expression
         end
 
         it "can have missing body" do
           node = parse(:statement, 'IF cond THEN END IF;')
-          node.count{|e| e.instance_of?(Statement) }.should == 1
+          node.should be_statement
+          node.count{|e| e.if? }.should == 1
+          node.count{|e| e.named?(:cond) }.should == 1
         end
 
         it "can have comment body" do
           node = parse(:statement, 'IF cond THEN /* removed */ END IF;')
-          node.count{|e| e.instance_of?(Statement) }.should == 1
-          node.count{|e| e.instance_of?(TComment) }.should == 1
-          node.find{|e| e.instance_of?(TComment) }.source_text.should == '/* removed */'
+          node.should be_statement
+          node.count{|e| e.if? }.should == 1
+          node.count{|e| e.comment? }.should == 1
+          node.find{|e| e.comment? }.source_text.should == '/* removed */'
         end
 
         it "can have single statement body" do
           node = parse(:statement, 'IF cond THEN a := 10; END IF;')
-          node.count{|e| e.instance_of?(Statement) }.should == 2
+          node.count{|e| e.if? }.should == 1
+          node.count{|e| e.assignment? }.should == 1
         end
 
         it "can have multiple statement body" do
           node = parse(:statement, 'IF cond THEN a := 10; b := 10; END IF;')
-          node.count{|e| e.instance_of?(Statement) }.should == 3
+          node.count{|e| e.if? }.should == 1
+          node.count{|e| e.assignment? }.should == 2
         end
 
         it "can contain comments" do
           node = parse(:statement, "IF cond /* comment */ THEN -- foo\n  NULL; /* foo */ END IF;")
-          node.should be_a(Statement)
-          node.count{|e| e.is_a?(TComment) }.should == 3
+          node.should be_statement
+          node.count{|e| e.comment? }.should == 3
         end
       end
 
       describe "if .. then .. else .. end if" do
         it "parses successfully" do
           node, rest = parse_some(:statement, 'IF cond THEN a := 10; ELSE a := 20; END IF;')
-          node.should be_a(Statement)
+          node.should be_statement
           rest.should == ''
         end
 
         it "has an Else node named 'else'" do
           node = parse(:statement, 'IF cond THEN a := 10; ELSE a := 20; END IF;')
-          node.count{|e| e.named?(:else) and e.is_a?(Else) }.should == 1
+          node.count{|e| e.named?(:else) and e.else? }.should == 1
           node.find{|e| e.named?(:else) }.source_text.should == 'ELSE a := 20; '
         end
 
         it "can have missing else body" do
           node = parse(:statement, 'IF cond THEN a := 10; ELSE END IF;')
-          node.count{|e| e.instance_of?(Statement) }.should == 2
+          node.count{|e| e.if? }.should == 1
+          node.count{|e| e.assignment? }.should == 1
         end
 
         it "can have comment body" do
           node = parse(:statement, 'IF cond THEN a := 10; ELSE /* removed */ END IF;')
-          node.count{|e| e.instance_of?(Statement) }.should == 2
-          node.count{|e| e.is_a?(TComment) }.should == 1
+          node.count{|e| e.if? }.should == 1
+          node.count{|e| e.comment? }.should == 1
+          node.count{|e| e.assignment? }.should == 1
         end
 
         it "can have single statement body" do
           node = parse(:statement, 'IF cond THEN a := 10; ELSE a := 20; END IF;')
-          node.count{|e| e.instance_of?(Statement) }.should == 3
+          node.count{|e| e.if? }.should == 1
+          node.count{|e| e.assignment? }.should == 2
         end
 
         it "can have multiple statement body" do
           node = parse(:statement, 'IF cond THEN a := 10; ELSE a := 20; b := 30; END IF;')
-          node.count{|e| e.instance_of?(Statement) }.should == 4
+          node.count{|e| e.if? }.should == 1
+          node.count{|e| e.assignment? }.should == 3
         end
       end
 
       describe "if .. then .. elsif .. then .. end if" do
         it "parses successfully" do
           node, rest = parse_some(:statement, 'IF cond THEN a := 10; ELSIF cond THEN a := 20; END IF;')
-          node.should be_a(Statement)
+          node.should be_statement
           rest.should == ''
         end
 
         it "can have comment body" do
           node = parse(:statement, 'IF cond THEN a := 10; ELSIF cond THEN /* removed */ END IF;')
-          node.count{|e| e.is_a?(TComment) }.should == 1
-          node.count{|e| e.instance_of?(Statement) }.should == 2
+          node.count{|e| e.if? }.should == 2
+          node.count{|e| e.comment? }.should == 1
+          node.count{|e| e.assignment? }.should == 1
         end
 
         it "can having missing body" do
           node = parse(:statement, 'IF cond THEN a := 10; ELSIF cond THEN END IF;')
-          node.count{|e| e.instance_of?(Statement) }.should == 2
+          node.count{|e| e.if? }.should == 2
+          node.count{|e| e.assignment? }.should == 1
         end
 
         it "can have single statement body" do
           node = parse(:statement, 'IF cond THEN a := 10; ELSIF cond THEN a := 20; END IF;')
-          node.count{|e| e.instance_of?(Statement) }.should == 3
+          node.count{|e| e.if? }.should == 2
+          node.count{|e| e.assignment? }.should == 2
         end
 
         it "can have multiple statement body" do
           node = parse(:statement, 'IF cond THEN a := 10; ELSIF cond THEN a := 20; b := 30; END IF;')
-          node.count{|e| e.instance_of?(Statement) }.should == 4
+          node.count{|e| e.if? }.should == 2
+          node.count{|e| e.assignment? }.should == 3
         end
 
         it "can have many elsif branches" do
@@ -134,13 +147,13 @@ module Piggly
           SQL
 
           node.count{|e| e.named?(:cond) }.should == 6
-          node.count{|e| e.is_a?(If) }.should == 6
-          node.count{|e| e.is_a?(If) and e.named?(:else) }.should == 5
+          node.count{|e| e.if? }.should == 6
+          node.count{|e| e.if? and e.named?(:else) }.should == 5
         end
 
         it "has no Else nodes" do
           node = parse(:statement, 'IF cond THEN a := 10; ELSIF cond THEN a := 20; END IF;')
-          node.count{|e| e.is_a?(Else) }.should == 0
+          node.count{|e| e.else? }.should == 0
         end
       end
 
@@ -151,25 +164,25 @@ module Piggly
 
         it "parses successfully" do
           node, rest = parse_some(:statement, @text)
-          node.should be_a(Statement)
+          node.should be_statement
           rest.should == ''
         end
 
         it "has an If node named 'else'" do
           node = parse(:statement, @text)
-          node.count{|e| e.named?(:else) and e.is_a?(If) }.should == 1
-          node.find{|e| e.named?(:else) and e.is_a?(If) }.source_text.should == 'ELSIF cond THEN a := 20; ELSE a := 30; '
+          node.count{|e| e.named?(:else) and e.if? }.should == 1
+          node.find{|e| e.named?(:else) and e.if? }.source_text.should == 'ELSIF cond THEN a := 20; ELSE a := 30; '
         end
 
         it "has an Else node named 'else'" do
           node = parse(:statement, @text)
-          node.count{|e| e.named?(:else) and e.is_a?(Else) }.should == 1
-          node.find{|e| e.named?(:else) and e.is_a?(Else) }.source_text.should == 'ELSE a := 30; '
+          node.count{|e| e.named?(:else) and e.else? }.should == 1
+          node.find{|e| e.named?(:else) and e.else? }.source_text.should == 'ELSE a := 30; '
         end
 
         it "has two If nodes" do
           node = parse(:statement, @text)
-          node.count{|e| e.is_a?(If) }.should == 2
+          node.count{|e| e.if? }.should == 2
         end
       end
     end

data/spec/{grammar → examples/grammar}/statements/loop_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require 'spec_helper'
 
 module Piggly
   describe Parser, "control structures" do
@@ -8,20 +8,20 @@ module Piggly
       describe "for loops" do
         it "can loop over integers" do
           node = parse(:stmtForLoop, 'FOR x IN 0 .. 100 LOOP a := x; END LOOP;')
-          node.should be_a(Statement)
+          node.should be_statement
 
           cond = node.find{|e| e.named?(:cond) }
           cond.source_text.should == '0 .. 100 '
-          cond.should be_a(Expression)
+          cond.should be_expression
         end
 
         it "can loop over query results" do
           node = parse(:stmtForLoop, 'FOR x IN SELECT * FROM table LOOP a := x; END LOOP;')
-          node.should be_a(Statement)
+          node.should be_statement
 
           cond = node.find{|e| e.named?(:cond) }
           cond.source_text.should == 'SELECT * FROM table '
-          cond.should be_a(Sql)
+          cond.should be_sql
         end
       end
 

data/spec/{grammar → examples/grammar}/statements/sql_spec.rb

@@ -1,15 +1,15 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require 'spec_helper'
 
 module Piggly
   describe Parser, "statements" do
     include GrammarHelper
 
     describe "SQL statements" do
-      it "parses successfully" do
+      it "parse successfully" do
         node, rest = parse_some(:statement, 'SELECT id FROM users;')
-        node.should be_a(Statement)
-        node.count{|e| e.is_a?(Sql) }.should == 1
-        node.find{|e| e.is_a?(Sql) }.source_text.should == 'SELECT id FROM users;'
+        node.should be_statement
+        node.count{|e| e.sql? }.should == 1
+        node.find{|e| e.sql? }.source_text.should == 'SELECT id FROM users;'
         rest.should == ''
       end
 
@@ -26,20 +26,20 @@ module Piggly
           WHERE u.disabled -- can't login
             AND u.id = 100;
         SQL
-        sql = node.find{|e| e.is_a?(Sql) }
-        sql.count{|e| e.is_a?(TComment) }.should == 2
+        sql = node.find{|e| e.sql? }
+        sql.count{|e| e.comment? }.should == 2
       end
 
       it "can be followed by comments" do
         node, rest = parse_some(:statement, 'SELECT id FROM users; -- comment')
-        node.find{|e| e.is_a?(Sql) }.source_text == 'SELECT id FROM users;'
+        node.find{|e| e.sql? }.source_text == 'SELECT id FROM users;'
         node.tail.source_text.should == ' -- comment'
         rest.should == ''
       end
       
       it "can be followed by whitespace" do
         node, rest = parse_some(:statement, "SELECT id FROM users;    \n")
-        node.find{|e| e.is_a?(Sql) }.source_text == 'SELECT id FROM users;'
+        node.find{|e| e.sql? }.source_text == 'SELECT id FROM users;'
         node.tail.source_text.should == "    \n"
         rest.should == ''
       end
@@ -51,8 +51,8 @@ module Piggly
           WHERE first_name ILIKE '%a%'
              OR last_name ILIKE '%b%';
         SQL
-        sql = node.find{|e| e.is_a?(Sql) }
-        sql.count{|e| e.is_a?(TString) }.should == 2
+        sql = node.find{|e| e.sql? }
+        sql.count{|e| e.string? }.should == 2
       end
 
       it "can contain strings and comments" do

data/spec/{grammar → examples/grammar}/tokens/comment_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require 'spec_helper'
 
 module Piggly
   describe Parser, "tokens" do
@@ -7,52 +7,52 @@ module Piggly
     describe "comments" do
       it "can begin with -- and terminate at EOF" do
         GrammarHelper::COMMENTS.map{|s| "-- #{s}" }.test_each do |s|
-          parse(:tComment, s).should be_a(TComment)
+          parse(:tComment, s).should be_comment
         end
       end
 
       it "can begin with -- and terminate at line ending" do
         GrammarHelper::COMMENTS.map{|s| "-- #{s}\n" }.test_each do |s|
-          parse(:tComment, s).should be_a(TComment)
+          parse(:tComment, s).should be_comment
         end
 
         GrammarHelper::COMMENTS.map{|s| "-- #{s}\n\n" }.test_each do |s|
           node, rest = parse_some(:tComment, s)
-          node.should be_a(TComment)
+          node.should be_comment
           rest.should == "\n"
         end
 
         GrammarHelper::COMMENTS.map{|s| "-- #{s}\nremaining cruft\n" }.test_each do |s|
           node, rest = parse_some(:tComment, s)
-          node.should be_a(TComment)
+          node.should be_comment
           rest.should == "remaining cruft\n"
         end
       end
 
       it "can be /* c-style */" do
         GrammarHelper::COMMENTS.map{|s| "/* #{s} */" }.test_each do |s|
-          parse(:tComment, s).should be_a(TComment)
+          parse(:tComment, s).should be_comment
         end
       end
 
-      it "terminate after */ marker" do
+      it "terminates after */ marker" do
         GrammarHelper::COMMENTS.map{|s| "/* #{s} */remaining cruft\n" }.test_each do |s|
           node, rest = parse_some(:tComment, s)
-          node.should be_a(TComment)
+          node.should be_comment
           rest.should == "remaining cruft\n"
         end
       end
 
       it "cannot be nested" do
         node, rest = parse_some(:tComment, "/* nested /*INLINE*/ comments */")
-        node.should be_a(TComment)
+        node.should be_comment
         rest.should == " comments */"
 
         node, rest = parse_some(:tComment, "-- nested -- line comments")
-        node.count{|e| e.is_a?(TComment) }.should == 1
+        node.count{|e| e.comment? }.should == 1
         rest.should == ''
       end
     end
 
   end
-end
+end