# File lib/action_view/template.rb, line 123
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

# File lib/action_view/template.rb, line 189
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

# File lib/action_view/template.rb, line 171
def inspect
  "#<#{self.class.name} #{short_identifier} locals=#{@locals.inspect}>"
end

# File lib/action_view/template.rb, line 103
eager_autoload do
  autoload :Error
  autoload :RawFile
  autoload :Renderable
  autoload :Handlers
  autoload :HTML
  autoload :Inline
  autoload :Sources
  autoload :Text
  autoload :Types
end

# File lib/action_view/template.rb, line 154
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

# File lib/action_view/template.rb, line 167
def short_identifier
  @short_identifier ||= defined?(Rails.root) ? identifier.delete_prefix("#{Rails.root}/") : identifier
end

# File lib/action_view/template.rb, line 175
def source
  @source.to_s
end

# File lib/action_view/template.rb, line 144
def supports_streaming?
  handler.respond_to?(:supports_streaming?) && handler.supports_streaming?
end

# File lib/action_view/template.rb, line 163
def type
  @type ||= Types[format]
end

# File lib/action_view/template.rb, line 275
      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

# File lib/action_view/template.rb, line 241
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

# File lib/action_view/template.rb, line 316
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

# File lib/action_view/template.rb, line 352
def identifier_method_name
  short_identifier.tr("^a-z_", "_")
end

# File lib/action_view/template.rb, line 356
def instrument(action, &block) # :doc:
  ActiveSupport::Notifications.instrument("#{action}.action_view", instrument_payload, &block)
end

# File lib/action_view/template.rb, line 364
def instrument_payload
  { virtual_path: @virtual_path, identifier: @identifier }
end

# File lib/action_view/template.rb, line 360
def instrument_render_template(&block)
  ActiveSupport::Notifications.instrument("!render_template.action_view", instrument_payload, &block)
end

# File lib/action_view/template.rb, line 325
      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

# File lib/action_view/template.rb, line 344
def method_name
  @method_name ||= begin
    m = +"_#{identifier_method_name}__#{@identifier.hash}_#{__id__}"
    m.tr!("-", "_")
    m
  end
end