toml-rb 5.0.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ad0b925f6a96bd61b0e3b03278a9b5168ee7bcaefc78e9944f6b5c9e1167fba
-  data.tar.gz: abce3cc229d44c245c02ae8dcc99acdffbdea3323ccb9c3d502f25fe4f73fab1
+  metadata.gz: d7514edd12c127a9f4ff3343e7590d4e526a15ebf3b13594d4d9683aea9fa1d0
+  data.tar.gz: a689fab092b24d2aadcecd046462af6d0cc741cdec8d4461372c65f6d249411b
 SHA512:
-  metadata.gz: e06fafb826214f9438b2317b549b0eb9fcd03d6afda24ae1d93523b86f47dfdc004dd5b60ad935e5be55bbf21a0980cff4cf3e18ccf2c59ed4d51f552d787647
-  data.tar.gz: 34f568d2288d58cdada406d05ecd525e9b7f491f3dcb365c7dd20425b2cb6425d93c5a106e3631417d0f8e37d7ba2fdddbcc13be5a23f8ecf6c871d744a6bff8
+  metadata.gz: e58611d93fbb27112dd505c43edc135500661c088e33cae0b50d6419bf30f814c94d389cc3a71f85072996a61492e74b9b9e9fce00477df5c3cd8e14691980a4
+  data.tar.gz: 4c5dff3f4537f96ba315410482dee6100463538be2cefe8c19fd8a1fcbce0db614870c9b0e83d52bc269fce28ef9872e8d9b78317b25fcae1b92a12b28c20cca

data/README.md

@@ -9,7 +9,7 @@ toml-rb
 [![Code Climate](https://codeclimate.com/github/emancu/toml-rb/badges/gpa.svg)](https://codeclimate.com/github/emancu/toml-rb)
 [![RubyGem](https://img.shields.io/gem/dt/toml-rb.svg)](https://rubygems.org/gems/toml-rb)
 
-A [TOML](https://github.com/toml-lang/toml) parser using [Citrus](http://mjackson.github.io/citrus) library.
+A pure Ruby [TOML](https://github.com/toml-lang/toml) parser and dumper with no runtime dependencies.
 
 toml-rb implements [TOML 1.1.0](https://toml.io/en/v1.1.0) and passes all [toml-test](https://github.com/toml-lang/toml-test) v2.2.0 decoder tests for that version.
 
@@ -20,7 +20,7 @@ Installation
 
 Or add this line to your Gemfile:
 
-    gem "toml-rb", "~> 5.0"
+    gem "toml-rb", "~> 6.0"
 
 Parser Usage
 ------------

data/lib/toml-rb/datetime.rb

@@ -5,63 +5,50 @@ module TomlRB
   LocalDate = Class.new(Time)
   LocalTime = Class.new(Time)
 
-  module DateSkeletonParser
-    def value
-      year, mon, day = [:year, :mon, :day].map { |s| capture(s).value }
-      unless Date.valid_date?(year.to_i, mon.to_i, day.to_i, Date::GREGORIAN)
-        raise ParseError, "Invalid date: #{year}-#{mon}-#{day}"
-      end
-      [year, mon, day]
-    end
-  end
+  module DatetimeParser
+    module_function
 
-  module TimeSkeletonParser
-    def value
-      hour, min, sec = [:hour, :mim, :sec].map { |s| capture(s)&.value || "0" }
-      unless hour.to_i.between?(0, 23) && min.to_i.between?(0, 59) && sec.to_i.between?(0, 60)
-        raise ParseError, "Invalid time: #{hour}:#{min}:#{sec}"
-      end
-      [hour, min, sec, capture(:sec_frac) || "0"]
-    end
-  end
-
-  module OffsetDateTimeParser
-    def value
-      skeleton = captures[:datetime_skeleton].first
-      year, mon, day, hour, min, sec, sec_frac = skeleton.value
-      offset = (captures[:date_offset].first || "+00:00").to_s
+    def offset_datetime(year, mon, day, hour, min, sec, sec_frac, offset)
+      validate_date(year, mon, day)
+      validate_time(hour, min, sec)
+      offset = "+00:00" if offset.casecmp?("Z")
       unless offset[1, 2].to_i.between?(0, 23) && offset[4, 2].to_i.between?(0, 59)
         raise ParseError, "Invalid UTC offset: #{offset}"
       end
-      sec = "#{sec}.#{sec_frac}".to_r
 
-      Time.new(year, mon, day, hour, min, sec, offset)
+      Time.new(year, mon, day, hour, min, seconds(sec, sec_frac), offset)
     end
-  end
 
-  module LocalDateTimeParser
-    def value
-      year, mon, day = captures[:date_skeleton].first.value
-      hour, min, sec, sec_frac = captures[:time_skeleton].first.value
-      sec = "#{sec}.#{sec_frac}".to_r
+    def local_datetime(year, mon, day, hour, min, sec, sec_frac)
+      validate_date(year, mon, day)
+      validate_time(hour, min, sec)
+      LocalDateTime.utc(year, mon, day, hour, min, seconds(sec, sec_frac))
+    end
 
-      LocalDateTime.local(year, mon, day, hour, min, sec)
+    def local_date(year, mon, day)
+      validate_date(year, mon, day)
+      LocalDate.utc(year, mon, day)
     end
-  end
 
-  module LocalDateParser
-    def value
-      year, mon, day = captures[:date_skeleton].first.value
-      LocalDate.local(year, mon, day)
+    def local_time(hour, min, sec, sec_frac)
+      validate_time(hour, min, sec)
+      LocalTime.utc(1970, 1, 1, hour, min, seconds(sec, sec_frac))
     end
-  end
 
-  module LocalTimeParser
-    def value
-      hour, min, sec, sec_frac = captures[:time_skeleton].first.value
-      sec = "#{sec}.#{sec_frac}".to_r
+    def validate_date(year, mon, day)
+      unless Date.valid_date?(year.to_i, mon.to_i, day.to_i, Date::GREGORIAN)
+        raise ParseError, "Invalid date: #{year}-#{mon}-#{day}"
+      end
+    end
+
+    def validate_time(hour, min, sec)
+      unless hour.to_i.between?(0, 23) && min.to_i.between?(0, 59) && sec.to_i.between?(0, 60)
+        raise ParseError, "Invalid time: #{hour}:#{min}:#{sec || 0}"
+      end
+    end
 
-      LocalTime.utc(1970, 1, 1, hour, min, sec)
+    def seconds(sec, sec_frac)
+      "#{sec || 0}.#{sec_frac || 0}".to_r
     end
   end
 end

data/lib/toml-rb/dumper.rb

@@ -19,7 +19,7 @@ module TomlRB
     attr_reader :toml_str
 
     def initialize(hash)
-      @toml_str = ""
+      @toml_str = +""
 
       visit(hash, [])
     end
@@ -78,7 +78,7 @@ module TomlRB
     def dump_simple_pairs(simple_pairs)
       simple_pairs.each do |key, val|
         key = quote_key(key) unless bare_key? key
-        @toml_str += "#{key} = #{to_toml(val)}\n"
+        @toml_str << "#{key} = #{to_toml(val)}\n"
       end
     end
 
@@ -108,7 +108,7 @@ module TomlRB
       new_prefix = prefix.join(".")
       new_prefix = "[" + new_prefix + "]" if extra_brackets
 
-      @toml_str += "[" + new_prefix + "]\n"
+      @toml_str << "[" + new_prefix + "]\n"
     end
 
     def to_toml(obj)

data/lib/toml-rb/inline_table.rb

@@ -15,10 +15,4 @@ module TomlRB
       result
     end
   end
-
-  module InlineTableParser
-    def value
-      TomlRB::InlineTable.new(captures[:keyvalue].map(&:value))
-    end
-  end
 end

data/lib/toml-rb/keyvalue.rb

@@ -42,11 +42,4 @@ module TomlRB
       a_value.accept_visitor self
     end
   end
-
-  # Used in document.citrus
-  module KeyvalueParser
-    def value
-      TomlRB::Keyvalue.new(capture(:stripped_key).value, capture(:v).value)
-    end
-  end
 end

data/lib/toml-rb/parser.rb

@@ -1,5 +1,21 @@
+# frozen_string_literal: true
+
+require "strscan"
+
 module TomlRB
   class Parser
+    BASIC_STRING = /(?:[^"\\\x00-\x08\x0a-\x1f\x7f]|\\.)*/
+    LITERAL_STRING = /[^'\x00-\x08\x0a-\x1f\x7f]*/
+    MULTILINE_STRING = /(?:[^"\\\x00-\x08\x0b-\x1f\x7f]|\r\n|\\(?:[^\r]|\r\n)|"{1,2}(?!"))*(?:"{0,2}(?="""))?/
+    MULTILINE_LITERAL = /(?:[^'\x00-\x08\x0b-\x1f\x7f]|\r\n|'{1,2}(?!'))*(?:'{0,2}(?='''))?/
+    # A UTF-8 regexp raises Encoding::CompatibilityError on binary input with high bytes.
+    COMMENT = /[^\x00-\x08\x0a-\x1f\x7f]*/u
+    DATETIME = /(\d{4})-(\d\d)-(\d\d)(?:[Tt ]([0-2]\d):([0-6]\d)(?::([0-6]\d)(?:\.(\d{1,9})\d*)?)?([Zz]|[+-]\d\d:\d\d)?)?/
+    TIME = /([0-2]\d):([0-6]\d)(?::([0-6]\d)(?:\.(\d{1,9})\d*)?)?/
+    PREFIXED_INTEGER = /0x[0-9a-fA-F](?:_?[0-9a-fA-F])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*/
+    DECIMAL = /[+-]?(?:0|[1-9](?:_?\d)*)(\.\d(?:_?\d)*(?:[eE][+-]?\d(?:_?\d)*)?|[eE][+-]?\d(?:_?\d)*)?/
+    MAX_NESTING = 100
+
     attr_reader :hash
 
     def initialize(content, symbolize_keys: false)
@@ -10,12 +26,13 @@ module TomlRB
       @tables = {}.compare_by_identity
       @current = @hash
       @symbolize_keys = symbolize_keys
+      @depth = 0
 
       begin
-        parsed = TomlRB::Document.parse(content)
-        parsed.matches.map(&:value).compact.each { |m| m.accept_visitor(self) }
-      rescue Citrus::ParseError => e
-        raise TomlRB::ParseError.new(e.message)
+        @scanner = StringScanner.new(source_text(content))
+        # The visitor runs after the whole document is parsed, so a syntax
+        # error wins over a key or table that the visitor rejects.
+        document.each { |statement| statement.accept_visitor(self) }
       rescue Encoding::CompatibilityError => e
         raise TomlRB::ParseError.new("Encoding error: #{e.message}")
       rescue ArgumentError => e
@@ -40,5 +57,240 @@ module TomlRB
     def visit_keyvalue(keyvalue)
       keyvalue.assign @current, @tables, @symbolize_keys
     end
+
+    private
+
+    def source_text(source)
+      if source.respond_to?(:to_path)
+        File.read(source.to_path)
+      elsif source.respond_to?(:read)
+        source.read
+      elsif source.respond_to?(:to_str)
+        source.to_str
+      else
+        raise ArgumentError, "Unable to parse from #{source}"
+      end
+    end
+
+    def document
+      statements = []
+      loop do
+        @scanner.skip(/(?:[ \t]*\r?\n)*[ \t]*/)
+        return statements if @scanner.eos?
+
+        statements << statement unless @scanner.match?(/#/)
+        line_end
+      end
+    end
+
+    def statement
+      if @scanner.match?(/\[/)
+        @scanner.match?(/\[\[/) ? table_array : table
+      else
+        keyvalue
+      end
+    end
+
+    def table_array
+      @scanner.skip(/\[\[[ \t]*/)
+      keys = key
+      expect(/[ \t]*\]\]/, "']]'")
+      TableArray.new(keys)
+    end
+
+    def table
+      @scanner.skip(/\[[ \t]*/)
+      keys = key
+      expect(/[ \t]*\]/, "']'")
+      Table.new(keys)
+    end
+
+    def keyvalue
+      keys = key
+      expect(/[ \t]*=[ \t]*/, "'='")
+      Keyvalue.new(keys, value)
+    end
+
+    def key
+      keys = [simple_key]
+      keys << simple_key while @scanner.skip(/[ \t]*\.[ \t]*/)
+      keys
+    end
+
+    def simple_key
+      if (bare = @scanner.scan(/[A-Za-z0-9_-]+/))
+        bare
+      elsif @scanner.match?(/"/)
+        basic_string
+      elsif @scanner.match?(/'/)
+        literal_string
+      else
+        syntax_error("a key")
+      end
+    end
+
+    def value
+      case @scanner.peek(1)
+      when '"'
+        @scanner.match?(/"""/) ? multiline_string : basic_string
+      when "'"
+        @scanner.match?(/'''/) ? multiline_literal : literal_string
+      when "["
+        nested { array }
+      when "{"
+        nested { inline_table }
+      when "t"
+        expect(/true/, "a value")
+        true
+      when "f"
+        expect(/false/, "a value")
+        false
+      else
+        datetime || local_time || number
+      end
+    end
+
+    def basic_string
+      @scanner.skip(/"/)
+      text = @scanner.scan(BASIC_STRING)
+      expect(/"/, %('"'))
+      unescape(text)
+    end
+
+    def literal_string
+      @scanner.skip(/'/)
+      text = @scanner.scan(LITERAL_STRING)
+      expect(/'/, %("'"))
+      text
+    end
+
+    def multiline_string
+      start = @scanner.pos
+      @scanner.skip(/"""(?:\r?\n)?/)
+      text = @scanner.scan(MULTILINE_STRING)
+      @scanner.skip(/"""/) || syntax_error(%('"""' to close the string at #{location(start)}))
+      unescape(text)
+    end
+
+    def multiline_literal
+      start = @scanner.pos
+      @scanner.skip(/'''(?:\r?\n)?/)
+      text = @scanner.scan(MULTILINE_LITERAL)
+      @scanner.skip(/'''/) || syntax_error(%("'''" to close the string at #{location(start)}))
+      text
+    end
+
+    def unescape(text)
+      text.include?("\\") ? BasicString.transform_escaped_chars(text) : text
+    end
+
+    def datetime
+      return unless @scanner.skip(DATETIME)
+
+      year, mon, day, hour, min, sec, sec_frac, offset = @scanner.values_at(1, 2, 3, 4, 5, 6, 7, 8)
+      if hour.nil?
+        DatetimeParser.local_date(year, mon, day)
+      elsif offset
+        DatetimeParser.offset_datetime(year, mon, day, hour, min, sec, sec_frac, offset)
+      else
+        DatetimeParser.local_datetime(year, mon, day, hour, min, sec, sec_frac)
+      end
+    end
+
+    def local_time
+      DatetimeParser.local_time(*@scanner.values_at(1, 2, 3, 4)) if @scanner.skip(TIME)
+    end
+
+    def number
+      if (text = @scanner.scan(PREFIXED_INTEGER))
+        Integer(text)
+      elsif (text = @scanner.scan(DECIMAL))
+        @scanner[1] ? text.to_f : text.to_i
+      elsif (text = @scanner.scan(/[+-]?inf/))
+        text.start_with?("-") ? -Float::INFINITY : Float::INFINITY
+      elsif @scanner.skip(/[+-]?nan/)
+        Float::NAN
+      else
+        syntax_error("a value")
+      end
+    end
+
+    def array
+      @scanner.skip(/\[/)
+      values = []
+      loop do
+        skip_whitespace_and_comments
+        return values if @scanner.skip(/\]/)
+
+        values << value
+        skip_whitespace_and_comments
+        return values if @scanner.skip(/\]/)
+
+        expect(/,/, "',' or ']'")
+      end
+    end
+
+    def inline_table
+      @scanner.skip(/\{/)
+      pairs = []
+      loop do
+        skip_whitespace_and_comments
+        return InlineTable.new(pairs) if @scanner.skip(/\}/)
+
+        pairs << keyvalue
+        skip_whitespace_and_comments
+        return InlineTable.new(pairs) if @scanner.skip(/\}/)
+
+        expect(/,/, "',' or '}'")
+      end
+    end
+
+    # Each nested array or inline table recurses, so the limit stops a deep
+    # document before it exhausts the stack.
+    def nested
+      @depth += 1
+      syntax_error("at most #{MAX_NESTING} nested arrays and inline tables") if @depth > MAX_NESTING
+      yield
+    ensure
+      @depth -= 1
+    end
+
+    def line_end
+      return if @scanner.skip(/[ \t]*\r?\n/)
+
+      @scanner.skip(/[ \t]*/)
+      @scanner.skip(COMMENT) if @scanner.skip(/#/)
+      new_line
+    end
+
+    def skip_whitespace_and_comments
+      @scanner.skip(/[ \t\r\n]*/)
+      while @scanner.skip(/#/)
+        @scanner.skip(COMMENT)
+        new_line
+        @scanner.skip(/[ \t\r\n]*/)
+      end
+    end
+
+    def new_line
+      @scanner.skip(/\r?\n/) || @scanner.eos? || syntax_error("a new line")
+    end
+
+    def expect(pattern, expected)
+      @scanner.skip(pattern) || syntax_error(expected)
+    end
+
+    def syntax_error(expected)
+      @scanner.skip(/[ \t]*/)
+      found = @scanner.eos? ? "end of input" : @scanner.check(/./m).inspect
+      raise ParseError, "Unexpected #{found} at #{location(@scanner.pos)}: expected #{expected}"
+    end
+
+    def location(pos)
+      consumed = @scanner.string.byteslice(0, pos)
+      line = consumed.count("\n") + 1
+      column = consumed.length - (consumed.rindex("\n") || -1)
+      "line #{line}, column #{column}"
+    end
   end
 end

data/lib/toml-rb/string.rb

@@ -1,5 +1,4 @@
 module TomlRB
-  # Used in primitive.citrus
   module BasicString
     SPECIAL_CHARS = {
       "\\t" => "\t",
@@ -12,12 +11,6 @@ module TomlRB
       "\\\\" => "\\"
     }.freeze
 
-    def value
-      aux = TomlRB::BasicString.transform_escaped_chars first.value
-
-      aux[1...-1]
-    end
-
     # Replace the unicode escaped characters with the corresponding character
     # e.g. \u03B4 => ?
     def self.decode_unicode(str)
@@ -45,22 +38,4 @@ module TomlRB
       fail ParseError.new "Escape sequence #{m} is reserved"
     end
   end
-
-  module LiteralString
-    def value
-      first.value[1...-1]
-    end
-  end
-
-  module MultilineString
-    def value
-      TomlRB::BasicString.transform_escaped_chars captures[:text].first.value
-    end
-  end
-
-  module MultilineLiteral
-    def value
-      captures[:text].first.value
-    end
-  end
 end

data/lib/toml-rb/table.rb

@@ -31,11 +31,4 @@ module TomlRB
       @dotted_keys.join(".")
     end
   end
-
-  # Used in document.citrus
-  module TableParser
-    def value
-      TomlRB::Table.new(captures[:stripped_key].map(&:value).first)
-    end
-  end
 end

data/lib/toml-rb/table_array.rb

@@ -40,11 +40,4 @@ module TomlRB
       parser.visit_table_array self
     end
   end
-
-  # Used in document.citrus
-  module TableArrayParser
-    def value
-      TomlRB::TableArray.new(captures[:stripped_key].map(&:value).first)
-    end
-  end
 end

data/lib/toml-rb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TomlRB
-  VERSION = "5.0.0"
+  VERSION = "6.0.0"
 end

data/lib/toml-rb.rb

@@ -1,7 +1,4 @@
-require "citrus"
-
 require_relative "toml-rb/errors"
-require_relative "toml-rb/array"
 require_relative "toml-rb/string"
 require_relative "toml-rb/datetime"
 require_relative "toml-rb/table"
@@ -11,12 +8,6 @@ require_relative "toml-rb/keyvalue"
 require_relative "toml-rb/parser"
 require_relative "toml-rb/dumper"
 
-File.dirname(File.expand_path(__FILE__)).tap do |root|
-  Citrus.load "#{root}/toml-rb/grammars/helper.citrus"
-  Citrus.load "#{root}/toml-rb/grammars/primitive.citrus"
-  Citrus.load "#{root}/toml-rb/grammars/document.citrus"
-end
-
 module TomlRB
   # Public: Returns a hash from *TomlRB* content.
   #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: toml-rb
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Emiliano Mancuso
@@ -10,26 +10,6 @@ bindir: bin
 cert_chain: []
 date: 2026-09-28 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: citrus
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-    - - ">"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-    - - ">"
-      - !ruby/object:Gem::Version
-        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -72,7 +52,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 'A Toml parser using Citrus parsing library. '
+description: A TOML 1.1.0 parser and dumper.
 email:
 - emiliano.mancuso@gmail.com
 - lucas.tolchinsky@gmail.com
@@ -83,13 +63,9 @@ files:
 - LICENSE
 - README.md
 - lib/toml-rb.rb
-- lib/toml-rb/array.rb
 - lib/toml-rb/datetime.rb
 - lib/toml-rb/dumper.rb
 - lib/toml-rb/errors.rb
-- lib/toml-rb/grammars/document.citrus
-- lib/toml-rb/grammars/helper.citrus
-- lib/toml-rb/grammars/primitive.citrus
 - lib/toml-rb/inline_table.rb
 - lib/toml-rb/keyvalue.rb
 - lib/toml-rb/parser.rb

data/lib/toml-rb/array.rb

@@ -1,8 +0,0 @@
-module TomlRB
-  module ArrayParser
-    def value
-      elements = captures[:array_elements].first
-      elements ? elements.value : []
-    end
-  end
-end

data/lib/toml-rb/grammars/document.citrus

@@ -1,67 +0,0 @@
-grammar TomlRB::Document
-  include TomlRB::Primitive
-
-  rule document
-    (comment | table_array | table | keyvalue_line | line_break | trailing_space)*
-  end
-
-  rule table_array
-    (space? '[[' stripped_key ']]' line_end) <TomlRB::TableArrayParser>
-  end
-
-  rule table
-    (space? '[' stripped_key ']' line_end) <TomlRB::TableParser>
-  end
-
-  rule keyvalue_line
-    (keyvalue line_end) { capture(:keyvalue).value }
-  end
-
-  rule keyvalue
-    (stripped_key '=' space? v:(toml_values) space) <TomlRB::KeyvalueParser>
-  end
-
-  ### Values
-
-  rule inline_table
-    (space? '{' array_comments (keyvalue (array_comments ',' array_comments keyvalue)* (array_comments ',')?)? array_comments '}' ) <TomlRB::InlineTableParser>
-  end
-
-  rule array
-    ("[" array_comments (array_elements (array_comments ",")?)? array_comments "]") <TomlRB::ArrayParser>
-  end
-
-  rule array_array
-    (array (space "," array_comments array)*) {
-      captures[:array].map(&:value)
-    }
-  end
-
-  rule array_elements
-    (toml_values (array_comments "," array_comments toml_values)*) {
-      captures[:toml_values].map(&:value)
-    }
-  end
-
-  ### Helpers
-
-  rule line_end
-    (space (comment | line_break | !.))
-  end
-
-  rule trailing_space
-    ([ \t]+ !.) { nil }
-  end
-
-  rule stripped_key
-    (space? key space?) { captures[:key].first.value }
-  end
-
-  rule array_comments
-    (indent? (comment indent?)*)
-  end
-
-  rule toml_values
-    primitive | inline_table | array
-  end
-end

data/lib/toml-rb/grammars/helper.citrus

@@ -1,17 +0,0 @@
-grammar TomlRB::Helper
-  rule comment
-    (space? "#" /[^\x00-\x08\x0a-\x1f\x7f]*(?=\r?\n|\z)/u line_break?) { nil }
-  end
-
-  rule space
-    [ \t]*
-  end
-
-  rule indent
-    [ \t\r\n]*
-  end
-
-  rule line_break
-    (space "\n" space | space "\r\n" space) { nil }
-  end
-end

data/lib/toml-rb/grammars/primitive.citrus

@@ -1,176 +0,0 @@
-grammar TomlRB::Primitive
-  include TomlRB::Helper
-
-  rule primitive
-    datetime | bool | number | string
-  end
-
-  ##
-  # String rules
-  ##
-
-  rule string
-    multiline_string | multiline_literal | basic_string | literal_string
-  end
-
-  rule basic_string
-    (/"(?:[^"\\\x00-\x08\x0a-\x1f\x7f]|\\.)*"/ space) <TomlRB::BasicString>
-  end
-
-  rule literal_string
-    (/'[^'\x00-\x08\x0a-\x1f\x7f]*'/ space) <TomlRB::LiteralString>
-  end
-
-  rule multiline_string
-    ('"""' /\r?\n/? text:/(?:[^"\\\x00-\x08\x0b-\x1f\x7f]|\r\n|\\(?:[^\r]|\r\n)|"{1,2}(?!"))*"{0,2}(?=""")/ '"""' space) <TomlRB::MultilineString>
-  end
-
-  rule multiline_literal
-    ("'''" /\r?\n/? text:/(?:[^'\x00-\x08\x0b-\x1f\x7f]|\r\n|'{1,2}(?!'))*'{0,2}(?=''')/ "'''" space) <TomlRB::MultilineLiteral>
-  end
-
-  ##
-  # Date time rules
-  ##
-
-  rule datetime
-    offset_datetime | local_datetime | local_date | local_time
-  end
-
-  rule offset_datetime
-    ( skeleton:datetime_skeleton ([Zz] | date_offset) ) <TomlRB::OffsetDateTimeParser>
-  end
-
-  rule local_datetime
-    datetime_skeleton <TomlRB::LocalDateTimeParser>
-  end
-
-  rule local_date
-    (date_skeleton space) <TomlRB::LocalDateParser>
-  end
-
-  rule local_time
-    (time_skeleton space) <TomlRB::LocalTimeParser>
-  end
-
-  rule datetime_skeleton
-    (date_skeleton ([Tt]|" ") time_skeleton) {
-      capture(:date_skeleton).value + capture(:time_skeleton).value
-    }
-  end
-
-  rule date_skeleton
-    (year:/\d\d\d\d/ "-" mon:/\d\d/ "-" day:/\d\d/) <TomlRB::DateSkeletonParser>
-  end
-
-  rule time_skeleton
-    ( hour:([0-2][0-9]) ":" mim:([0-6][0-9]) (":" sec:([0-6][0-9])  ("." sec_frac:(/\d/1*9) /\d/*)?)? ) <TomlRB::TimeSkeletonParser>
-  end
-
-  rule date_offset
-    offset:(sign /\d\d/ ":" /\d\d/)
-  end
-
-  ##
-  # Number rules
-  ##
-
-  rule number
-    float | integer
-  end
-
-  rule float
-    inf | nan | exponential_float | fractional_float
-  end
-
-  rule inf
-    (s:sign? 'inf') {
-      sign = (capture(:s).value != '-') ? 1 : -1
-      sign * Float::INFINITY
-    }
-  end
-
-  rule nan
-    (sign? 'nan') { Float::NAN }
-  end
-
-  rule exponential_float
-    ((fractional_float | decimal_integer) [eE] exponent) { to_str.to_f }
-  end
-
-  rule exponent
-    sign? [0-9] ([0-9] | '_' [0-9])*
-  end
-
-  rule fractional_float
-    (decimal_integer '.' [0-9] ([0-9] | '_' [0-9])*) {
-      to_str.to_f
-    }
-  end
-
-  rule integer
-    hexadecimal_integer | octal_integer | binary_integer | decimal_integer
-  end
-
-  rule hexadecimal_integer
-    ('0x' [a-fA-F0-9] ([a-fA-F0-9] | '_' [a-fA-F0-9])*) { to_str.to_i(16) }
-  end
-
-  rule octal_integer
-    ('0o' [0-7] ([0-7] | '_' [0-7])*) { to_str.to_i(8) }
-  end
-
-  rule binary_integer
-    ('0b' [01] ([01] | '_' [01])*) { to_str.to_i(2) }
-  end
-
-  rule decimal_integer
-    (sign? ('0' | [1-9] ([0-9] | '_' [0-9])*)) { to_str.to_i }
-  end
-
-  rule sign
-    '+' | '-'
-  end
-
-  ##
-  # Boolean rules
-  ##
-
-  rule bool
-    true | false
-  end
-
-  rule true
-    'true' { true }
-  end
-
-  rule false
-    'false' { false }
-  end
-
-  ##
-  # Key rules
-  ##
-
-  rule key
-    dotted_key
-  end
-
-  rule bare_key
-    [a-zA-Z0-9_-]+
-  end
-
-  rule quoted_key
-    basic_string | literal_string
-  end
-
-  rule single_key
-    quoted_key | bare_key
-  end
-
-  rule dotted_key
-    (space? single_key space?  ("." space? single_key space?)* ) {
-      captures[:single_key].map(&:value)
-    }
-  end
-end