herb 0.7.5-arm64-darwin → 0.8.3-arm64-darwin

data/src/extract.c

@@ -1,101 +1,89 @@
-#include "include/array.h"
-#include "include/buffer.h"
 #include "include/herb.h"
 #include "include/io.h"
 #include "include/lexer.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_buffer.h"
 
 #include <stdlib.h>
+#include <string.h>
 
-void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
+void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output) {
+  hb_array_T* tokens = herb_lex(source);
   bool skip_erb_content = false;
+  bool is_comment_tag = false;
 
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    const token_T* token = array_get(tokens, i);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {
       case TOKEN_NEWLINE: {
-        buffer_append(output, token->value);
+        hb_buffer_append(output, token->value);
         break;
       }
 
       case TOKEN_ERB_START: {
-        if (strcmp(token->value, "<%#") == 0 || strcmp(token->value, "<%%") == 0 || strcmp(token->value, "<%%=") == 0) {
+        if (strcmp(token->value, "<%#") == 0) {
           skip_erb_content = true;
+          is_comment_tag = true;
+        } else if (strcmp(token->value, "<%%") == 0 || strcmp(token->value, "<%%=") == 0) {
+          skip_erb_content = true;
+          is_comment_tag = false;
+        } else {
+          skip_erb_content = false;
+          is_comment_tag = false;
         }
 
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
         break;
       }
 
       case TOKEN_ERB_CONTENT: {
         if (skip_erb_content == false) {
-          buffer_append(output, token->value);
+          bool is_inline_comment = false;
+
+          if (!is_comment_tag && token->value != NULL) {
+            const char* content = token->value;
+
+            while (*content == ' ' || *content == '\t') {
+              content++;
+            }
+
+            if (*content == '#' && token->location.start.line == token->location.end.line) {
+              is_comment_tag = true;
+              is_inline_comment = true;
+            }
+          }
+
+          if (is_inline_comment) {
+            hb_buffer_append_whitespace(output, range_length(token->range));
+          } else {
+            hb_buffer_append(output, token->value);
+          }
         } else {
-          buffer_append_whitespace(output, range_length(token->range));
+          hb_buffer_append_whitespace(output, range_length(token->range));
         }
 
         break;
       }
 
       case TOKEN_ERB_END: {
+        bool was_comment = is_comment_tag;
         skip_erb_content = false;
+        is_comment_tag = false;
 
-        buffer_append_char(output, ';');
-        buffer_append_whitespace(output, range_length(token->range) - 1);
-        break;
-      }
-
-      default: {
-        buffer_append_whitespace(output, range_length(token->range));
-      }
-    }
-  }
-
-  herb_free_tokens(&tokens);
-}
-
-void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
-  bool skip_erb_content = false;
-
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    const token_T* token = array_get(tokens, i);
-
-    switch (token->type) {
-      case TOKEN_NEWLINE: {
-        buffer_append(output, token->value);
-        break;
-      }
-
-      case TOKEN_ERB_START: {
-        if (strcmp(token->value, "<%#") == 0 || strcmp(token->value, "<%%") == 0 || strcmp(token->value, "<%%=") == 0) {
-          skip_erb_content = true;
+        if (was_comment) {
+          hb_buffer_append_whitespace(output, range_length(token->range));
+          break;
         }
 
-        buffer_append_whitespace(output, range_length(token->range));
-        break;
-      }
-
-      case TOKEN_ERB_CONTENT: {
-        if (skip_erb_content == false) {
-          buffer_append(output, token->value);
-        } else {
-          buffer_append_whitespace(output, range_length(token->range));
-        }
-
-        break;
-      }
-
-      case TOKEN_ERB_END: {
-        skip_erb_content = false;
-
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_char(output, ' ');
+        hb_buffer_append_char(output, ';');
+        hb_buffer_append_whitespace(output, range_length(token->range) - 2);
         break;
       }
 
       default: {
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
       }
     }
   }
@@ -103,17 +91,17 @@ void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
   herb_free_tokens(&tokens);
 }
 
-void herb_extract_html_to_buffer(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
+void herb_extract_html_to_buffer(const char* source, hb_buffer_T* output) {
+  hb_array_T* tokens = herb_lex(source);
 
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    const token_T* token = array_get(tokens, i);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {
       case TOKEN_ERB_START:
       case TOKEN_ERB_CONTENT:
-      case TOKEN_ERB_END: buffer_append_whitespace(output, range_length(token->range)); break;
-      default: buffer_append(output, token->value);
+      case TOKEN_ERB_END: hb_buffer_append_whitespace(output, range_length(token->range)); break;
+      default: hb_buffer_append(output, token->value);
     }
   }
 
@@ -121,17 +109,21 @@ void herb_extract_html_to_buffer(const char* source, buffer_T* output) {
 }
 
 char* herb_extract_ruby_with_semicolons(const char* source) {
-  buffer_T output;
-  buffer_init(&output);
+  if (!source) { return NULL; }
 
-  herb_extract_ruby_to_buffer_with_semicolons(source, &output);
+  hb_buffer_T output;
+  hb_buffer_init(&output, strlen(source));
+
+  herb_extract_ruby_to_buffer(source, &output);
 
   return output.value;
 }
 
 char* herb_extract(const char* source, const herb_extract_language_T language) {
-  buffer_T output;
-  buffer_init(&output);
+  if (!source) { return NULL; }
+
+  hb_buffer_T output;
+  hb_buffer_init(&output, strlen(source));
 
   switch (language) {
     case HERB_EXTRACT_LANGUAGE_RUBY: herb_extract_ruby_to_buffer(source, &output); break;

data/src/herb.c

@@ -1,103 +1,91 @@
 #include "include/herb.h"
-#include "include/array.h"
-#include "include/buffer.h"
 #include "include/io.h"
-#include "include/json.h"
 #include "include/lexer.h"
 #include "include/parser.h"
 #include "include/token.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_buffer.h"
 #include "include/version.h"
 
 #include <prism.h>
 #include <stdlib.h>
 
-array_T* herb_lex(const char* source) {
-  lexer_T* lexer = lexer_init(source);
+HERB_EXPORTED_FUNCTION hb_array_T* herb_lex(const char* source) {
+  lexer_T lexer = { 0 };
+  lexer_init(&lexer, source);
+
   token_T* token = NULL;
-  array_T* tokens = array_init(128);
+  hb_array_T* tokens = hb_array_init(128);
 
-  while ((token = lexer_next_token(lexer))->type != TOKEN_EOF) {
-    array_append(tokens, token);
+  while ((token = lexer_next_token(&lexer))->type != TOKEN_EOF) {
+    hb_array_append(tokens, token);
   }
 
-  array_append(tokens, token);
-
-  lexer_free(lexer);
+  hb_array_append(tokens, token);
 
   return tokens;
 }
 
-AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
-  lexer_T* lexer = lexer_init(source);
-  parser_T* parser = herb_parser_init(lexer, options);
+HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
+  if (!source) { source = ""; }
+
+  lexer_T lexer = { 0 };
+  lexer_init(&lexer, source);
+  parser_T parser = { 0 };
+
+  parser_options_T parser_options = HERB_DEFAULT_PARSER_OPTIONS;
 
-  AST_DOCUMENT_NODE_T* document = herb_parser_parse(parser);
+  if (options != NULL) { parser_options = *options; }
 
-  parser_free(parser);
+  herb_parser_init(&parser, &lexer, parser_options);
+
+  AST_DOCUMENT_NODE_T* document = herb_parser_parse(&parser);
+
+  herb_parser_deinit(&parser);
 
   return document;
 }
 
-array_T* herb_lex_file(const char* path) {
+HERB_EXPORTED_FUNCTION hb_array_T* herb_lex_file(const char* path) {
   char* source = herb_read_file(path);
-  array_T* tokens = herb_lex(source);
+  hb_array_T* tokens = herb_lex(source);
 
   free(source);
 
   return tokens;
 }
 
-void herb_lex_to_buffer(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
-
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    token_T* token = array_get(tokens, i);
+HERB_EXPORTED_FUNCTION void herb_lex_to_buffer(const char* source, hb_buffer_T* output) {
+  hb_array_T* tokens = herb_lex(source);
 
-    char* type = token_to_string(token);
-    buffer_append(output, type);
-    free(type);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    token_T* token = hb_array_get(tokens, i);
 
-    buffer_append(output, "\n");
-  }
-
-  herb_free_tokens(&tokens);
-}
+    hb_string_T type = token_to_string(token);
+    hb_buffer_append_string(output, type);
+    free(type.data);
 
-void herb_lex_json_to_buffer(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
-
-  buffer_T json = buffer_new();
-  json_start_root_array(&json);
-
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    token_T* token = array_get(tokens, i);
-    char* token_json = token_to_json(token);
-    json_add_raw_string(&json, token_json);
-    free(token_json);
+    hb_buffer_append(output, "\n");
   }
 
-  json_end_array(&json);
-  buffer_concat(output, &json);
-
-  buffer_free(&json);
   herb_free_tokens(&tokens);
 }
 
-void herb_free_tokens(array_T** tokens) {
+HERB_EXPORTED_FUNCTION void herb_free_tokens(hb_array_T** tokens) {
   if (!tokens || !*tokens) { return; }
 
-  for (size_t i = 0; i < array_size(*tokens); i++) {
-    token_T* token = array_get(*tokens, i);
+  for (size_t i = 0; i < hb_array_size(*tokens); i++) {
+    token_T* token = hb_array_get(*tokens, i);
     if (token) { token_free(token); }
   }
 
-  array_free(tokens);
+  hb_array_free(tokens);
 }
 
-const char* herb_version(void) {
+HERB_EXPORTED_FUNCTION const char* herb_version(void) {
   return HERB_VERSION;
 }
 
-const char* herb_prism_version(void) {
+HERB_EXPORTED_FUNCTION const char* herb_prism_version(void) {
   return PRISM_VERSION;
 }

data/src/html_util.c

@@ -1,76 +1,31 @@
 #include "include/html_util.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <ctype.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
-#include <strings.h>
 
 // https://developer.mozilla.org/en-US/docs/Glossary/Void_element
-bool is_void_element(const char* tag_name) {
-  if (tag_name == NULL) { return false; }
+bool is_void_element(hb_string_T tag_name) {
+  if (hb_string_is_empty(tag_name)) { return false; }
 
-  const char* void_tags[] = {
-    "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr",
+  hb_string_T void_tags[14] = {
+    hb_string("area"),  hb_string("base"),   hb_string("br"),    hb_string("col"),  hb_string("embed"),
+    hb_string("hr"),    hb_string("img"),    hb_string("input"), hb_string("link"), hb_string("meta"),
+    hb_string("param"), hb_string("source"), hb_string("track"), hb_string("wbr"),
   };
 
-  for (size_t i = 0; i < sizeof(void_tags) / sizeof(char*); i++) {
-    if (strcasecmp(tag_name, void_tags[i]) == 0) { return true; }
-  }
-
-  return false;
-}
-
-bool is_html4_void_element(const char* tag_name) {
-  if (tag_name == NULL) { return false; }
-
-  const char* html4_void_tags[] = {
-    "basefont", "bgsound", "command", "frame", "image", "keygen",
-  };
-
-  for (size_t i = 0; i < sizeof(html4_void_tags) / sizeof(char*); i++) {
-    if (strcasecmp(tag_name, html4_void_tags[i]) == 0) { return true; }
+  for (size_t i = 0; i < 14; i++) {
+    if (hb_string_equals_case_insensitive(tag_name, void_tags[i])) { return true; }
   }
 
   return false;
 }
 
-/**
- * @brief Creates an opening HTML tag string like "<tag_name>"
- *
- * @param tag_name The name of the HTML tag to be enclosed in a opening tag
- * @return A newly allocated string containing the opening tag, or NULL if memory allocation fails
- * @note The caller is responsible for freeing the returned string
- *
- * Example:
- * @code
- * char* tag = html_opening_tag_string("div");
- * if (tag) {
- *   printf("%s\n", tag); // Prints: <div>
- *   free(tag);
- * }
- * @endcode
- */
-char* html_opening_tag_string(const char* tag_name) {
-  if (tag_name == NULL) { return herb_strdup("<>"); }
-
-  size_t length = strlen(tag_name);
-  char* result = (char*) malloc(length + 3); // +3 for '<', '>', and '\0'
-
-  if (result == NULL) { return NULL; }
-
-  result[0] = '<';
-
-  memcpy(result + 1, tag_name, length);
-
-  result[length + 1] = '>';
-  result[length + 2] = '\0';
-
-  return result;
-}
-
 /**
  * @brief Creates a closing HTML tag string like "</tag_name>"
  *
@@ -80,30 +35,22 @@ char* html_opening_tag_string(const char* tag_name) {
  *
  * Example:
  * @code
- * char* tag = html_closing_tag_string("div");
- * if (tag) {
- *   printf("%s\n", tag); // Prints: </div>
- *   free(tag);
- * }
+ * hb_string_T tag = html_closing_tag_string(hb_string("div"));
+ *
+ * printf("%.*s\n", tag.length, tag.data); // Prints: </div>
+ * free(tag.data);
  * @endcode
  */
-char* html_closing_tag_string(const char* tag_name) {
-  if (tag_name == NULL) { return herb_strdup("</>"); }
+hb_string_T html_closing_tag_string(hb_string_T tag_name) {
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, tag_name.length + 3);
 
-  size_t length = strlen(tag_name);
-  char* result = (char*) malloc(length + 4); // +4 for '<', '/', '>', and '\0'
+  hb_buffer_append_char(&buffer, '<');
+  hb_buffer_append_char(&buffer, '/');
+  hb_buffer_append_string(&buffer, tag_name);
+  hb_buffer_append_char(&buffer, '>');
 
-  if (result == NULL) { return NULL; }
-
-  result[0] = '<';
-  result[1] = '/';
-
-  memcpy(result + 2, tag_name, length);
-
-  result[length + 2] = '>';
-  result[length + 3] = '\0';
-
-  return result;
+  return hb_string(buffer.value);
 }
 
 /**
@@ -115,29 +62,20 @@ char* html_closing_tag_string(const char* tag_name) {
  *
  * Example:
  * @code
- * char* tag = html_self_closing_tag_string("br");
- * if (tag) {
- *   printf("%s\n", tag); // Prints: <br />
- *   free(tag);
- * }
+ * hb_string_T tag = html_self_closing_tag_string(hb_string("br"));
+ * printf("%.*s\n", tag.length, tag.data); // Prints: <br />
+ * free(tag);
  * @endcode
  */
-char* html_self_closing_tag_string(const char* tag_name) {
-  if (tag_name == NULL) { return herb_strdup("< />"); }
-
-  size_t length = strlen(tag_name);
-  char* result = (char*) malloc(length + 5); // +5 for '<', ' ', '/', '>', and '\0'
-
-  if (result == NULL) { return NULL; }
-
-  result[0] = '<';
-
-  memcpy(result + 1, tag_name, length);
+hb_string_T html_self_closing_tag_string(hb_string_T tag_name) {
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, tag_name.length + 4);
 
-  result[length + 1] = ' ';
-  result[length + 2] = '/';
-  result[length + 3] = '>';
-  result[length + 4] = '\0';
+  hb_buffer_append_char(&buffer, '<');
+  hb_buffer_append_string(&buffer, tag_name);
+  hb_buffer_append_char(&buffer, ' ');
+  hb_buffer_append_char(&buffer, '/');
+  hb_buffer_append_char(&buffer, '>');
 
-  return result;
+  return hb_string(buffer.value);
 }

data/src/include/analyze.h

@@ -2,13 +2,13 @@
 #define HERB_ANALYZE_H
 
 #include "analyzed_ruby.h"
-#include "array.h"
 #include "ast_nodes.h"
+#include "util/hb_array.h"
 
 typedef struct ANALYZE_RUBY_CONTEXT_STRUCT {
   AST_DOCUMENT_NODE_T* document;
   AST_NODE_T* parent;
-  array_T* ruby_context_stack;
+  hb_array_T* ruby_context_stack;
 } analyze_ruby_context_T;
 
 typedef enum {
@@ -33,7 +33,15 @@ typedef enum {
   CONTROL_TYPE_UNKNOWN
 } control_type_t;
 
+typedef struct {
+  int loop_depth;
+  int rescue_depth;
+} invalid_erb_context_T;
+
 void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source);
 void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source);
 
+hb_array_T* rewrite_node_array(AST_NODE_T* node, hb_array_T* array, analyze_ruby_context_T* context);
+bool transform_erb_nodes(const AST_NODE_T* node, void* data);
+
 #endif

data/src/include/analyze_helpers.h

@@ -5,6 +5,7 @@
 #include <stdbool.h>
 
 #include "analyzed_ruby.h"
+#include "ast_node.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed);
 bool has_elsif_node(analyzed_ruby_T* analyzed);
@@ -46,4 +47,6 @@ bool search_rescue_nodes(analyzed_ruby_T* analyzed);
 bool search_ensure_nodes(analyzed_ruby_T* analyzed);
 bool search_yield_nodes(const pm_node_t* node, void* data);
 
+void check_erb_node_for_missing_end(const AST_NODE_T* node);
+
 #endif

data/src/include/analyzed_ruby.h

@@ -1,7 +1,8 @@
 #ifndef HERB_ANALYZED_RUBY_H
 #define HERB_ANALYZED_RUBY_H
 
-#include "array.h"
+#include "util/hb_array.h"
+#include "util/hb_string.h"
 
 #include <prism.h>
 
@@ -30,7 +31,8 @@ typedef struct ANALYZED_RUBY_STRUCT {
   bool has_yield_node;
 } analyzed_ruby_T;
 
-analyzed_ruby_T* init_analyzed_ruby(char* source);
+analyzed_ruby_T* init_analyzed_ruby(hb_string_T source);
 void free_analyzed_ruby(analyzed_ruby_T* analyzed);
+const char* erb_keyword_from_analyzed_ruby(const analyzed_ruby_T* analyzed);
 
 #endif

data/src/include/ast_node.h

@@ -6,7 +6,7 @@
 #include "position.h"
 #include "token_struct.h"
 
-void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T start, position_T end, array_T* errors);
+void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T start, position_T end, hb_array_T* errors);
 void ast_node_free(AST_NODE_T* node);
 
 AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token);
@@ -22,7 +22,7 @@ void ast_node_set_start(AST_NODE_T* node, position_T position);
 void ast_node_set_end(AST_NODE_T* node, position_T position);
 
 size_t ast_node_errors_count(const AST_NODE_T* node);
-array_T* ast_node_errors(const AST_NODE_T* node);
+hb_array_T* ast_node_errors(const AST_NODE_T* node);
 void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error);
 
 void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token);
@@ -32,4 +32,6 @@ void ast_node_set_positions_from_token(AST_NODE_T* node, const token_T* token);
 
 bool ast_node_is(const AST_NODE_T* node, ast_node_type_T type);
 
+AST_NODE_T* find_erb_content_at_offset(AST_DOCUMENT_NODE_T* document, const char* source, size_t offset);
+
 #endif