herb 0.8.0-x86_64-linux-musl → 0.8.3-x86_64-linux-musl

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d45baee381e42c61b1d7dad531894f819493df04fcc92e1aa8ca391ea4f940d
-  data.tar.gz: 6ff4407abde435b81f7ac97c36e84dd006f96c8afa3be27e26266d17cdd81e21
+  metadata.gz: ca866c43027348e063e3d6fbd56dfb618f0e85456fc9d9dce2f00cbaa502687d
+  data.tar.gz: 1b9bd456f2510973c71c476fa5053068ed79f235a9455d7eeea35ee2bb9fd5c3
 SHA512:
-  metadata.gz: d4d7555a050440a19c1654c0c6ea9c98347b2bc7a46d74f006b289e93aa2b6d067e22570a41b5b5fc61c71f0cc80ba9602cd271e91d9a7e654cb4ac3e228139a
-  data.tar.gz: b1cae0e1d0c6e3e53602fdc772f65e5a5fd11afa1e1096bcaa1c05defdf101dce655747fb98ccdd7c4268d30d88a93bfa6263518b9f9ece00c3734c62675d322
+  metadata.gz: 2b5e67ecdba473eed52047f412070684ad00262163ce43a9768f2a6b981baff71f69f0f42033500d9b1855012e6cad1fc0770553f0915c1e99af7445bb0eef4f
+  data.tar.gz: 485271294cf64c46c6abc8ee42a2c4583486279fe335ba646b6715f5edf81ed64eb5e6e5159d5216b928c12f60715655e75661df2524e1311e40c5db3ea17968

data/README.md

@@ -10,8 +10,13 @@
 
 <p align="center">
   <a href="https://rubygems.org/gems/herb"><img alt="Gem Version" src="https://img.shields.io/gem/v/herb"></a>
+  <a href="https://crates.io/crates/herb"><img alt="Crates.io Version" src="https://img.shields.io/crates/v/herb"></a>
+  <a href="https://www.npmjs.com/package/@herb-tools/core"><img alt="npm Version" src="https://img.shields.io/npm/v/@herb-tools/core"></a>
+  <a href="https://marketplace.visualstudio.com/items?itemName=marcoroth.herb-lsp"><img alt="VS Code Marketplace" src="https://img.shields.io/visual-studio-marketplace/v/marcoroth.herb-lsp"></a>
+  <a href="https://open-vsx.org/extension/marcoroth/herb-lsp"><img alt="Open VSX" src="https://img.shields.io/open-vsx/v/marcoroth/herb-lsp"></a>
   <a href="https://herb-tools.dev"><img alt="Documentation" src="https://img.shields.io/badge/documentation-available-green"></a>
   <a href="https://herb-tools.dev/playground"><img alt="playground" src="https://img.shields.io/badge/playground-Try_it_in_the_browser!-green"></a>
+  <a href="https://pkg.pr.new/~/marcoroth/herb"><img alt="pkg.pr.new" src="https://pkg.pr.new/badge/marcoroth/herb"></a>
   <a href="https://github.com/marcoroth/herb/blob/main/LICENSE.txt"><img alt="License" src="https://img.shields.io/github/license/marcoroth/herb"></a>
   <a href="https://github.com/marcoroth/herb/issues"><img alt="Issues" src="https://img.shields.io/github/issues/marcoroth/herb"></a>
 </p>
@@ -99,7 +104,7 @@ Commands:
   bundle exec herb version            Prints the versions of the Herb gem and the libherb library.
 ```
 
-For detailed information, like how you can use Herb programatically in Ruby and JavaScript, visit the [documentation site](https://herb-tools.dev/bindings/ruby/reference).
+For detailed information, like how you can use Herb programmatically in Ruby and JavaScript, visit the [documentation site](https://herb-tools.dev/bindings/ruby/reference).
 
 
 ## Background and Talk

data/ext/herb/extconf.rb

@@ -24,7 +24,7 @@ $INCFLAGS << " -I#{include_path}"
 $INCFLAGS << " -I#{prism_src_path}"
 $INCFLAGS << " -I#{prism_src_path}/util"
 
-$CFLAGS << " -DPRISM_EXPORT_SYMBOLS=static "
+$CFLAGS << " -fvisibility=hidden"
 
 herb_src_files = Dir.glob("#{$srcdir}/../../src/**/*.c").map { |file| file.delete_prefix("../../../../ext/herb/") }.sort
 

data/ext/herb/extension.c

@@ -124,7 +124,7 @@ static VALUE Herb_version(VALUE self) {
   return rb_funcall(rb_mKernel, rb_intern("sprintf"), 4, format_string, gem_version, libprism_version, libherb_version);
 }
 
-void Init_herb(void) {
+__attribute__((__visibility__("default"))) void Init_herb(void) {
   mHerb = rb_define_module("Herb");
   cPosition = rb_define_class_under(mHerb, "Position", rb_cObject);
   cLocation = rb_define_class_under(mHerb, "Location", rb_cObject);

data/ext/herb/nodes.c

@@ -464,7 +464,7 @@ static VALUE rb_erb_content_node_from_c_struct(AST_ERB_CONTENT_NODE_T* erb_conte
   VALUE erb_content_node_tag_opening = rb_token_from_c_struct(erb_content_node->tag_opening);
   VALUE erb_content_node_content = rb_token_from_c_struct(erb_content_node->content);
   VALUE erb_content_node_tag_closing = rb_token_from_c_struct(erb_content_node->tag_closing);
-  /* #<Herb::Template::AnalyzedRubyField:0x00007f63faa57188 @name="analyzed_ruby", @options={kind: nil}> */
+  /* #<Herb::Template::AnalyzedRubyField:0x00007f305b7942e8 @name="analyzed_ruby", @options={kind: nil}> */
   VALUE erb_content_node_analyzed_ruby = Qnil;
   VALUE erb_content_node_parsed = (erb_content_node->parsed) ? Qtrue : Qfalse;
   VALUE erb_content_node_valid = (erb_content_node->valid) ? Qtrue : Qfalse;

data/lib/herb/engine/error_formatter.rb

@@ -98,16 +98,24 @@ module Herb
       def format_error(error, number)
         output = String.new
 
-        output << "Error ##{number}: #{error.class.name.split("::").last.gsub(/Error$/, "")}\n"
+        error_name = if error.is_a?(Hash)
+                       error[:code] || "UnknownError"
+                     else
+                       error.class.name.split("::").last.gsub(/Error$/, "")
+                     end
+
+        output << "Error ##{number}: #{error_name}\n"
         output << ("-" * 40) << "\n"
 
-        if error.location
+        location = error.is_a?(Hash) ? error[:location] : error.location
+        if location
           output << "  File: #{@filename}\n"
-          output << "  Location: Line #{error.location.start.line}, Column #{error.location.start.column}\n"
+          output << "  Location: Line #{location.start.line}, Column #{location.start.column}\n"
         end
 
-        output << "  Message: #{error.message}\n\n"
-        output << format_source_context(error) if error.location
+        error_message = error.is_a?(Hash) ? error[:message] : error.message
+        output << "  Message: #{error_message}\n\n"
+        output << format_source_context(error) if location
         output << format_error_details(error)
 
         output

data/lib/herb/version.rb

@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.8.0"
+  VERSION = "0.8.3"
 end

data/src/analyze.c

@@ -90,6 +90,138 @@ static size_t process_subsequent_block(
   control_type_t parent_type
 );
 
+typedef struct {
+  control_type_t type;
+  uint32_t offset;
+  bool found;
+} earliest_control_keyword_t;
+
+typedef struct {
+  earliest_control_keyword_t* result;
+  const uint8_t* source_start;
+} location_walker_context_t;
+
+static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* data) {
+  if (!node) { return true; }
+
+  location_walker_context_t* context = (location_walker_context_t*) data;
+  earliest_control_keyword_t* result = context->result;
+
+  control_type_t current_type = CONTROL_TYPE_UNKNOWN;
+  uint32_t keyword_offset = UINT32_MAX;
+
+  switch (node->type) {
+    case PM_IF_NODE: {
+      pm_if_node_t* if_node = (pm_if_node_t*) node;
+      current_type = CONTROL_TYPE_IF;
+      keyword_offset = (uint32_t) (if_node->if_keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_UNLESS_NODE: {
+      pm_unless_node_t* unless_node = (pm_unless_node_t*) node;
+      current_type = CONTROL_TYPE_UNLESS;
+      keyword_offset = (uint32_t) (unless_node->keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_CASE_NODE: {
+      pm_case_node_t* case_node = (pm_case_node_t*) node;
+      current_type = CONTROL_TYPE_CASE;
+      keyword_offset = (uint32_t) (case_node->case_keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_CASE_MATCH_NODE: {
+      pm_case_match_node_t* case_match_node = (pm_case_match_node_t*) node;
+      current_type = CONTROL_TYPE_CASE_MATCH;
+      keyword_offset = (uint32_t) (case_match_node->case_keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_WHILE_NODE: {
+      pm_while_node_t* while_node = (pm_while_node_t*) node;
+      current_type = CONTROL_TYPE_WHILE;
+      keyword_offset = (uint32_t) (while_node->keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_UNTIL_NODE: {
+      pm_until_node_t* until_node = (pm_until_node_t*) node;
+      current_type = CONTROL_TYPE_UNTIL;
+      keyword_offset = (uint32_t) (until_node->keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_FOR_NODE: {
+      pm_for_node_t* for_node = (pm_for_node_t*) node;
+      current_type = CONTROL_TYPE_FOR;
+      keyword_offset = (uint32_t) (for_node->for_keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_BEGIN_NODE: {
+      pm_begin_node_t* begin_node = (pm_begin_node_t*) node;
+      current_type = CONTROL_TYPE_BEGIN;
+
+      if (begin_node->begin_keyword_loc.start != NULL) {
+        keyword_offset = (uint32_t) (begin_node->begin_keyword_loc.start - context->source_start);
+      } else {
+        keyword_offset = (uint32_t) (node->location.start - context->source_start);
+      }
+      break;
+    }
+
+    case PM_YIELD_NODE: {
+      current_type = CONTROL_TYPE_YIELD;
+      keyword_offset = (uint32_t) (node->location.start - context->source_start);
+      break;
+    }
+
+    case PM_CALL_NODE: {
+      pm_call_node_t* call = (pm_call_node_t*) node;
+
+      if (call->block != NULL) {
+        current_type = CONTROL_TYPE_BLOCK;
+        keyword_offset = (uint32_t) (node->location.start - context->source_start);
+      }
+      break;
+    }
+
+    case PM_NEXT_NODE:
+    case PM_BREAK_NODE:
+    case PM_RETURN_NODE: {
+      current_type = CONTROL_TYPE_UNKNOWN;
+      keyword_offset = (uint32_t) (node->location.start - context->source_start);
+      break;
+    }
+
+    default: break;
+  }
+
+  if (keyword_offset != UINT32_MAX) {
+    if (!result->found || keyword_offset < result->offset) {
+      result->type = current_type;
+      result->offset = keyword_offset;
+      result->found = true;
+    }
+  }
+
+  return true;
+}
+
+static control_type_t find_earliest_control_keyword(pm_node_t* root, const uint8_t* source_start) {
+  if (!root) { return CONTROL_TYPE_UNKNOWN; }
+
+  earliest_control_keyword_t result = { .type = CONTROL_TYPE_UNKNOWN, .offset = UINT32_MAX, .found = false };
+
+  location_walker_context_t context = { .result = &result, .source_start = source_start };
+
+  pm_visit_node(root, find_earliest_control_keyword_walker, &context);
+
+  return result.found ? result.type : CONTROL_TYPE_UNKNOWN;
+}
+
 static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
   if (!erb_node || erb_node->base.type != AST_ERB_CONTENT_NODE) { return CONTROL_TYPE_UNKNOWN; }
 
@@ -99,26 +231,18 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
 
   if (ruby->valid) { return CONTROL_TYPE_UNKNOWN; }
 
-  if (has_block_node(ruby)) { return CONTROL_TYPE_BLOCK; }
-  if (has_if_node(ruby)) { return CONTROL_TYPE_IF; }
+  pm_node_t* root = ruby->root;
+
   if (has_elsif_node(ruby)) { return CONTROL_TYPE_ELSIF; }
   if (has_else_node(ruby)) { return CONTROL_TYPE_ELSE; }
   if (has_end(ruby)) { return CONTROL_TYPE_END; }
-  if (has_case_node(ruby)) { return CONTROL_TYPE_CASE; }
-  if (has_case_match_node(ruby)) { return CONTROL_TYPE_CASE_MATCH; }
   if (has_when_node(ruby)) { return CONTROL_TYPE_WHEN; }
   if (has_in_node(ruby)) { return CONTROL_TYPE_IN; }
-  if (has_begin_node(ruby)) { return CONTROL_TYPE_BEGIN; }
   if (has_rescue_node(ruby)) { return CONTROL_TYPE_RESCUE; }
   if (has_ensure_node(ruby)) { return CONTROL_TYPE_ENSURE; }
-  if (has_unless_node(ruby)) { return CONTROL_TYPE_UNLESS; }
-  if (has_while_node(ruby)) { return CONTROL_TYPE_WHILE; }
-  if (has_until_node(ruby)) { return CONTROL_TYPE_UNTIL; }
-  if (has_for_node(ruby)) { return CONTROL_TYPE_FOR; }
   if (has_block_closing(ruby)) { return CONTROL_TYPE_BLOCK_CLOSE; }
-  if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
 
-  return CONTROL_TYPE_UNKNOWN;
+  return find_earliest_control_keyword(root, ruby->parser.start);
 }
 
 static bool is_subsequent_type(control_type_t parent_type, control_type_t child_type) {
@@ -164,7 +288,7 @@ static AST_NODE_T* create_control_node(
   if (end_node) {
     end_position = end_node->base.location.end;
   } else if (children && hb_array_size(children) > 0) {
-    AST_NODE_T* last_child = hb_array_get(children, hb_array_size(children) - 1);
+    AST_NODE_T* last_child = hb_array_last(children);
     end_position = last_child->location.end;
   } else if (subsequent) {
     end_position = subsequent->location.end;
@@ -515,21 +639,7 @@ static size_t process_control_structure(
 
           index++;
 
-          while (index < hb_array_size(array)) {
-            AST_NODE_T* child = hb_array_get(array, index);
-
-            if (!child) { break; }
-
-            if (child->type == AST_ERB_CONTENT_NODE) {
-              AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
-              control_type_t child_type = detect_control_type(child_erb);
-
-              if (child_type == CONTROL_TYPE_END) { break; }
-            }
-
-            hb_array_append(else_children, child);
-            index++;
-          }
+          index = process_block_children(node, array, index, else_children, context, initial_type);
 
           hb_array_T* else_errors = next_erb->base.errors;
           next_erb->base.errors = NULL;
@@ -585,10 +695,10 @@ static size_t process_control_structure(
     } else if (else_clause) {
       end_position = else_clause->base.location.end;
     } else if (hb_array_size(when_conditions) > 0) {
-      AST_NODE_T* last_when = hb_array_get(when_conditions, hb_array_size(when_conditions) - 1);
+      AST_NODE_T* last_when = hb_array_last(when_conditions);
       end_position = last_when->location.end;
     } else if (hb_array_size(in_conditions) > 0) {
-      AST_NODE_T* last_in = hb_array_get(in_conditions, hb_array_size(in_conditions) - 1);
+      AST_NODE_T* last_in = hb_array_last(in_conditions);
       end_position = last_in->location.end;
     }
 
@@ -677,21 +787,7 @@ static size_t process_control_structure(
 
           index++;
 
-          while (index < hb_array_size(array)) {
-            AST_NODE_T* child = hb_array_get(array, index);
-
-            if (!child) { break; }
-
-            if (child->type == AST_ERB_CONTENT_NODE) {
-              AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
-              control_type_t child_type = detect_control_type(child_erb);
-
-              if (child_type == CONTROL_TYPE_ENSURE || child_type == CONTROL_TYPE_END) { break; }
-            }
-
-            hb_array_append(else_children, child);
-            index++;
-          }
+          index = process_block_children(node, array, index, else_children, context, initial_type);
 
           hb_array_T* else_errors = next_erb->base.errors;
           next_erb->base.errors = NULL;
@@ -859,7 +955,7 @@ static size_t process_control_structure(
     if (end_node) {
       end_position = end_node->base.location.end;
     } else if (children && hb_array_size(children) > 0) {
-      AST_NODE_T* last_child = hb_array_get(children, hb_array_size(children) - 1);
+      AST_NODE_T* last_child = hb_array_last(children);
       end_position = last_child->location.end;
     }
 
@@ -1043,7 +1139,7 @@ static size_t process_block_children(
       hb_array_T* temp_array = hb_array_init(1);
       size_t new_index = process_control_structure(node, array, index, temp_array, context, child_type);
 
-      if (hb_array_size(temp_array) > 0) { hb_array_append(children_array, hb_array_get(temp_array, 0)); }
+      if (hb_array_size(temp_array) > 0) { hb_array_append(children_array, hb_array_first(temp_array)); }
 
       hb_array_free(&temp_array);
 
@@ -1313,6 +1409,35 @@ void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source)
   free(invalid_context);
 }
 
+static void parse_erb_content_errors(AST_NODE_T* erb_node, const char* source) {
+  if (!erb_node || erb_node->type != AST_ERB_CONTENT_NODE) { return; }
+  AST_ERB_CONTENT_NODE_T* content_node = (AST_ERB_CONTENT_NODE_T*) erb_node;
+
+  if (!content_node->content || !content_node->content->value) { return; }
+
+  const char* content = content_node->content->value;
+  if (strlen(content) == 0) { return; }
+
+  pm_parser_t parser;
+  pm_options_t options = { 0, .partial_script = true };
+  pm_parser_init(&parser, (const uint8_t*) content, strlen(content), &options);
+
+  pm_node_t* root = pm_parse(&parser);
+
+  const pm_diagnostic_t* error = (const pm_diagnostic_t*) parser.error_list.head;
+
+  if (error != NULL) {
+    RUBY_PARSE_ERROR_T* parse_error =
+      ruby_parse_error_from_prism_error_with_positions(error, erb_node->location.start, erb_node->location.end);
+
+    hb_array_append(erb_node->errors, parse_error);
+  }
+
+  pm_node_destroy(&parser, root);
+  pm_parser_free(&parser);
+  pm_options_free(&options);
+}
+
 void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source) {
   char* extracted_ruby = herb_extract_ruby_with_semicolons(source);
 
@@ -1326,6 +1451,19 @@ void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source
 
   for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) parser.error_list.head; error != NULL;
        error = (const pm_diagnostic_t*) error->node.next) {
+    size_t error_offset = (size_t) (error->location.start - parser.start);
+
+    if (strstr(error->message, "unexpected ';'") != NULL) {
+      if (error_offset < strlen(extracted_ruby) && extracted_ruby[error_offset] == ';') {
+        if (error_offset >= strlen(source) || source[error_offset] != ';') {
+          AST_NODE_T* erb_node = find_erb_content_at_offset(document, source, error_offset);
+
+          if (erb_node) { parse_erb_content_errors(erb_node, source); }
+
+          continue;
+        }
+      }
+    }
 
     RUBY_PARSE_ERROR_T* parse_error = ruby_parse_error_from_prism_error(error, (AST_NODE_T*) document, source, &parser);
     hb_array_append(document->base.errors, parse_error);

data/src/analyze_helpers.c

@@ -110,12 +110,20 @@ bool search_block_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
   if (node->type == PM_BLOCK_NODE) {
-    analyzed->has_block_node = true;
-    return true;
-  } else {
-    pm_visit_child_nodes(node, search_block_nodes, analyzed);
+    pm_block_node_t* block_node = (pm_block_node_t*) node;
+
+    size_t opening_length = block_node->opening_loc.end - block_node->opening_loc.start;
+
+    if ((opening_length == 2 && block_node->opening_loc.start[0] == 'd' && block_node->opening_loc.start[1] == 'o')
+        || (opening_length == 1 && block_node->opening_loc.start[0] == '{')) {
+      analyzed->has_block_node = true;
+
+      return true;
+    }
   }
 
+  pm_visit_child_nodes(node, search_block_nodes, analyzed);
+
   return false;
 }
 

data/src/ast_node.c

@@ -1,8 +1,10 @@
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
+#include "include/position.h"
 #include "include/token.h"
 #include "include/util.h"
+#include "include/visitor.h"
 
 #include <prism.h>
 #include <stdio.h>
@@ -76,3 +78,30 @@ void ast_node_set_positions_from_token(AST_NODE_T* node, const token_T* token) {
 bool ast_node_is(const AST_NODE_T* node, const ast_node_type_T type) {
   return node->type == type;
 }
+
+typedef struct {
+  position_T position;
+  AST_NODE_T* found_node;
+} find_erb_at_position_context_T;
+
+static bool find_erb_at_position_visitor(const AST_NODE_T* node, void* data) {
+  find_erb_at_position_context_T* context = (find_erb_at_position_context_T*) data;
+
+  if (node->type == AST_ERB_CONTENT_NODE) {
+    if (position_is_within_range(context->position, node->location.start, node->location.end)) {
+      context->found_node = (AST_NODE_T*) node;
+      return false;
+    }
+  }
+
+  return true;
+}
+
+AST_NODE_T* find_erb_content_at_offset(AST_DOCUMENT_NODE_T* document, const char* source, size_t offset) {
+  position_T position = position_from_source_with_offset(source, offset);
+  find_erb_at_position_context_T context = { .position = position, .found_node = NULL };
+
+  herb_visit_node((AST_NODE_T*) document, find_erb_at_position_visitor, &context);
+
+  return context.found_node;
+}

data/src/extract.c

@@ -7,7 +7,7 @@
 #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;
@@ -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;
       }
 
@@ -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,7 +55,7 @@ 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++) {
@@ -71,7 +71,7 @@ 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++) {
@@ -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/util/hb_buffer.h

@@ -1,18 +1,21 @@
 #ifndef HERB_BUFFER_H
 #define HERB_BUFFER_H
 
+#include "hb_arena.h"
 #include "hb_string.h"
 
 #include <stdbool.h>
 #include <stdlib.h>
 
 typedef struct HB_BUFFER_STRUCT {
+  hb_arena_T* allocator;
   char* value;
   size_t length;
   size_t capacity;
 } hb_buffer_T;
 
 bool hb_buffer_init(hb_buffer_T* buffer, size_t capacity);
+bool hb_buffer_init_arena(hb_buffer_T* buffer, hb_arena_T* allocator, size_t capacity);
 
 void hb_buffer_append(hb_buffer_T* buffer, const char* text);
 void hb_buffer_append_with_length(hb_buffer_T* buffer, const char* text, size_t length);
@@ -29,6 +32,5 @@ size_t hb_buffer_capacity(const hb_buffer_T* buffer);
 size_t hb_buffer_sizeof(void);
 
 void hb_buffer_clear(hb_buffer_T* buffer);
-void hb_buffer_free(hb_buffer_T** buffer);
 
 #endif

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.0"
+#define HERB_VERSION "0.8.3"
 
 #endif

data/src/parser.c

@@ -315,8 +315,8 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
   position_T node_end = { 0 };
 
   if (children->size > 0) {
-    AST_NODE_T* first_child = hb_array_get(children, 0);
-    AST_NODE_T* last_child = hb_array_get(children, children->size - 1);
+    AST_NODE_T* first_child = hb_array_first(children);
+    AST_NODE_T* last_child = hb_array_last(children);
 
     node_start = first_child->location.start;
     node_end = last_child->location.end;
@@ -1301,17 +1301,15 @@ void match_tags_in_node_array(hb_array_T* nodes, hb_array_T* errors) {
 
   hb_array_T* processed = parser_build_elements_from_tags(nodes, errors);
 
-  while (hb_array_size(nodes) > 0) {
-    hb_array_remove(nodes, 0);
-  }
+  nodes->size = 0;
 
-  for (size_t i = 0; i < hb_array_size(processed); i++) {
+  for (size_t i = 0; i < processed->size; i++) {
     hb_array_append(nodes, hb_array_get(processed, i));
   }
 
   hb_array_free(&processed);
 
-  for (size_t i = 0; i < hb_array_size(nodes); i++) {
+  for (size_t i = 0; i < nodes->size; i++) {
     AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, i);
     if (node == NULL) { continue; }
 

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/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_buffer.c

@@ -22,8 +22,14 @@ static bool hb_buffer_resize(hb_buffer_T* buffer, const size_t new_capacity) {
     fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
     exit(1);
   }
+  char* new_value = NULL;
 
-  char* new_value = realloc(buffer->value, new_capacity + 1);
+  if (buffer->allocator == NULL) {
+    new_value = realloc(buffer->value, new_capacity + 1);
+  } else {
+    new_value = hb_arena_alloc(buffer->allocator, new_capacity + 1);
+    memcpy(new_value, buffer->value, buffer->capacity + 1);
+  }
 
   if (unlikely(new_value == NULL)) {
     fprintf(stderr, "Error: Failed to resize buffer to %zu.\n", new_capacity);
@@ -61,6 +67,7 @@ static bool hb_buffer_expand_if_needed(hb_buffer_T* buffer, const size_t require
 }
 
 bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity) {
+  buffer->allocator = NULL;
   buffer->capacity = capacity;
   buffer->length = 0;
   buffer->value = malloc(sizeof(char) * (buffer->capacity + 1));
@@ -76,6 +83,16 @@ bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity) {
   return true;
 }
 
+bool hb_buffer_init_arena(hb_buffer_T* buffer, hb_arena_T* allocator, size_t capacity) {
+  buffer->allocator = allocator;
+  buffer->capacity = capacity;
+  buffer->length = 0;
+  buffer->value = hb_arena_alloc(allocator, sizeof(char) * (buffer->capacity + 1));
+  buffer->value[0] = '\0';
+
+  return true;
+}
+
 char* hb_buffer_value(const hb_buffer_T* buffer) {
   return buffer->value;
 }
@@ -192,12 +209,3 @@ void hb_buffer_clear(hb_buffer_T* buffer) {
   buffer->length = 0;
   buffer->value[0] = '\0';
 }
-
-void hb_buffer_free(hb_buffer_T** buffer) {
-  if (!buffer || !*buffer) { return; }
-
-  if ((*buffer)->value != NULL) { free((*buffer)->value); }
-
-  free(*buffer);
-  *buffer = NULL;
-}

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) {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.3
 platform: x86_64-linux-musl
 authors:
 - Marco Roth
@@ -161,6 +161,7 @@ files:
 - src/parser.c
 - src/parser_helpers.c
 - src/parser_match_tags.c
+- src/position.c
 - src/pretty_print.c
 - src/prism_helpers.c
 - src/range.c