mirror of
https://github.com/rails/rails.git
synced 2022-11-09 12:12:34 -05:00
248 lines
7.5 KiB
Ruby
248 lines
7.5 KiB
Ruby
require 'active_support/core_ext/array/wrap'
|
|
require 'active_support/core_ext/object/blank'
|
|
|
|
module ActionView
|
|
# = Action View Lookup Context
|
|
#
|
|
# LookupContext is the object responsible to hold all information required to lookup
|
|
# templates, i.e. view paths and details. The LookupContext is also responsible to
|
|
# generate a key, given to view paths, used in the resolver cache lookup. Since
|
|
# this key is generated just once during the request, it speeds up all cache accesses.
|
|
class LookupContext #:nodoc:
|
|
mattr_accessor :fallbacks
|
|
@@fallbacks = FallbackFileSystemResolver.instances
|
|
|
|
mattr_accessor :registered_details
|
|
self.registered_details = []
|
|
|
|
mattr_accessor :registered_detail_setters
|
|
self.registered_detail_setters = []
|
|
|
|
def self.register_detail(name, options = {}, &block)
|
|
self.registered_details << name
|
|
self.registered_detail_setters << [name, "#{name}="]
|
|
|
|
Accessors.send :define_method, :"_#{name}_defaults", &block
|
|
Accessors.module_eval <<-METHOD, __FILE__, __LINE__ + 1
|
|
def #{name}
|
|
@details[:#{name}]
|
|
end
|
|
|
|
def #{name}=(value)
|
|
value = Array.wrap(value.presence || _#{name}_defaults)
|
|
_set_detail(:#{name}, value) if value != @details[:#{name}]
|
|
end
|
|
METHOD
|
|
end
|
|
|
|
# Holds accessors for the registered details.
|
|
module Accessors #:nodoc:
|
|
end
|
|
|
|
register_detail(:formats) { Mime::SET.symbols }
|
|
register_detail(:locale) { [I18n.locale, I18n.default_locale] }
|
|
|
|
class DetailsKey #:nodoc:
|
|
alias :eql? :equal?
|
|
alias :object_hash :hash
|
|
|
|
attr_reader :hash
|
|
@details_keys = Hash.new
|
|
|
|
def self.get(details)
|
|
@details_keys[details.freeze] ||= new
|
|
end
|
|
|
|
def initialize
|
|
@hash = object_hash
|
|
end
|
|
end
|
|
|
|
def initialize(view_paths, details = {})
|
|
@details, @details_key = { :handlers => default_handlers }, nil
|
|
@frozen_formats, @skip_default_locale = false, false
|
|
@cache = true
|
|
|
|
self.view_paths = view_paths
|
|
self.registered_detail_setters.each do |key, setter|
|
|
send(setter, details[key])
|
|
end
|
|
end
|
|
|
|
module ViewPaths
|
|
attr_reader :view_paths
|
|
|
|
# Whenever setting view paths, makes a copy so we can manipulate then in
|
|
# instance objects as we wish.
|
|
def view_paths=(paths)
|
|
@view_paths = ActionView::Base.process_view_paths(paths)
|
|
end
|
|
|
|
def find(name, prefixes = [], partial = false, keys = [])
|
|
@view_paths.find(*args_for_lookup(name, prefixes, partial, keys))
|
|
end
|
|
alias :find_template :find
|
|
|
|
def find_all(name, prefixes = [], partial = false, keys = [])
|
|
@view_paths.find_all(*args_for_lookup(name, prefixes, partial, keys))
|
|
end
|
|
|
|
def exists?(name, prefixes = [], partial = false, keys = [])
|
|
@view_paths.exists?(*args_for_lookup(name, prefixes, partial, keys))
|
|
end
|
|
alias :template_exists? :exists?
|
|
|
|
# Add fallbacks to the view paths. Useful in cases you are rendering a :file.
|
|
def with_fallbacks
|
|
added_resolvers = 0
|
|
self.class.fallbacks.each do |resolver|
|
|
next if view_paths.include?(resolver)
|
|
view_paths.push(resolver)
|
|
added_resolvers += 1
|
|
end
|
|
yield
|
|
ensure
|
|
added_resolvers.times { view_paths.pop }
|
|
end
|
|
|
|
protected
|
|
|
|
def args_for_lookup(name, prefixes, partial, keys) #:nodoc:
|
|
name, prefixes = normalize_name(name, prefixes)
|
|
[name, prefixes, partial || false, @details, details_key, keys]
|
|
end
|
|
|
|
# Support legacy foo.erb names even though we now ignore .erb
|
|
# as well as incorrectly putting part of the path in the template
|
|
# name instead of the prefix.
|
|
def normalize_name(name, prefixes) #:nodoc:
|
|
name = name.to_s.gsub(handlers_regexp, '')
|
|
parts = name.split('/')
|
|
name = parts.pop
|
|
|
|
prefixes = if prefixes.blank?
|
|
[parts.join('/')]
|
|
else
|
|
prefixes.map { |prefix| [prefix, *parts].compact.join('/') }
|
|
end
|
|
|
|
return name, prefixes
|
|
end
|
|
|
|
def default_handlers #:nodoc:
|
|
@@default_handlers ||= Template::Handlers.extensions
|
|
end
|
|
|
|
def handlers_regexp #:nodoc:
|
|
@@handlers_regexp ||= /\.(?:#{default_handlers.join('|')})$/
|
|
end
|
|
end
|
|
|
|
module Details
|
|
attr_accessor :cache
|
|
|
|
# Calculate the details key. Remove the handlers from calculation to improve performance
|
|
# since the user cannot modify it explicitly.
|
|
def details_key #:nodoc:
|
|
@details_key ||= DetailsKey.get(@details) if @cache
|
|
end
|
|
|
|
# Temporary skip passing the details_key forward.
|
|
def disable_cache
|
|
old_value, @cache = @cache, false
|
|
yield
|
|
ensure
|
|
@cache = old_value
|
|
end
|
|
|
|
# Freeze the current formats in the lookup context. By freezing them, you are guaranteeing
|
|
# that next template lookups are not going to modify the formats. The controller can also
|
|
# use this, to ensure that formats won't be further modified (as it does in respond_to blocks).
|
|
def freeze_formats(formats, unless_frozen=false) #:nodoc:
|
|
return if unless_frozen && @frozen_formats
|
|
self.formats = formats
|
|
@frozen_formats = true
|
|
end
|
|
|
|
# Overload formats= to reject [:"*/*"] values.
|
|
def formats=(values)
|
|
if values && values.size == 1
|
|
value = values.first
|
|
values = nil if value == :"*/*"
|
|
values << :html if value == :js
|
|
end
|
|
super(values)
|
|
end
|
|
|
|
# Do not use the default locale on template lookup.
|
|
def skip_default_locale!
|
|
@skip_default_locale = true
|
|
self.locale = nil
|
|
end
|
|
|
|
# Overload locale to return a symbol instead of array.
|
|
def locale
|
|
@details[:locale].first
|
|
end
|
|
|
|
# Overload locale= to also set the I18n.locale. If the current I18n.config object responds
|
|
# to i18n_config, it means that it's has a copy of the original I18n configuration and it's
|
|
# acting as proxy, which we need to skip.
|
|
def locale=(value)
|
|
if value
|
|
config = I18n.config.respond_to?(:i18n_config) ? I18n.config.i18n_config : I18n.config
|
|
config.locale = value
|
|
end
|
|
|
|
super(@skip_default_locale ? I18n.locale : _locale_defaults)
|
|
end
|
|
|
|
# A method which only uses the first format in the formats array for layout lookup.
|
|
# This method plays straight with instance variables for performance reasons.
|
|
def with_layout_format
|
|
if formats.size == 1
|
|
yield
|
|
else
|
|
old_formats = formats
|
|
_set_detail(:formats, formats[0,1])
|
|
|
|
begin
|
|
yield
|
|
ensure
|
|
_set_detail(:formats, old_formats)
|
|
end
|
|
end
|
|
end
|
|
|
|
# Update the details keys by merging the given hash into the current
|
|
# details hash. If a block is given, the details are modified just during
|
|
# the execution of the block and reverted to the previous value after.
|
|
def update_details(new_details)
|
|
old_details = @details.dup
|
|
|
|
registered_detail_setters.each do |key, setter|
|
|
send(setter, new_details[key]) if new_details.key?(key)
|
|
end
|
|
|
|
begin
|
|
yield
|
|
ensure
|
|
@details_key = nil
|
|
@details = old_details
|
|
end
|
|
end
|
|
|
|
protected
|
|
|
|
def _set_detail(key, value)
|
|
@details_key = nil
|
|
@details = @details.dup if @details.frozen?
|
|
@details[key] = value.freeze
|
|
end
|
|
end
|
|
|
|
include Accessors
|
|
include Details
|
|
include ViewPaths
|
|
end
|
|
end
|