toml_empty 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 18f7758393bd1544a64b10d28ab7a83340f07c14d90a2e6177b362abd43debea
+  data.tar.gz: 89879113263d7ecd003a6f0b950dcfe1657d45a5296532a711ff82285c249e37
+SHA512:
+  metadata.gz: 45613e3e99d0123782583bdcf4fe98e010353e52b33519da766a9bb5e9ee9e41ccb9dac5ff492467fb4c28f5a22b71e37c6180c3bcf905e2e6d554f9c39a3a9a
+  data.tar.gz: fbbb621d8725790a55aad4da7b355c301fd0f0869ffa77b20d05dd6b56dbe48eeb7c527117933347f23d11c314098f2b609d483e8e2dcaefc31ce179ae221740

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+## 0.3.0 / 2020-06-09
+
+- 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/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Tom Preston-Werner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+# TOML
+
+A sane configuration format from @mojombo.  More information here: https://github.com/mojombo/toml
+
+This is far superior to YAML and JSON because it doesn't suck.  Really it doesn't.
+
+## Usage
+
+Add to your Gemfile:
+
+```ruby
+gem "toml", "~> 0.3.0"
+```
+
+It's simple, really.
+
+```ruby
+content = <<-TOML
+
+# Hello, this is an example.
+[things]
+other = "things"
+what = 900000
+
+TOML
+
+parser = TOML::Parser.new(content).parsed
+# => { "things" => { "other" => "things", "what" => 900000 } }
+```
+
+You can also use the same API as `YAML` if you'd like:
+
+```ruby
+TOML.load("thing = 9")
+# => {"thing" => 9}
+
+TOML.load_file("my_file.toml")
+# => {"whatever" => "keys"}
+```
+
+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
+hash = {
+  "integer" => 1,
+  "float" => 3.14159,
+  "true" => true,
+  "false" => false,
+  "string" => "hi",
+  "array" => [[1], [2], [3]],
+  "key" => {
+    "group" => {
+      "value" => "lol"
+    }
+  }
+}
+doc = TOML::Generator.new(hash).body
+# doc will be a string containing a proper TOML document.
+```
+
+## Contributors
+
+Written by Jeremy McAnally (@jm) and Dirk Gadsden (@dirk) based on TOML from Tom Preston-Werner (@mojombo).

data/lib/toml.rb

@@ -0,0 +1,25 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'time'
+require 'parslet'
+
+require 'toml/version'
+require 'toml/key'
+require 'toml/table'
+require 'toml/parslet'
+require 'toml/transformer'
+require 'toml/parser'
+require 'toml/generator'
+# Don't do monkey-patching by default. Only pulled in by TOML::Generator
+# if needed (see generator.rb line 27).
+# require 'toml/monkey_patch
+
+module TOML
+  def self.load(content)
+    Parser.new(content).parsed
+  end
+
+  def self.load_file(path)
+    Parser.new(File.read(path)).parsed
+  end
+end

data/lib/toml/generator.rb

@@ -0,0 +1,29 @@
+
+module TOML  
+  class Generator
+    attr_reader :body, :doc
+
+    def initialize(doc)
+      # Ensure all the to_toml methods are injected into the base Ruby classes
+      # used by TOML.
+      self.class.inject!
+      
+      @doc = doc
+      @body = doc.to_toml
+      
+      return @body
+    end
+    
+    # Whether or not the injections have already been done.
+    @@injected = false
+    # Inject to_toml methods into the Ruby classes used by TOML (booleans,
+    # String, Numeric, Array). You can add to_toml methods to your own classes
+    # to allow them to be easily serialized by the generator (and it will shout
+    # if something doesn't have a to_toml method).
+    def self.inject!
+      return if @@injected
+      require 'toml/monkey_patch'
+      @@injected = true
+    end
+  end#Generator
+end#TOML

data/lib/toml/key.rb

@@ -0,0 +1,10 @@
+module TOML
+  class Key
+    attr_reader :key, :value
+    
+    def initialize(key, value)
+      @key = key
+      @value = value
+    end
+  end
+end

data/lib/toml/monkey_patch.rb

@@ -0,0 +1,89 @@
+# 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)
+      if toml_val.empty?
+        toml << "\n[#{key}]\n"
+      else
+        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(path = ""); "true"; end
+end
+class FalseClass
+  def to_toml(path = ""); "false"; end
+end
+class String
+  def to_toml(path = ""); self.inspect; end
+end
+class Numeric
+  def to_toml(path = ""); self.to_s; end
+end
+class DateTime
+  def to_toml(path = "")
+    self.to_time.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+  end
+end

data/lib/toml/parser.rb

@@ -0,0 +1,99 @@
+module TOML  
+  class Parser
+    attr_reader :parsed
+
+    def initialize(markup)
+      # Make sure we have a newline on the end
+      
+      markup += "\n" unless markup.end_with?("\n") || markup.length == 0
+      begin
+        tree = Parslet.new.parse(markup)
+      rescue Parslet::ParseFailed => failure
+        puts failure.cause.ascii_tree
+      end
+      
+      
+      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}'"
+            unless @current_path.empty?
+              err += " at path '#{@current_path}'"
+            end
+            raise err
+          end
+          # Set the key-value into the current hash
+          @current[part.key] = part.value
+        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_table_array(t)
+      @current = @parsed
+      path = t.name.dup
+      @current_path = path.join('.')
+      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[n] = {}
+        end
+        @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

@@ -0,0 +1,103 @@
+module TOML
+  class Parslet < ::Parslet::Parser
+    rule(:document) {
+      all_space >>
+      (table | table_array | key_value | comment_line).repeat >>
+      all_space
+    }
+    root :document
+
+    rule(:value) {
+      array |
+      string |
+      datetime.as(:datetime) |
+      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 }
+    
+    rule(:array) {
+      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 >>
+        (all_space >> str(",")).maybe >> # possible trailing comma
+        all_space >> array_comments # Grab any remaining comments just in case
+      ).maybe.as(:array) >> str("]") 
+    }
+    
+    rule(:key_value) { 
+      space >> key.as(:key) >>
+      space >> str("=") >>
+      space >> value.as(:value) >>
+      space >> comment.maybe >> newline >> all_space
+    }
+    rule(:table) {
+      space >> str("[") >>
+        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(: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(: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["_"].maybe >> match["0-9"]).repeat)
+    }
+    rule(:float) {
+      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)
+    }
+
+    rule(:time) {
+      match["0-9"].repeat(2,2) >> str(":") >>
+      match["0-9"].repeat(2,2) >> str(":") >>
+      match["0-9"].repeat(2,2)
+    }
+
+    rule(:datetime) { date >> str("T") >> time >> str("Z") }
+  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

@@ -0,0 +1,115 @@
+module TOML
+  
+  class Transformer < ::Parslet::Transform
+    # Utility to properly handle escape sequences in parsed string.
+    def self.parse_string(val)
+      e = val.length
+      s = 0
+      o = []
+      while s < e
+        if val[s].chr == "\\"
+          s += 1
+          case val[s].chr
+          when "t"
+            o << "\t"
+          when "n"
+            o << "\n"
+          when "\\"
+            o << "\\"
+          when '"'
+            o << '"'
+          when "r"
+            o << "\r"
+          when "0"
+            o << "\0"
+          else
+            raise "Unexpected escape character: '\\#{val[s]}'"
+          end
+        else
+          o << val[s].chr
+        end
+        s += 1
+      end
+      o.join
+    end
+    
+    # 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 }
+    rule(:string => simple(:s)) {
+      Transformer.parse_string(s.to_s)
+    }
+    rule(:string => sequence(:s)) {
+      raise "Unexpected string-sequence: #{s.inspect}" unless s.empty?
+      ""
+    }
+    rule(:datetime => simple(:d)) { DateTime.iso8601(d) }
+    rule(:true => simple(:b)) { true }
+    rule(:false => simple(:b)) { false }
+    
+    rule(:key => simple(:k), :value => simple(:v)) { Key.new(k.to_s, v) }
+    
+    # New array cleanup
+    # TODO: Make this more readable/understandable.
+    def self.visit_array(h)
+      if h.is_a? Hash
+        # If it's an {:array => ...} hash
+        a = h[:array]
+        if a.is_a? Array
+          # If the value is already an array
+          a = a.map {|v| visit_array(v) }
+          classes = a.map {|v|
+            # Grab the class, with a little exception for true and false since
+            # they're different classes (TrueClass and FalseClass).
+            (v == true || v == false) ? true : v.class
+          }
+          if classes.uniq.length != 1
+            raise "Conflicting types in array: " + \
+              classes.map(&:to_s).join(", ")
+          end
+          return a
+        else
+          # Turn the value into an array
+          return [visit_array(a)].compact
+        end
+      else
+        # Plain old non-hash value
+        return h
+      end
+    end
+    rule(:key => simple(:k), :value => subtree(:v)) {
+      Key.new(k.to_s, Transformer.visit_array(v))
+    }
+    
+    # Make key hashes (inside key_groups) just be strings
+    rule(:key => simple(:k)) { k }
+
+    # Captures array-like key-groups
+    rule(:table => subtree(:kg)) {
+      Table.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.1.0'
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: toml_empty
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jeremy McAnally
+- Dirk Gadsden
+- Guillaume Virlet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    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 (allow empty group), seriously.
+email: github@virlet.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+- CHANGELOG.md
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/toml.rb
+- lib/toml/generator.rb
+- lib/toml/key.rb
+- lib/toml/monkey_patch.rb
+- lib/toml/parser.rb
+- lib/toml/parslet.rb
+- lib/toml/table.rb
+- lib/toml/transformer.rb
+- lib/toml/version.rb
+homepage: http://github.com/doc75/toml
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 2
+summary: Parse your TOML (allow empty group).
+test_files: []