actionview 4.1.0.beta1

data/lib/action_view/log_subscriber.rb

@@ -0,0 +1,44 @@
+require 'active_support/log_subscriber'
+
+module ActionView
+  # = Action View Log Subscriber
+  #
+  # Provides functionality so that Rails can output logs from Action View.
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    VIEWS_PATTERN = /^app\/views\//
+
+    def initialize
+      @root = nil
+      super
+    end
+
+    def render_template(event)
+      return unless logger.info?
+      message = "  Rendered #{from_rails_root(event.payload[:identifier])}"
+      message << " within #{from_rails_root(event.payload[:layout])}" if event.payload[:layout]
+      message << " (#{event.duration.round(1)}ms)"
+      info(message)
+    end
+    alias :render_partial :render_template
+    alias :render_collection :render_template
+
+    def logger
+      ActionView::Base.logger
+    end
+
+  protected
+
+    EMPTY = ''
+    def from_rails_root(string)
+      string = string.sub(rails_root, EMPTY)
+      string.sub!(VIEWS_PATTERN, EMPTY)
+      string
+    end
+
+    def rails_root
+      @root ||= "#{Rails.root}/"
+    end
+  end
+end
+
+ActionView::LogSubscriber.attach_to :action_view

data/lib/action_view/lookup_context.rb

@@ -0,0 +1,249 @@
+require 'thread_safe'
+require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/module/attribute_accessors'
+
+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:
+    attr_accessor :prefixes, :rendered_format
+
+    mattr_accessor :fallbacks
+    @@fallbacks = FallbackFileSystemResolver.instances
+
+    mattr_accessor :registered_details
+    self.registered_details = []
+
+    def self.register_detail(name, options = {}, &block)
+      self.registered_details << name
+      initialize = registered_details.map { |n| "@details[:#{n}] = details[:#{n}] || default_#{n}" }
+
+      Accessors.send :define_method, :"default_#{name}", &block
+      Accessors.module_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def #{name}
+          @details.fetch(:#{name}, [])
+        end
+
+        def #{name}=(value)
+          value = value.present? ? Array(value) : default_#{name}
+          _set_detail(:#{name}, value) if value != @details[:#{name}]
+        end
+
+        remove_possible_method :initialize_details
+        def initialize_details(details)
+          #{initialize.join("\n")}
+        end
+      METHOD
+    end
+
+    # Holds accessors for the registered details.
+    module Accessors #:nodoc:
+    end
+
+    register_detail(:locale) do
+      locales = [I18n.locale]
+      locales.concat(I18n.fallbacks[I18n.locale]) if I18n.respond_to? :fallbacks
+      locales << I18n.default_locale
+      locales.uniq!
+      locales
+    end
+    register_detail(:formats) { ActionView::Base.default_formats || [:html, :text, :js, :css,  :xml, :json] }
+    register_detail(:variants) { [] }
+    register_detail(:handlers){ Template::Handlers.extensions }
+
+    class DetailsKey #:nodoc:
+      alias :eql? :equal?
+      alias :object_hash :hash
+
+      attr_reader :hash
+      @details_keys = ThreadSafe::Cache.new
+
+      def self.get(details)
+        if details[:formats]
+          details = details.dup
+          syms    = Set.new Mime::SET.symbols
+          details[:formats] = details[:formats].select { |v|
+            syms.include? v
+          }
+        end
+        @details_keys[details] ||= new
+      end
+
+      def self.clear
+        @details_keys.clear
+      end
+
+      def initialize
+        @hash = object_hash
+      end
+    end
+
+    # Add caching behavior on top of Details.
+    module DetailsCache
+      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
+
+    protected
+
+      def _set_detail(key, value)
+        @details = @details.dup if @details_key
+        @details_key = nil
+        @details[key] = value
+      end
+    end
+
+    # Helpers related to template lookup using the lookup context information.
+    module ViewPaths
+      attr_reader :view_paths, :html_fallback_for_js
+
+      # 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::PathSet.new(Array(paths))
+      end
+
+      def find(name, prefixes = [], partial = false, keys = [], options = {})
+        @view_paths.find(*args_for_lookup(name, prefixes, partial, keys, options))
+      end
+      alias :find_template :find
+
+      def find_all(name, prefixes = [], partial = false, keys = [], options = {})
+        @view_paths.find_all(*args_for_lookup(name, prefixes, partial, keys, options))
+      end
+
+      def exists?(name, prefixes = [], partial = false, keys = [], options = {})
+        @view_paths.exists?(*args_for_lookup(name, prefixes, partial, keys, options))
+      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, details_options) #:nodoc:
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for(details_options)
+        [name, prefixes, partial || false, details, details_key, keys]
+      end
+
+      # Compute details hash and key according to user options (e.g. passed from #render).
+      def detail_args_for(options)
+        return @details, details_key if options.empty? # most common path.
+        user_details = @details.merge(options)
+        [user_details, DetailsKey.get(user_details)]
+      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:
+        prefixes = prefixes.presence
+        parts    = name.to_s.split('/')
+        parts.shift if parts.first.empty?
+        name     = parts.pop
+
+        return name, prefixes || [""] if parts.empty?
+
+        parts    = parts.join('/')
+        prefixes = prefixes ? prefixes.map { |p| "#{p}/#{parts}" } : [parts]
+
+        return name, prefixes
+      end
+    end
+
+    include Accessors
+    include DetailsCache
+    include ViewPaths
+
+    def initialize(view_paths, details = {}, prefixes = [])
+      @details, @details_key = {}, nil
+      @skip_default_locale = false
+      @cache = true
+      @prefixes = prefixes
+      @rendered_format = nil
+
+      self.view_paths = view_paths
+      initialize_details(details)
+    end
+
+    # Override formats= to expand ["*/*"] values and automatically
+    # add :html as fallback to :js.
+    def formats=(values)
+      if values
+        values.concat(default_formats) if values.delete "*/*"
+        if values == [:js]
+          values << :html
+          @html_fallback_for_js = true
+        end
+      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
+
+    # Override 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 original_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?(:original_config) ? I18n.config.original_config : I18n.config
+        config.locale = value
+      end
+
+      super(@skip_default_locale ? I18n.locale : default_locale)
+    end
+
+    # A method which only uses the first format in the formats array for layout lookup.
+    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
+  end
+end

data/lib/action_view/model_naming.rb

@@ -0,0 +1,12 @@
+module ActionView
+  module ModelNaming
+    # Converts the given object to an ActiveModel compliant one.
+    def convert_to_model(object)
+      object.respond_to?(:to_model) ? object.to_model : object
+    end
+
+    def model_name_from_record_or_class(record_or_class)
+      (record_or_class.is_a?(Class) ? record_or_class : convert_to_model(record_or_class).class).model_name
+    end
+  end
+end

data/lib/action_view/path_set.rb

@@ -0,0 +1,77 @@
+module ActionView #:nodoc:
+  # = Action View PathSet
+  #
+  # This class is used to store and access paths in Action View. A number of
+  # operations are defined so that you can search among the paths in this
+  # set and also perform operations on other +PathSet+ objects.
+  #
+  # A +LookupContext+ will use a +PathSet+ to store the paths in its context.
+  class PathSet #:nodoc:
+    include Enumerable
+
+    attr_reader :paths
+
+    delegate :[], :include?, :pop, :size, :each, to: :paths
+
+    def initialize(paths = [])
+      @paths = typecast paths
+    end
+
+    def initialize_copy(other)
+      @paths = other.paths.dup
+      self
+    end
+
+    def to_ary
+      paths.dup
+    end
+
+    def compact
+      PathSet.new paths.compact
+    end
+
+    def +(array)
+      PathSet.new(paths + array)
+    end
+
+    %w(<< concat push insert unshift).each do |method|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def #{method}(*args)
+          paths.#{method}(*typecast(args))
+        end
+      METHOD
+    end
+
+    def find(*args)
+      find_all(*args).first || raise(MissingTemplate.new(self, *args))
+    end
+
+    def find_all(path, prefixes = [], *args)
+      prefixes = [prefixes] if String === prefixes
+      prefixes.each do |prefix|
+        paths.each do |resolver|
+          templates = resolver.find_all(path, prefix, *args)
+          return templates unless templates.empty?
+        end
+      end
+      []
+    end
+
+    def exists?(path, prefixes, *args)
+      find_all(path, prefixes, *args).any?
+    end
+
+    private
+
+    def typecast(paths)
+      paths.map do |path|
+        case path
+        when Pathname, String
+          OptimizedFileSystemResolver.new path.to_s
+        else
+          path
+        end
+      end
+    end
+  end
+end

data/lib/action_view/railtie.rb

@@ -0,0 +1,49 @@
+require "action_view"
+require "rails"
+
+module ActionView
+  # = Action View Railtie
+  class Railtie < Rails::Railtie # :nodoc:
+    config.action_view = ActiveSupport::OrderedOptions.new
+    config.action_view.embed_authenticity_token_in_remote_forms = false
+
+    config.eager_load_namespaces << ActionView
+
+    initializer "action_view.embed_authenticity_token_in_remote_forms" do |app|
+      ActiveSupport.on_load(:action_view) do
+        ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms =
+          app.config.action_view.delete(:embed_authenticity_token_in_remote_forms)
+      end
+    end
+
+    initializer "action_view.logger" do
+      ActiveSupport.on_load(:action_view) { self.logger ||= Rails.logger }
+    end
+
+    initializer "action_view.set_configs" do |app|
+      ActiveSupport.on_load(:action_view) do
+        app.config.action_view.each do |k,v|
+          send "#{k}=", v
+        end
+      end
+    end
+
+    initializer "action_view.caching" do |app|
+      ActiveSupport.on_load(:action_view) do
+        if app.config.action_view.cache_template_loading.nil?
+          ActionView::Resolver.caching = app.config.cache_classes
+        end
+      end
+    end
+
+    initializer "action_view.setup_action_pack" do |app|
+      ActiveSupport.on_load(:action_controller) do
+        ActionView::RoutingUrlFor.send(:include, ActionDispatch::Routing::UrlFor)
+      end
+    end
+
+    rake_tasks do
+      load "action_view/tasks/dependencies.rake"
+    end
+  end
+end

data/lib/action_view/record_identifier.rb

@@ -0,0 +1,84 @@
+require 'active_support/core_ext/module'
+require 'action_view/model_naming'
+
+module ActionView
+  # The record identifier encapsulates a number of naming conventions for dealing with records, like Active Records or
+  # pretty much any other model type that has an id. These patterns are then used to try elevate the view actions to
+  # a higher logical level.
+  #
+  #   # routes
+  #   resources :posts
+  #
+  #   # view
+  #   <%= div_for(post) do %>    <div id="post_45" class="post">
+  #     <%= post.body %>           What a wonderful world!
+  #   <% end %>                  </div>
+  #
+  #   # controller
+  #   def update
+  #     post = Post.find(params[:id])
+  #     post.update(params[:post])
+  #
+  #     redirect_to(post) # Calls polymorphic_url(post) which in turn calls post_url(post)
+  #   end
+  #
+  # As the example above shows, you can stop caring to a large extent what the actual id of the post is.
+  # You just know that one is being assigned and that the subsequent calls in redirect_to expect that
+  # same naming convention and allows you to write less code if you follow it.
+  module RecordIdentifier
+    extend self
+    extend ModelNaming
+
+    include ModelNaming
+
+    JOIN = '_'.freeze
+    NEW = 'new'.freeze
+
+    # The DOM class convention is to use the singular form of an object or class.
+    #
+    #   dom_class(post)   # => "post"
+    #   dom_class(Person) # => "person"
+    #
+    # If you need to address multiple instances of the same class in the same view, you can prefix the dom_class:
+    #
+    #   dom_class(post, :edit)   # => "edit_post"
+    #   dom_class(Person, :edit) # => "edit_person"
+    def dom_class(record_or_class, prefix = nil)
+      singular = model_name_from_record_or_class(record_or_class).param_key
+      prefix ? "#{prefix}#{JOIN}#{singular}" : singular
+    end
+
+    # The DOM id convention is to use the singular form of an object or class with the id following an underscore.
+    # If no id is found, prefix with "new_" instead.
+    #
+    #   dom_id(Post.find(45))       # => "post_45"
+    #   dom_id(Post.new)            # => "new_post"
+    #
+    # If you need to address multiple instances of the same class in the same view, you can prefix the dom_id:
+    #
+    #   dom_id(Post.find(45), :edit) # => "edit_post_45"
+    #   dom_id(Post.new, :custom)    # => "custom_post"
+    def dom_id(record, prefix = nil)
+      if record_id = record_key_for_dom_id(record)
+        "#{dom_class(record, prefix)}#{JOIN}#{record_id}"
+      else
+        dom_class(record, prefix || NEW)
+      end
+    end
+
+  protected
+
+    # Returns a string representation of the key attribute(s) that is suitable for use in an HTML DOM id.
+    # This can be overwritten to customize the default generated string representation if desired.
+    # If you need to read back a key from a dom_id in order to query for the underlying database record,
+    # you should write a helper like 'person_record_from_dom_id' that will extract the key either based
+    # on the default implementation (which just joins all key attributes with '_') or on your own
+    # overwritten version of the method. By default, this implementation passes the key string through a
+    # method that replaces all characters that are invalid inside DOM ids, with valid ones. You need to
+    # make sure yourself that your dom ids are valid, in case you overwrite this method.
+    def record_key_for_dom_id(record)
+      key = convert_to_model(record).to_key
+      key ? key.join('_') : key
+    end
+  end
+end