lunar_cheese 0.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4932384681af36606d0bb204cf859d9a1b6286ce
+  data.tar.gz: f4ce54c92446ee47a805f58669f14be0f09313f0
+SHA512:
+  metadata.gz: a103d93908ed0087bfd55be0dc9091c6a7b6ce56d41e733e1999b16e1bf749df57e203206c5f9e019cd5309289a778244220a5a226021be2367e9fda09035198
+  data.tar.gz: 81073d37bc2764b7a2c1d5fe66aebc4e1cd69b8f4263efda8962eb5785c3b74e7c19e34414ffad80cde805cffefbbf26a6124cd6df7fdfa20a0b97c0288402f6

data/.yardopts

@@ -0,0 +1,3 @@
+--title "Lunar Cheese"
+--exclude grammar.rb
+--exclude ast.rb

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright 2013 Michael Senn
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

data/README.md

@@ -0,0 +1,44 @@
+# Lunar Cheese
+## Introduction
+This gem allows you to convert between Ruby objects, and Lua table dumps as they are used by the game [Don't Starve](http://www.dontstarvegame.com/).
+
+It consists of:
+
+* A Treetop-based PEG grammar, to parse the Lua table dump into a Ruby object.
+* Additions to Ruby core classes, to dump those objects back into the same format.
+
+If you find any issues, create a ticket on the [issue tracker](https://bitbucket.org/Lavode/lunar-cheese/issues?status=new&status=open).
+
+## Usage
+Example usage, Ruby 1.9 & 2.0
+
+    #!/usr/bin/env ruby
+    # coding: utf-8
+
+    require 'zlib'
+    require 'base64'
+    require 'lunar_cheese'
+
+    raw = IO::read('survival_1')
+    # Base64-decoding, discarding the first eleven bytes
+    decoded = Base64::decode64(raw[11..-1])
+    # Inflating, discarding the first 16 bytes
+    inflated = Zlib::inflate(decoded[16..-1])
+    # Discarding the 'return' string at the beginning
+    input = inflated[7..-1]
+
+    parser = LunarCheese::LuaTableDumpParser.new
+    ast = parser.parse(input)
+    result = ast.to_rb
+    puts result.inspect
+
+## Compatability
+This gem has been tested to work on Ruby 2.0.0-p0, 2.0.0-p247, Ruby 1.9.3-p448 and JRuby 1.7.4.
+
+Note that performance on JRuby is worse by quite a bit. Probably related to [Treetop's constant usage of extend()](https://groups.google.com/forum/#!topic/treetop-dev/aujDDSZw368)
+
+## Contributing
+
+* Fork
+* Feature branch
+* Pull request / git-format-patch

data/Rakefile

@@ -0,0 +1,5 @@
+#coding: utf-8
+
+task :compile_grammar do
+  `rm lib/lunar_cheese/grammar.rb & tt lib/lunar_cheese/grammar.treetop`
+end

data/lib/lunar_cheese.rb

@@ -0,0 +1,6 @@
+#coding: utf-8
+
+require 'treetop'
+
+require_relative 'lunar_cheese/ast'
+require_relative 'lunar_cheese/grammar'

data/lib/lunar_cheese/ast.rb

@@ -0,0 +1,105 @@
+#coding: utf-8
+
+module LunarCheese
+
+  module AST
+
+    class IntegerLiteral < Treetop::Runtime::SyntaxNode
+      def to_rb
+        text_value.to_i
+      end
+
+      def clean_tree
+        elements.delete_if { true }
+      end
+    end
+
+    class FloatLiteral < Treetop::Runtime::SyntaxNode
+      def to_rb
+        text_value.to_f
+      end
+
+      def clean_tree
+        elements.delete_if { true }
+      end
+    end
+
+    class BooleanLit < Treetop::Runtime::SyntaxNode
+      def to_rb
+        text_value == 'true'
+      end
+
+      def clean_tree
+        elements.delete_if { true }
+      end
+    end
+
+    class StringLiteral < Treetop::Runtime::SyntaxNode
+      def to_rb
+        (@internal_text || text.text_value).gsub(/\\"/, '"')
+      end
+
+      def clean_tree
+        # Cleaning the tree will remove the 'text' node, so in order for #to_rb to work we'll have to either
+        # a) keep that node, b) use self.text_value and get rid of leading and closing quote or c) store the value somewhere.
+        @internal_text = text.text_value
+        elements.delete_if { true }
+      end
+    end
+
+    class IdentifierLiteral < Treetop::Runtime::SyntaxNode
+      def to_rb
+        text_value.to_sym
+      end
+
+      def clean_tree
+        elements.delete_if { true }
+      end
+    end
+
+    class Assignment < Treetop::Runtime::SyntaxNode
+      def to_rb
+        { identifier.to_rb => value.to_rb }
+      end
+    end
+
+    class LuaArray < Treetop::Runtime::SyntaxNode
+      def to_rb
+        index = 0
+        other_values.elements.map(&:value).inject({ index => value.to_rb }) do |hash, value|
+          index += 1
+          hash.merge({ index => value.to_rb })
+        end
+      end
+    end
+
+    class LuaHash < Treetop::Runtime::SyntaxNode
+      def to_rb
+        other_assignments.elements.inject(assignment.to_rb) { |hash, comma_and_assignment| hash.merge(comma_and_assignment.assignment.to_rb) }
+      end
+    end
+
+    class LuaTable < Treetop::Runtime::SyntaxNode
+      def to_rb
+        # Todo: Refactor this. Also, the grammar currently allows {,1,2,3} which wouldn't be correct.
+        return {} if text_value == '{}'
+
+        index = 0
+
+        ([child] + other_children.elements.map(&:child)).inject({}) do |result, child|
+          if child.is_a? Assignment
+            result.update(child.to_rb)
+          else
+            result[index] = child.to_rb
+            index += 1
+          end
+        
+          result
+        end
+
+      end
+    end
+
+  end
+
+end

data/lib/lunar_cheese/dump.rb

@@ -0,0 +1,144 @@
+#coding: utf-8
+
+class String
+
+  # Dump the string to a format used by Don't Starve table dumps.
+  # This will a) surround the string with quotation marks (") and b) escape any quotation marks which it contains.
+  #
+  # @example Dumping string
+  #   puts 'Hello "John", if this truly is your name.'.to_lua
+  #   => "Hello \"John\", if this truly is your name."
+  #
+  # @return [String] Dumped version of the string.
+  def to_lua
+    "\"#{ gsub(/"/, '\"') }\""
+  end
+
+end
+
+class Fixnum
+
+  # Dump the fixnum to a format used by Don't Starve table dumps.
+  # This will simply call #to_s
+  #
+  # @example Dumping fixnum
+  #   puts 21.to_lua
+  #   => '21'
+  #
+  # @return [String] Dumped version of the fixnum.
+  def to_lua
+    to_s
+  end
+
+end
+
+class Float
+
+  # Dump the float to a format used by Don't Starve table dumps.
+  # This will simply call #to_s
+  #
+  # @example Dumping float
+  #   puts 21.5.to_lua
+  #   => '21.5'
+  #
+  # @return [String] Dumped version of the float.
+  def to_lua
+    to_s
+  end
+
+end
+
+class FalseClass
+
+  # Dump 'false' to a format used by Don't Starve table dumps.
+  #
+  # @example Dumping 'false'
+  #   puts false.to_lua
+  #   => 'false'
+  #
+  # @return [String] 'false'
+  def to_lua
+    to_s
+  end
+
+end
+
+class TrueClass
+
+  # Dump 'true' to a format used by Don't Starve table dumps.
+  #
+  # @example Dumping 'true'
+  #   puts true.to_lua
+  #   => 'true'
+  #
+  # @return [String] 'true'
+  def to_lua
+    to_s
+  end
+
+end
+
+class Symbol
+
+  # Dump the symbol to a format used by Don't Starve table dumps.
+  # Depending on the symbol this will return a different string:
+  # If it consists of alphanumeric characters & underscores, its string value will be returned.
+  # If it consists of an opening bracket, followed by any amount of characters except an opening or closing bracket, followed by a closing bracket, its string value will be returned.
+  # Else its string value, surrounded by brackets, will be returned.
+  #
+  # @example Dumping alphanumeric + underscore symbol.
+  #   puts :is_alive.to_lua
+  #   => 'is_alive'
+  #
+  # @example Dumping symbol starting and ending with bracket.
+  #   puts :'[3 * 2]'.to_lua
+  #   => '[3 * 2]'
+  #
+  # @example Dumping non-alphanumeric symbol, not enclosed in brackets.
+  # puts :'number one'
+  # => '[number one]'
+  #
+  # @return [String] Dumped version of the symbol.
+  def to_lua
+    s = to_s
+    if s =~ /^[a-zA-Z0-9_]+$/
+      s
+    elsif s=~ /^\[[^\[\]]+\]$/ # An opening bracket, followed by >=1 of anything except an opening or closing bracket, followed by a closing bracket.
+      s
+    else
+      "[#{ s }]"
+    end
+  end
+
+end
+
+class Hash
+
+  # Dump the Hash to a format used by Don't Starve table dumps.
+  # The result will, roughly, contain of a comma-separated list of assignments, which are the result of calling #to_lua on each key and value, and joining them with an '=' sign.
+  # One exemption are Fixnum keys - in those cases, merely the result of calling #to_lua on the value will be part of the result.
+  # This is to make use of the implicit indices in a Lua table dump like '!{1,2,"foo","bar",3}'.
+  #
+  # @example Dumping array-like hash.
+  #   puts { 0 => 'a', 1 => 'b', 2 => 'c' }.to_lua
+  #   => {"a","b","c"}
+  #
+  # @example Dumping nested hash.
+  #   puts { :name => { :first_name => 'John', :last_name => 'Madden' } }.to_lua
+  #   => {name={first_name="John",last_name="Madden"}}
+  #
+  # @return [String] Dumped version of the hash.
+  def to_lua
+
+    results = each_pair.map do |key, value|
+      if key.is_a? Fixnum
+        value.to_lua
+      else
+        "#{key.to_lua}=#{value.to_lua}"
+      end
+    end
+
+    "{#{ results.join(',') }}"
+  end
+
+end

data/lib/lunar_cheese/grammar.rb

@@ -0,0 +1,680 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module LunarCheese
+    module LuaTableDump
+      include Treetop::Runtime
+
+      def root
+        @root ||= :table
+      end
+
+      module Table0
+        def child
+          elements[1]
+        end
+      end
+
+      module Table1
+        def child
+          elements[1]
+        end
+
+        def other_children
+          elements[2]
+        end
+
+      end
+
+      def _nt_table
+        start_index = index
+        if node_cache[:table].has_key?(index)
+          cached = node_cache[:table][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        if has_terminal?('{', false, index)
+          r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('{')
+          r1 = nil
+        end
+        s0 << r1
+        if r1
+          i3 = index
+          r4 = _nt_assignment
+          if r4
+            r3 = r4
+          else
+            r5 = _nt_value
+            if r5
+              r3 = r5
+            else
+              @index = i3
+              r3 = nil
+            end
+          end
+          if r3
+            r2 = r3
+          else
+            r2 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s0 << r2
+          if r2
+            s6, i6 = [], index
+            loop do
+              i7, s7 = index, []
+              if has_terminal?(',', false, index)
+                r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure(',')
+                r8 = nil
+              end
+              s7 << r8
+              if r8
+                i9 = index
+                r10 = _nt_assignment
+                if r10
+                  r9 = r10
+                else
+                  r11 = _nt_value
+                  if r11
+                    r9 = r11
+                  else
+                    @index = i9
+                    r9 = nil
+                  end
+                end
+                s7 << r9
+              end
+              if s7.last
+                r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+                r7.extend(Table0)
+              else
+                @index = i7
+                r7 = nil
+              end
+              if r7
+                s6 << r7
+              else
+                break
+              end
+            end
+            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+            s0 << r6
+            if r6
+              if has_terminal?('}', false, index)
+                r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure('}')
+                r12 = nil
+              end
+              s0 << r12
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(AST::LuaTable,input, i0...index, s0)
+          r0.extend(Table1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:table][start_index] = r0
+
+        r0
+      end
+
+      def _nt_prefix
+        start_index = index
+        if node_cache[:prefix].has_key?(index)
+          cached = node_cache[:prefix][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0 = index
+        if has_terminal?('+', false, index)
+          r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('+')
+          r1 = nil
+        end
+        if r1
+          r0 = r1
+        else
+          if has_terminal?('-', false, index)
+            r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('-')
+            r2 = nil
+          end
+          if r2
+            r0 = r2
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+
+        node_cache[:prefix][start_index] = r0
+
+        r0
+      end
+
+      module Integer0
+      end
+
+      def _nt_integer
+        start_index = index
+        if node_cache[:integer].has_key?(index)
+          cached = node_cache[:integer][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r2 = _nt_prefix
+        if r2
+          r1 = r2
+        else
+          r1 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r1
+        if r1
+          s3, i3 = [], index
+          loop do
+            if has_terminal?('\G[0-9]', true, index)
+              r4 = true
+              @index += 1
+            else
+              r4 = nil
+            end
+            if r4
+              s3 << r4
+            else
+              break
+            end
+          end
+          if s3.empty?
+            @index = i3
+            r3 = nil
+          else
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          end
+          s0 << r3
+        end
+        if s0.last
+          r0 = instantiate_node(AST::IntegerLiteral,input, i0...index, s0)
+          r0.extend(Integer0)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:integer][start_index] = r0
+
+        r0
+      end
+
+      module Float0
+        def integer
+          elements[0]
+        end
+
+      end
+
+      def _nt_float
+        start_index = index
+        if node_cache[:float].has_key?(index)
+          cached = node_cache[:float][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_integer
+        s0 << r1
+        if r1
+          if has_terminal?('.', false, index)
+            r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('.')
+            r2 = nil
+          end
+          s0 << r2
+          if r2
+            s3, i3 = [], index
+            loop do
+              if has_terminal?('\G[0-9]', true, index)
+                r4 = true
+                @index += 1
+              else
+                r4 = nil
+              end
+              if r4
+                s3 << r4
+              else
+                break
+              end
+            end
+            if s3.empty?
+              @index = i3
+              r3 = nil
+            else
+              r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            end
+            s0 << r3
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(AST::FloatLiteral,input, i0...index, s0)
+          r0.extend(Float0)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:float][start_index] = r0
+
+        r0
+      end
+
+      def _nt_boolean
+        start_index = index
+        if node_cache[:boolean].has_key?(index)
+          cached = node_cache[:boolean][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0 = index
+        if has_terminal?('false', false, index)
+          r1 = instantiate_node(AST::BooleanLit,input, index...(index + 5))
+          @index += 5
+        else
+          terminal_parse_failure('false')
+          r1 = nil
+        end
+        if r1
+          r0 = r1
+        else
+          if has_terminal?('true', false, index)
+            r2 = instantiate_node(AST::BooleanLit,input, index...(index + 4))
+            @index += 4
+          else
+            terminal_parse_failure('true')
+            r2 = nil
+          end
+          if r2
+            r0 = r2
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+
+        node_cache[:boolean][start_index] = r0
+
+        r0
+      end
+
+      module String0
+      end
+
+      module String1
+        def text
+          elements[1]
+        end
+
+      end
+
+      def _nt_string
+        start_index = index
+        if node_cache[:string].has_key?(index)
+          cached = node_cache[:string][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        if has_terminal?('"', false, index)
+          r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('"')
+          r1 = nil
+        end
+        s0 << r1
+        if r1
+          s2, i2 = [], index
+          loop do
+            i3 = index
+            if has_terminal?('\"', false, index)
+              r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
+              @index += 2
+            else
+              terminal_parse_failure('\"')
+              r4 = nil
+            end
+            if r4
+              r3 = r4
+            else
+              i5, s5 = index, []
+              i6 = index
+              if has_terminal?('"', false, index)
+                r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure('"')
+                r7 = nil
+              end
+              if r7
+                r6 = nil
+              else
+                @index = i6
+                r6 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s5 << r6
+              if r6
+                if index < input_length
+                  r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure("any character")
+                  r8 = nil
+                end
+                s5 << r8
+              end
+              if s5.last
+                r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+                r5.extend(String0)
+              else
+                @index = i5
+                r5 = nil
+              end
+              if r5
+                r3 = r5
+              else
+                @index = i3
+                r3 = nil
+              end
+            end
+            if r3
+              s2 << r3
+            else
+              break
+            end
+          end
+          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+          s0 << r2
+          if r2
+            if has_terminal?('"', false, index)
+              r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure('"')
+              r9 = nil
+            end
+            s0 << r9
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(AST::StringLiteral,input, i0...index, s0)
+          r0.extend(String1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:string][start_index] = r0
+
+        r0
+      end
+
+      module Identifier0
+      end
+
+      module Identifier1
+      end
+
+      def _nt_identifier
+        start_index = index
+        if node_cache[:identifier].has_key?(index)
+          cached = node_cache[:identifier][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0 = index
+        i1, s1 = index, []
+        if has_terminal?('\G[a-zA-Z_]', true, index)
+          r2 = true
+          @index += 1
+        else
+          r2 = nil
+        end
+        s1 << r2
+        if r2
+          s3, i3 = [], index
+          loop do
+            if has_terminal?('\G[a-zA-Z0-9_]', true, index)
+              r4 = true
+              @index += 1
+            else
+              r4 = nil
+            end
+            if r4
+              s3 << r4
+            else
+              break
+            end
+          end
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          s1 << r3
+        end
+        if s1.last
+          r1 = instantiate_node(AST::IdentifierLiteral,input, i1...index, s1)
+          r1.extend(Identifier0)
+        else
+          @index = i1
+          r1 = nil
+        end
+        if r1
+          r0 = r1
+        else
+          i5, s5 = index, []
+          if has_terminal?('[', false, index)
+            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('[')
+            r6 = nil
+          end
+          s5 << r6
+          if r6
+            s7, i7 = [], index
+            loop do
+              if has_terminal?('\G[^\\[\\]]', true, index)
+                r8 = true
+                @index += 1
+              else
+                r8 = nil
+              end
+              if r8
+                s7 << r8
+              else
+                break
+              end
+            end
+            if s7.empty?
+              @index = i7
+              r7 = nil
+            else
+              r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+            end
+            s5 << r7
+            if r7
+              if has_terminal?(']', false, index)
+                r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure(']')
+                r9 = nil
+              end
+              s5 << r9
+            end
+          end
+          if s5.last
+            r5 = instantiate_node(AST::IdentifierLiteral,input, i5...index, s5)
+            r5.extend(Identifier1)
+          else
+            @index = i5
+            r5 = nil
+          end
+          if r5
+            r0 = r5
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+
+        node_cache[:identifier][start_index] = r0
+
+        r0
+      end
+
+      def _nt_value
+        start_index = index
+        if node_cache[:value].has_key?(index)
+          cached = node_cache[:value][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0 = index
+        r1 = _nt_float
+        if r1
+          r0 = r1
+        else
+          r2 = _nt_integer
+          if r2
+            r0 = r2
+          else
+            r3 = _nt_string
+            if r3
+              r0 = r3
+            else
+              r4 = _nt_boolean
+              if r4
+                r0 = r4
+              else
+                r5 = _nt_table
+                if r5
+                  r0 = r5
+                else
+                  @index = i0
+                  r0 = nil
+                end
+              end
+            end
+          end
+        end
+
+        node_cache[:value][start_index] = r0
+
+        r0
+      end
+
+      module Assignment0
+        def identifier
+          elements[0]
+        end
+
+        def value
+          elements[2]
+        end
+      end
+
+      def _nt_assignment
+        start_index = index
+        if node_cache[:assignment].has_key?(index)
+          cached = node_cache[:assignment][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_identifier
+        s0 << r1
+        if r1
+          if has_terminal?('=', false, index)
+            r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('=')
+            r2 = nil
+          end
+          s0 << r2
+          if r2
+            r3 = _nt_value
+            s0 << r3
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(AST::Assignment,input, i0...index, s0)
+          r0.extend(Assignment0)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:assignment][start_index] = r0
+
+        r0
+      end
+
+    end
+
+    class LuaTableDumpParser < Treetop::Runtime::CompiledParser
+      include LuaTableDump
+    end
+
+end