herb 0.9.4-arm-linux-gnu → 0.9.6-arm-linux-gnu

data/src/analyze/strict_locals.c

@@ -2,12 +2,14 @@
 #include "../include/analyze/action_view/tag_helper_node_builders.h"
 #include "../include/analyze/action_view/tag_helpers.h"
 #include "../include/analyze/analyze.h"
+#include "../include/analyze/helpers.h"
 #include "../include/ast/ast_nodes.h"
 #include "../include/errors.h"
 #include "../include/lib/hb_allocator.h"
 #include "../include/lib/hb_array.h"
 #include "../include/lib/hb_buffer.h"
 #include "../include/lib/hb_string.h"
+#include "../include/lib/string.h"
 #include "../include/util/util.h"
 #include "../include/visitor.h"
 
@@ -101,40 +103,9 @@ static pm_parameters_node_t* find_parameters_node(pm_node_t* root) {
   return def_node->parameters;
 }
 
-static token_T* create_strict_local_token(
-  const uint8_t* prism_node_start,
-  const uint8_t* prism_node_end,
-  const char* name,
-  token_type_T type,
-  const char* source,
-  size_t erb_content_byte_offset,
-  const char* content_bytes,
-  const char* params_open,
-  const uint8_t* synthetic_start,
-  hb_allocator_T* allocator
-) {
-  size_t params_in_content = (size_t) (params_open - content_bytes);
-  size_t prism_start_in_synthetic = (size_t) (prism_node_start - synthetic_start);
-  size_t prism_end_in_synthetic = (size_t) (prism_node_end - synthetic_start);
-  size_t content_start = params_in_content + (prism_start_in_synthetic - strlen(SYNTHETIC_PREFIX));
-  size_t content_end = params_in_content + (prism_end_in_synthetic - strlen(SYNTHETIC_PREFIX));
-
-  position_T start = byte_offset_to_position(source, erb_content_byte_offset + content_start);
-  position_T end = byte_offset_to_position(source, erb_content_byte_offset + content_end);
-
-  return create_synthetic_token(allocator, name, type, start, end);
-}
-
-static char* extract_name_from_location(pm_location_t name_location, hb_allocator_T* allocator) {
-  size_t length = (size_t) (name_location.end - name_location.start);
-
-  if (length > 0 && name_location.start[length - 1] == ':') { length--; }
-
-  return hb_allocator_strndup(allocator, (const char*) name_location.start, length);
-}
-
 static hb_array_T* extract_strict_locals(
   pm_parameters_node_t* params,
+  pm_parser_t* parser,
   const char* source,
   size_t erb_content_byte_offset,
   const char* content_bytes,
@@ -143,317 +114,29 @@ static hb_array_T* extract_strict_locals(
   hb_array_T* errors,
   hb_allocator_T* allocator
 ) {
-  hb_array_T* locals = hb_array_init(4, allocator);
-
-  if (!params) { return locals; }
-
-  for (size_t index = 0; index < params->optionals.size; index++) {
-    pm_node_t* optional = params->optionals.nodes[index];
-    if (!optional || optional->type != PM_OPTIONAL_PARAMETER_NODE) { continue; }
+  if (!params) { return hb_array_init(0, allocator); }
 
-    pm_optional_parameter_node_t* optional_param = (pm_optional_parameter_node_t*) optional;
-    pm_location_t location = optional_param->name_loc;
-    size_t length = (size_t) (location.end - location.start);
-    char* name = hb_allocator_strndup(allocator, (const char*) location.start, length);
-
-    token_T* name_token = create_strict_local_token(
-      location.start,
-      location.end,
-      name,
-      TOKEN_IDENTIFIER,
-      source,
-      erb_content_byte_offset,
-      content_bytes,
-      params_open,
-      synthetic_start,
-      allocator
-    );
-
-    position_T start = name_token ? name_token->location.start : (position_T) { .line = 1, .column = 1 };
-    position_T end = name_token ? name_token->location.end : start;
-
-    size_t value_prism_start = (size_t) (optional_param->value->location.start - synthetic_start);
-    size_t value_prism_end = (size_t) (optional_param->value->location.end - synthetic_start);
-    size_t params_in_content = (size_t) (params_open - content_bytes);
-    size_t value_content_start = params_in_content + (value_prism_start - strlen(SYNTHETIC_PREFIX));
-    size_t value_content_end = params_in_content + (value_prism_end - strlen(SYNTHETIC_PREFIX));
-
-    size_t value_length = value_prism_end - value_prism_start;
-    char* value_string =
-      hb_allocator_strndup(allocator, (const char*) optional_param->value->location.start, value_length);
-
-    position_T value_start = byte_offset_to_position(source, erb_content_byte_offset + value_content_start);
-    position_T value_end = byte_offset_to_position(source, erb_content_byte_offset + value_content_end);
-
-    AST_RUBY_LITERAL_NODE_T* value_node = ast_ruby_literal_node_init(
-      hb_string_from_c_string(value_string),
-      value_start,
-      value_end,
-      hb_array_init(0, allocator),
-      allocator
-    );
-
-    hb_array_T* node_errors = hb_array_init(1, allocator);
-    append_strict_locals_positional_argument_error(hb_string_from_c_string(name), start, end, allocator, node_errors);
-
-    AST_RUBY_STRICT_LOCAL_NODE_T* local =
-      ast_ruby_strict_local_node_init(name_token, value_node, false, false, start, value_end, node_errors, allocator);
-
-    hb_array_append(locals, local);
-    hb_allocator_dealloc(allocator, name);
-    hb_allocator_dealloc(allocator, value_string);
-  }
-
-  for (size_t index = 0; index < params->requireds.size; index++) {
-    pm_node_t* required = params->requireds.nodes[index];
-    if (!required) { continue; }
-
-    pm_location_t location = required->location;
-    size_t length = (size_t) (location.end - location.start);
-    char* name = hb_allocator_strndup(allocator, (const char*) location.start, length);
-
-    token_T* name_token = create_strict_local_token(
-      location.start,
-      location.end,
-      name,
-      TOKEN_IDENTIFIER,
-      source,
-      erb_content_byte_offset,
-      content_bytes,
-      params_open,
-      synthetic_start,
-      allocator
-    );
-
-    position_T start = name_token ? name_token->location.start : (position_T) { .line = 1, .column = 1 };
-    position_T end = name_token ? name_token->location.end : start;
-
-    hb_array_T* node_errors = hb_array_init(1, allocator);
-    append_strict_locals_positional_argument_error(hb_string_from_c_string(name), start, end, allocator, node_errors);
-
-    AST_RUBY_STRICT_LOCAL_NODE_T* local =
-      ast_ruby_strict_local_node_init(name_token, NULL, true, false, start, end, node_errors, allocator);
-
-    hb_array_append(locals, local);
-    hb_allocator_dealloc(allocator, name);
-  }
-
-  if (params->block) {
-    pm_block_parameter_node_t* block_param = params->block;
-
-    if (block_param->name) {
-      size_t length = (size_t) (block_param->name_loc.end - block_param->name_loc.start);
-      char* name = hb_allocator_strndup(allocator, (const char*) block_param->name_loc.start, length);
-
-      token_T* name_token = create_strict_local_token(
-        block_param->name_loc.start,
-        block_param->name_loc.end,
-        name,
-        TOKEN_IDENTIFIER,
-        source,
-        erb_content_byte_offset,
-        content_bytes,
-        params_open,
-        synthetic_start,
-        allocator
-      );
-
-      position_T start = name_token ? name_token->location.start : (position_T) { .line = 1, .column = 1 };
-      position_T end = name_token ? name_token->location.end : start;
-
-      hb_array_T* node_errors = hb_array_init(1, allocator);
-      append_strict_locals_block_argument_error(hb_string_from_c_string(name), start, end, allocator, node_errors);
-
-      AST_RUBY_STRICT_LOCAL_NODE_T* local =
-        ast_ruby_strict_local_node_init(name_token, NULL, false, false, start, end, node_errors, allocator);
-
-      hb_array_append(locals, local);
-      hb_allocator_dealloc(allocator, name);
-    }
-  }
-
-  if (params->rest && params->rest->type == PM_REST_PARAMETER_NODE) {
-    pm_rest_parameter_node_t* splat_param = (pm_rest_parameter_node_t*) params->rest;
-
-    if (splat_param->name) {
-      size_t length = (size_t) (splat_param->name_loc.end - splat_param->name_loc.start);
-      char* name = hb_allocator_strndup(allocator, (const char*) splat_param->name_loc.start, length);
-
-      token_T* name_token = create_strict_local_token(
-        splat_param->name_loc.start,
-        splat_param->name_loc.end,
-        name,
-        TOKEN_IDENTIFIER,
-        source,
-        erb_content_byte_offset,
-        content_bytes,
-        params_open,
-        synthetic_start,
-        allocator
-      );
-
-      position_T start = name_token ? name_token->location.start : (position_T) { .line = 1, .column = 1 };
-      position_T end = name_token ? name_token->location.end : start;
-
-      hb_array_T* node_errors = hb_array_init(1, allocator);
-      append_strict_locals_splat_argument_error(hb_string_from_c_string(name), start, end, allocator, node_errors);
-
-      AST_RUBY_STRICT_LOCAL_NODE_T* local =
-        ast_ruby_strict_local_node_init(name_token, NULL, false, false, start, end, node_errors, allocator);
-
-      hb_array_append(locals, local);
-      hb_allocator_dealloc(allocator, name);
-    }
-  }
-
-  for (size_t index = 0; index < params->keywords.size; index++) {
-    pm_node_t* keyword_node = params->keywords.nodes[index];
-
-    if (keyword_node->type == PM_REQUIRED_KEYWORD_PARAMETER_NODE) {
-      pm_required_keyword_parameter_node_t* keyword_param = (pm_required_keyword_parameter_node_t*) keyword_node;
-
-      char* name = extract_name_from_location(keyword_param->name_loc, allocator);
-      if (!name) { continue; }
-
-      token_T* name_token = create_strict_local_token(
-        keyword_param->name_loc.start,
-        keyword_param->name_loc.end,
-        name,
-        TOKEN_IDENTIFIER,
-        source,
-        erb_content_byte_offset,
-        content_bytes,
-        params_open,
-        synthetic_start,
-        allocator
-      );
-
-      position_T start = name_token ? name_token->location.start : (position_T) { .line = 1, .column = 1 };
-      position_T end = name_token ? name_token->location.end : start;
-
-      AST_RUBY_STRICT_LOCAL_NODE_T* local = ast_ruby_strict_local_node_init(
-        name_token,
-        NULL,
-        true,
-        false,
-        start,
-        end,
-        hb_array_init(0, allocator),
-        allocator
-      );
-
-      hb_array_append(locals, local);
-      hb_allocator_dealloc(allocator, name);
-
-    } else if (keyword_node->type == PM_OPTIONAL_KEYWORD_PARAMETER_NODE) {
-      pm_optional_keyword_parameter_node_t* keyword_param = (pm_optional_keyword_parameter_node_t*) keyword_node;
-
-      char* name = extract_name_from_location(keyword_param->name_loc, allocator);
-      if (!name) { continue; }
-
-      size_t value_prism_start = (size_t) (keyword_param->value->location.start - synthetic_start);
-      size_t value_prism_end = (size_t) (keyword_param->value->location.end - synthetic_start);
-      size_t params_in_content = (size_t) (params_open - content_bytes);
-      size_t value_content_start = params_in_content + (value_prism_start - strlen(SYNTHETIC_PREFIX));
-      size_t value_content_end = params_in_content + (value_prism_end - strlen(SYNTHETIC_PREFIX));
-
-      size_t value_length = value_prism_end - value_prism_start;
-      char* value_string =
-        hb_allocator_strndup(allocator, (const char*) keyword_param->value->location.start, value_length);
-
-      position_T value_start = byte_offset_to_position(source, erb_content_byte_offset + value_content_start);
-      position_T value_end = byte_offset_to_position(source, erb_content_byte_offset + value_content_end);
-
-      AST_RUBY_LITERAL_NODE_T* value_node = ast_ruby_literal_node_init(
-        hb_string_from_c_string(value_string),
-        value_start,
-        value_end,
-        hb_array_init(0, allocator),
-        allocator
-      );
-
-      token_T* name_token = create_strict_local_token(
-        keyword_param->name_loc.start,
-        keyword_param->name_loc.end,
-        name,
-        TOKEN_IDENTIFIER,
-        source,
-        erb_content_byte_offset,
-        content_bytes,
-        params_open,
-        synthetic_start,
-        allocator
-      );
-
-      position_T start = name_token ? name_token->location.start : (position_T) { .line = 1, .column = 1 };
-
-      AST_RUBY_STRICT_LOCAL_NODE_T* local = ast_ruby_strict_local_node_init(
-        name_token,
-        value_node,
-        false,
-        false,
-        start,
-        value_end,
-        hb_array_init(0, allocator),
-        allocator
-      );
-
-      hb_array_append(locals, local);
-      hb_allocator_dealloc(allocator, name);
-      hb_allocator_dealloc(allocator, value_string);
-    }
-  }
-
-  if (params->keyword_rest && params->keyword_rest->type == PM_KEYWORD_REST_PARAMETER_NODE) {
-    pm_keyword_rest_parameter_node_t* keyword_rest_param = (pm_keyword_rest_parameter_node_t*) params->keyword_rest;
-
-    if (keyword_rest_param->name) {
-      char* name = extract_name_from_location(keyword_rest_param->name_loc, allocator);
-      if (!name) { return locals; }
-
-      token_T* name_token = create_strict_local_token(
-        keyword_rest_param->name_loc.start,
-        keyword_rest_param->name_loc.end,
-        name,
-        TOKEN_IDENTIFIER,
-        source,
-        erb_content_byte_offset,
-        content_bytes,
-        params_open,
-        synthetic_start,
-        allocator
-      );
-
-      position_T start = name_token ? name_token->location.start : (position_T) { .line = 1, .column = 1 };
-      position_T end = name_token ? name_token->location.end : start;
-
-      AST_RUBY_STRICT_LOCAL_NODE_T* local = ast_ruby_strict_local_node_init(
-        name_token,
-        NULL,
-        false,
-        true,
-        start,
-        end,
-        hb_array_init(0, allocator),
-        allocator
-      );
+  size_t params_in_content = (size_t) (params_open - content_bytes);
+  size_t prefix_length = strlen(SYNTHETIC_PREFIX);
+  size_t source_base_offset = erb_content_byte_offset + params_in_content - prefix_length;
 
-      hb_array_append(locals, local);
-      hb_allocator_dealloc(allocator, name);
-    } else {
-      size_t params_in_content = (size_t) (params_open - content_bytes);
-      size_t operator_prism_start = (size_t) (keyword_rest_param->operator_loc.start - synthetic_start);
-      size_t operator_prism_end = (size_t) (keyword_rest_param->operator_loc.end - synthetic_start);
-      size_t content_start = params_in_content + (operator_prism_start - strlen(SYNTHETIC_PREFIX));
-      size_t content_end = params_in_content + (operator_prism_end - strlen(SYNTHETIC_PREFIX));
+  hb_array_T* locals =
+    extract_parameters_from_prism(params, parser, source, source_base_offset, synthetic_start, allocator);
 
-      position_T start = byte_offset_to_position(source, erb_content_byte_offset + content_start);
-      position_T end = byte_offset_to_position(source, erb_content_byte_offset + content_end);
+  for (size_t index = 0; index < hb_array_size(locals); index++) {
+    AST_RUBY_PARAMETER_NODE_T* local = hb_array_get(locals, index);
+    if (!local) { continue; }
 
-      AST_RUBY_STRICT_LOCAL_NODE_T* local =
-        ast_ruby_strict_local_node_init(NULL, NULL, false, true, start, end, hb_array_init(0, allocator), allocator);
+    position_T start = local->base.location.start;
+    position_T end = local->base.location.end;
+    hb_string_T name = local->name ? local->name->value : hb_string("");
 
-      hb_array_append(locals, local);
+    if (string_equals(local->kind.data, "positional")) {
+      append_strict_locals_positional_argument_error(name, start, end, allocator, local->base.errors);
+    } else if (string_equals(local->kind.data, "rest")) {
+      append_strict_locals_splat_argument_error(name, start, end, allocator, local->base.errors);
+    } else if (string_equals(local->kind.data, "block")) {
+      append_strict_locals_block_argument_error(name, start, end, allocator, local->base.errors);
     }
   }
 
@@ -575,6 +258,7 @@ static AST_ERB_STRICT_LOCALS_NODE_T* create_strict_locals_node(
   } else {
     locals = extract_strict_locals(
       params_node,
+      &parser,
       source,
       erb_content_byte_offset,
       content_bytes,

data/src/analyze/ternary_conditionals.c

@@ -0,0 +1,265 @@
+#include "../include/analyze/ternary_conditionals.h"
+#include "../include/analyze/action_view/tag_helper_node_builders.h"
+#include "../include/analyze/analyze.h"
+#include "../include/analyze/analyzed_ruby.h"
+#include "../include/ast/ast_nodes.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_array.h"
+#include "../include/lib/hb_string.h"
+#include "../include/prism/herb_prism_node.h"
+#include "../include/visitor.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <string.h>
+
+static bool is_erb_output_tag(AST_ERB_CONTENT_NODE_T* erb_node) {
+  if (!erb_node || !erb_node->tag_opening) { return false; }
+
+  hb_string_T opening = erb_node->tag_opening->value;
+
+  return opening.length >= 3 && opening.data[0] == '<' && opening.data[1] == '%' && opening.data[2] == '=';
+}
+
+static pm_node_t* find_ternary_statement(analyzed_ruby_T* analyzed) {
+  if (!analyzed || !analyzed->valid || !analyzed->root) { return NULL; }
+
+  if (analyzed->root->type != PM_PROGRAM_NODE) { return NULL; }
+  pm_program_node_t* program = (pm_program_node_t*) analyzed->root;
+
+  if (!program->statements || program->statements->body.size != 1) { return NULL; }
+  pm_node_t* statement = program->statements->body.nodes[0];
+
+  if (statement->type != PM_IF_NODE) { return NULL; }
+  pm_if_node_t* if_node = (pm_if_node_t*) statement;
+
+  if (if_node->if_keyword_loc.start == NULL && if_node->subsequent != NULL) { return statement; }
+
+  return NULL;
+}
+
+typedef struct {
+  char* source;
+  size_t offset_in_content;
+  size_t length;
+} body_info_T;
+
+static body_info_T extract_statements_body_info(
+  pm_statements_node_t* statements,
+  analyzed_ruby_T* analyzed,
+  hb_allocator_T* allocator
+) {
+  body_info_T info = { .source = NULL, .offset_in_content = 0, .length = 0 };
+
+  if (!statements || statements->body.size == 0) { return info; }
+
+  pm_node_t* first = statements->body.nodes[0];
+  pm_node_t* last = statements->body.nodes[statements->body.size - 1];
+
+  const uint8_t* start = first->location.start;
+  const uint8_t* end = last->location.end;
+
+  const uint8_t* parser_start = analyzed->parser.start;
+  size_t source_length = (size_t) (analyzed->parser.end - parser_start);
+
+  if (start < parser_start || end > parser_start + source_length) { return info; }
+
+  const uint8_t* body_start = start;
+  const uint8_t* body_end = end;
+
+  if (body_start > parser_start && *(body_start - 1) == ' ') { body_start--; }
+  if (body_end < parser_start + source_length && *body_end == ' ') { body_end++; }
+
+  info.offset_in_content = (size_t) (body_start - parser_start);
+  info.length = (size_t) (body_end - body_start);
+  info.source = hb_allocator_strndup(allocator, (const char*) body_start, info.length);
+
+  return info;
+}
+
+static char* extract_condition_source(pm_if_node_t* if_node, hb_allocator_T* allocator) {
+  pm_node_t* predicate = if_node->predicate;
+
+  if (!predicate) { return NULL; }
+
+  size_t length = (size_t) (predicate->location.end - predicate->location.start);
+
+  return hb_allocator_strndup(allocator, (const char*) predicate->location.start, length);
+}
+
+AST_NODE_T* transform_ternary_expression(
+  AST_ERB_CONTENT_NODE_T* erb_node,
+  pm_if_node_t* if_node,
+  hb_allocator_T* allocator
+) {
+  body_info_T true_info = extract_statements_body_info(if_node->statements, erb_node->analyzed_ruby, allocator);
+  if (!true_info.source) { return NULL; }
+
+  pm_else_node_t* else_node = (pm_else_node_t*) if_node->subsequent;
+  if (!else_node) { return NULL; }
+
+  body_info_T false_info = extract_statements_body_info(else_node->statements, erb_node->analyzed_ruby, allocator);
+  if (!false_info.source) { return NULL; }
+
+  char* condition_source = extract_condition_source(if_node, allocator);
+  if (!condition_source) { return NULL; }
+
+  position_T start = erb_node->base.location.start;
+  position_T end = erb_node->base.location.end;
+  position_T content_start = erb_node->content->location.start;
+
+  position_T true_content_start = { .line = content_start.line,
+                                    .column = content_start.column + (uint32_t) true_info.offset_in_content };
+
+  position_T true_content_end = { .line = content_start.line,
+                                  .column = content_start.column
+                                          + (uint32_t) (true_info.offset_in_content + true_info.length) };
+
+  token_T* true_content =
+    create_synthetic_token(allocator, true_info.source, TOKEN_ERB_CONTENT, true_content_start, true_content_end);
+
+  AST_ERB_CONTENT_NODE_T* true_erb_node = ast_erb_content_node_init(
+    erb_node->tag_opening,
+    true_content,
+    erb_node->tag_closing,
+    NULL,
+    false,
+    true,
+    HERB_PRISM_NODE_EMPTY,
+    start,
+    end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+
+  if (!true_erb_node) { return NULL; }
+
+  position_T false_content_start = { .line = content_start.line,
+                                     .column = content_start.column + (uint32_t) false_info.offset_in_content };
+
+  position_T false_content_end = { .line = content_start.line,
+                                   .column = content_start.column
+                                           + (uint32_t) (false_info.offset_in_content + false_info.length) };
+
+  token_T* false_content =
+    create_synthetic_token(allocator, false_info.source, TOKEN_ERB_CONTENT, false_content_start, false_content_end);
+
+  AST_ERB_CONTENT_NODE_T* false_erb_node = ast_erb_content_node_init(
+    erb_node->tag_opening,
+    false_content,
+    erb_node->tag_closing,
+    NULL,
+    false,
+    true,
+    HERB_PRISM_NODE_EMPTY,
+    start,
+    end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+
+  if (!false_erb_node) { return NULL; }
+
+  hb_array_T* true_statements = hb_array_init(1, allocator);
+  hb_array_T* false_statements = hb_array_init(1, allocator);
+
+  hb_array_append(true_statements, (AST_NODE_T*) true_erb_node);
+  hb_array_append(false_statements, (AST_NODE_T*) false_erb_node);
+
+  token_T* else_opening = create_synthetic_token(allocator, "<%", TOKEN_ERB_START, end, end);
+  token_T* else_content_token = create_synthetic_token(allocator, " else ", TOKEN_ERB_CONTENT, end, end);
+  token_T* else_closing = create_synthetic_token(allocator, "%>", TOKEN_ERB_END, end, end);
+
+  AST_ERB_ELSE_NODE_T* erb_else_node = ast_erb_else_node_init(
+    else_opening,
+    else_content_token,
+    else_closing,
+    false_statements,
+    end,
+    end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+
+  hb_buffer_T condition_buffer;
+  hb_buffer_init(&condition_buffer, 64, allocator);
+  hb_buffer_append(&condition_buffer, " if ");
+  hb_buffer_append(&condition_buffer, condition_source);
+  hb_buffer_append(&condition_buffer, " ");
+
+  const char* condition_content = hb_buffer_value(&condition_buffer);
+
+  token_T* if_opening = create_synthetic_token(allocator, "<%", TOKEN_ERB_START, start, start);
+  token_T* if_content = create_synthetic_token(allocator, condition_content, TOKEN_ERB_CONTENT, start, end);
+  token_T* if_closing = create_synthetic_token(allocator, "%>", TOKEN_ERB_END, end, end);
+
+  token_T* end_opening = create_synthetic_token(allocator, "<%", TOKEN_ERB_START, end, end);
+  token_T* end_content = create_synthetic_token(allocator, " end ", TOKEN_ERB_CONTENT, end, end);
+  token_T* end_closing = create_synthetic_token(allocator, "%>", TOKEN_ERB_END, end, end);
+
+  AST_ERB_END_NODE_T* end_node =
+    ast_erb_end_node_init(end_opening, end_content, end_closing, end, end, hb_array_init(0, allocator), allocator);
+
+  herb_prism_node_T empty_prism_node = HERB_PRISM_NODE_EMPTY;
+
+  AST_ERB_IF_NODE_T* result_if_node = ast_erb_if_node_init(
+    if_opening,
+    if_content,
+    if_closing,
+    NULL,
+    empty_prism_node,
+    true_statements,
+    (AST_NODE_T*) erb_else_node,
+    end_node,
+    start,
+    end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+
+  return (AST_NODE_T*) result_if_node;
+}
+
+static void transform_ternary_array(hb_array_T* array, analyze_ruby_context_T* context) {
+  if (!array || !context) { return; }
+
+  for (size_t i = 0; i < hb_array_size(array); i++) {
+    AST_NODE_T* child = hb_array_get(array, i);
+    if (!child) { continue; }
+    if (child->type != AST_ERB_CONTENT_NODE) { continue; }
+
+    AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) child;
+    if (!is_erb_output_tag(erb_node)) { continue; }
+    if (!erb_node->analyzed_ruby) { continue; }
+
+    pm_node_t* ternary_node = find_ternary_statement(erb_node->analyzed_ruby);
+    if (!ternary_node) { continue; }
+
+    AST_NODE_T* replacement = transform_ternary_expression(erb_node, (pm_if_node_t*) ternary_node, context->allocator);
+    if (replacement) { hb_array_set(array, i, replacement); }
+  }
+}
+
+static void transform_ternary_blocks(const AST_NODE_T* node, analyze_ruby_context_T* context) {
+  if (!node || !context) { return; }
+
+  switch (node->type) {
+    case AST_DOCUMENT_NODE: transform_ternary_array(((AST_DOCUMENT_NODE_T*) node)->children, context); break;
+    case AST_HTML_ELEMENT_NODE: transform_ternary_array(((AST_HTML_ELEMENT_NODE_T*) node)->body, context); break;
+    case AST_HTML_OPEN_TAG_NODE: transform_ternary_array(((AST_HTML_OPEN_TAG_NODE_T*) node)->children, context); break;
+    case AST_HTML_ATTRIBUTE_VALUE_NODE:
+      transform_ternary_array(((AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node)->children, context);
+      break;
+    default: break;
+  }
+}
+
+bool transform_ternary_conditional_nodes(const AST_NODE_T* node, void* data) {
+  analyze_ruby_context_T* context = (analyze_ruby_context_T*) data;
+
+  transform_ternary_blocks(node, context);
+
+  herb_visit_child_nodes(node, transform_ternary_conditional_nodes, data);
+
+  return false;
+}