rattler 0.2.0 → 0.2.1

data/README.rdoc

@@ -14,6 +14,8 @@ A language syntax is specified in a grammar using the Rattler syntax. Parser
 classes and modules can be generated statically using the "rtlr" command or
 dynamically from strings.
 
+{RDoc}[http://rubydoc.info/gems/rattler/0.2.0/frames]
+
 == FEATURES:
 
 * Uses readable PEG-like grammars

data/bin/rtlr

@@ -1,5 +1,8 @@
-#!/usr/bin/env ruby
-
-require 'rattler/runner'
-
-Rattler::Runner.run(ARGV.clone)
+#! /usr/bin/env ruby
+
+rattler_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift rattler_dir unless $:.include? rattler_dir
+
+require 'rattler/runner'
+
+::Rattler::Runner.run(ARGV.clone)

data/features/command_line/dest_option.feature

@@ -0,0 +1,34 @@
+Feature: --dest option
+
+  Use the --dest (or -d) option to specify a different (base) destination
+  directory.
+
+  Scenario: Grammar as top-level module
+    Given a file named "binary.rtlr" with:
+      """
+      grammar BinaryGrammar
+      expr <- [01]*
+      """
+      And a directory named "lib"
+    When I run "rtlr --dest lib binary.rtlr"
+    Then the output should contain "binary.rtlr -> lib/binary_grammar.rb"
+      And the file "lib/binary_grammar.rb" should contain:
+        """
+        module BinaryGrammar
+        """
+
+  Scenario: Grammar as top-level module
+    Given a file named "binary.rtlr" with:
+      """
+      grammar Examples::BinaryGrammar
+      expr <- [01]*
+      """
+      And a directory named "lib/examples"
+    When I run "rtlr --dest lib binary.rtlr"
+    Then the output should contain "binary.rtlr -> lib/examples/binary_grammar.rb"
+      And the file "lib/examples/binary_grammar.rb" should contain:
+        """
+        module Examples
+          # @private
+          module BinaryGrammar
+        """

data/features/command_line/output_option.feature

@@ -0,0 +1,31 @@
+Feature: --output option
+
+  Use the --output (or -o) option to specify a different output file name, or
+  "-" for STDOUT.
+
+  Scenario: Specify a different file name
+    Given a file named "binary.rtlr" with:
+      """
+      grammar BinaryGrammar
+      expr <- [01]*
+      """
+      And a directory named "lib"
+    When I run "rtlr --output my_grammar.rb binary.rtlr"
+    Then the output should contain "binary.rtlr -> my_grammar.rb"
+      And the file "my_grammar.rb" should contain:
+        """
+        module BinaryGrammar
+        """
+
+  Scenario: Use "-" to write to STDOUT
+    Given a file named "binary.rtlr" with:
+      """
+      grammar BinaryGrammar
+      expr <- [01]*
+      """
+      And a directory named "lib"
+    When I run "rtlr --output - binary.rtlr"
+    Then the output should contain:
+      """
+      module BinaryGrammar
+      """

data/features/command_line/parser_generator.feature

@@ -0,0 +1,80 @@
+Feature: Parser Generator
+
+  The "rtlr" command is used to generate a grammar module or parser class from
+  a Rattler grammar file.
+  
+  Scenario: Getting help
+    When I run "rtlr --help"
+    Then the output should contain:
+      """
+      Usage: rtlr FILENAME [options]
+
+          -d, --dest DIRECTORY             Specify the destination directory
+          -o, --output FILENAME            Specify a different output filename
+          -f, --force                      Force overwrite if the output file exists
+
+          -h, --help                       Show this message
+      """
+
+  Scenario: Generate a grammar module
+    Given a file named "binary.rtlr" with:
+      """
+      grammar BinaryGrammar
+      expr <- [01]*
+      """
+    When I run "rtlr binary.rtlr"
+    Then the output should contain "binary.rtlr -> binary_grammar.rb"
+      And the file "binary_grammar.rb" should contain:
+        """
+        # @private
+        module BinaryGrammar #:nodoc:
+          
+          # @private
+          def start_rule #:nodoc:
+            :expr
+          end
+          
+          # @private
+          def match_expr #:nodoc:
+            a0 = []
+            while r = @scanner.scan(/[01]/)
+              a0 << r
+            end
+            a0
+          end
+          
+        end
+        """
+  
+  Scenario: Generate a parser class
+    Given a file named "binary.rtlr" with:
+      """
+      require "rattler"
+      parser BinaryParser < Rattler::Runtime::PackratParser
+      expr <- [01]*
+      """
+    When I run "rtlr binary.rtlr"
+    Then the output should contain "binary.rtlr -> binary_parser.rb"
+      And the file "binary_parser.rb" should contain:
+        """
+        require "rattler"
+        
+        # @private
+        class BinaryParser < Rattler::Runtime::PackratParser #:nodoc:
+          
+          # @private
+          def start_rule #:nodoc:
+            :expr
+          end
+          
+          # @private
+          def match_expr #:nodoc:
+            a0 = []
+            while r = @scanner.scan(/[01]/)
+              a0 << r
+            end
+            a0
+          end
+          
+        end
+        """

data/features/grammar/word_literal.feature

@@ -2,9 +2,9 @@ Feature: Word Literal Expressions
   
   A word literal is like a string literal but delimited with backquotes (`) and
   it means to match the literal only if it is not followed by a word character.
-  It is useful for matching whole words only. What is considered a word
-  character can be defined using the %word_character directive. By default a
-  word charactacter is an alphanumeric character or the underscore character.
+  It is useful when you want to match whole words only. What is considered a
+  word character can be defined using the %word_character directive. By default
+  a word charactacter is an alphanumeric character or the underscore character.
   
   In order to define keywords
   As a language designer

data/features/step_definitions/cli_steps.rb

@@ -0,0 +1,3 @@
+Then /^the file "([^"]+)" should contain:$/ do |file, partial_content|
+  check_file_content(file, partial_content, true)
+end

data/features/support/env.rb

@@ -11,3 +11,4 @@ $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
 require 'rattler'
 
 require 'rspec/expectations'
+require 'aruba/cucumber'

data/lib/rattler.rb

@@ -23,14 +23,14 @@ module Rattler
     
     # @private
     @@defaults = {
-      :type => :packrat
+      :type => :extended_packrat
     }
     
     # @private
     @@parser_types = {
       :recursive_descent  => :RecursiveDescentParser,
       :packrat            => :PackratParser,
-      :wdm                => :WDMParser
+      :extended_packrat   => :ExtendedPackratParser
     }
     
     # Define parse rules with the given block

data/lib/rattler/back_end/parser_generator.rb

@@ -38,6 +38,7 @@ module Rattler::BackEnd
     autoload :SkipGenerator, 'rattler/back_end/parser_generator/skip_generator'
     autoload :LabelGenerator, 'rattler/back_end/parser_generator/label_generator'
     autoload :FailGenerator, 'rattler/back_end/parser_generator/fail_generator'
+    autoload :RepeatGenerating, 'rattler/back_end/parser_generator/repeat_generating'
     autoload :PredicatePropogating, 'rattler/back_end/parser_generator/predicate_propogating'
     autoload :TokenPropogating, 'rattler/back_end/parser_generator/token_propogating'
     autoload :SkipPropogating, 'rattler/back_end/parser_generator/skip_propogating'

data/lib/rattler/back_end/parser_generator/one_or_more_generator.rb

@@ -3,29 +3,10 @@ require 'rattler/back_end/parser_generator'
 module Rattler::BackEnd::ParserGenerator
   
   # @private
-  class OneOrMoreGenerator < ZeroOrMoreGenerator #:nodoc:
+  class OneOrMoreGenerator < ExprGenerator #:nodoc:
+    include RepeatGenerating
     include PredicatePropogating
     
-    def gen_basic_top_level(one_or_more)
-      if one_or_more.capturing?
-        required_match { super }
-      else
-        gen_skip_top_level one_or_more
-      end
-    end
-    
-    def gen_dispatch_action_top_level(one_or_more, target, method_name)
-      required_match { super }
-    end
-    
-    def gen_direct_action_top_level(one_or_more, action)
-      required_match { super }
-    end
-    
-    def gen_token_top_level(one_or_more)
-      required_match { super }
-    end
-    
     def gen_skip_top_level(one_or_more)
       (@g << "#{result_name} = false").newline
       @g << 'while '
@@ -34,13 +15,12 @@ module Rattler::BackEnd::ParserGenerator
       @g << result_name
     end
     
-    private
-    
-    def required_match
-      yield
-      @g << " unless #{accumulator_name}.empty?"
+    protected
+
+    def gen_result(captures)
+      @g << captures << " unless #{accumulator_name}.empty?"
     end
-    
+
   end
   
   # @private
@@ -56,7 +36,16 @@ module Rattler::BackEnd::ParserGenerator
   # @private
   class TopLevelOneOrMoreGenerator < OneOrMoreGenerator #:nodoc:
     include TopLevel
-    include TopLevelGenerators
+    include NestedGenerators
+
+    def gen_assert(parser)
+      generate parser.child, :gen_assert_top_level
+    end
+    
+    def gen_disallow(parser)
+      generate parser.child, :gen_disallow_top_level
+    end
+    
   end
   
   def OneOrMoreGenerator.top_level(*args)

data/lib/rattler/back_end/parser_generator/repeat_generating.rb

@@ -0,0 +1,69 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+  # @private
+  module RepeatGenerating #:nodoc:
+
+    def gen_basic_nested(repeat)
+      atomic_block { gen_basic_top_level repeat }
+    end
+    
+    def gen_basic_top_level(repeat)
+      if repeat.capturing?
+        gen_loop repeat, :gen_basic_nested
+        gen_result accumulator_name
+      else
+        gen_skip_top_level repeat
+      end
+    end
+    
+    def gen_dispatch_action_nested(repeat, target, method_name)
+      atomic_block do
+        gen_dispatch_action_top_level repeat, target, method_name
+      end
+    end
+    
+    def gen_dispatch_action_top_level(repeat, target, method_name)
+      gen_loop repeat
+      gen_result dispatch_action_result(target, method_name,
+          :array_expr => "select_captures(#{accumulator_name})")
+    end
+    
+    def gen_direct_action_nested(repeat, action)
+      atomic_block { gen_direct_action_top_level repeat, action }
+    end
+    
+    def gen_direct_action_top_level(repeat, action)
+      gen_loop repeat
+      gen_result direct_action_result(action,
+          :bind_args => ["select_captures(#{accumulator_name})"])
+    end
+    
+    def gen_token_nested(repeat)
+      atomic_block { gen_token_top_level repeat }
+    end
+    
+    def gen_token_top_level(repeat)
+      gen_loop repeat, :gen_token
+      gen_result "#{accumulator_name}.join"
+    end
+    
+    def gen_skip_nested(repeat)
+      atomic_block { gen_skip_top_level repeat }
+    end
+    
+    private
+    
+    def gen_loop(repeat, gen_method = :gen_basic)
+      (@g << "#{accumulator_name} = []").newline
+      @g << "while #{result_name} = "
+      generate repeat.child, gen_method
+      @g.block('') { @g << "#{accumulator_name} << #{result_name}" }.newline
+    end
+    
+    def accumulator_name
+      "a#{repeat_level}"
+    end
+    
+  end
+end

data/lib/rattler/back_end/parser_generator/rule_generator.rb

@@ -80,7 +80,7 @@ module Rattler::BackEnd::ParserGenerator
     def gen_parser_def(parser_name, base_name)
       nest_modules(parser_name.split('::')) do |name|
         (@g << "# @private").newline
-        module_block("class #{name} < #{base_name}") { yield }
+        module_block("class #{name} < #{base_name} #:nodoc:") { yield }
       end
     end
     

data/lib/rattler/back_end/parser_generator/zero_or_more_generator.rb

@@ -4,19 +4,7 @@ module Rattler::BackEnd::ParserGenerator
   
   # @private
   class ZeroOrMoreGenerator < ExprGenerator #:nodoc:
-    
-    def gen_basic_nested(zero_or_more)
-      atomic_block { gen_basic_top_level zero_or_more }
-    end
-    
-    def gen_basic_top_level(zero_or_more)
-      if zero_or_more.capturing?
-        gen_loop(zero_or_more)
-        @g << accumulator_name
-      else
-        gen_skip_top_level zero_or_more
-      end
-    end
+    include RepeatGenerating
     
     def gen_assert(optional)
       @g << 'true'
@@ -26,61 +14,19 @@ module Rattler::BackEnd::ParserGenerator
       @g << 'false'
     end
     
-    def gen_dispatch_action_nested(zero_or_more, target, method_name)
-      atomic_block do
-        gen_dispatch_action_top_level zero_or_more, target, method_name
-      end
-    end
-    
-    def gen_dispatch_action_top_level(zero_or_more, target, method_name)
-      gen_loop zero_or_more
-      @g << dispatch_action_result(target, method_name,
-          :array_expr => "select_captures(#{accumulator_name})")
-    end
-    
-    def gen_direct_action_nested(zero_or_more, action)
-      atomic_block { gen_direct_action_top_level zero_or_more, action }
-    end
-    
-    def gen_direct_action_top_level(zero_or_more, action)
-      gen_loop zero_or_more
-      @g << direct_action_result(action,
-          :bind_args => ["select_captures(#{accumulator_name})"])
-    end
-    
-    def gen_token_nested(zero_or_more)
-      atomic_block { gen_token_top_level zero_or_more }
-    end
-    
-    def gen_token_top_level(zero_or_more)
-      gen_loop zero_or_more, :gen_token
-      @g << "#{accumulator_name}.join"
-    end
-    
-    def gen_skip_nested(zero_or_more)
-      atomic_block { gen_skip_top_level zero_or_more }
-    end
-    
-    def gen_skip_top_level(zero_or_more)
+    def gen_skip_top_level(repeat)
       @g << 'while '
-      generate zero_or_more.child, :gen_intermediate_skip
+      generate repeat.child, :gen_intermediate_skip
       (@g << '; end').newline
       @g << 'true'
     end
     
-    private
-    
-    def gen_loop(zero_or_more, gen_method = :gen_basic)
-      (@g << "#{accumulator_name} = []").newline
-      @g << "while #{result_name} = "
-      generate zero_or_more.child, gen_method
-      @g.block('') { @g << "#{accumulator_name} << #{result_name}" }.newline
-    end
-    
-    def accumulator_name
-      "a#{repeat_level}"
+    protected
+
+    def gen_result(captures)
+      @g << captures
     end
-    
+
   end
   
   # @private
@@ -96,7 +42,7 @@ module Rattler::BackEnd::ParserGenerator
   # @private
   class TopLevelZeroOrMoreGenerator < ZeroOrMoreGenerator #:nodoc:
     include TopLevel
-    include TopLevelGenerators
+    include NestedGenerators
   end
   
   def ZeroOrMoreGenerator.top_level(*args)