herb 0.7.4-x86-linux-gnu → 0.7.5-x86-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5686adc013e239cbb9ceda550da801ff75c8cde4ac3a9fd316317de517fa708
-  data.tar.gz: b748f6ef34c932ece85f1931cbd8f81570f19f31fd7e93730308a7f4347730ca
+  metadata.gz: 71ad6c6d788139d98397fc010ed14607fea675ff70b3180489f988f3c414d307
+  data.tar.gz: bd8aedaf8adf48873703bbf9b1d6a6b4962612ec1af4885c11758b93b66b65ff
 SHA512:
-  metadata.gz: 2d974fdb21ccba9767d354de219ca55ec8280ec4cd6ddefa69827b46625a556e29681e762b47376a4c4f80b734111fe440031c7d33e582e498bf5fc4aefe3e1f
-  data.tar.gz: e40994555945a3bca80dc7f40c77f144dc5cac517e32c6e94727a88c0b42d54d80d785c9f6bba70268b36292d86e09b74b610de823979154f81bcca4cb883460
+  metadata.gz: a120fd92055db187dc57864552caebd84cc802459fb7b8f24fd7eaef748996772c567c82aeeb4472c5c00390f223ce5fd5002efb3b666dce72e25cedd6f279b2
+  data.tar.gz: 386c42e813e0103d1fc3136634276badaae0f1455fa0ca27e8f879d3a6887088e5f49f0a955a028f9243da065304818f4a682650a77693ef6ce66912f0e60b61

data/config.yml

@@ -34,8 +34,8 @@ errors:
         arguments:
           - token_type_to_string(found->type)
           - token_type_to_string(expected_type)
-          - found->location->start->line
-          - found->location->start->column
+          - found->location.start.line
+          - found->location.start.column
 
       fields:
         - name: expected_type
@@ -49,8 +49,8 @@ errors:
         template: "Found closing tag `</%s>` at (%zu:%zu) without a matching opening tag."
         arguments:
           - closing_tag->value
-          - closing_tag->location->start->line
-          - closing_tag->location->start->column
+          - closing_tag->location.start.line
+          - closing_tag->location.start.column
 
       fields:
         - name: closing_tag
@@ -61,8 +61,8 @@ errors:
         template: "Opening tag `<%s>` at (%zu:%zu) doesn't have a matching closing tag `</%s>`."
         arguments:
           - opening_tag->value
-          - opening_tag->location->start->line
-          - opening_tag->location->start->column
+          - opening_tag->location.start.line
+          - opening_tag->location.start.column
           - opening_tag->value
 
       fields:
@@ -74,11 +74,11 @@ errors:
         template: "Opening tag `<%s>` at (%zu:%zu) closed with `</%s>` at (%zu:%zu)."
         arguments:
           - opening_tag->value
-          - opening_tag->location->start->line
-          - opening_tag->location->start->column
+          - opening_tag->location.start.line
+          - opening_tag->location.start.column
           - closing_tag->value
-          - closing_tag->location->start->line
-          - closing_tag->location->start->column
+          - closing_tag->location.start.line
+          - closing_tag->location.start.column
 
       fields:
         - name: opening_tag
@@ -93,8 +93,8 @@ errors:
         arguments:
           - opening_quote->value
           - closing_quote->value
-          - closing_quote->location->start->line
-          - closing_quote->location->start->column
+          - closing_quote->location.start.line
+          - closing_quote->location.start.column
 
       fields:
         - name: opening_quote
@@ -127,8 +127,8 @@ errors:
         template: "Tag `<%s>` opened at (%zu:%zu) was never closed before the end of document."
         arguments:
           - opening_tag->value
-          - opening_tag->location->start->line
-          - opening_tag->location->start->column
+          - opening_tag->location.start.line
+          - opening_tag->location.start.column
 
       fields:
         - name: opening_tag

data/ext/herb/extension_helpers.c

@@ -20,32 +20,26 @@ const char* check_string(VALUE value) {
   return RSTRING_PTR(value);
 }
 
-VALUE rb_position_from_c_struct(position_T* position) {
-  if (!position) { return Qnil; }
-
+VALUE rb_position_from_c_struct(position_T position) {
   VALUE args[2];
-  args[0] = SIZET2NUM(position->line);
-  args[1] = SIZET2NUM(position->column);
+  args[0] = UINT2NUM(position.line);
+  args[1] = UINT2NUM(position.column);
 
   return rb_class_new_instance(2, args, cPosition);
 }
 
-VALUE rb_location_from_c_struct(location_T* location) {
-  if (!location) { return Qnil; }
-
+VALUE rb_location_from_c_struct(location_T location) {
   VALUE args[2];
-  args[0] = rb_position_from_c_struct(location->start);
-  args[1] = rb_position_from_c_struct(location->end);
+  args[0] = rb_position_from_c_struct(location.start);
+  args[1] = rb_position_from_c_struct(location.end);
 
   return rb_class_new_instance(2, args, cLocation);
 }
 
-VALUE rb_range_from_c_struct(range_T* range) {
-  if (!range) { return Qnil; }
-
+VALUE rb_range_from_c_struct(range_T range) {
   VALUE args[2];
-  args[0] = SIZET2NUM(range->from);
-  args[1] = SIZET2NUM(range->to);
+  args[0] = UINT2NUM(range.from);
+  args[1] = UINT2NUM(range.to);
 
   return rb_class_new_instance(2, args, cRange);
 }

data/ext/herb/extension_helpers.h

@@ -12,11 +12,11 @@
 const char* check_string(VALUE value);
 VALUE read_file_to_ruby_string(const char* file_path);
 
-VALUE rb_position_from_c_struct(position_T* position);
-VALUE rb_location_from_c_struct(location_T* location);
+VALUE rb_position_from_c_struct(position_T position);
+VALUE rb_location_from_c_struct(location_T location);
 
 VALUE rb_token_from_c_struct(token_T* token);
-VALUE rb_range_from_c_struct(range_T* range);
+VALUE rb_range_from_c_struct(range_T range);
 
 VALUE create_lex_result(array_T* tokens, VALUE source);
 VALUE create_parse_result(AST_DOCUMENT_NODE_T* root, VALUE source);

data/ext/herb/nodes.c

@@ -445,7 +445,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:0x00007f64bd63b388 @name="analyzed_ruby", @options={kind: nil}> */
+  /* #<Herb::Template::AnalyzedRubyField:0x00007f952d549150 @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.rb

@@ -193,13 +193,17 @@ module Herb
     def add_code(code)
       terminate_expression
 
-      @src << " " << code
-
-      # TODO: rework and check for Prism::InlineComment as soon as we expose the Prism Nodes in the Herb AST
-      if code.include?("#")
-        @src << "\n"
+      if code.include?("=begin") || code.include?("=end")
+        @src << "\n" << code << "\n"
       else
-        @src << ";" unless code[-1] == "\n"
+        @src << " " << code
+
+        # 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
       end
 
       @buffer_on_stack = false

data/lib/herb/version.rb

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

data/src/analyze.c

@@ -96,12 +96,8 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
 
   if (!ruby) { return CONTROL_TYPE_UNKNOWN; }
 
-  if (ruby->valid) {
-    if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
-    return CONTROL_TYPE_UNKNOWN;
-  }
+  if (ruby->valid) { return CONTROL_TYPE_UNKNOWN; }
 
-  if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
   if (has_block_node(ruby)) { return CONTROL_TYPE_BLOCK; }
   if (has_if_node(ruby)) { return CONTROL_TYPE_IF; }
   if (has_elsif_node(ruby)) { return CONTROL_TYPE_ELSIF; }
@@ -119,6 +115,7 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
   if (has_until_node(ruby)) { return CONTROL_TYPE_UNTIL; }
   if (has_for_node(ruby)) { return CONTROL_TYPE_FOR; }
   if (has_block_closing(ruby)) { return CONTROL_TYPE_BLOCK_CLOSE; }
+  if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
 
   return CONTROL_TYPE_UNKNOWN;
 }
@@ -158,16 +155,16 @@ static AST_NODE_T* create_control_node(
   control_type_t control_type
 ) {
   array_T* errors = array_init(8);
-  position_T* start_position = erb_node->tag_opening->location->start;
-  position_T* end_position = erb_node->tag_closing->location->end;
+  position_T start_position = erb_node->tag_opening->location.start;
+  position_T end_position = erb_node->tag_closing->location.end;
 
   if (end_node) {
-    end_position = end_node->base.location->end;
+    end_position = end_node->base.location.end;
   } else if (children && array_size(children) > 0) {
     AST_NODE_T* last_child = array_get(children, array_size(children) - 1);
-    end_position = last_child->location->end;
+    end_position = last_child->location.end;
   } else if (subsequent) {
-    end_position = subsequent->location->end;
+    end_position = subsequent->location.end;
   }
 
   token_T* tag_opening = erb_node->tag_opening;
@@ -435,32 +432,15 @@ static size_t process_control_structure(
         array_T* when_statements = array_init(8);
         index++;
 
-        while (index < array_size(array)) {
-          AST_NODE_T* child = array_get(array, index);
-
-          if (!child) { break; }
-
-          if (child->type == AST_ERB_CONTENT_NODE) {
-            AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
-            control_type_t child_type = detect_control_type(child_erb);
-
-            if (child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_ELSE
-                || child_type == CONTROL_TYPE_END) {
-              break;
-            }
-          }
-
-          array_append(when_statements, child);
-          index++;
-        }
+        index = process_block_children(node, array, index, when_statements, context, CONTROL_TYPE_WHEN);
 
         AST_ERB_WHEN_NODE_T* when_node = ast_erb_when_node_init(
           erb_content->tag_opening,
           erb_content->content,
           erb_content->tag_closing,
           when_statements,
-          erb_content->tag_opening->location->start,
-          erb_content->tag_closing->location->end,
+          erb_content->tag_opening->location.start,
+          erb_content->tag_closing->location.end,
           array_init(8)
         );
 
@@ -471,32 +451,15 @@ static size_t process_control_structure(
         array_T* in_statements = array_init(8);
         index++;
 
-        while (index < array_size(array)) {
-          AST_NODE_T* child = array_get(array, index);
-
-          if (!child) { break; }
-
-          if (child->type == AST_ERB_CONTENT_NODE) {
-            AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
-            control_type_t child_type = detect_control_type(child_erb);
-
-            if (child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE
-                || child_type == CONTROL_TYPE_END) {
-              break;
-            }
-          }
-
-          array_append(in_statements, child);
-          index++;
-        }
+        index = process_block_children(node, array, index, in_statements, context, CONTROL_TYPE_IN);
 
         AST_ERB_IN_NODE_T* in_node = ast_erb_in_node_init(
           erb_content->tag_opening,
           erb_content->content,
           erb_content->tag_closing,
           in_statements,
-          erb_content->tag_opening->location->start,
-          erb_content->tag_closing->location->end,
+          erb_content->tag_opening->location.start,
+          erb_content->tag_closing->location.end,
           array_init(8)
         );
 
@@ -546,8 +509,8 @@ static size_t process_control_structure(
             next_erb->content,
             next_erb->tag_closing,
             else_children,
-            next_erb->tag_opening->location->start,
-            next_erb->tag_closing->location->end,
+            next_erb->tag_opening->location.start,
+            next_erb->tag_closing->location.end,
             array_init(8)
           );
         }
@@ -567,8 +530,8 @@ static size_t process_control_structure(
             end_erb->tag_opening,
             end_erb->content,
             end_erb->tag_closing,
-            end_erb->tag_opening->location->start,
-            end_erb->tag_closing->location->end,
+            end_erb->tag_opening->location.start,
+            end_erb->tag_closing->location.end,
             end_erb->base.errors
           );
 
@@ -577,19 +540,19 @@ static size_t process_control_structure(
       }
     }
 
-    position_T* start_position = erb_node->tag_opening->location->start;
-    position_T* end_position = erb_node->tag_closing->location->end;
+    position_T start_position = erb_node->tag_opening->location.start;
+    position_T end_position = erb_node->tag_closing->location.end;
 
     if (end_node) {
-      end_position = end_node->base.location->end;
+      end_position = end_node->base.location.end;
     } else if (else_clause) {
-      end_position = else_clause->base.location->end;
+      end_position = else_clause->base.location.end;
     } else if (array_size(when_conditions) > 0) {
       AST_NODE_T* last_when = array_get(when_conditions, array_size(when_conditions) - 1);
-      end_position = last_when->location->end;
+      end_position = last_when->location.end;
     } else if (array_size(in_conditions) > 0) {
       AST_NODE_T* last_in = array_get(in_conditions, array_size(in_conditions) - 1);
-      end_position = last_in->location->end;
+      end_position = last_in->location.end;
     }
 
     if (array_size(in_conditions) > 0) {
@@ -682,8 +645,8 @@ static size_t process_control_structure(
             next_erb->content,
             next_erb->tag_closing,
             else_children,
-            next_erb->tag_opening->location->start,
-            next_erb->tag_closing->location->end,
+            next_erb->tag_opening->location.start,
+            next_erb->tag_closing->location.end,
             array_init(8)
           );
         }
@@ -723,8 +686,8 @@ static size_t process_control_structure(
             next_erb->content,
             next_erb->tag_closing,
             ensure_children,
-            next_erb->tag_opening->location->start,
-            next_erb->tag_closing->location->end,
+            next_erb->tag_opening->location.start,
+            next_erb->tag_closing->location.end,
             array_init(8)
           );
         }
@@ -744,8 +707,8 @@ static size_t process_control_structure(
             end_erb->tag_opening,
             end_erb->content,
             end_erb->tag_closing,
-            end_erb->tag_opening->location->start,
-            end_erb->tag_closing->location->end,
+            end_erb->tag_opening->location.start,
+            end_erb->tag_closing->location.end,
             end_erb->base.errors
           );
 
@@ -754,17 +717,17 @@ static size_t process_control_structure(
       }
     }
 
-    position_T* start_position = erb_node->tag_opening->location->start;
-    position_T* end_position = erb_node->tag_closing->location->end;
+    position_T start_position = erb_node->tag_opening->location.start;
+    position_T end_position = erb_node->tag_closing->location.end;
 
     if (end_node) {
-      end_position = end_node->base.location->end;
+      end_position = end_node->base.location.end;
     } else if (ensure_clause) {
-      end_position = ensure_clause->base.location->end;
+      end_position = ensure_clause->base.location.end;
     } else if (else_clause) {
-      end_position = else_clause->base.location->end;
+      end_position = else_clause->base.location.end;
     } else if (rescue_clause) {
-      end_position = rescue_clause->base.location->end;
+      end_position = rescue_clause->base.location.end;
     }
 
     AST_ERB_BEGIN_NODE_T* begin_node = ast_erb_begin_node_init(
@@ -802,8 +765,8 @@ static size_t process_control_structure(
             close_erb->tag_opening,
             close_erb->content,
             close_erb->tag_closing,
-            close_erb->tag_opening->location->start,
-            close_erb->tag_closing->location->end,
+            close_erb->tag_opening->location.start,
+            close_erb->tag_closing->location.end,
             close_erb->base.errors
           );
 
@@ -812,14 +775,14 @@ static size_t process_control_structure(
       }
     }
 
-    position_T* start_position = erb_node->tag_opening->location->start;
-    position_T* end_position = erb_node->tag_closing->location->end;
+    position_T start_position = erb_node->tag_opening->location.start;
+    position_T end_position = erb_node->tag_closing->location.end;
 
     if (end_node) {
-      end_position = end_node->base.location->end;
+      end_position = end_node->base.location.end;
     } else if (children && array_size(children) > 0) {
       AST_NODE_T* last_child = array_get(children, array_size(children) - 1);
-      end_position = last_child->location->end;
+      end_position = last_child->location.end;
     }
 
     AST_ERB_BLOCK_NODE_T* block_node = ast_erb_block_node_init(
@@ -866,8 +829,8 @@ static size_t process_control_structure(
           end_erb->tag_opening,
           end_erb->content,
           end_erb->tag_closing,
-          end_erb->tag_opening->location->start,
-          end_erb->tag_closing->location->end,
+          end_erb->tag_opening->location.start,
+          end_erb->tag_closing->location.end,
           end_erb->base.errors
         );
 

data/src/ast_node.c

@@ -12,11 +12,12 @@ size_t ast_node_sizeof(void) {
   return sizeof(struct AST_NODE_STRUCT);
 }
 
-void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T* start, position_T* end, array_T* errors) {
+void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T start, position_T end, array_T* errors) {
   if (!node) { return; }
 
   node->type = type;
-  node->location = location_init(position_copy(start), position_copy(end));
+  node->location.start = start;
+  node->location.end = end;
 
   if (errors == NULL) {
     node->errors = array_init(8);
@@ -28,7 +29,7 @@ void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T* sta
 AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token) {
   AST_LITERAL_NODE_T* literal = malloc(sizeof(AST_LITERAL_NODE_T));
 
-  ast_node_init(&literal->base, AST_LITERAL_NODE, token->location->start, token->location->end, NULL);
+  ast_node_init(&literal->base, AST_LITERAL_NODE, token->location.start, token->location.end, NULL);
 
   literal->content = herb_strdup(token->value);
 
@@ -51,24 +52,20 @@ void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error) {
   array_append(node->errors, error);
 }
 
-void ast_node_set_start(AST_NODE_T* node, position_T* position) {
-  if (node->location->start != NULL) { position_free(node->location->start); }
-
-  node->location->start = position_copy(position);
+void ast_node_set_start(AST_NODE_T* node, position_T position) {
+  node->location.start = position;
 }
 
-void ast_node_set_end(AST_NODE_T* node, position_T* position) {
-  if (node->location->end != NULL) { position_free(node->location->end); }
-
-  node->location->end = position_copy(position);
+void ast_node_set_end(AST_NODE_T* node, position_T position) {
+  node->location.end = position;
 }
 
 void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token) {
-  ast_node_set_start(node, token->location->start);
+  ast_node_set_start(node, token->location.start);
 }
 
 void ast_node_set_end_from_token(AST_NODE_T* node, const token_T* token) {
-  ast_node_set_end(node, token->location->end);
+  ast_node_set_end(node, token->location.end);
 }
 
 void ast_node_set_positions_from_token(AST_NODE_T* node, const token_T* token) {