def compile(mod) #:nodoc:
  encode!
  method_name = self.method_name
  code = @handler.call(self)
  # Make sure that the resulting String to be eval'd is in the
  # encoding of the code
  source = <<-end_src
    def #{method_name}(local_assigns, output_buffer)
      _old_virtual_path, @virtual_path = @virtual_path, #{@virtual_path.inspect};_old_output_buffer = @output_buffer;#{locals_code};#{code}
    ensure
      @virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
    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
  mod.module_eval(source, identifier, 0)
  ObjectSpace.define_finalizer(self, Finalizer[method_name, mod])
end

def compile!(view) #:nodoc:
  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
    if view.is_a?(ActionView::CompiledTemplates)
      mod = ActionView::CompiledTemplates
    else
      mod = view.singleton_class
    end
    instrument("!compile_template") do
      compile(mod)
    end
    # Just discard the source if we have a virtual path. This
    # means we can get the template back.
    @source = nil if @virtual_path
    @compiled = true
  end
end

def encode!
  return 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) #:nodoc:
  if e.is_a?(Template::Error)
    e.sub_template_of(self)
    raise e
  else
    template = self
    unless template.source
      template = refresh(view)
      template.encode!
    end
    raise Template::Error.new(template, e)
  end
end

def identifier_method_name #:nodoc:
  inspect.tr('^a-z_', '_')
end

def initialize(source, identifier, handler, details)
  format = details[:format] || (handler.default_format if handler.respond_to?(:default_format))
  @source            = source
  @identifier        = identifier
  @handler           = handler
  @compiled          = false
  @original_encoding = nil
  @locals            = details[:locals] || []
  @virtual_path      = details[:virtual_path]
  @updated_at        = details[:updated_at] || Time.now
  @formats           = Array(format).map { |f| f.respond_to?(:ref) ? f.ref : f  }
  @variants          = [details[:variant]]
  @compile_mutex     = Mutex.new
end

def inspect
  @inspect ||= defined?(Rails.root) ? identifier.sub("#{Rails.root}/", '') : identifier
end

def instrument(action, &block)
  payload = { virtual_path: @virtual_path, identifier: @identifier }
  ActiveSupport::Notifications.instrument("#{action}.action_view", payload, &block)
end

def locals_code #:nodoc:
  # Double assign to suppress the dreaded 'assigned but unused variable' warning
  @locals.each_with_object('') { |key, code| code << "#{key} = #{key} = local_assigns[:#{key}];" }
end

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

def refresh(view)
  raise "A template needs to have a virtual path in order to be refreshed" unless @virtual_path
  lookup  = view.lookup_context
  pieces  = @virtual_path.split("/")
  name    = pieces.pop
  partial = !!name.sub!(/^_/, "")
  lookup.disable_cache do
    lookup.find_template(name, [ pieces.join('/') ], partial, @locals)
  end
end

def render(view, locals, buffer=nil, &block)
  instrument("!render_template") do
    compile!(view)
    view.send(method_name, locals, buffer, &block)
  end
rescue => e
  handle_render_error(view, e)
end

def supports_streaming?
  handler.respond_to?(:supports_streaming?) && handler.supports_streaming?
end

def type
  @type ||= Types[@formats.first] if @formats.first
end