herb 0.7.2-x86_64-linux-musl → 0.7.4-x86_64-linux-musl

data/herb.gemspec

@@ -26,10 +26,13 @@ Gem::Specification.new do |spec|
     "Makefile",
     "Rakefile",
     "README.md",
+    "config.yml",
     "lib/**/*.rb",
     "sig/**/*.rbs",
     "src/**/*.{c,h}",
     "ext/**/*.{c,h}",
+    "templates/**/*.{rb,erb}",
+    "vendor/prism/**/*",
     "exe/*"
   ]
 

data/lib/herb/engine.rb

@@ -194,7 +194,14 @@ module Herb
       terminate_expression
 
       @src << " " << code
-      @src << ";" unless code[-1] == "\n"
+
+      # TODO: rework and check for Prism::InlineComment as soon as we expose the Prism Nodes in the Herb AST
+      if code.include?("#")
+        @src << "\n"
+      else
+        @src << ";" unless code[-1] == "\n"
+      end
+
       @buffer_on_stack = false
     end
 

data/lib/herb/version.rb

@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.7.2"
+  VERSION = "0.7.4"
 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/herb.c

@@ -29,9 +29,9 @@ array_T* herb_lex(const char* source) {
 
 AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
   lexer_T* lexer = lexer_init(source);
-  parser_T* parser = parser_init(lexer, options);
+  parser_T* parser = herb_parser_init(lexer, options);
 
-  AST_DOCUMENT_NODE_T* document = parser_parse(parser);
+  AST_DOCUMENT_NODE_T* document = herb_parser_parse(parser);
 
   parser_free(parser);
 

data/src/include/parser.h

@@ -28,9 +28,9 @@ typedef struct PARSER_STRUCT {
   parser_options_T* options;
 } parser_T;
 
-parser_T* parser_init(lexer_T* lexer, parser_options_T* options);
+parser_T* herb_parser_init(lexer_T* lexer, parser_options_T* options);
 
-AST_DOCUMENT_NODE_T* parser_parse(parser_T* parser);
+AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser);
 
 size_t parser_sizeof(void);
 

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.2"
+#define HERB_VERSION "0.7.4"
 
 #endif

data/src/parser.c

@@ -31,7 +31,7 @@ size_t parser_sizeof(void) {
   return sizeof(struct PARSER_STRUCT);
 }
 
-parser_T* parser_init(lexer_T* lexer, parser_options_T* options) {
+parser_T* herb_parser_init(lexer_T* lexer, parser_options_T* options) {
   parser_T* parser = calloc(1, parser_sizeof());
 
   parser->lexer = lexer;
@@ -1131,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,
@@ -1222,7 +1223,7 @@ static AST_DOCUMENT_NODE_T* parser_parse_document(parser_T* parser) {
   return document_node;
 }
 
-AST_DOCUMENT_NODE_T* parser_parse(parser_T* parser) {
+AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser) {
   return parser_parse_document(parser);
 }
 

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}`);
+  }
+}