herb 0.8.2-x86_64-linux-musl → 0.8.4-x86_64-linux-musl

data/src/extract.c

@@ -7,12 +7,12 @@
 #include <stdlib.h>
 #include <string.h>
 
-void herb_extract_ruby_to_buffer_with_semicolons(const char* source, hb_buffer_T* output) {
+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 < hb_array_size(tokens); i++) {
+  for (size_t i = 0; i < tokens->size; i++) {
     const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {
@@ -76,75 +76,9 @@ void herb_extract_ruby_to_buffer_with_semicolons(const char* source, hb_buffer_T
           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);
-
-          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: {
-        hb_buffer_append_whitespace(output, range_length(token->range));
-      }
-    }
-  }
-
-  herb_free_tokens(&tokens);
-}
-
-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 < hb_array_size(tokens); i++) {
-    const token_T* token = hb_array_get(tokens, i);
-
-    switch (token->type) {
-      case TOKEN_NEWLINE: {
-        hb_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;
-        }
-
-        hb_buffer_append_whitespace(output, range_length(token->range));
-        break;
-      }
-
-      case TOKEN_ERB_CONTENT: {
-        if (skip_erb_content == false) {
-          hb_buffer_append(output, token->value);
-        } else {
-          hb_buffer_append_whitespace(output, range_length(token->range));
-        }
-
-        break;
-      }
-
-      case TOKEN_ERB_END: {
-        skip_erb_content = false;
-
-        hb_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;
       }
 
@@ -160,7 +94,7 @@ 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) {
   hb_array_T* tokens = herb_lex(source);
 
-  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+  for (size_t i = 0; i < tokens->size; i++) {
     const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {
@@ -180,7 +114,7 @@ char* herb_extract_ruby_with_semicolons(const char* source) {
   hb_buffer_T output;
   hb_buffer_init(&output, strlen(source));
 
-  herb_extract_ruby_to_buffer_with_semicolons(source, &output);
+  herb_extract_ruby_to_buffer(source, &output);
 
   return output.value;
 }

data/src/herb.c

@@ -10,7 +10,7 @@
 #include <prism.h>
 #include <stdlib.h>
 
-hb_array_T* herb_lex(const char* source) {
+HERB_EXPORTED_FUNCTION hb_array_T* herb_lex(const char* source) {
   lexer_T lexer = { 0 };
   lexer_init(&lexer, source);
 
@@ -26,7 +26,7 @@ hb_array_T* herb_lex(const char* source) {
   return tokens;
 }
 
-AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
+HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
   if (!source) { source = ""; }
 
   lexer_T lexer = { 0 };
@@ -46,7 +46,7 @@ AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
   return document;
 }
 
-hb_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);
   hb_array_T* tokens = herb_lex(source);
 
@@ -55,10 +55,10 @@ hb_array_T* herb_lex_file(const char* path) {
   return tokens;
 }
 
-void herb_lex_to_buffer(const char* source, hb_buffer_T* output) {
+HERB_EXPORTED_FUNCTION void herb_lex_to_buffer(const char* source, hb_buffer_T* output) {
   hb_array_T* tokens = herb_lex(source);
 
-  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+  for (size_t i = 0; i < tokens->size; i++) {
     token_T* token = hb_array_get(tokens, i);
 
     hb_string_T type = token_to_string(token);
@@ -71,10 +71,10 @@ void herb_lex_to_buffer(const char* source, hb_buffer_T* output) {
   herb_free_tokens(&tokens);
 }
 
-void herb_free_tokens(hb_array_T** tokens) {
+HERB_EXPORTED_FUNCTION void herb_free_tokens(hb_array_T** tokens) {
   if (!tokens || !*tokens) { return; }
 
-  for (size_t i = 0; i < hb_array_size(*tokens); i++) {
+  for (size_t i = 0; i < (*tokens)->size; i++) {
     token_T* token = hb_array_get(*tokens, i);
     if (token) { token_free(token); }
   }
@@ -82,10 +82,10 @@ void herb_free_tokens(hb_array_T** 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/include/ast_node.h

@@ -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

data/src/include/extract.h

@@ -12,7 +12,6 @@ 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, 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);

data/src/include/herb.h

@@ -3,6 +3,7 @@
 
 #include "ast_node.h"
 #include "extract.h"
+#include "macros.h"
 #include "parser.h"
 #include "util/hb_array.h"
 #include "util/hb_buffer.h"
@@ -13,17 +14,17 @@
 extern "C" {
 #endif
 
-void herb_lex_to_buffer(const char* source, hb_buffer_T* output);
+HERB_EXPORTED_FUNCTION void herb_lex_to_buffer(const char* source, hb_buffer_T* output);
 
-hb_array_T* herb_lex(const char* source);
-hb_array_T* herb_lex_file(const char* path);
+HERB_EXPORTED_FUNCTION hb_array_T* herb_lex(const char* source);
+HERB_EXPORTED_FUNCTION hb_array_T* herb_lex_file(const char* path);
 
-AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options);
+HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options);
 
-const char* herb_version(void);
-const char* herb_prism_version(void);
+HERB_EXPORTED_FUNCTION const char* herb_version(void);
+HERB_EXPORTED_FUNCTION const char* herb_prism_version(void);
 
-void herb_free_tokens(hb_array_T** tokens);
+HERB_EXPORTED_FUNCTION void herb_free_tokens(hb_array_T** tokens);
 
 #ifdef __cplusplus
 }

data/src/include/macros.h

@@ -1,6 +1,14 @@
 #ifndef HERB_MACROS_H
 #define HERB_MACROS_H
 
+#ifndef HERB_EXPORTED_FUNCTION
+#  ifdef HERB_EXPORT_SYMBOLS
+#    define HERB_EXPORTED_FUNCTION __attribute__((__visibility__("default"))) extern
+#  else
+#    define HERB_EXPORTED_FUNCTION
+#  endif
+#endif
+
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))

data/src/include/position.h

@@ -1,6 +1,8 @@
 #ifndef HERB_POSITION_H
 #define HERB_POSITION_H
 
+#include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
 
 typedef struct POSITION_STRUCT {
@@ -8,4 +10,7 @@ typedef struct POSITION_STRUCT {
   uint32_t column;
 } position_T;
 
+position_T position_from_source_with_offset(const char* source, size_t offset);
+bool position_is_within_range(position_T position, position_T start, position_T end);
+
 #endif

data/src/include/prism_helpers.h

@@ -16,6 +16,10 @@ 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);
+RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error_with_positions(
+  const pm_diagnostic_t* error,
+  position_T start,
+  position_T end
+);
 
 #endif

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.2"
+#define HERB_VERSION "0.8.4"
 
 #endif

data/src/parser.c

@@ -1142,7 +1142,7 @@ static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, h
 static size_t find_matching_close_tag(hb_array_T* nodes, size_t start_idx, hb_string_T tag_name) {
   int depth = 0;
 
-  for (size_t i = start_idx + 1; i < hb_array_size(nodes); i++) {
+  for (size_t i = start_idx + 1; i < nodes->size; i++) {
     AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, i);
     if (node == NULL) { continue; }
 
@@ -1166,9 +1166,9 @@ static size_t find_matching_close_tag(hb_array_T* nodes, size_t start_idx, hb_st
 static hb_array_T* parser_build_elements_from_tags(hb_array_T* nodes, hb_array_T* errors);
 
 static hb_array_T* parser_build_elements_from_tags(hb_array_T* nodes, hb_array_T* errors) {
-  hb_array_T* result = hb_array_init(hb_array_size(nodes));
+  hb_array_T* result = hb_array_init(nodes->size);
 
-  for (size_t index = 0; index < hb_array_size(nodes); index++) {
+  for (size_t index = 0; index < nodes->size; index++) {
     AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, index);
     if (node == NULL) { continue; }
 
@@ -1179,7 +1179,7 @@ static hb_array_T* parser_build_elements_from_tags(hb_array_T* nodes, hb_array_T
       size_t close_index = find_matching_close_tag(nodes, index, tag_name);
 
       if (close_index == (size_t) -1) {
-        if (hb_array_size(open_tag->base.errors) == 0) {
+        if (open_tag->base.errors->size == 0) {
           append_missing_closing_tag_error(
             open_tag->tag_name,
             open_tag->base.location.start,
@@ -1223,7 +1223,7 @@ static hb_array_T* parser_build_elements_from_tags(hb_array_T* nodes, hb_array_T
       AST_HTML_CLOSE_TAG_NODE_T* close_tag = (AST_HTML_CLOSE_TAG_NODE_T*) node;
 
       if (!is_void_element(hb_string(close_tag->tag_name->value))) {
-        if (hb_array_size(close_tag->base.errors) == 0) {
+        if (close_tag->base.errors->size == 0) {
           append_missing_opening_tag_error(
             close_tag->tag_name,
             close_tag->base.location.start,
@@ -1297,7 +1297,7 @@ void herb_parser_deinit(parser_T* parser) {
 }
 
 void match_tags_in_node_array(hb_array_T* nodes, hb_array_T* errors) {
-  if (nodes == NULL || hb_array_size(nodes) == 0) { return; }
+  if (nodes == NULL || nodes->size == 0) { return; }
 
   hb_array_T* processed = parser_build_elements_from_tags(nodes, errors);
 

data/src/parser_helpers.c

@@ -19,7 +19,7 @@ void parser_push_open_tag(const parser_T* parser, token_T* tag_name) {
 }
 
 bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
-  if (hb_array_size(parser->open_tags_stack) == 0) { return false; }
+  if (parser->open_tags_stack->size == 0) { return false; }
 
   token_T* top_token = hb_array_last(parser->open_tags_stack);
   if (top_token == NULL || top_token->value == NULL) { return false; };
@@ -28,7 +28,7 @@ bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {
-  if (hb_array_size(parser->open_tags_stack) == 0) { return NULL; }
+  if (parser->open_tags_stack->size == 0) { return NULL; }
 
   return hb_array_pop(parser->open_tags_stack);
 }
@@ -42,7 +42,7 @@ token_T* parser_pop_open_tag(const parser_T* parser) {
 bool parser_in_svg_context(const parser_T* parser) {
   if (!parser || !parser->open_tags_stack) { return false; }
 
-  size_t stack_size = hb_array_size(parser->open_tags_stack);
+  size_t stack_size = parser->open_tags_stack->size;
 
   for (size_t i = 0; i < stack_size; i++) {
     token_T* tag = (token_T*) hb_array_get(parser->open_tags_stack, i);
@@ -191,7 +191,7 @@ void parser_handle_mismatched_tags(
   const AST_HTML_CLOSE_TAG_NODE_T* close_tag,
   hb_array_T* errors
 ) {
-  if (hb_array_size(parser->open_tags_stack) > 0) {
+  if (parser->open_tags_stack->size > 0) {
     token_T* expected_tag = hb_array_last(parser->open_tags_stack);
     token_T* actual_tag = close_tag->tag_name;
 

data/src/position.c

@@ -0,0 +1,27 @@
+#include "include/position.h"
+#include "include/util.h"
+
+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;
+    } else {
+      position.column++;
+    }
+  }
+
+  return position;
+}
+
+bool position_is_within_range(position_T position, position_T start, position_T end) {
+  if (position.line < start.line) { return false; }
+  if (position.line == start.line && position.column < start.column) { return false; }
+
+  if (position.line > end.line) { return false; }
+  if (position.line == end.line && position.column > end.column) { return false; }
+
+  return true;
+}

data/src/pretty_print.c

@@ -113,7 +113,7 @@ void pretty_print_array(
     return;
   }
 
-  if (hb_array_size(array) == 0) {
+  if (array->size == 0) {
     pretty_print_property(name, hb_string("[]"), indent, relative_indent, last_property, buffer);
 
     return;
@@ -124,17 +124,17 @@ void pretty_print_array(
   hb_buffer_append(buffer, "(");
 
   char count[16];
-  sprintf(count, "%zu", hb_array_size(array));
+  sprintf(count, "%zu", array->size);
   hb_buffer_append(buffer, count);
   hb_buffer_append(buffer, ")\n");
 
   if (indent < 20) {
-    for (size_t i = 0; i < hb_array_size(array); i++) {
+    for (size_t i = 0; i < array->size; i++) {
       AST_NODE_T* child = hb_array_get(array, i);
       pretty_print_indent(buffer, indent);
       pretty_print_indent(buffer, relative_indent + 1);
 
-      if (i == hb_array_size(array) - 1) {
+      if (i == array->size - 1) {
         hb_buffer_append(buffer, "└── ");
       } else {
         hb_buffer_append(buffer, "├── ");
@@ -142,7 +142,7 @@ void pretty_print_array(
 
       ast_pretty_print_node(child, indent + 1, relative_indent + 1, buffer);
 
-      if (i != hb_array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+      if (i != array->size - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
     }
   }
   hb_buffer_append(buffer, "\n");
@@ -155,7 +155,7 @@ void pretty_print_errors(
   const bool last_property,
   hb_buffer_T* buffer
 ) {
-  if (node->errors != NULL && hb_array_size(node->errors) > 0) {
+  if (node->errors != NULL && node->errors->size > 0) {
     error_pretty_print_array("errors", node->errors, indent, relative_indent, last_property, buffer);
     hb_buffer_append(buffer, "\n");
   }

data/src/prism_helpers.c

@@ -16,21 +16,6 @@ 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 = { .line = 1, .column = 0 };
-
-  for (size_t i = 0; i < offset; i++) {
-    if (is_newline(source[i])) {
-      position.line++;
-      position.column = 0;
-    } else {
-      position.column++;
-    }
-  }
-
-  return position;
-}
-
 RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
   const pm_diagnostic_t* error,
   const AST_NODE_T* node,
@@ -51,3 +36,17 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
     end
   );
 }
+
+RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error_with_positions(
+  const pm_diagnostic_t* error,
+  position_T start,
+  position_T end
+) {
+  return ruby_parse_error_init(
+    error->message,
+    pm_diagnostic_id_human(error->diag_id),
+    pm_error_level_to_string(error->level),
+    start,
+    end
+  );
+}

data/src/util/hb_system.c

@@ -1,13 +1,13 @@
 #include "../include/util/hb_system.h"
 
 #ifdef __linux__
-#define _GNU_SOURCE
+#  define _GNU_SOURCE
 #endif
 
 #ifdef HB_USE_MALLOC
-#include <stdlib.h>
+#  include <stdlib.h>
 #else
-#include <sys/mman.h>
+#  include <sys/mman.h>
 #endif
 
 void* hb_system_allocate_memory(size_t size) {