configgy 0.6

data/CHANGELOG

@@ -0,0 +1,2 @@
+
+v0.5. testing.

data/Manifest

@@ -0,0 +1,10 @@
+CHANGELOG
+Manifest
+Rakefile
+lib/configgy.rb
+lib/configgy/config_map.rb
+lib/configgy/config_parser.rb
+lib/treetop/configgy.rb
+lib/treetop/configgy.treetop
+spec/config_map_spec.rb
+spec/config_parser_spec.rb

data/Rakefile

@@ -0,0 +1,21 @@
+
+require 'rubygems'
+gem 'treetop'
+require 'echoe'
+
+require 'spec/rake/spectask'
+
+Echoe.new("configgy") do |p|
+  p.version = "0.6"
+  p.author = "Robey Pointer"
+  p.email = "robeypointer@gmail.com"
+  p.project = "configgy"
+  p.summary = "config file parser for ruby"
+  p.rdoc_pattern = /README|TODO|LICENSE|CHANGELOG|BENCH|COMPAT|exceptions|behaviors|rails.rb/
+  p.spec_pattern = "spec/*_spec.rb"
+  p.ignore_pattern = [ "configgyrb.tmproj" ]
+end
+
+task :treetop do
+  system("tt lib/treetop/configgy.treetop")
+end

data/configgy.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{configgy}
+  s.version = "0.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Robey Pointer"]
+  s.date = %q{2010-03-01}
+  s.description = %q{config file parser for ruby}
+  s.email = %q{robeypointer@gmail.com}
+  s.extra_rdoc_files = ["CHANGELOG"]
+  s.files = ["CHANGELOG", "Manifest", "Rakefile", "lib/configgy.rb", "lib/configgy/config_map.rb", "lib/configgy/config_parser.rb", "lib/treetop/configgy.rb", "lib/treetop/configgy.treetop", "spec/config_map_spec.rb", "spec/config_parser_spec.rb", "configgy.gemspec"]
+  s.homepage = %q{}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Configgy"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{configgy}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{config file parser for ruby}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/configgy.rb

@@ -0,0 +1,13 @@
+require "rubygems"
+require "treetop"
+require "treetop/configgy"
+require "configgy/config_map"
+require "configgy/config_parser"
+
+class ConfigException < RuntimeError; end
+
+module Configgy
+  def self.load_file(filename)
+    Configgy::ConfigParser.new.load_file(filename)
+  end
+end

data/lib/configgy/config_map.rb

@@ -0,0 +1,141 @@
+module Configgy
+  class ConfigMap
+    attr_reader :name, :cells
+    attr_accessor :root, :monitored, :inherit_from
+
+    def initialize(root, name)
+      @root = root
+      @name = name
+      @monitored = false
+      @inherit_from = nil
+      @cells = {}
+    end
+
+    def create_nested(key)
+      config_map = ConfigMap.new(@root, name == "" ? key : name + "." + key)
+      config_map.monitored = @monitored
+      @cells[key] = config_map
+    end
+
+    # find (ConfigMap, key) after following any dot-separated names
+    def recurse(key, &block)
+      left, right = key.split(".", 2)
+      if right
+        create_nested(left) unless @cells.has_key?(left)
+        raise ConfigException("illegal key #{key}") unless @cells[left].respond_to?(:recurse)
+        @cells[left].recurse(right, &block)
+      else
+        yield [ self, key ]
+      end
+    end
+
+    def lookup_cell(key)
+      left, right = key.split(".", 2)
+      if @cells.has_key?(left)
+        if right
+          if @cells[left].respond_to?(:lookup_cell)
+            @cells[left].lookup_cell(right)
+          else
+            nil
+          end
+        else
+          @cells[left]
+        end
+      elsif @inherit_from
+        @inherit_from.lookup_cell(key)
+      else
+        nil
+      end
+    end
+
+    def []=(key, value)
+      key = key.to_s
+      if @monitored
+        @root.deep_set(@name, key, value)
+      else
+        recurse(key) do |config_map, key|
+          config_map.cells[key] = value
+        end
+      end
+    end
+
+    def [](key)
+      lookup_cell(key.to_s)
+    end
+
+    def delete(key)
+      key = key.to_s
+      if @monitored
+        @root.deep_delete(@name, key)
+      else
+        recurse(key) { |config_map, key| config_map.cells.delete(key) }
+      end
+    end
+
+    def has_key?(key)
+      !lookup_cell(key.to_s).nil?
+    end
+
+    def ==(other)
+      other.instance_of?(self.class) and @cells == other.cells
+    end
+
+    def to_map
+      rv = @cells.dup
+      rv.each do |k, v|
+        if v.instance_of?(ConfigMap)
+          rv[k] = v.to_map
+        end
+      end
+    end
+
+    def copy_to(map)
+      @inherit_from.copy_to(map) if @inherit_from
+      @cells.each do |k, v|
+        # assume everything that doesn't respond to dup is immutable.
+        map[k] = begin v.dup rescue v end
+      end
+    end
+
+    def dup
+      map = ConfigMap.new(@root, @name)
+      copy_to(map)
+      map
+    end
+
+    def merge(map)
+      rv = dup
+      map.each { |k, v| rv[k] = v }
+      rv
+    end
+
+    def to_config_string
+      to_config_list.join("\n") + "\n"
+    end
+
+    def to_config_list
+      @cells.keys.sort.map do |k|
+        v = @cells[k]
+        if v.instance_of?(ConfigMap)
+          [ "#{k}" + (v.inherit_from ? " (inherit=\"#{v.inherit_from.name}\")" : "") + " {", v.to_config_list.map { |s| "  " + s }, "}" ].flatten
+        else
+          "#{k} = #{v.inspect}"
+        end
+      end.flatten
+    end
+
+    def interpolate(s)
+      s.gsub(/(?!\\)\$\((\w[\w\d\._-]*)\)|\\\$/) do |m|
+        if m == "\\$"
+          "$"
+        else
+          ([ self, @root, ENV ].find { |config_map| config_map[$1] } || {})[$1]
+        end
+      end
+    end
+
+    def inspect
+      "{#{@name}" + (@inherit_from ? " (inherit=#{@inherit_from.name})" : "") + ": " + @cells.keys.sort.map { |k| "#{k}=#{@cells[k].inspect}" }.join(" ") + "}"
+    end
+  end
+end

data/lib/configgy/config_parser.rb

@@ -0,0 +1,20 @@
+module Configgy
+  class ConfigParser < Treetop_ConfiggyParser
+    def import_file(filename)
+      File.open(filename, "r").read
+    end
+
+    def read(s, map=nil)
+      if !map
+        map = Configgy::ConfigMap.new(nil, "")
+        map.root = map
+      end
+      parse(s).apply(map, self)
+      map
+    end
+
+    def load_file(filename, map=nil)
+      read(import_file(filename), map)
+    end
+  end
+end

data/lib/treetop/configgy.rb

@@ -0,0 +1,1617 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module Treetop_Configgy
+  include Treetop::Runtime
+
+  def root
+    @root || :root
+  end
+
+  module Root0
+    def d
+      elements[0]
+    end
+
+  end
+
+  module Root1
+    def apply(config_map, parser)
+      d.elements.each { |node| node.apply(config_map, parser) }
+    end
+  end
+
+  def _nt_root
+    start_index = index
+    if node_cache[:root].has_key?(index)
+      cached = node_cache[:root][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    s1, i1 = [], index
+    loop do
+      r2 = _nt_declaration
+      if r2
+        s1 << r2
+      else
+        break
+      end
+    end
+    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+    s0 << r1
+    if r1
+      s3, i3 = [], index
+      loop do
+        r4 = _nt_whitespace
+        if r4
+          s3 << r4
+        else
+          break
+        end
+      end
+      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+      s0 << r3
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Root0)
+      r0.extend(Root1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:root][start_index] = r0
+
+    r0
+  end
+
+  module Declaration0
+    def d
+      elements[1]
+    end
+  end
+
+  module Declaration1
+    def apply(config_map, parser)
+      d.apply(config_map, parser)
+    end
+  end
+
+  def _nt_declaration
+    start_index = index
+    if node_cache[:declaration].has_key?(index)
+      cached = node_cache[:declaration][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    s1, i1 = [], index
+    loop do
+      r2 = _nt_whitespace
+      if r2
+        s1 << r2
+      else
+        break
+      end
+    end
+    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+    s0 << r1
+    if r1
+      i3 = index
+      r4 = _nt_include_file
+      if r4
+        r3 = r4
+      else
+        r5 = _nt_assignment
+        if r5
+          r3 = r5
+        else
+          r6 = _nt_toggle
+          if r6
+            r3 = r6
+          else
+            r7 = _nt_section
+            if r7
+              r3 = r7
+            else
+              @index = i3
+              r3 = nil
+            end
+          end
+        end
+      end
+      s0 << r3
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Declaration0)
+      r0.extend(Declaration1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:declaration][start_index] = r0
+
+    r0
+  end
+
+  module Assignment0
+    def identifier
+      elements[0]
+    end
+
+    def op
+      elements[2]
+    end
+
+    def value
+      elements[4]
+    end
+  end
+
+  module Assignment1
+    def apply(config_map, parser)
+      key = identifier.text_value
+      if (op.text_value == "=") or !config_map.has_key?(key)
+        config_map[key] = value.to_value(config_map)
+      end
+    end
+  end
+
+  def _nt_assignment
+    start_index = index
+    if node_cache[:assignment].has_key?(index)
+      cached = node_cache[:assignment][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_identifier
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_whitespace
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        i4 = index
+        if has_terminal?("=", false, index)
+          r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure("=")
+          r5 = nil
+        end
+        if r5
+          r4 = r5
+        else
+          if has_terminal?("?=", false, index)
+            r6 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure("?=")
+            r6 = nil
+          end
+          if r6
+            r4 = r6
+          else
+            @index = i4
+            r4 = nil
+          end
+        end
+        s0 << r4
+        if r4
+          s7, i7 = [], index
+          loop do
+            r8 = _nt_whitespace
+            if r8
+              s7 << r8
+            else
+              break
+            end
+          end
+          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+          s0 << r7
+          if r7
+            r9 = _nt_value
+            s0 << r9
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Assignment0)
+      r0.extend(Assignment1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:assignment][start_index] = r0
+
+    r0
+  end
+
+  module Toggle0
+    def identifier
+      elements[0]
+    end
+
+    def true_false
+      elements[2]
+    end
+  end
+
+  module Toggle1
+    def apply(config_map, parser)
+      key = identifier.text_value
+      config_map[key] = true_false.to_value
+    end
+  end
+
+  def _nt_toggle
+    start_index = index
+    if node_cache[:toggle].has_key?(index)
+      cached = node_cache[:toggle][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_identifier
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_whitespace
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        r4 = _nt_true_false
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Toggle0)
+      r0.extend(Toggle1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:toggle][start_index] = r0
+
+    r0
+  end
+
+  def _nt_value
+    start_index = index
+    if node_cache[:value].has_key?(index)
+      cached = node_cache[:value][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_number
+    if r1
+      r0 = r1
+    else
+      r2 = _nt_string
+      if r2
+        r0 = r2
+      else
+        r3 = _nt_true_false
+        if r3
+          r0 = r3
+        else
+          r4 = _nt_string_list
+          if r4
+            r0 = r4
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+    end
+
+    node_cache[:value][start_index] = r0
+
+    r0
+  end
+
+  module Whitespace0
+  end
+
+  def _nt_whitespace
+    start_index = index
+    if node_cache[:whitespace].has_key?(index)
+      cached = node_cache[:whitespace][index]
+      @index = cached.interval.end if cached
+      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?("\t", false, index)
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure("\t")
+        r2 = nil
+      end
+      if r2
+        r0 = r2
+      else
+        if has_terminal?("\n", false, index)
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure("\n")
+          r3 = nil
+        end
+        if r3
+          r0 = r3
+        else
+          i4, s4 = index, []
+          if has_terminal?("#", false, index)
+            r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure("#")
+            r5 = nil
+          end
+          s4 << r5
+          if r5
+            s6, i6 = [], index
+            loop do
+              if has_terminal?('\G[^\\n]', true, index)
+                r7 = true
+                @index += 1
+              else
+                r7 = nil
+              end
+              if r7
+                s6 << r7
+              else
+                break
+              end
+            end
+            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+            s4 << r6
+            if r6
+              if has_terminal?("\n", false, index)
+                r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure("\n")
+                r8 = nil
+              end
+              s4 << r8
+            end
+          end
+          if s4.last
+            r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+            r4.extend(Whitespace0)
+          else
+            @index = i4
+            r4 = nil
+          end
+          if r4
+            r0 = r4
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+    end
+
+    node_cache[:whitespace][start_index] = r0
+
+    r0
+  end
+
+  module Number0
+  end
+
+  module Number1
+    def decimal
+      elements[2]
+    end
+  end
+
+  module Number2
+    def to_value(config_map=nil)
+      decimal.text_value.empty? ? text_value.to_i : text_value.to_f
+    end
+  end
+
+  def _nt_number
+    start_index = index
+    if node_cache[:number].has_key?(index)
+      cached = node_cache[:number][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if has_terminal?("-", false, index)
+      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure("-")
+      r2 = nil
+    end
+    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
+      if r3
+        i6, s6 = index, []
+        if has_terminal?(".", false, index)
+          r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure(".")
+          r7 = nil
+        end
+        s6 << r7
+        if r7
+          s8, i8 = [], index
+          loop do
+            if has_terminal?('\G[0-9]', true, index)
+              r9 = true
+              @index += 1
+            else
+              r9 = nil
+            end
+            if r9
+              s8 << r9
+            else
+              break
+            end
+          end
+          if s8.empty?
+            @index = i8
+            r8 = nil
+          else
+            r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+          end
+          s6 << r8
+        end
+        if s6.last
+          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+          r6.extend(Number0)
+        else
+          @index = i6
+          r6 = nil
+        end
+        if r6
+          r5 = r6
+        else
+          r5 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r5
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Number1)
+      r0.extend(Number2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:number][start_index] = r0
+
+    r0
+  end
+
+  module String0
+    def raw
+      elements[1]
+    end
+
+  end
+
+  module String1
+    def to_value(config_map=nil)
+      rv = raw.elements.inject("") { |total, segment| total + segment.unquoted }
+      config_map ? config_map.interpolate(rv) : rv
+    end
+  end
+
+  def _nt_string
+    start_index = index
+    if node_cache[:string].has_key?(index)
+      cached = node_cache[:string][index]
+      @index = cached.interval.end if cached
+      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
+        r3 = _nt_string_innards
+        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)
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure("\"")
+          r4 = nil
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(String0)
+      r0.extend(String1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:string][start_index] = r0
+
+    r0
+  end
+
+  module StringInnards0
+    def unquoted
+      text_value
+    end
+  end
+
+  module StringInnards1
+    def quoted_entity
+      elements[1]
+    end
+  end
+
+  module StringInnards2
+    def unquoted
+      quoted_entity.unquoted
+    end
+  end
+
+  def _nt_string_innards
+    start_index = index
+    if node_cache[:string_innards].has_key?(index)
+      cached = node_cache[:string_innards][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0 = index
+    s1, i1 = [], index
+    loop do
+      if has_terminal?('\G[^\\\\\\"]', true, index)
+        r2 = true
+        @index += 1
+      else
+        r2 = nil
+      end
+      if r2
+        s1 << r2
+      else
+        break
+      end
+    end
+    if s1.empty?
+      @index = i1
+      r1 = nil
+    else
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(StringInnards0)
+    end
+    if r1
+      r0 = r1
+    else
+      i3, s3 = index, []
+      if has_terminal?("\\", false, index)
+        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure("\\")
+        r4 = nil
+      end
+      s3 << r4
+      if r4
+        r5 = _nt_quoted_entity
+        s3 << r5
+      end
+      if s3.last
+        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        r3.extend(StringInnards1)
+        r3.extend(StringInnards2)
+      else
+        @index = i3
+        r3 = nil
+      end
+      if r3
+        r0 = r3
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:string_innards][start_index] = r0
+
+    r0
+  end
+
+  module QuotedEntity0
+    def unquoted
+      case text_value
+        when "r" then "\r"
+        when "n" then "\n"
+        when "t" then "\t"
+        when "$" then "\\$"
+        else text_value
+      end
+    end
+  end
+
+  module QuotedEntity1
+    def hex_digit1
+      elements[0]
+    end
+
+    def hex_digit2
+      elements[1]
+    end
+
+    def hex_digit3
+      elements[2]
+    end
+
+    def hex_digit4
+      elements[3]
+    end
+  end
+
+  module QuotedEntity2
+    def digits
+      elements[1]
+    end
+  end
+
+  module QuotedEntity3
+    def unquoted
+      [ digits.text_value.to_i(16) ].pack("U")
+    end
+  end
+
+  module QuotedEntity4
+    def hex_digit1
+      elements[0]
+    end
+
+    def hex_digit2
+      elements[1]
+    end
+  end
+
+  module QuotedEntity5
+    def digits
+      elements[1]
+    end
+  end
+
+  module QuotedEntity6
+    def unquoted
+      digits.text_value.to_i(16).chr
+    end
+  end
+
+  def _nt_quoted_entity
+    start_index = index
+    if node_cache[:quoted_entity].has_key?(index)
+      cached = node_cache[:quoted_entity][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0 = index
+    if has_terminal?('\G[^ux]', true, index)
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      r1.extend(QuotedEntity0)
+      @index += 1
+    else
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      i2, s2 = index, []
+      if has_terminal?("u", false, index)
+        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure("u")
+        r3 = nil
+      end
+      s2 << r3
+      if r3
+        i4, s4 = index, []
+        r5 = _nt_hex_digit
+        s4 << r5
+        if r5
+          r6 = _nt_hex_digit
+          s4 << r6
+          if r6
+            r7 = _nt_hex_digit
+            s4 << r7
+            if r7
+              r8 = _nt_hex_digit
+              s4 << r8
+            end
+          end
+        end
+        if s4.last
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+          r4.extend(QuotedEntity1)
+        else
+          @index = i4
+          r4 = nil
+        end
+        s2 << r4
+      end
+      if s2.last
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        r2.extend(QuotedEntity2)
+        r2.extend(QuotedEntity3)
+      else
+        @index = i2
+        r2 = nil
+      end
+      if r2
+        r0 = r2
+      else
+        i9, s9 = index, []
+        if has_terminal?("x", false, index)
+          r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure("x")
+          r10 = nil
+        end
+        s9 << r10
+        if r10
+          i11, s11 = index, []
+          r12 = _nt_hex_digit
+          s11 << r12
+          if r12
+            r13 = _nt_hex_digit
+            s11 << r13
+          end
+          if s11.last
+            r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+            r11.extend(QuotedEntity4)
+          else
+            @index = i11
+            r11 = nil
+          end
+          s9 << r11
+        end
+        if s9.last
+          r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+          r9.extend(QuotedEntity5)
+          r9.extend(QuotedEntity6)
+        else
+          @index = i9
+          r9 = nil
+        end
+        if r9
+          r0 = r9
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:quoted_entity][start_index] = r0
+
+    r0
+  end
+
+  def _nt_hex_digit
+    start_index = index
+    if node_cache[:hex_digit].has_key?(index)
+      cached = node_cache[:hex_digit][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    if has_terminal?('\G[0-9a-fA-F]', true, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      r0 = nil
+    end
+
+    node_cache[:hex_digit][start_index] = r0
+
+    r0
+  end
+
+  module TrueFalse0
+    def to_value(config_map=nil)
+      true
+    end
+  end
+
+  module TrueFalse1
+    def to_value(config_map=nil)
+      true
+    end
+  end
+
+  module TrueFalse2
+    def to_value(config_map=nil)
+      false
+    end
+  end
+
+  module TrueFalse3
+    def to_value(config_map=nil)
+      false
+    end
+  end
+
+  def _nt_true_false
+    start_index = index
+    if node_cache[:true_false].has_key?(index)
+      cached = node_cache[:true_false][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0 = index
+    if has_terminal?("true", false, index)
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
+      r1.extend(TrueFalse0)
+      @index += 4
+    else
+      terminal_parse_failure("true")
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      if has_terminal?("on", false, index)
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 2))
+        r2.extend(TrueFalse1)
+        @index += 2
+      else
+        terminal_parse_failure("on")
+        r2 = nil
+      end
+      if r2
+        r0 = r2
+      else
+        if has_terminal?("false", false, index)
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 5))
+          r3.extend(TrueFalse2)
+          @index += 5
+        else
+          terminal_parse_failure("false")
+          r3 = nil
+        end
+        if r3
+          r0 = r3
+        else
+          if has_terminal?("off", false, index)
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 3))
+            r4.extend(TrueFalse3)
+            @index += 3
+          else
+            terminal_parse_failure("off")
+            r4 = nil
+          end
+          if r4
+            r0 = r4
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+    end
+
+    node_cache[:true_false][start_index] = r0
+
+    r0
+  end
+
+  module StringList0
+  end
+
+  module StringList1
+    def item
+      elements[0]
+    end
+
+  end
+
+  module StringList2
+    def list
+      elements[2]
+    end
+
+  end
+
+  module StringList3
+    def to_value(config_map=nil)
+      list.elements.map { |e| e.item.to_value(config_map) }
+    end
+  end
+
+  def _nt_string_list
+    start_index = index
+    if node_cache[:string_list].has_key?(index)
+      cached = node_cache[:string_list][index]
+      @index = cached.interval.end if cached
+      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
+        r3 = _nt_whitespace
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        s4, i4 = [], index
+        loop do
+          i5, s5 = index, []
+          i6 = index
+          r7 = _nt_string
+          if r7
+            r6 = r7
+          else
+            r8 = _nt_number
+            if r8
+              r6 = r8
+            else
+              @index = i6
+              r6 = nil
+            end
+          end
+          s5 << r6
+          if r6
+            i10, s10 = index, []
+            s11, i11 = [], index
+            loop do
+              r12 = _nt_whitespace
+              if r12
+                s11 << r12
+              else
+                break
+              end
+            end
+            r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+            s10 << r11
+            if r11
+              if has_terminal?(",", false, index)
+                r13 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure(",")
+                r13 = nil
+              end
+              s10 << r13
+            end
+            if s10.last
+              r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
+              r10.extend(StringList0)
+            else
+              @index = i10
+              r10 = nil
+            end
+            if r10
+              r9 = r10
+            else
+              r9 = instantiate_node(SyntaxNode,input, index...index)
+            end
+            s5 << r9
+            if r9
+              s14, i14 = [], index
+              loop do
+                r15 = _nt_whitespace
+                if r15
+                  s14 << r15
+                else
+                  break
+                end
+              end
+              r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
+              s5 << r14
+            end
+          end
+          if s5.last
+            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+            r5.extend(StringList1)
+          else
+            @index = i5
+            r5 = nil
+          end
+          if r5
+            s4 << r5
+          else
+            break
+          end
+        end
+        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+        s0 << r4
+        if r4
+          if has_terminal?("]", false, index)
+            r16 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure("]")
+            r16 = nil
+          end
+          s0 << r16
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(StringList2)
+      r0.extend(StringList3)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:string_list][start_index] = r0
+
+    r0
+  end
+
+  module Identifier0
+    def identifier_token
+      elements[1]
+    end
+  end
+
+  module Identifier1
+    def identifier_token
+      elements[0]
+    end
+
+  end
+
+  def _nt_identifier
+    start_index = index
+    if node_cache[:identifier].has_key?(index)
+      cached = node_cache[:identifier][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_identifier_token
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3, s3 = index, []
+        if has_terminal?("\.", false, index)
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure("\.")
+          r4 = nil
+        end
+        s3 << r4
+        if r4
+          r5 = _nt_identifier_token
+          s3 << r5
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(Identifier0)
+        else
+          @index = i3
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Identifier1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:identifier][start_index] = r0
+
+    r0
+  end
+
+  module IdentifierToken0
+  end
+
+  def _nt_identifier_token
+    start_index = index
+    if node_cache[:identifier_token].has_key?(index)
+      cached = node_cache[:identifier_token][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if has_terminal?('\G[\\da-zA-Z]', true, index)
+      r1 = true
+      @index += 1
+    else
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        if has_terminal?('\G[-\\da-zA-Z_]', true, index)
+          r3 = true
+          @index += 1
+        else
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(IdentifierToken0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:identifier_token][start_index] = r0
+
+    r0
+  end
+
+  module Section0
+    def tag_attribute
+      elements[0]
+    end
+
+  end
+
+  module Section1
+    def attributes
+      elements[2]
+    end
+
+  end
+
+  module Section2
+    def identifier_token
+      elements[0]
+    end
+
+    def attribute_list
+      elements[2]
+    end
+
+    def root
+      elements[5]
+    end
+
+  end
+
+  module Section3
+    def apply(config_map, parser)
+      new_name = identifier_token.text_value
+      nested_config_map = Configgy::ConfigMap.new(config_map.root, config_map.name == "" ? new_name : config_map.name + "." + new_name)
+      if attribute_list.elements
+        attribute_list.attributes.elements.map { |e| e.tag_attribute }.each do |attr|
+          case attr.name.text_value
+          when "inherit"
+            v = attr.value.to_value
+            if config_map[v].instance_of?(Configgy::ConfigMap)
+              nested_config_map.inherit_from = config_map[v]
+            elsif config_map.root
+              config_map.root[v] = Configgy::ConfigMap.new(config_map.root, v) unless config_map.root.has_key?(v)
+              if config_map.root[v].instance_of?(Configgy::ConfigMap)
+                nested_config_map.inherit_from = config_map.root[v]
+              else
+                raise ConfigException("can only inherit from blocks")
+              end
+            end
+          end
+        end
+      end
+      config_map[new_name] = nested_config_map
+      root.apply(nested_config_map, parser)
+    end
+  end
+
+  def _nt_section
+    start_index = index
+    if node_cache[:section].has_key?(index)
+      cached = node_cache[:section][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_identifier_token
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_whitespace
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        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
+            r8 = _nt_whitespace
+            if r8
+              s7 << r8
+            else
+              break
+            end
+          end
+          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+          s5 << r7
+          if r7
+            s9, i9 = [], index
+            loop do
+              i10, s10 = index, []
+              r11 = _nt_tag_attribute
+              s10 << r11
+              if r11
+                s12, i12 = [], index
+                loop do
+                  r13 = _nt_whitespace
+                  if r13
+                    s12 << r13
+                  else
+                    break
+                  end
+                end
+                r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
+                s10 << r12
+              end
+              if s10.last
+                r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
+                r10.extend(Section0)
+              else
+                @index = i10
+                r10 = nil
+              end
+              if r10
+                s9 << r10
+              else
+                break
+              end
+            end
+            r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+            s5 << r9
+            if r9
+              if has_terminal?(")", false, index)
+                r14 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure(")")
+                r14 = nil
+              end
+              s5 << r14
+            end
+          end
+        end
+        if s5.last
+          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+          r5.extend(Section1)
+        else
+          @index = i5
+          r5 = nil
+        end
+        if r5
+          r4 = r5
+        else
+          r4 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r4
+        if r4
+          s15, i15 = [], index
+          loop do
+            r16 = _nt_whitespace
+            if r16
+              s15 << r16
+            else
+              break
+            end
+          end
+          r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+          s0 << r15
+          if r15
+            if has_terminal?("{", false, index)
+              r17 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure("{")
+              r17 = nil
+            end
+            s0 << r17
+            if r17
+              r18 = _nt_root
+              s0 << r18
+              if r18
+                if has_terminal?("}", false, index)
+                  r19 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure("}")
+                  r19 = nil
+                end
+                s0 << r19
+              end
+            end
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Section2)
+      r0.extend(Section3)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:section][start_index] = r0
+
+    r0
+  end
+
+  module TagAttribute0
+    def name
+      elements[0]
+    end
+
+    def value
+      elements[2]
+    end
+  end
+
+  def _nt_tag_attribute
+    start_index = index
+    if node_cache[:tag_attribute].has_key?(index)
+      cached = node_cache[:tag_attribute][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if has_terminal?("inherit", false, index)
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 7))
+      @index += 7
+    else
+      terminal_parse_failure("inherit")
+      r1 = nil
+    end
+    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_string
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(TagAttribute0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:tag_attribute][start_index] = r0
+
+    r0
+  end
+
+  module IncludeFile0
+    def string
+      elements[2]
+    end
+  end
+
+  module IncludeFile1
+    def apply(config_map, parser)
+      parser.load_file(string.to_value, config_map)
+    end
+  end
+
+  def _nt_include_file
+    start_index = index
+    if node_cache[:include_file].has_key?(index)
+      cached = node_cache[:include_file][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if has_terminal?("include", false, index)
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 7))
+      @index += 7
+    else
+      terminal_parse_failure("include")
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_whitespace
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        r4 = _nt_string
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(IncludeFile0)
+      r0.extend(IncludeFile1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:include_file][start_index] = r0
+
+    r0
+  end
+
+end
+
+class Treetop_ConfiggyParser < Treetop::Runtime::CompiledParser
+  include Treetop_Configgy
+end
+