antlr3 1.7.5 → 1.8.0

data/test/functional/lexer/filter-mode.rb

@@ -5,7 +5,7 @@ require 'antlr3/test/functional'
 
 class TestFilterMode < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar Filter;
     options {
         language = Ruby;
@@ -71,7 +71,7 @@ class TestFilterMode < ANTLR3::Test::Functional
   END
 
   example "skipping tokens that aren't important with filter mode" do
-    input = <<-END.fixed_indent(0)
+    input = <<-END.fixed_indent( 0 )
       import org.antlr.runtime.*;
       
       public class Main {
@@ -97,7 +97,7 @@ end
 
 class TestFuzzy < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar Fuzzy;
     options {
         language = Ruby;
@@ -205,7 +205,7 @@ class TestFuzzy < ANTLR3::Test::Functional
   END
   
   example "fuzzy lexing with the filter mode option" do
-    input = <<-END.fixed_indent(0)
+    input = <<-END.fixed_indent( 0 )
       import org.antlr.runtime.*;
       
       public class Main {
@@ -221,7 +221,7 @@ class TestFuzzy < ANTLR3::Test::Functional
       }
     END
     
-    expected_output = <<-END.fixed_indent(0)
+    expected_output = <<-END.fixed_indent( 0 )
       found class Main
       found method main
       found var i
@@ -235,11 +235,10 @@ class TestFuzzy < ANTLR3::Test::Functional
       found // comment //System.out.println(tokens);
     END
     
-    lexer = Fuzzy::Lexer.new(input)
+    lexer = Fuzzy::Lexer.new( input )
     lexer.each { |tk| tk }
     lexer.output.should == expected_output
   end
 
 
 end
-

data/test/functional/lexer/nuances.rb

@@ -4,7 +4,7 @@
 require 'antlr3/test/functional'
 
 class TestBug80 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar Bug80;
     options { language = Ruby; }
      
@@ -28,7 +28,7 @@ end
 
 class TestEOF < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar EndOfFile;
     
     options {
@@ -44,4 +44,3 @@ class TestEOF < ANTLR3::Test::Functional
     tks = lexer.map { |tk| tk }
   end
 end
-

data/test/functional/lexer/properties.rb

@@ -5,7 +5,7 @@ require 'antlr3/test/functional'
 
 class TestLexerRuleReference < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar RuleProperty;
     options {
       language = Ruby;
@@ -31,8 +31,8 @@ class TestLexerRuleReference < ANTLR3::Test::Functional
     lexer = RuleProperty::Lexer.new( "foobar _ab98 \n A12sdf" )
     tokens = lexer.map { |tk| tk }
     
-    lexer.properties.should have(3).things
-    text, type, line, pos, index, channel, start, stop = lexer.properties[0]
+    lexer.properties.should have( 3 ).things
+    text, type, line, pos, index, channel, start, stop = lexer.properties[ 0 ]
     text.should == 'foobar'
     type.should == RuleProperty::TokenData::IDENTIFIER
     line.should == 1
@@ -42,7 +42,7 @@ class TestLexerRuleReference < ANTLR3::Test::Functional
     start.should == 0
     stop.should == 5
     
-    text, type, line, pos, index, channel, start, stop = lexer.properties[1]
+    text, type, line, pos, index, channel, start, stop = lexer.properties[ 1 ]
     text.should == '_ab98'
     type.should == RuleProperty::TokenData::IDENTIFIER
     line.should == 1
@@ -52,8 +52,8 @@ class TestLexerRuleReference < ANTLR3::Test::Functional
     start.should == 7
     stop.should == 11
     
-    lexer.properties.should have(3).things
-    text, type, line, pos, index, channel, start, stop = lexer.properties[2]
+    lexer.properties.should have( 3 ).things
+    text, type, line, pos, index, channel, start, stop = lexer.properties[ 2 ]
     text.should == 'A12sdf'
     type.should == RuleProperty::TokenData::IDENTIFIER
     line.should == 2
@@ -68,7 +68,7 @@ class TestLexerRuleReference < ANTLR3::Test::Functional
 end
 
 class TestLexerRuleLabel < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar LexerRuleLabel;
     options {
       language = Ruby;
@@ -101,4 +101,3 @@ class TestLexerRuleLabel < ANTLR3::Test::Functional
   end
 
 end
-

data/test/functional/lexer/syn-pred.rb

@@ -4,7 +4,7 @@
 require 'antlr3/test/functional'
 
 class TestSyntacticPredicate < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar SyntacticPredicateGate;
     options {
       language = Ruby;
@@ -29,4 +29,3 @@ class TestSyntacticPredicate < ANTLR3::Test::Functional
 
 
 end
-

data/test/functional/lexer/xml.rb

@@ -4,7 +4,7 @@
 require 'antlr3/test/functional'
 
 class XMLLexerTest < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar XML;
     options { language = Ruby; }
     
@@ -134,7 +134,7 @@ class XMLLexerTest < ANTLR3::Test::Functional
   END
   
   it "should be valid" do
-    lexer = XML::Lexer.new(<<-'END'.fixed_indent(0))
+    lexer = XML::Lexer.new( <<-'END'.fixed_indent( 0 ) )
       <?xml version='1.0'?>
       <!DOCTYPE component [
       <!ELEMENT component (PCDATA|sub)*>
@@ -160,7 +160,7 @@ class XMLLexerTest < ANTLR3::Test::Functional
     
     lexer.map { |tk| tk }
     
-    lexer.output.should == <<-'END'.fixed_indent(0)
+    lexer.output.should == <<-'END'.fixed_indent( 0 )
       XML declaration
       Attr: version = '1.0'
       ROOTELEMENT: component

data/test/functional/main/main-scripts.rb

@@ -5,12 +5,12 @@ require 'antlr3'
 require 'antlr3/test/functional'
 
 ENV.delete( 'RUBYOPT' )
-ENV['RUBYLIB'] = ANTLR3.library_path
+ENV[ 'RUBYLIB' ] = ANTLR3.library_path
 
 class TestMainUtility < ANTLR3::Test::Functional
   
   example 'overriding the built-in script action using the @main named-action' do
-    grammar = inline_grammar(<<-'END')
+    grammar = inline_grammar( <<-'END' )
       lexer grammar MainOverride;
       options { language = Ruby; }
       
@@ -30,15 +30,15 @@ class TestMainUtility < ANTLR3::Test::Functional
     # this assertion verifies that the main region is executed
     # when the parser script is run directly
     lexer_script = grammar.target_files.first
-    out = `ruby #{lexer_script} 2>&1`.chomp
+    out = `ruby #{ lexer_script } 2>&1`.chomp
     out.should =~ /the main block ran/
   end
   
   example 'using Lexer.main() to run the built-in lexer utility script on a source file' do
-    input_path = local_path('input.txt')
-    open(input_path, 'w') { |f| f.write("yada yada") }
+    input_path = local_path( 'input.txt' )
+    open( input_path, 'w' ) { |f| f.write( "yada yada" ) }
     
-    compile_and_load inline_grammar(<<-'END')
+    compile_and_load inline_grammar( <<-'END' )
       lexer grammar LexerMainWithSourceFile;
       options { language = Ruby; }
       
@@ -48,21 +48,21 @@ class TestMainUtility < ANTLR3::Test::Functional
     
     begin
       output = StringIO.new
-      input = File.open(input_path)
-      LexerMainWithSourceFile::Lexer.main([], :input => input, :output => output)
+      input = File.open( input_path )
+      LexerMainWithSourceFile::Lexer.main( [], :input => input, :output => output )
       
-      out_lines = output.string.split(/\n/)
-      out_lines.should have(3).things
+      out_lines = output.string.split( /\n/ )
+      out_lines.should have( 3 ).things
     ensure
-      File.delete(input_path)
+      File.delete( input_path )
     end
   end
 
   example 'using Lexer.main to run the built-in lexer utility script on input from $stdin' do
-    input = StringIO.new("yada yada")    # <- used to simulate $stdin
+    input = StringIO.new( "yada yada" )    # <- used to simulate $stdin
     output = StringIO.new
     
-    compile_and_load inline_grammar(<<-'END')
+    compile_and_load inline_grammar( <<-'END' )
       lexer grammar LexerMainFromStdIO;
       options { language = Ruby; }
       
@@ -70,13 +70,13 @@ class TestMainUtility < ANTLR3::Test::Functional
       WS: ' '+ { $channel = HIDDEN; };
     END
     
-    LexerMainFromStdIO::Lexer.main([], :input => input, :output => output)
-    lines = output.string.split(/\n/)
-    lines.should have(3).things
+    LexerMainFromStdIO::Lexer.main( [], :input => input, :output => output )
+    lines = output.string.split( /\n/ )
+    lines.should have( 3 ).things
   end
 
   example 'using Parser.main to run the built-in parser script utility with a combo grammar' do
-    compile_and_load inline_grammar(<<-'END')
+    compile_and_load inline_grammar( <<-'END' )
       grammar MainForCombined;
       options { language = Ruby; }
       r returns [res]: (ID)+ EOF { $res = $text; };
@@ -86,17 +86,17 @@ class TestMainUtility < ANTLR3::Test::Functional
     END
     
     output = StringIO.new
-    input = StringIO.new('yada yada')
+    input = StringIO.new( 'yada yada' )
     
-    MainForCombined::Parser.main(
+    MainForCombined::Parser.main( 
         %w(--rule r --lexer-name MainForCombined::Lexer),
-        :input => input, :output => output)
-    lines = output.string.split("\n")
-    lines.should have(4).things
+        :input => input, :output => output )
+    lines = output.string.split( "\n" )
+    lines.should have( 4 ).things
   end
   
   example 'using built-in main to inspect AST constructed by an AST-building parser' do
-    compile_and_load inline_grammar(<<-'END')
+    compile_and_load inline_grammar( <<-'END' )
       grammar ASTParserMain;
       options {
         language = Ruby;
@@ -111,15 +111,15 @@ class TestMainUtility < ANTLR3::Test::Functional
     
     output = StringIO.new
     input  = StringIO.new 'yada + yada'
-    ASTParserMain::Parser.main(
+    ASTParserMain::Parser.main( 
       %w(--rule r --lexer-name ASTParserMain::Lexer),
-      :input => input, :output => output)
+      :input => input, :output => output )
     output = output.string.strip
     output.should == "(+ yada yada)"
   end
   
   example "using a tree parser's built-in main" do
-    compile_and_load inline_grammar(<<-'END')
+    compile_and_load inline_grammar( <<-'END' )
       grammar TreeMain;
       options {
         language = Ruby;
@@ -132,7 +132,7 @@ class TestMainUtility < ANTLR3::Test::Functional
       OP: '+';
       WS: ' '+ { $channel = HIDDEN; };
     END
-    compile_and_load inline_grammar(<<-'END')
+    compile_and_load inline_grammar( <<-'END' )
       tree grammar TreeMainWalker;
       options {
         language=Ruby;
@@ -147,16 +147,16 @@ class TestMainUtility < ANTLR3::Test::Functional
     output = StringIO.new
     input  = StringIO.new 'a+b'
     
-    TreeMainWalker::TreeParser.main(
+    TreeMainWalker::TreeParser.main( 
       %w(--rule r --parser-name TreeMain::Parser
          --parser-rule r --lexer-name TreeMain::Lexer),
-      :input => input, :output => output)
+      :input => input, :output => output )
     output = output.string.strip
     output.should == '"a + b"'
   end
   
   example "using a tree parser's built-in main to inspect AST rewrite output" do
-    compile_and_load inline_grammar(<<-'END')
+    compile_and_load inline_grammar( <<-'END' )
       grammar TreeRewriteMain;
       options {
         language = Ruby;
@@ -169,7 +169,7 @@ class TestMainUtility < ANTLR3::Test::Functional
       OP: '+';
       WS: ' '+ { $channel = HIDDEN; };
     END
-    compile_and_load inline_grammar(<<-'END')
+    compile_and_load inline_grammar( <<-'END' )
       tree grammar TreeRewriteMainWalker;
       options {
         language=Ruby;
@@ -183,7 +183,7 @@ class TestMainUtility < ANTLR3::Test::Functional
     
     output = StringIO.new
     input  = StringIO.new 'a+b'
-    TreeRewriteMainWalker::TreeParser.main(
+    TreeRewriteMainWalker::TreeParser.main( 
       %w(--rule r --parser-name TreeRewriteMain::Parser
          --parser-rule r --lexer-name TreeRewriteMain::Lexer),
       :input => input, :output => output
@@ -194,12 +194,12 @@ class TestMainUtility < ANTLR3::Test::Functional
   end
   
   example 'using built-in main with a delegating grammar' do
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       parser grammar MainSlave;
       options { language=Ruby; }
       a : B;
     END
-    master = inline_grammar(<<-'END')
+    master = inline_grammar( <<-'END' )
       grammar MainMaster;
       options { language=Ruby; }
       import MainSlave;
@@ -209,15 +209,15 @@ class TestMainUtility < ANTLR3::Test::Functional
     END
     master.compile
     for file in master.target_files
-      require(file)
+      require( file )
     end
     
     output = StringIO.new
     input = StringIO.new 'b'
     
-    MainMaster::Parser.main(
+    MainMaster::Parser.main( 
       %w(--rule s --lexer-name MainMaster::Lexer),
-      :input => input, :output => output)
+      :input => input, :output => output )
     output = output.string.strip
     output.should == 'b'.inspect
   end

data/test/functional/parser/actions.rb

@@ -4,7 +4,7 @@
 require 'antlr3/test/functional'
 
 class TestActions1 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar ParserActions;
     options { language = Ruby; }
     
@@ -48,7 +48,7 @@ end
 
 class TestActions2 < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar AllKindsOfActions;
     options { language = Ruby; }
     
@@ -92,13 +92,13 @@ class TestActions2 < ANTLR3::Test::Functional
     parser = AllKindsOfActions::Parser.new lexer
     parser.prog
     
-    parser.output.should == <<-END.fixed_indent(0)
+    parser.output.should == <<-END.fixed_indent( 0 )
       init
       after
       finally
     END
     
-    lexer.output.should == <<-END.fixed_indent(0)
+    lexer.output.should == <<-END.fixed_indent( 0 )
       action
       "foobar" 4 1 0 -1 :default 0 5
       attribute
@@ -114,7 +114,7 @@ end
 
 class TestFinally < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar Finally;
     
     options {
@@ -148,7 +148,7 @@ end
 
 class TestActionScopes < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar SpecialActionScopes;
     options { language=Ruby; }
     
@@ -216,9 +216,9 @@ class TestActionScopes < ANTLR3::Test::Functional
   END
   
   example 'verifying action scope behavior' do
-    lexer = SpecialActionScopes::Lexer.new("10 20 30 40 50")
+    lexer = SpecialActionScopes::Lexer.new( "10 20 30 40 50" )
     parser = SpecialActionScopes::Parser.new lexer
-    parser.nums.should == [10, 20, 30, 40, 50]
+    parser.nums.should == [ 10, 20, 30, 40, 50 ]
   end
   
   example 'special action scope locations' do

data/test/functional/parser/backtracking.rb

@@ -5,7 +5,7 @@ require 'antlr3/test/functional'
 
 class TestBacktracking < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar Backtrack;
     options {
 			language = Ruby;
@@ -241,4 +241,3 @@ class TestBacktracking < ANTLR3::Test::Functional
   end
 
 end
-

data/test/functional/parser/basic.rb

@@ -4,7 +4,7 @@
 require 'antlr3/test/functional'
 
 class TestParser001 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar Identifiers;
     options { language = Ruby; }
     
@@ -52,7 +52,7 @@ class TestParser001 < ANTLR3::Test::Functional
     parser = Identifiers::Parser.new( lexer )
     parser.document
     
-    parser.reported_errors.should have(1).thing
+    parser.reported_errors.should have( 1 ).thing
   end
   
   example 'automatic input wrapping' do
@@ -71,7 +71,7 @@ class TestParser001 < ANTLR3::Test::Functional
 end
 
 class TestParser002 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar SimpleLanguage;
     options {
       language = Ruby;
@@ -119,7 +119,7 @@ class TestParser002 < ANTLR3::Test::Functional
     parser.document
     
     parser.reported_errors.should be_empty
-    parser.events.should == [
+    parser.events.should == [ 
       %w(decl foobar),
       %w(call gnarz),
       %w(decl blupp),
@@ -133,7 +133,7 @@ class TestParser002 < ANTLR3::Test::Functional
     
     parser.document
     
-    parser.reported_errors.should have(1).thing
+    parser.reported_errors.should have( 1 ).thing
     parser.events.should be_empty
   end
   
@@ -143,8 +143,8 @@ class TestParser002 < ANTLR3::Test::Functional
     
     parser.document
     
-    parser.reported_errors.should have(1).thing
-    parser.events.should == [
+    parser.reported_errors.should have( 1 ).thing
+    parser.events.should == [ 
       %w(call gnarz),
       %w(call flupp)
     ]
@@ -153,7 +153,7 @@ class TestParser002 < ANTLR3::Test::Functional
 end
 
 class TestParser003 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar MoreComplicated;
     
     options { language = Ruby; }
@@ -269,14 +269,14 @@ class TestParser003 < ANTLR3::Test::Functional
     lexer = MoreComplicated::Lexer.new "int foo() { 1+2 }"
     parser = MoreComplicated::Parser.new lexer
     parser.program
-    parser.reported_errors.should have(1).thing
+    parser.reported_errors.should have( 1 ).thing
   end
   
   example "two instances of badly formed input" do
     lexer = MoreComplicated::Lexer.new "int foo() { 1+; 1+2 }"
     parser = MoreComplicated::Parser.new lexer
     parser.program
-    parser.reported_errors.should have(2).things
+    parser.reported_errors.should have( 2 ).things
   end
   
 end