herb 0.8.2-aarch64-linux-gnu → 0.8.3-aarch64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a62db91cf0f5985a1048a018b2199f260992974e8ee92d79c55ce9c913998ddf
-  data.tar.gz: c43846d1c1d18ec9ea43330db1e7b4f789f874a23adad4b381e345de19e2e06e
+  metadata.gz: 7b78acc930919b1a5b7173f2c0e16df53039eb536d692d4f1b8e39da26fd2c26
+  data.tar.gz: 2ec84da56f908fd2acf9c6fac9fc3dce26c5a4ac807569ede9de3f9cc43f3d6a
 SHA512:
-  metadata.gz: 5e2eb7f072d2f74f99fc6405a62a7211f4e63a771c3359a924592b5627b6bf2b1189e83696374ddaf2cc7982489329a370cd18def642005df5f2427502b96b3a
-  data.tar.gz: 80267f6d67a7d9af1d3c189845e85d3dabc3046785f40dc59bdcee87d0b63cfb6c38c004776639db2aac473d13a89fe3cac636c529c4540ff7cdbea5f662bd36
+  metadata.gz: e10b50835c32bf2f494c6b03fe07f15ec26633b836c6ffb42c938fc0393f3b111056927689e498b5de2fe4bfd6b7220e05bf9812bbf62032b87d6768b2206381
+  data.tar.gz: 72ff7c8d06edd7d080839294299caeef20237ae33964571724ec8cbe765ff22f5af58dbd53ed21be3dd856727e847dcba2611e22d14406fc124e212d8492282d

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:0x00007fdea9bf4750 @name="analyzed_ruby", @options={kind: nil}> */
+  /* #<Herb::Template::AnalyzedRubyField:0x00007f14d4f03f30 @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.2"
+  VERSION = "0.8.3"
 end

data/src/analyze.c

@@ -1409,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);
 
@@ -1422,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/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/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.3"
 
 #endif

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_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.2
+  version: 0.8.3
 platform: aarch64-linux-gnu
 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