@herb-tools/node 0.7.5 → 0.8.0

package/extension/libherb/errors.h

@@ -1,15 +1,15 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.7.5/templates/src/include/errors.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.0/templates/src/include/errors.h.erb
 
 #ifndef HERB_ERRORS_H
 #define HERB_ERRORS_H
 
-#include "array.h"
-#include "buffer.h"
 #include "errors.h"
 #include "location.h"
 #include "position.h"
 #include "token.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
 
 typedef enum {
   UNEXPECTED_ERROR,
@@ -21,6 +21,8 @@ typedef enum {
   VOID_ELEMENT_CLOSING_TAG_ERROR,
   UNCLOSED_ELEMENT_ERROR,
   RUBY_PARSE_ERROR,
+  ERB_CONTROL_FLOW_SCOPE_ERROR,
+  MISSINGERB_END_TAG_ERROR,
 } error_type_T;
 
 typedef struct ERROR_STRUCT {
@@ -84,24 +86,38 @@ typedef struct {
   const char* level;
 } RUBY_PARSE_ERROR_T;
 
+typedef struct {
+  ERROR_T base;
+  const char* keyword;
+} ERB_CONTROL_FLOW_SCOPE_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  const char* keyword;
+} MISSINGERB_END_TAG_ERROR_T;
+
 UNEXPECTED_ERROR_T* unexpected_error_init(const char* description, const char* expected, const char* found, position_T start, position_T end);
-void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, array_T* errors);
+void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors);
 UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T start, position_T end);
-void append_unexpected_token_error(token_type_T expected_type, token_T* found, position_T start, position_T end, array_T* errors);
+void append_unexpected_token_error(token_type_T expected_type, token_T* found, position_T start, position_T end, hb_array_T* errors);
 MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error_init(token_T* closing_tag, position_T start, position_T end);
-void append_missing_opening_tag_error(token_T* closing_tag, position_T start, position_T end, array_T* errors);
+void append_missing_opening_tag_error(token_T* closing_tag, position_T start, position_T end, hb_array_T* errors);
 MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error_init(token_T* opening_tag, position_T start, position_T end);
-void append_missing_closing_tag_error(token_T* opening_tag, position_T start, position_T end, array_T* errors);
+void append_missing_closing_tag_error(token_T* opening_tag, position_T start, position_T end, hb_array_T* errors);
 TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error_init(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end);
-void append_tag_names_mismatch_error(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, array_T* errors);
+void append_tag_names_mismatch_error(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, hb_array_T* errors);
 QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error_init(token_T* opening_quote, token_T* closing_quote, position_T start, position_T end);
-void append_quotes_mismatch_error(token_T* opening_quote, token_T* closing_quote, position_T start, position_T end, array_T* errors);
+void append_quotes_mismatch_error(token_T* opening_quote, token_T* closing_quote, position_T start, position_T end, hb_array_T* errors);
 VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error_init(token_T* tag_name, const char* expected, const char* found, position_T start, position_T end);
-void append_void_element_closing_tag_error(token_T* tag_name, const char* expected, const char* found, position_T start, position_T end, array_T* errors);
+void append_void_element_closing_tag_error(token_T* tag_name, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors);
 UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error_init(token_T* opening_tag, position_T start, position_T end);
-void append_unclosed_element_error(token_T* opening_tag, position_T start, position_T end, array_T* errors);
+void append_unclosed_element_error(token_T* opening_tag, position_T start, position_T end, hb_array_T* errors);
 RUBY_PARSE_ERROR_T* ruby_parse_error_init(const char* error_message, const char* diagnostic_id, const char* level, position_T start, position_T end);
-void append_ruby_parse_error(const char* error_message, const char* diagnostic_id, const char* level, position_T start, position_T end, array_T* errors);
+void append_ruby_parse_error(const char* error_message, const char* diagnostic_id, const char* level, position_T start, position_T end, hb_array_T* errors);
+ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error_init(const char* keyword, position_T start, position_T end);
+void append_erb_control_flow_scope_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
+MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error_init(const char* keyword, position_T start, position_T end);
+void append_missingerb_end_tag_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
 
 void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 
@@ -115,11 +131,11 @@ const char* error_human_type(ERROR_T* error);
 
 void error_free(ERROR_T* error);
 
-void error_pretty_print(ERROR_T* error, size_t indent, size_t relative_indent, buffer_T* buffer);
+void error_pretty_print(ERROR_T* error, size_t indent, size_t relative_indent, hb_buffer_T* buffer);
 
 void error_pretty_print_array(
-  const char* name, array_T* array, size_t indent, size_t relative_indent, bool last_property,
-  buffer_T* buffer
+  const char* name, hb_array_T* array, size_t indent, size_t relative_indent, bool last_property,
+  hb_buffer_T* buffer
 );
 
 #endif

package/extension/libherb/extract.c

@@ -1,53 +1,107 @@
-#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_with_semicolons(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;
+
+        if (was_comment) {
+          hb_buffer_append_whitespace(output, range_length(token->range));
+          break;
+        }
+
+        bool needs_semicolon = false;
+        uint32_t current_line = token->location.end.line;
+
+        for (size_t j = i + 1; j < hb_array_size(tokens); j++) {
+          const token_T* next_token = hb_array_get(tokens, j);
 
-        buffer_append_char(output, ';');
-        buffer_append_whitespace(output, range_length(token->range) - 1);
+          if (next_token->type == TOKEN_NEWLINE) { break; }
+
+          if (next_token->type == TOKEN_ERB_START && next_token->location.start.line == current_line) {
+            needs_semicolon = true;
+            break;
+          }
+        }
+
+        if (needs_semicolon) {
+          hb_buffer_append_char(output, ' ');
+          hb_buffer_append_char(output, ';');
+          hb_buffer_append_whitespace(output, range_length(token->range) - 2);
+        } else {
+          hb_buffer_append_whitespace(output, range_length(token->range));
+        }
         break;
       }
 
       default: {
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
       }
     }
   }
@@ -55,16 +109,16 @@ void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* o
   herb_free_tokens(&tokens);
 }
 
-void herb_extract_ruby_to_buffer(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;
 
-  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;
       }
 
@@ -73,15 +127,15 @@ void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
           skip_erb_content = true;
         }
 
-        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);
+          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;
@@ -90,12 +144,12 @@ void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
       case TOKEN_ERB_END: {
         skip_erb_content = false;
 
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
         break;
       }
 
       default: {
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
       }
     }
   }
@@ -103,17 +157,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,8 +175,10 @@ 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; }
+
+  hb_buffer_T output;
+  hb_buffer_init(&output, strlen(source));
 
   herb_extract_ruby_to_buffer_with_semicolons(source, &output);
 
@@ -130,8 +186,10 @@ char* herb_extract_ruby_with_semicolons(const char* source) {
 }
 
 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;

package/extension/libherb/extract.h

@@ -1,18 +1,18 @@
 #ifndef HERB_EXTRACT_H
 #define HERB_EXTRACT_H
 
-#include "buffer.h"
+#include "util/hb_buffer.h"
 
 typedef enum {
   HERB_EXTRACT_LANGUAGE_RUBY,
   HERB_EXTRACT_LANGUAGE_HTML,
 } herb_extract_language_T;
 
-void herb_extract_ruby_to_buffer(const char* source, buffer_T* output);
-void herb_extract_html_to_buffer(const char* source, buffer_T* output);
+void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output);
+void herb_extract_html_to_buffer(const char* source, hb_buffer_T* output);
 
 char* herb_extract_ruby_with_semicolons(const char* source);
-void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output);
+void herb_extract_ruby_to_buffer_with_semicolons(const char* source, hb_buffer_T* output);
 
 char* herb_extract(const char* source, herb_extract_language_T language);
 char* herb_extract_from_file(const char* path, herb_extract_language_T language);

package/extension/libherb/herb.c

@@ -1,97 +1,85 @@
 #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);
+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);
+  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) {
+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);
+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) {
+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) {

package/extension/libherb/herb.h

@@ -1,11 +1,11 @@
 #ifndef HERB_H
 #define HERB_H
 
-#include "array.h"
 #include "ast_node.h"
-#include "buffer.h"
 #include "extract.h"
 #include "parser.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
 
 #include <stdint.h>
 
@@ -13,18 +13,17 @@
 extern "C" {
 #endif
 
-void herb_lex_to_buffer(const char* source, buffer_T* output);
-void herb_lex_json_to_buffer(const char* source, buffer_T* output);
+void herb_lex_to_buffer(const char* source, hb_buffer_T* output);
 
-array_T* herb_lex(const char* source);
-array_T* herb_lex_file(const char* path);
+hb_array_T* herb_lex(const char* source);
+hb_array_T* herb_lex_file(const char* path);
 
 AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options);
 
 const char* herb_version(void);
 const char* herb_prism_version(void);
 
-void herb_free_tokens(array_T** tokens);
+void herb_free_tokens(hb_array_T** tokens);
 
 #ifdef __cplusplus
 }