piggly 1.2.0

data/spec/grammar/statements/if_spec.rb

@@ -0,0 +1,178 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+
+  describe Parser, "control structures" do
+    include GrammarHelper
+
+    describe "if statements" do
+      describe "if .. then .. end if" do
+        it "must end with a semicolon" do
+          lambda{ parse(:statement, 'IF cond THEN a := 10; END IF') }.should raise_error
+          lambda{ parse_some(:stmtIf, 'IF cond THEN a := 10; END IF') }.should raise_error
+        end
+
+        it "parses successfully" do
+          node, rest = parse_some(:statement, 'IF cond THEN a := 10; END IF;')
+          node.should be_a(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.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)
+        end
+
+        it "can have missing body" do
+          node = parse(:statement, 'IF cond THEN END IF;')
+          node.count{|e| e.instance_of?(Statement) }.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 */'
+        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
+        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
+        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
+        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)
+          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.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
+        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
+        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
+        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
+        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)
+          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
+        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
+        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
+        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
+        end
+
+        it "can have many elsif branches" do
+          node = parse(:statement, <<-SQL.strip)
+            IF cond THEN a := 10;
+            ELSIF cond THEN a := 20;
+            ELSIF cond THEN a := 30;
+            ELSIF cond THEN a := 40;
+            ELSIF cond THEN a := 50;
+            ELSIF cond THEN a := 60;
+            END IF;
+          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
+        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
+        end
+      end
+
+      describe "if .. then .. elsif .. then .. else .. endif" do
+        before do
+          @text = 'IF cond THEN a := 10; ELSIF cond THEN a := 20; ELSE a := 30; END IF;'
+        end
+
+        it "parses successfully" do
+          node, rest = parse_some(:statement, @text)
+          node.should be_a(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; '
+        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; '
+        end
+
+        it "has two If nodes" do
+          node = parse(:statement, @text)
+          node.count{|e| e.is_a?(If) }.should == 2
+        end
+      end
+    end
+
+  end
+end

data/spec/grammar/statements/loop_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+  describe Parser, "control structures" do
+    include GrammarHelper
+
+    describe "loops" do
+      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)
+
+          cond = node.find{|e| e.named?(:cond) }
+          cond.source_text.should == '0 .. 100 '
+          cond.should be_a(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)
+
+          cond = node.find{|e| e.named?(:cond) }
+          cond.source_text.should == 'SELECT * FROM table '
+          cond.should be_a(Sql)
+        end
+      end
+
+      describe "while loops" do
+      end
+
+      describe "unconditional loops" do
+      end
+
+      describe "continue" do
+      end
+
+      describe "break" do
+      end
+    end
+  end
+end

data/spec/grammar/statements/sql_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+  describe Parser, "statements" do
+    include GrammarHelper
+
+    describe "SQL statements" do
+      it "parses 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;'
+        rest.should == ''
+      end
+
+      it "must end with a semicolon" do
+        lambda{ parse(:statement, 'SELECT id FROM users') }.should raise_error
+        lambda{ parse_some(:statement, 'SELECT id FROM users') }.should raise_error
+      end
+
+      it "can contain comments" do
+        node = parse(:statement, <<-SQL.strip)
+          SELECT INTO user u.id, /* u.name */, p.fist_name, p.last_name
+          FROM users u
+          INNER JOIN people p ON p.id = u.person_id
+          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
+      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.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.tail.source_text.should == "    \n"
+        rest.should == ''
+      end
+
+      it "can contain strings" do
+        node, rest = parse_some(:statement, <<-SQL.strip)
+          SELECT INTO user u.id, u.first_name, u.last_name
+          FROM users u
+          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
+      end
+
+      it "can contain strings and comments" do
+        node = parse(:statement, <<-SQL.strip)
+          a := (SELECT fk, count(*), 'not a statement;'
+                FROM dataset
+                WHERE id > 100 /* filter out 'reserved' range */
+                  AND id < 900 -- shouldn't be a string
+                   OR source_text <> 'alpha /* no comment */;'
+                GROUP BY /* pk ; 'abc' */ fk);
+        SQL
+      end
+
+    end
+  end
+end

data/spec/grammar/tokens/comment_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+
+    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)
+        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)
+        end
+
+        GrammarHelper::COMMENTS.map{|s| "-- #{s}\n\n" }.test_each do |s|
+          node, rest = parse_some(:tComment, s)
+          node.should be_a(TComment)
+          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)
+          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)
+        end
+      end
+
+      it "terminate 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)
+          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)
+        rest.should == " comments */"
+
+        node, rest = parse_some(:tComment, "-- nested -- line comments")
+        node.count{|e| e.is_a?(TComment) }.should == 1
+        rest.should == ''
+      end
+    end
+
+  end
+end

data/spec/grammar/tokens/datatype_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+
+    describe "data types" do
+      it "can consist of a single word" do
+        %w[int boolean char varchar text date timestamp record].test_each do |s|
+          parse(:tType, s).should be_a(TDatatype)
+        end
+      end
+      
+      it "can have parameterized types" do
+        ["numeric(10,2)", "decimal(12,4)", "char(1)", "varchar(100)"].test_each do |s|
+          parse(:tType, s).should be_a(TDatatype)
+        end
+      end
+
+      it "can end in %ROWTYPE" do
+        %w[users%rowtype].test_each do |s|
+          parse(:tType, s).should be_a(TDatatype)
+        end
+      end
+
+      it "can consist of several words" do
+        ["timestamp with time zone", "character varying"].test_each do |s|
+          parse(:tType, s).should be_a(TDatatype)
+        end
+      end
+
+      it "can specify arrays" do
+        ["integer[]", "varchar(10)[]", "numeric(10,2)[]", "timestamp without time zone[]"].test_each do |s|
+          parse(:tType, s).should be_a(TDatatype)
+        end
+      end
+
+      it "can specify multi-dimensional" do
+        ["integer[][]", "char(1)[][]", "character varying[][]"].test_each do |s|
+          parse(:tType, s).should be_a(TDatatype)
+        end
+      end
+
+      it "are terminated by symbol outside of parentheses" do
+        node, rest = parse_some(:tType, "character varying, ")
+        node.should be_a(TDatatype)
+        rest.should == ', '
+      end
+    end
+
+  end
+end

data/spec/grammar/tokens/identifier_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+    
+    describe "identifiers" do
+      it "cannot be a keyword" do
+        GrammarHelper::KEYWORDS.test_each do |s|
+          lambda{ parse(:tIdentifier, s) }.should raise_error
+        end
+      end
+
+      it "can be quoted keyword" do
+        GrammarHelper::KEYWORDS.map{|s| '"' + s + '"' }.test_each do |s|
+          parse(:tIdentifier, s).should be_a(TIdentifier)
+        end
+      end
+
+      it "can begin with a keyword" do
+        GrammarHelper::KEYWORDS.select{|s| s =~ /^[a-z]/i }.map{|s| "#{s}xyz" }.test_each do |s|
+          parse(:tIdentifier, s).should be_a(TIdentifier)
+        end
+
+        GrammarHelper::KEYWORDS.select{|s| s =~ /^[a-z]/i }.map{|s| "#{s}_xyz" }.test_each do |s|
+          parse(:tIdentifier, s).should be_a(TIdentifier)
+        end
+      end
+
+      it "can end with a keyword" do
+        GrammarHelper::KEYWORDS.select{|s| s =~ /^[a-z]/i }.map{|s| "xyz#{s}" }.test_each do |s|
+          parse(:tIdentifier, s).should be_a(TIdentifier)
+        end
+
+        GrammarHelper::KEYWORDS.select{|s| s =~ /^[a-z]/i }.map{|s| "xyz_#{s}" }.test_each do |s|
+          parse(:tIdentifier, s).should be_a(TIdentifier)
+        end
+      end
+
+      it "can be one single character" do
+        %w[_ a b c d e f g h i j k l m n o p q r s t u v w x y z].test_each do |s|
+          parse(:tIdentifier, s).should be_a(TIdentifier)
+        end
+      end
+
+      it "can contain underscores" do
+        %w[_abc abc_ ab_c a_bc ab_cd ab_c_d a_bc_d ab_c_d a_b_c_d a__b__c__d].test_each do |s|
+          parse(:tIdentifier, s).should be_a(TIdentifier)
+        end
+      end
+
+      it "can contain numbers" do
+        parse(:tIdentifier, 'foo9000').should be_a(TIdentifier)
+      end
+    end
+
+  end
+end

data/spec/grammar/tokens/keyword_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+  
+    describe "keywords" do
+      it "parse successfully" do
+        GrammarHelper::KEYWORDS.test_each do |k|
+          parse(:keyword, k).should be_a(TKeyword)
+        end
+      end
+
+      it "cannot have trailing characters" do
+        GrammarHelper::KEYWORDS.each do |k|
+          lambda{ parse(:keyword, "#{k}abc") }.should raise_error
+        end
+      end
+
+      it "cannot have preceeding characters" do
+        GrammarHelper::KEYWORDS.each do |k|
+          lambda{ parse(:keyword, "abc#{k}") }.should raise_error
+        end
+      end
+
+      it "are terminated by symbols" do
+        GrammarHelper::KEYWORDS.test_each do |k|
+          node, rest = parse_some(:keyword, "#{k}+")
+          node.should be_a(TKeyword)
+          rest.should == '+'
+        end
+      end
+
+      it "are terminated by spaces" do
+        GrammarHelper::KEYWORDS.test_each do |k|
+          node, rest = parse_some(:keyword, "#{k} ")
+          node.should be_a(TKeyword)
+          rest.should == ' '
+        end
+      end
+    end
+
+  end
+end

data/spec/grammar/tokens/label_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+
+    describe "labels" do
+      it "must be enclosed in << and >>" do
+        ['', 'a', 'abc', '<< a', 'a >>'].test_each do |s|
+          lambda{ parse(:tLabel, s) }.should raise_error
+        end
+      end
+
+      it "can have space padding" do
+        %w[a abc _].map{|s| "<< #{s} >>" }.test_each do |s|
+          parse(:tLabel, s).should be_a(TLabel)
+        end
+      end
+
+      it "can have no space padding" do
+        %w[a abc _].map{|s| "<<#{s}>>" }.test_each do |s|
+          parse(:tLabel, s).should be_a(TLabel)
+        end
+      end
+
+      it "cannot be multiple unquoted words" do
+        ["<< a b >>", "<< ab cd >>"].test_each do |s|
+          lambda{ parse(:tLabel, s) }.should raise_error
+        end
+      end
+
+      it "can be enclosed in double quotes" do
+        ['<< "a" >>', '<< "a b" >>', '<< "ab cd" >>'].test_each do |s|
+          parse(:tLabel, s).should be_a(TLabel)
+        end
+      end
+    end
+
+  end
+end

data/spec/grammar/tokens/literal_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+ 
+    describe "literals" do
+      it "can be a cast call on a string" do
+        node = parse(:tLiteral, "cast('100.00' as numeric(10, 2))")
+        node = parse(:tLiteral, "cast( '100.00' as numeric (10, 2) )")
+      end
+
+      it "can be a cast call on a number" do
+        node = parse(:tLiteral, "cast(100.00 as character varying(8))")
+        node = parse(:tLiteral, "cast( 100.00 as character varying (8) )")
+      end
+
+      it "can be a ::cast on a string" do
+        node = parse(:tLiteral, "'100'::int")
+        node = parse(:tLiteral, "'100' :: int")
+      end
+
+      it "can be a ::cast on a number" do
+        node = parse(:tLiteral, '100 :: varchar')
+        node = parse(:tLiteral, '100::varchar')
+      end
+    end
+
+  end
+end

data/spec/grammar/tokens/lval_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+
+    describe "l-values" do
+      it "can be a simple identifier" do
+        parse(:lValue, 'id').should be_a(Assignable)
+      end
+
+      it "can be an attribute accessor" do
+        parse(:lValue, 'record.id').should be_a(Assignable)
+        parse(:lValue, 'public.dataset.id').should be_a(Assignable)
+      end
+
+      it "can use quoted attributes" do
+        parse(:lValue, 'record."ID"').should be_a(Assignable)
+        parse(:lValue, '"schema name"."table name"."column name"').should be_a(Assignable)
+      end
+      
+      it "can be an array accessor" do
+        parse(:lValue, 'names[0]').should be_a(Assignable)
+        parse(:lValue, 'names[1000]').should be_a(Assignable)
+      end
+
+      it "can contain comments in array accessors" do
+        node = parse(:lValue, 'names[3 /* comment */]')
+        node.should be_a(Assignable)
+        node.count{|e| e.is_a?(TComment) }
+        
+        node = parse(:lValue, "names[9 -- comment \n]")
+        node.should be_a(Assignable)
+        node.count{|e| e.is_a?(TComment) }
+      end
+
+      it "can be an array accessed by another l-value" do
+        parse(:lValue, 'names[face.id]').should be_a(Assignable)
+      end
+
+      it "can be a nested array access"
+        # names[faces[0].id].id doesn't work because it requires context-sensitivity [faces[0]
+      
+      it "can be a multi-dimensional array access" do
+        parse(:lValue, 'data[10][2][0]').should be_a(Assignable)
+      end
+    end
+
+  end
+end

data/spec/grammar/tokens/number_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+ 
+    describe "numbers" do
+      it "can be an integer in binary notation" do
+        node = parse(:tNumber, "B'0'")
+      end
+
+      it "can be an integer in hexadecimal notation" do
+        node = parse(:tNumber, "X'F'")
+      end
+
+      it "can be an integer in decimal notation" do
+        node = parse(:tNumber, '11223344556677889900')
+      end
+
+      it "can be a real number in decimial notation" do
+        node = parse(:tNumber, '3.2267')
+      end
+
+      it "can be a real number in scientific notation" do
+        node = parse(:tNumber, '1.3e3')
+      end
+
+      it "can be an integer in scientific notation" do
+        node = parse(:tNumber, '5e4')
+      end
+    end
+
+  end
+end