class ActionView::Template

Experimental RBS support (using type sampling data from the type_fusion project). 

# sig/action_view/template.rbs

class ActionView::Template
  def compile: (Class mod) -> Symbol
  
  type ActionView__Template_compile!_view = #<Class:0x000000010fd1fb40> | #<Class:0x0000000117c74300> | #<Class:0x000000011a97a8e0> | #<Class:0x0000000122fe7b30> | #<Class:0x00000001397bbff8> | #<Class:0x000000010c3a67d8> | #<Class:0x0000000110baf520> | #<Class:0x00000001088d00a0>
  
  def compile!: (ActionView__Template_compile!_view view) -> nil
  def encode!: () -> String
  def identifier_method_name: () -> String
  def initialize: (ActionView::Template::Sources::File source, String identifier, ActionView::Template::Handlers::ERB handler, locals: Array[], format: Symbol, variant: nil, virtual_path: String) -> void
  def instrument: (String action, ) -> Symbol
  def instrument_payload: () -> Hash
  def instrument_render_template: () -> ActionView::OutputBuffer
  def locals_code: () -> String
  def method_name: () -> String
  def render: ((#<Class:0x000000011ee7c768> | #<Class:0x000000010b88d540> | #<Class:0x000000010c3a67d8>) view, Hash locals, ?ActionView::OutputBuffer buffer, add_to_stack: true, ) -> ActionView::OutputBuffer
  def short_identifier: () -> String
  def source: () -> String
  def type: () -> Mime::Type
end

Action View Template ↑

def compile(mod)

Experimental RBS support (using type sampling data from the type_fusion project). 

def compile: (Class mod) -> Symbol

This signature was generated using 1 sample from 1 application.

regardless of the original source encoding.
In general, this means that templates will be UTF-8 inside of Rails,
encode the source into Encoding.default_internal.
Otherwise, after we figure out the correct encoding, we then

specifying the encoding. For instance, ERB supports <%# encoding: %>
the template engine to support additional mechanisms for
String to the engine without further processing. This allows
If the template engine handles encodings, we send the encoded

the encoding of the compiled template.
Among other things, this method is responsible for properly setting 
def compile(mod)
  source = encode!
  code = @handler.call(self, source)
  # Make sure that the resulting String to be eval'd is in the
  # encoding of the code
  original_source = source
  source = +<<-end_src
    def #{method_name}(local_assigns, output_buffer)
      @virtual_path = #{@virtual_path.inspect};#{locals_code};#{code}
    end
  end_src
  # Make sure the source is in the encoding of the returned code
  source.force_encoding(code.encoding)
  # In case we get back a String from a handler that is not in
  # BINARY or the default_internal, encode it to the default_internal
  source.encode!
  # Now, validate that the source we got back from the template
  # handler is valid in the default_internal. This is for handlers
  # that handle encoding but screw up
  unless source.valid_encoding?
    raise WrongEncodingError.new(source, Encoding.default_internal)
  end
  begin
    if Template.frozen_string_literal
      mod.module_eval("# frozen_string_literal: true\n#{source}", identifier, -1)
    else
      mod.module_eval(source, identifier, 0)
    end
  rescue SyntaxError
    # Account for when code in the template is not syntactically valid; e.g. if we're using
    # ERB and the user writes <%= foo( %>, attempting to call a helper `foo` and interpolate
    # the result into the template, but missing an end parenthesis.
    raise SyntaxErrorInTemplate.new(self, original_source)
  end
end

def compile!(view)

Experimental RBS support (using type sampling data from the type_fusion project). 

type ActionView__Template_compile!_view = #<Class:0x000000010fd1fb40> | #<Class:0x0000000117c74300> | #<Class:0x000000011a97a8e0> | #<Class:0x0000000122fe7b30> | #<Class:0x00000001397bbff8> | #<Class:0x000000010c3a67d8> | #<Class:0x0000000110baf520> | #<Class:0x00000001088d00a0>

def compile!: (ActionView__Template_compile!_view view) -> nil

This signature was generated using 9 samples from 1 application.

just once and removes the source after it is compiled.
Compile a template. This method ensures a template is compiled 
def compile!(view)
  return if @compiled
  # Templates can be used concurrently in threaded environments
  # so compilation and any instance variable modification must
  # be synchronized
  @compile_mutex.synchronize do
    # Any thread holding this lock will be compiling the template needed
    # by the threads waiting. So re-check the @compiled flag to avoid
    # re-compilation
    return if @compiled
    mod = view.compiled_method_container
    instrument("!compile_template") do
      compile(mod)
    end
    @compiled = true
  end
end

def encode!

Experimental RBS support (using type sampling data from the type_fusion project). 

def encode!: () -> String

This signature was generated using 2 samples from 1 application.

blank line in its stead.
before passing the source on to the template engine, leaving a
with any template engine, as we process out the encoding comment
line of the template (# encoding: NAME-OF-ENCODING). This will work
The user can also specify the encoding via a comment on the first

the same as Encoding.default_external.
If no additional information is supplied, we assume the encoding is
source. Until this point, we assume that the source is BINARY data.
This method is responsible for properly setting the encoding of the 
def encode!
  source = self.source
  return source unless source.encoding == Encoding::BINARY
  # Look for # encoding: *. If we find one, we'll encode the
  # String in that encoding, otherwise, we'll use the
  # default external encoding.
  if source.sub!(/\A#{ENCODING_FLAG}/, "")
    encoding = magic_encoding = $1
  else
    encoding = Encoding.default_external
  end
  # Tag the source with the default external encoding
  # or the encoding specified in the file
  source.force_encoding(encoding)
  # If the user didn't specify an encoding, and the handler
  # handles encodings, we simply pass the String as is to
  # the handler (with the default_external tag)
  if !magic_encoding && @handler.respond_to?(:handles_encoding?) && @handler.handles_encoding?
    source
  # Otherwise, if the String is valid in the encoding,
  # encode immediately to default_internal. This means
  # that if a handler doesn't handle encodings, it will
  # always get Strings in the default_internal
  elsif source.valid_encoding?
    source.encode!
  # Otherwise, since the String is invalid in the encoding
  # specified, raise an exception
  else
    raise WrongEncodingError.new(source, encoding)
  end
end

def handle_render_error(view, e) 

def handle_render_error(view, e)
  if e.is_a?(Template::Error)
    e.sub_template_of(self)
    raise e
  else
    raise Template::Error.new(self)
  end
end

def identifier_method_name

Experimental RBS support (using type sampling data from the type_fusion project). 

def identifier_method_name: () -> String

This signature was generated using 3 samples from 1 application. 

def identifier_method_name
  short_identifier.tr("^a-z_", "_")
end

def initialize(source, identifier, handler, locals:, format: nil, variant: nil, virtual_path: nil)

Experimental RBS support (using type sampling data from the type_fusion project). 

def initialize: (ActionView::Template::Sources::File source, String identifier, ActionView::Template::Handlers::ERB handler, locals: , format: Symbol, variant: nil, virtual_path: String) -> void

This signature was generated using 1 sample from 1 application. 

def initialize(source, identifier, handler, locals:, format: nil, variant: nil, virtual_path: nil)
  @source            = source
  @identifier        = identifier
  @handler           = handler
  @compiled          = false
  @locals            = locals
  @virtual_path      = virtual_path
  @variable = if @virtual_path
    base = @virtual_path.end_with?("/") ? "" : ::File.basename(@virtual_path)
    base =~ /\A_?(.*?)(?:\.\w+)*\z/
    $1.to_sym
  end
  @format            = format
  @variant           = variant
  @compile_mutex     = Mutex.new
end

def inspect 

def inspect
  "#<#{self.class.name} #{short_identifier} locals=#{@locals.inspect}>"
end

def instrument(action, &block) # :doc:

Experimental RBS support (using type sampling data from the type_fusion project). 

def instrument: (String action, ) -> Symbol

This signature was generated using 2 samples from 1 application.

:doc: 
def instrument(action, &block) # :doc:
  ActiveSupport::Notifications.instrument("#{action}.action_view", instrument_payload, &block)
end

def instrument_payload

Experimental RBS support (using type sampling data from the type_fusion project). 

def instrument_payload: () -> virtual_path | String | identifier | String

This signature was generated using 5 samples from 1 application. 

def instrument_payload
  { virtual_path: @virtual_path, identifier: @identifier }
end

def instrument_render_template(&block)

Experimental RBS support (using type sampling data from the type_fusion project). 

def instrument_render_template: () -> ActionView::OutputBuffer

This signature was generated using 6 samples from 1 application. 

def instrument_render_template(&block)
  ActiveSupport::Notifications.instrument("!render_template.action_view", instrument_payload, &block)
end

def locals_code

Experimental RBS support (using type sampling data from the type_fusion project). 

def locals_code: () -> String

This signature was generated using 2 samples from 2 applications. 

def locals_code
  # Only locals with valid variable names get set directly. Others will
  # still be available in local_assigns.
  locals = @locals - Module::RUBY_RESERVED_KEYWORDS
  deprecated_locals = locals.grep(/\A@+/)
  if deprecated_locals.any?
    ActiveSupport::Deprecation.warn(<<~MSG)
      Passing instance variables to `render` is deprecated.
      In Rails 7.1, #{deprecated_locals.to_sentence} will be ignored.
    MSG
    locals = locals.grep(/\A@?(?![A-Z0-9])(?:[[:alnum:]_]|[^\0-\177])+\z/)
  else
    locals = locals.grep(/\A(?![A-Z0-9])(?:[[:alnum:]_]|[^\0-\177])+\z/)
  end
  # Assign for the same variable is to suppress unused variable warning
  locals.each_with_object(+"") { |key, code| code << "#{key} = local_assigns[:#{key}]; #{key} = #{key};" }
end

def marshal_dump # :nodoc:

:nodoc:
the marshalling of the compiler mutex and instantiating that again on unmarshalling.
to ensure that references to the template object can be marshalled as well. This means forgoing
Exceptions are marshalled when using the parallel test runner with DRb, so we need 
def marshal_dump # :nodoc:
  [ @source, @identifier, @handler, @compiled, @locals, @virtual_path, @format, @variant ]
end

def marshal_load(array) # :nodoc:

:nodoc: 
def marshal_load(array) # :nodoc:
  @source, @identifier, @handler, @compiled, @locals, @virtual_path, @format, @variant = *array
  @compile_mutex = Mutex.new
end

def method_name

Experimental RBS support (using type sampling data from the type_fusion project). 

def method_name: () -> String

This signature was generated using 9 samples from 1 application. 

def method_name
  @method_name ||= begin
    m = +"_#{identifier_method_name}__#{@identifier.hash}_#{__id__}"
    m.tr!("-", "_")
    m
  end
end

def render(view, locals, buffer = ActionView::OutputBuffer.new, add_to_stack: true, &block)

Experimental RBS support (using type sampling data from the type_fusion project). 

def render: ((#<Class:0x000000011ee7c768> | #<Class:0x000000010b88d540> | #<Class:0x000000010c3a67d8>) view, ( | route | name | String | verb | String | path | String | reqs | String | route_counter | Integer | route_iteration | ActionView::PartialIteration) locals, ?ActionView::OutputBuffer buffer, add_to_stack: true, ) -> ActionView::OutputBuffer

This signature was generated using 4 samples from 1 application.

consume this in production. This is only slow if it's being listened to.
we use a bang in this instrumentation because you don't want to
This method is instrumented as "!render_template.action_view". Notice that

exactly before rendering.
Render a template. If the template was not compiled yet, it is done 
def render(view, locals, buffer = ActionView::OutputBuffer.new, add_to_stack: true, &block)
  instrument_render_template do
    compile!(view)
    view._run(method_name, self, locals, buffer, add_to_stack: add_to_stack, &block)
  end
rescue => e
  handle_render_error(view, e)
end

def short_identifier

Experimental RBS support (using type sampling data from the type_fusion project). 

def short_identifier: () -> String

This signature was generated using 1 sample from 1 application. 

def short_identifier
  @short_identifier ||= defined?(Rails.root) ? identifier.delete_prefix("#{Rails.root}/") : identifier
end

def source

Experimental RBS support (using type sampling data from the type_fusion project). 

def source: () -> String

This signature was generated using 3 samples from 1 application. 

def source
  @source.to_s
end

def supports_streaming?

a streaming buffer *may* be passed when it starts rendering.
Returns whether the underlying handler supports streaming. If so, 
def supports_streaming?
  handler.respond_to?(:supports_streaming?) && handler.supports_streaming?
end

def type

Experimental RBS support (using type sampling data from the type_fusion project). 

def type: () -> Mime::Type

This signature was generated using 1 sample from 1 application. 

def type
  @type ||= Types[format]
end