tomlrb 2.0.4 → 3.0.0

data/lib/tomlrb/handler.rb

@@ -1,279 +0,0 @@
-# frozen-string-literal: true
-
-module Tomlrb
-  class Handler
-    attr_reader :output, :symbolize_keys
-
-    def initialize(**options)
-      @output = {}
-      @current = @output
-      @stack = []
-      @array_names = []
-      @current_table = []
-      @keys = Keys.new
-      @symbolize_keys = options[:symbolize_keys]
-    end
-
-    def set_context(identifiers, is_array_of_tables: false)
-      if identifiers.empty?
-        raise ParseError, 'Array needs a name'
-      end
-
-      @current_table = identifiers.dup
-      @keys.add_table_key identifiers, is_array_of_tables
-      @current = @output
-
-      deal_with_array_of_tables(identifiers, is_array_of_tables) do |identifierz|
-        identifierz.each do |k|
-          k = k.to_sym if @symbolize_keys
-          if @current[k].is_a?(Array)
-            @current = @current[k].last
-          else
-            @current[k] ||= {}
-            @current = @current[k]
-          end
-        end
-      end
-    end
-
-    def deal_with_array_of_tables(identifiers, is_array_of_tables)
-      stringified_identifier = identifiers.join('.')
-
-      if is_array_of_tables
-        @array_names << stringified_identifier
-        last_identifier = identifiers.pop
-      elsif @array_names.include?(stringified_identifier)
-        raise ParseError, 'Cannot define a normal table with the same name as an already established array'
-      end
-
-      yield(identifiers)
-
-      if is_array_of_tables
-        last_identifier = last_identifier.to_sym if @symbolize_keys
-        @current[last_identifier] ||= []
-        raise ParseError, "Cannot use key #{last_identifier} for both table and array at once" unless @current[last_identifier].respond_to?(:<<)
-        @current[last_identifier] << {}
-        @current = @current[last_identifier].last
-      end
-    end
-
-    def assign(k)
-      @keys.add_pair_key k, @current_table
-      current = @current
-      while (key = k.shift)
-        key = key.to_sym if @symbolize_keys
-        current = assign_key_path(current, key, k.empty?)
-      end
-    end
-
-    def push(o)
-      @stack << o
-    end
-
-    def push_inline(inline_arrays)
-      merged_inline = {}
-      keys = Keys.new
-
-      inline_arrays.each do |inline_array|
-        current = merged_inline
-        value = inline_array.pop
-        keys.add_table_key inline_array, value.is_a?(Array)
-
-        inline_array.each_with_index do |inline_key, inline_index|
-          inline_key = inline_key.to_sym if @symbolize_keys
-          last_key = inline_index == inline_array.size - 1
-
-          if last_key
-            if current[inline_key].nil?
-              keys.add_pair_key [inline_key], []
-
-              current[inline_key] = value
-            else
-              raise Key::KeyConflict, "Inline key #{inline_key} is already used"
-            end
-          else
-            current[inline_key] ||= {}
-            current = current[inline_key]
-          end
-        end
-      end
-
-      push(merged_inline)
-    end
-
-    def start_(type)
-      push([type])
-    end
-
-    def end_(type)
-      array = []
-      while (value = @stack.pop) != [type]
-        raise ParseError, 'Unclosed table' if @stack.empty?
-
-        array.unshift(value)
-      end
-      array
-    end
-
-    def validate_value(value)
-      if value.nil?
-        raise ParseError, 'Value must be present'
-      end
-    end
-
-    private
-
-    def assign_key_path(current, key, key_emptied)
-      existed = current.key?(key)
-      raise ParseError, "Cannot overwrite value with key #{key}" if existed && !current[key].is_a?(Hash)
-      if key_emptied
-        raise ParseError, "Cannot overwrite value with key #{key}" unless current.is_a?(Hash)
-
-        value = @stack.pop
-        raise ParseError, "Cannot overwrite value with key #{key}" if current[key].is_a?(Hash) && !value.is_a?(Hash)
-        current[key] = value
-        return current
-      end
-      current[key] ||= {}
-      current[key]
-    end
-  end
-
-  class Keys
-    def initialize
-      @keys = {}
-    end
-
-    def add_table_key(keys, is_array_of_tables = false)
-      self << [keys, [], is_array_of_tables]
-    end
-
-    def add_pair_key(keys, context)
-      self << [context, keys, false]
-    end
-
-    def <<(keys)
-      table_keys, pair_keys, is_array_of_tables = keys
-      current = @keys
-      current = append_table_keys(current, table_keys, pair_keys.empty?, is_array_of_tables)
-      append_pair_keys(current, pair_keys, table_keys.empty?, is_array_of_tables)
-    end
-
-    private
-
-    def append_table_keys(current, table_keys, pair_keys_empty, is_array_of_tables)
-      table_keys.each_with_index do |key, index|
-        declared = (index == table_keys.length - 1) && pair_keys_empty
-        if index.zero?
-          current = find_or_create_first_table_key(current, key, declared, is_array_of_tables)
-        else
-          current <<= [key, :table, declared, is_array_of_tables]
-        end
-      end
-
-      current.clear_children if is_array_of_tables
-      current
-    end
-
-    def find_or_create_first_table_key(current, key, declared, is_array_of_tables)
-      existed = current[key]
-      if existed && existed.type == :pair
-        raise Key::KeyConflict, "Key #{key} is already used as #{existed.type} key"
-      end
-      if existed && existed.declared? && declared && ! is_array_of_tables
-        raise Key::KeyConflict, "Key #{key} is already used"
-      end
-      k = existed || Key.new(key, :table, declared)
-      k.declared = k.declared? || declared
-      current[key] = k
-      k
-    end
-
-    def append_pair_keys(current, pair_keys, table_keys_empty, is_array_of_tables)
-      pair_keys.each_with_index do |key, index|
-        declared = index == pair_keys.length - 1
-        if index.zero? && table_keys_empty
-          current = find_or_create_first_pair_key(current, key, declared, table_keys_empty)
-        else
-          key = current << [key, :pair, declared, is_array_of_tables]
-          current = key
-        end
-      end
-    end
-
-    def find_or_create_first_pair_key(current, key, declared, table_keys_empty)
-      existed = current[key]
-      if existed && (existed.type == :pair) && declared && table_keys_empty
-        raise Key::KeyConflict, "Key #{key} is already used"
-      end
-      k = Key.new(key, :pair, declared)
-      current[key] = k
-      k
-    end
-  end
-
-  class Key
-    class KeyConflict < ParseError; end
-
-    attr_reader :key, :type
-    attr_writer :declared
-
-    def initialize(key, type, declared = false)
-      @key = key
-      @type = type
-      @declared = declared
-      @children = {}
-    end
-
-    def declared?
-      @declared
-    end
-
-    def <<(key_type_declared)
-      key, type, declared, is_array_of_tables = key_type_declared
-      existed = @children[key]
-      validate_already_declared_as_different_key(type, declared, existed)
-      validate_already_declared_as_non_array_table(type, is_array_of_tables, declared, existed)
-      validate_path_already_created_as_different_type(type, declared, existed)
-      validate_path_already_declared_as_different_type(type, declared, existed)
-      validate_already_declared_as_same_key(declared, existed)
-      @children[key] = existed || self.class.new(key, type, declared)
-    end
-
-    def clear_children
-      @children.clear
-    end
-
-    private
-
-    def validate_already_declared_as_different_key(type, _declared, existed)
-      if existed && existed.declared? && existed.type != type
-        raise KeyConflict, "Key #{existed.key} is already used as #{existed.type} key"
-      end
-    end
-
-    def validate_already_declared_as_non_array_table(type, is_array_of_tables, declared, existed)
-      if declared && type == :table && existed && existed.declared? && !is_array_of_tables
-        raise KeyConflict, "Key #{existed.key} is already used"
-      end
-    end
-
-    def validate_path_already_created_as_different_type(type, declared, existed)
-      if declared && (type == :table) && existed && (existed.type == :pair) && !existed.declared?
-        raise KeyConflict, "Key #{existed.key} is already used as #{existed.type} key"
-      end
-    end
-
-    def validate_path_already_declared_as_different_type(type, declared, existed)
-      if !declared && (type == :pair) && existed && (existed.type == :pair) && existed.declared?
-        raise KeyConflict, "Key #{key} is already used as #{type} key"
-      end
-    end
-
-    def validate_already_declared_as_same_key(declared, existed)
-      if existed && !existed.declared? && declared
-        raise KeyConflict, "Key #{existed.key} is already used as #{existed.type} key"
-      end
-    end
-  end
-end

data/lib/tomlrb/parser.y

@@ -1,230 +0,0 @@
-class Tomlrb::GeneratedParser
-token IDENTIFIER STRING_MULTI STRING_BASIC STRING_LITERAL_MULTI STRING_LITERAL DATETIME LOCAL_TIME INTEGER NON_DEC_INTEGER FLOAT FLOAT_KEYWORD BOOLEAN NEWLINE EOS
-rule
-  expressions
-    | expressions expression
-    | expressions EOS
-    ;
-  expression
-    : table
-    | assignment
-    | inline_table
-    | NEWLINE
-    ;
-  table
-    : table_start table_identifier table_end newlines
-    | table_start table_identifier table_end EOS
-    | table_start table_end newlines
-    | table_start table_end EOS
-    ;
-  table_start
-    : '[' '[' { @handler.start_(:array_of_tables) }
-    | '[' { @handler.start_(:table) }
-    ;
-    ;
-  table_end
-    : ']' ']' { array = @handler.end_(:array_of_tables); @handler.set_context(array, is_array_of_tables: true) }
-    | ']' { array = @handler.end_(:table); @handler.set_context(array) }
-    ;
-  table_identifier
-    : table_identifier '.' table_identifier_component { @handler.push(val[2]) }
-    | table_identifier '.' FLOAT { val[2].split('.').each { |k| @handler.push(k) } }
-    | FLOAT {
-      keys = val[0].split('.')
-      @handler.start_(:table)
-      keys.each { |key| @handler.push(key) }
-    }
-    | table_identifier_component { @handler.push(val[0]) }
-    ;
-  table_identifier_component
-    : IDENTIFIER
-    | STRING_BASIC { result = StringUtils.replace_escaped_chars(val[0]) }
-    | STRING_LITERAL
-    | INTEGER
-    | NON_DEC_INTEGER
-    | FLOAT_KEYWORD
-    | BOOLEAN
-    | DATETIME { result = val[0][0] }
-    | LOCAL_TIME { result = val[0][0] }
-    ;
-  inline_table
-    : inline_table_start inline_table_end
-    | inline_table_start inline_continued inline_table_end
-    ;
-  inline_table_start
-    : '{' { @handler.start_(:inline) }
-    ;
-  inline_table_end
-    : '}' {
-      array = @handler.end_(:inline)
-      @handler.push_inline(array)
-    }
-    ;
-  inline_continued
-    : inline_assignment
-    | inline_assignment inline_next
-    ;
-  inline_next
-    : ',' inline_continued
-    ;
-  inline_assignment
-    : inline_assignment_key '=' value {
-      keys = @handler.end_(:inline_keys)
-      @handler.push(keys)
-    }
-    ;
-  inline_assignment_key
-    : inline_assignment_key '.' assignment_key_component { 
-      @handler.push(val[2]) 
-    }
-    | inline_assignment_key '.' FLOAT { val[2].split('.').each { |k| @handler.push(k) } }
-    | FLOAT {
-      keys = val[0].split('.')
-      @handler.start_(:inline_keys)
-      keys.each { |key| @handler.push(key) }
-    }
-    | assignment_key_component { 
-      @handler.start_(:inline_keys) 
-      @handler.push(val[0]) 
-    }
-    ;
-  assignment
-    : assignment_key '=' value EOS {
-      keys = @handler.end_(:keys)
-      value = keys.pop
-      @handler.validate_value(value)
-      @handler.push(value)
-      @handler.assign(keys)
-    }
-    | assignment_key '=' value NEWLINE {
-      keys = @handler.end_(:keys)
-      value = keys.pop
-      @handler.validate_value(value)
-      @handler.push(value)
-      @handler.assign(keys)
-    }
-    ;
-  assignment_key
-    : assignment_key '.' assignment_key_component { @handler.push(val[2]) }
-    | assignment_key '.' FLOAT { val[2].split('.').each { |k| @handler.push(k) } }
-    | FLOAT {
-      keys = val[0].split('.')
-      @handler.start_(:keys)
-      keys.each { |key| @handler.push(key) }
-    }
-    | assignment_key_component { @handler.start_(:keys); @handler.push(val[0]) }
-    ;
-  assignment_key_component
-    : IDENTIFIER
-    | STRING_BASIC { result = StringUtils.replace_escaped_chars(val[0]) }
-    | STRING_LITERAL
-    | INTEGER
-    | NON_DEC_INTEGER
-    | FLOAT_KEYWORD
-    | BOOLEAN
-    | DATETIME { result = val[0][0] }
-    | LOCAL_TIME { result = val[0][0] }
-    ;
-  array
-    : start_array array_first_value array_values comma end_array
-    | start_array array_first_value array_values end_array
-    | start_array array_first_value comma end_array
-    | start_array array_first_value end_array
-    | start_array end_array
-    ;
-  array_first_value
-    : newlines non_nil_value
-    | non_nil_value
-    ;
-  array_values
-    : array_values array_value
-    | array_value
-    ;
-  array_value
-    : comma newlines non_nil_value
-    | comma non_nil_value
-    ;
-  start_array
-    : '[' { @handler.start_(:array) }
-    ;
-  end_array
-    : newlines ']' { array = @handler.end_(:array); @handler.push(array.compact) }
-    | ']' { array = @handler.end_(:array); @handler.push(array.compact) }
-    ;
-  comma
-    : newlines ','
-    | ','
-    ;
-  newlines
-    : newlines NEWLINE
-    | NEWLINE
-    ;
-  value
-    : scalar { @handler.push(val[0]) }
-    | array
-    | inline_table
-    ;
-  non_nil_value
-    : non_nil_scalar { @handler.push(val[0]) }
-    | array
-    | inline_table
-    ;
-  scalar
-    : string
-    | literal
-    ;
-  non_nil_scalar
-    : string
-    | non_nil_literal
-    ;
-  literal
-    | non_nil_literal
-    ;
-  non_nil_literal
-    : FLOAT { result = val[0].to_f }
-    | FLOAT_KEYWORD {
-      v = val[0]
-      result = if v.end_with?('nan')
-                 Float::NAN
-               else
-                 (v[0] == '-' ? -1 : 1) * Float::INFINITY
-               end
-    }
-    | INTEGER { result = val[0].to_i }
-    | NON_DEC_INTEGER {
-      base = case val[0][1]
-             when 'x' then 16
-             when 'o' then 8
-             when 'b' then 2
-             end
-      result = val[0].to_i(base)
-    }
-    | BOOLEAN { result = val[0] == 'true' ? true : false }
-    | DATETIME {
-      _str, year, month, day, hour, min, sec, offset = val[0]
-      result = if offset.nil?
-                 if hour.nil?
-                   LocalDate.new(year, month, day)
-                 else
-                   LocalDateTime.new(year, month, day, hour, min || 0, sec.to_f)
-                 end
-               else
-                 # Patch for 24:00:00 which Ruby parses
-                 if hour.to_i == 24 && min.to_i == 0 && sec.to_i == 0
-                   hour = (hour.to_i + 1).to_s
-                 end
-
-                 time = Time.new(year, month, day, hour || 0, min || 0, sec.to_f, offset)
-                 # Should be out of parser.y?
-                 raise ArgumentError, "Invalid Offset Date-Time: #{year}-#{month}-#{day}T#{hour}:#{min}:#{sec}#{offset}" unless min.to_i == time.min && hour.to_i == time.hour && day.to_i == time.day && month.to_i == time.month && year.to_i == time.year
-                 time
-               end
-    }
-    | LOCAL_TIME { result = LocalTime.new(*val[0][1..-1]) }
-    ;
-  string
-    : STRING_MULTI { result = StringUtils.replace_escaped_chars(StringUtils.multiline_replacements(val[0])) }
-    | STRING_BASIC { result = StringUtils.replace_escaped_chars(val[0]) }
-    | STRING_LITERAL_MULTI { result = StringUtils.strip_spaces(val[0]) }
-    | STRING_LITERAL { result = val[0] }
-    ;

data/lib/tomlrb/scanner.rb

@@ -1,92 +0,0 @@
-# frozen-string-literal: true
-
-require 'strscan'
-
-module Tomlrb
-  class Scanner
-    COMMENT =
-      /#[^\u0000-\u0008\u000A-\u001F\u007F]*/.freeze
-    IDENTIFIER =
-      /[A-Za-z0-9_-]+/.freeze
-    SPACE =
-      /[ \t]/.freeze
-    NEWLINE =
-      /(?:[ \t]*(?:\r?\n)[ \t]*)+/.freeze
-    STRING_BASIC =
-      /(")(?:\\?[^\u0000-\u0008\u000A-\u001F\u007F\\]|(?:\\[^\u0000-\u0008\u000A-\u001F\u007F]))*?\1/.freeze
-    STRING_MULTI =
-      /"{3}([^\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]*?(?<!\\)"{3,5})/m.freeze
-    STRING_LITERAL =
-      /(')(?:\\?[^\u0000-\u0008\u000A-\u001F\u007F])*?\1/.freeze
-    STRING_LITERAL_MULTI =
-      /'{3}([^\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]*?'{3,5})/m.freeze
-    DATETIME =
-      /(-?\d{4})-([01]\d)-([0-3]\d)(?:(?:t|\s)([0-2]\d):([0-5]\d):([0-6]\d(?:\.\d+)?))?(z|[-+][01]\d:\d{2})?/i.freeze
-    LOCAL_TIME =
-      /([0-2]\d):([0-5]\d):([0-6]\d(?:\.\d+)?)/.freeze
-    FLOAT =
-      /[+-]?(?:(?:\d|[1-9](?:_?\d)*)\.\d(?:_?\d)*|\d+(?=[eE]))(?:[eE][+-]?[0-9]+(_[0-9])*[0-9]*)?(?!\w)/.freeze
-    FLOAT_KEYWORD =
-      /[+-]?(?:inf|nan)\b/.freeze
-    INTEGER =
-      /[+-]?([1-9](_?\d)*|0)(?![A-Za-z0-9_-]+)/.freeze
-    NON_DEC_INTEGER =
-      /0(?:x[0-9A-Fa-f](_?[0-9A-Fa-f])*|o[0-7](_?[0-7])*|b[01](_?[01])*)/.freeze
-    BOOLEAN =
-      /true|false/.freeze
-    SPACED_ARRAY_OF_TABLES_START =
-      /^\[[ \t]+\[(#{IDENTIFIER}|#{STRING_BASIC}|#{STRING_LITERAL}|#{INTEGER}|#{NON_DEC_INTEGER}|#{FLOAT_KEYWORD}|#{BOOLEAN})\]\]$/.freeze
-    SPACED_ARRAY_OF_TABLES_END =
-      /^\[\[(#{IDENTIFIER}|#{STRING_BASIC}|#{STRING_LITERAL}|#{INTEGER}|#{NON_DEC_INTEGER}|#{FLOAT_KEYWORD}|#{BOOLEAN})\][ \t]+\]$/.freeze
-    SPACED_ARRAY_OF_TABLES_BOTH =
-      /^\[[ \t]+\[(#{IDENTIFIER}|#{STRING_BASIC}|#{STRING_LITERAL}|#{INTEGER}|#{NON_DEC_INTEGER}|#{FLOAT_KEYWORD}|#{BOOLEAN})\][ \t]+\]$/.freeze
-
-    def initialize(io)
-      @ss = StringScanner.new(io.read)
-      @eos = false
-    end
-
-    def next_token
-      case
-      when @ss.scan(NEWLINE) then [:NEWLINE, nil]
-      when @ss.scan(SPACED_ARRAY_OF_TABLES_START) then raise ParseError.new('Array of tables has spaces in starting brackets')
-      when @ss.scan(SPACED_ARRAY_OF_TABLES_END) then raise ParseError.new('Array of tables has spaces in ending brackets')
-      when @ss.scan(SPACED_ARRAY_OF_TABLES_BOTH) then raise ParseError.new('Array of tables has spaces in starting and ending brackets')
-      when @ss.scan(SPACE) then next_token
-      when @ss.scan(COMMENT) then next_token
-      when @ss.scan(DATETIME) then process_datetime
-      when @ss.scan(LOCAL_TIME) then process_local_time
-      when text = @ss.scan(STRING_MULTI) then [:STRING_MULTI, text[3..-4]]
-      when text = @ss.scan(STRING_BASIC) then [:STRING_BASIC, text[1..-2]]
-      when text = @ss.scan(STRING_LITERAL_MULTI) then [:STRING_LITERAL_MULTI, text[3..-4]]
-      when text = @ss.scan(STRING_LITERAL) then [:STRING_LITERAL, text[1..-2]]
-      when text = @ss.scan(FLOAT) then [:FLOAT, text]
-      when text = @ss.scan(FLOAT_KEYWORD) then [:FLOAT_KEYWORD, text]
-      when text = @ss.scan(INTEGER) then [:INTEGER, text]
-      when text = @ss.scan(NON_DEC_INTEGER) then [:NON_DEC_INTEGER, text]
-      when text = @ss.scan(BOOLEAN) then [:BOOLEAN, text]
-      when text = @ss.scan(IDENTIFIER) then [:IDENTIFIER, text]
-      when @ss.eos? then process_eos
-      else x = @ss.getch; [x, x]
-      end
-    end
-
-    def process_datetime
-      offset = @ss[7].gsub(/[zZ]/, '+00:00') if @ss[7]
-      args = [@ss[0], @ss[1], @ss[2], @ss[3], @ss[4], @ss[5], @ss[6], offset]
-      [:DATETIME, args]
-    end
-
-    def process_local_time
-      args = [@ss[0], @ss[1], @ss[2], @ss[3].to_f]
-      [:LOCAL_TIME, args]
-    end
-
-    def process_eos
-      return if @eos
-
-      @eos = true
-      [:EOS, nil]
-    end
-  end
-end

data/lib/tomlrb/string_utils.rb

@@ -1,40 +0,0 @@
-# frozen-string-literal: true
-
-module Tomlrb
-  class StringUtils
-    SPECIAL_CHARS = {
-      '\\t'  => "\t",
-      '\\b'  => "\b",
-      '\\f'  => "\f",
-      '\\n'  => "\n",
-      '\\r'  => "\r",
-      '\\"'  => '"',
-      '\\\\' => '\\'
-    }.freeze
-
-    def self.multiline_replacements(str)
-      strip_spaces(str).gsub(/\\+\s*\n\s*/) do |matched|
-        if matched.match(/\\+/)[0].length.odd?
-          matched.gsub(/\\\s*\n\s*/, '')
-        else
-          matched
-        end
-      end
-    end
-
-    def self.replace_escaped_chars(str)
-      str.gsub(/\\(u[\da-fA-F]{4}|U[\da-fA-F]{8}|.)/) do |m|
-        if m.size == 2
-          SPECIAL_CHARS[m] || (raise Tomlrb::ParseError.new "Escape sequence #{m} is reserved")
-        else
-          m[2..-1].to_i(16).chr(Encoding::UTF_8)
-        end
-      end
-    end
-
-    def self.strip_spaces(str)
-      str[0] = '' if str[0] == "\n"
-      str
-    end
-  end
-end