Ruby: Generate build factories for AST nodes (#2055)

Follow up on the recently added `Herb::Location.zero`,
`Herb::Range.zero` and `Herb::Token.from` constructors, applying the
same idea one level up to AST nodes.

Constructing a node by hand means repeating the node type as a string,
passing an empty errors array, and then positionally filling every
field, including the ones you don't care about:

```ruby
Herb::AST::ERBContentNode.new(
  "ERBContentNode",
  element_node.location,
  [],
  Herb::Token.from("TOKEN_ERB_START", "<%="),
  Herb::Token.from("TOKEN_ERB_CONTENT", " #{code}"),
  Herb::Token.from("TOKEN_ERB_END", "%>"),
  nil,
  false,
  true,
  nil
)
```

The same `ERBContentNode` from above with this pull request:

```ruby
Herb::AST::ERBContentNode.build(
  location: element_node.location,
  tag_opening: Herb::Token.from("TOKEN_ERB_START", "<%="),
  content: Herb::Token.from("TOKEN_ERB_CONTENT", " #{code}"),
  tag_closing: Herb::Token.from("TOKEN_ERB_END", "%>"),
  valid: true
)
```

Author: marcoroth

lib/herb/engine/auto_close_omitted_tags_visitor.rb

@@ -34,14 +34,11 @@ def inspect
 
       #: (Herb::Token, Herb::Location) -> Herb::AST::HTMLCloseTagNode
       def explicit_close_tag(tag_name, location)
-        Herb::AST::HTMLCloseTagNode.new(
-          "HTMLCloseTagNode",
-          location,
-          [],
-          Herb::Token.from("TOKEN_HTML_TAG_START_CLOSE", "</", location: location),
-          tag_name,
-          [],
-          Herb::Token.from("TOKEN_HTML_TAG_END", ">", location: location)
+        Herb::AST::HTMLCloseTagNode.build(
+          location: location,
+          tag_opening: Herb::Token.from("TOKEN_HTML_TAG_START_CLOSE", "</", location: location),
+          tag_name: tag_name,
+          tag_closing: Herb::Token.from("TOKEN_HTML_TAG_END", ">", location: location)
         )
       end
     end

lib/herb/engine/component_visitor.rb

@@ -204,48 +204,34 @@ def escape(content)
 
       #: (Herb::AST::HTMLElementNode, String) -> Herb::AST::ERBContentNode
       def erb_content_node(element_node, code)
-        Herb::AST::ERBContentNode.new(
-          "ERBContentNode",
-          element_node.location,
-          [],
-          Herb::Token.from("TOKEN_ERB_START", "<%="),
-          Herb::Token.from("TOKEN_ERB_CONTENT", " #{code}"),
-          Herb::Token.from("TOKEN_ERB_END", "%>"),
-          nil,
-          false,
-          true,
-          nil
+        Herb::AST::ERBContentNode.build(
+          location: element_node.location,
+          tag_opening: Herb::Token.from("TOKEN_ERB_START", "<%="),
+          content: Herb::Token.from("TOKEN_ERB_CONTENT", " #{code}"),
+          tag_closing: Herb::Token.from("TOKEN_ERB_END", "%>"),
+          valid: true
         )
       end
 
       #: (Herb::AST::HTMLElementNode, String, Array[Herb::AST::Node]) -> Herb::AST::ERBBlockNode
       def erb_block_node(element_node, code, body)
-        Herb::AST::ERBBlockNode.new(
-          "ERBBlockNode",
-          element_node.location,
-          [],
-          Herb::Token.from("TOKEN_ERB_START", "<%="),
-          Herb::Token.from("TOKEN_ERB_CONTENT", " #{code}"),
-          Herb::Token.from("TOKEN_ERB_END", "%>"),
-          nil,
-          body,
-          [],
-          nil,
-          nil,
-          nil,
-          erb_end_node(element_node)
+        Herb::AST::ERBBlockNode.build(
+          location: element_node.location,
+          tag_opening: Herb::Token.from("TOKEN_ERB_START", "<%="),
+          content: Herb::Token.from("TOKEN_ERB_CONTENT", " #{code}"),
+          tag_closing: Herb::Token.from("TOKEN_ERB_END", "%>"),
+          body: body,
+          end_node: erb_end_node(element_node)
         )
       end
 
       #: (Herb::AST::HTMLElementNode) -> Herb::AST::ERBEndNode
       def erb_end_node(element_node)
-        Herb::AST::ERBEndNode.new(
-          "ERBEndNode",
-          element_node.location,
-          [],
-          Herb::Token.from("TOKEN_ERB_START", "<%"),
-          Herb::Token.from("TOKEN_ERB_CONTENT", " end "),
-          Herb::Token.from("TOKEN_ERB_END", "%>")
+        Herb::AST::ERBEndNode.build(
+          location: element_node.location,
+          tag_opening: Herb::Token.from("TOKEN_ERB_START", "<%"),
+          content: Herb::Token.from("TOKEN_ERB_CONTENT", " end "),
+          tag_closing: Herb::Token.from("TOKEN_ERB_END", "%>")
         )
       end
     end

lib/herb/engine/debug_visitor.rb

@@ -187,16 +187,22 @@ def add_debug_attributes_to_element(open_tag_node)
       end
 
       def create_debug_attribute(name, value)
-        name_literal = Herb::AST::LiteralNode.new("LiteralNode", Herb::Location.zero, [], name.dup)
-        name_node = Herb::AST::HTMLAttributeNameNode.new("HTMLAttributeNameNode", Herb::Location.zero, [], [name_literal])
-
-        value_literal = Herb::AST::LiteralNode.new("LiteralNode", Herb::Location.zero, [], value.dup)
-        value_node = Herb::AST::HTMLAttributeValueNode.new("HTMLAttributeValueNode", Herb::Location.zero, [], Herb::Token.from(:quote, '"'),
-                                                           [value_literal], Herb::Token.from(:quote, '"'), true)
-
-        equals_token = Herb::Token.from(:equals, "=")
+        name_literal = Herb::AST::LiteralNode.build(content: name.dup)
+        name_node = Herb::AST::HTMLAttributeNameNode.build(children: [name_literal])
+
+        value_literal = Herb::AST::LiteralNode.build(content: value.dup)
+        value_node = Herb::AST::HTMLAttributeValueNode.build(
+          open_quote: Herb::Token.from(:quote, '"'),
+          children: [value_literal],
+          close_quote: Herb::Token.from(:quote, '"'),
+          quoted: true
+        )
 
-        Herb::AST::HTMLAttributeNode.new("HTMLAttributeNode", Herb::Location.zero, [], name_node, equals_token, value_node)
+        Herb::AST::HTMLAttributeNode.build(
+          name: name_node,
+          equals: Herb::Token.from(:equals, "="),
+          value: value_node
+        )
       end
 
       def create_debug_span_for_erb(erb_node)
@@ -233,29 +239,26 @@ def create_debug_span_for_erb(erb_node)
 
         tag_name_token = Herb::Token.from(:tag_name, "span")
 
-        open_tag = Herb::AST::HTMLOpenTagNode.new(
-          "HTMLOpenTagNode",
-          Herb::Location.zero,
-          [],
-          Herb::Token.from(:tag_opening, "<"),
-          tag_name_token,
-          Herb::Token.from(:tag_closing, ">"),
-          debug_attributes,
-          false
+        open_tag = Herb::AST::HTMLOpenTagNode.build(
+          tag_opening: Herb::Token.from(:tag_opening, "<"),
+          tag_name: tag_name_token,
+          tag_closing: Herb::Token.from(:tag_closing, ">"),
+          children: debug_attributes
         )
 
-        close_tag = Herb::AST::HTMLCloseTagNode.new(
-          "HTMLCloseTagNode",
-          Herb::Location.zero,
-          [],
-          Herb::Token.from(:tag_opening, "</"),
-          Herb::Token.from(:tag_name, "span"),
-          [],
-          Herb::Token.from(:tag_closing, ">")
+        close_tag = Herb::AST::HTMLCloseTagNode.build(
+          tag_opening: Herb::Token.from(:tag_opening, "</"),
+          tag_name: Herb::Token.from(:tag_name, "span"),
+          tag_closing: Herb::Token.from(:tag_closing, ">")
         )
 
-        Herb::AST::HTMLElementNode.new("HTMLElementNode", Herb::Location.zero, [], open_tag, tag_name_token, [erb_node], close_tag,
-                                       false, "Debug")
+        Herb::AST::HTMLElementNode.build(
+          open_tag: open_tag,
+          tag_name: tag_name_token,
+          body: [erb_node],
+          close_tag: close_tag,
+          element_source: "Debug"
+        )
       end
 
       def determine_view_type