@herb-tools/node 0.7.4 → 0.8.0

package/extension/libherb/position.h

@@ -1,22 +1,11 @@
 #ifndef HERB_POSITION_H
 #define HERB_POSITION_H
 
-#include <stdlib.h>
+#include <stdint.h>
 
 typedef struct POSITION_STRUCT {
-  size_t line;
-  size_t column;
+  uint32_t line;
+  uint32_t column;
 } position_T;
 
-position_T* position_init(size_t line, size_t column);
-
-size_t position_line(const position_T* position);
-size_t position_column(const position_T* position);
-
-size_t position_sizeof(void);
-
-position_T* position_copy(position_T* position);
-
-void position_free(position_T* position);
-
 #endif

package/extension/libherb/pretty_print.c

@@ -3,146 +3,149 @@
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/ast_pretty_print.h"
-#include "include/buffer.h"
 #include "include/errors.h"
 #include "include/token_struct.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-void pretty_print_indent(buffer_T* buffer, const size_t indent) {
+void pretty_print_indent(hb_buffer_T* buffer, const size_t indent) {
   for (size_t i = 0; i < indent; i++) {
-    buffer_append(buffer, "    ");
+    hb_buffer_append(buffer, "    ");
   }
 }
 
-void pretty_print_newline(const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+void pretty_print_newline(const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   pretty_print_indent(buffer, indent);
   pretty_print_indent(buffer, relative_indent);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_label(
-  const char* name,
+  hb_string_T name,
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_indent(buffer, indent);
   pretty_print_indent(buffer, relative_indent);
 
   if (last_property) {
-    buffer_append(buffer, "└── ");
+    hb_buffer_append(buffer, "└── ");
   } else {
-    buffer_append(buffer, "├── ");
+    hb_buffer_append(buffer, "├── ");
   }
 
-  buffer_append(buffer, name);
-  buffer_append(buffer, ": ");
+  hb_buffer_append_string(buffer, name);
+  hb_buffer_append(buffer, ": ");
 }
 
 void pretty_print_quoted_property(
-  const char* name,
-  const char* value,
+  hb_string_T name,
+  hb_string_T value,
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
-  char* quoted = quoted_string(value);
+  hb_string_T quoted = quoted_string(value);
   pretty_print_property(name, quoted, indent, relative_indent, last_property, buffer);
-  free(quoted);
+  free(quoted.data);
 }
 
 void pretty_print_boolean_property(
-  const char* name,
+  hb_string_T name,
   bool value,
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
-  pretty_print_property(name, value ? "true" : "false", indent, relative_indent, last_property, buffer);
+  pretty_print_property(name, hb_string(value ? "true" : "false"), indent, relative_indent, last_property, buffer);
 }
 
 void pretty_print_property(
-  const char* name,
-  const char* value,
+  hb_string_T name,
+  hb_string_T value,
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
-  buffer_append(buffer, value);
-  buffer_append(buffer, "\n");
+  hb_buffer_append_string(buffer, value);
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_size_t_property(
   size_t value,
-  const char* name,
+  hb_string_T name,
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
-  char* string = size_t_to_string(value);
-  buffer_append(buffer, string);
-  buffer_append(buffer, "\n");
-  free(string);
+
+  char size_string[21];
+  snprintf(size_string, 21, "%zu", value);
+
+  hb_buffer_append(buffer, size_string);
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_array(
-  const char* name,
-  array_T* array,
+  hb_string_T name,
+  hb_array_T* array,
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   if (array == NULL) {
-    pretty_print_property(name, "∅", indent, relative_indent, last_property, buffer);
+    pretty_print_property(name, hb_string("∅"), indent, relative_indent, last_property, buffer);
 
     return;
   }
 
-  if (array_size(array) == 0) {
-    pretty_print_property(name, "[]", indent, relative_indent, last_property, buffer);
+  if (hb_array_size(array) == 0) {
+    pretty_print_property(name, hb_string("[]"), indent, relative_indent, last_property, buffer);
 
     return;
   }
 
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
-  buffer_append(buffer, "(");
+  hb_buffer_append(buffer, "(");
 
   char count[16];
-  sprintf(count, "%zu", array_size(array));
-  buffer_append(buffer, count);
-  buffer_append(buffer, ")\n");
+  sprintf(count, "%zu", hb_array_size(array));
+  hb_buffer_append(buffer, count);
+  hb_buffer_append(buffer, ")\n");
 
   if (indent < 20) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      AST_NODE_T* child = array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      AST_NODE_T* child = hb_array_get(array, i);
       pretty_print_indent(buffer, indent);
       pretty_print_indent(buffer, relative_indent + 1);
 
-      if (i == array_size(array) - 1) {
-        buffer_append(buffer, "└── ");
+      if (i == hb_array_size(array) - 1) {
+        hb_buffer_append(buffer, "└── ");
       } else {
-        buffer_append(buffer, "├── ");
+        hb_buffer_append(buffer, "├── ");
       }
 
       ast_pretty_print_node(child, indent + 1, relative_indent + 1, buffer);
 
-      if (i != array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+      if (i != hb_array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
     }
   }
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_errors(
@@ -150,97 +153,92 @@ void pretty_print_errors(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
-  if (node->errors != NULL && array_size(node->errors) > 0) {
+  if (node->errors != NULL && hb_array_size(node->errors) > 0) {
     error_pretty_print_array("errors", node->errors, indent, relative_indent, last_property, buffer);
-    buffer_append(buffer, "\n");
+    hb_buffer_append(buffer, "\n");
   }
 }
 
-void pretty_print_location(location_T* location, buffer_T* buffer) {
-  buffer_append(buffer, "(location: (");
+void pretty_print_location(location_T location, hb_buffer_T* buffer) {
+  hb_buffer_append(buffer, "(location: (");
   char location_string[128];
   sprintf(
     location_string,
-    "%zu,%zu)-(%zu,%zu",
-    (location->start && location->start->line) ? location->start->line : 0,
-    (location->start && location->start->column) ? location->start->column : 0,
-    (location->end && location->end->line) ? location->end->line : 0,
-    (location->end && location->end->column) ? location->end->column : 0
+    "%u,%u)-(%u,%u",
+    location.start.line,
+    location.start.column,
+    location.end.line,
+    location.end.column
   );
-  buffer_append(buffer, location_string);
-  buffer_append(buffer, "))");
+  hb_buffer_append(buffer, location_string);
+  hb_buffer_append(buffer, "))");
 }
 
 void pretty_print_position_property(
   position_T* position,
-  const char* name,
+  hb_string_T name,
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
   if (position != NULL) {
-    buffer_append(buffer, "(");
+    hb_buffer_append(buffer, "(");
 
     char position_string[128];
 
-    sprintf(
-      position_string,
-      "%zu:%zu",
-      (position->line) ? position->line : 0,
-      (position->column) ? position->column : 0
-    );
+    sprintf(position_string, "%u:%u", (position->line) ? position->line : 0, (position->column) ? position->column : 0);
 
-    buffer_append(buffer, position_string);
-    buffer_append(buffer, ")");
+    hb_buffer_append(buffer, position_string);
+    hb_buffer_append(buffer, ")");
   } else {
-    buffer_append(buffer, "∅");
+    hb_buffer_append(buffer, "∅");
   }
 
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_token_property(
   token_T* token,
-  const char* name,
+  hb_string_T name,
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
   if (token != NULL && token->value != NULL) {
-    char* quoted = quoted_string(token->value);
-    buffer_append(buffer, quoted);
-    free(quoted);
+    hb_string_T quoted = quoted_string(hb_string(token->value));
+    hb_buffer_append_string(buffer, quoted);
+    free(quoted.data);
 
-    buffer_append(buffer, " ");
+    hb_buffer_append(buffer, " ");
     pretty_print_location(token->location, buffer);
   } else {
-    buffer_append(buffer, "∅");
+    hb_buffer_append(buffer, "∅");
   }
 
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_string_property(
-  const char* string,
-  const char* name,
+  hb_string_T string,
+  hb_string_T name,
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
-  const char* value = "∅";
-  char* escaped = NULL;
-  char* quoted = NULL;
+  hb_string_T value = hb_string("∅");
+  hb_string_T escaped = { .data = NULL, .length = 0 };
+  hb_string_T quoted;
 
-  if (string != NULL) {
+  if (!hb_string_is_empty(string)) {
     escaped = escape_newlines(string);
     quoted = quoted_string(escaped);
     value = quoted;
@@ -248,35 +246,8 @@ void pretty_print_string_property(
 
   pretty_print_property(name, value, indent, relative_indent, last_property, buffer);
 
-  if (string != NULL) {
-    if (escaped != NULL) { free(escaped); }
-    if (quoted != NULL) { free(quoted); }
+  if (!hb_string_is_empty(string)) {
+    if (!hb_string_is_empty(escaped)) { free(escaped.data); }
+    if (!hb_string_is_empty(quoted)) { free(quoted.data); }
   }
 }
-
-void pretty_print_analyzed_ruby(analyzed_ruby_T* analyzed, const char* source) {
-  printf(
-    "------------------------\nanalyzed (%p)\n------------------------\n%s\n------------------------\n  if:     %i\n "
-    " elsif:  %i\n  else:   %i\n  end:    %i\n  block:  %i\n  block_closing: %i\n  case:   %i\n  when:   %i\n  for:    "
-    "%i\n  while:  %i\n "
-    " until:  %i\n  begin:  %i\n  "
-    "rescue: %i\n  ensure: %i\n  unless: %i\n==================\n\n",
-    (void*) analyzed,
-    source,
-    analyzed->has_if_node,
-    analyzed->has_elsif_node,
-    analyzed->has_else_node,
-    analyzed->has_end,
-    analyzed->has_block_node,
-    analyzed->has_block_closing,
-    analyzed->has_case_node,
-    analyzed->has_when_node,
-    analyzed->has_for_node,
-    analyzed->has_while_node,
-    analyzed->has_until_node,
-    analyzed->has_begin_node,
-    analyzed->has_rescue_node,
-    analyzed->has_ensure_node,
-    analyzed->has_unless_node
-  );
-}

package/extension/libherb/pretty_print.h

@@ -3,91 +3,101 @@
 
 #include "analyzed_ruby.h"
 #include "ast_nodes.h"
-#include "buffer.h"
 #include "location.h"
+#include "util/hb_buffer.h"
 
 #include <stdbool.h>
 
-void pretty_print_indent(buffer_T* buffer, size_t indent);
-void pretty_print_newline(size_t indent, size_t relative_indent, buffer_T* buffer);
-void pretty_print_label(const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
+void pretty_print_indent(hb_buffer_T* buffer, size_t indent);
+void pretty_print_newline(size_t indent, size_t relative_indent, hb_buffer_T* buffer);
+void pretty_print_label(
+  hb_string_T name,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  hb_buffer_T* buffer
+);
 
 void pretty_print_position_property(
   position_T* position,
-  const char* name,
+  hb_string_T name,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
-void pretty_print_location(location_T* location, buffer_T* buffer);
+void pretty_print_location(location_T location, hb_buffer_T* buffer);
 
 void pretty_print_property(
-  const char* name,
-  const char* value,
+  hb_string_T name,
+  hb_string_T value,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_size_t_property(
   size_t value,
-  const char* name,
+  hb_string_T name,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_string_property(
-  const char* string,
-  const char* name,
+  hb_string_T string,
+  hb_string_T name,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_quoted_property(
-  const char* name,
-  const char* value,
+  hb_string_T name,
+  hb_string_T value,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_boolean_property(
-  const char* name,
+  hb_string_T name,
   bool value,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_token_property(
   token_T* token,
-  const char* name,
+  hb_string_T name,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_array(
-  const char* name,
-  array_T* array,
+  hb_string_T name,
+  hb_array_T* array,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
-void pretty_print_errors(AST_NODE_T* node, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
-
-void pretty_print_analyzed_ruby(analyzed_ruby_T* analyzed, const char* source);
+void pretty_print_errors(
+  AST_NODE_T* node,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  hb_buffer_T* buffer
+);
 
 #endif

package/extension/libherb/prism_helpers.c

@@ -16,15 +16,15 @@ const char* pm_error_level_to_string(pm_error_level_t level) {
   }
 }
 
-position_T* position_from_source_with_offset(const char* source, size_t offset) {
-  position_T* position = position_init(1, 0);
+position_T position_from_source_with_offset(const char* source, size_t offset) {
+  position_T position = { .line = 1, .column = 0 };
 
   for (size_t i = 0; i < offset; i++) {
     if (is_newline(source[i])) {
-      position->line++;
-      position->column = 0;
+      position.line++;
+      position.column = 0;
     } else {
-      position->column++;
+      position.column++;
     }
   }
 
@@ -40,8 +40,8 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
   size_t start_offset = (size_t) (error->location.start - parser->start);
   size_t end_offset = (size_t) (error->location.end - parser->start);
 
-  position_T* start = position_from_source_with_offset(source, start_offset);
-  position_T* end = position_from_source_with_offset(source, end_offset);
+  position_T start = position_from_source_with_offset(source, start_offset);
+  position_T end = position_from_source_with_offset(source, end_offset);
 
   return ruby_parse_error_init(
     error->message,

package/extension/libherb/prism_helpers.h

@@ -16,6 +16,6 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
   pm_parser_t* parser
 );
 
-position_T* position_from_source_with_offset(const char* source, size_t offset);
+position_T position_from_source_with_offset(const char* source, size_t offset);
 
 #endif

package/extension/libherb/range.c

@@ -1,38 +1,5 @@
 #include "include/range.h"
 
-size_t range_sizeof(void) {
-  return sizeof(range_T);
-}
-
-range_T* range_init(const size_t from, const size_t to) {
-  range_T* range = calloc(1, range_sizeof());
-
-  range->from = from;
-  range->to = to;
-
-  return range;
-}
-
-size_t range_from(const range_T* range) {
-  return range->from;
-}
-
-size_t range_to(const range_T* range) {
-  return range->to;
-}
-
-size_t range_length(range_T* range) {
-  return range_to(range) - range_from(range);
-}
-
-range_T* range_copy(range_T* range) {
-  if (!range) { return NULL; }
-
-  return range_init(range_from(range), range_to(range));
-}
-
-void range_free(range_T* range) {
-  if (range == NULL) { return; }
-
-  free(range);
+uint32_t range_length(range_T range) {
+  return range.to - range.from;
 }

package/extension/libherb/range.h

@@ -1,23 +1,14 @@
 #ifndef HERB_RANGE_H
 #define HERB_RANGE_H
 
+#include <stdint.h>
 #include <stdlib.h>
 
 typedef struct RANGE_STRUCT {
-  size_t from;
-  size_t to;
+  uint32_t from;
+  uint32_t to;
 } range_T;
 
-range_T* range_init(size_t from, size_t to);
-
-size_t range_from(const range_T* range);
-size_t range_to(const range_T* range);
-size_t range_length(range_T* range);
-
-range_T* range_copy(range_T* range);
-
-size_t range_sizeof(void);
-
-void range_free(range_T* range);
+uint32_t range_length(range_T range);
 
 #endif