herb 0.10.3-x86-linux-gnu → 0.11.0-x86-linux-gnu

data/templates/lib/herb/action_view/helper_registry.rb.erb

@@ -58,6 +58,25 @@ module Herb
       def maps_to_aria_attribute? = maps_to&.start_with?("aria-") || false
     end
 
+    class HelperBlockArgument
+      attr_reader :name #: String
+      attr_reader :position #: Integer
+      attr_reader :type #: String
+      attr_reader :description #: String
+
+      #: (String, Integer, String, bool, String) -> void
+      def initialize(name, position, type, optional, description)
+        @name = name
+        @position = position
+        @type = type
+        @optional = optional
+        @description = description
+      end
+
+      #: () -> bool
+      def optional? = @optional
+    end
+
     class HelperImplicitAttribute
       attr_reader :name #: String
       attr_reader :source #: String
@@ -75,6 +94,35 @@ module Herb
       end
     end
 
+    class HelperContent
+      attr_reader :source #: Symbol
+      attr_reader :arg_position #: Integer?
+      attr_reader :skip_if_hash #: bool
+      attr_reader :to_s_suffix_when_single #: bool
+      attr_reader :positional_arguments_with_block #: Integer?
+
+      #: (Symbol, Integer?, bool, bool, Integer?) -> void
+      def initialize(source, arg_position, skip_if_hash, to_s_suffix_when_single, positional_arguments_with_block)
+        @source = source
+        @arg_position = arg_position
+        @skip_if_hash = skip_if_hash
+        @to_s_suffix_when_single = to_s_suffix_when_single
+        @positional_arguments_with_block = positional_arguments_with_block
+      end
+
+      #: () -> bool
+      def first_arg? = @source == :first_arg
+
+      #: () -> bool
+      def block_or_arg? = @source == :block_or_arg
+
+      #: () -> bool
+      def skip_if_hash? = @skip_if_hash
+
+      #: () -> bool
+      def to_s_suffix_when_single? = @to_s_suffix_when_single
+    end
+
     class HelperEntry
       attr_reader :name #: String
       attr_reader :type #: Symbol
@@ -82,22 +130,25 @@ module Herb
       attr_reader :gem #: String
       attr_reader :output #: Symbol
       attr_reader :visibility #: String
+      attr_reader :receiver #: String
       attr_reader :tag_name #: String?
       attr_reader :detect_style #: Symbol
       attr_reader :description #: String
       attr_reader :signature #: String
       attr_reader :documentation_url #: String
       attr_reader :implicit_attribute #: HelperImplicitAttribute?
+      attr_reader :content #: HelperContent?
       attr_reader :arguments #: Array[HelperArgument]
       attr_reader :options #: Array[HelperOption]
+      attr_reader :block_arguments #: Array[HelperBlockArgument]
       attr_reader :special_behaviors #: Array[Symbol]
       attr_reader :aliases #: Array[String]
 
-      #: (name: String, type: Symbol, source: String, gem: String, output: Symbol, visibility: String, tag_name: String?, is_void: bool, supports_block: bool, preferred_for_tag: bool, supported: bool, detect_style: Symbol, description: String, signature: String, documentation_url: String, implicit_attribute: HelperImplicitAttribute?, arguments: Array[HelperArgument], options: Array[HelperOption], special_behaviors: Array[Symbol], aliases: Array[String]) -> void
+      #: (name: String, type: Symbol, source: String, gem: String, output: Symbol, visibility: String, receiver: String, tag_name: String?, is_void: bool, supports_block: bool, preferred_for_tag: bool, supported: bool, detect_style: Symbol, description: String, signature: String, documentation_url: String, implicit_attribute: HelperImplicitAttribute?, content: HelperContent?, arguments: Array[HelperArgument], options: Array[HelperOption], block_arguments: Array[HelperBlockArgument], special_behaviors: Array[Symbol], aliases: Array[String]) -> void
       def initialize( # rubocop:disable Metrics/ParameterLists
-        name:, type:, source:, gem:, output:, visibility:, tag_name:, is_void:, supports_block:,
+        name:, type:, source:, gem:, output:, visibility:, receiver:, tag_name:, is_void:, supports_block:,
         preferred_for_tag:, supported:, detect_style:, description:, signature:, documentation_url:,
-        implicit_attribute:, arguments:, options:, special_behaviors:, aliases:
+        implicit_attribute:, content:, arguments:, options:, block_arguments:, special_behaviors:, aliases:
       )
         @name = name
         @type = type
@@ -105,6 +156,7 @@ module Herb
         @gem = gem
         @output = output
         @visibility = visibility
+        @receiver = receiver
         @tag_name = tag_name
         @is_void = is_void
         @supports_block = supports_block
@@ -115,8 +167,10 @@ module Herb
         @signature = signature
         @documentation_url = documentation_url
         @implicit_attribute = implicit_attribute
+        @content = content
         @arguments = arguments
         @options = options
+        @block_arguments = block_arguments
         @special_behaviors = special_behaviors
         @aliases = aliases
       end
@@ -139,6 +193,9 @@ module Herb
       #: () -> bool
       def implicit_attribute? = !@implicit_attribute.nil?
 
+      #: () -> bool
+      def content? = !@content.nil?
+
       #: () -> bool
       def call_name_detect? = @detect_style == :call_name
 
@@ -155,6 +212,7 @@ module Herb
         gem: "<%= helper.gem %>",
         output: :<%= helper.output %>,
         visibility: "<%= helper.visibility %>",
+        receiver: "<%= helper.receiver %>",
         tag_name: <%= helper.tag_name ? "\"#{helper.tag_name}\"" : "nil" %>,
         is_void: <%= helper.void? %>,
         supports_block: <%= helper.supports_block %>,
@@ -174,6 +232,17 @@ module Herb
         ),
       <%- else -%>
         implicit_attribute: nil,
+      <%- end -%>
+      <%- if helper.content? -%>
+        content: HelperContent.new(
+          :<%= helper.content.source %>,
+          <%= helper.content.arg_position || "nil" %>,
+          <%= helper.content.skip_if_hash %>,
+          <%= helper.content.to_s_suffix_when_single %>,
+          <%= helper.content.positional_arguments_with_block || "nil" %>
+        ),
+      <%- else -%>
+        content: nil,
       <%- end -%>
         arguments: [
         <%- helper.arguments.each do |arg| -%>
@@ -185,6 +254,11 @@ module Herb
           HelperOption.new("<%= opt.name %>", "<%= opt.type_display %>", <%= opt.maps_to ? "\"#{opt.maps_to}\"" : "nil" %>, "<%= opt.escaped_description %>"),
         <%- end -%>
         ],
+        block_arguments: [
+        <%- helper.block_arguments.each do |arg| -%>
+          HelperBlockArgument.new("<%= arg.name %>", <%= arg.position %>, "<%= arg.type_display %>", <%= arg.optional %>, "<%= arg.escaped_description %>"),
+        <%- end -%>
+        ],
         special_behaviors: [<%= helper.special_behaviors.map { |b| ":#{b}" }.join(", ") %>],
         aliases: [<%= helper.aliases.map { |a| "\"#{a}\"" }.join(", ") %>],
       ).freeze #: HelperEntry

data/templates/lib/herb/ast/nodes.rb.erb

@@ -5,19 +5,17 @@ module Herb
     <%- nodes.each do |node| -%>
     #: type serialized_<%= node.human %> = {
       <%- node.fields.each do |field| -%>
-      <%- is_nilable = !%w[Array[Herb::AST::Node] Array[Herb::AST::ERBWhenNode] Array[Herb::AST::ERBInNode] bool nil].include?(field.ruby_type) -%>
-    #|  <%= field.name %>: <%= field.ruby_type %><%= if is_nilable then "?" end %>,
+    #|  <%= field.name %>: <%= field.nilable_ruby_type %>,
       <%- end -%>
     #| }
     class <%= node.name -%> < Node
       include Colors
 
       <%- node.fields.each do |field| -%>
-      <%- is_nilable = !%w[Array[Herb::AST::Node] Array[Herb::AST::ERBWhenNode] Array[Herb::AST::ERBInNode] bool nil].include?(field.ruby_type) -%>
-      attr_reader :<%= field.name %> #: <%= field.ruby_type %><%= if is_nilable then "?" end %>
+      <%= field.writable? ? "attr_accessor" : "attr_reader" %> :<%= field.name %> #: <%= field.nilable_ruby_type %>
       <%- end -%>
 
-      #: (<%= ["String", "Location", "Array[Herb::Errors::Error]", *node.fields.map(&:ruby_type)].join(", ") %>) -> void
+      #: (<%= ["String", "Location", "Array[Herb::Errors::Error]", *node.fields.map(&:nilable_ruby_type)].join(", ") %>) -> void
       def initialize(<%= ["type", "location", "errors", *node.fields.map(&:name)].join(", ") %>)
         super(type, location, errors)
         <%- node.fields.each do |field| -%>
@@ -29,6 +27,16 @@ module Herb
         <%- end -%>
       end
 
+      #: () -> String
+      def self.type
+        "<%= node.type %>"
+      end
+
+      #: (<%= [*node.fields.map { |field| "?#{field.name}: #{field.nilable_ruby_type}" }, "?location: Location", "?errors: Array[Herb::Errors::Error]"].join(", ") %>) -> <%= node.name %>
+      def self.build(<%= [*node.fields.map { |field| "#{field.name}: #{field.default_ruby_value}" }, "location: Location.zero", "errors: []"].join(", ") %>)
+        new(<%= ["type", "location", "errors", *node.fields.map(&:name)].join(", ") %>)
+      end
+
       <%- if node.fields.any? { |f| f.is_a?(Herb::Template::PrismSerializedField) || f.is_a?(Herb::Template::PrismNodeField) } -%>
       <%- prism_field = node.fields.find { |f| f.is_a?(Herb::Template::PrismSerializedField) || f.is_a?(Herb::Template::PrismNodeField) } -%>
       #: () -> Prism::node?
@@ -89,7 +97,9 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 10)
         output = +""
 
-        output += white("@ #{bold(yellow(node_name.to_s))} #{dimmed("(location: #{location.tree_inspect})")}")
+        location_inspect = location ? location.tree_inspect : "∅"
+
+        output += white("@ #{bold(yellow(node_name.to_s))} #{dimmed("(location: #{location_inspect})")}")
         output += "\n"
 
         if depth >= depth_limit

data/templates/lib/herb/engine/slots/component_definitions.rb.erb

@@ -0,0 +1,38 @@
+module Herb
+  class Engine
+    module Slots
+      # The built-in components a slots template may use, and what each one takes.
+      #
+      module ComponentDefinitions
+        COMPONENTS = {
+<%- slots_components.each do |component| -%>
+          <%= component.name.inspect %> => {
+            void: <%= component.void? %>,
+            deferred: <%= component.deferred? %>,
+            parents: <%= component.parents ? "[#{component.parents.map(&:inspect).join(", ")}].freeze" : "nil" %>,
+            description: <%= component.description.inspect %>,
+<%- if component.attributes.empty? -%>
+            attributes: {}, #: Hash[String, Hash[Symbol, String]]
+<%- else -%>
+            attributes: {
+<%- component.attributes.each do |attribute| -%>
+              <%= attribute.name.inspect %> => { type: <%= attribute.type.inspect %>, description: <%= attribute.description.inspect %> }.freeze,
+<%- end -%>
+            }.freeze,
+<%- end -%>
+          }.freeze,
+<%- end -%>
+        }.freeze #: Hash[String, { void: bool, deferred: bool, parents: Array[String]?, description: String, attributes: Hash[String, Hash[Symbol, String]] }]
+
+        BUILT_IN = COMPONENTS.keys.freeze #: Array[String]
+
+        DEFERRED = COMPONENTS.select { |_, component| component[:deferred] }.keys.freeze #: Array[String]
+
+        #: (String) -> Hash[String, Hash[Symbol, String]]
+        def self.attributes_for(name)
+          COMPONENTS.dig(name, :attributes) || {}
+        end
+      end
+    end
+  end
+end

data/templates/lib/herb/engine/slots/state_kinds.rb.erb

@@ -0,0 +1,37 @@
+module Herb
+  class Engine
+    module Slots
+      # The kinds a `herb:state` default can have, and what each one means to the compiler.
+      #
+      module StateKinds
+        PRISM = {
+<%- state_kinds.select(&:literal?).each do |kind| -%>
+<%- kind.prism_nodes.each do |node| -%>
+          "Prism::<%= node %>" => :<%= kind.name %>,
+<%- end -%>
+<%- end -%>
+        }.freeze #: Hash[String, Symbol]
+
+        NODE = {
+<%- state_kinds.select(&:literal?).each do |kind| -%>
+          <%= kind.name.inspect %> => :<%= kind.name %>,
+<%- end -%>
+        }.freeze #: Hash[String, Symbol]
+
+        LITERAL = [<%= state_kinds.select(&:literal?).map { |kind| ":#{kind.name}" }.join(", ") %>].freeze #: Array[Symbol]
+
+        UNKNOWN = [<%= state_kinds.select(&:unknown?).map { |kind| ":#{kind.name}" }.join(", ") %>].freeze #: Array[Symbol]
+
+        FALSY = [<%= state_kinds.select(&:falsy?).map { |kind| ":#{kind.name}" }.join(", ") %>].freeze #: Array[Symbol]
+
+        NILABLE = [<%= state_kinds.select(&:nilable?).map { |kind| ":#{kind.name}" }.join(", ") %>].freeze #: Array[Symbol]
+
+        ARTICLES = {
+<%- state_kinds.each do |kind| -%>
+          <%= kind.name.inspect %> => <%= kind.article.inspect %>,
+<%- end -%>
+        }.freeze #: Hash[String, String]
+      end
+    end
+  end
+end

data/templates/lib/herb/engine/slots/state_operators.rb.erb

@@ -0,0 +1,26 @@
+module Herb
+  class Engine
+    module Slots
+      # The comparison operators a `herb:state` read may use, and what swapping or negating one
+      # turns it into.
+      #
+      module StateOperators
+        MIRRORED = {
+<%- state_operators.select(&:mirrored).each do |operator| -%>
+          <%= operator.operator.inspect %> => <%= operator.mirrored.inspect %>,
+<%- end -%>
+        }.freeze #: Hash[String, String]
+
+        NEGATED = {
+<%- state_operators.each do |operator| -%>
+          <%= operator.operator.inspect %> => <%= operator.negated.inspect %>,
+<%- end -%>
+        }.freeze #: Hash[String, String]
+
+        ORDERED = [<%= state_operators.select(&:ordered?).map { |operator| ":#{operator.operator}" }.join(", ") %>].freeze #: Array[Symbol]
+
+        COMPARISONS = [<%= state_operators.map { |operator| operator.operator.inspect }.join(", ") %>].freeze #: Array[String]
+      end
+    end
+  end
+end

data/templates/lib/herb/engine/slots/state_predicates.rb.erb

@@ -0,0 +1,39 @@
+module Herb
+  class Engine
+    module Slots
+      # The Ruby predicates a `herb:state` read may use, and the condition each one resolves into.
+      #
+      module StatePredicates
+        TABLE = {
+<%- state_predicates.each do |predicate| -%>
+          <%= predicate.name.inspect %> => {
+<%- if predicate.comparand -%>
+            comparand: <%= predicate.comparand.inspect %>,
+<%- end -%>
+<%- if predicate.operator -%>
+            operator: <%= predicate.operator.inspect %>,
+<%- end -%>
+            kinds: <%= predicate.ruby_kinds %>,
+            only: <%= predicate.only.inspect %>,
+<%- if predicate.rewrite -%>
+            rewrite: <%= predicate.rewrite.inspect %>,
+<%- end -%>
+          },
+<%- end -%>
+        }.freeze #: Hash[String, Hash[Symbol, untyped]]
+
+        NEGATED = {
+<%- state_predicates.select { |predicate| predicate.unary? && predicate.negated }.each do |predicate| -%>
+          <%= predicate.operator.inspect %> => <%= predicate.negated.inspect %>,
+<%- end -%>
+        }.freeze #: Hash[String, String]
+
+        UNARY = {
+<%- state_predicates.select(&:unary?).each do |predicate| -%>
+          <%= predicate.operator.inspect %> => <%= predicate.name.inspect %>,
+<%- end -%>
+        }.freeze #: Hash[String, String]
+      end
+    end
+  end
+end

data/templates/lib/herb/engine/slots/state_transforms.rb.erb

@@ -0,0 +1,27 @@
+module Herb
+  class Engine
+    module Slots
+      # The Ruby methods a `herb:state` read may call to transform a state's value before comparing
+      # it, and the operation each one becomes on the wire.
+      #
+      module StateTransforms
+        TABLE = {
+<%- state_transforms.each do |transform| -%>
+          <%= transform.name.inspect %> => {
+            operation: <%= transform.operation.inspect %>,
+            kinds: <%= transform.ruby_kinds %>,
+            returns: :<%= transform.returns %>,
+            only: <%= transform.only.inspect %>,
+          },
+<%- end -%>
+        }.freeze #: Hash[String, Hash[Symbol, untyped]]
+
+        SPELLINGS = {
+<%- state_transforms.group_by(&:operation).each do |operation, transforms| -%>
+          <%= operation.inspect %> => <%= transforms.first.name.inspect %>,
+<%- end -%>
+        }.freeze #: Hash[String, String]
+      end
+    end
+  end
+end

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

@@ -18,6 +18,26 @@ module Herb
         <%- end -%>
       end
 
+      #: () -> String?
+      def suggestion
+        nil
+      end
+
+      #: (template: String, ?origin: String) -> Herb::Diagnostic
+      def to_diagnostic(template:, origin: "Herb Parser")
+        Herb::Diagnostic.new(
+          template: template,
+          message: message,
+          severity: :error,
+          origin: origin,
+          code: error_name,
+          location: location,
+          suggestion: suggestion,
+          phase: :compile,
+          data: { type: type }
+        )
+      end
+
       #: () -> serialized_error
       def to_hash
         {
@@ -53,11 +73,6 @@ module Herb
       include Colors
       <%- if error.fields.any? -%>
 
-      <%- error.fields.each do |field| -%>
-      #|  <%= "#{field.name}: #{field.ruby_type}?," %>
-      <%- end -%>
-      #| }
-
       <%- error.fields.each do |field| -%>
       attr_reader :<%= field.name %> #: <%= field.ruby_type %>?
       <%- end -%>
@@ -70,6 +85,19 @@ module Herb
         <%- end -%>
       end
       <%- end -%>
+      <%- if error.suggestion_template -%>
+
+      #: () -> String?
+      def suggestion
+        <%- if error.suggestion_arguments.any? -%>
+        return nil unless <%= error.ruby_suggestion_guards.join(" && ") %>
+
+        format(<%= error.suggestion_template.inspect %>, <%= error.ruby_suggestion_arguments.join(", ") %>)
+        <%- else -%>
+        <%= error.suggestion_template.inspect %>
+        <%- end -%>
+      end
+      <%- end -%>
 
       #: () -> String
       def inspect
@@ -91,7 +119,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect || "∅"})\n")}")
         <%- symbol = error.fields.none? ? "└──" : "├──" -%>
         output += white("<%= symbol %> message: #{green(message.inspect)}\n")
         <%- error.fields.each do |field| -%>

data/templates/lib/herb/html/elements.rb.erb

@@ -0,0 +1,12 @@
+module Herb
+  module HTML
+    module Elements
+      RAW_TEXT_ELEMENTS = [<%= foreign_content_elements.select(&:raw_text?).map { |element| element.name.inspect }.join(", ") %>].freeze #: Array[String]
+      RCDATA_ELEMENTS = [<%= foreign_content_elements.select(&:rcdata?).map { |element| element.name.inspect }.join(", ") %>].freeze #: Array[String]
+      VOID_ELEMENTS = [<%= html_elements.select(&:void?).map { |element| element.name.inspect }.join(", ") %>].freeze #: Array[String]
+      BOOLEAN_ATTRIBUTES = [<%= boolean_attributes.map(&:inspect).join(", ") %>].freeze #: Array[String]
+      WHITESPACE_PRESERVING_ELEMENTS = [<%= whitespace_preserving_elements.map(&:inspect).join(", ") %>].freeze #: Array[String]
+      INLINE_ELEMENTS = [<%= inline_elements.map(&:inspect).join(", ") %>].freeze #: Array[String]
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Herb
+  class ParserOptions
+  <%- parser_options.fields_for(:ruby).each do |field| -%>
+    attr_reader :<%= field.snake_case %> #: <%= field.ruby_type %>
+  <%- end -%>
+
+  <%- parser_options.fields_for(:ruby).select(&:ruby_constant?).each do |field| -%>
+    DEFAULT_<%= field.upper_snake %> = <%= field.ruby_default %> #: <%= field.ruby_default_type %>
+  <%- end -%>
+
+    #: (<%= parser_options.fields_for(:ruby).map { |f| "?#{f.snake_case}: #{f.ruby_type}" }.join(", ") %>) -> void
+    def initialize(<%= parser_options.fields_for(:ruby).map { |f| "#{f.snake_case}: #{f.ruby_constant? ? "DEFAULT_#{f.upper_snake}" : f.ruby_default}" }.join(", ") %>)
+    <%- parser_options.fields_for(:ruby).each do |field| -%>
+      @<%= field.snake_case %> = <%= field.snake_case %>
+    <%- end -%>
+    end
+
+    #: () -> Hash[Symbol, (bool | Numeric | Array[String] | nil)]
+    def to_h
+      {
+      <%- parser_options.fields_for(:ruby).each do |field| -%>
+        <%= field.snake_case %>: @<%= field.snake_case %>,
+      <%- end -%>
+      }
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{to_h.map { |key, value| "#{key}=#{value.inspect}" }.join(", ")}>"
+    end
+  end
+end

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

@@ -1,6 +1,12 @@
+require_relative "visitor/parser_option_requirements"
+
 module Herb
   class Visitor
     include AST::Helpers
+    include ParserOptionRequirements
+
+    # @rbs!
+    #   extend Herb::Visitor::ParserOptionRequirements::ClassMethods
 
     #: (Herb::AST::Node?) -> void
     def visit(node)
@@ -31,7 +37,7 @@ module Herb
     #: (Herb::AST::<%= node.name %>) -> void
     def visit_<%= node.human %>(node)
       visit_node(node)
-      <%- if node.name.start_with?("ERB") -%>
+      <%- if node.erb_tag? -%>
       visit_erb_node(node)
       <%- end -%>
       visit_child_nodes(node)

data/templates/rust/herb-printer/src/printer_visitor.rs.erb

@@ -0,0 +1,14 @@
+macro_rules! impl_printer_visitor {
+  ($printer:ty) => {
+    impl herb::Visitor for $printer {
+      <%- nodes.each do |node| -%>
+      fn visit_<%= node.human %>(&mut self, node: &herb::nodes::<%= node.name %>) {
+        $crate::printer::Printer::emit_<%= node.human.delete_suffix("_node") %>(self, node);
+      }
+
+      <%- end -%>
+    }
+  };
+}
+
+pub(crate) use impl_printer_visitor;

data/templates/rust/src/action_view_helpers.rs.erb

@@ -44,6 +44,15 @@ pub struct HelperOption {
   pub description: &'static str,
 }
 
+#[derive(Debug, Clone)]
+pub struct HelperBlockArgument {
+  pub name: &'static str,
+  pub position: usize,
+  pub argument_type: &'static str,
+  pub optional: bool,
+  pub description: &'static str,
+}
+
 #[derive(Debug, Clone)]
 pub struct HelperImplicitAttribute {
   pub name: &'static str,
@@ -53,6 +62,15 @@ pub struct HelperImplicitAttribute {
   pub skip_wrapping_for: &'static [&'static str],
 }
 
+#[derive(Debug, Clone)]
+pub struct HelperContent {
+  pub source: &'static str,
+  pub arg_position: Option<usize>,
+  pub skip_if_hash: bool,
+  pub to_s_suffix_when_single: bool,
+  pub positional_arguments_with_block: Option<usize>,
+}
+
 #[derive(Debug, Clone)]
 pub struct HelperEntry {
   pub name: &'static str,
@@ -61,6 +79,7 @@ pub struct HelperEntry {
   pub gem: &'static str,
   pub output: &'static str,
   pub visibility: &'static str,
+  pub receiver: &'static str,
   pub tag_name: Option<&'static str>,
   pub is_void: bool,
   pub supports_block: bool,
@@ -71,8 +90,10 @@ pub struct HelperEntry {
   pub signature: &'static str,
   pub documentation_url: &'static str,
   pub implicit_attribute: Option<&'static HelperImplicitAttribute>,
+  pub content: Option<&'static HelperContent>,
   pub arguments: &'static [HelperArgument],
   pub options: &'static [HelperOption],
+  pub block_arguments: &'static [HelperBlockArgument],
   pub special_behaviors: &'static [&'static str],
   pub aliases: &'static [&'static str],
 }
@@ -87,6 +108,16 @@ static <%= helper.constant_name %>_IMPLICIT_ATTR: HelperImplicitAttribute = Help
   skip_wrapping_for: &[<%= helper.implicit_attribute.skip_wrapping_for.map { |s| "\"#{s}\"" }.join(", ") %>],
 };
 
+<%- end -%>
+<%- if helper.content? -%>
+static <%= helper.constant_name %>_CONTENT: HelperContent = HelperContent {
+  source: "<%= helper.content.source %>",
+  arg_position: <%= helper.content.arg_position ? "Some(#{helper.content.arg_position})" : "None" %>,
+  skip_if_hash: <%= helper.content.skip_if_hash %>,
+  to_s_suffix_when_single: <%= helper.content.to_s_suffix_when_single %>,
+  positional_arguments_with_block: <%= helper.content.positional_arguments_with_block ? "Some(#{helper.content.positional_arguments_with_block})" : "None" %>,
+};
+
 <%- end -%>
 <%- end -%>
 
@@ -99,6 +130,7 @@ static REGISTRY: [HelperEntry; <%= helpers.size %>] = [
     gem: "<%= helper.gem %>",
     output: "<%= helper.output %>",
     visibility: "<%= helper.visibility %>",
+    receiver: "<%= helper.receiver %>",
     tag_name: <%= helper.tag_name ? "Some(\"#{helper.tag_name}\")" : "None" %>,
     is_void: <%= helper.void? %>,
     supports_block: <%= helper.supports_block %>,
@@ -109,6 +141,7 @@ static REGISTRY: [HelperEntry; <%= helpers.size %>] = [
     signature: "<%= helper.escaped_signature %>",
     documentation_url: "<%= helper.documentation_url %>",
     implicit_attribute: <%= helper.implicit_attribute? ? "Some(&#{helper.constant_name}_IMPLICIT_ATTR)" : "None" %>,
+    content: <%= helper.content? ? "Some(&#{helper.constant_name}_CONTENT)" : "None" %>,
     arguments: &[
     <%- helper.arguments.each do |arg| -%>
       HelperArgument { name: "<%= arg.name %>", position: <%= arg.position %>, argument_type: "<%= arg.type_display %>", optional: <%= arg.optional %>, default: <%= arg.default ? "Some(\"#{arg.escaped_default}\")" : "None" %>, splat: <%= arg.splat %>, description: "<%= arg.escaped_description %>" },
@@ -119,6 +152,11 @@ static REGISTRY: [HelperEntry; <%= helpers.size %>] = [
       HelperOption { name: "<%= opt.name %>", option_type: "<%= opt.type_display %>", maps_to: <%= opt.maps_to ? "Some(\"#{opt.maps_to}\")" : "None" %>, description: "<%= opt.escaped_description %>" },
     <%- end -%>
     ],
+    block_arguments: &[
+    <%- helper.block_arguments.each do |arg| -%>
+      HelperBlockArgument { name: "<%= arg.name %>", position: <%= arg.position %>, argument_type: "<%= arg.type_display %>", optional: <%= arg.optional %>, description: "<%= arg.escaped_description %>" },
+    <%- end -%>
+    ],
     special_behaviors: &[<%= helper.special_behaviors.map { |b| "\"#{b}\"" }.join(", ") %>],
     aliases: &[<%= helper.aliases.map { |a| "\"#{a}\"" }.join(", ") %>],
   },