herb 0.7.1-arm-linux-gnu → 0.7.3-arm-linux-gnu

data/lib/herb/engine.rb

@@ -17,7 +17,7 @@ require_relative "engine/validators/accessibility_validator"
 module Herb
   class Engine
     attr_reader :src, :filename, :project_path, :relative_file_path, :bufvar, :debug, :content_for_head,
-                :validation_error_template
+                :validation_error_template, :visitors
 
     ESCAPE_TABLE = {
       "&" => "&",
@@ -51,6 +51,16 @@ module Herb
       @content_for_head = properties[:content_for_head]
       @validation_error_template = nil
       @validation_mode = properties.fetch(:validation_mode, :raise)
+      @visitors = properties.fetch(:visitors, default_visitors)
+
+      if @debug && @visitors.empty?
+        debug_visitor = DebugVisitor.new(
+          file_path: @filename,
+          project_path: @project_path
+        )
+
+        @visitors << debug_visitor
+      end
 
       unless [:raise, :overlay, :none].include?(@validation_mode)
         raise ArgumentError,
@@ -109,12 +119,12 @@ module Herb
 
         add_validation_overlay(validation_errors, input) if @validation_mode == :overlay && validation_errors&.any?
 
-        if @debug
-          debug_visitor = DebugVisitor.new(self)
-          ast.accept(debug_visitor)
+        @visitors.each do |visitor|
+          ast.accept(visitor)
         end
 
         compiler = Compiler.new(self, properties)
+
         ast.accept(compiler)
 
         compiler.generate_output
@@ -359,8 +369,12 @@ module Herb
       )
 
       error_html = overlay_generator.generate_html
-      escaped_html = error_html.gsub("'", "\\'")
-      @validation_error_template = "<template data-herb-parser-error>#{escaped_html}</template>"
+      @validation_error_template = "<template data-herb-parser-error>#{error_html}</template>"
+    end
+
+    #: () -> Array[Herb::Visitor]
+    def default_visitors
+      []
     end
   end
 end

data/lib/herb/version.rb

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

data/sig/herb/engine/debug_visitor.rbs

@@ -3,9 +3,7 @@
 module Herb
   class Engine
     class DebugVisitor < Herb::Visitor
-      def initialize: (untyped engine) -> untyped
-
-      def debug_enabled?: () -> untyped
+      def initialize: (?file_path: untyped, ?project_path: untyped) -> untyped
 
       def visit_document_node: (untyped node) -> untyped
 
@@ -23,6 +21,8 @@ module Herb
 
       private
 
+      def calculate_relative_path: () -> untyped
+
       def wrap_all_erb_nodes: (untyped node) -> untyped
 
       # Creates a dummy location for AST nodes that don't need real location info

data/sig/herb/engine.rbs

@@ -18,6 +18,8 @@ module Herb
 
     attr_reader validation_error_template: untyped
 
+    attr_reader visitors: untyped
+
     ESCAPE_TABLE: untyped
 
     class CompilationError < StandardError
@@ -68,5 +70,8 @@ module Herb
     def escape_attr: (untyped text) -> untyped
 
     def add_parser_error_overlay: (untyped parser_errors, untyped input) -> untyped
+
+    # : () -> Array[Herb::Visitor]
+    def default_visitors: () -> Array[Herb::Visitor]
   end
 end

data/src/analyze.c

@@ -54,7 +54,7 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
     if (strcmp(opening, "<%%") != 0 && strcmp(opening, "<%%=") != 0 && strcmp(opening, "<%#") != 0) {
       analyzed_ruby_T* analyzed = herb_analyze_ruby(erb_content_node->content->value);
 
-      if (false) { pretty_print_analyed_ruby(analyzed, erb_content_node->content->value); }
+      if (false) { pretty_print_analyzed_ruby(analyzed, erb_content_node->content->value); }
 
       erb_content_node->parsed = true;
       erb_content_node->valid = analyzed->valid;
@@ -1107,7 +1107,8 @@ void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source
   char* extracted_ruby = herb_extract_ruby_with_semicolons(source);
 
   pm_parser_t parser;
-  pm_parser_init(&parser, (const uint8_t*) extracted_ruby, strlen(extracted_ruby), NULL);
+  pm_options_t options = { 0, .partial_script = true };
+  pm_parser_init(&parser, (const uint8_t*) extracted_ruby, strlen(extracted_ruby), &options);
 
   pm_node_t* root = pm_parse(&parser);
 
@@ -1115,16 +1116,11 @@ void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source
        error = (const pm_diagnostic_t*) error->node.next) {
 
     RUBY_PARSE_ERROR_T* parse_error = ruby_parse_error_from_prism_error(error, (AST_NODE_T*) document, source, &parser);
-
-    // TODO: ideally this shouldn't be hard-coded
-    if (strcmp(parse_error->diagnostic_id, "invalid_yield") == 0) {
-      error_free((ERROR_T*) parse_error);
-    } else {
-      array_append(document->base.errors, parse_error);
-    }
+    array_append(document->base.errors, parse_error);
   }
 
   pm_node_destroy(&parser, root);
   pm_parser_free(&parser);
+  pm_options_free(&options);
   free(extracted_ruby);
 }

data/src/analyze_helpers.c

@@ -91,9 +91,12 @@ bool search_if_nodes(const pm_node_t* node, void* data) {
   if (node->type == PM_IF_NODE) {
     const pm_if_node_t* if_node = (const pm_if_node_t*) node;
 
-    // Handle ternary
-    if (if_node->if_keyword_loc.start != NULL && if_node->if_keyword_loc.end != NULL) {
+    bool has_if_keyword = if_node->if_keyword_loc.start != NULL && if_node->if_keyword_loc.end != NULL;
+    bool has_end_keyword = if_node->end_keyword_loc.start != NULL && if_node->end_keyword_loc.end != NULL;
+
+    if (has_if_keyword && has_end_keyword) {
       analyzed->has_if_node = true;
+
       return true;
     }
   }
@@ -198,12 +201,20 @@ bool search_unless_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
   if (node->type == PM_UNLESS_NODE) {
-    analyzed->has_unless_node = true;
-    return true;
-  } else {
-    pm_visit_child_nodes(node, search_unless_nodes, analyzed);
+    const pm_unless_node_t* unless_node = (const pm_unless_node_t*) node;
+
+    bool has_if_keyword = unless_node->keyword_loc.start != NULL && unless_node->keyword_loc.end != NULL;
+    bool has_end_keyword = unless_node->end_keyword_loc.start != NULL && unless_node->end_keyword_loc.end != NULL;
+
+    if (has_if_keyword && has_end_keyword) {
+      analyzed->has_unless_node = true;
+
+      return true;
+    }
   }
 
+  pm_visit_child_nodes(node, search_unless_nodes, analyzed);
+
   return false;
 }
 

data/src/include/pretty_print.h

@@ -88,6 +88,6 @@ void pretty_print_array(
 
 void pretty_print_errors(AST_NODE_T* node, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
 
-void pretty_print_analyed_ruby(analyzed_ruby_T* analyzed, const char* source);
+void pretty_print_analyzed_ruby(analyzed_ruby_T* analyzed, const char* source);
 
 #endif

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.7.1"
+#define HERB_VERSION "0.7.3"
 
 #endif

data/src/parser.c

@@ -555,14 +555,12 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
     return value;
   }
 
-  token_T* token = parser_advance(parser);
-
   append_unexpected_error(
     "Unexpected Token",
     "TOKEN_IDENTIFIER, TOKEN_QUOTE, TOKEN_ERB_START",
-    token_type_to_string(token->type),
-    token->location->start,
-    token->location->end,
+    token_type_to_string(parser->current_token->type),
+    parser->current_token->location->start,
+    parser->current_token->location->end,
     errors
   );
 
@@ -571,13 +569,11 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
     children,
     NULL,
     false,
-    token->location->start,
-    token->location->end,
+    parser->current_token->location->start,
+    parser->current_token->location->end,
     errors
   );
 
-  token_free(token);
-
   return value;
 }
 
@@ -1135,6 +1131,7 @@ static void parser_parse_in_data_state(parser_T* parser, array_T* children, arra
           parser,
           TOKEN_AMPERSAND,
           TOKEN_AT,
+          TOKEN_BACKTICK,
           TOKEN_CHARACTER,
           TOKEN_COLON,
           TOKEN_DASH,

data/src/pretty_print.c

@@ -254,7 +254,7 @@ void pretty_print_string_property(
   }
 }
 
-void pretty_print_analyed_ruby(analyzed_ruby_T* analyzed, const char* source) {
+void pretty_print_analyzed_ruby(analyzed_ruby_T* analyzed, const char* source) {
   printf(
     "------------------------\nanalyzed (%p)\n------------------------\n%s\n------------------------\n  if:     %i\n "
     " elsif:  %i\n  else:   %i\n  end:    %i\n  block:  %i\n  block_closing: %i\n  case:   %i\n  when:   %i\n  for:    "

data/templates/ext/herb/error_helpers.c.erb

@@ -0,0 +1,85 @@
+#include <ruby.h>
+
+#include "extension.h"
+#include "extension_helpers.h"
+#include "error_helpers.h"
+
+#include "../../src/include/errors.h"
+#include "../../src/include/herb.h"
+#include "../../src/include/token.h"
+
+VALUE rb_error_from_c_struct(ERROR_T* error);
+
+<%- errors.each do |error| -%>
+static VALUE rb_<%= error.human %>_from_c_struct(<%= error.struct_type %>* <%= error.human %>) {
+  if (<%= error.human %> == NULL) { return Qnil; }
+
+  ERROR_T* error = &<%= error.human %>->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Errors = rb_define_module_under(Herb, "Errors");
+  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
+  VALUE <%= error.name %> = rb_define_class_under(Errors, "<%= error.name %>", Error);
+
+  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_utf8_str_new_cstr(error->message);
+
+  <%- error.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::PositionField -%>
+  VALUE <%= error.human %>_<%= field.name %> = rb_position_from_c_struct(<%= error.human %>-><%= field.name %>);
+  <%- when Herb::Template::TokenField -%>
+  VALUE <%= error.human %>_<%= field.name %> = rb_token_from_c_struct(<%= error.human %>-><%= field.name %>);
+  <%- when Herb::Template::TokenTypeField -%>
+  VALUE <%= error.human %>_<%= field.name %> = rb_utf8_str_new_cstr(token_type_to_string(<%= error.human %>-><%= field.name %>));
+  <%- when Herb::Template::StringField -%>
+  VALUE <%= error.human %>_<%= field.name %> = rb_utf8_str_new_cstr(<%= error.human %>-><%= field.name %>);
+  <%- else -%>
+  /* <%= field.inspect %> */
+  VALUE <%= error.human %>_<%= field.name %> = Qnil;
+  <%- end -%>
+  <%- end -%>
+
+  VALUE args[<%= 3 + error.fields.count %>] = {
+    type,
+    location,
+    message<% if error.fields.any? %>,<% end %>
+    <%- error.fields.each do |field| -%>
+    <%= error.human %>_<%= field.name %><% if error.fields.last != field %>,<% end %>
+    <%- end -%>
+  };
+
+  return rb_class_new_instance(<%= 3 + error.fields.count %>, args, <%= error.name %>);
+};
+
+<%- end -%>
+
+VALUE rb_error_from_c_struct(ERROR_T* error) {
+  if (!error) { return Qnil; }
+
+  switch (error->type) {
+  <%- errors.each do |error| -%>
+    case <%= error.type %>: return rb_<%= error.human %>_from_c_struct((<%= error.struct_type %>*) error); break;
+  <%- end -%>
+  }
+
+  return Qnil;
+}
+
+VALUE rb_errors_array_from_c_array(array_T* array) {
+  VALUE rb_array = rb_ary_new();
+
+  if (array) {
+    for (size_t i = 0; i < array_size(array); i++) {
+      ERROR_T* child_node = (ERROR_T*) array_get(array, i);
+
+      if (child_node) {
+        VALUE rb_child = rb_error_from_c_struct(child_node);
+        rb_ary_push(rb_array, rb_child);
+      }
+    }
+  }
+
+  return rb_array;
+}

data/templates/ext/herb/error_helpers.h.erb

@@ -0,0 +1,12 @@
+#ifndef HERB_EXTENSION_ERROR_HELPERS_H
+#define HERB_EXTENSION_ERROR_HELPERS_H
+
+#include "../../src/include/errors.h"
+#include "../../src/include/herb.h"
+
+#include <ruby.h>
+
+VALUE rb_error_from_c_struct(ERROR_T* error);
+VALUE rb_errors_array_from_c_array(array_T* array);
+
+#endif

data/templates/ext/herb/nodes.c.erb

@@ -0,0 +1,90 @@
+#include <ruby.h>
+
+#include "error_helpers.h"
+#include "extension_helpers.h"
+#include "extension.h"
+#include "nodes.h"
+
+#include "../../src/include/herb.h"
+#include "../../src/include/token.h"
+
+VALUE rb_node_from_c_struct(AST_NODE_T* node);
+static VALUE rb_nodes_array_from_c_array(array_T* array);
+
+<%- nodes.each do |node| -%>
+static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= node.human %>) {
+  if (<%= node.human %> == NULL) { return Qnil; }
+
+  AST_NODE_T* node = &<%= node.human %>->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE AST = rb_define_module_under(Herb, "AST");
+  VALUE Node = rb_define_class_under(AST, "Node", rb_cObject);
+  VALUE <%= node.name %> = rb_define_class_under(AST, "<%= node.name %>", Node);
+
+  VALUE type = rb_utf8_str_new_cstr(ast_node_type_to_string(node));
+  VALUE location = rb_location_from_c_struct(node->location);
+  VALUE errors = rb_errors_array_from_c_array(node->errors);
+
+  <%- node.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  VALUE <%= node.human %>_<%= field.name %> = rb_utf8_str_new_cstr(<%= node.human %>-><%= field.name %>);
+  <%- when Herb::Template::NodeField -%>
+  VALUE <%= node.human %>_<%= field.name %> = rb_node_from_c_struct((AST_NODE_T*) <%= node.human %>-><%= field.name %>);
+  <%- when Herb::Template::TokenField -%>
+  VALUE <%= node.human %>_<%= field.name %> = rb_token_from_c_struct(<%= node.human %>-><%= field.name %>);
+  <%- when Herb::Template::BooleanField -%>
+  VALUE <%= node.human %>_<%= field.name %> = (<%= node.human %>-><%= field.name %>) ? Qtrue : Qfalse;
+  <%- when Herb::Template::ArrayField -%>
+  VALUE <%= node.human %>_<%= field.name %> = rb_nodes_array_from_c_array(<%= node.human %>-><%= field.name %>);
+  <%- when Herb::Template::ElementSourceField -%>
+  VALUE <%= node.human %>_<%= field.name %> = rb_utf8_str_new_cstr(element_source_to_string(<%= node.human %>-><%= field.name %>));
+  <%- else -%>
+  /* <%= field.inspect %> */
+  VALUE <%= node.human %>_<%= field.name %> = Qnil;
+  <%- end -%>
+  <%- end -%>
+
+  VALUE args[<%= 3 + node.fields.count %>] = {
+    type,
+    location,
+    errors<% if node.fields.any? %>,<% end %>
+    <%- node.fields.each do |field| -%>
+    <%= node.human %>_<%= field.name %><% if node.fields.last != field %>,<% end %>
+    <%- end -%>
+  };
+
+  return rb_class_new_instance(<%= 3 + node.fields.count %>, args, <%= node.name %>);
+};
+
+<%- end -%>
+
+VALUE rb_node_from_c_struct(AST_NODE_T* node) {
+  if (!node) { return Qnil; }
+
+  switch (node->type) {
+  <%- nodes.each do |node| -%>
+    case <%= node.type %>: return rb_<%= node.human %>_from_c_struct((<%= node.struct_type %>*) node); break;
+  <%- end -%>
+  }
+
+  return Qnil;
+}
+
+static VALUE rb_nodes_array_from_c_array(array_T* array) {
+  VALUE rb_array = rb_ary_new();
+
+  if (array) {
+    for (size_t i = 0; i < array_size(array); i++) {
+      AST_NODE_T* child_node = (AST_NODE_T*) array_get(array, i);
+
+      if (child_node) {
+        VALUE rb_child = rb_node_from_c_struct(child_node);
+        rb_ary_push(rb_array, rb_child);
+      }
+    }
+  }
+
+  return rb_array;
+}

data/templates/ext/herb/nodes.h.erb

@@ -0,0 +1,9 @@
+#ifndef HERB_EXTENSION_NODES_H
+#define HERB_EXTENSION_NODES_H
+
+#include "../../src/include/herb.h"
+#include <ruby.h>
+
+VALUE rb_node_from_c_struct(AST_NODE_T* node);
+
+#endif

data/templates/javascript/packages/core/src/errors.ts.erb

@@ -0,0 +1,193 @@
+import { Location, SerializedLocation } from "./location.js"
+import { Token, SerializedToken } from "./token.js"
+import { Diagnostic, MonacoDiagnostic } from "./diagnostic.js"
+
+export type HerbErrorType =
+  <%- errors.each_with_index.map do |error, index| -%>
+  | "<%= error.type %>"
+  <%- end -%>
+
+export type SerializedErrorType = string
+
+export interface SerializedHerbError {
+  type: string
+  message: string
+  location: SerializedLocation
+}
+
+export abstract class HerbError implements Diagnostic {
+  readonly type: string
+  readonly message: string
+  readonly location: Location
+  readonly severity: "error" | "warning" | "info" | "hint" = "error"
+  readonly source: string = "parser"
+
+  get code(): string {
+    return this.type
+  }
+
+  static from(error: SerializedHerbError): HerbError {
+    return fromSerializedError(error)
+  }
+
+  constructor(type: string, message: string, location: Location) {
+    this.type = type
+    this.message = message
+    this.location = location
+  }
+
+  toJSON(): SerializedHerbError {
+    return {
+      type: this.type,
+      message: this.message,
+      location: this.location.toJSON(),
+    }
+  }
+
+  inspect(): string {
+    return this.treeInspect(0)
+  }
+
+  abstract treeInspect(indent?: number): string
+}
+
+<%- errors.each do |error| -%>
+export interface Serialized<%= error.name %> {
+  type: "<%= error.type %>";
+  message: string;
+  location: SerializedLocation;
+  <%- error.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  <%= field.name %>: string;
+  <%- when Herb::Template::TokenField -%>
+  <%= field.name %>: SerializedToken | null;
+  <%- when Herb::Template::TokenTypeField -%>
+  <%= field.name %>: string | null;
+  <%- else -%>
+  <%= field.name %>: any; // <%= field.inspect %>
+  <%- end -%>
+  <%- end -%>
+}
+
+export interface <%= error.name %>Props {
+  type: string;
+  message: string;
+  location: Location;
+  <%- error.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  <%= field.name %>: string;
+  <%- when Herb::Template::TokenField -%>
+  <%= field.name %>: Token | null;
+  <%- when Herb::Template::TokenTypeField -%>
+  <%= field.name %>: string | null;
+  <%- else -%>
+  <%= field.name %>: any; // <%= field.inspect %>
+  <%- end -%>
+  <%- end -%>
+}
+
+export class <%= error.name %> extends HerbError {
+  <%- error.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  readonly <%= field.name %>: string;
+  <%- when Herb::Template::TokenField -%>
+  readonly <%= field.name %>: Token | null;
+  <%- when Herb::Template::TokenTypeField -%>
+  readonly <%= field.name %>: string | null;
+  <%- else -%>
+  readonly <%= field.name %>: any;
+  <%- end -%>
+  <%- end -%>
+
+  static from(data: Serialized<%= error.name %>): <%= error.name %> {
+    return new <%= error.name %>({
+      type: data.type,
+      message: data.message,
+      location: Location.from(data.location),
+      <%- error.fields.each do |field| -%>
+      <%- case field -%>
+      <%- when Herb::Template::StringField, Herb::Template::TokenTypeField, Herb::Template::SizeTField -%>
+      <%= field.name %>: data.<%= field.name %>,
+      <%- when Herb::Template::TokenField -%>
+      <%= field.name %>: data.<%= field.name %> ? Token.from(data.<%= field.name %>) : null,
+      <%- else -%>
+      <% raise "Unexpetected type: #{field.class}" %>
+      <%- end -%>
+      <%- end -%>
+    })
+  }
+
+  constructor(props: <%= error.name %>Props) {
+    super(props.type, props.message, props.location);
+
+    <%- error.fields.each do |field| -%>
+    this.<%= field.name %> = props.<%= field.name %>;
+    <%- end -%>
+  }
+
+  toJSON(): Serialized<%= error.name %> {
+    return {
+      ...super.toJSON(),
+      type: "<%= error.type %>",
+      <%- error.fields.each do |field| -%>
+      <%- case field -%>
+      <%- when Herb::Template::StringField, Herb::Template::TokenTypeField, Herb::Template::SizeTField -%>
+      <%= field.name %>: this.<%= field.name %>,
+      <%- when Herb::Template::TokenField -%>
+      <%= field.name %>: this.<%= field.name %> ? this.<%= field.name %>.toJSON() : null,
+      <%- else -%>
+      <% raise "Unexpetected type: #{field.class}" %>
+      <%- end -%>
+      <%- end -%>
+    };
+  }
+
+  toMonacoDiagnostic(): MonacoDiagnostic {
+    return {
+      line: this.location.start.line,
+      column: this.location.start.column,
+      endLine: this.location.end.line,
+      endColumn: this.location.end.column,
+      message: this.message,
+      severity: 'error'
+    }
+  }
+
+  treeInspect(): string {
+    let output = "";
+
+    output += `@ <%= error.name %> ${this.location.treeInspectWithLabel()}\n`;
+    <%- symbol = error.fields.any? ? "├──" : "└──" -%>
+    output += `<%= symbol %> message: "${this.message}"\n`;
+    <%- error.fields.each do |field| -%>
+    <%- symbol = error.fields.last == field ? "└──" : "├──" -%>
+    <%- name = "#{symbol} #{field.name}: " -%>
+    <%- case field -%>
+    <%- when Herb::Template::StringField, Herb::Template::TokenTypeField, Herb::Template::SizeTField -%>
+    output += `<%= name %>${JSON.stringify(this.<%= field.name %>)}\n`;
+    <%- when Herb::Template::TokenField -%>
+    output += `<%= name %>${this.<%= field.name %> ? this.<%= field.name %>.treeInspect() : "∅"}\n`;
+    <%- else -%>
+    <% raise "Unexpetected type: #{field.class}" %>
+    <%- end -%>
+    <%- end -%>
+
+    return output;
+  }
+}
+
+<%- end -%>
+
+export function fromSerializedError(error: SerializedHerbError): HerbError {
+  switch (error.type) {
+    <%- errors.each do |error| -%>
+    case "<%= error.type %>": return <%= error.name %>.from(error as Serialized<%= error.name %>);
+    <%- end -%>
+
+    default:
+      throw new Error(`Unknown node type: ${error.type}`);
+  }
+}