actionpack 3.2.19 → 4.0.0

data/lib/action_view/helpers.rb

@@ -6,6 +6,7 @@ module ActionView #:nodoc:
 
     autoload :ActiveModelHelper
     autoload :AssetTagHelper
+    autoload :AssetUrlHelper
     autoload :AtomFeedHelper
     autoload :CacheHelper
     autoload :CaptureHelper
@@ -29,13 +30,10 @@ module ActionView #:nodoc:
 
     extend ActiveSupport::Concern
 
-    included do
-      extend SanitizeHelper::ClassMethods
-    end
-
     include ActiveSupport::Benchmarkable
     include ActiveModelHelper
     include AssetTagHelper
+    include AssetUrlHelper
     include AtomFeedHelper
     include CacheHelper
     include CaptureHelper

data/lib/action_view/locale/en.yml

@@ -1,101 +1,4 @@
 "en":
-  number:
-    # Used in number_with_delimiter()
-    # These are also the defaults for 'currency', 'percentage', 'precision', and 'human'
-    format:
-      # Sets the separator between the units, for more precision (e.g. 1.0 / 2.0 == 0.5)
-      separator: "."
-      # Delimits thousands (e.g. 1,000,000 is a million) (always in groups of three)
-      delimiter: ","
-      # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
-      precision: 3
-      # If set to true, precision will mean the number of significant digits instead
-      # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
-      significant: false
-      # If set, the zeros after the decimal separator will always be stripped (eg.: 1.200 will be 1.2)
-      strip_insignificant_zeros: false
-
-    # Used in number_to_currency()
-    currency:
-      format:
-        # Where is the currency sign? %u is the currency unit, %n the number (default: $5.00)
-        format: "%u%n"
-        unit: "$"
-        # These five are to override number.format and are optional
-        separator: "."
-        delimiter: ","
-        precision: 2
-        significant: false
-        strip_insignificant_zeros: false
-
-    # Used in number_to_percentage()
-    percentage:
-      format:
-        # These five are to override number.format and are optional
-        # separator:
-        delimiter: ""
-        # precision:
-        # significant: false
-        # strip_insignificant_zeros: false
-
-    # Used in number_to_precision()
-    precision:
-      format:
-        # These five are to override number.format and are optional
-        # separator:
-        delimiter: ""
-        # precision:
-        # significant: false
-        # strip_insignificant_zeros: false
-
-    # Used in number_to_human_size() and number_to_human()
-    human:
-      format:
-        # These five are to override number.format and are optional
-        # separator:
-        delimiter: ""
-        precision: 3
-        significant: true
-        strip_insignificant_zeros: true
-      # Used in number_to_human_size()
-      storage_units:
-        # Storage units output formatting.
-        # %u is the storage unit, %n is the number (default: 2 MB)
-        format: "%n %u"
-        units:
-          byte:
-            one:   "Byte"
-            other: "Bytes"
-          kb: "KB"
-          mb: "MB"
-          gb: "GB"
-          tb: "TB"
-      # Used in number_to_human()
-      decimal_units:
-        format: "%n %u"
-        # Decimal units output formatting
-        # By default we will only quantify some of the exponents
-        # but the commented ones might be defined or overridden
-        # by the user.
-        units:
-          # femto: Quadrillionth
-          # pico: Trillionth
-          # nano: Billionth
-          # micro: Millionth
-          # mili: Thousandth
-          # centi: Hundredth
-          # deci: Tenth
-          unit: ""
-          # ten:
-          #   one: Ten
-          #   other: Tens
-          # hundred: Hundred
-          thousand: Thousand
-          million: Million
-          billion: Billion
-          trillion: Trillion
-          quadrillion: Quadrillion
-
   # Used in distance_of_time_in_words(), distance_of_time_in_words_to_now(), time_ago_in_words()
   datetime:
     distance_in_words:
@@ -146,15 +49,8 @@
       # Default value for :prompt => true in FormOptionsHelper
       prompt: "Please select"
 
-    # Default translation keys for submit FormHelper
+    # Default translation keys for submit and button FormHelper
     submit:
       create: 'Create %{model}'
       update: 'Update %{model}'
       submit: 'Save %{model}'
-
-    # Default translation keys for button FormHelper
-    button:
-      create: 'Create %{model}'
-      update: 'Update %{model}'
-      submit: 'Save %{model}'
-

data/lib/action_view/log_subscriber.rb

@@ -3,24 +3,26 @@ module ActionView
   #
   # Provides functionality so that Rails can output logs from Action View.
   class LogSubscriber < ActiveSupport::LogSubscriber
+    VIEWS_PATTERN = /^app\/views\//.freeze
+
     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 << (" (%.1fms)" % event.duration)
+      message << " (#{event.duration.round(1)}ms)"
       info(message)
     end
     alias :render_partial :render_template
     alias :render_collection :render_template
 
-    # TODO: Ideally, ActionView should have its own logger so it does not depend on AC.logger
     def logger
-      ActionController::Base.logger if defined?(ActionController::Base)
+      ActionView::Base.logger
     end
 
   protected
 
     def from_rails_root(string)
-      string.sub("#{Rails.root}/", "").sub(/^app\/views\//, "")
+      string.sub("#{Rails.root}/", "").sub(VIEWS_PATTERN, "")
     end
   end
 end

data/lib/action_view/lookup_context.rb

@@ -1,6 +1,6 @@
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/object/blank'
+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
@@ -25,11 +25,11 @@ module ActionView
       Accessors.send :define_method, :"default_#{name}", &block
       Accessors.module_eval <<-METHOD, __FILE__, __LINE__ + 1
         def #{name}
-          @details[:#{name}]
+          @details.fetch(:#{name}, [])
         end
 
         def #{name}=(value)
-          value = value.present? ? Array.wrap(value) : default_#{name}
+          value = value.present? ? Array(value) : default_#{name}
           _set_detail(:#{name}, value) if value != @details[:#{name}]
         end
 
@@ -51,7 +51,7 @@ module ActionView
       locales.uniq!
       locales
     end
-    register_detail(:formats) { Mime::SET.symbols }
+    register_detail(:formats) { ActionView::Base.default_formats || [:html, :text, :js, :css,  :xml, :json] }
     register_detail(:handlers){ Template::Handlers.extensions }
 
     class DetailsKey #:nodoc:
@@ -59,16 +59,9 @@ module ActionView
       alias :object_hash :hash
 
       attr_reader :hash
-      @details_keys = Hash.new
+      @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
 
@@ -110,12 +103,12 @@ module ActionView
 
     # Helpers related to template lookup using the lookup context information.
     module ViewPaths
-      attr_reader :view_paths
+      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.wrap(paths))
+        @view_paths = ActionView::PathSet.new(Array(paths))
       end
 
       def find(name, prefixes = [], partial = false, keys = [], options = {})
@@ -164,14 +157,9 @@ module ActionView
       # 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.sub(handlers_regexp) do |match|
-          ActiveSupport::Deprecation.warn "Passing a template handler in the template name is deprecated. " \
-            "You can simply remove the handler name or pass render :handlers => [:#{match[1..-1]}] instead.", caller
-          ""
-        end
-
-        prefixes = nil if prefixes.blank?
-        parts    = name.split('/')
+        prefixes = prefixes.presence
+        parts    = name.to_s.split('/')
+        parts.shift if parts.first.empty?
         name     = parts.pop
 
         return name, prefixes || [""] if parts.empty?
@@ -181,10 +169,6 @@ module ActionView
 
         return name, prefixes
       end
-
-      def handlers_regexp #:nodoc:
-        @@handlers_regexp ||= /\.(?:#{default_handlers.join('|')})$/
-      end
     end
 
     include Accessors
@@ -207,7 +191,10 @@ module ActionView
     def formats=(values)
       if values
         values.concat(default_formats) if values.delete "*/*"
-        values << :html if values == [:js]
+        if values == [:js]
+          values << :html
+          @html_fallback_for_js = true
+        end
       end
       super(values)
     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

@@ -1,10 +1,18 @@
 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
@@ -14,30 +22,10 @@ module ActionView #:nodoc:
       self
     end
 
-    def [](i)
-      paths[i]
-    end
-
     def to_ary
       paths.dup
     end
 
-    def include?(item)
-      paths.include? item
-    end
-
-    def pop
-      paths.pop
-    end
-
-    def size
-      paths.size
-    end
-
-    def each(&block)
-      paths.each(&block)
-    end
-
     def compact
       PathSet.new paths.compact
     end

data/lib/action_view/railtie.rb

@@ -3,11 +3,11 @@ require "rails"
 
 module ActionView
   # = Action View Railtie
-  class Railtie < Rails::Railtie
+  class Railtie < Rails::Railtie # :nodoc:
     config.action_view = ActiveSupport::OrderedOptions.new
-    config.action_view.stylesheet_expansions = {}
-    config.action_view.javascript_expansions = { :defaults => %w(jquery jquery_ujs) }
-    config.action_view.embed_authenticity_token_in_remote_forms = true
+    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
@@ -16,24 +16,8 @@ module ActionView
       end
     end
 
-    initializer "action_view.cache_asset_ids" do |app|
-      unless app.config.cache_classes
-        ActiveSupport.on_load(:action_view) do
-          ActionView::Helpers::AssetTagHelper::AssetPaths.cache_asset_ids = false
-        end
-      end
-    end
-
-    initializer "action_view.javascript_expansions" do |app|
-      ActiveSupport.on_load(:action_view) do
-        ActionView::Helpers::AssetTagHelper.register_javascript_expansion(
-          app.config.action_view.delete(:javascript_expansions)
-        )
-
-        ActionView::Helpers::AssetTagHelper.register_stylesheet_expansion(
-          app.config.action_view.delete(:stylesheet_expansions)
-        )
-      end
+    initializer "action_view.logger" do
+      ActiveSupport.on_load(:action_view) { self.logger ||= Rails.logger }
     end
 
     initializer "action_view.set_configs" do |app|

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

data/lib/action_view/renderer/abstract_renderer.rb

@@ -1,7 +1,21 @@
 module ActionView
+  # This class defines the interface for a renderer. Each class that
+  # subclasses +AbstractRenderer+ is used by the base +Renderer+ class to
+  # render a specific type of object.
+  #
+  # The base +Renderer+ class uses its +render+ method to delegate to the
+  # renderers. These currently consist of
+  #
+  #   PartialRenderer - Used for rendering partials
+  #   TemplateRenderer - Used for rendering other types of templates
+  #   StreamingTemplateRenderer - Used for streaming
+  #
+  # Whenever the +render+ method is called on the base +Renderer+ class, a new
+  # renderer object of the correct type is created, and the +render+ method on
+  # that new object is called in turn. This abstracts the setup and rendering
+  # into a separate classes for partials and templates.
   class AbstractRenderer #:nodoc:
-    delegate :find_template, :template_exists?, :with_fallbacks, :update_details,
-      :with_layout_format, :formats, :to => :@lookup_context
+    delegate :find_template, :template_exists?, :with_fallbacks, :with_layout_format, :formats, :to => :@lookup_context
 
     def initialize(lookup_context)
       @lookup_context = lookup_context
@@ -12,30 +26,22 @@ module ActionView
     end
 
     protected
-    
+
     def extract_details(options)
-      details = {}
-      @lookup_context.registered_details.each do |key|
+      @lookup_context.registered_details.each_with_object({}) do |key, details|
         next unless value = options[key]
-        details[key] = Array.wrap(value)
-      end
-      details
-    end
-    
-    def extract_format(value, details)
-      if value.is_a?(String) && value.sub!(formats_regexp, "")
-        ActiveSupport::Deprecation.warn "Passing the format in the template name is deprecated. " \
-          "Please pass render with :formats => [:#{$1}] instead.", caller
-        details[:formats] ||= [$1.to_sym]
+        details[key] = Array(value)
       end
     end
 
-    def formats_regexp
-      @@formats_regexp ||= /\.(#{Mime::SET.symbols.join('|')})$/
-    end
-
     def instrument(name, options={})
       ActiveSupport::Notifications.instrument("render_#{name}.action_view", options){ yield }
     end
+
+    def prepend_formats(formats)
+      formats = Array(formats)
+      return if formats.empty? || @lookup_context.html_fallback_for_js
+      @lookup_context.formats = formats | @lookup_context.formats
+    end
   end
 end