herb 0.10.4-x86-linux-gnu → 0.11.0-x86-linux-gnu

data/templates/src/analyze/missing_end.c.erb

@@ -1,5 +1,7 @@
+#include "../include/analyze/builders.h"
 #include "../include/analyze/helpers.h"
 #include "../include/errors.h"
+#include "../include/parser/parser.h"
 #include "../include/lib/hb_allocator.h"
 #include "../include/lib/hb_string.h"
 
@@ -9,7 +11,7 @@
   end
 -%>
 
-void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator) {
+void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator, const parser_options_T* options) {
   switch (node->type) {
     <%- nodes_with_end_node.each do |node| -%>
     <%- keyword = node.name.gsub(/^ERB/, '').gsub(/Match|Node$/, '').downcase -%>
@@ -18,15 +20,21 @@ void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allo
 
       if (<%= node.human %>->end_node == NULL) {
         <%= "append_#{errors.find { |e| e.name == 'MissingERBEndTagError' }.human}" %>(
-        <%- if keyword == "block" -%>
+        <%- if keyword.end_with?("block") -%>
           hb_string("ERB block"),
         <%- else -%>
           hb_string("`<" "%" " <%= keyword %> " "%" ">`"),
         <%- end -%>
-          <%= node.human %>->tag_opening->location.start,
-          <%= node.human %>->tag_closing->location.end,
+          erb_tag_start_position(<%= node.human %>->tag_opening, <%= node.human %>->content, node->location),
+          erb_tag_end_position(
+            <%= node.human %>->tag_closing,
+            <%= node.human %>->content,
+            <%= node.human %>->tag_opening,
+            node->location
+          ),
           allocator,
-          node->errors
+          &((AST_NODE_T*) node)->errors,
+          options
         );
       }
 

data/templates/src/ast/ast_nodes.c.erb

@@ -27,7 +27,7 @@
   <%- node.fields.each do |field| -%>
   <%- case field -%>
   <%- when Herb::Template::TokenField -%>
-  <%= node.human %>-><%= field.name %> = token_copy(<%= field.name %>, allocator);
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::NodeField -%>
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::ArrayField -%>
@@ -118,7 +118,7 @@ static void ast_free_<%= node.human %>(<%= node.struct_type %>* <%= node.human %
     hb_array_free(&<%= node.human %>-><%= field.name %>);
   }
   <%- when Herb::Template::StringField -%>
-  if (<%= node.human %>-><%= field.name %>.data != NULL) { hb_allocator_dealloc(allocator, <%= node.human %>-><%= field.name %>.data); }
+  if (!hb_string_is_empty(<%= node.human %>-><%= field.name %>)) { hb_allocator_dealloc(allocator, <%= node.human %>-><%= field.name %>.data); }
   <%- when Herb::Template::PrismNodeField -%>
   /* prism_node is a borrowed reference into the prism context, not freed here */
   <%- when Herb::Template::AnalyzedRubyField -%>
@@ -144,6 +144,45 @@ static void ast_free_<%= node.human %>(<%= node.struct_type %>* <%= node.human %
 }
 <%- end -%>
 
+static void ast_rebase_token(token_T* token, const char* from, const char* to, size_t length) {
+  if (token == NULL || token->value.data == NULL) { return; }
+  if (token->value.data < from || token->value.data >= from + length) { return; }
+
+  token->value.data = (char*) to + (token->value.data - from);
+}
+
+void ast_node_rebase_tokens(AST_NODE_T* node, const char* from, const char* to, size_t length) {
+  if (!node) { return; }
+
+  switch (node->type) {
+    <%- nodes.each do |node| -%>
+    case <%= node.type %>: {
+      <%- if node.fields.none? { |f| [Herb::Template::TokenField, Herb::Template::NodeField, Herb::Template::ArrayField].include?(f.class) } -%>
+      break;
+      <%- else -%>
+      <%= node.struct_type %>* typed = (<%= node.struct_type %>*) node;
+      <%- node.fields.each do |field| -%>
+      <%- case field -%>
+      <%- when Herb::Template::TokenField -%>
+      ast_rebase_token(typed-><%= field.name %>, from, to, length);
+      <%- when Herb::Template::BorrowedNodeField -%>
+      <%- when Herb::Template::NodeField -%>
+      ast_node_rebase_tokens((AST_NODE_T*) typed-><%= field.name %>, from, to, length);
+      <%- when Herb::Template::ArrayField -%>
+      if (typed-><%= field.name %> != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed-><%= field.name %>); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed-><%= field.name %>, i), from, to, length);
+        }
+      }
+      <%- end -%>
+      <%- end -%>
+      break;
+      <%- end -%>
+    }
+    <%- end -%>
+  }
+}
+
 void ast_node_free(AST_NODE_T* node, hb_allocator_T* allocator) {
   if (!node) { return; }
 

data/templates/src/diff/herb_diff_nodes.c.erb

@@ -1,5 +1,6 @@
 #include "../include/diff/herb_diff.h"
 #include "../include/lib/hb_string.h"
+#include "../include/util/html_util.h"
 
 static bool tokens_equal(const token_T* old_token, const token_T* new_token) {
   if (old_token == NULL && new_token == NULL) { return true; }
@@ -8,14 +9,26 @@ static bool tokens_equal(const token_T* old_token, const token_T* new_token) {
   return hb_string_equals(old_token->value, new_token->value);
 }
 
+static bool body_preserves_whitespace(const token_T* old_tag_name, const token_T* new_tag_name, const bool inherited) {
+  if (inherited) { return true; }
+  if (old_tag_name != NULL && is_whitespace_preserving_element(old_tag_name->value)) { return true; }
+  if (new_tag_name != NULL && is_whitespace_preserving_element(new_tag_name->value)) { return true; }
+
+  return false;
+}
+
 static void diff_element_node(
   const AST_HTML_ELEMENT_NODE_T* old_element,
   const AST_HTML_ELEMENT_NODE_T* new_element,
   const herb_diff_path_T path,
   const herb_hash_map_T* old_hashes,
   const herb_hash_map_T* new_hashes,
+  const bool preserve_whitespace,
   herb_diff_result_T* result
 ) {
+  const bool preserve_body_whitespace =
+    body_preserves_whitespace(old_element->tag_name, new_element->tag_name, preserve_whitespace);
+
   if (!tokens_equal(old_element->tag_name, new_element->tag_name)) {
     herb_diff_emit_operation(result, HERB_DIFF_TAG_NAME_CHANGED, path, (const AST_NODE_T*) old_element, (const AST_NODE_T*) new_element, 0, 0);
   }
@@ -33,7 +46,7 @@ static void diff_element_node(
   }
 
   if (old_element->body != NULL && new_element->body != NULL) {
-    herb_diff_children(old_element->body, new_element->body, path, old_hashes, new_hashes, result);
+    herb_diff_children(old_element->body, new_element->body, path, old_hashes, new_hashes, preserve_body_whitespace, result);
   } else if (old_element->body == NULL && new_element->body != NULL) {
     for (size_t index = 0; index < hb_array_size(new_element->body); index++) {
       const AST_NODE_T* new_child = (const AST_NODE_T*) hb_array_get(new_element->body, index);
@@ -53,8 +66,12 @@ static void diff_conditional_element_node(
   const herb_diff_path_T path,
   const herb_hash_map_T* old_hashes,
   const herb_hash_map_T* new_hashes,
+  const bool preserve_whitespace,
   herb_diff_result_T* result
 ) {
+  const bool preserve_body_whitespace =
+    body_preserves_whitespace(old_element->tag_name, new_element->tag_name, preserve_whitespace);
+
   if (!tokens_equal(old_element->tag_name, new_element->tag_name)) {
     herb_diff_emit_operation(result, HERB_DIFF_TAG_NAME_CHANGED, path, (const AST_NODE_T*) old_element, (const AST_NODE_T*) new_element, 0, 0);
   }
@@ -69,7 +86,7 @@ static void diff_conditional_element_node(
   }
 
   if (old_element->body != NULL && new_element->body != NULL) {
-    herb_diff_children(old_element->body, new_element->body, path, old_hashes, new_hashes, result);
+    herb_diff_children(old_element->body, new_element->body, path, old_hashes, new_hashes, preserve_body_whitespace, result);
   }
 }
 
@@ -79,10 +96,11 @@ static void diff_children_nullable(
   const herb_diff_path_T path,
   const herb_hash_map_T* old_hashes,
   const herb_hash_map_T* new_hashes,
+  const bool preserve_whitespace,
   herb_diff_result_T* result
 ) {
   if (old_children != NULL && new_children != NULL) {
-    herb_diff_children(old_children, new_children, path, old_hashes, new_hashes, result);
+    herb_diff_children(old_children, new_children, path, old_hashes, new_hashes, preserve_whitespace, result);
   } else if (old_children == NULL && new_children != NULL) {
     for (size_t index = 0; index < hb_array_size(new_children); index++) {
       const AST_NODE_T* new_child = (const AST_NODE_T*) hb_array_get(new_children, index);
@@ -102,6 +120,7 @@ void herb_diff_node(
   const herb_diff_path_T path,
   const herb_hash_map_T* old_hashes,
   const herb_hash_map_T* new_hashes,
+  const bool preserve_whitespace,
   herb_diff_result_T* result
 ) {
   if (old_node == NULL && new_node == NULL) { return; }
@@ -134,7 +153,7 @@ void herb_diff_node(
       diff_element_node(
         (const <%= node.struct_type %>*) old_node,
         (const <%= node.struct_type %>*) new_node,
-        path, old_hashes, new_hashes, result
+        path, old_hashes, new_hashes, preserve_whitespace, result
       );
     } break;
 
@@ -143,10 +162,27 @@ void herb_diff_node(
       diff_conditional_element_node(
         (const <%= node.struct_type %>*) old_node,
         (const <%= node.struct_type %>*) new_node,
-        path, old_hashes, new_hashes, result
+        path, old_hashes, new_hashes, preserve_whitespace, result
       );
     } break;
 
+  <%- elsif node.name == "HTMLTextNode" -%>
+    case <%= node.type %>: {
+      const <%= node.struct_type %>* old_text_node = (const <%= node.struct_type %>*) old_node;
+      const <%= node.struct_type %>* new_text_node = (const <%= node.struct_type %>*) new_node;
+
+      if (preserve_whitespace) {
+        if (!hb_string_equals(old_text_node->content, new_text_node->content)) {
+          herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+        }
+      } else if (!hb_string_equals_collapsing_whitespace(old_text_node->content, new_text_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      } else if (result->options.track_whitespace_changes
+                 && !hb_string_equals(old_text_node->content, new_text_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_WHITESPACE_CHANGED, path, old_node, new_node, 0, 0);
+      }
+    } break;
+
   <%- elsif node.name == "HTMLAttributeNode" -%>
     case <%= node.type %>: {
       const <%= node.struct_type %>* old_attribute = (const <%= node.struct_type %>*) old_node;
@@ -183,7 +219,7 @@ void herb_diff_node(
     <%- node_fields = all_fields.select { |field| field.is_a?(Herb::Template::NodeField) || field.is_a?(Herb::Template::BorrowedNodeField) } -%>
     <%- content_tokens = token_fields.select { |field| %w[content tag_opening].include?(field.name) } -%>
     <%- has_comparisons = content_tokens.any? || string_fields.any? || array_fields.any? || node_fields.any? -%>
-    <%- is_erb_node = node.name.start_with?("ERB") || node.name.start_with?("Ruby") -%>
+    <%- is_erb_node = node.erb_tag? || node.name.start_with?("Ruby") -%>
     <%- if !has_comparisons -%>
     case <%= node.type %>: {
       herb_diff_emit_operation(result, HERB_DIFF_NODE_REPLACED, path, old_node, new_node, 0, 0);
@@ -209,11 +245,11 @@ void herb_diff_node(
     <%- end -%>
 
     <%- array_fields.each do |field| -%>
-      diff_children_nullable(old_<%= node.human %>-><%= field.name %>, new_<%= node.human %>-><%= field.name %>, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_<%= node.human %>-><%= field.name %>, new_<%= node.human %>-><%= field.name %>, path, old_hashes, new_hashes, preserve_whitespace, result);
     <%- end -%>
 
     <%- node_fields.each do |field| -%>
-      herb_diff_node((const AST_NODE_T*) old_<%= node.human %>-><%= field.name %>, (const AST_NODE_T*) new_<%= node.human %>-><%= field.name %>, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_<%= node.human %>-><%= field.name %>, (const AST_NODE_T*) new_<%= node.human %>-><%= field.name %>, path, old_hashes, new_hashes, preserve_whitespace, result);
     <%- end -%>
     } break;
 

data/templates/src/errors.c.erb

@@ -1,4 +1,5 @@
 #include "include/errors.h"
+#include "include/parser/parser.h"
 #include "include/location/location.h"
 #include "include/location/position.h"
 #include "include/ast/pretty_print.h"
@@ -90,8 +91,12 @@ void error_init(ERROR_T* error, const error_type_T type, position_T start, posit
   return <%= error.human %>;
 }
 
-void append_<%= error.human %>(<%= (arguments + ["hb_array_T* errors"]).join(", ") %>) {
-  hb_array_append(errors, <%= error.human %>_init(<%= arguments.map { |argument| argument.split(" ").last.strip }.join(", ") %>));
+void append_<%= error.human %>(<%= (arguments + ["hb_array_T** errors", "const struct PARSER_OPTIONS_STRUCT* options"]).join(", ") %>) {
+  if (parser_options_errors_exceeded(options)) { return; }
+
+  hb_array_append_lazy(errors, <%= error.human %>_init(<%= arguments.map { |argument| argument.split(" ").last.strip }.join(", ") %>), allocator);
+
+  parser_options_increment_error_count(options);
 }
 <%- end -%>
 
@@ -139,7 +144,7 @@ static void error_free_<%= error.human %>(<%= error.struct_type %>* <%= error.hu
   <%- when Herb::Template::PositionField -%>
   // position_T is part of struct
   <%- when Herb::Template::StringField -%>
-  if (<%= error.human %>-><%= field.name %>.data != NULL) { hb_allocator_dealloc(allocator, <%= error.human %>-><%= field.name %>.data); }
+  if (!hb_string_is_empty(<%= error.human %>-><%= field.name %>)) { hb_allocator_dealloc(allocator, <%= error.human %>-><%= field.name %>.data); }
   <%- else -%>
   <%= field.inspect %>
   <%- end -%>

data/templates/src/include/analyze/action_view/helper_registry.h.erb

@@ -32,6 +32,13 @@ typedef struct {
   const char* description;
 } helper_option_T;
 
+typedef struct {
+  const char* name;
+  const char* type;
+  bool optional;
+  const char* description;
+} helper_block_argument_T;
+
 typedef struct {
   const char* name;
   const char* source;
@@ -39,6 +46,14 @@ typedef struct {
   const char* wrapper;
 } helper_implicit_attribute_T;
 
+typedef struct {
+  const char* source;
+  int arg_position;
+  bool skip_if_hash;
+  bool to_s_suffix_when_single;
+  int positional_arguments_with_block;
+} helper_content_T;
+
 typedef enum {
   HELPER_OUTPUT_HTML,
   HELPER_OUTPUT_TEXT,
@@ -56,6 +71,7 @@ typedef struct {
   const char* gem;
   helper_output_T output;
   const char* visibility;
+  const char* receiver;
   const char* tag_name;
   bool is_void;
   bool supports_block;
@@ -66,10 +82,13 @@ typedef struct {
   const char* signature;
   const char* documentation_url;
   const helper_implicit_attribute_T* implicit_attribute;
+  const helper_content_T* content;
   const helper_argument_T* arguments;
   size_t arguments_count;
   const helper_option_T* options;
   size_t options_count;
+  const helper_block_argument_T* block_arguments;
+  size_t block_arguments_count;
 } helper_registry_entry_T;
 
 const helper_registry_entry_T* helper_registry_get(helper_type_T type);

data/templates/src/include/analyze/herb_directive_kinds.h.erb

@@ -0,0 +1,25 @@
+#ifndef HERB_DIRECTIVE_KINDS_H
+#define HERB_DIRECTIVE_KINDS_H
+
+#include <prism.h>
+
+/**
+ * The kind a `herb:state` default gets from the Prism node it parsed into.
+ *
+ * Returns NULL for a node type that has no plain mapping. The caller decides what those become,
+ * since a call node is a bare read or a seed depending on its shape.
+ */
+static inline const char* herb_directive_kind_for_prism_type(pm_node_type_t type) {
+  switch (type) {
+<%- state_kinds.reject { |kind| kind.prism_nodes.empty? }.each do |kind| -%>
+<%- kind.prism_constants[0..-2].each do |constant| -%>
+    case <%= constant %>:
+<%- end -%>
+    case <%= kind.prism_constants.last %>: return "<%= kind.name %>";
+
+<%- end -%>
+    default: return NULL;
+  }
+}
+
+#endif

data/templates/src/include/errors.h.erb

@@ -10,6 +10,8 @@
 #include "lib/hb_buffer.h"
 #include "lib/hb_string.h"
 
+struct PARSER_OPTIONS_STRUCT;
+
 typedef enum {
 <%- errors.each do |error| -%>
   <%= error.type.upcase %>,
@@ -35,7 +37,7 @@ typedef struct {
 <%- error_arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
 <%- arguments = error_arguments + ["position_T start", "position_T end", "hb_allocator_T* allocator"] -%>
 <%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>);
-void append_<%= error.human %>(<%= (arguments << "hb_array_T* errors").join(", ") %>);
+void append_<%= error.human %>(<%= (arguments + ["hb_array_T** errors", "const struct PARSER_OPTIONS_STRUCT* options"]).join(", ") %>);
 <%- end -%>
 
 void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);

data/templates/src/include/parser/foreign_content_elements.h.erb

@@ -0,0 +1,23 @@
+#ifndef HERB_FOREIGN_CONTENT_ELEMENTS_H
+#define HERB_FOREIGN_CONTENT_ELEMENTS_H
+
+#include "parser.h"
+
+#include <stdbool.h>
+
+typedef struct {
+  const char* name;
+  foreign_content_kind_T kind;
+  bool has_end_tag;
+  bool html_only;
+} foreign_content_element_T;
+
+static const foreign_content_element_T FOREIGN_CONTENT_ELEMENTS[] = {
+<%- foreign_content_elements.each do |element| -%>
+  { "<%= element.name %>", <%= element.raw_text? ? "FOREIGN_CONTENT_RAW_TEXT" : "FOREIGN_CONTENT_RCDATA" %>, <%= element.end_tag? %>, <%= element.html_only? %> },
+<%- end -%>
+};
+
+#define FOREIGN_CONTENT_ELEMENTS_COUNT (sizeof(FOREIGN_CONTENT_ELEMENTS) / sizeof(FOREIGN_CONTENT_ELEMENTS[0]))
+
+#endif

data/templates/src/include/parser/parser_options.h.erb

@@ -0,0 +1,21 @@
+#ifndef HERB_PARSER_OPTIONS_H
+#define HERB_PARSER_OPTIONS_H
+
+#include "../lib/hb_string.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct PARSER_OPTIONS_STRUCT {
+<%- parser_options.all_c_fields.each do |field| -%>
+  <%= field.c_type %> <%= field.c_name %>;
+<%- if field.string_array? -%>
+  size_t <%= field.count_name %>;
+<%- end -%>
+<%- end -%>
+} parser_options_T;
+
+extern const parser_options_T HERB_DEFAULT_PARSER_OPTIONS;
+
+#endif

data/templates/src/include/util/html_elements.h.erb

@@ -0,0 +1,28 @@
+#ifndef HERB_HTML_ELEMENTS_H
+#define HERB_HTML_ELEMENTS_H
+
+#include "../lib/hb_string.h"
+
+// https://developer.mozilla.org/en-US/docs/Glossary/Void_element
+static hb_string_T void_tags[] = HB_STRING_LIST(
+<%- void_elements = html_elements.select(&:void?) -%>
+<%- void_elements.each_with_index do |element, index| -%>
+  <%= element.name.inspect %><%= index < void_elements.size - 1 ? "," : "" %>
+<%- end -%>
+);
+
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#boolean-attributes
+static hb_string_T boolean_attributes[] = HB_STRING_LIST(
+<%- boolean_attributes.each_with_index do |attribute, index| -%>
+  <%= attribute.inspect %><%= index < boolean_attributes.size - 1 ? "," : "" %>
+<%- end -%>
+);
+
+// https://html.spec.whatwg.org/multipage/rendering.html#the-page
+static hb_string_T whitespace_preserving_tags[] = HB_STRING_LIST(
+<%- whitespace_preserving_elements.each_with_index do |element, index| -%>
+  <%= element.inspect %><%= index < whitespace_preserving_elements.size - 1 ? "," : "" %>
+<%- end -%>
+);
+
+#endif

data/templates/src/parser_options_defaults.c.erb

@@ -0,0 +1,9 @@
+#include "include/parser/parser_options.h"
+
+#include <stddef.h>
+
+<%- entries = parser_options.all_c_fields.flat_map { |field| field.string_array? ? [[field.c_name, "NULL"], [field.count_name, "0"]] : [[field.c_name, field.pointer? ? "NULL" : field.c_default.to_s]] } -%>
+<%- prefix = "const parser_options_T HERB_DEFAULT_PARSER_OPTIONS = { " -%>
+<%- entries.each_with_index do |(name, value), index| -%>
+<%= index.zero? ? prefix : " " * prefix.length %>.<%= name %> = <%= value %><%= index < entries.length - 1 ? "," : " };" %>
+<%- end -%>