Beckett

https://rubydoc.info/gems/beckett/0.1.0
Admin
Beckett is a Ruby gem that parses GitHub Flavored Markdown content and converts it into structured...
Tokens:8,050
Snippets:64
Trust Score:10
Update:6 months ago
Show doc for...
Tokens:
Raw
### GET /to_hash

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Document

Converts the initialized document content into a hash representation.

```APIDOC
## Method: to_hash

### Description
Parses the document content using Kramdown and returns a hash representation.

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

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

### GET /to_json

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Document

Converts the initialized document content into a JSON string.

```APIDOC
## Method: to_json

### Description
Converts the document hash representation into a JSON string.

### Response
#### Success Response (200)
- **Object** - The JSON string representation of the document.
```

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

### GET Beckett::Node::Base#node

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Anode

Retrieves the underlying node object from a Beckett::Node::Base instance.

```APIDOC
## GET Beckett::Node::Base#node

### Description
Returns the value of the attribute 'node' for a given Beckett::Node::Base object.

### Method
GET

### Endpoint
Beckett::Node::Base#node

### Response
#### Success Response (200)
- **node** (Object) - The underlying node object associated with the instance.
```

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

### GET /beckett/node/element/to_h

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Element

Serializes a Beckett node element into a hash representation including node name, type, attributes, and children.

```APIDOC
## GET /beckett/node/element/to_h

### Description
Converts a Beckett node element into a hash format. This method recursively maps children nodes to their hash representations.

### Method
GET

### Endpoint
/beckett/node/element/to_h

### Response
#### Success Response (200)
- **node_name** (string) - The name of the node.
- **node_type** (string) - The type of the node.
- **attributes** (hash) - Optional node attributes.
- **children** (array) - An array of child nodes serialized as hashes.

#### Response Example
{
  "node_name": "article",
  "node_type": "element",
  "attributes": {},
  "children": []
}
```

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

### GET Beckett::Node::Codeblock#to_h

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Codeblock

Retrieves a hash representation of the Codeblock node, including its name, type, and text content.

```APIDOC
## GET Beckett::Node::Codeblock#to_h

### Description
Serializes the current Beckett::Node::Codeblock instance into a Ruby Hash containing the node's metadata.

### Method
GET

### Response
#### Success Response (200)
- **node_name** (String) - The name of the node.
- **node_type** (String) - The type of the node.
- **node_text** (String) - The text content associated with the node.

### Response Example
{
  "node_name": "codeblock",
  "node_type": "element",
  "node_text": "example code content"
}
```

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

### GET Beckett::Node::Base#children

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Achildren

Retrieves the children attribute from a Beckett::Node::Base instance.

```APIDOC
## GET Beckett::Node::Base#children

### Description
Returns the value of the children attribute for a node in the Beckett document tree.

### Method
GET

### Endpoint
Beckett::Node::Base#children

### Response
#### Success Response (200)
- **children** (Object) - The collection of child nodes associated with the current node.
```

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

### GET Beckett::Node::Codeblock#to_h

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Codeblock%3Ato_h

Returns a hash representation of the Codeblock node, including node_name, node_type, and node_text.

```APIDOC
## GET Beckett::Node::Codeblock#to_h

### Description
Serializes the Codeblock node into a hash format containing its metadata and content.

### Method
GET

### Response
#### Success Response (200)
- **node_name** (String) - The name of the node
- **node_type** (String) - The type of the node
- **node_text** (String) - The text content of the node

#### Response Example
{
  "node_name": "codeblock",
  "node_type": "element",
  "node_text": "example code content"
}
```

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

### GET Beckett::Node::Text#to_h

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Text%3Ato_h

Serializes a Beckett text node into a hash representation containing node metadata and content.

```APIDOC
## GET Beckett::Node::Text#to_h

### Description
Serializes a Beckett text node into a hash containing the node name, type, and text content.

### Method
GET

### Response
#### Success Response (200)
- **node_name** (string) - The name of the node
- **node_type** (string) - The type of the node
- **node_text** (string) - The text content of the node

#### Response Example
{
  "node_name": "text",
  "node_type": "text",
  "node_text": "example text"
}
```

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

### GET Beckett::Node::Element#to_h

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Element%3Ato_h

Retrieves a hash representation of a Beckett node element, including its metadata and recursive children.

```APIDOC
## GET Beckett::Node::Element#to_h

### Description
Serializes a Beckett node element into a hash format, including node name, type, attributes, and a recursive list of children.

### Method
GET

### Endpoint
Beckett::Node::Element#to_h

### Response
#### Success Response (200)
- **node_name** (String) - The name of the node.
- **node_type** (String) - The type of the node.
- **attributes** (Hash) - Optional node attributes.
- **children** (Array) - A list of child nodes serialized via to_h.

#### Response Example
{
  "node_name": "example_node",
  "node_type": "element",
  "attributes": {},
  "children": []
}
```

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

### Get Beckett::Node::Base position

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Aposition

Returns the value of the position attribute for a Beckett::Node::Base object. This is a simple getter method.

```ruby
def position
  @position
end
```

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

### POST /initialize

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Document

Initializes a new Beckett::Document instance with the provided content.

```APIDOC
## Constructor: initialize

### Description
Creates a new instance of Beckett::Document.

### Parameters
#### Request Body
- **content** (String) - Required - The raw document content to be parsed.
```

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

### Constructor: initialize

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Renderer

Initializes a new instance of the Beckett::Renderer class.

```APIDOC
## Constructor: initialize

### Description
Creates a new instance of the Renderer class and initializes the internal stack.

### Method
initialize(root, options = {})

### Parameters
#### Arguments
- **root** (Object) - Required - The root node of the document.
- **options** (Hash) - Optional - Configuration options for the renderer.
```

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

### Beckett::Document#initialize

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Document%3Ainitialize

Initializes a new instance of the Beckett::Document class with the provided content.

```APIDOC
## Beckett::Document#initialize

### Description
Creates a new instance of the Beckett::Document class.

### Parameters
#### Request Body
- **content** (Object) - Required - The content to be associated with the new Document instance.

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

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

### Beckett::Renderer#initialize

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Renderer%3Ainitialize

Initializes a new instance of the Renderer class.

```APIDOC
## Beckett::Renderer#initialize

### Description
Returns a new instance of Renderer.

### Method
initialize

### Parameters
#### Path Parameters
- **root** (Object) - Required - The root node for the renderer.
- **options** (Hash) - Optional - Configuration options for the renderer.

### Request Example
```ruby
renderer = Beckett::Renderer.new(root_node, { option1: 'value1' })
```

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

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

### Beckett::Node::Base#initialize

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Ainitialize

Initializes a new instance of the Base class.

```APIDOC
## Beckett::Node::Base#initialize

### Description
Returns a new instance of Base.

### Method
initialize

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

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

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

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

### Initialize Beckett::Document

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Document

Constructor for the Document class. Initializes a new instance with the provided content.

```ruby
def initialize(content)
  @content = content
end
```

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

### Initialize Beckett::Document

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Document%3Ainitialize

Creates a new instance of the Document class by assigning the provided content to an instance variable.

```ruby
# File 'lib/beckett.rb', line 21

def initialize(content)
  @content = content
end
```

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

### Initialize Beckett::Node::Base

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base

Constructor for creating a new node instance, setting initial state and position.

```ruby
# File 'lib/beckett/node.rb', line 17

def initialize(node)
  @node     = node
  @children = []
  @position = $position
  $position += 1
end
```

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

### Beckett::Node::Br Class Documentation

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Br

Documentation for the Beckett::Node::Br class, detailing its inheritance and instance methods.

```APIDOC
## Class: Beckett::Node::Br

### Description
Represents a line break element within the Beckett node structure.

### Inheritance
Inherits from `Beckett::Node::Element` and ultimately `Object`.

### Defined in
`lib/beckett/node/br.rb`

### Instance Method Summary
* **#to_h** ⇒ `Object` - Returns a hash representation of the Br node.

### Instance Method Details
#### permalink #**to_h** ⇒ `Object`
[View source]
```ruby
def to_h
  {
  }.tap do |element|
    element[:node_name] = node_name
    element[:node_type] = node_type
  end
end
```
```

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

### Beckett::Node::Codespan Class Documentation

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Codespan

Documentation for the Beckett::Node::Codespan class, detailing its inheritance and methods.

```APIDOC
## Class: Beckett::Node::Codespan

### Description
Represents a codespan element within the Beckett parsing structure.

### Inheritance
- Inherits from: `Beckett::Node::Text`
- Also inherits from: `Object`, `Base`, `Text`, `Beckett::Node::Codespan`

### Defined in
- `lib/beckett/node/codespan.rb`

### Instance Attribute Summary
#### Inherited from Base
- `#children`: (type unknown) - Description of children attribute.
- `#node`: (type unknown) - Description of node attribute.
- `#position`: (type unknown) - Description of position attribute.

### Method Summary
#### Inherited from Text
- `#nil?`: Checks if the object is nil.
- `#to_h`: Converts the object to a hash.

#### Inherited from Base
- `#<<`: Appends content to the node.
- `#initialize`: Constructor for the Base class.
- `#inspect`: Returns a string representation of the object.
- `#to_h`: Converts the object to a hash.
- `#to_s`: Returns a string representation of the object.

### Constructor Details
This class inherits its constructor from `Beckett::Node::Base`.
```

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

### Beckett::Node::Text Class Methods

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Text

Documentation for the instance methods of the Beckett::Node::Text class.

```APIDOC
## Beckett::Node::Text

### Description
Represents text nodes within the Beckett document structure. It inherits from `Beckett::Node::Base`.

### Class Hierarchy
- Object
- Base
- Beckett::Node::Base
- Beckett::Node::Text

### Direct Known Subclasses
- `Codespan`

### Instance Attribute Summary
#### Attributes inherited from Base
- `#children` (type: unknown) - Description: List of child nodes.
- `#node` (type: unknown) - Description: The underlying node object.
- `#position` (type: unknown) - Description: The position of the node.

### Instance Method Summary
#### #**nil?** ⇒ `Boolean`
Checks if the text node is effectively empty after stripping whitespace.

##### Method
`nil?`

##### Returns
- `Boolean` - `true` if the node text is empty or only contains whitespace, `false` otherwise.

##### Source
`lib/beckett/node/text.rb`, line 11

```ruby
def nil?
  # improves list rendering.
  node_text.strip.empty?
end
```

#### #**to_h** ⇒ `Object`
Converts the text node to a hash representation.

##### Method
`to_h`

##### Returns
- `Object` - A hash containing node details.

##### Request Body
```json
{
  "example": "{}\n  .tap do |element|\n    element[:node_name] = node_name\n    element[:node_type] = node_type\n    element[:node_text] = node_text\n  end\n}"
}
```

##### Response
#### Success Response (200)
- `node_name` (String) - The name of the node.
- `node_type` (String) - The type of the node.
- `node_text` (String) - The text content of the node.

#### Response Example
```json
{
  "node_name": "text",
  "node_type": "text",
  "node_text": "Example text content"
}
```

##### Source
`lib/beckett/node/text.rb`, line 3

```ruby
def to_h
  {}.tap do |element|
    element[:node_name] = node_name
    element[:node_type] = node_type
    element[:node_text] = node_text
  end
end
```
```

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

### Beckett::Node::Root Class Documentation

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Root

Documentation for the `Beckett::Node::Root` class, including its inheritance, attributes, and methods.

```APIDOC
## Class: Beckett::Node::Root

### Description
Represents the root node in the Beckett document structure. It inherits from `Base` and provides a method to convert its structure to a hash.

### Inheritance
- `Base`
- `Object`
- `Base`
- `Beckett::Node::Root`

### Defined in
- `lib/beckett/node/root.rb`

### Instance Attribute Summary
#### Attributes inherited from Base
- `#children`
- `#node`
- `#position`

### Instance Method Summary
- `#to_h ⇒ Object`
  Converts the root node and its children into a hash representation.

#### Methods inherited from Base
- `#<<`
- `#initialize`
- `#inspect`
- `#to_s`

### Constructor Details
This class inherits its constructor from `Beckett::Node::Base`.

### Instance Method Details
#### #to_h ⇒ `Object`
[View source]
```ruby
# File 'lib/beckett/node/root.rb', line 3
def to_h
  {
    root: {}.tap do |root|
      root[:children] = children.map(&:to_h)
    end
  }
end
```
```

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

### Initialize Beckett Node Base

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Ainitialize

Constructor for creating a new instance of Base, setting the node, children, and global position.

```ruby
def initialize(node)
  @node     = node
  @children = []
  @position = $position
  $position += 1
end
```

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

### Beckett::Node::Section Class Documentation

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Section

Documentation for the Beckett::Node::Section class, detailing its inheritance and methods.

```APIDOC
## Class: Beckett::Node::Section

### Description
Represents a section within a document structure.

### Inheritance
- Inherits from: `Beckett::Node::Element`
- Also inherits from: `Object`, `Base`, `Element`, `Beckett::Node::Section`

### Defined In
- `lib/beckett/node/section.rb`

### Instance Attribute Summary
#### Inherited from Base
- `#children` (type: unknown) - Description: List of child nodes.
- `#node` (type: unknown) - Description: The underlying node object.
- `#position` (type: unknown) - Description: The position of the node.

### Method Summary
#### Inherited from Element
- `#to_h` (type: unknown) - Description: Converts the element to a hash.

#### Inherited from Base
- `#<<` (type: unknown) - Description: Appends a node to the current node.
- `#initialize` (type: unknown) - Description: Initializes the node.
- `#inspect` (type: unknown) - Description: Returns a string representation of the node.
- `#to_h` (type: unknown) - Description: Converts the node to a hash.
- `#to_s` (type: unknown) - Description: Returns a string representation of the node.

### Constructor Details
This class inherits its constructor from `Beckett::Node::Base`.
```

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

### Convert document to hash using Beckett::Document#to_hash

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Document%3Ato_hash

Initializes a Kramdown document from content and processes it through the Beckett renderer.

```ruby
# File 'lib/beckett.rb', line 25

def to_hash
  document = Kramdown::Document.new(@content, input: 'GFM')
  renderer = Renderer.send(:new, document.root)
  renderer.convert(document.root)
end
```

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

### Method: convert

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Renderer

Converts a given node using the internal dispatcher.

```APIDOC
## Method: convert

### Description
Converts a node by dispatching it to the appropriate conversion method based on the node type.

### Method
convert(node)

### Parameters
#### Arguments
- **node** (Object) - Required - The node object to be converted.

### Response
- **Object** - The result of the conversion process.
```

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

### Implement to_s in Beckett::Node::Base

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Ato_s

This method is defined in lib/beckett/node.rb and delegates to inspect.

```ruby
# File 'lib/beckett/node.rb', line 28

def to_s
  inspect
end
```

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

### Initialize Beckett::Renderer

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Renderer%3Ainitialize

Constructor for the Renderer class. Initializes the stack instance variable.

```ruby
def initialize(root, options = {})
  super
  @stack = []
end
```

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

### Beckett::Node::Article Class Reference

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Article

Details regarding the Beckett::Node::Article class, its inheritance hierarchy, and available methods.

```APIDOC
## Class: Beckett::Node::Article

### Description
Represents an article node within the Beckett document structure. Inherits functionality from Beckett::Node::Element.

### Inheritance
- Object
- Beckett::Node::Base
- Beckett::Node::Element
- Beckett::Node::Article

### Attributes (Inherited from Base)
- **children** (Array) - Child nodes of the current element.
- **node** (Object) - The underlying node representation.
- **position** (Integer) - The position of the node in the document.

### Methods
- **to_h** (Inherited from Element) - Converts the node structure to a hash representation.
- **<<** (Inherited from Base) - Appends a child node.
- **initialize** (Inherited from Base) - Initializes a new node instance.
- **inspect** (Inherited from Base) - Returns a string representation for debugging.
- **to_s** (Inherited from Base) - Returns the string representation of the node.
```

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

### Beckett Library Overview

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett

Overview of the Beckett module structure and available classes for document manipulation.

```APIDOC
## Beckett Module

### Description
The Beckett module serves as the primary namespace for the library, providing classes for document parsing and rendering.

### Namespace
- **Modules**: Beckett::Node
- **Classes**: Beckett::Document, Beckett::Renderer

### Version
- **VERSION**: "0.1.0"
```

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

### Beckett::Node::Base Class

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base

Documentation for the Beckett::Node::Base class, including its inheritance, attributes, and methods.

```APIDOC
## Class: Beckett::Node::Base

### Description
Represents the base node in the Beckett document structure.

### Inheritance
- Object
- Beckett::Node::Base

### Defined in
- lib/beckett/node.rb

### Direct Known Subclasses
- Element
- Root
- Text

### Instance Attribute Summary
- `#children` (Object) - readonly: Returns the value of attribute children.
- `#node` (Object) - readonly: Returns the value of attribute node.
- `#position` (Object) - readonly: Returns the value of attribute position.

### Instance Method Summary
- `#< <(nodes)` (Object): Appends nodes to the children.
- `#initialize(node)` (Base): Constructor for the Base class.
- `#inspect` (Object): Returns a string representation of the node.
- `#to_h` (Object): Converts the node to a hash (raises NotImplementedError).
- `#to_s` (Object): Returns a string representation of the node, typically by calling `#inspect`.

### Constructor Details
#### initialize(node)
Returns a new instance of Base.

```ruby
def initialize(node)
  @node     = node
  @children = []
  @position = $position
  $position += 1
end
```

### Instance Attribute Details
#### children
Returns the value of attribute children.

```ruby
def children
  @children
end
```

#### node
Returns the value of attribute node.

```ruby
def node
  @node
end
```

#### position
Returns the value of attribute position.

```ruby
def position
  @position
end
```

### Instance Method Details
#### <<(nodes)
Appends nodes to the children.

```ruby
def <<(nodes)
  @children += ([nodes].flatten)
end
```

#### inspect
Returns a string representation of the node.

```ruby
def inspect
  "<#{node_name} position=#{position}>"
end
```

#### to_h
Converts the node to a hash.

Raises:
- `NotImplementedError`

```ruby
def to_h
  raise NotImplementedError
end
```

#### to_s
Returns a string representation of the node.

```ruby
def to_s
  inspect
end
```
```

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

### Beckett::Node::Header Class

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Header

Details about the Beckett::Node::Header class, its inheritance, attributes, and methods.

```APIDOC
## Class: Beckett::Node::Header

### Description
Represents a header element within the Beckett parsing structure.

### Inheritance
- Inherits from: `Beckett::Node::Element`
- Also inherits from: `Object`, `Base`, `Element`

### Defined in
- `lib/beckett/node/header.rb`

### Instance Attribute Summary
#### Inherited from Base
- `#children` (Object): Represents child nodes.
- `#node` (Object): The underlying node object.
- `#position` (Integer): The position of the node.

### Method Summary
#### Inherited from Element
- `#to_h` (Hash): Converts the element to a hash representation.

#### Inherited from Base
- `#<<` (Beckett::Node::Base): Appends a child node.
- `#initialize` (Beckett::Node::Base): Constructor for the Base class.
- `#inspect` (String): Returns a string representation of the object.
- `#to_h` (Hash): Converts the node to a hash representation.
- `#to_s` (String): Returns a string representation of the node.

### Constructor Details
This class inherits its constructor from `Beckett::Node::Base`.
```

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

### Access the Beckett version constant

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett

Retrieves the current version string of the Beckett gem.

```ruby
"0.1.0"
```

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

### Beckett::Node::Base#to_s Method

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Ato_s

The `to_s` method for the `Beckett::Node::Base` class returns the inspection of the object.

```APIDOC
## Beckett::Node::Base#to_s

### Description
Returns the inspection of the object.

### Method
`to_s`

### Returns
`Object` - The inspection of the object.

### Source
`lib/beckett/node.rb`
```

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

### Beckett::Node::Base#inspect

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Ainspect

Returns a string representation of a node, including its name and position.

```APIDOC
## Beckett::Node::Base#inspect

### Description
Returns a string representation of the node object, useful for debugging purposes. It displays the node name and its position.

### Method
Instance Method

### Returns
- **String** - A formatted string containing the node name and position (e.g., "<node_name position=1>").
```

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

### Beckett::Node::Base#<< Method

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3A%3C%3C

This snippet details the `<<` method within the `Beckett::Node::Base` class, which is used for appending nodes.

```APIDOC
## Beckett::Node::Base#<<

### Description
Appends one or more nodes to the current node's children.

### Method
`<<` (Append)

### Endpoint
N/A (Instance Method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```ruby
# Assuming 'parent_node' is an instance of Beckett::Node::Base
# and 'child_node' is another node object
parent_node << child_node
# or
parent_node << [node1, node2]
```

### Response
#### Success Response (200)
Returns the modified node instance.

#### Response Example
```json
// No direct JSON response, modifies the object in memory.
```

### Source
```ruby
# lib/beckett/node.rb
def <<(nodes)
  @children += ([nodes].flatten)
end
```
```

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

### Beckett::Node::Br#to_h Method

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Br%3Ato_h

This snippet details the `to_h` method of the `Beckett::Node::Br` class, which is used to convert the node to a hash representation.

```APIDOC
## Beckett::Node::Br#to_h

### Description
Converts the `Br` node to a hash representation, including its node name and type.

### Method
`to_h`

### Endpoint
N/A (Instance Method)

### Parameters
None

### Request Body
None

### Request Example
None

### Response
#### Success Response (Hash)
- **node_name** (String) - The name of the node.
- **node_type** (String) - The type of the node.

### Response Example
```json
{
  "node_name": "br",
  "node_type": "element"
}
```
```

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

### Beckett::Renderer#convert

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Renderer%3Aconvert

The convert method dispatches a node to the appropriate handler based on its type.

```APIDOC
## Beckett::Renderer#convert

### Description
Converts a given node into its rendered representation by dispatching the node to a specific handler based on its type.

### Method
Instance Method

### Parameters
- **node** (Object) - Required - The node object to be converted.

### Response
- **Object** - The rendered output of the node.
```

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

### Implement to_h in Beckett::Node::Base

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Ato_h

This method is defined in lib/beckett/node.rb and serves as an interface that must be implemented by subclasses.

```ruby
# File 'lib/beckett/node.rb', line 32

def to_h
  raise NotImplementedError
end
```

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

### Beckett::Document#to_hash

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Document%3Ato_hash

Converts the Beckett document content into a hash representation using the Kramdown GFM parser.

```APIDOC
## Beckett::Document#to_hash

### Description
Converts the current document content into a hash format. It initializes a Kramdown document with GFM input and uses the internal Renderer to convert the document root.

### Method
Instance Method

### Response
- **Object** - A hash representation of the document structure.
```

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

### Convert node using Beckett::Renderer

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Renderer%3Aconvert

Dispatches the conversion process to a specific handler based on the node type.

```ruby
def convert(node)
  send(DISPATCHER[node.type], node)
end
```

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

### Inspect Beckett Node

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Ainspect

Returns a string representation of the node including its name and position.

```ruby
# File 'lib/beckett/node.rb', line 24

def inspect
  "<#{node_name} position=#{position}>"
end
```

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

### Check for empty node text in Beckett::Node::Text

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Text%3Anil%3F

Determines if the node text is effectively empty by stripping whitespace. Used to improve list rendering.

```ruby
def nil?
  # improves list rendering.
  node_text.strip.empty?
end
```

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

### Beckett::Node::Root#to_h

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Root%3Ato_h

Converts the Root node and its children into a hash representation.

```APIDOC
## Beckett::Node::Root#to_h

### Description
Converts the Root node and its children into a hash representation.

### Method
GET

### Endpoint
N/A (Instance Method)

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **root** (Hash) - A hash containing the root node's data, including its children.

#### Response Example
```json
{
  "root": {
    "children": [
      // ... children nodes converted to hash
    ]
  }
}
```
```

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

### Serialize Root Node to Hash

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Root

Converts the root node and its children into a nested hash structure. This method is defined in lib/beckett/node/root.rb.

```ruby
def to_h
  {
    root: {}.tap do |root|
      root[:children] = children.map(&:to_h)
    end
  }
end
```

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

### Convert Beckett::Document to Hash

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Document

Converts the Markdown content to a hash representation. It uses Kramdown to parse the content and a custom Renderer to convert the document's root node.

```ruby
def to_hash
  document = Kramdown::Document.new(@content, input: 'GFM')
  renderer = Renderer.send(:new, document.root)
  renderer.convert(document.root)
end
```

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

### Method: Beckett::Node::Base#to_h

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Ato_h

Serializes a node object into a hash representation. This method is intended to be overridden by subclasses.

```APIDOC
## Beckett::Node::Base#to_h

### Description
Converts the current node instance into a hash representation. This method is currently abstract and raises a NotImplementedError if called directly on the base class.

### Method
Instance Method

### Parameters
None

### Response
#### Success Response (Object)
- **Returns** (Hash) - A hash representation of the node data.

#### Error Response
- **NotImplementedError** - Raised when the method is called on the base class without being overridden.
```

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

### Convert Codeblock Node to Hash

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Codeblock%3Ato_h

Converts a Beckett::Node::Codeblock object into a hash representation. This method is useful for serializing node data.

```ruby
def to_h
  {}.tap do |element|
    element[:node_name] = node_name
    element[:node_type] = node_type
    element[:node_text] = node_text
  end
end
```

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

### Convert Beckett::Document to JSON

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Document

Converts the document to a JSON string by first converting it to a hash.

```ruby
def to_json
  to_hash.to_json
end
```

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

### Beckett::Document#to_json

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Document%3Ato_json

Converts the Document object to a JSON string by first converting it to a hash.

```APIDOC
## Beckett::Document#to_json

### Description
Converts the Document object to a JSON string.

### Method
GET

### Endpoint
N/A (Instance Method)

### Request Body
None

### Response
#### Success Response (200)
- **json_string** (string) - A JSON representation of the Document object.

### Response Example
```json
{
  "example": "{\"key\": \"value\"}"
}
```
```

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

### Manage Node Children

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base

Appends nodes to the current node's children list.

```ruby
# File 'lib/beckett/node.rb', line 36

def <<(nodes)
  @children += ([nodes].flatten)
end
```

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

### Beckett::Node::Text#nil?

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Text%3Anil%3F

Checks if the text content of a node is empty or whitespace, which is used to improve list rendering.

```APIDOC
## Beckett::Node::Text#nil?

### Description
Returns a boolean indicating if the node text is empty or consists only of whitespace. This method is used to improve list rendering.

### Method
Instance Method

### Returns
- **Boolean** - True if the node text is empty or whitespace, false otherwise.
```

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

### Convert Beckett Document to JSON

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Document%3Ato_json

Serializes the document object to a JSON string using the to_hash method.

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

def to_json
  to_hash.to_json
end
```

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

### Convert Text Node to Hash

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Text

Converts the text node into a hash representation containing its name, type, and text content. This is useful for serialization or data processing.

```ruby
def to_h
  {
  }.tap do |element|
    element[:node_name] = node_name
    element[:node_type] = node_type
    element[:node_text] = node_text
  end
end
```

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

### Convert Beckett::Node::Br to Hash

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Br%3Ato_h

Converts a Br node to a hash representation, including its node name and type. This method is part of the Beckett::Node::Br class.

```ruby
def to_h
  {}.tap do |element|
    element[:node_name] = node_name
    element[:node_type] = node_type
  end
end
```

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

### Convert Element to Hash Representation

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Element

Converts the element node into a hash, including its name, type, attributes, and children. This method is useful for serializing or inspecting the element's structure.

```ruby
def to_h
  {}.tap do |element|
    element[:node_name]  = node_name
    element[:node_type]  = node_type
    # NOTE: might add attributes as `nil` or empty Hash at a later date...
    element[:attributes] = node_attributes if node_attributes
    element[:children]   = children.map(&:to_h)
  end
end
```

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

### Access Node Attributes

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base

Getter methods for accessing the node's children, node data, and position.

```ruby
# File 'lib/beckett/node.rb', line 15

def children
  @children
end
```

```ruby
# File 'lib/beckett/node.rb', line 15

def node
  @node
end
```

```ruby
# File 'lib/beckett/node.rb', line 15

def position
  @position
end
```

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

### Append nodes to Beckett::Node::Base

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3A%3C%3C

Appends one or more nodes to the current node's children array. The input is flattened to ensure compatibility with single or multiple node arguments.

```ruby
def <<(nodes)
  @children += ([nodes].flatten)
end
```

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

### Define DISPATCHER constant in Beckett::Renderer

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Renderer

The DISPATCHER constant is a Hash that dynamically maps node types to their corresponding conversion methods. It defaults to :convert_node if a specific method is not defined.

```ruby
Hash.new { |h, k|
  method = :"convert_#{k}"
  h[k] = Renderer.method_defined?(method) ? method : :convert_node
}
```

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

### Beckett::Node.find

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node.find

Finds a Node class based on the node type. If a corresponding class is defined, it returns that class; otherwise, it defaults to Element.

```APIDOC
## Beckett::Node.find

### Description
Finds a Node class based on the node type. If a corresponding class is defined, it returns that class; otherwise, it defaults to Element.

### Method
GET

### Endpoint
/websites/rubydoc_info_gems_beckett_0_1_0/lib/beckett/node.rb

### Parameters
#### Path Parameters
- **node** (Object) - Required - The node object to find the class for.

### Response
#### Success Response (200)
- **Object** - The corresponding Node class or the default Element class.

### Response Example
```ruby
Beckett::Node.find(some_node_object)
```
```

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

### Access the node attribute in Beckett::Node::Base

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Anode

Retrieves the value of the @node instance variable. This method is defined in lib/beckett/node.rb.

```ruby
# File 'lib/beckett/node.rb', line 15

def node
  @node
end
```

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

### Beckett::Node::Base#position

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Aposition

Retrieves the position attribute from a Beckett node object.

```APIDOC
## Beckett::Node::Base#position

### Description
Returns the value of the position attribute for a given node instance.

### Method
GET (Attribute Accessor)

### Endpoint
Beckett::Node::Base#position

### Response
- **position** (Object) - The value of the position attribute.
```

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

### Find node type in Beckett::Node

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node.find

Resolves the class constant based on the node type. Defaults to Element if the specific type constant is missing.

```ruby
def self.find(node)
  type = node.type.capitalize

  if self.const_defined?(type)
    const_get(type)
  else
    Element
  end
end
```

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

### Access children attribute in Beckett::Node::Base

Source: https://rubydoc.info/gems/beckett/0.1.0/Beckett/Node/Base%3Achildren

Retrieves the value of the children attribute for a node instance.

```ruby
# File 'lib/beckett/node.rb', line 15

def children
  @children
end
```
Tokens:
Raw