IniParse

https://www.rubydoc.info/gems/iniparse
Admin
IniParse is a pure Ruby library for parsing INI configuration and data files while preserving...
Tokens:23,956
Snippets:211
Trust Score:10
Update:6 months ago
Show doc for...
Tokens:
Raw
### Get all keys

Source: https://www.rubydoc.info/gems/iniparse/IniParse/LineCollection

Returns an array containing the keys for all lines that have been added to this collection.

```ruby
def keys
  @indicies.keys
end
```

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

### Initialize IniParse::LineCollection

Source: https://www.rubydoc.info/gems/iniparse/IniParse/LineCollection%3Ainitialize

Initializes a new LineCollection instance by creating empty arrays and hash maps for storing lines and their indices. This is the standard setup for a new collection.

```ruby
def initialize
  @lines    = []
  @indicies = {}
end
```

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

### GET IniParse::OptionCollection#keys

Source: https://www.rubydoc.info/gems/iniparse/IniParse/OptionCollection%3Akeys

Retrieves an array of unique keys present in the OptionCollection.

```APIDOC
## GET IniParse::OptionCollection#keys

### Description
Returns an array containing the unique keys for the lines added to the OptionCollection.

### Method
GET

### Endpoint
IniParse::OptionCollection#keys

### Response
#### Success Response (200)
- **keys** (Array) - An array of unique key strings found in the collection.
```

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

### Get Unique Keys from OptionCollection

Source: https://www.rubydoc.info/gems/iniparse/IniParse/OptionCollection%3Akeys

Use this method to get an array of unique keys present in the option collection. It maps each line to its key and then filters for uniqueness.

```ruby
def keys
  map(&:key).uniq
end
```

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

### GET IniParse::Document#each

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document%3Aeach

Enumerates through each section in an IniParse document, with an optional parameter to include blank and comment lines.

```APIDOC
## GET IniParse::Document#each

### Description
Enumerates through each Section in this document. Does not yield blank and comment lines by default; if you want all lines to be yielded, pass true.

### Parameters
#### Query Parameters
- **include_blank** (Boolean) - Optional - Include blank/comment lines in the enumeration.

### Response
#### Success Response (200)
- **Object** - Returns the result of the enumeration.
```

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

### GET IniParse::Lines::Section#each

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Section%3Aeach

Enumerates through each Option in a section. By default, it skips blank and comment lines, but this behavior can be toggled.

```APIDOC
## GET IniParse::Lines::Section#each

### Description
Enumerates through each Option in this section. Does not yield blank and comment lines by default; if you want all lines to be yielded, pass true.

### Parameters
#### Path Parameters
- **include_blank** (Boolean) - Optional - Include blank/comment lines?

### Response
- **Object** - Returns the result of the enumeration.
```

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

### GET IniParse::LineCollection#each

Source: https://www.rubydoc.info/gems/iniparse/IniParse/LineCollection%3Aeach

Enumerates through the collection of lines in an INI document. By default, it skips blank and comment lines unless specified otherwise.

```APIDOC
## GET IniParse::LineCollection#each

### Description
Enumerates through the collection. By default, #each does not yield blank and comment lines.

### Method
GET

### Parameters
#### Query Parameters
- **include_blank** (Boolean) - Optional - Include blank/comment lines in the enumeration.

### Response
#### Success Response (200)
- **Object** - Returns an enumerator if no block is given, otherwise yields each line.
```

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

### GET #keys

Source: https://www.rubydoc.info/gems/iniparse/IniParse/OptionCollection

Retrieves an array of unique keys present in the collection.

```APIDOC
## GET #keys

### Description
Returns an array containing the unique keys for the lines added to this collection.
```

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

### GET IniParse::LineCollection#to_a

Source: https://www.rubydoc.info/gems/iniparse/IniParse/LineCollection%3Ato_a

Retrieves the collection of lines as an array, including blank and comment lines.

```APIDOC
## GET IniParse::LineCollection#to_a

### Description
Returns the current line collection as an array. This includes all lines, such as blank lines and comments.

### Method
GET

### Endpoint
IniParse::LineCollection#to_a

### Response
#### Success Response (200)
- **result** (Array) - An array containing the lines of the collection.
```

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

### GET IniParse::Lines::Blank#blank?

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Blank%3Ablank%3F

Checks if a line is blank within the IniParse library.

```APIDOC
## GET IniParse::Lines::Blank#blank?

### Description
Returns a boolean indicating whether the line is considered blank.

### Method
GET

### Endpoint
IniParse::Lines::Blank#blank?

### Response
#### Success Response (200)
- **result** (Boolean) - Returns true if the line is blank.
```

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

### Get Line Options - Ruby

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Line%3Aoptions

Retrieves the options used to construct a line, including comment and indentation settings. This method is part of the IniParse::Lines::Line class.

```ruby
def options
  {
    comment: @comment,
    comment_sep: @comment_sep,
    comment_prefix: @comment_prefix,
    comment_offset: @comment_offset,
    indent: @indent,
    option_sep: @option_sep
  }
end
```

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

### GET IniParse::Document#section

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document%3Asection

Retrieves a section by its key from an IniParse document. If the section does not exist, it is automatically created.

```APIDOC
## GET IniParse::Document#section

### Description
Returns the section identified by the provided key. If no section exists with the given key, a new one is created.

### Method
GET

### Parameters
#### Path Parameters
- **key** (String) - Required - The identifier for the section to retrieve or create.

### Response
#### Success Response (200)
- **Object** - Returns the Section object associated with the key.
```

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

### GET /IniParse/LineCollection/has_key?

Source: https://www.rubydoc.info/gems/iniparse/IniParse/LineCollection%3Ahas_key%3F

Checks if a specific key exists within the IniParse line collection.

```APIDOC
## GET /IniParse/LineCollection/has_key?

### Description
Returns a boolean indicating whether the specified key exists within the collection.

### Method
GET

### Endpoint
IniParse::LineCollection#has_key?

### Parameters
#### Path Parameters
- **args** (Array) - Required - The key or arguments to check for existence in the collection.

### Response
#### Success Response (200)
- **Boolean** - Returns true if the key exists, false otherwise.

### Response Example
{
  "result": true
}
```

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

### Get Keys from Line Collection

Source: https://www.rubydoc.info/gems/iniparse/IniParse/LineCollection

Extracts keys from each line in a collection. Assumes lines have a 'key' attribute.

```ruby
def keys
  map { |line| line.key }
end
```

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

### GET IniParse::Lines::Section#option

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Section%3Aoption

Retrieves the matching line instance for a given key within an INI section.

```APIDOC
## GET IniParse::Lines::Section#option

### Description
Retrieves the matching line instance for a given key. Unlike the [] operator, this returns the line object itself rather than just the value. If multiple lines match the key, an array of line instances is returned.

### Method
GET

### Parameters
#### Path Parameters
- **key** (String/Symbol) - Required - The key to search for within the section.

### Response
#### Success Response (200)
- **Object** - Returns the matching line instance or an array of line instances if duplicates exist.
```

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

### GET IniParse::Generator#context

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Generator%3Acontext

Retrieves the context attribute from the IniParse::Generator instance.

```APIDOC
## GET IniParse::Generator#context

### Description
Returns the value of the context attribute for the Generator instance.

### Method
GET

### Endpoint
IniParse::Generator#context

### Response
#### Success Response (200)
- **context** (Object) - The current context value of the generator.
```

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

### Handle Dynamic Method Calls in IniParse::Generator

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Generator%3Amethod_missing

Use this method to dynamically create INI options or sections. It distinguishes between assignment-like calls (e.g., `key=value`) for options and regular calls for sections. Requires no specific setup beyond including the Generator module.

```Ruby
def method_missing(name, *args, &blk) # :nodoc:
  if m = name.to_s.match(/(.*)=$/)
    option(m[1], *args)
  else
    section(name.to_s, *args, &blk)
  end
end
```

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

### GET IniParse::Document#inspect

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document%3Ainspect

Returns a human-readable string representation of the IniParse::Document object, listing all contained sections.

```APIDOC
## GET IniParse::Document#inspect

### Description
Returns a human-readable version of the document, primarily used for debugging purposes. It lists the keys of all sections contained within the document.

### Method
GET

### Endpoint
IniParse::Document#inspect

### Response
#### Success Response (200)
- **result** (String) - A formatted string containing the keys of the sections in the document, e.g., "#<IniParse::Document {section1, section2}>"
```

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

### GET IniParse::Lines::Option#key

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Option%3Akey

Retrieves the key attribute from an Option object within the IniParse library.

```APIDOC
## GET IniParse::Lines::Option#key

### Description
Returns the value of the key attribute for an instance of IniParse::Lines::Option.

### Method
GET

### Endpoint
IniParse::Lines::Option#key

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

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

### GET IniParse::Document#to_hash

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document%3Ato_hash

Converts an INI document object into a Ruby hash representation, handling multi-line options as arrays.

```APIDOC
## GET IniParse::Document#to_hash

### Description
Returns a hash representation of the INI document. Multi-line options are returned as an array of values.

### Method
GET

### Endpoint
IniParse::Document#to_hash

### Response
#### Success Response (200)
- **result** (Hash) - A nested hash where keys are section names and values are hashes of option keys and their corresponding values.
```

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

### Retrieve Value by Key in IniParse::LineCollection

Source: https://www.rubydoc.info/gems/iniparse/IniParse/LineCollection%3A%5B%5D

Use this method to get a value from the line collection using its associated key. Returns nil if the key is not found. Requires the key to be present in the collection.

```ruby
def [](key)
  has_key?(key) ? @lines[ @indicies[key] ] : nil
end
```

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

### Initialize Document

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document

Creates a new Document instance with an optional file path.

```ruby
# File 'lib/iniparse/document.rb', line 10

def initialize(path = nil)
  @path  = path
  @lines = IniParse::SectionCollection.new
end
```

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

### Initialize IniParse::Document

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document%3Ainitialize

Creates a new Document instance. Optionally accepts a file path to initialize the document from.

```ruby
def initialize(path = nil)
  @path  = path
  @lines = IniParse::SectionCollection.new
end
```

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

### Initialize IniParse::Lines::Section

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Section%3Ainitialize

Initializes a new section with a key and optional configuration. The key is converted to a string and an empty OptionCollection is created.

```ruby
def initialize(key, opts = {})
  super(opts)
  @key   = key.to_s
  @lines = IniParse::OptionCollection.new
end
```

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

### IniParse::Parser#initialize

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Parser%3Ainitialize

Initializes a new Parser instance with the provided source string.

```APIDOC
## IniParse::Parser#initialize

### Description
Creates a new Parser instance for parsing string `source`.

### Method
POST

### Endpoint
/websites/rubydoc_info_gems_iniparse

### Parameters
#### Path Parameters
- **source** (String) - Required - The source string.

### Request Example
```json
{
  "source": "[Your INI content here]"
}
```

### Response
#### Success Response (200)
- **Parser** (Object) - An instance of the Parser class.

#### Response Example
```json
{
  "message": "Parser initialized successfully"
}
```
```

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

### IniParse::Document#initialize

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document%3Ainitialize

Initializes a new Document instance. It can optionally take a file path to load INI data from.

```APIDOC
## IniParse::Document#initialize

### Description
Creates a new Document instance. Optionally loads data from a given file path.

### Method
POST

### Endpoint
/websites/rubydoc_info_gems_iniparse

### Parameters
#### Path Parameters
- **path** (String) - Optional - The file path to load INI data from.

### Request Example
```json
{
  "path": "/path/to/your/config.ini"
}
```

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

#### Response Example
```json
{
  "message": "Document initialized successfully"
}
```
```

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

### Generate a new IniParse::Document

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Generator.gen

Initializes a new generator with the specified options and executes the generation process.

```ruby
def self.gen(opts = {}, &blk)
  new(opts).gen(&blk)
end
```

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

### Get IniParse Generator Context

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Generator%3Acontext

Returns the value of the context attribute. This method is read-only.

```ruby
def context
  @context
end
```

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

### POST /IniParse/Lines/Line/initialize

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Line%3Ainitialize

Initializes a new line object within the IniParse library with optional configuration parameters.

```APIDOC
## initialize

### Description
Initializes a new instance of the IniParse::Lines::Line class with specific formatting options.

### Method
N/A (Constructor)

### Parameters
#### Request Body
- **opts** (Hash) - Optional - Extra options for the line.
  - **comment** (Object) - Optional - The comment content.
  - **comment_sep** (String) - Optional - The separator used for comments (default: ';').
  - **comment_prefix** (String) - Optional - The prefix used for comments (default: ' ').
  - **comment_offset** (Integer) - Optional - The offset for comments (default: 0).
  - **indent** (String) - Optional - The indentation string (default: '').
  - **option_sep** (String) - Optional - The separator used for options.

### Request Example
{
  "comment": "example comment",
  "indent": "  "
}
```

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

### Get IniParse Document Lines

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document%3Alines

Returns the value of the lines attribute. This method is read-only.

```Ruby
def lines
  @lines
end
```

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

### IniParse::Document Initialization

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document

Initializes a new IniParse::Document instance. Optionally accepts a path to load the document from.

```APIDOC
## POST /websites/rubydoc_info_gems_iniparse/document

### Description
Creates a new Document instance.

### Method
POST

### Endpoint
/websites/rubydoc_info_gems_iniparse/document

### Parameters
#### Query Parameters
- **path** (String) - Optional - The path to load the INI document from.

### Request Example
```json
{
  "path": "/path/to/your/file.ini"
}
```

### Response
#### Success Response (200)
- **document** (IniParse::Document) - The newly created Document object.

#### Response Example
```json
{
  "document": {
    "lines": [],
    "path": "/path/to/your/file.ini"
  }
}
```
```

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

### IniParse::Generator#initialize

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Generator%3Ainitialize

Initializes a new instance of the Generator class. It sets up the internal document and context, and manages the option stack.

```APIDOC
## IniParse::Generator#initialize

### Description
Initializes a new instance of the Generator class. It sets up the internal document and context, and manages the option stack.

### Method

`initialize(opts = {})

### Endpoint

N/A (Instance method)

### Parameters

#### Path Parameters

None

#### Query Parameters

None

#### Request Body

None

### Request Example

```ruby
generator = IniParse::Generator.new({ some_option: true })
```

### Response

#### Success Response (200)

Returns an instance of `Generator`.

#### Response Example

```ruby
# Returns an instance of IniParse::Generator
```
```

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

### GET IniParse::Document#has_section?

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document%3Ahas_section%3F

Checks if a specific section exists within an IniParse document.

```APIDOC
## GET IniParse::Document#has_section?

### Description
Returns true if a section with the given key exists in this document.

### Method
GET

### Parameters
#### Path Parameters
- **key** (String) - Required - The name of the section to check.

### Response
#### Success Response (200)
- **Boolean** - Returns true if the section exists, false otherwise.
```

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

### IniParse::LineCollection#initialize

Source: https://www.rubydoc.info/gems/iniparse/IniParse/LineCollection%3Ainitialize

Initializes a new LineCollection object. It sets up an empty array for lines and an empty hash for indices.

```APIDOC
## IniParse::LineCollection#initialize

### Description
Initializes a new LineCollection object. It sets up an empty array for lines and an empty hash for indices.

### Method
initialize

### Endpoint
N/A (Instance method)

### Parameters
None

### Request Example
N/A

### Response
#### Success Response (200)
- **@lines** (Array) - An empty array to store lines.
- **@indicies** (Hash) - An empty hash to store indices.

#### Response Example
N/A
```

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

### Initialize IniParse::Lines::Line

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Line%3Ainitialize

Initializes a new Line object with optional parameters for comment, separator, prefix, offset, indent, and option separator. Defaults are provided if options are not specified.

```ruby
def initialize(opts = {})
  @comment        = opts.fetch(:comment, nil)
  @comment_sep    = opts.fetch(:comment_sep, ';')
  @comment_prefix = opts.fetch(:comment_prefix, ' ')
  @comment_offset = opts.fetch(:comment_offset, 0)
  @indent         = opts.fetch(:indent, '')
  @option_sep     = opts.fetch(:option_sep, nil)
end
```

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

### GET IniParse::Lines::Line#line_contents

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Line%3Aline_contents

Retrieves the contents of a specific line within the IniParse library.

```APIDOC
## GET IniParse::Lines::Line#line_contents

### Description
Returns the contents for the specified line object.

### Method
GET

### Endpoint
IniParse::Lines::Line#line_contents

### Response
#### Success Response (200)
- **contents** (Object) - The contents of the line.
```

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

### Initialize a new IniParse::Parser instance

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Parser%3Ainitialize

Creates a new Parser instance for parsing a string source. The source string is duplicated upon initialization.

```ruby
# File 'lib/iniparse/parser.rb', line 31

def initialize(source)
  @source = source.dup
end
```

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

### Method: IniParse::Generator#with_options

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Generator%3Awith_options

Wraps lines and sets default options for each line within the provided block.

```APIDOC
## Method: IniParse::Generator#with_options

### Description
Wraps lines, setting default options for each. The method yields the generator instance to the provided block and ensures options are scoped to that block.

### Parameters
#### Arguments
- **opts** (Hash) - Optional - A hash of options to apply to the lines within the block.

### Yields
- **_self** (IniParse::Generator) - The generator instance.
```

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

### Get Document Value - IniParse::Generator#document

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Generator%3Adocument

Returns the value of the document attribute. This method is read-only.

```ruby
def document
  @document
end
```

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

### GET IniParse::Lines::Section#key

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Section%3Akey

Retrieves the key attribute value for an IniParse::Lines::Section object.

```APIDOC
## GET IniParse::Lines::Section#key

### Description
Returns the value of the key attribute for a section within the IniParse library.

### Method
GET

### Endpoint
IniParse::Lines::Section#key

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

### Response Example
{
  "key": "section_name"
}
```

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

### Initialize IniParse::Lines::Option

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Option%3Ainitialize

Initializes an Option object with a key, value, and optional settings. The key and value are converted to strings, and the option separator defaults to ' = '.

```ruby
def initialize(key, value, opts = {})
  super(opts)
  @key, @value = key.to_s, value
  @option_sep = opts.fetch(:option_sep, ' = ')
end
```

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

### Retrieve or create a section in IniParse::Document

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document%3Asection

Accesses a section by its key, initializing a new Section object if the key is not found.

```ruby
def section(key)
  @lines[key.to_s] ||= Lines::Section.new(key.to_s)
end
```

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

### POST /IniParse/Lines/AnonymousSection/initialize

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/AnonymousSection%3Ainitialize

Initializes a new instance of the AnonymousSection class within the IniParse library.

```APIDOC
## initialize

### Description
Returns a new instance of AnonymousSection. This method is defined in lib/iniparse/lines.rb.

### Method
N/A (Constructor)

### Endpoint
IniParse::Lines::AnonymousSection#initialize

### Request Example
```ruby
AnonymousSection.new
```

### Response
#### Success Response (200)
- **instance** (AnonymousSection) - A new instance of AnonymousSection initialized with the name '__anonymous__'.
```

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

### Get Line Contents - IniParse::Lines::Line#line_contents

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Line%3Aline_contents

Returns the contents for this line. This method is defined in lib/iniparse/lines.rb.

```ruby
def line_contents
  ''
end
```

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

### Access INI document sections and options

Source: https://www.rubydoc.info/gems/iniparse/file/README.rdoc

Access sections and options using the bracket operator on the document instance.

```ruby
document = IniParse.parse( File.read('path/to/my/file.ini') )

document['a_section']
  # => IniParse::Lines::Section

document['a_section']['an_option']
  # => "a value"
document['a_section']['another_option']
  # => "another value"
```

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

### GET IniParse::Lines::Line#has_comment?

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Line%3Ahas_comment%3F

Checks if a specific line in an INI file contains an inline comment.

```APIDOC
## GET IniParse::Lines::Line#has_comment?

### Description
Returns a boolean indicating whether the current line object contains an inline comment.

### Method
GET

### Endpoint
IniParse::Lines::Line#has_comment?

### Response
#### Success Response (200)
- **result** (Boolean) - True if the line has an inline comment, false otherwise.

#### Response Example
{
  "has_comment": true
}
```

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

### Converting to Hash

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document

Converts the INI document into a hash representation.

```APIDOC
## GET /websites/rubydoc_info_gems_iniparse/document/to_hash

### Description
Returns a hash representation of the INI with multi-line options as an array.

### Method
GET

### Endpoint
/websites/rubydoc_info_gems_iniparse/document/to_hash

### Response
#### Success Response (200)
- **hash_representation** (Object) - The hash representation of the INI document.

#### Response Example
```json
{
  "hash_representation": {
    "Section1": {
      "option1": "value1",
      "option2": ["value2a", "value2b"]
    }
  }
}
```
```

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

### GET IniParse::Lines::Comment#comment

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Comment%3Acomment

Retrieves the inline comment associated with a specific line in an INI file.

```APIDOC
## GET IniParse::Lines::Comment#comment

### Description
Returns the inline comment for this line. Includes the comment separator at the beginning of the string. In cases where a comment separator appeared without a comment, only the separator is returned.

### Method
GET

### Endpoint
IniParse::Lines::Comment#comment

### Response
#### Success Response (200)
- **comment** (Object) - The inline comment string including the separator.
```

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

### IniParse::LineCollection Instance Methods

Source: https://www.rubydoc.info/gems/iniparse/IniParse/LineCollection

This section covers the instance methods for the IniParse::LineCollection module, detailing how to manipulate and query the collection of INI lines.

```APIDOC
## IniParse::LineCollection Instance Methods

### Description
Represents a collection of lines in an INI document. LineCollection acts as a hybrid of an Array and a Hash, allowing arbitrary lines to be added and providing O(1) lookup for Section and Option lines by their keys.

### Methods

#### `<< (line)` or `#push(line)`
**Description**: Appends a line to the collection. If a line with the same key already exists, it will be replaced.
**Parameters**:
- `line` (Object) - The line object to append.
**Returns**:
- `Object` - The collection itself.

#### `[](key)`
**Description**: Retrieves a value identified by `key`.
**Parameters**:
- `key` (String) - The key of the line to retrieve.
**Returns**:
- `Object` - The line object associated with the key, or `nil` if not found.

#### `[]=(key, value)`
**Description**: Sets a `value` identified by `key`. If a value with the given key already exists, it will be replaced, maintaining its position. Otherwise, the new value is appended.
**Parameters**:
- `key` (String) - The key for the value.
- `value` (Object) - The value to set.
**Returns**:
- `Object` - The value that was set.

#### `delete(key)`
**Description**: Removes the value identified by `key`.
**Parameters**:
- `key` (String) - The key of the value to remove.
**Returns**:
- `Object` - The removed value, or `nil` if the key was not found.

#### `each(include_blank = false)`
**Description**: Enumerates through the collection. By default, blank and comment lines are skipped.
**Parameters**:
- `include_blank` (Boolean) - If true, includes blank and comment lines in the enumeration.
**Returns**:
- `Object` - An enumerator.

#### `has_key?(*args)`
**Description**: Returns whether `key` is in the collection.
**Parameters**:
- `*args` - Arguments to pass to the underlying hash lookup.
**Returns**:
- `Boolean` - True if the key exists, false otherwise.

#### `initialize`
**Description**: Initializes a new `LineCollection` instance with empty `@lines` and `@indicies`.

#### `keys`
**Description**: Returns an array containing the keys for the lines added to this collection.
**Returns**:
- `Object` - An array of keys.
```

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

### IniParse::Lines::Section#initialize

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Section%3Ainitialize

Initializes a new Section object, which represents a section in an INI file.

```APIDOC
## IniParse::Lines::Section#initialize

### Description
Initializes a new Section object, which represents a section in an INI file.

### Method
POST

### Endpoint
/websites/rubydoc_info_gems_iniparse

### Parameters
#### Path Parameters
- **key** (String) - Required - The section name.
- **opts** (Hash) - Optional - Extra options for the line.

### Request Example
```json
{
  "key": "SectionName",
  "opts": {}
}
```

### Response
#### Success Response (200)
- **Section** (Object) - The initialized Section object.

#### Response Example
```json
{
  "section_name": "SectionName",
  "lines": []
}
```
```

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

### IniParse::Lines::Line#options

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Line%3Aoptions

Retrieves the options used to create a line within the IniParse library.

```APIDOC
## GET /api/iniparse/lines/options

### Description
Retrieves the options used to create a line within the IniParse library.

### Method
GET

### Endpoint
/api/iniparse/lines/options

### Parameters
#### Query Parameters
- **line_id** (string) - Required - The identifier for the specific line.

### Response
#### Success Response (200)
- **options** (object) - An object containing the line's configuration options.
  - **comment** (string) - The comment associated with the line.
  - **comment_sep** (string) - The separator used for comments.
  - **comment_prefix** (string) - The prefix for comment characters.
  - **comment_offset** (integer) - The offset for comment placement.
  - **indent** (integer) - The indentation level of the line.
  - **option_sep** (string) - The separator used for options.

#### Response Example
```json
{
  "options": {
    "comment": "# This is a comment",
    "comment_sep": ":",
    "comment_prefix": "#",
    "comment_offset": 10,
    "indent": 2,
    "option_sep": "="
  }
}
```
```

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

### Get IniParse Document Path

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document%3Apath

Returns the value of the path attribute. This method is part of the IniParse::Document class.

```ruby
def path
  @path
end
```

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

### Get the inline comment

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Line

Retrieves the inline comment associated with a line. The comment separator is included at the beginning of the returned string.

```ruby
def comment
  "#{ @comment_sep }#{ @comment_prefix }#{ @comment }"
end
```

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

### Initialize IniParse::Generator

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Generator%3Ainitialize

Initializes a new Generator instance. Accepts an optional hash of options.

```ruby
def initialize(opts = {}) # :nodoc:
  @document   = IniParse::Document.new
  @context    = @document

  @in_section = false
  @opt_stack  = [opts]
end
```

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

### Document#section

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document

Retrieves a section from the INI document by its key. If the section does not exist, it is created.

```APIDOC
## GET /websites/rubydoc_info_gems_iniparse/section/{key}

### Description
Retrieves a section from the INI document by its key. If the section does not exist, it is created.

### Method
GET

### Endpoint
/websites/rubydoc_info_gems_iniparse/section/{key}

### Parameters
#### Path Parameters
- **key** (string) - Required - The key of the section to retrieve.

### Response
#### Success Response (200)
- **section_data** (object) - The data of the requested section.

#### Response Example
```json
{
  "section_data": {
    "option1": "value1",
    "option2": "value2"
  }
}
```
```

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

### Retrieve option line instance in IniParse

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Section%3Aoption

Returns the matching line instance for a given key. If multiple lines match the key, an array of lines is returned.

```ruby
def option(key)
  @lines[key.to_s]
end
```

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

### Initialize IniParse::Lines::Option

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Option%3Ainitialize

Initializes a new option line within an INI file structure, defining the key, value, and optional separators.

```APIDOC
## Initialize IniParse::Lines::Option

### Description
Creates a new instance of an Option line, representing a key-value pair in an INI file.

### Method
initialize(key, value, opts = {})

### Parameters
#### Arguments
- **key** (String) - Required - The option key.
- **value** (String) - Required - The value for this option.
- **opts** (Hash) - Optional - Extra options for the line, including :option_sep (default: ' = ').
```

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

### GET IniParse::Document#to_ini

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document%3Ato_ini

Converts an IniParse::Document instance into a string representation suitable for saving to an INI file.

```APIDOC
## GET IniParse::Document#to_ini

### Description
Returns the current document as a string formatted for an INI file. This method is also aliased as `to_s`.

### Method
GET

### Endpoint
IniParse::Document#to_ini

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

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

### IniParse::Document Instance Methods

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document

Details on the instance methods available for IniParse::Document objects.

```APIDOC
## API Endpoints for IniParse::Document Instance Methods

### Description
Provides access to various instance methods for manipulating and querying IniParse::Document objects.

### Method
GET

### Endpoint
/websites/rubydoc_info_gems_iniparse/document/methods

### Response
#### Success Response (200)
- **[]**(key) (Object) - Returns the section identified by `key`.
- **delete**(*args) (Object) - Deletes the section whose name matches the given `key`.
- **each**(*args, &blk) (Object) - Enumerates through each Section in this document.
- **has_section?**(key) (Boolean) - Returns true if a section with the given `key` exists in this document.
- **initialize**(path = nil) (Document) - Creates a new Document instance.
- **inspect** (Object) - A human-readable version of the document, for debugging.
- **save**(path = nil) (Object) - Saves a copy of this Document to disk.
- **section**(key) (Object) - Returns the section identified by `key`.
- **to_hash** (Object) - Returns a hash representation of the INI with multi-line options as an array.
- **to_ini** (Object) - Returns this document as a string suitable for saving to a file.

#### Response Example
```json
{
  "methods": [
    "[]",
    "delete",
    "each",
    "has_section?",
    "initialize",
    "inspect",
    "save",
    "section",
    "to_hash",
    "to_ini"
  ]
}
```
```

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

### GET IniParse::Lines::Comment#has_comment?

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Comment%3Ahas_comment%3F

Checks if a line object is identified as a comment. For the Comment class, this method always returns true.

```APIDOC
## GET IniParse::Lines::Comment#has_comment?

### Description
Returns a boolean indicating if the line contains an inline comment. For instances of the Comment class, this method always returns true, regardless of whether comment text is present.

### Method
GET

### Response
#### Success Response (200)
- **result** (Boolean) - Returns true if the line is a comment.
```

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

### Get IniParse Line Types

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Parser.parse_types

Returns an array of line types used by the IniParse parser. This method initializes and returns a class instance variable `@@parse_types`.

```ruby
def self.parse_types
  @@parse_types ||= []
end
```

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

### Access Sections

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document

Retrieves a section by its key.

```ruby
# File 'lib/iniparse/document.rb', line 31

def [](key)
  @lines[key.to_s]
end
```

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

### Get Key Value - IniParse::Lines::Option#key

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Option%3Akey

Returns the value of the attribute key. This method is part of the IniParse gem for parsing INI files.

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

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

### IniParse::Generator#method_missing

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Generator%3Amethod_missing

Handles dynamic method calls for setting options and sections in INI data.

```APIDOC
## IniParse::Generator#method_missing

### Description
This method is a dynamic method that handles calls to set options or sections. If the method name ends with '=', it treats it as an option setter; otherwise, it treats it as a section getter or creator.

### Method
method_missing

### Endpoint
N/A (Instance method)

### Parameters
- **name** (Symbol/String) - The name of the method being called.
- **args** (*args) - Positional arguments passed to the method.
- **blk** (&blk) - A block passed to the method.

### Request Example
N/A

### Response
#### Success Response (200)
- **Object** - Returns the result of the `option` or `section` method call.

#### Response Example
N/A
```

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

### Document#to_ini

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document

Returns the INI document as a string formatted for saving to a file.

```APIDOC
## GET /websites/rubydoc_info_gems_iniparse/to_ini

### Description
Returns the INI document as a string formatted for saving to a file.

### Method
GET

### Endpoint
/websites/rubydoc_info_gems_iniparse/to_ini

### Response
#### Success Response (200)
- **ini_string** (string) - The INI document as a formatted string.

#### Response Example
```json
{
  "ini_string": "[Section1]\noption1 = value1\nmultiline_option = line1\nline2"
}
```
```

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

### Convert Section Lines to INI Format

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Section%3Ato_ini

Use this method to get the INI string representation of a section, including its options, comments, and blank lines. It handles nested arrays of lines by joining their INI representations.

```ruby
def to_ini
  coll = lines.to_a

  if coll.any?
    [*super,coll.to_a.map do |line|
      if line.kind_of?(Array)
        line.map { |dup_line| dup_line.to_ini }.join($/)
      else
        line.to_ini
      end
    end].join($/)
  else
    super
  end
end
```

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

### Access anonymous section options

Source: https://www.rubydoc.info/gems/iniparse/file/README.rdoc

Options defined before any section header are placed in the __anonymous__ section.

```ruby
document = IniParse.parse <<-EOS
  driver = true

  [driver]
  key = value
EOS

document['__anonymous__']['driver']
  # => true

document['driver']['key']
  # => 'value'
```

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

### Get Inline Comment - IniParse::Lines::Comment

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Comment%3Acomment

Returns the inline comment for this line, including the comment separator. If no comment exists, it returns the separator. This method is part of the IniParse library for parsing INI files.

```ruby
def comment
  @comment !~ /\S/ ? @comment_sep : super
end
```

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

### Convert LineCollection to Array

Source: https://www.rubydoc.info/gems/iniparse/IniParse/LineCollection%3Ato_a

Use this method to get an array representation of the line collection. It includes all lines, even blank ones and comments. The method returns a duplicate of the internal array to prevent external modification.

```ruby
def to_a
  @lines.dup
end
```

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

### Handle duplicate options in INI

Source: https://www.rubydoc.info/gems/iniparse/file/README.rdoc

Duplicate keys in the same section return an array of all associated values.

```ruby
document = IniParse.parse <<-EOS
  [my_section]
  key = value
  key = another value
  key = a third value
EOS

document['my_section']['key']
  # => ['value', 'another value', 'third value']
```

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

### Check if line has inline comment

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Comment%3Ahas_comment%3F

This method always returns true for a Comment object, indicating the presence of an inline comment. This holds true even if the comment text is empty, as long as the line starts with a comment separator.

```Ruby
def has_comment?
  true
end
```

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

### IniParse::Lines::AnonymousSection

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/AnonymousSection

Represents options that appear at the beginning of a file before any section.

```APIDOC
## Class: IniParse::Lines::AnonymousSection

### Description
Stores options which appear at the beginning of a file, without a preceding section.

### Inheritance
- Section
- Object
- Section
- IniParse::Lines::AnonymousSection

### Defined in
- lib/iniparse/lines.rb

### Instance Attribute Summary
#### Inherited from Section
- #key
- #lines

### Instance Method Summary
- #**initialize** ⇒ AnonymousSection
  Constructor. Creates a new instance of AnonymousSection.
- #**to_ini** ⇒ Object
  Converts the section to INI format.

### Methods inherited from Section
- #[]
- #[]=
- #delete
- #each
- #has_option?
- #merge!
- #option
- #parse

### Methods included from Line
- #blank?
- #comment
- #has_comment?
- #options

### Constructor Details
#### permalink #**initialize** ⇒ `AnonymousSection`
Returns a new instance of AnonymousSection.

```ruby
# File 'lib/iniparse/lines.rb', line 226
def initialize
  super('__anonymous__')
end
```

### Instance Method Details
#### permalink #**to_ini** ⇒ `Object`

```ruby
# File 'lib/iniparse/lines.rb', line 230
def to_ini
  # Remove the leading space which is added by joining the blank line
  # content with the options.
  super.gsub(/\A\n/, '')
end
```
```

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

### Document#to_hash

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document

Converts the INI document into a hash representation. Multi-line options are represented as arrays.

```APIDOC
## GET /websites/rubydoc_info_gems_iniparse/to_hash

### Description
Converts the INI document into a hash representation. Multi-line options are represented as arrays.

### Method
GET

### Endpoint
/websites/rubydoc_info_gems_iniparse/to_hash

### Response
#### Success Response (200)
- **hash_representation** (object) - A hash representing the INI document.

#### Response Example
```json
{
  "hash_representation": {
    "Section1": {
      "option1": "value1",
      "multiline_option": [
        "line1",
        "line2"
      ]
    }
  }
}
```
```

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

### Iterate Sections

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document

Enumerates through sections in the document.

```ruby
# File 'lib/iniparse/document.rb', line 23

def each(*args, &blk)
  @lines.each(*args, &blk)
end
```

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

### Identify Comment Lines in INI Files

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Lines/Comment

Demonstrates the format of comment lines in INI files. Comment lines begin with a semi-colon or hash.

```plaintext
; this is a comment
# also a comment

```

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

### Saving the Document

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document

Saves the current state of the INI document to a file.

```APIDOC
## POST /websites/rubydoc_info_gems_iniparse/document/save

### Description
Saves a copy of this Document to disk. If a path was supplied when the Document was initialized, it will be saved to that path. Otherwise, a path must be provided.

### Method
POST

### Endpoint
/websites/rubydoc_info_gems_iniparse/document/save

### Parameters
#### Query Parameters
- **path** (String) - Optional - A path to which this document will be saved.

### Raises
- **IniParseError** - If your document couldn’t be saved.

### Response
#### Success Response (200)
- **message** (String) - Confirmation message indicating the document was saved.

#### Response Example
```json
{
  "message": "Document saved successfully to /path/to/save.ini"
}
```
```

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

### POST /IniParse/LineCollection/append

Source: https://www.rubydoc.info/gems/iniparse/IniParse/LineCollection%3A%3C%3C

Appends a line to the collection. If the key already exists, the old item is replaced.

```APIDOC
## POST /IniParse/LineCollection/<<

### Description
Appends a line to the collection. Note that if you pass a line with a key already represented in the collection, the old item will be replaced.

### Method
POST

### Endpoint
/IniParse/LineCollection/<<

### Parameters
#### Request Body
- **line** (Object) - Required - The line object to be added to the collection.

### Request Example
{
  "line": { "key": "example_key", "value": "example_value" }
}

### Response
#### Success Response (200)
- **self** (Object) - Returns the updated LineCollection instance.
```

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

### POST /parse

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Parser%3Aparse

Parses a source string into an IniParse::Document object.

```APIDOC
## POST /parse

### Description
Parses the source string and returns the resulting data structure as an IniParse::Document.

### Method
POST

### Endpoint
/parse

### Response
#### Success Response (200)
- **document** (IniParse::Document) - The resulting data structure representing the parsed INI content.
```

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

### Converting to INI String

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document

Converts the INI document into a string format suitable for saving to a file.

```APIDOC
## GET /websites/rubydoc_info_gems_iniparse/document/to_ini

### Description
Returns this document as a string suitable for saving to a file.

### Method
GET

### Endpoint
/websites/rubydoc_info_gems_iniparse/document/to_ini

### Response
#### Success Response (200)
- **ini_string** (String) - The INI document as a string.

#### Response Example
```ini
[Section1]
option1 = value1
option2 = value2a
      = value2b
```
```

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

### POST #<<

Source: https://www.rubydoc.info/gems/iniparse/IniParse/OptionCollection

Appends a line to the OptionCollection. If the line is an Option with a key already present, it is treated as a duplicate and stored as an array.

```APIDOC
## POST #<<

### Description
Appends a line to the collection. If an Option with an existing key is added, the previous value and the new value are combined into an array.

### Parameters
#### Path Parameters
- **line** (IniParse::LineType::Line) - Required - The line object to be added to the collection.
```

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

### IniParse Class List

Source: https://www.rubydoc.info/gems/iniparse/IniParse/ParseError

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

```APIDOC
## Class List

### Top Level Namespace

- **IniParse**

### IniParse Top Level Namespace

- **Document** < Object
- **Generator** < Object
- **IniParseError** < StandardError
- **LineCollection**
- **LineNotAllowed** < IniParseError
- **Lines**
  - **AnonymousSection** < Section
  - **Blank** < Object
  - **Comment** < Blank
  - **Line**
  - **Option** < Object
  - **Section** < Line
- **NoSectionError** < ParseError
- **OptionCollection** < Object
- **ParseError** < IniParseError
- **Parser** < Object
- **SectionCollection** < Object
```

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

### IniParse::Generator#with_options Method

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Generator%3Awith_options

Use this method to wrap lines and set default options for them. It manages an option stack, pushing new options and popping them after the block executes. The 'comment' option is explicitly deleted before merging.

```ruby
def with_options(opts = {}) # :nodoc:
  opts = opts.dup
  opts.delete(:comment)
  @opt_stack.push( @opt_stack.last.merge(opts))
  yield self
  @opt_stack.pop
end
```

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

### Accessing a Section by Key

Source: https://www.rubydoc.info/gems/iniparse/IniParse/Document

Retrieves a specific section from the INI document using its key.

```APIDOC
## GET /websites/rubydoc_info_gems_iniparse/document/:key

### Description
Returns the section identified by `key`. Returns nil if there is no Section with the given key.

### Method
GET

### Endpoint
/websites/rubydoc_info_gems_iniparse/document/:key

### Parameters
#### Path Parameters
- **key** (String) - Required - The key of the section to retrieve.

### Response
#### Success Response (200)
- **section** (Object) - The section identified by the key.

#### Response Example
```json
{
  "section": {
    "key": "ExampleSection",
    "options": {}
  }
}
```
```
Tokens:
Raw