herb 0.8.4 → 0.8.5

data/src/include/analyzed_ruby.h

@@ -11,24 +11,25 @@ typedef struct ANALYZED_RUBY_STRUCT {
   pm_node_t* root;
   bool valid;
   bool parsed;
-  bool has_if_node;
-  bool has_elsif_node;
-  bool has_else_node;
-  bool has_end;
-  bool has_block_closing;
-  bool has_block_node;
-  bool has_case_node;
-  bool has_case_match_node;
-  bool has_when_node;
-  bool has_in_node;
-  bool has_for_node;
-  bool has_while_node;
-  bool has_until_node;
-  bool has_begin_node;
-  bool has_rescue_node;
-  bool has_ensure_node;
-  bool has_unless_node;
-  bool has_yield_node;
+  int if_node_count;
+  int elsif_node_count;
+  int else_node_count;
+  int end_count;
+  int block_closing_count;
+  int block_node_count;
+  int case_node_count;
+  int case_match_node_count;
+  int when_node_count;
+  int in_node_count;
+  int for_node_count;
+  int while_node_count;
+  int until_node_count;
+  int begin_node_count;
+  int rescue_node_count;
+  int ensure_node_count;
+  int unless_node_count;
+  int yield_node_count;
+  int unclosed_control_flow_count;
 } analyzed_ruby_T;
 
 analyzed_ruby_T* init_analyzed_ruby(hb_string_T source);

data/src/include/errors.h

@@ -23,6 +23,7 @@ typedef enum {
   RUBY_PARSE_ERROR,
   ERB_CONTROL_FLOW_SCOPE_ERROR,
   MISSINGERB_END_TAG_ERROR,
+  ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR,
 } error_type_T;
 
 typedef struct ERROR_STRUCT {
@@ -96,6 +97,11 @@ typedef struct {
   const char* keyword;
 } MISSINGERB_END_TAG_ERROR_T;
 
+typedef struct {
+  ERROR_T base;
+  /* no additional fields */
+} ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T;
+
 UNEXPECTED_ERROR_T* unexpected_error_init(const char* description, const char* expected, const char* found, position_T start, position_T end);
 void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors);
 UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T start, position_T end);
@@ -118,6 +124,8 @@ ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error_init(const char* ke
 void append_erb_control_flow_scope_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
 MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error_init(const char* keyword, position_T start, position_T end);
 void append_missingerb_end_tag_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
+ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error_init(position_T start, position_T end);
+void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, hb_array_T* errors);
 
 void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.4"
+#define HERB_VERSION "0.8.5"
 
 #endif

data/src/lexer.c

@@ -185,8 +185,8 @@ static token_T* lexer_parse_identifier(lexer_T* lexer) {
 // ===== ERB Parsing
 
 static token_T* lexer_parse_erb_open(lexer_T* lexer) {
-  hb_string_T erb_patterns[] = { hb_string("<%=="), hb_string("<%%="), hb_string("<%="), hb_string("<%#"),
-                                 hb_string("<%-"),  hb_string("<%%"),  hb_string("<%") };
+  hb_string_T erb_patterns[] = { hb_string("<%=="), hb_string("<%%="), hb_string("<%="),       hb_string("<%#"),
+                                 hb_string("<%-"),  hb_string("<%%"),  hb_string("<%graphql"), hb_string("<%") };
 
   lexer->state = STATE_ERB_CONTENT;
 
@@ -278,7 +278,7 @@ token_T* lexer_next_token(lexer_T* lexer) {
         return lexer_advance_with_next(lexer, strlen("<![CDATA["), TOKEN_CDATA_START);
       }
 
-      if (isalnum(lexer_peek(lexer, 1))) { return lexer_advance_current(lexer, TOKEN_HTML_TAG_START); }
+      if (isalpha(lexer_peek(lexer, 1))) { return lexer_advance_current(lexer, TOKEN_HTML_TAG_START); }
 
       if (lexer_peek_for_html_comment_start(lexer, 0)) {
         return lexer_advance_with(lexer, hb_string("<!--"), TOKEN_HTML_COMMENT_START);

data/src/parser.c

@@ -1115,7 +1115,9 @@ static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, h
           TOKEN_DASH,
           TOKEN_EQUALS,
           TOKEN_EXCLAMATION,
+          TOKEN_HTML_TAG_END,
           TOKEN_IDENTIFIER,
+          TOKEN_LT,
           TOKEN_NBSP,
           TOKEN_NEWLINE,
           TOKEN_PERCENT,
@@ -1149,11 +1151,11 @@ static size_t find_matching_close_tag(hb_array_T* nodes, size_t start_idx, hb_st
     if (node->type == AST_HTML_OPEN_TAG_NODE) {
       AST_HTML_OPEN_TAG_NODE_T* open = (AST_HTML_OPEN_TAG_NODE_T*) node;
 
-      if (hb_string_equals(hb_string(open->tag_name->value), tag_name)) { depth++; }
+      if (hb_string_equals_case_insensitive(hb_string(open->tag_name->value), tag_name)) { depth++; }
     } else if (node->type == AST_HTML_CLOSE_TAG_NODE) {
       AST_HTML_CLOSE_TAG_NODE_T* close = (AST_HTML_CLOSE_TAG_NODE_T*) node;
 
-      if (hb_string_equals(hb_string(close->tag_name->value), tag_name)) {
+      if (hb_string_equals_case_insensitive(hb_string(close->tag_name->value), tag_name)) {
         if (depth == 0) { return i; }
         depth--;
       }

data/src/parser_helpers.c

@@ -24,7 +24,7 @@ bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
   token_T* top_token = hb_array_last(parser->open_tags_stack);
   if (top_token == NULL || top_token->value == NULL) { return false; };
 
-  return hb_string_equals(hb_string(top_token->value), tag_name);
+  return hb_string_equals_case_insensitive(hb_string(top_token->value), tag_name);
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {
@@ -49,7 +49,7 @@ bool parser_in_svg_context(const parser_T* parser) {
 
     if (tag && tag->value) {
       hb_string_T tag_value_string = hb_string(tag->value);
-      if (hb_string_equals(tag_value_string, hb_string("svg"))) { return true; }
+      if (hb_string_equals_case_insensitive(tag_value_string, hb_string("svg"))) { return true; }
     }
   }
 
@@ -61,8 +61,8 @@ bool parser_in_svg_context(const parser_T* parser) {
 foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name) {
   if (hb_string_is_empty(tag_name)) { return FOREIGN_CONTENT_UNKNOWN; }
 
-  if (hb_string_equals(tag_name, hb_string("script"))) { return FOREIGN_CONTENT_SCRIPT; }
-  if (hb_string_equals(tag_name, hb_string("style"))) { return FOREIGN_CONTENT_STYLE; }
+  if (hb_string_equals_case_insensitive(tag_name, hb_string("script"))) { return FOREIGN_CONTENT_SCRIPT; }
+  if (hb_string_equals_case_insensitive(tag_name, hb_string("style"))) { return FOREIGN_CONTENT_STYLE; }
 
   return FOREIGN_CONTENT_UNKNOWN;
 }
@@ -217,5 +217,5 @@ bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_t
 
   if (hb_string_is_empty(tag_name) || hb_string_is_empty(expected_tag_name)) { return false; }
 
-  return hb_string_equals(expected_tag_name, tag_name);
+  return hb_string_equals_case_insensitive(expected_tag_name, tag_name);
 }

data/templates/lib/herb/errors.rb.erb

@@ -46,6 +46,7 @@ module Herb
     <%- errors.each do |error| -%>
     class <%= error.name -%> < Error
       include Colors
+      <%- if error.fields.any? -%>
 
       <%- error.fields.each do |field| -%>
       attr_reader :<%= field.name %> #: <%= field.ruby_type %>
@@ -54,25 +55,27 @@ module Herb
       #: (<%= [*base_arguments.map(&:last), *error.fields.map(&:ruby_type)].join(", ") %>) -> void
       def initialize(<%= [*base_arguments.map(&:first), *error.fields.map(&:name)].join(", ") %>)
         super(<%= base_arguments.map(&:first).join(", ") %>)
-
         <%- error.fields.each do |field| -%>
         @<%= field.name %> = <%= field.name %>
         <%- end -%>
       end
+      <%- end -%>
 
       #: () -> String
       def inspect
         tree_inspect.rstrip.gsub(/\s+$/, "")
       end
+      <%- if error.fields.any? -%>
 
       #: () -> serialized_<%= error.human %>
       def to_hash
-        super.merge({
-          <%- error.fields.each do |field| -%>
-          <%= field.name %>: <%= field.name %>,
+        super.merge(
+          <%- error.fields.each_with_index do |field, index| -%>
+          <%= field.name %>: <%= field.name %><%= index < error.fields.size - 1 ? "," : "" %>
           <%- end -%>
-        }) #: Herb::serialized_<%= error.human %>
+        ) #: Herb::serialized_<%= error.human %>
       end
+      <%- end -%>
 
       #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)

data/templates/src/ast_pretty_print.c.erb

@@ -1,3 +1,4 @@
+#include "include/analyze_helpers.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
@@ -62,21 +63,21 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
 
       <%- when Herb::Template::AnalyzedRubyField -%>
       if (<%= node.human %>-><%= field.name %>) {
-        pretty_print_boolean_property(hb_string("if_node"), <%= node.human %>-><%= field.name %>->has_if_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("elsif_node"), <%= node.human %>-><%= field.name %>->has_elsif_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("else_node"), <%= node.human %>-><%= field.name %>->has_else_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("end"), <%= node.human %>-><%= field.name %>->has_end, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("block_node"), <%= node.human %>-><%= field.name %>->has_block_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("block_closing"), <%= node.human %>-><%= field.name %>->has_block_closing, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("case_node"), <%= node.human %>-><%= field.name %>->has_case_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("when_node"), <%= node.human %>-><%= field.name %>->has_when_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("for_node"), <%= node.human %>-><%= field.name %>->has_for_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("while_node"), <%= node.human %>-><%= field.name %>->has_while_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("until_node"), <%= node.human %>-><%= field.name %>->has_until_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("begin_node"), <%= node.human %>-><%= field.name %>->has_begin_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("rescue_node"), <%= node.human %>-><%= field.name %>->has_rescue_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("ensure_node"), <%= node.human %>-><%= field.name %>->has_ensure_node, indent, relative_indent,  <%= last %>, buffer);
-        pretty_print_boolean_property(hb_string("unless_node"), <%= node.human %>-><%= field.name %>->has_unless_node, indent, relative_indent,  <%= last %>, buffer);
+        pretty_print_boolean_property(hb_string("if_node"), has_if_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("elsif_node"), has_elsif_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("else_node"), has_else_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("end"), has_end(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("block_node"), has_block_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("block_closing"), has_block_closing(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("case_node"), has_case_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("when_node"), has_when_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("for_node"), has_for_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("while_node"), has_while_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("until_node"), has_until_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("begin_node"), has_begin_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("rescue_node"), has_rescue_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("ensure_node"), has_ensure_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("unless_node"), has_unless_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
       } else {
       pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
         hb_buffer_append(buffer, " ∅\n");

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.8.4
+  version: 0.8.5
 platform: ruby
 authors:
 - Marco Roth