Tomlrb

https://www.rubydoc.info/gems/tomlrb
Admin
Tomlrb is a Ruby parser library that converts TOML configuration files into Ruby data structures.
Tokens:22,105
Snippets:170
Trust Score:10
Update:6 months ago
Show doc for...
Tokens:
Raw
### GET Tomlrb::Parser#next_token

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Parser%3Anext_token

Retrieves the next token from the tokenizer instance within the parser.

```APIDOC
## GET Tomlrb::Parser#next_token

### Description
Retrieves the next token from the tokenizer instance within the parser.

### Method
GET

### Endpoint
Tomlrb::Parser#next_token

### Response
#### Success Response (200)
- **token** (Object) - The next token retrieved from the tokenizer.
```

--------------------------------

### GET Tomlrb::LocalDateTime#inspect

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDateTime%3Ainspect

Retrieves a string representation of a Tomlrb::LocalDateTime object.

```APIDOC
## GET Tomlrb::LocalDateTime#inspect

### Description
Returns a string representation of the Tomlrb::LocalDateTime instance in the format #<Tomlrb::LocalDateTime: value>.

### Method
GET

### Endpoint
Tomlrb::LocalDateTime#inspect

### Response
#### Success Response (200)
- **result** (String) - The string representation of the object.
```

--------------------------------

### GET Tomlrb::Handler#output

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler%3Aoutput

Retrieves the current value of the output attribute from the Tomlrb::Handler instance.

```APIDOC
## GET Tomlrb::Handler#output

### Description
Returns the value of the output attribute, which typically contains the result of a TOML parsing operation.

### Method
GET

### Endpoint
Tomlrb::Handler#output

### Response
#### Success Response (200)
- **output** (Object) - The parsed TOML data stored in the handler.
```

--------------------------------

### Define SPACED_ARRAY_OF_TABLES_START Regex - Tomlrb::Scanner

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Scanner

Regular expression for matching the start of a spaced array of tables.

```ruby
/^\[[ \t]+ \[
(#{IDENTIFIER}|#{STRING_BASIC}|#{STRING_LITERAL}|#{INTEGER}|#{NON_DEC_INTEGER}|#{FLOAT_KEYWORD}|#{BOOLEAN})\] $/.freeze
```

--------------------------------

### GET Tomlrb::LocalTime#inspect

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalTime%3Ainspect

Returns a string representation of the LocalTime object for debugging purposes.

```APIDOC
## GET Tomlrb::LocalTime#inspect

### Description
Returns a formatted string representation of the Tomlrb::LocalTime instance.

### Method
GET

### Endpoint
Tomlrb::LocalTime#inspect

### Response
#### Success Response (200)
- **result** (String) - A string in the format '#<Tomlrb::LocalTime: [value]>'
```

--------------------------------

### Get Tomlrb Handler Output

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler%3Aoutput

Returns the value of the output attribute. This is a simple getter method.

```ruby
def output
  @output
end
```

--------------------------------

### GET Tomlrb::Key#type

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Key%3Atype

Retrieves the type attribute of a Tomlrb::Key object.

```APIDOC
## GET Tomlrb::Key#type

### Description
Returns the value of the type attribute for a given Key object.

### Method
GET

### Endpoint
Tomlrb::Key#type

### Response
#### Success Response (200)
- **type** (Object) - The value of the attribute type.
```

--------------------------------

### Get Key Attribute

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Key

Retrieves the value of the 'key' attribute. This is a read-only attribute.

```ruby
def key
  @key
end
```

--------------------------------

### Handle Array of Tables in TOML Parsing

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler%3Adeal_with_array_of_tables

This method is used to process array of tables during TOML parsing. It manages identifiers and raises errors for conflicting table definitions. Ensure proper setup of the handler for correct behavior.

```ruby
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
```

--------------------------------

### Get Next Token - Tomlrb Parser

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Parser%3Anext_token

Retrieves the next token from the tokenizer. This method is part of the `Parser` class in the `tomlrb` gem.

```ruby
def next_token
  @tokenizer.next_token
end
```

--------------------------------

### Tomlrb::Key#initialize

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Key%3Ainitialize

Initializes a new instance of the Tomlrb::Key class.

```APIDOC
## Tomlrb::Key#initialize

### Description
Creates a new instance of the Key class used within the Tomlrb handler.

### Parameters
#### Arguments
- **key** (Object) - Required - The key identifier.
- **type** (Object) - Required - The type associated with the key.
- **declared** (Boolean) - Optional - Indicates if the key has been explicitly declared (default: false).

### Response
- **Key** (Object) - Returns a new instance of Key.
```

--------------------------------

### Get Type Attribute

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Key

Retrieves the value of the 'type' attribute. This is a read-only attribute.

```ruby
def type
  @type
end
```

--------------------------------

### start_

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler

Initializes a new parsing state for a specific type.

```APIDOC
## start_

### Description
Triggers the start of a parsing sequence for a given type by pushing it to the stack.

### Parameters
- **type** (Object) - Required - The type identifier to initialize.
```

--------------------------------

### POST /Tomlrb/Parser/initialize

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Parser%3Ainitialize

Initializes a new instance of the Tomlrb::Parser class with a tokenizer and optional configuration.

```APIDOC
## initialize

### Description
Returns a new instance of the Tomlrb::Parser class.

### Method
Constructor

### Parameters
#### Arguments
- **tokenizer** (Object) - Required - The tokenizer instance used for parsing.
- **options** (Hash) - Optional - Configuration options passed to the Tomlrb::Handler.

### Request Example
```ruby
parser = Tomlrb::Parser.new(tokenizer, symbolize_keys: true)
```

### Response
#### Success Response
- **Parser** (Object) - A new instance of Tomlrb::Parser.
```

--------------------------------

### Tomlrb::Handler#start_

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler%3Astart_

Initializes a new structure in the handler by pushing the specified type onto the stack.

```APIDOC
## Method: Tomlrb::Handler#start_

### Description
Initializes a new structure in the handler by pushing the specified type onto the stack.

### Parameters
#### Arguments
- **type** (Object) - Required - The type of structure to start.

### Request Example
```ruby
# Internal call within the parser
start_(:table)
```

### Response
- **Returns** (Object) - The result of the push operation.
```

--------------------------------

### Initialize Tomlrb::Key instance

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Key%3Ainitialize

Constructor for creating a new Key instance. Sets the key, type, and declaration status, and initializes an empty children hash.

```ruby
# File 'lib/tomlrb/handler.rb', line 221

def initialize(key, type, declared = false)
  @key = key
  @type = type
  @declared = declared
  @children = {}
end
```

--------------------------------

### Tomlrb::Keys#initialize

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Keys%3Ainitialize

Initializes a new instance of the Keys class within the Tomlrb module.

```APIDOC
## Initialize Tomlrb::Keys

### Description
Creates a new instance of the Keys class, initializing an empty hash for key storage.

### Method
Constructor

### Endpoint
Tomlrb::Keys#initialize

### Response
- **instance** (Keys) - A new instance of the Keys class with an empty @keys hash.
```

--------------------------------

### POST /Tomlrb/LocalTime/initialize

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalTime%3Ainitialize

Initializes a new instance of the LocalTime class with hour, minute, and second parameters.

```APIDOC
## POST /Tomlrb/LocalTime/initialize

### Description
Creates a new instance of LocalTime. Validates that the provided hour and minute values are within logical time bounds.

### Method
POST

### Parameters
#### Request Body
- **hour** (Integer) - Required - The hour component of the time.
- **min** (Integer) - Required - The minute component of the time.
- **sec** (Integer) - Required - The second component of the time.

### Response
#### Success Response (200)
- **LocalTime** (Object) - A new instance of the LocalTime class.

#### Error Response (400)
- **ArgumentError** - Raised if the provided hour or minute values are invalid.
```

--------------------------------

### Tomlrb::Parser#initialize

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Parser

Details of the constructor for the Tomlrb::Parser class.

```APIDOC
## Constructor: Tomlrb::Parser#initialize

### Description
Returns a new instance of Parser.

### Method
`initialize(tokenizer, **options)`

### Parameters
* `tokenizer`: The tokenizer to use.
* `options`: Hash of options.

### Source
`lib/tomlrb/parser.rb`, line 7

### Code Example
```ruby
def initialize(tokenizer, **options)
  @tokenizer = tokenizer
  @handler   = Tomlrb::Handler.new(**options)
  super()
end
```
```

--------------------------------

### Initialize Tomlrb::Handler

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler%3Ainitialize

Initializes a new instance of the Tomlrb::Handler class with optional configuration settings.

```APIDOC
## POST /Tomlrb/Handler/initialize

### Description
Creates a new instance of the Handler class, setting up the internal state for TOML parsing.

### Method
POST

### Parameters
#### Request Body
- **symbolize_keys** (boolean) - Optional - If set to true, keys in the resulting hash will be symbolized.

### Request Example
{
  "symbolize_keys": true
}

### Response
#### Success Response (200)
- **Handler** (Object) - A new instance of the Tomlrb::Handler class.
```

--------------------------------

### Define SPACED_ARRAY_OF_TABLES_BOTH Regex - Tomlrb::Scanner

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Scanner

Regular expression for matching both start and end of a spaced array of tables.

```ruby
/^\[[ \t]+ \[
(#{IDENTIFIER}|#{STRING_BASIC}|#{STRING_LITERAL}|#{INTEGER}|#{NON_DEC_INTEGER}|#{FLOAT_KEYWORD}|#{BOOLEAN})\][ \t]+ \] $/.freeze
```

--------------------------------

### Tomlrb::Key Class Overview

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Key

Provides an overview of the Tomlrb::Key class, its inheritance, and defined methods.

```APIDOC
## Class: Tomlrb::Key

Inherits:
     Object
  * Object
  * Tomlrb::Key

show all 

Defined in:
    lib/tomlrb/handler.rb 
## Defined Under Namespace
**Classes:** KeyConflict
## Instance Attribute Summary collapse
  * #**declared** ⇒ Object  writeonly
Sets the attribute declared.
  * #**key** ⇒ Object  readonly
Returns the value of attribute key.
  * #**type** ⇒ Object  readonly
Returns the value of attribute type.


##  Instance Method Summary collapse
  * #**< <**(key_type_declared) ⇒ Object 
  * #**clear_children** ⇒ Object 
  * #**declared?** ⇒ Boolean 
  * #**initialize**(key, type, declared = false) ⇒ Key  constructor
A new instance of Key.

```

--------------------------------

### Tomlrb::Handler#start_ Method Implementation

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler%3Astart_

This method is part of the internal handler for parsing TOML. It pushes a new type onto the internal stack.

```ruby
def start_(type)
  push([type])
end
```

--------------------------------

### Initialize Tomlrb::Key

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Key

Constructor for the Key class. Initializes a new instance with a key, type, and an optional declared flag.

```ruby
def initialize(key, type, declared = false)
  @key = key
  @type = type
  @declared = declared
  @children = {}
end
```

--------------------------------

### Initialize Tomlrb::Parser

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Parser%3Ainitialize

Creates a new instance of the Parser class with a tokenizer and optional configuration.

```ruby
def initialize(tokenizer, **options)
  @tokenizer = tokenizer
  @handler   = Tomlrb::Handler.new(**options)
  super()
end
```

--------------------------------

### Initialize Tomlrb::Keys

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Keys%3Ainitialize

Initializes a new instance of the Keys class. This method sets up an empty hash to store keys.

```ruby
def initialize
  @keys = {}
end
```

--------------------------------

### Initialize Tomlrb::Handler

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler

Constructor for the Handler class, setting up the initial output structure and configuration options.

```ruby
# File 'lib/tomlrb/handler.rb', line 7

def initialize(**options)
  @output = {}
  @current = @output
  @stack = []
  @array_names = []
  @current_table = []
  @keys = Keys.new
  @symbolize_keys = options[:symbolize_keys]
end
```

--------------------------------

### Tomlrb::Key Instance Methods

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Key

Details the instance methods available for the Tomlrb::Key class.

```APIDOC
## Instance Method Details
### permalink #**< <**(key_type_declared) ⇒ `Object`
[View source] 
```ruby
# File 'lib/tomlrb/handler.rb', line 232
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

### permalink #**clear_children** ⇒ `Object`
[View source] 
```ruby
# File 'lib/tomlrb/handler.rb', line 243
def clear_children
  @children.clear
end

### permalink #**declared?** ⇒ `Boolean`
Returns:
  * (`Boolean`)

[View source] 
```ruby
# File 'lib/tomlrb/handler.rb', line 228
def declared?
  @declared
end
```
```

--------------------------------

### Tomlrb::LocalDateTime Instance Methods

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDateTime

Provides documentation for various instance methods of the Tomlrb::LocalDateTime class, including equality comparison, string inspection, and conversion to Time objects.

```APIDOC
## GET /api/users/{id}

### Description
Provides documentation for instance methods of the Tomlrb::LocalDateTime class.

### Method
GET

### Endpoint
Tomlrb::LocalDateTime Instance Methods

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
None

### Response
#### Success Response (200)
- **#==**(other) (Object) - Compares two LocalDateTime objects for equality.
- **#inspect** (Object) - Returns a string representation of the LocalDateTime object for inspection.
- **#to_s** (Object) - Returns a string representation of the LocalDateTime object in ISO 8601 format.
- **#to_time**(offset = '-00:00') (Time) - Converts the LocalDateTime object to a Time object with an optional offset.

#### Response Example
```json
{
  "methods": [
    "#==",
    "#inspect",
    "#to_s",
    "#to_time"
  ]
}
```
```

--------------------------------

### Tomlrb::Handler Instance Methods

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler

Documentation for the instance methods of the Tomlrb::Handler class.

```APIDOC
## Instance Method Details

### #assign(k) ⇒ Object
Handles the assignment of keys and values within the TOML structure.

### #deal_with_array_of_tables(identifiers, is_array_of_tables) {|identifiers| ... } ⇒ Object
Processes identifiers to manage arrays of tables, yielding control for further processing.

### #end_(type) ⇒ Object
Manages the closing of table structures during parsing.

### #push(o) ⇒ Object
Pushes an object onto the internal stack.

### #push_inline(inline_arrays) ⇒ Object
Handles the pushing of inline arrays onto the stack.

### #set_context(identifiers, is_array_of_tables: false) ⇒ Object
Sets the current parsing context based on identifiers and whether it's an array of tables.

### #start_(type) ⇒ Object
Initiates a new parsing context for a given type.

### #validate_value(value) ⇒ Object
Validates a given value according to TOML specifications.
```

--------------------------------

### Tomlrb::Scanner Constructor: initialize

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Scanner

Initializes a new instance of the Scanner class.

```APIDOC
## Constructor Details
### permalink #**initialize**(io) ⇒ `Scanner`

Returns a new instance of Scanner.
[View source]
```ruby
# File 'lib/tomlrb/scanner.rb', line 44
def initialize(io)
  @ss = StringScanner.new(io.read)
  @eos = false
end
```
```

--------------------------------

### Tomlrb::Keys Constructor

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Keys

Initializes a new instance of the Keys class. It sets up an internal hash to store keys.

```APIDOC
## initialize

### Description
Returns a new instance of Keys.

### Method
constructor

### Endpoint
N/A

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **Keys** (instance) - A new instance of the Keys class.

#### Response Example
None
```

--------------------------------

### Initialize Tomlrb::Handler

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler%3Ainitialize

Initializes a new instance of the Handler class. Accepts an options hash, where `:symbolize_keys` can be set to true to symbolize keys in the parsed TOML data.

```ruby
def initialize(**options)
  @output = {}
  @current = @output
  @stack = []
  @array_names = []
  @current_table = []
  @keys = Keys.new
  @symbolize_keys = options[:symbolize_keys]
end
```

--------------------------------

### Tomlrb::Key Instance Attributes

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Key

Documentation for the instance attributes of the Tomlrb::Key class.

```APIDOC
## Instance Attribute Details
### permalink #**declared=**(value) ⇒ `Object` (writeonly)
Sets the attribute declared
Parameters:
  * value — 
the value to set the attribute declared to.

```ruby
# File 'lib/tomlrb/handler.rb', line 219
def declared=(value)
  @declared = value
end
```
### permalink #**key** ⇒ `Object` (readonly)
Returns the value of attribute key.
```ruby
# File 'lib/tomlrb/handler.rb', line 218
def key
  @key
end
```
### permalink #**type** ⇒ `Object` (readonly)
Returns the value of attribute type.
```ruby
# File 'lib/tomlrb/handler.rb', line 218
def type
  @type
end
```
```

--------------------------------

### Initialize Tomlrb::Scanner

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Scanner%3Ainitialize

Creates a new instance of Scanner by reading from the provided IO object.

```ruby
def initialize(io)
  @ss = StringScanner.new(io.read)
  @eos = false
end
```

--------------------------------

### Tomlrb::Scanner#initialize

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Scanner%3Ainitialize

Initializes a new instance of the Scanner class by reading from an IO object.

```APIDOC
## initialize(io)

### Description
Returns a new instance of Scanner by reading the provided IO object.

### Parameters
#### Path Parameters
- **io** (IO) - Required - An IO object containing the TOML data to be scanned.

### Response
#### Success Response (200)
- **Scanner** (Object) - A new instance of the Tomlrb::Scanner class.
```

--------------------------------

### Initialize Scanner - Tomlrb::Scanner

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Scanner

Initializes a new instance of the Scanner class with the provided IO object. It reads the entire content and initializes a StringScanner.

```ruby
# File 'lib/tomlrb/scanner.rb', line 44

def initialize(io)
  @ss = StringScanner.new(io.read)
  @eos = false
end
```

--------------------------------

### Constructor: Tomlrb::LocalDate.new

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDate

Initializes a new instance of the LocalDate class with a specified year, month, and day.

```APIDOC
## Constructor: Tomlrb::LocalDate.new

### Description
Creates a new instance of LocalDate. Raises an ArgumentError if the provided date components are invalid.

### Parameters
- **year** (Integer) - Required - The year component.
- **month** (Integer) - Required - The month component.
- **day** (Integer) - Required - The day component.

### Response
- **LocalDate** - A new instance of the LocalDate class.
```

--------------------------------

### Initialize Tomlrb::LocalTime

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalTime%3Ainitialize

Constructor for creating a new LocalTime instance. Raises an ArgumentError if the provided time components are invalid.

```ruby
def initialize(hour, min, sec)
  @time = Time.utc(0, 1, 1, hour, min, sec)
  raise ArgumentError, "Invalid Local Time: #{hour}-#{min}-#{sec}" unless min.to_i == @time.min && hour.to_i == @time.hour
  @sec = sec
end
```

--------------------------------

### Tomlrb::Handler Constructor

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler

Documentation for the constructor of the Tomlrb::Handler class.

```APIDOC
## Constructor Details

### #initialize(**options) ⇒ Handler
Returns a new instance of Handler.

#### Parameters
- **options** (Hash) - Options for initializing the handler, such as `:symbolize_keys`.
```

--------------------------------

### Tomlrb::LocalTime Constructor

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalTime

Initializes a new instance of Tomlrb::LocalTime with hour, minute, and second.

```APIDOC
## initialize(hour, min, sec)

### Description
Constructor for creating a new LocalTime object.

### Method
`initialize`

### Parameters
#### Path Parameters
- **hour** (Integer) - The hour of the day.
- **min** (Integer) - The minute of the hour.
- **sec** (Integer) - The second of the minute.

### Request Body
None

### Response
#### Success Response (200)
- **LocalTime** (LocalTime) - A new instance of LocalTime.

#### Response Example
```json
{
  "example": "new Tomlrb::LocalTime(10, 30, 0)"
}
```

### Error Handling
- Raises `ArgumentError` for invalid time values.
```

--------------------------------

### Tomlrb::Key Constructor

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Key

Details the constructor for the Tomlrb::Key class, including parameters and source code.

```APIDOC
## Constructor Details
### permalink #**initialize**(key, type, declared = false) ⇒ `Key`
Returns a new instance of Key.
[View source] 
```ruby
# File 'lib/tomlrb/handler.rb', line 221
def initialize(key, type, declared = false)
  @key = key
  @type = type
  @declared = declared
  @children = {}
end
```
```

--------------------------------

### Initialize Tomlrb::LocalDate

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDate%3Ainitialize

Constructs a new LocalDate instance. Raises an ArgumentError if the provided date components do not form a valid date.

```ruby
def initialize(year, month, day)
  @time = Time.utc(year, month, day, 0, 0, 0)
  raise ArgumentError, "Invalid Local Date: #{year}-#{month}-#{day}" unless day.to_i == @time.day && month.to_i == @time.month && year.to_i == @time.year
end
```

--------------------------------

### Tomlrb::LocalDate#initialize

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDate%3Ainitialize

Initializes a new instance of the LocalDate class. It takes year, month, and day as arguments and raises an ArgumentError for invalid dates.

```APIDOC
## Tomlrb::LocalDate#initialize

### Description
Returns a new instance of LocalDate.

### Method
initialize

### Parameters
#### Path Parameters
- **year** (Integer) - Required - The year.
- **month** (Integer) - Required - The month.
- **day** (Integer) - Required - The day.

### Request Example
```json
{
  "year": 2023,
  "month": 10,
  "day": 27
}
```

### Response
#### Success Response (200)
- **LocalDate** (Object) - A new instance of LocalDate.

#### Response Example
```json
{
  "date": "2023-10-27"
}
```

### Error Handling
- **ArgumentError**: Raised if the provided year, month, and day do not form a valid date.
```

--------------------------------

### Tomlrb::Scanner Class Overview

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Scanner

Overview of the Tomlrb::Scanner class, its inheritance, and the file where it is defined.

```APIDOC
## Class: Tomlrb::Scanner

Inherits:
     Object
  * Object
  * Tomlrb::Scanner

Defined in:
    lib/tomlrb/scanner.rb
```

--------------------------------

### Method: #to_s

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDate

Returns the string representation of the LocalDate.

```APIDOC
## Method: #to_s

### Description
Returns the date formatted as a string using the '%F' format.

### Response
- **String** - The formatted date string.
```

--------------------------------

### Initialize Tomlrb::LocalDateTime

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDateTime%3Ainitialize

Constructor for creating a new LocalDateTime instance. It validates the provided date and time components against a UTC time object and raises an ArgumentError if the input is invalid.

```ruby
# File 'lib/tomlrb/local_date_time.rb', line 11

def initialize(year, month, day, hour, min, sec) # rubocop:disable Metrics/ParameterLists
  @time = Time.utc(year, month, day, hour, min, sec)
  raise ArgumentError, "Invalid Local Date-Time: #{year}-#{month}-#{day}T#{hour}:#{min}:#{sec}" 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

  @sec = sec
end
```

--------------------------------

### Initialize Tomlrb::LocalDateTime

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDateTime

Constructs a new LocalDateTime object. It validates the provided time components and raises an ArgumentError for invalid values. This method is intended for internal use or when precise control over time creation is needed.

```ruby
def initialize(year, month, day, hour, min, sec) # rubocop:disable Metrics/ParameterLists
  @time = Time.utc(year, month, day, hour, min, sec)
  raise ArgumentError, "Invalid Local Date-Time: #{year}-#{month}-#{day}T#{hour}:#{min}:#{sec}" 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

  @sec = sec
end
```

--------------------------------

### Tomlrb::LocalTime Instance Methods

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalTime

Details of instance methods available for Tomlrb::LocalTime objects.

```APIDOC
## ==(other)

### Description
Compares the current LocalTime object with another object for equality.

### Method
`==`

### Parameters
#### Path Parameters
- **other** (Object) - The object to compare with.

### Response
#### Success Response (200)
- **Object** (Boolean) - Returns true if the objects are equal, false otherwise.

### Request Example
```json
{
  "example": "time1 == time2"
}
```

### Response Example
```json
{
  "example": "true"
}
```
```

```APIDOC
## inspect

### Description
Returns a string representation of the LocalTime object, suitable for debugging.

### Method
`inspect`

### Response
#### Success Response (200)
- **Object** (String) - A string representation of the object.

#### Response Example
```json
{
  "example": "#<Tomlrb::LocalTime: 10:30:00>"
}
```
```

```APIDOC
## to_s

### Description
Returns a string representation of the LocalTime object in HH:MM:SS format.

### Method
`to_s`

### Response
#### Success Response (200)
- **Object** (String) - The time formatted as a string.

#### Response Example
```json
{
  "example": "10:30:00"
}
```
```

```APIDOC
## to_time(year, month, day, offset = '-00:00')

### Description
Converts the LocalTime object to a Time object by combining it with the provided date and offset.

### Method
`to_time`

### Parameters
#### Path Parameters
- **year** (Integer) - The year.
- **month** (Integer) - The month.
- **day** (Integer) - The day.
- **offset** (String) - The timezone offset, defaults to '-00:00'.

### Response
#### Success Response (200)
- **Time** (Time) - The resulting Time object.

#### Response Example
```json
{
  "example": "tomlrb_local_time.to_time(2023, 10, 27, '-05:00')"
}
```
```

--------------------------------

### Push to Stack

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler

Adds an object to the internal stack.

```ruby
# File 'lib/tomlrb/handler.rb', line 69

def push(o)
  @stack << o
end
```

--------------------------------

### Initialize Tomlrb::LocalDateTime

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDateTime%3Ainitialize

Initializes a new LocalDateTime object by validating the provided date and time components.

```APIDOC
## initialize(year, month, day, hour, min, sec)

### Description
Initializes a new instance of the LocalDateTime class. It validates the provided date and time components and raises an ArgumentError if the input is invalid.

### Parameters
- **year** (Integer) - Required - The year component.
- **month** (Integer) - Required - The month component.
- **day** (Integer) - Required - The day component.
- **hour** (Integer) - Required - The hour component.
- **min** (Integer) - Required - The minute component.
- **sec** (Integer) - Required - The second component.

### Response
- **LocalDateTime** (Object) - Returns a new instance of the LocalDateTime class.

### Errors
- **ArgumentError** - Raised if the provided date-time components do not form a valid date-time.
```

--------------------------------

### Tomlrb::Parser#parse

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Parser%3Aparse

Parses the TOML content and returns the handler object.

```APIDOC
## Tomlrb::Parser#parse

### Description
Parses the TOML content and returns the handler object.

### Method
GET

### Endpoint
/websites/rubydoc_info_gems_tomlrb

### Parameters
#### Query Parameters
- **content** (string) - Required - The TOML content to parse.

### Request Example
```json
{
  "content": "key = \"value\""
}
```

### Response
#### Success Response (200)
- **handler** (Object) - The handler object containing the parsed TOML data.

#### Response Example
```json
{
  "handler": {
    "key": "value"
  }
}
```
```

--------------------------------

### Assign Keys in Handler

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler

Assigns a key path to the current output structure, optionally symbolizing keys based on configuration.

```ruby
# File 'lib/tomlrb/handler.rb', line 60

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
```

--------------------------------

### POST /tomlrb/handler/push

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler%3Apush

The push method adds an object to the internal stack of the Tomlrb handler.

```APIDOC
## POST /tomlrb/handler/push

### Description
Adds an object to the internal stack of the Tomlrb handler.

### Method
POST

### Endpoint
/tomlrb/handler/push

### Parameters
#### Request Body
- **o** (Object) - Required - The object to be pushed onto the stack.

### Response
#### Success Response (200)
- **result** (Object) - The object that was pushed onto the stack.
```

--------------------------------

### Tomlrb::Parser Class

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Parser

Documentation for the Tomlrb::Parser class, its inheritance, and defined methods.

```APIDOC
## Class: Tomlrb::Parser

### Description
Represents the parser for TOML data.

### Inheritance
Inherits from: GeneratedParser, Object, Racc::Parser

### Defined in
`lib/tomlrb/parser.rb`

### Constructor
#### initialize(tokenizer, **options)

Creates a new instance of the Parser.

**Parameters**:
* `tokenizer`: An object responsible for tokenizing the input.
* `options` (Hash): Optional configuration options.

### Instance Methods
#### next_token

Retrieves the next token from the tokenizer.

#### parse

Parses the TOML data and returns the handler object.

### Constants inherited from GeneratedParser
* `Racc_arg`
* `Racc_debug_parser`
* `Racc_token_to_s_table`
```

--------------------------------

### Tomlrb::Handler#assign

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler%3Aassign

Assigns a key to the current table, handling nested keys.

```APIDOC
## Tomlrb::Handler#assign

### Description
Assigns a key to the current table, handling nested keys. It iterates through the key path, creating or navigating through tables as necessary.

### Method
`assign(k)`

### Endpoint
N/A (Instance Method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
Returns `Object` - The assigned value or the current table.

#### Response Example
None

### Source Code
```ruby
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
```
```

--------------------------------

### Implement _reduce_none method

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/GeneratedParser

Internal reduction method used by the parser to return the first value in the stack.

```ruby
# File 'lib/tomlrb/generated_parser.rb', line 803

def _reduce_none(val, _values, result)
  val[0]
end
```

--------------------------------

### Implement Equality Comparison for LocalTime

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalTime%3A%3D%3D

Compares a LocalTime object with another object for equality. Ensures the other object is also a LocalTime and checks if their time values match.

```Ruby
def ==(other)
  other.is_a?(self.class) &&
    @time == other.to_time(0, 1, 1)
end
```

--------------------------------

### Tomlrb::Parser#next_token

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Parser

Details of the next_token instance method for the Tomlrb::Parser class.

```APIDOC
## Instance Method: Tomlrb::Parser#next_token

### Description
Retrieves the next token from the tokenizer.

### Method
`next_token`

### Returns
* `Object`: The next token.

### Source
`lib/tomlrb/parser.rb`, line 13

### Code Example
```ruby
def next_token
  @tokenizer.next_token
end
```
```

--------------------------------

### Tomlrb::LocalDateTime Constructor

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDateTime

Initializes a new LocalDateTime object with the provided year, month, day, hour, minute, and second. It validates the input and raises an ArgumentError for invalid date-time values.

```APIDOC
## POST /api/users

### Description
Initializes a new LocalDateTime object.

### Method
CONSTRUCTOR

### Endpoint
Tomlrb::LocalDateTime#initialize

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **year** (Integer) - Required - The year.
- **month** (Integer) - Required - The month.
- **day** (Integer) - Required - The day.
- **hour** (Integer) - Required - The hour.
- **min** (Integer) - Required - The minute.
- **sec** (Integer) - Required - The second.

### Request Example
```json
{
  "year": 2023,
  "month": 10,
  "day": 27,
  "hour": 14,
  "min": 30,
  "sec": 0
}
```

### Response
#### Success Response (200)
- **LocalDateTime** (Object) - The newly created LocalDateTime object.

#### Response Example
```json
{
  "message": "LocalDateTime object created successfully"
}
```

### Error Handling
- **ArgumentError**: Raised if the provided date-time components are invalid.
```

--------------------------------

### Tomlrb Exception: KeyConflict

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Key/KeyConflict

Details about the KeyConflict exception in the Tomlrb gem.

```APIDOC
## Exception: Tomlrb::Key::KeyConflict

### Description
Represents an error that occurs when a key conflict is detected during TOML parsing.

### Inheritance
- ParseError
- Object
- StandardError
- ParseError
- Tomlrb::Key::KeyConflict

### Defined In
- lib/tomlrb/handler.rb
```

--------------------------------

### Add a table key in Tomlrb

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Keys%3Aadd_table_key

Registers a new table key to the handler. The is_array_of_tables parameter defaults to false.

```ruby
def add_table_key(keys, is_array_of_tables = false)
  self << [keys, [], is_array_of_tables]
end
```

--------------------------------

### Access Handler Attributes

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler

Getter methods for the output and symbolize_keys attributes.

```ruby
# File 'lib/tomlrb/handler.rb', line 5

def output
  @output
end
```

```ruby
# File 'lib/tomlrb/handler.rb', line 5

def symbolize_keys
  @symbolize_keys
end
```

--------------------------------

### Tomlrb::Handler Instance Attributes

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler

Details of the instance attributes available on the Tomlrb::Handler class.

```APIDOC
## Instance Attribute Summary

### #output ⇒ Object (readonly)
Returns the value of attribute output.

### #symbolize_keys ⇒ Object (readonly)
Returns the value of attribute symbolize_keys.
```

--------------------------------

### Tomlrb::Key#key Method

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Key%3Akey

This snippet documents the `#key` method of the `Tomlrb::Key` class, which returns the value of the key attribute.

```APIDOC
## Tomlrb::Key#key

### Description
Returns the value of attribute key.

### Method
GET

### Endpoint
N/A (Instance Method)

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **key** (Object) - The value of the key attribute.

#### Response Example
```json
{
  "key": "example_value"
}
```
```

--------------------------------

### Tomlrb Classes

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/ParseError

Lists the classes available in the Tomlrb gem, organized by namespace.

```APIDOC
## Class List

Classes Methods Files

Search:
* Top Level Namespace
* TomlrbTop Level Namespace
  * GeneratedParser < ParserTomlrb
  * Handler < ObjectTomlrb
  * Key < ObjectTomlrb
    * KeyConflict < ParseErrorTomlrb::Key
  * Keys < ObjectTomlrb
  * LocalDate < ObjectTomlrb
  * LocalDateTime < ObjectTomlrb
  * LocalTime < ObjectTomlrb
  * ParseError < StandardErrorTomlrb
  * Parser < GeneratedParserTomlrb
  * Scanner < ObjectTomlrb
  * StringUtils < ObjectTomlrb
```

--------------------------------

### Tomlrb::Handler#push Method Implementation

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler%3Apush

This method adds an object to the internal stack. It's a core part of the parsing process for handling nested structures.

```Ruby
def push(o)
  @stack << o
end
```

--------------------------------

### Tomlrb Class List

Source: https://www.rubydoc.info/gems/tomlrb/index

Lists all classes available within the tomlrb gem, organized by namespace.

```APIDOC
## Tomlrb Gem Class Overview

### Description
This section details the classes and their hierarchical structure within the tomlrb gem.

### Classes

*   **Top Level Namespace**
    *   **Tomlrb**
        *   **GeneratedParser** < Parser
        *   **Handler** < Object
        *   **Key** < Object
            *   **KeyConflict** < ParseError::Key
        *   **Keys** < Object
        *   **LocalDate** < Object
        *   **LocalDateTime** < Object
        *   **LocalTime** < Object
        *   **ParseError** < StandardError
        *   **Parser** < GeneratedParser
        *   **Scanner** < Object
        *   **StringUtils** < Object

### Alphabetic Index

*   **G**
    *   GeneratedParser (Tomlrb)
*   **H**
    *   Handler (Tomlrb)
*   **K**
    *   Key (Tomlrb)
    *   KeyConflict (Tomlrb::Key)
    *   Keys (Tomlrb)
*   **L**
    *   LocalDate (Tomlrb)
    *   LocalDateTime (Tomlrb)
    *   LocalTime (Tomlrb)
*   **P**
    *   ParseError (Tomlrb)
    *   Parser (Tomlrb)
*   **S**
    *   Scanner (Tomlrb)
    *   StringUtils (Tomlrb)
*   **T**
    *   Tomlrb
```

--------------------------------

### Convert LocalTime to String

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalTime

Formats the LocalTime object as a string, including fractional seconds if present.

```ruby
def to_s
  frac = (@sec - sec)
  frac_str = frac.zero? ? '' : frac.to_s[1..-1]
  @time.strftime('%T') << frac_str
end
```

--------------------------------

### Tomlrb::Parser#parse

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Parser

Details of the parse instance method for the Tomlrb::Parser class.

```APIDOC
## Instance Method: Tomlrb::Parser#parse

### Description
Parses the TOML data.

### Method
`parse`

### Returns
* `Object`: The handler object after parsing.

### Source
`lib/tomlrb/parser.rb`, line 17

### Code Example
```ruby
def parse
  do_parse
  @handler
end
```
```

--------------------------------

### Convert LocalDate to string

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDate

Formats the date as a string using the ISO 8601 date format.

```ruby
def to_s
  @time.strftime('%F')
end
```

--------------------------------

### Convert LocalDateTime to String

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDateTime%3Ato_s

Returns a string representation of the date-time object formatted as ISO 8601, including fractional seconds if present.

```ruby
def to_s
  frac = (@sec - sec)
  frac_str = frac.zero? ? '' : frac.to_s[1..-1]
  @time.strftime('%FT%T') << frac_str
end
```

--------------------------------

### Method: #to_time

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/LocalDate

Converts the LocalDate instance to a Ruby Time object.

```APIDOC
## Method: #to_time

### Description
Returns the 00:00:00 time representation of the date.

### Parameters
- **offset** (String) - Optional - The timezone offset (defaults to '-00:00').

### Response
- **Time** - The Time object representing 00:00:00 of the date.
```

--------------------------------

### Handle Array of Tables

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler

Manages the logic for nested tables and arrays of tables during parsing, raising errors for invalid structures.

```ruby
# File 'lib/tomlrb/handler.rb', line 39

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
```

--------------------------------

### Tomlrb::Keys#<<

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Keys%3A%3C%3C

Appends keys to the current key structure, handling table keys, pair keys, and array of tables logic.

```APIDOC
## Method: Tomlrb::Keys#<<

### Description
Appends table and pair keys to the current key structure. It determines the hierarchy based on whether the keys represent a table, a pair, or an array of tables.

### Method
Instance Method

### Parameters
#### Arguments
- **keys** (Array) - Required - An array containing [table_keys, pair_keys, is_array_of_tables]

### Response
- **Object** - Returns the updated key structure.
```

--------------------------------

### Define Racc_token_to_s_table constant

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/GeneratedParser

Maps token symbols to their string representations for the parser.

```ruby
[
"$end",
"error",
"IDENTIFIER",
"STRING_MULTI",
"STRING_BASIC",
"STRING_LITERAL_MULTI",
"STRING_LITERAL",
"DATETIME",
"LOCAL_TIME",
"INTEGER",
"NON_DEC_INTEGER",
"FLOAT",
"FLOAT_KEYWORD",
"BOOLEAN",
"NEWLINE",
"EOS",
"\"[\"",
"\"]\"",
"\".\"",
"\"{\"",
"\"}\"",
"\",\"",
"\"=\"",
"$start",
"expressions",
"expression",
"table",
"assignment",
"inline_table",
"table_start",
"table_identifier",
"table_end",
"newlines",
"table_identifier_component",
"inline_table_start",
"inline_table_end",
"inline_continued",
"inline_assignment",
"inline_next",
"inline_assignment_key",
"value",
"assignment_key_component",
"assignment_key",
"array",
"start_array",
"array_first_value",
"array_values",
"comma",
"end_array",
"non_nil_value",
"array_value",
"scalar",
"non_nil_scalar",
"string",
"literal",
"non_nil_literal" ]
```

--------------------------------

### set_context

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Handler

Sets the current parsing context based on identifiers and handles array of tables logic.

```APIDOC
## set_context

### Description
Sets the current parsing context for the TOML document. It validates that identifiers are provided and updates the internal state to track the current table hierarchy.

### Parameters
- **identifiers** (Array) - Required - A list of keys representing the current table path.
- **is_array_of_tables** (Boolean) - Optional - Flag indicating if the current context is an array of tables (default: false).
```

--------------------------------

### Tomlrb::Parser#parse Method

Source: https://www.rubydoc.info/gems/tomlrb/Tomlrb/Parser%3Aparse

Parses TOML content and returns the handler object. This method should be called after the parser has processed the input.

```ruby
def parse
  do_parse
  @handler
end
```
Tokens:
Raw