rattler 0.4.0 → 0.4.1

data/README.rdoc

@@ -14,7 +14,7 @@ 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.4.0/frames]
+{RDoc}[http://rubydoc.info/gems/rattler/0.4.1/frames]
 
 == FEATURES:
 

data/features/grammar/node_action.feature

@@ -4,7 +4,8 @@ Feature: Node Actions
   expression. A node type is an object (typically a class) that responds to
   the #parsed method. It means to pass the parse results to #parsed and use
   the value returned as the parse result. The parse results are passed as an
-  Array and any attributes are included in a Hash.
+  Array and any attributes are included in a Hash. The action can optionally
+  include a name.
   
   In order to create node objects as parse results
   As a language designer
@@ -28,4 +29,16 @@ Feature: Node Actions
       integer <- @DIGIT+ <>
       """
     When I parse "42"
-    Then the parse result should be Rattler::Runtime::ParseNode["42"]
+    Then the parse result should be Rattler::Runtime::ParseNode["42"]
+  
+  Scenario: Class and node name
+    Given a grammar with:
+      """
+      expr <- @DIGIT+ ~'+' @DIGIT+ <Expr "sum">
+      """
+      And a class definition:
+        """
+        class Expr < Rattler::Runtime::ParseNode; end
+        """
+    When I parse "42+23"
+    Then the parse result should be Expr[["42", "23"], {:name => "sum"}] 

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

@@ -14,5 +14,13 @@ module Rattler::BackEnd::ParserGenerator
       num_groups
     end
 
+    def parse(scanner, rules, scope={})
+      scanner.scan(re) && if num_groups == 1
+        scanner[1]
+      else
+        (1..num_groups).map {|_| scanner[_] }
+      end
+    end
+
   end
 end

data/lib/rattler/grammar/metagrammar.rb

@@ -218,8 +218,72 @@ module Rattler
               @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>[[:lower:]])(?>(?>[[:alnum:]_])*))|(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>(?>(?>[[:upper:]])(?>(?>[[:alnum:]_])*)(?>::))*)(?>[[:upper:]])(?>(?>[[:alnum:]_])*)))(?>(?>(?>\.)(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>[[:lower:]])(?>(?>[[:alnum:]_])*))))?))/) &&
               @scanner[1]
             end) ? [r] : [])) &&
+            (r0_2 = ((r = begin
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>")(?>(?>(?>\\)(?>.)|[^"])*)(?>"))/) &&
+                @scanner[1]
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>')(?>(?>(?>\\)(?>.)|[^'])*)(?>'))/) &&
+                @scanner[1]
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%\()(?>(?>(?>\\)(?>.)|[^)])*)(?>\)))/) &&
+                @scanner[1]
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%\{)(?>(?>(?>\\)(?>.)|[^}])*)(?>\}))/) &&
+                @scanner[1]
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%\[)(?>(?>(?>\\)(?>.)|[^\]])*)(?>\]))/) &&
+                @scanner[1]
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%<)(?>(?>(?>\\)(?>.)|[^>])*)(?>>))/) &&
+                @scanner[1]
+              end ||
+              begin
+                p1 = @scanner.pos
+                begin
+                  @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
+                  begin
+                    p2 = @scanner.pos
+                    begin
+                      @scanner.skip(/%/) &&
+                      (r2_0 = @scanner.scan(/[[:punct:]]/)) &&
+                      begin
+                        while begin
+                          @scanner.skip(/(?>\\)(?>.)/) ||
+                          begin
+                            p3 = @scanner.pos
+                            begin
+                              @scanner.skip(/(?!#{r2_0})/) &&
+                              @scanner.skip(/./) &&
+                              true
+                            end || begin
+                              @scanner.pos = p3
+                              false
+                            end
+                          end
+                        end; end
+                        true
+                      end &&
+                      @scanner.skip(/#{r2_0}/) &&
+                      @scanner.string[p2...(@scanner.pos)]
+                    end || begin
+                      @scanner.pos = p2
+                      false
+                    end
+                  end
+                end || begin
+                  @scanner.pos = p1
+                  false
+                end
+              end
+            end) ? [r] : [])) &&
             @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>>)/) &&
-            DispatchAction.parsed(select_captures([r0_0, r0_1]))
+            DispatchAction.parsed(select_captures([r0_0, r0_1, r0_2]))
           end || begin
             @scanner.pos = p0
             false

data/lib/rattler/grammar/rattler.rtlr

@@ -44,7 +44,7 @@ include Rattler::Parsers
   expression        <-  expression ~'/' attributed                              <Choice>
                       / attributed
 
-  attributed        <-  attributed ~'<' node_action? ~'>'                       <DispatchAction>
+  attributed        <-  attributed ~'<' node_action? literal? ~'>'              <DispatchAction>
                       / attributed ~'{' action ~'}'                             <DirectAction>
                       / terms
 

data/lib/rattler/parsers/dispatch_action.rb

@@ -25,8 +25,13 @@ module Rattler::Parsers
 
     # @private
     def self.parsed(results, *_) #:nodoc:
-      attributed, optional_attribute = results
-      self[attributed, optional_attribute.first || @@node_defaults[:target]]
+      attributed, optional_attribute, optional_name = results
+      a = self[attributed, optional_attribute.first || @@node_defaults[:target]]
+      unless optional_name.empty?
+        a.with_attrs(:target_attrs => {:name => eval(optional_name.first, TOPLEVEL_BINDING)})
+      else
+        a
+      end
     end
 
     # @private
@@ -59,10 +64,11 @@ module Rattler::Parsers
       super(children, self.class.parse_attrs_arg(attrs_arg))
       @@node_defaults.each {|k, v| attrs[k] ||= v } unless attrs[:code]
       @method_name = attrs[:method]
+      @target_attrs = attrs[:target_attrs] || {}
     end
 
     # the name of the method used as the symantic action
-    attr_reader :method_name
+    attr_reader :method_name, :target_attrs
 
     # If the wrapped parser matches at the parse position, return the result
     # of applying the symantic action, otherwise return a false value.
@@ -84,7 +90,7 @@ module Rattler::Parsers
     end
 
     def bindable_code
-      @bindable_code ||= NodeCode.new(target, method_name)
+      @bindable_code ||= NodeCode.new(target, method_name, target_attrs)
     end
 
     def bind(scope, bind_args)

data/lib/rattler/parsers/node_code.rb

@@ -15,12 +15,13 @@ module Rattler::Parsers
       self.new(action.target, action.method_name)
     end
 
-    def initialize(target_name, method_name)
+    def initialize(target_name, method_name, target_attrs = {})
       @target_name = target_name
       @method_name = method_name
+      @target_attrs = target_attrs
     end
 
-    attr_reader :target_name, :method_name
+    attr_reader :target_name, :method_name, :target_attrs
 
     def bind(scope, bind_args)
       args = [array_expr(bind_args)]
@@ -28,6 +29,7 @@ module Rattler::Parsers
         labeled = '{' + scope.map {|k, v| ":#{k} => #{v}"}.join(', ') + '}'
         args << ":labeled => #{labeled}"
       end
+      target_attrs.each {|k, v| args << ":#{k} => #{v.inspect}" }
       t = target_name == 'self' ? '' : "#{target_name}."
       "#{t}#{method_name}(#{args.join ', '})"
     end

data/lib/rattler/util/graphviz/node_builder.rb

@@ -18,7 +18,13 @@ module Rattler::Util::GraphViz
     # Yield any children of +o+ that should be represented as separate nodes in
     # the graph.
     def each_child_of(o)
-      o.each {|_| yield _ } if array_like? o and not record_like? o
+      if array_like? o and not record_like? o
+        if o.respond_to? :to_hash
+          o.each {|k, v| yield Mapping.new(k, v) }
+        else
+          o.each {|_| yield _ }
+        end
+      end
     end
 
     # Return the options for a node representing +o+.
@@ -31,7 +37,7 @@ module Rattler::Util::GraphViz
     # @return the shape option for a node representing +o+.
     def node_shape(o)
       case o
-      when Hash, Array
+      when Array, Hash, Mapping
         'circle'
       when String, Numeric, Symbol
         'plaintext'
@@ -49,6 +55,8 @@ module Rattler::Util::GraphViz
         record_label(o, o)
       elsif array_like? o
         type_label(o)
+      elsif o.respond_to? :to_str
+        "\"#{o}\""
       else
         o.inspect
       end
@@ -58,6 +66,7 @@ module Rattler::Util::GraphViz
       case o
       when Hash then '\\{\\}'
       when Array then '\\[\\]'
+      when Mapping then '->'
       else o.respond_to?(:name) ? o.name : o.class.name
       end
     end
@@ -73,12 +82,26 @@ module Rattler::Util::GraphViz
     end
 
     def record_label(o, h)
-      '{' + ([type_label(o)] + hash_content_labels(h)).join('|') + '}'
+      fields = h.reject {|k,v| k == :name }
+      '{' + ([type_label(o)] + hash_content_labels(fields)).join('|') + '}'
     end
 
     def hash_content_labels(h)
       h.map {|pair| '{' + pair.map {|_| _.inspect }.join('|') + '}' }
     end
 
+    # @private
+    class Mapping #:nodoc:
+      def initialize(key, value)
+        @key = key
+        @value = value
+      end
+      attr_reader :key, :value
+      def each
+        yield key
+        yield value
+      end
+    end
+
   end
 end

data/spec/rattler/back_end/compiler_spec.rb

@@ -5,6 +5,13 @@ describe Rattler::BackEnd::Compiler do
   include CompilerSpecHelper
 
   describe '.compile_parser result' do
+
+    let :compiled_parser do
+      described_class.compile_parser compiled_parser_base, grammar
+    end
+
+    let(:compiled_parser_base) { Rattler::Runtime::RecursiveDescentParser }
+
     it_behaves_like 'a compiled parser'
   end
 

data/spec/rattler/back_end/optimizer_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/shared_compiler_examples')
+
+describe Rattler::BackEnd::Optimizer do
+  include CompilerSpecHelper
+
+  describe '.optimize result' do
+
+    let :compiled_parser do
+      combinator_parser described_class.optimize(grammar)
+    end
+
+    it_behaves_like 'a compiled parser'
+
+  end
+end

data/spec/rattler/back_end/parser_generator/group_match_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::BackEnd::ParserGenerator
+
+describe GroupMatch do
+  include CombinatorParserSpecHelper
+
+  let(:single_group) { GroupMatch[Match[/\s*(\w+)/], {:num_groups => 1}] }
+  let(:multi_group) { GroupMatch[Match[/\s*(\w+)\s+(\w+)/], {:num_groups => 2}] }
+
+  describe '#parse' do
+
+    context 'with a single group' do
+
+      subject { single_group }
+
+      context 'when the regexp matches' do
+        it 'succeeds returning the matched group' do
+          parsing('  abc123  ').should result_in('abc123').at(8)
+        end
+      end
+
+      context 'when the regexp does not match' do
+        it 'fails' do
+          parsing('==').should fail
+        end
+      end
+    end
+
+    context 'with multiple groups' do
+
+      subject { multi_group }
+
+      context 'when the regexp matches' do
+        it 'succeeds returning the matched groups in an array' do
+          parsing(' abc 123 ').should result_in(['abc', '123']).at(8)
+        end
+      end
+    end
+  end
+
+  describe '#capturing?' do
+
+    subject { single_group }
+
+    it 'is true' do
+      subject.should be_capturing
+    end
+  end
+
+end

data/spec/rattler/back_end/shared_compiler_examples.rb

@@ -1,15 +1,9 @@
 shared_examples_for 'a compiled parser' do
   include CompilerSpecHelper
 
-  subject do
-    described_class.compile_parser(compiled_parser_base, grammar)
-  end
-
-  let :reference_parser do
-    Rattler::Parsers::CombinatorParser.as_class(grammar.rules.first, grammar.rules)
-  end
+  subject { compiled_parser }
 
-  let(:compiled_parser_base) { Rattler::Runtime::RecursiveDescentParser }
+  let(:reference_parser) { combinator_parser grammar }
 
   ########## match ##########
   context 'with a match rule' do

data/spec/rattler/grammar/grammar_parser_spec.rb

@@ -167,20 +167,90 @@ describe Rattler::Grammar::GrammarParser do
       end
     end
 
-    it 'parses dispatch-action-attributed expressions' do
-      matching(' expr <Expr> ').as(:expression).
-        should result_in(DispatchAction[Apply[:expr], {:target => 'Expr', :method => 'parsed'}]).
-        at(12)
+    context 'given a dispatch-action-attributed expression' do
+
+      context 'given an action with a class name' do
+        it 'parses as a DispatchAction with the default method' do
+          matching(' expr <Expr> ').as(:expression).
+            should result_in(DispatchAction[Apply[:expr],
+              {:target => 'Expr', :method => 'parsed'}
+            ]).at(12)
+        end
+
+        context 'with a literal' do
+          it 'uses the literal as the name' do
+            matching(' expr <Expr "expression"> ').as(:expression).
+              should result_in(DispatchAction[Apply[:expr],
+                {:target => 'Expr', :method => 'parsed',
+                  :target_attrs => {:name => 'expression'} }
+              ]).at(25)
+          end
+        end
+      end
+
+      context 'given an action with a class and method names' do
+        it 'parses as a DispatchAction with the default method' do
+          matching(' expr <Expr.eval> ').as(:expression).
+            should result_in(DispatchAction[Apply[:expr],
+              {:target => 'Expr', :method => 'eval'}
+            ]).at(17)
+        end
+
+        context 'with a literal' do
+          it 'uses the literal as the name' do
+            matching(' expr <Expr.eval "expression"> ').as(:expression).
+              should result_in(DispatchAction[Apply[:expr],
+                { :target => 'Expr', :method => 'eval',
+                  :target_attrs => {:name => 'expression'} }
+              ]).at(30)
+          end
+        end
+      end
+
+      context 'given an empty action' do
+        it 'parses as a DispatchAction with the default target and method' do
+          matching(' expr <> ').as(:expression).
+            should result_in(DispatchAction[Apply[:expr],
+              {:target => 'Rattler::Runtime::ParseNode', :method => 'parsed'}
+            ]).at(8)
+        end
+      end
+
+      context 'given just a literal' do
+        it 'parses as a default node with the literal as the name' do
+          matching(' expr <"expression"> ').as(:expression).
+            should result_in(DispatchAction[Apply[:expr],
+              { :target => 'Rattler::Runtime::ParseNode',
+                :method => 'parsed',
+                :target_attrs => {:name => 'expression'} }
+            ]).at(20)
+        end
+      end
     end
 
-    it 'parses direct-action-attributed expressions' do
-      matching(' digits {|_| _.to_i} ').as(:expression).
-        should result_in(DirectAction[Apply[:digits], '|_| _.to_i']).at(20)
+    context 'given direct-action-attributed expression' do
+      it 'parses as a DirectAction' do
+        matching(' digits {|_| _.to_i} ').as(:expression).
+          should result_in(DirectAction[Apply[:digits], '|_| _.to_i']).at(20)
+      end
     end
 
-    it 'parses sequence expressions' do
-      matching(' name "=" value ').as(:expression).
-        should result_in(Sequence[Apply[:name], Match[%r{=}], Apply[:value]]).at(15)
+    context 'given a sequence expression' do
+      it 'parses as a Sequence' do
+        matching(' name "=" value ').as(:expression).
+          should result_in(Sequence[Apply[:name], Match[%r{=}], Apply[:value]]).at(15)
+      end
+
+      context 'with a nested sequence expression' do
+        it 'parses as a nested Sequence' do
+          matching(' a (b c) d ').as(:expression).
+            should result_in(Sequence[
+              Apply[:a],
+              Sequence[Apply[:b], Apply[:c]],
+              Apply[:d]
+            ]).at(10)
+        end
+      end
     end
 
     it 'parses attributed sequence expressions' do

data/spec/rattler/parsers/dispatch_action_spec.rb

@@ -3,14 +3,15 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe DispatchAction do
   include CombinatorParserSpecHelper
 
+  subject { DispatchAction[nested_parser] }
+
   describe '#parse' do
 
     context 'with a capturing parser' do
-      subject do
-        DispatchAction[
-          Sequence[Match[/[[:alpha:]]+/], Match[/\=/], Match[/[[:digit:]]+/]]
-        ]
-      end
+
+      let (:nested_parser) { Sequence[
+        Match[/[[:alpha:]]+/], Match[/\=/], Match[/[[:digit:]]+/]
+      ] }
 
       context 'when the parser matches' do
         it 'applies the action to the result' do
@@ -26,6 +27,18 @@ describe DispatchAction do
       end
     end
 
+    context 'with a non-capturing parser' do
+
+      let (:nested_parser) { Skip[Match[/,/]] }
+
+      context 'when the parser matches' do
+        it 'applies the action to an empty array' do
+          parsing(', ').
+          should result_in(Rattler::Runtime::ParseNode.parsed([])).at(1)
+        end
+      end
+    end
+
     context 'with a token parser' do
 
       subject { DispatchAction[Token[Match[/\w+/]]] }

data/spec/rattler/parsers/node_code_spec.rb

@@ -2,10 +2,11 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Rattler::Parsers::NodeCode do
 
-  subject { described_class.new(target_name, method_name) }
+  subject { described_class.new(target_name, method_name, target_attrs) }
 
   let(:target_name) { 'Expr' }
   let(:method_name) { 'parsed' }
+  let(:target_attrs) { {} }
 
   describe '#bind' do
 
@@ -44,5 +45,15 @@ describe Rattler::Parsers::NodeCode do
           should == 'Expr.parsed([a, b], :labeled => {:word => w})'
       end
     end
+
+    context 'with target_attrs' do
+
+      let(:target_attrs) { {:name => 'expression'} }
+
+      it '' do
+        subject.bind(scope, ['a', 'b']).
+          should == 'Expr.parsed([a, b], :name => "expression")'
+      end
+    end
   end
 end

data/spec/rattler/util/graphviz/node_builder_spec.rb

@@ -3,6 +3,46 @@ require 'set'
 
 describe Rattler::Util::GraphViz::NodeBuilder do
 
+  describe '#node_label' do
+
+    context 'given a number' do
+      it 'returns a number as a string' do
+        subject.node_label(42).should == '42'
+      end
+    end
+
+    context 'given a string' do
+      it 'returns the string surrounded by escaped quotes' do
+        subject.node_label('abc').should == '"abc"'
+      end
+    end
+
+    context 'given an unnamed record-like object' do
+      it 'returns a record label with the class name' do
+        subject.node_label(Rattler::Util::Node[]).should == '{Rattler::Util::Node}'
+      end
+    end
+
+    context 'given a named record-like object' do
+      it 'returns a record label with a name' do
+        subject.node_label(Rattler::Util::Node[{:name => 'IDENT'}]).
+          should == '{IDENT}'
+      end
+    end
+
+    context 'given an array-like object' do
+      it 'returns "[]" escaped' do
+        subject.node_label(['let', 'x', '=', '1']).should == '\\[\\]'
+      end
+    end
+
+    context 'given a hash with compound values' do
+      it 'returns "{}" escaped' do
+        subject.node_label({:a => 'a', :b => ['a1', 'a2']}).should == '\\{\\}'
+      end
+    end
+  end
+
   describe '#array_like?' do
 
     context 'given an array' do
@@ -11,7 +51,7 @@ describe Rattler::Util::GraphViz::NodeBuilder do
       end
     end
 
-    context 'given a hash' do
+    context 'given a simple hash' do
       it 'returns true' do
         subject.array_like?({:a => 'a'}).should be_true
       end
@@ -62,10 +102,10 @@ describe Rattler::Util::GraphViz::NodeBuilder do
 
       let(:object) { {:a => ['a1', 'a2'], :b => 'b'} }
 
-      it 'iterates over the pairs' do
+      it 'iterates over the pairs yielding Mappings' do
         children = Set[]
         subject.each_child_of(object) {|_| children << _ }
-        children.should == Set[[:a, ['a1', 'a2']], [:b, 'b']]
+        children.should have(2).mappings
       end
     end
 

data/spec/support/compiler_spec_helper.rb

@@ -6,6 +6,10 @@ module CompilerSpecHelper
     Rattler::Grammar::Grammar.new(Rattler::Parsers.define(&block))
   end
 
+  def combinator_parser(g)
+    Rattler::Parsers::CombinatorParser.as_class(g.rules.first, g.rules)
+  end
+
   RSpec::Matchers.define :parse do |source|
     match do |parser_class|
       parser = parser_class.new(source)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rattler
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-03-12 00:00:00.000000000 -08:00
+date: 2011-03-15 00:00:00.000000000 -07:00
 default_executable: rtlr
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &74294690 !ruby/object:Gem::Requirement
+  requirement: &72971210 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *74294690
+  version_requirements: *72971210
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &74294440 !ruby/object:Gem::Requirement
+  requirement: &72970960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: 1.5.2
   type: :development
   prerelease: false
-  version_requirements: *74294440
+  version_requirements: *72970960
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &74268930 !ruby/object:Gem::Requirement
+  requirement: &72970700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +44,10 @@ dependencies:
         version: 2.3.0
   type: :development
   prerelease: false
-  version_requirements: *74268930
+  version_requirements: *72970700
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &74268690 !ruby/object:Gem::Requirement
+  requirement: &72970430 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,10 +55,10 @@ dependencies:
         version: 0.8.0
   type: :development
   prerelease: false
-  version_requirements: *74268690
+  version_requirements: *72970430
 - !ruby/object:Gem::Dependency
   name: aruba
-  requirement: &74268420 !ruby/object:Gem::Requirement
+  requirement: &72970180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -66,10 +66,10 @@ dependencies:
         version: 0.3.0
   type: :development
   prerelease: false
-  version_requirements: *74268420
+  version_requirements: *72970180
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &74268160 !ruby/object:Gem::Requirement
+  requirement: &72969930 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -77,10 +77,10 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *74268160
+  version_requirements: *72969930
 - !ruby/object:Gem::Dependency
   name: watchr
-  requirement: &74267920 !ruby/object:Gem::Requirement
+  requirement: &72969680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -88,10 +88,10 @@ dependencies:
         version: 0.5.5
   type: :development
   prerelease: false
-  version_requirements: *74267920
+  version_requirements: *72969680
 - !ruby/object:Gem::Dependency
   name: ruby-graphviz
-  requirement: &74267680 !ruby/object:Gem::Requirement
+  requirement: &72969430 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -99,7 +99,7 @@ dependencies:
         version: 0.9.6
   type: :development
   prerelease: false
-  version_requirements: *74267680
+  version_requirements: *72969430
 description: Simple language recognition tool for Ruby based on packrat parsing
 email: jarhart@gmail.com
 executables:
@@ -274,6 +274,7 @@ files:
 - spec/rattler/back_end/optimizer/reduce_repeat_match_spec.rb
 - spec/rattler/back_end/optimizer/simplify_redundant_repeat_spec.rb
 - spec/rattler/back_end/optimizer/simplify_token_match_spec.rb
+- spec/rattler/back_end/optimizer_spec.rb
 - spec/rattler/back_end/parser_generator/apply_generator_spec.rb
 - spec/rattler/back_end/parser_generator/assert_generator_spec.rb
 - spec/rattler/back_end/parser_generator/back_reference_generator_spec.rb
@@ -283,6 +284,7 @@ files:
 - spec/rattler/back_end/parser_generator/dispatch_action_generator_spec.rb
 - spec/rattler/back_end/parser_generator/fail_generator_spec.rb
 - spec/rattler/back_end/parser_generator/group_match_generator_spec.rb
+- spec/rattler/back_end/parser_generator/group_match_spec.rb
 - spec/rattler/back_end/parser_generator/label_generator_spec.rb
 - spec/rattler/back_end/parser_generator/list1_generator_spec.rb
 - spec/rattler/back_end/parser_generator/list_generator_spec.rb
@@ -356,7 +358,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -463546417
+      hash: 156917203
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -416,6 +418,7 @@ test_files:
 - spec/rattler/back_end/optimizer/reduce_repeat_match_spec.rb
 - spec/rattler/back_end/optimizer/simplify_redundant_repeat_spec.rb
 - spec/rattler/back_end/optimizer/simplify_token_match_spec.rb
+- spec/rattler/back_end/optimizer_spec.rb
 - spec/rattler/back_end/parser_generator/apply_generator_spec.rb
 - spec/rattler/back_end/parser_generator/assert_generator_spec.rb
 - spec/rattler/back_end/parser_generator/back_reference_generator_spec.rb
@@ -425,6 +428,7 @@ test_files:
 - spec/rattler/back_end/parser_generator/dispatch_action_generator_spec.rb
 - spec/rattler/back_end/parser_generator/fail_generator_spec.rb
 - spec/rattler/back_end/parser_generator/group_match_generator_spec.rb
+- spec/rattler/back_end/parser_generator/group_match_spec.rb
 - spec/rattler/back_end/parser_generator/label_generator_spec.rb
 - spec/rattler/back_end/parser_generator/list1_generator_spec.rb
 - spec/rattler/back_end/parser_generator/list_generator_spec.rb