toml 0.0.4 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6fe891b78d0c8ef3788c8abe359d4350bc1a1a9774d2576c94b8840160acee62
+  data.tar.gz: 948287584ed396f0f07bdaf358f4263f25528a5de4ccb3b8cfecabc1514936fb
+SHA512:
+  metadata.gz: 867a7f6183e52213106e50d68e8e2e1262b87875a6cbe20e43637803011d3796bc77ad50e5e6c64e778cd84ebb833fad474f39ac8abc605e1a436e41aff24edd
+  data.tar.gz: efd7be04b02c6487ce8a1bc686e8943f426ceb8054852eebb944ba655bcab152b299dd6a189f73d5671df16446cdeeb11d0bea2fe51171aad661c392efbfb4bb

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+## 0.3.0 / 2020-06-09
+
+- Fix "undefined method `ascii_tree' for nil:NilClass" when printing parse error
+- Fixes TOML to work with version 2.0 of Parslet
+
+## 0.2.0 / 2017-11-11
+
+- Add support for underscored Integers and Floats
+- Fixes TOML to work with version 1.8.0 of Parslet
+
+## 0.1.2 / 2014-10-16
+
+- Add support for `CR` and `CRLF` newlines (#13)
+- Add support for generating TOML from Ruby `Hash`es (#36)
+- Add a script interface for @BurntSushi's `toml-test` utility (#38)
+
+## 0.1.1 / 2014-02-17
+
+- Add license to gemspec (#26)
+- Loosen `multi_json` dependency version specified (#27)
+- `Generator` should print empty hash tables but not keys without values (#28)

data/README.md

@@ -1,15 +1,25 @@
 # TOML
 
-A sane configuration format from @mojombo.  More information here: https://github.com/mojombo/toml
+A Ruby parser for [TOML](https://github.com/mojombo/toml), built on [parslet](https://github.com/kschiess/parslet).
 
 This is far superior to YAML and JSON because it doesn't suck.  Really it doesn't.
 
+<<<<<<< HEAD
+=======
+[![Gem Version](https://badge.fury.io/rb/toml.svg)](http://badge.fury.io/rb/toml)
+
+>>>>>>> Update README
 ## Usage
 
-Add to your Gemfile:
+Install this library:
 
+<<<<<<< HEAD
 ```ruby
-gem "toml", "~> 0.0.3"
+gem "toml", "~> 0.3.0"
+=======
+```bash
+gem install "toml"
+>>>>>>> Update README
 ```
 
 It's simple, really.
@@ -38,6 +48,8 @@ TOML.load_file("my_file.toml")
 # => {"whatever" => "keys"}
 ```
 
+In case a syntax error occurs, the parser will raise a `Parslet::ParseFailed` exception.
+
 There's also a beta feature for generating a TOML file from a Ruby hash. Please note this will likely not give beautiful output right now.
 
 ```ruby

data/lib/toml.rb

@@ -3,8 +3,9 @@ $:.unshift(File.dirname(__FILE__))
 require 'time'
 require 'parslet'
 
+require 'toml/version'
 require 'toml/key'
-require 'toml/key_group'
+require 'toml/table'
 require 'toml/parslet'
 require 'toml/transformer'
 require 'toml/parser'
@@ -14,8 +15,6 @@ require 'toml/generator'
 # require 'toml/monkey_patch
 
 module TOML
-  VERSION = '0.0.4'
-
   def self.load(content)
     Parser.new(content).parsed
   end
@@ -23,4 +22,4 @@ module TOML
   def self.load_file(path)
     Parser.new(File.read(path)).parsed
   end
-end
+end

data/lib/toml/generator.rb

@@ -8,10 +8,8 @@ module TOML
       # used by TOML.
       self.class.inject!
       
-      @body = ""
       @doc = doc
-      
-      visit(@doc)
+      @body = doc.to_toml
       
       return @body
     end
@@ -27,42 +25,5 @@ module TOML
       require 'toml/monkey_patch'
       @@injected = true
     end
-    
-    def visit(hash, path = "")
-      hash_pairs = [] # Sub-hashes
-      other_pairs = []
-      
-      hash.keys.sort.each do |key|
-        val = hash[key]
-        # TODO: Refactor for other hash-likes (OrderedHash)
-        if val.is_a? Hash
-          hash_pairs << [key, val]
-        else
-          other_pairs << [key, val]
-        end
-      end
-      
-      # Handle all the key-values
-      if !path.empty? && !other_pairs.empty?
-        @body += "[#{path}]\n"
-      end
-      other_pairs.each do |pair|
-        key, val = pair
-        @body += "#{key} = #{format(val)}\n"
-      end
-      @body += "\n" unless other_pairs.empty?
-      
-      # Then deal with sub-hashes
-      hash_pairs.each do |pair|
-        key, hash = pair
-        visit(hash, (path.empty? ? key : [path, key].join(".")))
-      end
-    end#visit
-    
-    # Returns the value formatted for TOML.
-    def format(val)
-      val.to_toml
-    end
-    
   end#Generator
 end#TOML

data/lib/toml/monkey_patch.rb

@@ -1,21 +1,87 @@
 # Adds to_toml methods to base Ruby classes used by the generator.
+class Object
+  def toml_table?
+    self.kind_of?(Hash)
+  end
+  def toml_table_array?
+    self.kind_of?(Array) && self.first.toml_table?
+  end
+end
+class Hash
+  def to_toml(path = "")
+    return "" if self.empty?
+
+    tables = {}
+    values = {}
+    self.keys.sort.each do |key|
+      val = self[key]
+      if val.kind_of?(NilClass)
+        next
+      elsif val.toml_table? || val.toml_table_array?
+        tables[key] = val
+      else
+        values[key] = val
+      end
+    end
+
+    toml = ""
+    values.each do |key, val|
+      toml << "#{key} = #{val.to_toml(key)}\n"
+    end
+
+    tables.each do |key, val|
+      key = "#{path}.#{key}" unless path.empty?
+      toml_val = val.to_toml(key)
+      unless toml_val.empty?
+        if val.toml_table?
+          non_table_vals = val.values.reject do |v|
+            v.toml_table? || v.toml_table_array?
+          end
+
+          # Only add the table key if there are non table values.
+          if non_table_vals.length > 0
+            toml << "\n[#{key}]\n"
+          end
+        end
+        toml << toml_val
+      end
+    end
+
+    toml
+  end
+end
+class Array
+  def to_toml(path = "")
+    unless self.map(&:class).uniq.length == 1
+      raise "All array values must be the same type"
+    end
+
+    if self.first.toml_table?
+      toml = ""
+      self.each do |val|
+        toml << "\n[[#{path}]]\n"
+        toml << val.to_toml(path)
+      end
+      return toml
+    else
+      "[" + self.map {|v| v.to_toml(path) }.join(",") + "]"
+    end
+  end
+end
 class TrueClass
-  def to_toml; "true"; end
+  def to_toml(path = ""); "true"; end
 end
 class FalseClass
-  def to_toml; "false"; end
+  def to_toml(path = ""); "false"; end
 end
 class String
-  def to_toml; self.inspect; end
+  def to_toml(path = ""); self.inspect; end
 end
 class Numeric
-  def to_toml; self.to_s; end
+  def to_toml(path = ""); self.to_s; end
 end
-class Array
-  def to_toml
-    unless self.map(&:class).uniq.length < 2
-      raise "All array values must be the same type"
-    end
-    "[" + self.map {|v| v.to_toml }.join(",") + "]"
+class DateTime
+  def to_toml(path = "")
+    self.rfc3339
   end
 end

data/lib/toml/parser.rb

@@ -4,22 +4,25 @@ module TOML
 
     def initialize(markup)
       # Make sure we have a newline on the end
-      markup += "\n" unless markup.end_with?("\n")
-
-      begin
-        tree = Parslet.new.parse(markup)
-      rescue Parslet::ParseFailed => failure
-        puts failure.cause.ascii_tree
-      end
-      
-      parts = Transformer.new.apply(tree)
       
+      markup += "\n" unless markup.end_with?("\n") || markup.length == 0
+      tree = Parslet.new.parse(markup)
+
+      parts = Transformer.new.apply(tree) || []
       @parsed = {}
       @current = @parsed
       @current_path = ''
       
       parts.each do |part|
         if part.is_a? Key
+          # If @current is an array then we're in a key-group
+          if @current.is_a? Array
+            # Make sure there's a table to work with.
+            @current << {} if @current.last.nil?
+            # Set the key on the table.
+            @current.last[part.key] = part.value
+            next
+          end
           # Make sure the key isn't already set
           if !@current.is_a?(Hash) || @current.has_key?(part.key)
             err = "Cannot override key '#{part.key}'"
@@ -30,28 +33,62 @@ module TOML
           end
           # Set the key-value into the current hash
           @current[part.key] = part.value
-        elsif part.is_a? KeyGroup
-          resolve_key_group(part)
+        elsif part.is_a?(TableArray)
+          resolve_table_array(part)
+        elsif part.is_a?(Table)
+          resolve_table(part)
         else
           raise "Unrecognized part: #{part.inspect}"
         end
       end
     end
     
-    def resolve_key_group(kg)
+    def resolve_table_array(t)
       @current = @parsed
-
-      path = kg.keys.dup
+      path = t.name.dup
       @current_path = path.join('.')
-      
-      while k = path.shift
-        if @current.has_key? k
-          # pass
+      while n = path.shift
+        # If it's a table-array then get the last item.
+        @current = @current.last if @current.is_a? Array
+        
+        # If it's the last item:
+        if path.length == 0
+          # If the current table has an item:
+          if @current.has_key?(n)
+            # And that item is already a table-array:
+            if @current[n].is_a? Array
+              # Then add an item to that table-array.
+              @current[n] << {}
+            else
+              raise "Cannot override table array '#{t.name.join '.'}'"
+            end
+          else
+            # Create a new table array if nothing exists here.
+            @current[n] = []
+          end
+        elsif @current.has_key? n
+          # Don't do anything if we're just moving into tables.
         else
-          @current[k] = {}
+          @current[n] = {}
         end
-        @current = @current[k]
+        @current = @current[n]
       end
     end
+    
+    def resolve_table(t)
+      @current = @parsed
+
+      path = t.name.dup
+      @current_path = path.join('.')
+      while k = path.shift
+        # If it's a table-array then get the last item.
+        @current = @current.last if @current.is_a? Array
+        # Create a new table if one doesn't exist.
+        @current[k] = {} if !@current.has_key? k
+        # Move into the table.
+        @current = @current[k]
+      end
+    end#/resolve_key_group
+    
   end
 end

data/lib/toml/parslet.rb

@@ -2,7 +2,7 @@ module TOML
   class Parslet < ::Parslet::Parser
     rule(:document) {
       all_space >>
-      (key_group | key_value | comment_line).repeat(0) >>
+      (comment_line | table | table_array | key_value).repeat >>
       all_space
     }
     root :document
@@ -11,81 +11,104 @@ module TOML
       array |
       string |
       datetime.as(:datetime) |
+      datetime_rfc3339.as(:datetime_rfc3339) |
       float.as(:float) |
       integer.as(:integer) |
       boolean
     }
-    
+
     # Finding comments in multiline arrays requires accepting a bunch of
     # possible newlines and stuff before the comment
-    rule(:array_comments) { (all_space >> comment_line).repeat(0) }
-    
+    rule(:array_comments) { (all_space >> comment_line).repeat }
+
     rule(:array) {
-      str("[") >> ( array_comments >> # Match any comments on first line
+      str("[") >> all_space >> array_comments >>
+      ( array_comments >> # Match any comments on first line
         all_space >> value >> array_comments >>
         (
           # Separator followed by any comments
           all_space >> str(",") >> array_comments >>
           # Value followed by any comments
           all_space >> value >> array_comments
-        ).repeat(0) >>
+        ).repeat >>
+        (all_space >> str(",")).maybe >> # possible trailing comma
         all_space >> array_comments # Grab any remaining comments just in case
-      ).maybe.as(:array) >> str("]") 
+      ).maybe.as(:array) >> str("]")
     }
-    
-    rule(:key_value) { 
+
+    rule(:key_value) {
       space >> key.as(:key) >>
       space >> str("=") >>
       space >> value.as(:value) >>
-      space >> comment.maybe >> str("\n") >> all_space
+      space >> comment.maybe >> newline >> all_space
     }
-    rule(:key_group) {
+    rule(:table) {
       space >> str("[") >>
-        key_group_name.as(:key_group) >>
+        table_name.as(:table) >>
       str("]") >>
+      space >> comment.maybe >> newline >> all_space
+    }
+    rule(:table_array) {
+      space >> str("[[") >>
+        table_name.as(:table_array) >>
+      str("]]") >>
       space >> comment.maybe >> str("\n") >> all_space
     }
-    
-    rule(:key) { match("[^. \t\\]]").repeat(1) }
-    rule(:key_group_name) { key.as(:key) >> (str(".") >> key.as(:key)).repeat(0) }
 
-    rule(:comment_line) { comment >> str("\n") >> all_space }
-    rule(:comment) { str("#") >> match("[^\n]").repeat(0) }
+    rule(:key) { match["^. \t\\]"].repeat(1) }
+    rule(:table_name) { key.as(:key) >> (str(".") >> key.as(:key)).repeat }
+
+    rule(:comment_line) { comment >> newline >> all_space }
+    rule(:comment) { str("#") >> match["^\n"].repeat }
+
+    rule(:space) { match[" \t"].repeat }
+    rule(:all_space) { match[" \t\r\n"].repeat }
+    rule(:newline) { str("\r").maybe >> str("\n") | str("\r") >> str("\n").maybe }
 
-    rule(:space) { match("[ \t]").repeat(0) }
-    rule(:all_space) { match("[ \t\r\n]").repeat(0) }
-        
     rule(:string) {
       str('"') >> (
-      match("[^\"\\\\]") |
-      (str("\\") >> match("[0tnr\"\\\\]"))
-      ).repeat(0).as(:string) >> str('"')
+      match["^\"\\\\"] |
+      (str("\\") >> match["0tnr\"\\\\"])
+      ).repeat.as(:string) >> str('"')
     }
-    
+
     rule(:sign) { str("-") }
     rule(:sign?) { sign.maybe }
-    
+
     rule(:integer) {
-      str("0") | (sign? >> match("[1-9]") >> match("[0-9]").repeat(0))
+      str("0") | sign? >>
+      (match["1-9"] >> (match["_"].maybe >> match["0-9"]).repeat)
     }
     rule(:float) {
-      sign? >> match("[0-9]").repeat(1) >> str(".") >> match("[0-9]").repeat(1)
+      sign? >>
+      (match["0-9"] >> (match["_"].maybe >> match["0-9"]).repeat) >> str(".") >>
+      (match["0-9"] >> (match["_"].maybe >> match["0-9"]).repeat)
     }
 
     rule(:boolean) { str("true").as(:true) | str("false").as(:false) }
-    
+
     rule(:date) {
-      match("[0-9]").repeat(4,4) >> str("-") >>
-      match("[0-9]").repeat(2,2) >> str("-") >>
-      match("[0-9]").repeat(2,2)
+      match["0-9"].repeat(4,4) >> str("-") >>
+      match["0-9"].repeat(2,2) >> str("-") >>
+      match["0-9"].repeat(2,2)
     }
 
     rule(:time) {
-      match("[0-9]").repeat(2,2) >> str(":") >>
-      match("[0-9]").repeat(2,2) >> str(":") >>
-      match("[0-9]").repeat(2,2)
+      match["0-9"].repeat(2,2) >> str(":") >>
+      match["0-9"].repeat(2,2) >> str(":") >>
+      match["0-9"].repeat(2,2)
+    }
+
+    rule(:timezone) {
+      match["0-9"].repeat(2,2) >> str(":") >>
+      match["0-9"].repeat(2,2)
     }
 
     rule(:datetime) { date >> str("T") >> time >> str("Z") }
+
+    rule(:datetime_rfc3339) {
+      # rfc3339 section 5.6 allows replacing 'T' with a space.
+      date >> (str("T") | str(" ")) >> time >> (str("+") | str("-")) >> timezone
+    }
   end
-end
+end

data/lib/toml/table.rb

@@ -0,0 +1,10 @@
+module TOML
+  class Table
+    # :name is array of strings
+    attr_reader :name
+    def initialize(name)
+      @name = name
+    end
+  end
+  class TableArray < Table; end
+end

data/lib/toml/transformer.rb

@@ -7,9 +7,9 @@ module TOML
       s = 0
       o = []
       while s < e
-        if val[s] == "\\"
+        if val[s].chr == "\\"
           s += 1
-          case val[s]
+          case val[s].chr
           when "t"
             o << "\t"
           when "n"
@@ -26,7 +26,7 @@ module TOML
             raise "Unexpected escape character: '\\#{val[s]}'"
           end
         else
-          o << val[s]
+          o << val[s].chr
         end
         s += 1
       end
@@ -36,6 +36,11 @@ module TOML
     # Clean up arrays
     # rule(:array => subtree(:ar)) { ar.is_a?(Array) ? ar : [ar] }
     
+    # Empty file
+    rule('') {
+      nil
+    }
+
     # Clean up simple value hashes
     rule(:integer => simple(:i)) { i.to_i }
     rule(:float => simple(:f)) { f.to_f }
@@ -47,6 +52,7 @@ module TOML
       ""
     }
     rule(:datetime => simple(:d)) { DateTime.iso8601(d) }
+    rule(:datetime_rfc3339 => simple(:d)) { DateTime.rfc3339(d) }
     rule(:true => simple(:b)) { true }
     rule(:false => simple(:b)) { false }
     
@@ -87,14 +93,24 @@ module TOML
     # Make key hashes (inside key_groups) just be strings
     rule(:key => simple(:k)) { k }
 
-    # Then objectify the key_groups
-    rule(:key_group => simple(:kg)) {
-      KeyGroup.new([kg.to_s])
+    # Captures array-like key-groups
+    rule(:table => subtree(:kg)) {
+      Table.new(kg.map &:to_s)
     }
 
-    # Captures array-like key-groups
-    rule(:key_group => subtree(:kg)) {
-      KeyGroup.new(kg.map &:to_s)
+     # Then objectify the key_groups
+    rule(:table => simple(:kg)) {
+      Table.new([kg.to_s])
+    }
+    
+    # Multi-part (a.b.c) table-arrays
+    rule(:table_array => subtree(:names)) {
+      TableArray.new(names.map &:to_s)
+    }
+
+    # Single name table-arrays
+    rule(:table_array => simple(:name)) {
+      TableArray.new([name.to_s])
     }
   end
 end

data/lib/toml/version.rb

@@ -0,0 +1,3 @@
+module TOML
+  VERSION = '0.3.0'
+end

metadata

@@ -1,31 +1,48 @@
 --- !ruby/object:Gem::Specification
 name: toml
 version: !ruby/object:Gem::Version
-  version: 0.0.4
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Jeremy McAnally
 - Dirk Gadsden
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-03-28 00:00:00.000000000 Z
+date: 2021-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.8.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Parse your TOML, seriously.
@@ -35,49 +52,42 @@ extensions: []
 extra_rdoc_files:
 - README.md
 - LICENSE
+- CHANGELOG.md
 files:
-- Gemfile
+- CHANGELOG.md
 - LICENSE
 - README.md
-- Rakefile
 - lib/toml.rb
 - lib/toml/generator.rb
 - lib/toml/key.rb
-- lib/toml/key_group.rb
 - lib/toml/monkey_patch.rb
 - lib/toml/parser.rb
 - lib/toml/parslet.rb
+- lib/toml/table.rb
 - lib/toml/transformer.rb
-- test/spec.toml
-- test/test_generator.rb
-- test/test_parser.rb
-- test/tmp.rb
-- toml.gemspec
+- lib/toml/version.rb
 homepage: http://github.com/jm/toml
-licenses: []
-post_install_message: 
+licenses:
+- MIT
+metadata: {}
+post_install_message:
 rdoc_options:
-- --charset=UTF-8
+- "--charset=UTF-8"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.23
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 2
 summary: Parse your TOML.
-test_files:
-- test/test_generator.rb
-- test/test_parser.rb
+test_files: []

data/Gemfile

@@ -1,8 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in toml.gemspec
-gemspec
-
-group :test do
-  gem 'minitest'
-end

data/Rakefile

@@ -1,150 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'date'
-
-#############################################################################
-#
-# Helper functions
-#
-#############################################################################
-
-def name
-  @name ||= Dir['*.gemspec'].first.split('.').first
-end
-
-def version
-  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
-  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
-end
-
-def date
-  Date.today.to_s
-end
-
-def rubyforge_project
-  name
-end
-
-def gemspec_file
-  "#{name}.gemspec"
-end
-
-def gem_file
-  "#{name}-#{version}.gem"
-end
-
-def replace_header(head, header_name)
-  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
-end
-
-#############################################################################
-#
-# Standard tasks
-#
-#############################################################################
-
-task :default => :test
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-
-desc "Generate RCov test coverage and open in your browser"
-task :coverage do
-  require 'rcov'
-  sh "rm -fr coverage"
-  sh "rcov test/test_*.rb"
-  sh "open coverage/index.html"
-end
-
-require 'rdoc/task'
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "#{name} #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-desc "Open an irb session preloaded with this library"
-task :console do
-  sh "irb -rubygems -r ./lib/#{name}.rb"
-end
-
-#############################################################################
-#
-# Custom tasks (add your own tasks here)
-#
-#############################################################################
-
-
-
-#############################################################################
-#
-# Packaging tasks
-#
-#############################################################################
-
-desc "Create tag v#{version} and build and push #{gem_file} to Rubygems"
-task :release => :build do
-  unless `git branch` =~ /^\* master$/
-    puts "You must be on the master branch to release!"
-    exit!
-  end
-  sh "git commit --allow-empty -a -m 'Release #{version}'"
-  sh "git tag v#{version}"
-  sh "git push origin master"
-  sh "git push origin v#{version}"
-  sh "gem push pkg/#{name}-#{version}.gem"
-end
-
-desc "Build #{gem_file} into the pkg directory"
-task :build => :gemspec do
-  sh "mkdir -p pkg"
-  sh "gem build #{gemspec_file}"
-  sh "mv #{gem_file} pkg"
-end
-
-desc "Generate #{gemspec_file}"
-task :gemspec => :validate do
-  # read spec file and split out manifest section
-  spec = File.read(gemspec_file)
-  head, manifest, tail = spec.split("  # = MANIFEST =\n")
-
-  # replace name version and date
-  replace_header(head, :name)
-  replace_header(head, :version)
-  replace_header(head, :date)
-  #comment this out if your rubyforge_project has a different name
-  replace_header(head, :rubyforge_project)
-
-  # determine file list from git ls-files
-  files = `git ls-files`.
-    split("\n").
-    sort.
-    reject { |file| file =~ /^\./ }.
-    reject { |file| file =~ /^(rdoc|pkg)/ }.
-    map { |file| "    #{file}" }.
-    join("\n")
-
-  # piece file back together and write
-  manifest = "  s.files = %w[\n#{files}\n  ]\n"
-  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
-  File.open(gemspec_file, 'w') { |io| io.write(spec) }
-  puts "Updated #{gemspec_file}"
-end
-
-desc "Validate #{gemspec_file}"
-task :validate do
-  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
-  unless libfiles.empty?
-    puts "Directory `lib` should only contain a `#{name}.rb` file and `#{name}` dir."
-    exit!
-  end
-  unless Dir['VERSION*'].empty?
-    puts "A `VERSION` file at root level violates Gem best practices."
-    exit!
-  end
-end

data/lib/toml/key_group.rb

@@ -1,9 +0,0 @@
-module TOML
-  class KeyGroup
-    attr_reader :keys
-    
-    def initialize(keys)
-      @keys = keys
-    end
-  end
-end

data/test/spec.toml

@@ -1,62 +0,0 @@
-# Comment
-
-# Booleans
-true = true
-false = false
-
-[strings]
-# String
-string = "string\n\t\"string"
-empty = ""
-
-[ints]
-simple = 42
-negative = -42
-
-[floats]
-pi = 3.14159
-negative = -10.0
-
-[datetimes]
-# DateTime
-simple = 1979-05-27T07:32:00Z
-
-# Keygroups
-[a.b.c]
-d = "test"
-
-[e]
-f = "test"
-
-# Post line comment
-[comments]
-on = "a line" # with markup
-
-# Multi-line arrays
-[arrays]
-# Simple array
-simple = [1, 2, 3]
-
-# Nested array
-nested = [[1, 2], [3]]
-
-# Multiline array
-multiline = [
-	1,
-	2,
-	3
-]
-
-# With comments
-multiline_comments = [ # 0
-	1, # 1
-	2, # 2
-	3 # 3
-]
-
-multi = ["lines", "are",
-"super", "cool", "lol",
-"amirite"]
-
-# Uneven spacing
-uneven = [1, 2, 3,  4, 5 ]

data/test/test_generator.rb

@@ -1,33 +0,0 @@
-
-require 'rubygems'
-require 'bundler/setup'
-
-require 'toml'
-require 'minitest/autorun'
-
-class TestGenerator < MiniTest::Unit::TestCase
-  def setup
-    @doc = {
-      "integer" => 1,
-      "float" => 3.14159,
-      "true" => true,
-      "false" => false,
-      "string" => "hi",
-      "array" => [[1], [2], [3]],
-      "key" => {
-        "group" => {
-          "value" => "lol"
-        }
-      }
-    }
-    
-  end
-  
-  def test_generator
-    body = TOML::Generator.new(@doc).body
-
-    doc_parsed = TOML::Parser.new(body).parsed
-    
-    assert_equal @doc, doc_parsed
-  end
-end

data/test/test_parser.rb

@@ -1,75 +0,0 @@
-
-require 'rubygems'
-require 'bundler/setup'
-
-require 'toml'
-require 'minitest/autorun'
-
-class TestParser < MiniTest::Unit::TestCase
-  def setup
-    filepath = File.join(File.dirname(__FILE__), 'spec.toml')
-    @doc = TOML::Parser.new(File.read(filepath)).parsed
-  end
-
-  def test_string
-    assert_equal "string\n\t\"string", @doc["strings"]["string"]
-    assert_equal "", @doc["strings"]["empty"]
-  end
-
-  def test_integer
-    assert_equal 42, @doc["ints"]["simple"]
-  end
-
-  def test_negative_integer
-    assert_equal -42, @doc["ints"]["negative"]
-  end
-
-  def test_float
-    assert_equal 3.14159, @doc["floats"]["pi"]
-  end
-
-  def test_negative_float
-    assert_equal -10.0, @doc["floats"]["negative"]
-  end
-
-  def test_datetime
-    assert_equal DateTime.iso8601("1979-05-27T07:32:00Z"), @doc["datetimes"]["simple"]
-  end
-
-  def test_booleans
-    assert_equal true, @doc["true"]
-    assert_equal false, @doc["false"]
-  end
-
-  def test_simple_array
-    assert_equal [1, 2, 3], @doc["arrays"]["simple"]
-  end
-
-  def test_nested_array
-    assert_equal [[1, 2], [3]], @doc["arrays"]["nested"]
-  end
-
-  def test_multiline_arrays
-    assert_equal ["lines", "are", "super", "cool", "lol", "amirite"], @doc["arrays"]["multi"]
-  end
-  
-  def test_multiline_array
-    assert_equal @doc["arrays"]["multiline"], [1, 2, 3]
-  end
-  
-  def test_multiline_array_with_comments
-    assert_equal @doc["arrays"]["multiline_comments"], [1, 2, 3]
-  end
-
-  def test_simple_keygroup
-    assert_equal "test", @doc["e"]["f"]
-  end
-
-  def test_nested_keygroup
-    assert_equal "test", @doc["a"]["b"]["c"]["d"]
-  end
-
-  def test_inline_comment
-    assert_equal "a line", @doc["comments"]["on"]
-  end
-end

data/test/tmp.rb

@@ -1,25 +0,0 @@
-
-require 'rubygems'
-require 'bundler/setup'
-
-require 'toml'
-
-doc = "
-a = [true, false]
-"
-
-puts TOML.load(doc).inspect
-
-# puts TOML.load("a = [[[[1]]]]")["a"].inspect
-# puts "[[[[1]]]] <- expected"
-# 
-# puts TOML.load("a = [1]")["a"].inspect
-# puts "[1] <- expected"
-# 
-# puts TOML.load("a = [1, 2, 3]")["a"].inspect
-# puts "[1, 2, 3] <- expected"
-# 
-# puts TOML.load("a = [[[1], 2], 3]")["a"].inspect
-# puts "[[[1], 2], 3] <- expected"
-# 
-# puts TOML.load("a = [[]]")["a"].inspect

data/toml.gemspec

@@ -1,70 +0,0 @@
-## This is the rakegem gemspec template. Make sure you read and understand
-## all of the comments. Some sections require modification, and others can
-## be deleted if you don't need them. Once you understand the contents of
-## this file, feel free to delete any comments that begin with two hash marks.
-## You can find comprehensive Gem::Specification documentation, at
-## http://docs.rubygems.org/read/chapter/20
-Gem::Specification.new do |s|
-  s.specification_version = 2 if s.respond_to? :specification_version=
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.rubygems_version = '1.3.5'
-
-  ## Leave these as is they will be modified for you by the rake gemspec task.
-  ## If your rubyforge_project name is different, then edit it and comment out
-  ## the sub! line in the Rakefile
-  s.name              = 'toml'
-  s.version           = '0.0.4'
-  s.date              = '2013-03-28'
-
-  ## Make sure your summary is short. The description may be as long
-  ## as you like.
-  s.summary     = "Parse your TOML."
-  s.description = "Parse your TOML, seriously."
-
-  ## List the primary authors. If there are a bunch of authors, it's probably
-  ## better to set the email to an email list or something. If you don't have
-  ## a custom homepage, consider using your GitHub URL or the like.
-  s.authors  = ["Jeremy McAnally", "Dirk Gadsden"]
-  s.email    = 'jeremy@github.com'
-  s.homepage = 'http://github.com/jm/toml'
-
-  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
-  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
-  s.require_paths = %w[lib]
-
-  ## Specify any RDoc options here. You'll want to add your README and
-  ## LICENSE files to the extra_rdoc_files list.
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.extra_rdoc_files = %w[README.md LICENSE]
-  
-  s.add_dependency 'parslet'
-  
-  ## Leave this section as-is. It will be automatically generated from the
-  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
-  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
-  # = MANIFEST =
-  s.files = %w[
-    Gemfile
-    LICENSE
-    README.md
-    Rakefile
-    lib/toml.rb
-    lib/toml/generator.rb
-    lib/toml/key.rb
-    lib/toml/key_group.rb
-    lib/toml/monkey_patch.rb
-    lib/toml/parser.rb
-    lib/toml/parslet.rb
-    lib/toml/transformer.rb
-    test/spec.toml
-    test/test_generator.rb
-    test/test_parser.rb
-    test/tmp.rb
-    toml.gemspec
-  ]
-  # = MANIFEST =
-
-  ## Test files will be grabbed from the file list. Make sure the path glob
-  ## matches what you actually use.
-  s.test_files = s.files.select { |path| path =~ /^test\/test_.*\.rb/ }
-end