@herb-tools/node 0.1.1 → 0.3.0

package/extension/libherb/ast_nodes.h

@@ -0,0 +1,335 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release/templates/src/include/ast_nodes.h.erb
+
+#ifndef HERB_AST_NODES_H
+#define HERB_AST_NODES_H
+
+#include <stdbool.h>
+#include <prism.h>
+
+#include "array.h"
+#include "buffer.h"
+#include "position.h"
+#include "location.h"
+#include "token_struct.h"
+#include "analyzed_ruby.h"
+
+typedef enum {
+  AST_DOCUMENT_NODE,
+  AST_LITERAL_NODE,
+  AST_HTML_OPEN_TAG_NODE,
+  AST_HTML_CLOSE_TAG_NODE,
+  AST_HTML_SELF_CLOSE_TAG_NODE,
+  AST_HTML_ELEMENT_NODE,
+  AST_HTML_ATTRIBUTE_VALUE_NODE,
+  AST_HTML_ATTRIBUTE_NAME_NODE,
+  AST_HTML_ATTRIBUTE_NODE,
+  AST_HTML_TEXT_NODE,
+  AST_HTML_COMMENT_NODE,
+  AST_HTML_DOCTYPE_NODE,
+  AST_WHITESPACE_NODE,
+  AST_ERB_CONTENT_NODE,
+  AST_ERB_END_NODE,
+  AST_ERB_ELSE_NODE,
+  AST_ERB_IF_NODE,
+  AST_ERB_BLOCK_NODE,
+  AST_ERB_WHEN_NODE,
+  AST_ERB_CASE_NODE,
+  AST_ERB_CASE_MATCH_NODE,
+  AST_ERB_WHILE_NODE,
+  AST_ERB_UNTIL_NODE,
+  AST_ERB_FOR_NODE,
+  AST_ERB_RESCUE_NODE,
+  AST_ERB_ENSURE_NODE,
+  AST_ERB_BEGIN_NODE,
+  AST_ERB_UNLESS_NODE,
+  AST_ERB_YIELD_NODE,
+  AST_ERB_IN_NODE,
+} ast_node_type_T;
+
+typedef struct AST_NODE_STRUCT {
+  ast_node_type_T type;
+  location_T* location;
+  // maybe a range too?
+  array_T* errors;
+} AST_NODE_T;
+
+
+typedef struct AST_DOCUMENT_NODE_STRUCT {
+  AST_NODE_T base;
+  array_T* children;
+} AST_DOCUMENT_NODE_T;
+
+typedef struct AST_LITERAL_NODE_STRUCT {
+  AST_NODE_T base;
+  const char* content;
+} AST_LITERAL_NODE_T;
+
+typedef struct AST_HTML_OPEN_TAG_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* tag_name;
+  token_T* tag_closing;
+  array_T* children;
+  bool is_void;
+} AST_HTML_OPEN_TAG_NODE_T;
+
+typedef struct AST_HTML_CLOSE_TAG_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* tag_name;
+  token_T* tag_closing;
+} AST_HTML_CLOSE_TAG_NODE_T;
+
+typedef struct AST_HTML_SELF_CLOSE_TAG_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* tag_name;
+  array_T* attributes;
+  token_T* tag_closing;
+  bool is_void;
+} AST_HTML_SELF_CLOSE_TAG_NODE_T;
+
+typedef struct AST_HTML_ELEMENT_NODE_STRUCT {
+  AST_NODE_T base;
+  struct AST_HTML_OPEN_TAG_NODE_STRUCT* open_tag;
+  token_T* tag_name;
+  array_T* body;
+  struct AST_HTML_CLOSE_TAG_NODE_STRUCT* close_tag;
+  bool is_void;
+} AST_HTML_ELEMENT_NODE_T;
+
+typedef struct AST_HTML_ATTRIBUTE_VALUE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* open_quote;
+  array_T* children;
+  token_T* close_quote;
+  bool quoted;
+} AST_HTML_ATTRIBUTE_VALUE_NODE_T;
+
+typedef struct AST_HTML_ATTRIBUTE_NAME_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* name;
+} AST_HTML_ATTRIBUTE_NAME_NODE_T;
+
+typedef struct AST_HTML_ATTRIBUTE_NODE_STRUCT {
+  AST_NODE_T base;
+  struct AST_HTML_ATTRIBUTE_NAME_NODE_STRUCT* name;
+  token_T* equals;
+  struct AST_HTML_ATTRIBUTE_VALUE_NODE_STRUCT* value;
+} AST_HTML_ATTRIBUTE_NODE_T;
+
+typedef struct AST_HTML_TEXT_NODE_STRUCT {
+  AST_NODE_T base;
+  const char* content;
+} AST_HTML_TEXT_NODE_T;
+
+typedef struct AST_HTML_COMMENT_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* comment_start;
+  array_T* children;
+  token_T* comment_end;
+} AST_HTML_COMMENT_NODE_T;
+
+typedef struct AST_HTML_DOCTYPE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  array_T* children;
+  token_T* tag_closing;
+} AST_HTML_DOCTYPE_NODE_T;
+
+typedef struct AST_WHITESPACE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* value;
+} AST_WHITESPACE_NODE_T;
+
+typedef struct AST_ERB_CONTENT_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  analyzed_ruby_T* analyzed_ruby;
+  bool parsed;
+  bool valid;
+} AST_ERB_CONTENT_NODE_T;
+
+typedef struct AST_ERB_END_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+} AST_ERB_END_NODE_T;
+
+typedef struct AST_ERB_ELSE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+} AST_ERB_ELSE_NODE_T;
+
+typedef struct AST_ERB_IF_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+  AST_NODE_T* subsequent;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_IF_NODE_T;
+
+typedef struct AST_ERB_BLOCK_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* body;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_BLOCK_NODE_T;
+
+typedef struct AST_ERB_WHEN_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+} AST_ERB_WHEN_NODE_T;
+
+typedef struct AST_ERB_CASE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* children;
+  array_T* conditions;
+  struct AST_ERB_ELSE_NODE_STRUCT* else_clause;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_CASE_NODE_T;
+
+typedef struct AST_ERB_CASE_MATCH_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* children;
+  array_T* conditions;
+  struct AST_ERB_ELSE_NODE_STRUCT* else_clause;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_CASE_MATCH_NODE_T;
+
+typedef struct AST_ERB_WHILE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_WHILE_NODE_T;
+
+typedef struct AST_ERB_UNTIL_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_UNTIL_NODE_T;
+
+typedef struct AST_ERB_FOR_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_FOR_NODE_T;
+
+typedef struct AST_ERB_RESCUE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+  struct AST_ERB_RESCUE_NODE_STRUCT* subsequent;
+} AST_ERB_RESCUE_NODE_T;
+
+typedef struct AST_ERB_ENSURE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+} AST_ERB_ENSURE_NODE_T;
+
+typedef struct AST_ERB_BEGIN_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+  struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause;
+  struct AST_ERB_ELSE_NODE_STRUCT* else_clause;
+  struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_BEGIN_NODE_T;
+
+typedef struct AST_ERB_UNLESS_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+  struct AST_ERB_ELSE_NODE_STRUCT* else_clause;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_UNLESS_NODE_T;
+
+typedef struct AST_ERB_YIELD_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+} AST_ERB_YIELD_NODE_T;
+
+typedef struct AST_ERB_IN_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+} AST_ERB_IN_NODE_T;
+
+AST_DOCUMENT_NODE_T* ast_document_node_init(array_T* children, position_T* start_position, position_T* end_position, array_T* errors);
+AST_LITERAL_NODE_T* ast_literal_node_init(const char* content, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_OPEN_TAG_NODE_T* ast_html_open_tag_node_init(token_T* tag_opening, token_T* tag_name, token_T* tag_closing, array_T* children, bool is_void, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_CLOSE_TAG_NODE_T* ast_html_close_tag_node_init(token_T* tag_opening, token_T* tag_name, token_T* tag_closing, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_SELF_CLOSE_TAG_NODE_T* ast_html_self_close_tag_node_init(token_T* tag_opening, token_T* tag_name, array_T* attributes, token_T* tag_closing, bool is_void, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_ELEMENT_NODE_T* ast_html_element_node_init(struct AST_HTML_OPEN_TAG_NODE_STRUCT* open_tag, token_T* tag_name, array_T* body, struct AST_HTML_CLOSE_TAG_NODE_STRUCT* close_tag, bool is_void, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_ATTRIBUTE_VALUE_NODE_T* ast_html_attribute_value_node_init(token_T* open_quote, array_T* children, token_T* close_quote, bool quoted, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_ATTRIBUTE_NAME_NODE_T* ast_html_attribute_name_node_init(token_T* name, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_ATTRIBUTE_NODE_T* ast_html_attribute_node_init(struct AST_HTML_ATTRIBUTE_NAME_NODE_STRUCT* name, token_T* equals, struct AST_HTML_ATTRIBUTE_VALUE_NODE_STRUCT* value, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_TEXT_NODE_T* ast_html_text_node_init(const char* content, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_COMMENT_NODE_T* ast_html_comment_node_init(token_T* comment_start, array_T* children, token_T* comment_end, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_DOCTYPE_NODE_T* ast_html_doctype_node_init(token_T* tag_opening, array_T* children, token_T* tag_closing, position_T* start_position, position_T* end_position, array_T* errors);
+AST_WHITESPACE_NODE_T* ast_whitespace_node_init(token_T* value, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_CONTENT_NODE_T* ast_erb_content_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, analyzed_ruby_T* analyzed_ruby, bool parsed, bool valid, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_END_NODE_T* ast_erb_end_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_ELSE_NODE_T* ast_erb_else_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, AST_NODE_T* subsequent, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* body, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_WHEN_NODE_T* ast_erb_when_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_CASE_NODE_T* ast_erb_case_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* children, array_T* conditions, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_CASE_MATCH_NODE_T* ast_erb_case_match_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* children, array_T* conditions, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_WHILE_NODE_T* ast_erb_while_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_UNTIL_NODE_T* ast_erb_until_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_FOR_NODE_T* ast_erb_for_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_RESCUE_NODE_T* ast_erb_rescue_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_RESCUE_NODE_STRUCT* subsequent, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_ENSURE_NODE_T* ast_erb_ensure_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_BEGIN_NODE_T* ast_erb_begin_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_IN_NODE_T* ast_erb_in_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, position_T* start_position, position_T* end_position, array_T* errors);
+
+const char* ast_node_type_to_string(AST_NODE_T* node);
+const char* ast_node_human_type(AST_NODE_T* node);
+
+#endif

package/extension/libherb/ast_pretty_print.c

@@ -364,6 +364,47 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
 
     } break;
 
+    case AST_ERB_CASE_MATCH_NODE: {
+      const AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = (AST_ERB_CASE_MATCH_NODE_T*) node;
+
+      pretty_print_errors(node, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_case_match_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_case_match_node->content, "content", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_case_match_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
+      pretty_print_array("children", erb_case_match_node->children, indent, relative_indent, false, buffer);
+      pretty_print_array("conditions", erb_case_match_node->conditions, indent, relative_indent, false, buffer);
+
+      pretty_print_label("else_clause", indent, relative_indent, false, buffer);
+
+      if (erb_case_match_node->else_clause) {
+        buffer_append(buffer, "\n");
+        pretty_print_indent(buffer, indent);
+        pretty_print_indent(buffer, relative_indent + 1);
+
+        buffer_append(buffer, "└── ");
+        ast_pretty_print_node((AST_NODE_T*) erb_case_match_node->else_clause, indent, relative_indent + 2, buffer);
+      } else {
+        buffer_append(buffer, " ∅\n");
+      }
+      buffer_append(buffer, "\n");
+
+
+      pretty_print_label("end_node", indent, relative_indent, true, buffer);
+
+      if (erb_case_match_node->end_node) {
+        buffer_append(buffer, "\n");
+        pretty_print_indent(buffer, indent);
+        pretty_print_indent(buffer, relative_indent + 1);
+
+        buffer_append(buffer, "└── ");
+        ast_pretty_print_node((AST_NODE_T*) erb_case_match_node->end_node, indent, relative_indent + 2, buffer);
+      } else {
+        buffer_append(buffer, " ∅\n");
+      }
+      buffer_append(buffer, "\n");
+
+    } break;
+
     case AST_ERB_WHILE_NODE: {
       const AST_ERB_WHILE_NODE_T* erb_while_node = (AST_ERB_WHILE_NODE_T*) node;
 
@@ -584,5 +625,24 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
 
     } break;
 
+    case AST_ERB_YIELD_NODE: {
+      const AST_ERB_YIELD_NODE_T* erb_yield_node = (AST_ERB_YIELD_NODE_T*) node;
+
+      pretty_print_errors(node, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_yield_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_yield_node->content, "content", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_yield_node->tag_closing, "tag_closing", indent, relative_indent, true, buffer);
+    } break;
+
+    case AST_ERB_IN_NODE: {
+      const AST_ERB_IN_NODE_T* erb_in_node = (AST_ERB_IN_NODE_T*) node;
+
+      pretty_print_errors(node, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_in_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_in_node->content, "content", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_in_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
+      pretty_print_array("statements", erb_in_node->statements, indent, relative_indent, true, buffer);
+    } break;
+
   }
 }

package/extension/libherb/ast_pretty_print.h

@@ -0,0 +1,17 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release/templates/src/include/ast_pretty_print.h.erb
+
+#ifndef HERB_AST_PRETTY_PRINT_H
+#define HERB_AST_PRETTY_PRINT_H
+
+#include "ast_nodes.h"
+#include "buffer.h"
+
+void ast_pretty_print_node(
+  AST_NODE_T* node,
+  size_t indent,
+  size_t relative_indent,
+  buffer_T* buffer
+);
+
+#endif

package/extension/libherb/buffer.c

@@ -10,7 +10,7 @@
 bool buffer_init(buffer_T* buffer) {
   buffer->capacity = 1024;
   buffer->length = 0;
-  buffer->value = nullable_safe_malloc(buffer->capacity * sizeof(char));
+  buffer->value = nullable_safe_malloc((buffer->capacity + 1) * sizeof(char));
 
   if (!buffer->value) {
     fprintf(stderr, "Error: Failed to initialize buffer with capacity of %zu.\n", buffer->capacity);
@@ -50,32 +50,39 @@ size_t buffer_sizeof(void) {
  * or null termination.
  *
  * @param buffer The buffer to increase capacity for
- * @param required_length The additional length needed beyond current buffer length
- * @return true if capacity is sufficient (either already or after reallocation),
- *         false if reallocation failed
+ * @param additional_capacity The additional length needed beyond current buffer capacity
+ * @return true if capacity was increased, false if reallocation failed
  */
-bool buffer_increase_capacity(buffer_T* buffer, const size_t required_length) {
-  if (SIZE_MAX - buffer->length < required_length) {
+bool buffer_increase_capacity(buffer_T* buffer, const size_t additional_capacity) {
+  if (additional_capacity + 1 >= SIZE_MAX) {
     fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
-    return false;
+    exit(1);
   }
 
-  const size_t required_capacity = buffer->length + required_length;
-
-  if (buffer->capacity >= required_capacity) { return true; }
+  const size_t new_capacity = buffer->capacity + additional_capacity;
 
-  size_t new_capacity;
-  if (required_capacity > SIZE_MAX / 2) {
-    new_capacity = required_capacity + 1024;
+  return buffer_resize(buffer, new_capacity);
+}
 
-    if (new_capacity < required_capacity) { new_capacity = SIZE_MAX; }
-  } else {
-    new_capacity = required_capacity * 2;
+/**
+ * Resizes the capacity of the buffer to the specified new capacity.
+ *
+ * @param buffer The buffer to resize
+ * @param new_capacity The new capacity to resize the buffer to
+ * @return true if capacity was resized, false if reallocation failed
+ */
+bool buffer_resize(buffer_T* buffer, const size_t new_capacity) {
+  if (new_capacity + 1 >= SIZE_MAX) {
+    fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
+    exit(1);
   }
 
-  char* new_value = safe_realloc(buffer->value, new_capacity);
+  char* new_value = nullable_safe_realloc(buffer->value, new_capacity + 1);
 
-  if (unlikely(new_value == NULL)) { return false; }
+  if (unlikely(new_value == NULL)) {
+    fprintf(stderr, "Error: Failed to resize buffer to %zu.\n", new_capacity);
+    exit(1);
+  }
 
   buffer->value = new_value;
   buffer->capacity = new_capacity;
@@ -83,6 +90,33 @@ bool buffer_increase_capacity(buffer_T* buffer, const size_t required_length) {
   return true;
 }
 
+/**
+ * Expands the capacity of the buffer by doubling its current capacity.
+ * This function is a convenience function that calls buffer_increase_capacity
+ * with a factor of 2.
+ *
+ * @param buffer The buffer to expand capacity for
+ * @return true if capacity was increased, false if reallocation failed
+ */
+bool buffer_expand_capacity(buffer_T* buffer) {
+  return buffer_resize(buffer, buffer->capacity * 2);
+}
+
+/**
+ * Expands the capacity of the buffer if needed to accommodate additional content.
+ * This function is a convenience function that calls buffer_has_capacity and
+ * buffer_expand_capacity.
+ *
+ * @param buffer The buffer to expand capacity for
+ * @param required_length The additional length needed beyond current buffer capacity
+ * @return true if capacity was increased, false if reallocation failed
+ */
+bool buffer_expand_if_needed(buffer_T* buffer, const size_t required_length) {
+  if (buffer_has_capacity(buffer, required_length)) { return true; }
+
+  return buffer_resize(buffer, buffer->capacity + (required_length * 2));
+}
+
 /**
  * Appends a null-terminated string to the buffer.
  * @note This function requires that 'text' is a properly null-terminated string.
@@ -99,7 +133,7 @@ void buffer_append(buffer_T* buffer, const char* text) {
 
   size_t text_length = strlen(text);
 
-  if (!buffer_increase_capacity(buffer, text_length)) { return; }
+  if (!buffer_expand_if_needed(buffer, text_length)) { return; }
 
   memcpy(buffer->value + buffer->length, text, text_length);
   buffer->length += text_length;
@@ -120,7 +154,7 @@ void buffer_append(buffer_T* buffer, const char* text) {
  */
 void buffer_append_with_length(buffer_T* buffer, const char* text, const size_t length) {
   if (!buffer || !text || length == 0) { return; }
-  if (!buffer_increase_capacity(buffer, length)) { return; }
+  if (!buffer_expand_if_needed(buffer, length)) { return; }
 
   memcpy(buffer->value + buffer->length, text, length);
 
@@ -161,7 +195,7 @@ void buffer_prepend(buffer_T* buffer, const char* text) {
 
   size_t text_length = strlen(text);
 
-  if (!buffer_increase_capacity(buffer, text_length)) { return; }
+  if (!buffer_expand_if_needed(buffer, text_length)) { return; }
 
   memmove(buffer->value + text_length, buffer->value, buffer->length + 1);
   memcpy(buffer->value, text, text_length);
@@ -171,17 +205,16 @@ void buffer_prepend(buffer_T* buffer, const char* text) {
 
 void buffer_concat(buffer_T* destination, buffer_T* source) {
   if (source->length == 0) { return; }
-  if (!buffer_increase_capacity(destination, source->length)) { return; }
+  if (!buffer_expand_if_needed(destination, source->length)) { return; }
 
   memcpy(destination->value + destination->length, source->value, source->length);
+
   destination->length += source->length;
   destination->value[destination->length] = '\0';
 }
 
-bool buffer_reserve(buffer_T* buffer, const size_t min_capacity) {
-  const size_t required_length = min_capacity - buffer->length;
-
-  return buffer_increase_capacity(buffer, required_length);
+bool buffer_has_capacity(buffer_T* buffer, const size_t required_length) {
+  return (buffer->length + required_length <= buffer->capacity);
 }
 
 void buffer_clear(buffer_T* buffer) {
@@ -192,7 +225,7 @@ void buffer_clear(buffer_T* buffer) {
 void buffer_free(buffer_T* buffer) {
   if (!buffer) { return; }
 
-  free(buffer->value);
+  if (buffer->value != NULL) { free(buffer->value); }
 
   buffer->value = NULL;
   buffer->length = buffer->capacity = 0;

package/extension/libherb/buffer.h

@@ -0,0 +1,39 @@
+#ifndef HERB_BUFFER_H
+#define HERB_BUFFER_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef struct BUFFER_STRUCT {
+  char* value;
+  size_t length;
+  size_t capacity;
+} buffer_T;
+
+bool buffer_init(buffer_T* buffer);
+buffer_T buffer_new(void);
+
+bool buffer_increase_capacity(buffer_T* buffer, size_t additional_capacity);
+bool buffer_has_capacity(buffer_T* buffer, size_t required_length);
+bool buffer_expand_capacity(buffer_T* buffer);
+bool buffer_expand_if_needed(buffer_T* buffer, size_t required_length);
+bool buffer_resize(buffer_T* buffer, size_t new_capacity);
+
+void buffer_append(buffer_T* buffer, const char* text);
+void buffer_append_with_length(buffer_T* buffer, const char* text, size_t length);
+void buffer_append_char(buffer_T* buffer, char character);
+void buffer_append_repeated(buffer_T* buffer, char character, size_t length);
+void buffer_append_whitespace(buffer_T* buffer, size_t length);
+void buffer_prepend(buffer_T* buffer, const char* text);
+void buffer_concat(buffer_T* destination, buffer_T* source);
+
+char* buffer_value(const buffer_T* buffer);
+
+size_t buffer_length(const buffer_T* buffer);
+size_t buffer_capacity(const buffer_T* buffer);
+size_t buffer_sizeof(void);
+
+void buffer_clear(buffer_T* buffer);
+void buffer_free(buffer_T* buffer);
+
+#endif