2010-03-19 12:20:15 -04:00
|
|
|
require 'active_support/core_ext/array/wrap'
|
|
|
|
require 'active_support/core_ext/object/blank'
|
2010-08-26 15:48:04 -04:00
|
|
|
require 'active_support/core_ext/object/try'
|
2010-05-17 11:41:54 -04:00
|
|
|
require 'active_support/core_ext/kernel/singleton_class'
|
2009-04-14 20:22:51 -04:00
|
|
|
|
2011-11-06 05:54:59 -05:00
|
|
|
if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby' && RUBY_VERSION == '1.9.3' && RUBY_PATCHLEVEL == 0
|
2011-11-06 05:36:56 -05:00
|
|
|
# This is a hack to work around a bug in Ruby 1.9.3p0:
|
|
|
|
# http://redmine.ruby-lang.org/issues/5564
|
|
|
|
#
|
|
|
|
# Basically, at runtime we may need to perform some encoding conversions on the templates,
|
|
|
|
# but if the converter hasn't been loaded by Ruby beforehand (i.e. now), then it won't be
|
|
|
|
# able to find it (due to a bug).
|
|
|
|
#
|
|
|
|
# However, we don't know what conversions we may need to do a runtime. So we load up a
|
2011-11-16 16:37:10 -05:00
|
|
|
# text file which contains a pre-generated list of all the possible conversions,
|
2011-11-06 05:36:56 -05:00
|
|
|
# and we load all of them.
|
|
|
|
#
|
|
|
|
# In my testing this increased the process size by about 3.9 MB (after the conversions array
|
|
|
|
# is GC'd) and took around 170ms to run, which seems acceptable for a workaround.
|
|
|
|
#
|
2011-11-16 16:37:10 -05:00
|
|
|
# The script to dump the conversions is: https://gist.github.com/1371499
|
2011-11-06 05:36:56 -05:00
|
|
|
|
2011-11-16 16:37:10 -05:00
|
|
|
filename = File.join(File.dirname(__FILE__), 'data', 'encoding_conversions.txt')
|
|
|
|
conversions = File.read(filename)
|
|
|
|
conversions.split("\n").map do |line|
|
|
|
|
from, to_array = line.split(':')
|
|
|
|
to_array.split(',').each do |to|
|
2011-11-06 05:36:56 -05:00
|
|
|
Encoding::Converter.new(from, to)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2009-04-23 18:58:38 -04:00
|
|
|
module ActionView
|
2010-06-16 14:27:50 -04:00
|
|
|
# = Action View Template
|
2008-07-12 15:33:46 -04:00
|
|
|
class Template
|
2009-12-02 23:01:01 -05:00
|
|
|
extend ActiveSupport::Autoload
|
2009-12-22 18:27:37 -05:00
|
|
|
|
2010-05-17 11:41:54 -04:00
|
|
|
# === Encodings in ActionView::Template
|
|
|
|
#
|
|
|
|
# ActionView::Template is one of a few sources of potential
|
|
|
|
# encoding issues in Rails. This is because the source for
|
|
|
|
# templates are usually read from disk, and Ruby (like most
|
|
|
|
# encoding-aware programming languages) assumes that the
|
|
|
|
# String retrieved through File IO is encoded in the
|
|
|
|
# <tt>default_external</tt> encoding. In Rails, the default
|
|
|
|
# <tt>default_external</tt> encoding is UTF-8.
|
|
|
|
#
|
|
|
|
# As a result, if a user saves their template as ISO-8859-1
|
|
|
|
# (for instance, using a non-Unicode-aware text editor),
|
|
|
|
# and uses characters outside of the ASCII range, their
|
|
|
|
# users will see diamonds with question marks in them in
|
|
|
|
# the browser.
|
|
|
|
#
|
2010-05-30 05:07:34 -04:00
|
|
|
# For the rest of this documentation, when we say "UTF-8",
|
|
|
|
# we mean "UTF-8 or whatever the default_internal encoding
|
|
|
|
# is set to". By default, it will be UTF-8.
|
|
|
|
#
|
2010-05-17 11:41:54 -04:00
|
|
|
# To mitigate this problem, we use a few strategies:
|
|
|
|
# 1. If the source is not valid UTF-8, we raise an exception
|
|
|
|
# when the template is compiled to alert the user
|
|
|
|
# to the problem.
|
|
|
|
# 2. The user can specify the encoding using Ruby-style
|
|
|
|
# encoding comments in any template engine. If such
|
|
|
|
# a comment is supplied, Rails will apply that encoding
|
|
|
|
# to the resulting compiled source returned by the
|
|
|
|
# template handler.
|
|
|
|
# 3. In all cases, we transcode the resulting String to
|
2010-05-30 05:07:34 -04:00
|
|
|
# the UTF-8.
|
2010-05-17 11:41:54 -04:00
|
|
|
#
|
|
|
|
# This means that other parts of Rails can always assume
|
|
|
|
# that templates are encoded in UTF-8, even if the original
|
|
|
|
# source of the template was not UTF-8.
|
|
|
|
#
|
|
|
|
# From a user's perspective, the easiest thing to do is
|
|
|
|
# to save your templates as UTF-8. If you do this, you
|
|
|
|
# do not need to do anything else for things to "just work".
|
|
|
|
#
|
|
|
|
# === Instructions for template handlers
|
|
|
|
#
|
|
|
|
# The easiest thing for you to do is to simply ignore
|
|
|
|
# encodings. Rails will hand you the template source
|
|
|
|
# as the default_internal (generally UTF-8), raising
|
|
|
|
# an exception for the user before sending the template
|
|
|
|
# to you if it could not determine the original encoding.
|
|
|
|
#
|
|
|
|
# For the greatest simplicity, you can support only
|
|
|
|
# UTF-8 as the <tt>default_internal</tt>. This means
|
|
|
|
# that from the perspective of your handler, the
|
|
|
|
# entire pipeline is just UTF-8.
|
|
|
|
#
|
|
|
|
# === Advanced: Handlers with alternate metadata sources
|
|
|
|
#
|
|
|
|
# If you want to provide an alternate mechanism for
|
|
|
|
# specifying encodings (like ERB does via <%# encoding: ... %>),
|
2010-05-30 05:07:34 -04:00
|
|
|
# you may indicate that you will handle encodings yourself
|
|
|
|
# by implementing <tt>self.handles_encoding?</tt>
|
2010-05-17 11:41:54 -04:00
|
|
|
# on your handler.
|
|
|
|
#
|
2010-05-30 05:07:34 -04:00
|
|
|
# If you do, Rails will not try to encode the String
|
|
|
|
# into the default_internal, passing you the unaltered
|
|
|
|
# bytes tagged with the assumed encoding (from
|
|
|
|
# default_external).
|
2010-05-17 11:41:54 -04:00
|
|
|
#
|
|
|
|
# In this case, make sure you return a String from
|
|
|
|
# your handler encoded in the default_internal. Since
|
|
|
|
# you are handling out-of-band metadata, you are
|
|
|
|
# also responsible for alerting the user to any
|
|
|
|
# problems with converting the user's data to
|
2011-05-10 18:28:37 -04:00
|
|
|
# the <tt>default_internal</tt>.
|
2010-05-17 11:41:54 -04:00
|
|
|
#
|
2011-05-10 18:28:37 -04:00
|
|
|
# To do so, simply raise the raise +WrongEncodingError+
|
2010-05-17 11:41:54 -04:00
|
|
|
# as follows:
|
|
|
|
#
|
|
|
|
# raise WrongEncodingError.new(
|
|
|
|
# problematic_string,
|
|
|
|
# expected_encoding
|
|
|
|
# )
|
|
|
|
|
2009-12-22 18:27:37 -05:00
|
|
|
eager_autoload do
|
|
|
|
autoload :Error
|
|
|
|
autoload :Handlers
|
|
|
|
autoload :Text
|
|
|
|
end
|
|
|
|
|
2009-12-02 23:01:01 -05:00
|
|
|
extend Template::Handlers
|
2010-03-09 07:12:11 -05:00
|
|
|
|
2010-10-10 03:24:17 -04:00
|
|
|
attr_accessor :locals, :formats, :virtual_path
|
2010-10-07 09:50:20 -04:00
|
|
|
|
2010-10-10 03:24:17 -04:00
|
|
|
attr_reader :source, :identifier, :handler, :original_encoding, :updated_at
|
2009-09-24 13:30:13 -04:00
|
|
|
|
2010-09-30 05:40:51 -04:00
|
|
|
# This finalizer is needed (and exactly with a proc inside another proc)
|
|
|
|
# otherwise templates leak in development.
|
|
|
|
Finalizer = proc do |method_name, mod|
|
|
|
|
proc do
|
|
|
|
mod.module_eval do
|
|
|
|
remove_possible_method method_name
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2009-04-23 18:58:38 -04:00
|
|
|
def initialize(source, identifier, handler, details)
|
2010-10-10 03:24:17 -04:00
|
|
|
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
|
2010-11-28 16:40:32 -05:00
|
|
|
@formats = Array.wrap(format).map { |f| f.is_a?(Mime::Type) ? f.ref : f }
|
2009-04-14 20:22:51 -04:00
|
|
|
end
|
2009-09-24 13:30:13 -04:00
|
|
|
|
2011-04-16 04:28:47 -04:00
|
|
|
# Returns if the underlying handler supports streaming. If so,
|
|
|
|
# a streaming buffer *may* be passed when it start rendering.
|
|
|
|
def supports_streaming?
|
|
|
|
handler.respond_to?(:supports_streaming?) && handler.supports_streaming?
|
|
|
|
end
|
|
|
|
|
2010-10-09 17:56:08 -04:00
|
|
|
# Render a template. If the template was not compiled yet, it is done
|
|
|
|
# exactly before rendering.
|
|
|
|
#
|
|
|
|
# This method is instrumented as "!render_template.action_view". Notice that
|
|
|
|
# we use a bang in this instrumentation because you don't want to
|
|
|
|
# consume this in production. This is only slow if it's being listened to.
|
2011-04-15 20:10:36 -04:00
|
|
|
def render(view, locals, buffer=nil, &block)
|
2010-04-28 00:16:06 -04:00
|
|
|
ActiveSupport::Notifications.instrument("!render_template.action_view", :virtual_path => @virtual_path) do
|
2010-10-07 09:50:20 -04:00
|
|
|
compile!(view)
|
2011-04-15 20:10:36 -04:00
|
|
|
view.send(method_name, locals, buffer, &block)
|
2010-03-17 17:19:42 -04:00
|
|
|
end
|
2009-08-11 18:02:05 -04:00
|
|
|
rescue Exception => e
|
2010-10-09 17:56:08 -04:00
|
|
|
handle_render_error(view, e)
|
2009-04-23 18:58:38 -04:00
|
|
|
end
|
2009-09-24 13:30:13 -04:00
|
|
|
|
2010-03-09 07:12:11 -05:00
|
|
|
def mime_type
|
|
|
|
@mime_type ||= Mime::Type.lookup_by_extension(@formats.first.to_s) if @formats.first
|
|
|
|
end
|
|
|
|
|
2010-10-09 17:56:08 -04:00
|
|
|
# Receives a view object and return a template similar to self by using @virtual_path.
|
|
|
|
#
|
|
|
|
# This method is useful if you have a template object but it does not contain its source
|
|
|
|
# anymore since it was already compiled. In such cases, all you need to do is to call
|
|
|
|
# refresh passing in the view object.
|
|
|
|
#
|
|
|
|
# Notice this method raises an error if the template to be refreshed does not have a
|
|
|
|
# virtual path set (true just for inline templates).
|
|
|
|
def refresh(view)
|
2010-10-10 07:43:32 -04:00
|
|
|
raise "A template needs to have a virtual path in order to be refreshed" unless @virtual_path
|
2010-10-10 05:03:18 -04:00
|
|
|
lookup = view.lookup_context
|
2010-10-09 17:56:08 -04:00
|
|
|
pieces = @virtual_path.split("/")
|
|
|
|
name = pieces.pop
|
2010-10-10 07:43:32 -04:00
|
|
|
partial = !!name.sub!(/^_/, "")
|
2010-10-10 05:03:18 -04:00
|
|
|
lookup.disable_cache do
|
2010-12-12 15:40:40 -05:00
|
|
|
lookup.find_template(name, [ pieces.join('/') ], partial, @locals)
|
2010-10-10 07:43:32 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2009-09-24 13:30:13 -04:00
|
|
|
def inspect
|
2011-05-01 05:14:38 -04:00
|
|
|
@inspect ||= defined?(Rails.root) ? identifier.sub("#{Rails.root}/", '') : identifier
|
2009-09-24 13:30:13 -04:00
|
|
|
end
|
2008-02-05 23:26:40 -05:00
|
|
|
|
2010-10-09 17:56:08 -04:00
|
|
|
protected
|
2010-10-07 09:50:20 -04:00
|
|
|
|
2010-10-09 17:56:08 -04:00
|
|
|
# Compile a template. This method ensures a template is compiled
|
|
|
|
# just once and removes the source after it is compiled.
|
|
|
|
def compile!(view) #:nodoc:
|
|
|
|
return if @compiled
|
2010-10-07 09:50:20 -04:00
|
|
|
|
2010-10-09 17:56:08 -04:00
|
|
|
if view.is_a?(ActionView::CompiledTemplates)
|
|
|
|
mod = ActionView::CompiledTemplates
|
|
|
|
else
|
|
|
|
mod = view.singleton_class
|
|
|
|
end
|
2010-10-07 09:50:20 -04:00
|
|
|
|
2010-10-09 17:56:08 -04:00
|
|
|
compile(view, mod)
|
2010-10-07 09:50:20 -04:00
|
|
|
|
2010-10-09 17:56:08 -04:00
|
|
|
# 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
|
2010-10-07 09:50:20 -04:00
|
|
|
|
2010-05-17 11:41:54 -04:00
|
|
|
# Among other things, this method is responsible for properly setting
|
|
|
|
# the encoding of the source. Until this point, we assume that the
|
|
|
|
# source is BINARY data. If no additional information is supplied,
|
2011-05-10 18:28:37 -04:00
|
|
|
# we assume the encoding is the same as <tt>Encoding.default_external</tt>.
|
2010-05-17 11:41:54 -04:00
|
|
|
#
|
|
|
|
# The user can also specify the encoding via a comment on the first
|
|
|
|
# line of the template (# encoding: NAME-OF-ENCODING). This will work
|
|
|
|
# with any template engine, as we process out the encoding comment
|
|
|
|
# before passing the source on to the template engine, leaving a
|
|
|
|
# blank line in its stead.
|
|
|
|
#
|
2010-05-30 05:07:34 -04:00
|
|
|
# If the template engine handles encodings, we send the encoded
|
|
|
|
# String to the engine without further processing. This allows
|
|
|
|
# the template engine to support additional mechanisms for
|
|
|
|
# specifying the encoding. For instance, ERB supports <%# encoding: %>
|
|
|
|
#
|
|
|
|
# Otherwise, after we figure out the correct encoding, we then
|
2011-05-10 18:28:37 -04:00
|
|
|
# encode the source into <tt>Encoding.default_internal</tt>.
|
|
|
|
# In general, this means that templates will be UTF-8 inside of Rails,
|
2010-05-17 11:41:54 -04:00
|
|
|
# regardless of the original source encoding.
|
2010-10-09 17:56:08 -04:00
|
|
|
def compile(view, mod) #:nodoc:
|
2010-10-07 09:50:20 -04:00
|
|
|
method_name = self.method_name
|
2009-04-23 18:58:38 -04:00
|
|
|
|
2010-05-17 11:41:54 -04:00
|
|
|
if source.encoding_aware?
|
2010-05-30 05:07:34 -04:00
|
|
|
# Look for # encoding: *. If we find one, we'll encode the
|
|
|
|
# String in that encoding, otherwise, we'll use the
|
|
|
|
# default external encoding.
|
2010-05-17 11:41:54 -04:00
|
|
|
if source.sub!(/\A#{ENCODING_FLAG}/, '')
|
2010-05-30 05:07:34 -04:00
|
|
|
encoding = magic_encoding = $1
|
2010-05-17 11:41:54 -04:00
|
|
|
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)
|
|
|
|
|
2010-05-30 05:07:34 -04:00
|
|
|
# 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?
|
2010-05-17 11:41:54 -04:00
|
|
|
source.encode!
|
2010-05-30 05:07:34 -04:00
|
|
|
# Otherwise, since the String is invalid in the encoding
|
|
|
|
# specified, raise an exception
|
2010-05-17 11:41:54 -04:00
|
|
|
else
|
|
|
|
raise WrongEncodingError.new(source, encoding)
|
|
|
|
end
|
2010-05-16 16:52:51 -04:00
|
|
|
end
|
2010-05-16 02:25:55 -04:00
|
|
|
|
2011-04-15 20:10:36 -04:00
|
|
|
code = @handler.call(self)
|
2010-05-17 11:41:54 -04:00
|
|
|
|
2010-05-30 05:07:34 -04:00
|
|
|
# Make sure that the resulting String to be evalled is in the
|
|
|
|
# encoding of the code
|
2009-09-24 13:30:13 -04:00
|
|
|
source = <<-end_src
|
2011-04-15 20:10:36 -04:00
|
|
|
def #{method_name}(local_assigns, output_buffer)
|
2011-05-01 05:14:38 -04:00
|
|
|
_old_virtual_path, @virtual_path = @virtual_path, #{@virtual_path.inspect};_old_output_buffer = @output_buffer;#{locals_code};#{code}
|
2009-09-24 13:30:13 -04:00
|
|
|
ensure
|
2011-05-01 05:14:38 -04:00
|
|
|
@virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
|
2009-09-24 13:30:13 -04:00
|
|
|
end
|
|
|
|
end_src
|
|
|
|
|
2010-05-17 11:41:54 -04:00
|
|
|
if source.encoding_aware?
|
2010-05-30 05:07:34 -04:00
|
|
|
# Make sure the source is in the encoding of the returned code
|
|
|
|
source.force_encoding(code.encoding)
|
2010-05-17 11:41:54 -04:00
|
|
|
|
|
|
|
# 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
|
2010-05-30 05:07:34 -04:00
|
|
|
# handler is valid in the default_internal. This is for handlers
|
|
|
|
# that handle encoding but screw up
|
2010-05-17 11:41:54 -04:00
|
|
|
unless source.valid_encoding?
|
|
|
|
raise WrongEncodingError.new(@source, Encoding.default_internal)
|
|
|
|
end
|
2009-04-23 18:58:38 -04:00
|
|
|
end
|
2008-07-12 15:33:46 -04:00
|
|
|
|
2009-09-24 13:30:13 -04:00
|
|
|
begin
|
2010-05-17 11:41:54 -04:00
|
|
|
mod.module_eval(source, identifier, 0)
|
2010-09-30 05:40:51 -04:00
|
|
|
ObjectSpace.define_finalizer(self, Finalizer[method_name, mod])
|
2009-09-24 13:30:13 -04:00
|
|
|
rescue Exception => e # errors from template code
|
|
|
|
if logger = (view && view.logger)
|
|
|
|
logger.debug "ERROR: compiling #{method_name} RAISED #{e}"
|
|
|
|
logger.debug "Function body: #{source}"
|
|
|
|
logger.debug "Backtrace: #{e.backtrace.join("\n")}"
|
|
|
|
end
|
|
|
|
|
2009-12-02 23:01:01 -05:00
|
|
|
raise ActionView::Template::Error.new(self, {}, e)
|
2009-09-24 13:30:13 -04:00
|
|
|
end
|
2009-04-23 18:58:38 -04:00
|
|
|
end
|
2009-08-14 15:00:52 -04:00
|
|
|
|
2010-10-09 17:56:08 -04:00
|
|
|
def handle_render_error(view, e) #:nodoc:
|
|
|
|
if e.is_a?(Template::Error)
|
|
|
|
e.sub_template_of(self)
|
|
|
|
raise e
|
|
|
|
else
|
|
|
|
assigns = view.respond_to?(:assigns) ? view.assigns : {}
|
|
|
|
template = @virtual_path ? refresh(view) : self
|
|
|
|
raise Template::Error.new(template, assigns, e)
|
2010-10-07 15:30:19 -04:00
|
|
|
end
|
2010-10-07 09:50:20 -04:00
|
|
|
end
|
|
|
|
|
2010-10-09 17:56:08 -04:00
|
|
|
def locals_code #:nodoc:
|
|
|
|
@locals.map { |key| "#{key} = local_assigns[:#{key}];" }.join
|
|
|
|
end
|
|
|
|
|
|
|
|
def method_name #:nodoc:
|
2010-10-07 09:50:20 -04:00
|
|
|
@method_name ||= "_#{identifier_method_name}__#{@identifier.hash}_#{__id__}".gsub('-', "_")
|
2010-06-29 12:21:24 -04:00
|
|
|
end
|
|
|
|
|
2010-10-09 17:56:08 -04:00
|
|
|
def identifier_method_name #:nodoc:
|
2010-10-07 09:50:20 -04:00
|
|
|
inspect.gsub(/[^a-z_]/, '_')
|
2009-09-24 13:30:13 -04:00
|
|
|
end
|
2009-04-23 18:58:38 -04:00
|
|
|
end
|
2009-05-28 18:12:28 -04:00
|
|
|
end
|