rattler 0.3.0 → 0.4.0

data/spec/rattler/grammar/analysis_spec.rb

@@ -0,0 +1,167 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+include Rattler::Parsers
+
+describe Rattler::Grammar::Analysis do
+
+  subject { described_class.new(grammar.rules) }
+
+  let(:grammar) { Rattler::Grammar::Grammar[rule_set] }
+
+  describe '#recursive?' do
+
+    context 'given a directly recursive rule' do
+
+      let(:rule_set) { RuleSet[
+        Rule[:a, Sequence[Match[/a/], Apply[:a]]]
+      ] }
+
+      it 'returns true' do
+        subject.recursive?(:a).should be_true
+      end
+    end
+
+    context 'given an indirectly recursive rule' do
+
+      let(:rule_set) { RuleSet[
+        Rule[:a, Sequence[Match[/a/], Apply[:b]]],
+        Rule[:b, Sequence[Match[/b/], Apply[:c]]],
+        Rule[:c, Sequence[Match[/c/], Apply[:a]]]
+      ] }
+
+      it 'returns true' do
+        subject.recursive?(:a).should be_true
+      end
+    end
+
+    context 'given a non-recursive rule' do
+
+      let(:rule_set) { RuleSet[
+        Rule[:a, Sequence[Match[/a/], Apply[:b]]],
+        Rule[:b, Sequence[Match[/b/], Apply[:c]]],
+        Rule[:c, Sequence[Match[/c/], Apply[:b]]]
+      ] }
+
+      it 'returns false' do
+        subject.recursive?(:a).should be_false
+      end
+    end
+  end
+
+  describe '#left_recursive?' do
+
+    context 'given a directly left-recursive rule' do
+
+      let(:rule_set) { RuleSet[
+        Rule[:a, Apply[:a]]
+      ] }
+
+      it 'returns true' do
+        subject.left_recursive?(:a).should be_true
+      end
+    end
+
+    context 'given an indirectly left-recursive rule' do
+
+      let(:rule_set) { RuleSet[
+        Rule[:a, Apply[:b]],
+        Rule[:b, Apply[:c]],
+        Rule[:c, Apply[:a]]
+      ] }
+
+      it 'returns true' do
+        subject.left_recursive?(:a).should be_true
+      end
+    end
+
+    context 'given a non-recursive rule' do
+
+      let(:rule_set) { RuleSet[
+        Rule[:a, Apply[:b]],
+        Rule[:b, Apply[:c]],
+        Rule[:c, Apply[:b]]
+      ] }
+
+      it 'returns false' do
+        subject.left_recursive?(:a).should be_false
+      end
+    end
+
+    context 'given a recursive but not left-recursive rule' do
+
+      let(:rule_set) { RuleSet[
+        Rule[:a, Sequence[Match[/a/], Apply[:a]]]
+      ] }
+
+      it 'returns false' do
+        subject.left_recursive?(:a).should be_false
+      end
+    end
+  end
+
+  describe '#referenced_from?' do
+
+    context 'with non-recursive rules' do
+
+      let(:rule_set) { RuleSet[
+        Rule[:a, Apply[:b]],
+        Rule[:b, Apply[:c]],
+        Rule[:c, Match[/a/]],
+        Rule[:d, Match[/b/]]
+      ] }
+
+      context 'given a rule name and itself' do
+        it 'returns false' do
+          subject.referenced_from?(:a, :a).should be_false
+        end
+      end
+
+      context 'given a directly referenced rule name' do
+        it 'returns true' do
+          subject.referenced_from?(:a, :b).should be_true
+        end
+      end
+
+      context 'given an indirectly referenced rule name' do
+        it 'returns true' do
+          subject.referenced_from?(:a, :c).should be_true
+        end
+      end
+
+      context 'given a non-referenced rule name' do
+        it 'returns false' do
+          subject.referenced_from?(:a, :d).should be_false
+        end
+      end
+    end
+
+    context 'with recursive rules' do
+
+      let(:rule_set) { RuleSet[
+        Rule[:a, Apply[:a]],
+        Rule[:b, Apply[:c]],
+        Rule[:c, Apply[:b]]
+      ] }
+
+      context 'given a directly recursive rule name and itself' do
+        it 'returns true' do
+          subject.referenced_from?(:a, :a).should be_true
+        end
+      end
+
+      context 'given an indirectly recursive rule name and itself' do
+        it 'returns true' do
+          subject.referenced_from?(:b, :b).should be_true
+        end
+      end
+
+      context 'given a referenced rule name' do
+        it 'returns true' do
+          subject.referenced_from?(:b, :c).should be_true
+        end
+      end
+    end
+
+  end
+
+end

data/spec/rattler/grammar/grammar_parser_spec.rb

@@ -6,282 +6,272 @@ describe Rattler::Grammar::GrammarParser do
   include Rattler::Util::ParserSpecHelper
 
   let :posix_names do
-    %w{alnum alpha blank cntrl digit graph lower print punct space upper xdigit word}
+    %w{alnum alpha blank cntrl digit graph lower print punct space upper xdigit}
   end
 
-  it 'skips normal whitespace' do
-    parsing("  \n\t foo").as(:identifier).should result_in('foo').at(8)
-  end
-
-  it 'skips comments' do
-    parsing("\n# a comment\n\t foo").as(:identifier).
-    should result_in('foo').at(18)
-  end
-
-  describe '#match(:identifier)' do
-    it 'recognizes identifiers' do
-      parsing(' fooBar ').as(:identifier).should result_in('fooBar').at(7)
-      parsing(' FooBar ').as(:identifier).should result_in('FooBar').at(7)
-      parsing(' EO ').as(:identifier).should result_in('EO').at(3)
-      parsing(' EOFA ').as(:identifier).should result_in('EOFA').at(5)
-    end
+  describe '#match(:expression)' do
 
-    it 'does not recognize EOF as identifier' do
-      parsing('EOF').as(:identifier).should fail
-    end
-  end
+    context 'given a string literal' do
 
-  describe '#match(:eol)' do
-    it 'recognizes end-of-line before end-of-file' do
-      parsing("foo\nbar").from(3).as(:eol).should result_in(true).at(4)
-      parsing("foobar").from(3).as(:eol).should fail
-    end
+      context 'delimited by double quotes' do
+        it 'parses as a regex match' do
+          matching(%{ "a string" }).as(:expression).
+            should result_in(Match[/a\ string/]).at(11)
+        end
+      end
 
-    it 'recognizes end-of-file as end-of-line' do
-      parsing("foo\nbar").from(7).as(:eol).should result_in(true).at(7)
-    end
-  end
+      context 'delimited by single quotes' do
+        it 'parses as a regex match' do
+          matching(%{ 'a string' }).as(:expression).
+            should result_in(Match[/a\ string/]).at(11)
+        end
+      end
 
-  describe '#match(:var_name)' do
-    it 'recognizes variable names' do
-      parsing(' fooBar ').as(:var_name).should result_in('fooBar').at(7)
-      parsing(' FooBar ').as(:var_name).should fail
-    end
-  end
+      context 'using "general delimited text" syntax' do
+
+        context 'with "(" and ")"' do
+          it 'parses as a regex match' do
+            matching(' %(a string) ').as(:expression).
+              should result_in(Match[/a\ string/]).at(12)
+          end
+        end
+
+        context 'with "{" and "}"' do
+          it 'parses as a regex match' do
+            matching(' %{a string} ').as(:expression).
+              should result_in(Match[/a\ string/]).at(12)
+          end
+        end
+
+        context 'with "[" and "]"' do
+          it 'parses as a regex match' do
+            matching(' %[a string] ').as(:expression).
+              should result_in(Match[/a\ string/]).at(12)
+          end
+        end
+
+        context 'with "<" and ">"' do
+          it 'parses as a regex match' do
+            matching(' %<a string> ').as(:expression).
+              should result_in(Match[/a\ string/]).at(12)
+          end
+        end
+
+        context 'with arbitrary delimiters' do
+          it 'parses as a regex match' do
+            matching(' %!a string! ').as(:expression).
+              should result_in(Match[/a\ string/]).at(12)
+          end
+        end
+      end
 
-  describe '#match(:const_name)' do
-    it 'recognizes constant names' do
-      parsing(' FooBar ').as(:const_name).should result_in('FooBar').at(7)
-      parsing(' Foo::Bar ').as(:const_name).should result_in('Foo').at(4)
-      parsing(' fooBar ').as(:const_name).should fail
-    end
-  end
+      context 'delimited by backquotes' do
+        it 'parses as a word literal' do
+          matching(%{ `where` }).as(:expression).should result_in(
+            Token[Sequence[Match[/where/], Disallow[Match[/[[:alnum:]_]/]]]]
+          ).at(8)
+        end
+      end
 
-  describe '#match(:constant)' do
-    it 'recognizes constants' do
-      parsing(' Foo::Bar ').as(:constant).should result_in('Foo::Bar').at(9)
-      parsing(' FooBar ').as(:constant).should result_in('FooBar').at(7)
+      context 'with special characters' do
+        it 'escapes the special characters' do
+          matching(%{ "[...]" }).as(:expression).
+            should result_in(Match[/\[\.\.\.\]/]).at(8)
+        end
+      end
     end
-  end
 
-  describe '#match(:literal)' do
-    it 'recognizes string literals' do
-      parsing(%{ "a string" }).as(:literal).should result_in(%{"a string"}).at(11)
-      parsing(%{ 'a string' }).as(:literal).should result_in(%{'a string'}).at(11)
-      parsing(%q{ "a \"string\"" }).as(:literal).
-        should result_in(%q{"a \"string\""}).at(15)
-    end
-  end
+    context 'given a character class expression' do
 
-  describe '#match(:word_literal)' do
-    it 'recognizes word literals' do
-      parsing(' `then` ').as(:word_literal).should result_in("`then`").at(7)
-    end
-  end
+      context 'with a simple list of characters' do
+        it 'parses as a regex match' do
+          matching(' [abc123] ').as(:expression).
+            should result_in(Match[/[abc123]/]).at(9)
+        end
+      end
 
-  describe '#match(:class_char)' do
-    it 'recognizes normal characters as class characters' do
-      parsing('ab').as(:class_char).should result_in('a').at(1)
-    end
+      context 'with octal codes' do
+        it 'parses as a regex match' do
+          matching(' [\010\012\015] ').as(:expression).
+            should result_in(Match[/[\010\012\015]/]).at(15)
+        end
+      end
 
-    it 'recognizes octal codes as class characters' do
-      parsing('\\247').as(:class_char).should result_in('\\247').at(4)
-      parsing('\\2474').as(:class_char).should result_in('\\247').at(4)
-    end
+      context 'with hex codes' do
+        it 'parses as a regex match' do
+          matching(' [\x08\x0A\x0D] ').as(:expression).
+            should result_in(Match[/[\x08\x0A\x0D]/]).at(15)
+        end
+      end
 
-    it 'recognizes hex codes as class characters' do
-      parsing('\\x7e').as(:class_char).should result_in('\\x7e').at(4)
-      parsing('\\x7ee').as(:class_char).should result_in('\\x7e').at(4)
-    end
+      context 'with a range of characters' do
+        it 'parses as a regex match' do
+          matching(' [A-F] ').as(:expression).
+            should result_in(Match[/[A-F]/]).at(6)
+        end
+      end
 
-    it 'recognizes the "any" character as a class character' do
-      parsing('.').as(:class_char).should result_in('.').at(1)
-    end
+      context 'with a range of octal codes' do
+        it 'parses as a regex match' do
+          matching(' [\000-\177] ').as(:expression).
+            should result_in(Match[/[\000-\177]/]).at(12)
+        end
+      end
 
-    it 'recognizes escaped characters as class characters' do
-      parsing('\\]').as(:class_char).should result_in('\\]').at(2)
-      parsing('\\\\').as(:class_char).should result_in('\\\\').at(2)
+      context 'with a range of hex codes' do
+        it 'parses as a regex match' do
+          matching(' [\x00-\x7F] ').as(:expression).
+            should result_in(Match[/[\x00-\x7F]/]).at(12)
+        end
+      end
     end
-  end
 
-  describe '#match(:posix_name)' do
-    it 'recognizes posix names' do
-      for name in posix_names
-        parsing(name).as(:posix_name).should result_in(name).at(name.length)
-        parsing(name + 'a').as(:posix_name).should fail
-        parsing(name + '0').as(:posix_name).should fail
-        parsing(name + '_').as(:posix_name).should fail
+    context 'given a "."' do
+      it 'parses as Match[/./]' do
+        matching(' . ').as(:expression).should result_in(Match[/./]).at(2)
       end
     end
-  end
 
-  describe '#match(:range)' do
-    it 'recognizes posix character classes as class ranges' do
-      for name in posix_names
-        parsing("[:#{name}:] ").as(:range).should result_in("[:#{name}:]").
-          at(name.length + 4)
+    context 'given a lower-case word' do
+      it 'parses as an Apply' do
+        matching(' fooBar ').as(:expression).should result_in(Apply[:fooBar]).at(7)
       end
-      parsing('[:foo:]').as(:range).should result_in('[').at(1)
     end
 
-    it 'recognizes normal character ranges as class ranges' do
-      parsing('A-Z ').as(:range).should result_in('A-Z').at(3)
+    context 'given a upper-case word' do
+      it 'parses it as an Apply' do
+        matching(' FooBar ').as(:expression).should result_in(Apply[:FooBar]).at(7)
+      end
     end
 
-    it 'recognizes class characters as class ranges' do
-      parsing('ab').as(:range).should result_in('a').at(1)
-    end
-  end
-
-  describe '#match(:class)' do
-    it 'recognizes character classes' do
-      parsing(' [A-Za-z_] ').as(:class).should result_in('[A-Za-z_]').at(10)
+    context 'given the EOF keyword' do
+      it 'parses as Eof[]' do
+        matching(' EOF ').as(:expression).should result_in(Eof[]).at(4)
+      end
     end
-  end
 
-  describe '#match(:regexp)' do
-    it 'recognizes regexps' do
-      parsing(' /\\d+(?:\\.\\d+)?/ ').as(:regexp).
-        should result_in('/\\d+(?:\\.\\d+)?/').at(16)
+    context 'given an upper-case POSIX class name' do
+      it 'parses as a Match of a POSIX character class' do
+        for name in posix_names
+          matching(" #{name.upcase} ").as(:expression).
+            should result_in(Match[Regexp.new("[[:#{name}:]]")]).
+            at(name.length + 1)
+        end
+      end
     end
-  end
 
-  describe '#match(:atom)' do
-    it 'recognizes EOF as an eof atom' do
-      parsing(' EOF ').as(:atom).should result_in(Eof[]).at(4)
+    context 'given the non-POSIX WORD class name' do
+      it 'parses as syntactic sugar for [[:alnum:]_]' do
+        matching(' WORD ').as(:expression).
+          should result_in(Match[/[[:alnum:]_]/]).at(5)
+      end
     end
 
-    it 'recognizes "." as a regexp atom' do
-      parsing(' . ').as(:atom).should result_in(Match[/./]).at(2)
+    it 'parses dispatch-action-attributed expressions' do
+      matching(' expr <Expr> ').as(:expression).
+        should result_in(DispatchAction[Apply[:expr], {:target => 'Expr', :method => 'parsed'}]).
+        at(12)
     end
 
-    it 'recognizes uppercase posix character class names as regexp atoms' do
-      for name in posix_names.map {|_| _.upcase } - ['WORD']
-        parsing(" #{name} ").as(:atom).
-        should result_in(Match[Regexp.compile("[[:#{name.downcase}:]]")]).
-        at(name.length + 1)
-      end
+    it 'parses direct-action-attributed expressions' do
+      matching(' digits {|_| _.to_i} ').as(:expression).
+        should result_in(DirectAction[Apply[:digits], '|_| _.to_i']).at(20)
     end
 
-    it 'recognizes WORD as syntactic sugar for [[:alnum:]_]' do
-      parsing(' WORD ').as(:atom).should result_in(Match[/[[:alnum:]_]/]).at(5)
+    it 'parses sequence expressions' do
+      matching(' name "=" value ').as(:expression).
+        should result_in(Sequence[Apply[:name], Match[%r{=}], Apply[:value]]).at(15)
     end
 
-    it 'recognizes identifiers as apply atoms' do
-      parsing(' expr ').as(:atom).should result_in(Apply[:expr]).at(5)
+    it 'parses attributed sequence expressions' do
+      matching(' name "=" value <Assign>').as(:expression).
+        should result_in(DispatchAction[
+                          Sequence[Apply[:name], Match[%r{=}], Apply[:value]],
+                          {:target => 'Assign', :method => 'parsed'}]).
+                at(24)
     end
 
-    it 'recognizes string literals as match atoms' do
-      parsing(%{ "a string" }).as(:atom).should result_in(Match[/a\ string/]).at(11)
+    it 'parses ordered choice expressions' do
+      matching(' string / number ').as(:expression).
+        should result_in(Choice[Apply[:string], Apply[:number]]).at(16)
     end
 
-    it 'recognizes word literals as word atoms' do
-      parsing(' `then` ').as(:atom).
-      should result_in(Token[Sequence[Match[/then/], Disallow[Match[/[[:alnum:]_]/]]]]).at(7)
+    it 'skips normal whitespace' do
+      matching("  \n\t foo").as(:expression).should result_in(Apply[:foo]).at(8)
     end
 
-    it 'recognizes character classes as match atoms' do
-      parsing(' [A-Za-z_] ').as(:atom).should result_in(Match[/[A-Za-z_]/]).at(10)
+    it 'skips comments' do
+      matching("\n# a comment\n\t foo").as(:expression).
+        should result_in(Apply[:foo]).at(18)
     end
   end
 
   describe '#match(:attributed)' do
     it 'recognizes dispatch-action-attributed expressions' do
-      parsing(' expr <Expr> ').as(:attributed).
+      matching(' expr <Expr> ').as(:attributed).
         should result_in(DispatchAction[Apply[:expr], {:target => 'Expr', :method => 'parsed'}]).
         at(12)
     end
 
     it 'recognizes direct-action-attributed expressions' do
-      parsing(' digits {|_| _.to_i} ').as(:attributed).
+      matching(' digits {|_| _.to_i} ').as(:attributed).
         should result_in(DirectAction[Apply[:digits], '|_| _.to_i']).at(20)
     end
   end
 
   describe '#match(:term)' do
     it 'recognizes optional terms' do
-      parsing(' expr? ').as(:term).should result_in(Optional[Apply[:expr]]).at(6)
+      matching(' expr? ').as(:term).should result_in(Optional[Apply[:expr]]).at(6)
     end
 
     it 'recognizes zero-or-more terms' do
-      parsing(' expr* ').as(:term).should result_in(ZeroOrMore[Apply[:expr]]).at(6)
+      matching(' expr* ').as(:term).should result_in(ZeroOrMore[Apply[:expr]]).at(6)
     end
 
     it 'recognizes one-or-more terms' do
-      parsing(' expr+ ').as(:term).should result_in(OneOrMore[Apply[:expr]]).at(6)
+      matching(' expr+ ').as(:term).should result_in(OneOrMore[Apply[:expr]]).at(6)
     end
 
     it 'recognizes assert terms' do
-      parsing(' &expr ').as(:term).should result_in(Assert[Apply[:expr]]).at(6)
+      matching(' &expr ').as(:term).should result_in(Assert[Apply[:expr]]).at(6)
     end
 
     it 'recognizes disallow terms' do
-      parsing(' !expr ').as(:term).should result_in(Disallow[Apply[:expr]]).at(6)
+      matching(' !expr ').as(:term).should result_in(Disallow[Apply[:expr]]).at(6)
     end
 
     it 'recognizes skip terms' do
-      parsing(' ~expr ').as(:term).should result_in(Skip[Apply[:expr]]).at(6)
+      matching(' ~expr ').as(:term).should result_in(Skip[Apply[:expr]]).at(6)
     end
 
     it 'recognizes token terms' do
-      parsing(' @expr ').as(:term).should result_in(Token[Apply[:expr]]).at(6)
+      matching(' @expr ').as(:term).should result_in(Token[Apply[:expr]]).at(6)
     end
 
     it 'recognizes labeled terms' do
-      parsing(' val:expr ').as(:term).should result_in(Label[:val, Apply[:expr]]).at(9)
+      matching(' val:expr ').as(:term).should result_in(Label[:val, Apply[:expr]]).at(9)
     end
 
     it 'recognizes fail expressions' do
-      parsing(' fail("bad!") ').as(:term).
+      matching(' fail("bad!") ').as(:term).
         should result_in(Fail[:expr, 'bad!']).at(13)
-      parsing(' fail "bad!" ').as(:term).
+      matching(' fail "bad!" ').as(:term).
         should result_in(Fail[:expr, 'bad!']).at(12)
     end
 
     it 'recognizes fail_rule expressions' do
-      parsing(' fail_rule("bad!") ').as(:term).
+      matching(' fail_rule("bad!") ').as(:term).
         should result_in(Fail[:rule, 'bad!']).at(18)
-      parsing(' fail_rule "bad!" ').as(:term).
+      matching(' fail_rule "bad!" ').as(:term).
         should result_in(Fail[:rule, 'bad!']).at(17)
     end
 
     it 'recognizes fail_parse expressions' do
-      parsing(' fail_parse("bad!") ').as(:term).
+      matching(' fail_parse("bad!") ').as(:term).
         should result_in(Fail[:parse, 'bad!']).at(19)
-      parsing(' fail_parse "bad!" ').as(:term).
+      matching(' fail_parse "bad!" ').as(:term).
         should result_in(Fail[:parse, 'bad!']).at(18)
     end
   end
 
-  describe '#match(:expression)' do
-    it 'recognizes dispatch-action-attributed expressions' do
-      parsing(' expr <Expr> ').as(:expression).
-        should result_in(DispatchAction[Apply[:expr], {:target => 'Expr', :method => 'parsed'}]).
-        at(12)
-    end
-
-    it 'recognizes direct-action-attributed expressions' do
-      parsing(' digits {|_| _.to_i} ').as(:expression).
-        should result_in(DirectAction[Apply[:digits], '|_| _.to_i']).at(20)
-    end
-
-    it 'recognizes sequence expressions' do
-      parsing(' name "=" value ').as(:expression).
-        should result_in(Sequence[Apply[:name], Match[%r{=}], Apply[:value]]).at(15)
-    end
-
-    it 'recognizes attributed sequence expressions' do
-      parsing(' name "=" value <Assign>').as(:expression).
-        should result_in(DispatchAction[
-                          Sequence[Apply[:name], Match[%r{=}], Apply[:value]],
-                          {:target => 'Assign', :method => 'parsed'}]).
-                at(24)
-    end
-
-    it 'recognizes choice expressions' do
-      parsing(' string | number ').as(:expression).
-        should result_in(Choice[Apply[:string], Apply[:number]]).at(16)
-    end
-  end
-
 end