herb 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10b9ca3614ee3b23c37caf0f7d7363a434c15a39b27e3dc8c83023ec4f0587b1
-  data.tar.gz: 4be0d44ce17912901556481b7fb21ee18c5f7b71165c98f4e2cee6961614c626
+  metadata.gz: a552819ddaf0c50275110d19455609f491dfb3298da4b76e898eb996bc458e4a
+  data.tar.gz: 835fc30e2530c8c98aa2077d607f061f78f5ae4030e3c3d449bc2ac9796a6ea4
 SHA512:
-  metadata.gz: '00879b8718267317125d050da50cc6423f33e1765c236c470c5ea5ff1da8e8ad57b1c0c35a8d7a3a4b75200f3f00beacfbc17d14b6d44886cdf8b5e67ac033f0'
-  data.tar.gz: b7f7583d3dd1cce9bf9021cc8a33d1936bab1e3e1cd681d77bf6e4f4d9e6be25b332b742ad9c1e5c079f13f363d3a21a3188affbac96f84a77f4160cbb9498a2
+  metadata.gz: 3b9e9362ffce00e457a3df27e834419f5a8a0351ef313b7b73b0ae7a0f44dd4689dde96586342ed11ea736ac16baff2473fbab23f141b8f51bdc92aef7cc9d44
+  data.tar.gz: e76c844b40670b773106547cefd1955fb42867f08f49134557946b24f008187a1cdea4c5f010c40e27505c6dd4bdd4c4f5fa1aae16f92ab45f3a2dbff867d082

data/config.yml

@@ -336,6 +336,80 @@ errors:
         - name: nested_tag_column
           type: size_t
 
+    - name: RenderAmbiguousLocalsError
+      message:
+        template: "Did you mean `render partial: '%s', locals: { ... }`? Using `render '%s', locals: { ... }` passes a local variable named `locals` to the partial instead of setting the `locals:` option."
+        arguments:
+          - partial
+          - partial
+
+      fields:
+        - name: partial
+          type: string
+
+    - name: RenderMissingLocalsError
+      message:
+        template: "Wrap `%s` in `locals: { ... }` when using `partial:`. Use `render partial: '%s', locals: { %s }` instead. Without `locals:`, these keyword arguments are ignored."
+        arguments:
+          - keywords
+          - partial
+          - keywords
+
+      fields:
+        - name: partial
+          type: string
+
+        - name: keywords
+          type: string
+
+    - name: RenderNoArgumentsError
+      message:
+        template: "No arguments passed to `render`. It needs a partial name, a keyword argument like `partial:`, `template:`, or `layout:`, or a renderable object."
+        arguments: []
+
+      fields: []
+
+    - name: RenderConflictingPartialError
+      message:
+        template: "Both a positional partial `'%s'` and a keyword `partial: '%s'` were passed to `render`. Use one form or the other, not both."
+        arguments:
+          - positional_partial
+          - keyword_partial
+
+      fields:
+        - name: positional_partial
+          type: string
+
+        - name: keyword_partial
+          type: string
+
+    - name: RenderInvalidAsOptionError
+      message:
+        template: "The `as:` value `'%s'` is not a valid Ruby identifier. Use a name that starts with a lowercase letter or underscore, like `as: :item`."
+        arguments:
+          - as_value
+
+      fields:
+        - name: as_value
+          type: string
+
+    - name: RenderObjectAndCollectionError
+      message:
+        template: "The `object:` and `collection:` options are mutually exclusive. Use one or the other in your `render` call."
+        arguments: []
+
+      fields: []
+
+    - name: RenderLayoutWithoutBlockError
+      message:
+        template: "Layout rendering needs a block. Use `render layout: '%s' do ... end` so the layout has content to wrap."
+        arguments:
+          - layout
+
+      fields:
+        - name: layout
+          type: string
+
 warnings:
   fields: []
   types: []
@@ -1013,6 +1087,88 @@ nodes:
           type: node
           kind: ERBEndNode
 
+    - name: RubyRenderLocalNode
+      fields:
+        - name: name
+          type: token
+
+        - name: value
+          type: node
+          kind: RubyLiteralNode
+
+    - name: ERBRenderNode
+      fields:
+        - name: tag_opening
+          type: token
+
+        - name: content
+          type: token
+
+        - name: tag_closing
+          type: token
+
+        - name: analyzed_ruby
+          type: analyzed_ruby
+
+        - name: prism_node
+          type: prism_node
+
+        - name: partial
+          type: token
+
+        - name: template_path
+          type: token
+
+        - name: layout
+          type: token
+
+        - name: file
+          type: token
+
+        - name: inline_template
+          type: token
+
+        - name: body
+          type: token
+
+        - name: plain
+          type: token
+
+        - name: html
+          type: token
+
+        - name: renderable
+          type: token
+
+        - name: collection
+          type: token
+
+        - name: object
+          type: token
+
+        - name: as_name
+          type: token
+
+        - name: spacer_template
+          type: token
+
+        - name: formats
+          type: token
+
+        - name: variants
+          type: token
+
+        - name: handlers
+          type: token
+
+        - name: content_type
+          type: token
+
+        - name: locals
+          type: array
+          kind:
+            - RubyRenderLocalNode
+
     - name: ERBYieldNode
       fields:
         - name: tag_opening

data/ext/herb/error_helpers.c

@@ -39,6 +39,13 @@ static VALUE cMissingAttributeValueError;
 static VALUE cUnclosedERBTagError;
 static VALUE cStrayERBClosingTagError;
 static VALUE cNestedERBTagError;
+static VALUE cRenderAmbiguousLocalsError;
+static VALUE cRenderMissingLocalsError;
+static VALUE cRenderNoArgumentsError;
+static VALUE cRenderConflictingPartialError;
+static VALUE cRenderInvalidAsOptionError;
+static VALUE cRenderObjectAndCollectionError;
+static VALUE cRenderLayoutWithoutBlockError;
 
 void rb_init_error_classes(void) {
   mErrors = rb_define_module_under(mHerb, "Errors");
@@ -66,6 +73,13 @@ void rb_init_error_classes(void) {
   cUnclosedERBTagError = rb_define_class_under(mErrors, "UnclosedERBTagError", cError);
   cStrayERBClosingTagError = rb_define_class_under(mErrors, "StrayERBClosingTagError", cError);
   cNestedERBTagError = rb_define_class_under(mErrors, "NestedERBTagError", cError);
+  cRenderAmbiguousLocalsError = rb_define_class_under(mErrors, "RenderAmbiguousLocalsError", cError);
+  cRenderMissingLocalsError = rb_define_class_under(mErrors, "RenderMissingLocalsError", cError);
+  cRenderNoArgumentsError = rb_define_class_under(mErrors, "RenderNoArgumentsError", cError);
+  cRenderConflictingPartialError = rb_define_class_under(mErrors, "RenderConflictingPartialError", cError);
+  cRenderInvalidAsOptionError = rb_define_class_under(mErrors, "RenderInvalidAsOptionError", cError);
+  cRenderObjectAndCollectionError = rb_define_class_under(mErrors, "RenderObjectAndCollectionError", cError);
+  cRenderLayoutWithoutBlockError = rb_define_class_under(mErrors, "RenderLayoutWithoutBlockError", cError);
 }
 
 static VALUE rb_unexpected_error_from_c_struct(UNEXPECTED_ERROR_T* unexpected_error) {
@@ -582,6 +596,153 @@ static VALUE rb_nested_erb_tag_error_from_c_struct(NESTED_ERB_TAG_ERROR_T* neste
   return rb_class_new_instance(6, args, cNestedERBTagError);
 };
 
+static VALUE rb_render_ambiguous_locals_error_from_c_struct(RENDER_AMBIGUOUS_LOCALS_ERROR_T* render_ambiguous_locals_error) {
+  if (render_ambiguous_locals_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_ambiguous_locals_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE render_ambiguous_locals_error_partial = rb_utf8_str_new(render_ambiguous_locals_error->partial.data, render_ambiguous_locals_error->partial.length);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    render_ambiguous_locals_error_partial
+  };
+
+  return rb_class_new_instance(4, args, cRenderAmbiguousLocalsError);
+};
+
+static VALUE rb_render_missing_locals_error_from_c_struct(RENDER_MISSING_LOCALS_ERROR_T* render_missing_locals_error) {
+  if (render_missing_locals_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_missing_locals_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE render_missing_locals_error_partial = rb_utf8_str_new(render_missing_locals_error->partial.data, render_missing_locals_error->partial.length);
+  VALUE render_missing_locals_error_keywords = rb_utf8_str_new(render_missing_locals_error->keywords.data, render_missing_locals_error->keywords.length);
+
+  VALUE args[5] = {
+    type,
+    location,
+    message,
+    render_missing_locals_error_partial,
+    render_missing_locals_error_keywords
+  };
+
+  return rb_class_new_instance(5, args, cRenderMissingLocalsError);
+};
+
+static VALUE rb_render_no_arguments_error_from_c_struct(RENDER_NO_ARGUMENTS_ERROR_T* render_no_arguments_error) {
+  if (render_no_arguments_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_no_arguments_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+
+  VALUE args[3] = {
+    type,
+    location,
+    message
+  };
+
+  return rb_class_new_instance(3, args, cRenderNoArgumentsError);
+};
+
+static VALUE rb_render_conflicting_partial_error_from_c_struct(RENDER_CONFLICTING_PARTIAL_ERROR_T* render_conflicting_partial_error) {
+  if (render_conflicting_partial_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_conflicting_partial_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE render_conflicting_partial_error_positional_partial = rb_utf8_str_new(render_conflicting_partial_error->positional_partial.data, render_conflicting_partial_error->positional_partial.length);
+  VALUE render_conflicting_partial_error_keyword_partial = rb_utf8_str_new(render_conflicting_partial_error->keyword_partial.data, render_conflicting_partial_error->keyword_partial.length);
+
+  VALUE args[5] = {
+    type,
+    location,
+    message,
+    render_conflicting_partial_error_positional_partial,
+    render_conflicting_partial_error_keyword_partial
+  };
+
+  return rb_class_new_instance(5, args, cRenderConflictingPartialError);
+};
+
+static VALUE rb_render_invalid_as_option_error_from_c_struct(RENDER_INVALID_AS_OPTION_ERROR_T* render_invalid_as_option_error) {
+  if (render_invalid_as_option_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_invalid_as_option_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE render_invalid_as_option_error_as_value = rb_utf8_str_new(render_invalid_as_option_error->as_value.data, render_invalid_as_option_error->as_value.length);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    render_invalid_as_option_error_as_value
+  };
+
+  return rb_class_new_instance(4, args, cRenderInvalidAsOptionError);
+};
+
+static VALUE rb_render_object_and_collection_error_from_c_struct(RENDER_OBJECT_AND_COLLECTION_ERROR_T* render_object_and_collection_error) {
+  if (render_object_and_collection_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_object_and_collection_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+
+  VALUE args[3] = {
+    type,
+    location,
+    message
+  };
+
+  return rb_class_new_instance(3, args, cRenderObjectAndCollectionError);
+};
+
+static VALUE rb_render_layout_without_block_error_from_c_struct(RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T* render_layout_without_block_error) {
+  if (render_layout_without_block_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_layout_without_block_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE render_layout_without_block_error_layout = rb_utf8_str_new(render_layout_without_block_error->layout.data, render_layout_without_block_error->layout.length);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    render_layout_without_block_error_layout
+  };
+
+  return rb_class_new_instance(4, args, cRenderLayoutWithoutBlockError);
+};
+
 
 VALUE rb_error_from_c_struct(ERROR_T* error) {
   if (!error) { return Qnil; }
@@ -610,6 +771,13 @@ VALUE rb_error_from_c_struct(ERROR_T* error) {
     case UNCLOSED_ERB_TAG_ERROR: return rb_unclosed_erb_tag_error_from_c_struct((UNCLOSED_ERB_TAG_ERROR_T*) error); break;
     case STRAY_ERB_CLOSING_TAG_ERROR: return rb_stray_erb_closing_tag_error_from_c_struct((STRAY_ERB_CLOSING_TAG_ERROR_T*) error); break;
     case NESTED_ERB_TAG_ERROR: return rb_nested_erb_tag_error_from_c_struct((NESTED_ERB_TAG_ERROR_T*) error); break;
+    case RENDER_AMBIGUOUS_LOCALS_ERROR: return rb_render_ambiguous_locals_error_from_c_struct((RENDER_AMBIGUOUS_LOCALS_ERROR_T*) error); break;
+    case RENDER_MISSING_LOCALS_ERROR: return rb_render_missing_locals_error_from_c_struct((RENDER_MISSING_LOCALS_ERROR_T*) error); break;
+    case RENDER_NO_ARGUMENTS_ERROR: return rb_render_no_arguments_error_from_c_struct((RENDER_NO_ARGUMENTS_ERROR_T*) error); break;
+    case RENDER_CONFLICTING_PARTIAL_ERROR: return rb_render_conflicting_partial_error_from_c_struct((RENDER_CONFLICTING_PARTIAL_ERROR_T*) error); break;
+    case RENDER_INVALID_AS_OPTION_ERROR: return rb_render_invalid_as_option_error_from_c_struct((RENDER_INVALID_AS_OPTION_ERROR_T*) error); break;
+    case RENDER_OBJECT_AND_COLLECTION_ERROR: return rb_render_object_and_collection_error_from_c_struct((RENDER_OBJECT_AND_COLLECTION_ERROR_T*) error); break;
+    case RENDER_LAYOUT_WITHOUT_BLOCK_ERROR: return rb_render_layout_without_block_error_from_c_struct((RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T*) error); break;
   }
 
   return Qnil;

data/ext/herb/extension.c

@@ -136,6 +136,10 @@ static VALUE Herb_parse(int argc, VALUE* argv, VALUE self) {
     }
     if (!NIL_P(action_view_helpers) && RTEST(action_view_helpers)) { parser_options.action_view_helpers = true; }
 
+    VALUE render_nodes = rb_hash_lookup(options, rb_utf8_str_new_cstr("render_nodes"));
+    if (NIL_P(render_nodes)) { render_nodes = rb_hash_lookup(options, ID2SYM(rb_intern("render_nodes"))); }
+    if (!NIL_P(render_nodes) && RTEST(render_nodes)) { parser_options.render_nodes = true; }
+
     VALUE prism_nodes = rb_hash_lookup(options, rb_utf8_str_new_cstr("prism_nodes"));
     if (NIL_P(prism_nodes)) { prism_nodes = rb_hash_lookup(options, ID2SYM(rb_intern("prism_nodes"))); }
     if (!NIL_P(prism_nodes) && RTEST(prism_nodes)) { parser_options.prism_nodes = true; }

data/ext/herb/extension_helpers.c

@@ -89,6 +89,7 @@ VALUE create_parse_result(AST_DOCUMENT_NODE_T* root, VALUE source, const parser_
   rb_hash_aset(kwargs, ID2SYM(rb_intern("track_whitespace")), options->track_whitespace ? Qtrue : Qfalse);
   rb_hash_aset(kwargs, ID2SYM(rb_intern("analyze")), options->analyze ? Qtrue : Qfalse);
   rb_hash_aset(kwargs, ID2SYM(rb_intern("action_view_helpers")), options->action_view_helpers ? Qtrue : Qfalse);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("render_nodes")), options->render_nodes ? Qtrue : Qfalse);
   rb_hash_aset(kwargs, ID2SYM(rb_intern("prism_nodes")), options->prism_nodes ? Qtrue : Qfalse);
   rb_hash_aset(kwargs, ID2SYM(rb_intern("prism_nodes_deep")), options->prism_nodes_deep ? Qtrue : Qfalse);
   rb_hash_aset(kwargs, ID2SYM(rb_intern("prism_program")), options->prism_program ? Qtrue : Qfalse);

data/ext/herb/nodes.c

@@ -53,6 +53,8 @@ static VALUE cERBRescueNode;
 static VALUE cERBEnsureNode;
 static VALUE cERBBeginNode;
 static VALUE cERBUnlessNode;
+static VALUE cRubyRenderLocalNode;
+static VALUE cERBRenderNode;
 static VALUE cERBYieldNode;
 static VALUE cERBInNode;
 
@@ -95,6 +97,8 @@ void rb_init_node_classes(void) {
   cERBEnsureNode = rb_define_class_under(mAST, "ERBEnsureNode", cNode);
   cERBBeginNode = rb_define_class_under(mAST, "ERBBeginNode", cNode);
   cERBUnlessNode = rb_define_class_under(mAST, "ERBUnlessNode", cNode);
+  cRubyRenderLocalNode = rb_define_class_under(mAST, "RubyRenderLocalNode", cNode);
+  cERBRenderNode = rb_define_class_under(mAST, "ERBRenderNode", cNode);
   cERBYieldNode = rb_define_class_under(mAST, "ERBYieldNode", cNode);
   cERBInNode = rb_define_class_under(mAST, "ERBInNode", cNode);
 }
@@ -1260,6 +1264,110 @@ static VALUE rb_erb_unless_node_from_c_struct(AST_ERB_UNLESS_NODE_T* erb_unless_
   return rb_class_new_instance(11, args, cERBUnlessNode);
 };
 
+static VALUE rb_ruby_render_local_node_from_c_struct(AST_RUBY_RENDER_LOCAL_NODE_T* ruby_render_local_node) {
+  if (ruby_render_local_node == NULL) { return Qnil; }
+
+  AST_NODE_T* node = &ruby_render_local_node->base;
+
+  VALUE type = rb_string_from_hb_string(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);
+
+  VALUE ruby_render_local_node_name = rb_token_from_c_struct(ruby_render_local_node->name);
+  VALUE ruby_render_local_node_value = rb_node_from_c_struct((AST_NODE_T*) ruby_render_local_node->value);
+
+  VALUE args[5] = {
+    type,
+    location,
+    errors,
+    ruby_render_local_node_name,
+    ruby_render_local_node_value
+  };
+
+  return rb_class_new_instance(5, args, cRubyRenderLocalNode);
+};
+
+static VALUE rb_erb_render_node_from_c_struct(AST_ERB_RENDER_NODE_T* erb_render_node) {
+  if (erb_render_node == NULL) { return Qnil; }
+
+  AST_NODE_T* node = &erb_render_node->base;
+
+  VALUE type = rb_string_from_hb_string(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);
+
+  VALUE erb_render_node_tag_opening = rb_token_from_c_struct(erb_render_node->tag_opening);
+  VALUE erb_render_node_content = rb_token_from_c_struct(erb_render_node->content);
+  VALUE erb_render_node_tag_closing = rb_token_from_c_struct(erb_render_node->tag_closing);
+  /* analyzed_ruby is internal parser state, not exposed to Ruby */
+  VALUE erb_render_node_analyzed_ruby = Qnil;
+  VALUE erb_render_node_prism_node;
+  if (erb_render_node->prism_node.node != NULL && erb_render_node->prism_node.parser != NULL) {
+    pm_buffer_t pm_buffer = { 0 };
+    pm_serialize(erb_render_node->prism_node.parser, erb_render_node->prism_node.node, &pm_buffer);
+
+    if (pm_buffer.length > 0) {
+      erb_render_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
+      rb_enc_associate(erb_render_node_prism_node, rb_ascii8bit_encoding());
+      OBJ_FREEZE(erb_render_node_prism_node);
+    } else {
+      erb_render_node_prism_node = Qnil;
+    }
+    pm_buffer_free(&pm_buffer);
+  } else {
+    erb_render_node_prism_node = Qnil;
+  }
+  VALUE erb_render_node_partial = rb_token_from_c_struct(erb_render_node->partial);
+  VALUE erb_render_node_template_path = rb_token_from_c_struct(erb_render_node->template_path);
+  VALUE erb_render_node_layout = rb_token_from_c_struct(erb_render_node->layout);
+  VALUE erb_render_node_file = rb_token_from_c_struct(erb_render_node->file);
+  VALUE erb_render_node_inline_template = rb_token_from_c_struct(erb_render_node->inline_template);
+  VALUE erb_render_node_body = rb_token_from_c_struct(erb_render_node->body);
+  VALUE erb_render_node_plain = rb_token_from_c_struct(erb_render_node->plain);
+  VALUE erb_render_node_html = rb_token_from_c_struct(erb_render_node->html);
+  VALUE erb_render_node_renderable = rb_token_from_c_struct(erb_render_node->renderable);
+  VALUE erb_render_node_collection = rb_token_from_c_struct(erb_render_node->collection);
+  VALUE erb_render_node_object = rb_token_from_c_struct(erb_render_node->object);
+  VALUE erb_render_node_as_name = rb_token_from_c_struct(erb_render_node->as_name);
+  VALUE erb_render_node_spacer_template = rb_token_from_c_struct(erb_render_node->spacer_template);
+  VALUE erb_render_node_formats = rb_token_from_c_struct(erb_render_node->formats);
+  VALUE erb_render_node_variants = rb_token_from_c_struct(erb_render_node->variants);
+  VALUE erb_render_node_handlers = rb_token_from_c_struct(erb_render_node->handlers);
+  VALUE erb_render_node_content_type = rb_token_from_c_struct(erb_render_node->content_type);
+  VALUE erb_render_node_locals = rb_nodes_array_from_c_array(erb_render_node->locals);
+
+  VALUE args[26] = {
+    type,
+    location,
+    errors,
+    erb_render_node_tag_opening,
+    erb_render_node_content,
+    erb_render_node_tag_closing,
+    erb_render_node_analyzed_ruby,
+    erb_render_node_prism_node,
+    erb_render_node_partial,
+    erb_render_node_template_path,
+    erb_render_node_layout,
+    erb_render_node_file,
+    erb_render_node_inline_template,
+    erb_render_node_body,
+    erb_render_node_plain,
+    erb_render_node_html,
+    erb_render_node_renderable,
+    erb_render_node_collection,
+    erb_render_node_object,
+    erb_render_node_as_name,
+    erb_render_node_spacer_template,
+    erb_render_node_formats,
+    erb_render_node_variants,
+    erb_render_node_handlers,
+    erb_render_node_content_type,
+    erb_render_node_locals
+  };
+
+  return rb_class_new_instance(26, args, cERBRenderNode);
+};
+
 static VALUE rb_erb_yield_node_from_c_struct(AST_ERB_YIELD_NODE_T* erb_yield_node) {
   if (erb_yield_node == NULL) { return Qnil; }
 
@@ -1355,6 +1463,8 @@ VALUE rb_node_from_c_struct(AST_NODE_T* node) {
     case AST_ERB_ENSURE_NODE: return rb_erb_ensure_node_from_c_struct((AST_ERB_ENSURE_NODE_T*) node); break;
     case AST_ERB_BEGIN_NODE: return rb_erb_begin_node_from_c_struct((AST_ERB_BEGIN_NODE_T*) node); break;
     case AST_ERB_UNLESS_NODE: return rb_erb_unless_node_from_c_struct((AST_ERB_UNLESS_NODE_T*) node); break;
+    case AST_RUBY_RENDER_LOCAL_NODE: return rb_ruby_render_local_node_from_c_struct((AST_RUBY_RENDER_LOCAL_NODE_T*) node); break;
+    case AST_ERB_RENDER_NODE: return rb_erb_render_node_from_c_struct((AST_ERB_RENDER_NODE_T*) node); break;
     case AST_ERB_YIELD_NODE: return rb_erb_yield_node_from_c_struct((AST_ERB_YIELD_NODE_T*) node); break;
     case AST_ERB_IN_NODE: return rb_erb_in_node_from_c_struct((AST_ERB_IN_NODE_T*) node); break;
   }