remove the keywords citrus file (less clutter)

lib/parser/basic.citrus

@@ -45,6 +45,43 @@ grammar BasicTypes
     module_name_expression | string_expression
   end
 
+  rule keyword_begin    'begin'  space* end
+  rule keyword_class    'class'  space*  end
+  rule keyword_def      'def'    space*  end
+  rule keyword_do       'do'     space* end
+  rule keyword_else     'else'   space*  end
+  rule keyword_end      'end'    space*  end
+  rule keyword_if       'if'       end
+  rule keyword_rescue   'rescue' space* end
+  rule keyword_return   'return' space* end
+  rule keyword_module   'module' space*  end
+  rule keyword_unless   'unless' space* end
+  rule keyword_until    'until'  space* end
+  rule keyword_while    'while'  space* end
+
+  rule keyword_nil
+    ('nil'    space* ){ Ast::NilExpression.new }
+  end
+
+  rule keyword_false
+    ('false'  space*) { Ast::FalseExpression.new }
+  end
+
+  rule keyword_true
+    ('true'   space*) { Ast::TrueExpression.new }
+  end
+
+  # this rule is just to make sure identifiers can't be keywords. Kind of duplication here, but we need the
+  # space in above rules, so just make sure to add any here too.
+  rule keyword   ('begin'  |  'def'  |  'do'  |  'else'  |  'end'  |
+                   'false' |  'if' |  'rescue' |  'true' |  'nil'  |
+                   'unless' |  'until' |  'while') space*
+  end
+
+  rule keyword_expression
+    keyword_true | keyword_false | keyword_nil | basic_expression
+  end
+
 
   # Tokens are single or double character combinations with "meaning"
   # braces, comman, point, questionmark , quotes, that kind of thing

lib/parser/expression.citrus

@@ -1,5 +1,5 @@
 grammar Expression
-  include Keywords
+  include BasicTypes
 
   rule more_args
     (comma basic_expression )* {

lib/parser/keywords.citrus

@@ -1,42 +0,0 @@
-grammar Keywords
-  include BasicTypes
-
-  rule keyword_begin    'begin'  space* end
-  rule keyword_class    'class'  space*  end
-  rule keyword_def      'def'    space*  end
-  rule keyword_do       'do'     space* end
-  rule keyword_else     'else'   space*  end
-  rule keyword_end      'end'    space*  end
-  rule keyword_if       'if'       end
-  rule keyword_rescue   'rescue' space* end
-  rule keyword_return   'return' space* end
-  rule keyword_module   'module' space*  end
-  rule keyword_unless   'unless' space* end
-  rule keyword_until    'until'  space* end
-  rule keyword_while    'while'  space* end
-
-  rule keyword_nil
-    ('nil'    space* ){ Ast::NilExpression.new }
-  end
-
-  rule keyword_false
-    ('false'  space*) { Ast::FalseExpression.new }
-  end
-
-  rule keyword_true
-    ('true'   space*) { Ast::TrueExpression.new }
-  end
-
-  # this rule is just to make sure identifiers can't be keywords. Kind of duplication here, but we need the
-  # space in above rules, so just make sure to add any here too.
-  rule keyword   ('begin'  |  'def'  |  'do'  |  'else'  |  'end'  |
-                   'false' |  'if' |  'rescue' |  'true' |  'nil'  |
-                   'unless' |  'until' |  'while') space*
-  end
-
-  rule keyword_expression
-    keyword_true | keyword_false | keyword_nil | basic_expression
-  end
-
-  root  keyword_expression
-end

lib/parser/salama.rb

@@ -6,7 +6,6 @@ module Parser
   # obviously a work in progress !!
 
   Citrus.require "parser/basic"
-  Citrus.require "parser/keywords"
   Citrus.require "parser/expression"
   Citrus.require "parser/statement"
 

test/unit/test_basic.rb

@@ -3,11 +3,11 @@ require_relative "../setup"
 class TestBasic < MiniTest::Test
   #test basics and keyword expressions. Keywords includes BasicTypes
   def setup
-    @parser = Keywords
+    @parser = BasicTypes
   end
 
-  def check
-    parse    = @parser.parse(@input)
+  def check rule = :root
+    parse    = @parser.parse(@input , :root => rule)
     assert_equal @input , parse
     assert_equal @output , parse.value
   end
@@ -15,62 +15,62 @@ class TestBasic < MiniTest::Test
   def test_true
     @input    = 'true  '
     @output = Ast::TrueExpression.new()
-    check
+    check :keyword_true
   end
 
   def test_false
     @input    = 'false '
     @output = Ast::FalseExpression.new()
-    check
+    check :keyword_false
   end
 
   def test_nil
     @input    = 'nil '
     @output = Ast::NilExpression.new()
-    check
+    check :keyword_nil
   end
 
   def test_integer
     @input    = '42 '
     @output = Ast::IntegerExpression.new(42)
-    check
+    check :integer_expression
   end
 
   def test_name
     @input    = 'foo '
     @output = Ast::NameExpression.new('foo')
-    check
+    check :name_expression
   end
 
   def test_name_underscode_start
     @input    = '_bar '
     @output = Ast::NameExpression.new('_bar')
-    check
+    check :name_expression
   end
 
   def test_name_underscode_middle
     @input    = 'foo_bar '
     @output = Ast::NameExpression.new('foo_bar')
-    check
+    check :name_expression
   end
 
   def test_module_name
     @input    = 'FooBar '
     @output = Ast::ModuleName.new("FooBar")
-    check
+    check :module_name_expression
   end
 
   def test_string
     @input    = '"hello"'
     @output =  Ast::StringExpression.new('hello')
-    check
+    check :string_expression
   end
 
   def test_string_escapes
     out = 'hello  \nyou'
     @input    = '"' + out + '"'
     @output =  Ast::StringExpression.new(out)
-    check
+    check :string_expression
   end
 
 end