actionview 4.2.11 → 5.0.7

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2014 David Heinemeier Hansson
+Copyright (c) 2004-2016 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -9,11 +9,11 @@ used to inline short Ruby snippets inside HTML), and XML Builder.
 
 The latest version of Action View can be installed with RubyGems:
 
-  % [sudo] gem install actionview
+  $ gem install actionview
 
 Source code can be downloaded as part of the Rails project on GitHub
 
-* https://github.com/rails/rails/tree/4-2-stable/actionview
+* https://github.com/rails/rails/tree/5-0-stable/actionview
 
 
 == License
@@ -36,4 +36,3 @@ Bug reports can be filed for the Ruby on Rails project here:
 Feature requests should be discussed on the rails-core mailing list here:
 
 * https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
-

data/lib/action_view.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2014 David Heinemeier Hansson
+# Copyright (c) 2004-2016 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/action_view/base.rb

@@ -70,6 +70,14 @@ module ActionView #:nodoc:
   #   Headline: <%= headline %>
   #   First name: <%= person.first_name %>
   #
+  # The local variables passed to sub templates can be accessed as a hash using the <tt>local_assigns</tt> hash. This lets you access the
+  # variables as:
+  #
+  #   Headline: <%= local_assigns[:headline] %>
+  #
+  # This is useful in cases where you aren't sure if the local variable has been assigned. Alternatively, you could also use
+  # <tt>defined? headline</tt> to first check if the variable has been assigned before using it.
+  #
   # === Template caching
   #
   # By default, Rails will compile each template to a method in order to render it. When you alter a template,
@@ -126,8 +134,8 @@ module ActionView #:nodoc:
   #     end
   #   end
   #
-  # For more information on Builder please consult the [source
-  # code](https://github.com/jimweirich/builder).
+  # For more information on Builder please consult the {source
+  # code}[https://github.com/jimweirich/builder].
   class Base
     include Helpers, ::ERB::Util, Context
 
@@ -153,6 +161,10 @@ module ActionView #:nodoc:
     cattr_accessor :raise_on_missing_translations
     @@raise_on_missing_translations = false
 
+    # Specify whether submit_tag should automatically disable on click
+    cattr_accessor :automatically_disable_submit_tag
+    @@automatically_disable_submit_tag = true
+
     class_attribute :_routes
     class_attribute :logger
 

data/lib/action_view/dependency_tracker.rb

@@ -1,22 +1,26 @@
-require 'thread_safe'
+require 'concurrent/map'
+require 'action_view/path_set'
 
 module ActionView
   class DependencyTracker # :nodoc:
-    @trackers = ThreadSafe::Cache.new
+    @trackers = Concurrent::Map.new
 
-    def self.find_dependencies(name, template)
+    def self.find_dependencies(name, template, view_paths = nil)
       tracker = @trackers[template.handler]
+      return [] unless tracker
 
-      if tracker.present?
-        tracker.call(name, template)
-      else
-        []
-      end
+      tracker.call(name, template, view_paths)
     end
 
     def self.register_tracker(extension, tracker)
       handler = Template.handler_for_extension(extension)
-      @trackers[handler] = tracker
+      if tracker.respond_to?(:supports_view_paths?)
+        @trackers[handler] = tracker
+      else
+        @trackers[handler] = lambda { |name, template, _|
+          tracker.call(name, template)
+        }
+      end
     end
 
     def self.remove_tracker(handler)
@@ -76,12 +80,22 @@ module ActionView
         (?:#{STRING}|#{VARIABLE_OR_METHOD_CHAIN})      # finally, the dependency name of interest
       /xm
 
-      def self.call(name, template)
-        new(name, template).dependencies
+      LAYOUT_DEPENDENCY = /\A
+        (?:\s*\(?\s*)                                  # optional opening paren surrounded by spaces
+        (?:.*?#{LAYOUT_HASH_KEY})                      # check if the line has layout key declaration
+        (?:#{STRING}|#{VARIABLE_OR_METHOD_CHAIN})      # finally, the dependency name of interest
+      /xm
+
+      def self.supports_view_paths? # :nodoc:
+        true
+      end
+
+      def self.call(name, template, view_paths = nil)
+        new(name, template, view_paths).dependencies
       end
 
-      def initialize(name, template)
-        @name, @template = name, template
+      def initialize(name, template, view_paths = nil)
+        @name, @template, @view_paths = name, template, view_paths
       end
 
       def dependencies
@@ -106,15 +120,20 @@ module ActionView
           render_calls = source.split(/\brender\b/).drop(1)
 
           render_calls.each do |arguments|
-            arguments.scan(RENDER_ARGUMENTS) do
-              add_dynamic_dependency(render_dependencies, Regexp.last_match[:dynamic])
-              add_static_dependency(render_dependencies, Regexp.last_match[:static])
-            end
+            add_dependencies(render_dependencies, arguments, LAYOUT_DEPENDENCY)
+            add_dependencies(render_dependencies, arguments, RENDER_ARGUMENTS)
           end
 
           render_dependencies.uniq
         end
 
+        def add_dependencies(render_dependencies, arguments, pattern)
+          arguments.scan(pattern) do
+            add_dynamic_dependency(render_dependencies, Regexp.last_match[:dynamic])
+            add_static_dependency(render_dependencies, Regexp.last_match[:static])
+          end
+        end
+
         def add_dynamic_dependency(dependencies, dependency)
           if dependency
             dependencies << "#{dependency.pluralize}/#{dependency.singularize}"
@@ -131,8 +150,22 @@ module ActionView
           end
         end
 
+        def resolve_directories(wildcard_dependencies)
+          return [] unless @view_paths
+
+          wildcard_dependencies.flat_map { |query, templates|
+            @view_paths.find_all_with_query(query).map do |template|
+              "#{File.dirname(query)}/#{File.basename(template).split('.').first}"
+            end
+          }.sort
+        end
+
         def explicit_dependencies
-          source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
+          dependencies = source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
+
+          wildcards, explicits = dependencies.partition { |dependency| dependency[-1] == '*' }
+
+          (explicits + resolve_directories(wildcards)).uniq
         end
     end
 

data/lib/action_view/digestor.rb

@@ -1,123 +1,125 @@
-require 'thread_safe'
+require 'concurrent/map'
 require 'action_view/dependency_tracker'
 require 'monitor'
 
 module ActionView
   class Digestor
-    cattr_reader(:cache)
-    @@cache          = ThreadSafe::Cache.new
-    @@digest_monitor = Monitor.new
+    @@digest_mutex   = Mutex.new
+
+    module PerExecutionDigestCacheExpiry
+      def self.before(target)
+        ActionView::LookupContext::DetailsKey.clear
+      end
+    end
 
     class << self
       # Supported options:
       #
       # * <tt>name</tt>   - Template name
-      # * <tt>finder</tt>  - An instance of ActionView::LookupContext
+      # * <tt>finder</tt>  - An instance of <tt>ActionView::LookupContext</tt>
       # * <tt>dependencies</tt>  - An array of dependent views
       # * <tt>partial</tt>  - Specifies whether the template is a partial
-      def digest(options)
-        options.assert_valid_keys(:name, :finder, :dependencies, :partial)
-
-        cache_key = ([ options[:name], options[:finder].details_key.hash ].compact + Array.wrap(options[:dependencies])).join('.')
+      def digest(name:, finder:, dependencies: [])
+        dependencies ||= []
+        cache_key = [ name, finder.rendered_format, dependencies ].flatten.compact.join('.')
 
         # this is a correctly done double-checked locking idiom
-        # (ThreadSafe::Cache's lookups have volatile semantics)
-        @@cache[cache_key] || @@digest_monitor.synchronize do
-          @@cache.fetch(cache_key) do # re-check under lock
-            compute_and_store_digest(cache_key, options)
+        # (Concurrent::Map's lookups have volatile semantics)
+        finder.digest_cache[cache_key] || @@digest_mutex.synchronize do
+          finder.digest_cache.fetch(cache_key) do # re-check under lock
+            partial = name.include?("/_")
+            root = tree(name, finder, partial)
+            dependencies.each do |injected_dep|
+              root.children << Injected.new(injected_dep, nil, nil)
+            end
+            finder.digest_cache[cache_key] = root.digest(finder)
           end
         end
       end
 
-      private
-        def compute_and_store_digest(cache_key, options) # called under @@digest_monitor lock
-          klass = if options[:partial] || options[:name].include?("/_")
-            # Prevent re-entry or else recursive templates will blow the stack.
-            # There is no need to worry about other threads seeing the +false+ value,
-            # as they will then have to wait for this thread to let go of the @@digest_monitor lock.
-            pre_stored = @@cache.put_if_absent(cache_key, false).nil? # put_if_absent returns nil on insertion
-            PartialDigestor
-          else
-            Digestor
-          end
-
-          digest = klass.new(options).digest
-          # Store the actual digest if config.cache_template_loading is true
-          @@cache[cache_key] = stored_digest = digest if ActionView::Resolver.caching?
-          digest
-        ensure
-          # something went wrong or ActionView::Resolver.caching? is false, make sure not to corrupt the @@cache
-          @@cache.delete_pair(cache_key, false) if pre_stored && !stored_digest
-        end
-    end
+      def logger
+        ActionView::Base.logger || NullLogger
+      end
 
-    attr_reader :name, :finder, :options
+      # Create a dependency tree for template named +name+.
+      def tree(name, finder, partial = false, seen = {})
+        logical_name = name.gsub(%r|/_|, "/")
 
-    def initialize(options)
-      @name, @finder = options.values_at(:name, :finder)
-      @options = options.except(:name, :finder)
-    end
+        options = {}
+        options[:formats] = [finder.rendered_format] if finder.rendered_format
 
-    def digest
-      Digest::MD5.hexdigest("#{source}-#{dependency_digest}").tap do |digest|
-        logger.try :debug, "  Cache digest for #{template.inspect}: #{digest}"
-      end
-    rescue ActionView::MissingTemplate
-      logger.try :error, "  Couldn't find template for digesting: #{name}"
-      ''
-    end
+        if template = finder.disable_cache { finder.find_all(logical_name, [], partial, [], options).first }
+          finder.rendered_format ||= template.formats.first
 
-    def dependencies
-      DependencyTracker.find_dependencies(name, template)
-    rescue ActionView::MissingTemplate
-      logger.try :error, "  '#{name}' file doesn't exist, so no dependencies"
-      []
-    end
+          if node = seen[template.identifier] # handle cycles in the tree
+            node
+          else
+            node = seen[template.identifier] = Node.create(name, logical_name, template, partial)
 
-    def nested_dependencies
-      dependencies.collect do |dependency|
-        dependencies = PartialDigestor.new(name: dependency, finder: finder).nested_dependencies
-        dependencies.any? ? { dependency => dependencies } : dependency
+            deps = DependencyTracker.find_dependencies(name, template, finder.view_paths)
+            deps.uniq { |n| n.gsub(%r|/_|, "/") }.each do |dep_file|
+              node.children << tree(dep_file, finder, true, seen)
+            end
+            node
+          end
+        else
+          logger.error "  '#{name}' file doesn't exist, so no dependencies"
+          logger.error "  Couldn't find template for digesting: #{name}"
+          seen[name] ||= Missing.new(name, logical_name, nil)
+        end
       end
     end
 
-    private
-      def logger
-        ActionView::Base.logger
+    class Node
+      attr_reader :name, :logical_name, :template, :children
+
+      def self.create(name, logical_name, template, partial)
+        klass = partial ? Partial : Node
+        klass.new(name, logical_name, template, [])
       end
 
-      def logical_name
-        name.gsub(%r|/_|, "/")
+      def initialize(name, logical_name, template, children = [])
+        @name         = name
+        @logical_name = logical_name
+        @template     = template
+        @children     = children
       end
 
-      def partial?
-        false
+      def digest(finder, stack = [])
+        Digest::MD5.hexdigest("#{template.source}-#{dependency_digest(finder, stack)}")
       end
 
-      def template
-        @template ||= finder.disable_cache { finder.find(logical_name, [], partial?) }
+      def dependency_digest(finder, stack)
+        children.map do |node|
+          if stack.include?(node)
+            false
+          else
+            finder.digest_cache[node.name] ||= begin
+                                                 stack.push node
+                                                 node.digest(finder, stack).tap { stack.pop }
+                                               end
+          end
+        end.join("-")
       end
 
-      def source
-        template.source
+      def to_dep_map
+        children.any? ? { name => children.map(&:to_dep_map) } : name
       end
+    end
 
-      def dependency_digest
-        template_digests = dependencies.collect do |template_name|
-          Digestor.digest(name: template_name, finder: finder, partial: true)
-        end
+    class Partial < Node; end
 
-        (template_digests + injected_dependencies).join("-")
-      end
+    class Missing < Node
+      def digest(finder, _ = []) '' end
+    end
 
-      def injected_dependencies
-        Array.wrap(options[:dependencies])
-      end
-  end
+    class Injected < Node
+      def digest(finder, _ = []) name end
+    end
 
-  class PartialDigestor < Digestor # :nodoc:
-    def partial?
-      true
+    class NullLogger
+      def self.debug(_); end
+      def self.error(_); end
     end
   end
 end

data/lib/action_view/flows.rb

@@ -37,9 +37,8 @@ module ActionView
     end
 
     # Try to get stored content. If the content
-    # is not available and we are inside the layout
-    # fiber, we set that we are waiting for the given
-    # key and yield.
+    # is not available and we're inside the layout fiber,
+    # then it will begin waiting for the given key and yield.
     def get(key)
       return super if @content.key?(key)
 
@@ -60,8 +59,8 @@ module ActionView
     end
 
     # Appends the contents for the given key. This is called
-    # by provides and resumes back to the fiber if it is
-    # the key it is waiting for.
+    # by providing and resuming back to the fiber,
+    # if that's the key it's waiting for.
     def append!(key, value)
       super
       @fiber.resume if @waiting_for == key

data/lib/action_view/gem_version.rb

@@ -5,9 +5,9 @@ module ActionView
   end
 
   module VERSION
-    MAJOR = 4
-    MINOR = 2
-    TINY  = 11
+    MAJOR = 5
+    MINOR = 0
+    TINY  = 7
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/action_view/helpers/asset_tag_helper.rb

@@ -55,12 +55,12 @@ module ActionView
       #   # => <script src="http://www.example.com/xmlhr.js"></script>
       def javascript_include_tag(*sources)
         options = sources.extract_options!.stringify_keys
-        path_options = options.extract!('protocol', 'extname').symbolize_keys
+        path_options = options.extract!('protocol', 'extname', 'host').symbolize_keys
         sources.uniq.map { |source|
           tag_options = {
             "src" => path_to_javascript(source, path_options)
           }.merge!(options)
-          content_tag(:script, "", tag_options)
+          content_tag("script".freeze, "", tag_options)
         }.join("\n").html_safe
       end
 
@@ -91,7 +91,7 @@ module ActionView
       #   #    <link href="/css/stylish.css" media="screen" rel="stylesheet" />
       def stylesheet_link_tag(*sources)
         options = sources.extract_options!.stringify_keys
-        path_options = options.extract!('protocol').symbolize_keys
+        path_options = options.extract!('protocol', 'host').symbolize_keys
 
         sources.uniq.map { |source|
           tag_options = {
@@ -136,7 +136,7 @@ module ActionView
         tag(
           "link",
           "rel"   => tag_options[:rel] || "alternate",
-          "type"  => tag_options[:type] || Mime::Type.lookup_by_extension(type.to_s).to_s,
+          "type"  => tag_options[:type] || Template::Types[type].to_s,
           "title" => tag_options[:title] || type.to_s.upcase,
           "href"  => url_options.is_a?(Hash) ? url_for(url_options.merge(:only_path => false)) : url_options
         )
@@ -205,8 +205,11 @@ module ActionView
       #   # => <img alt="Icon" height="32" src="/icons/icon.gif" width="32" />
       #   image_tag("/icons/icon.gif", class: "menu_icon")
       #   # => <img alt="Icon" class="menu_icon" src="/icons/icon.gif" />
+      #   image_tag("/icons/icon.gif", data: { title: 'Rails Application' })
+      #   # => <img data-title="Rails Application" src="/icons/icon.gif" />
       def image_tag(source, options={})
         options = options.symbolize_keys
+        check_for_image_tag_errors(options)
 
         src = options[:src] = path_to_image(source)
 
@@ -236,7 +239,7 @@ module ActionView
       #   image_alt('underscored_file_name.png')
       #   # => Underscored file name
       def image_alt(src)
-        File.basename(src, '.*').sub(/-[[:xdigit:]]{32,64}\z/, '').tr('-_', ' ').capitalize
+        File.basename(src, '.*'.freeze).sub(/-[[:xdigit:]]{32,64}\z/, ''.freeze).tr('-_'.freeze, ' '.freeze).capitalize
       end
 
       # Returns an HTML video tag for the +sources+. If +sources+ is a string,
@@ -318,12 +321,19 @@ module ActionView
         end
 
         def extract_dimensions(size)
+          size = size.to_s
           if size =~ %r{\A\d+x\d+\z}
             size.split('x')
           elsif size =~ %r{\A\d+\z}
             [size, size]
           end
         end
+
+        def check_for_image_tag_errors(options)
+          if options[:size] && (options[:height] || options[:width])
+            raise ArgumentError, "Cannot pass a :size option with a :height or :width option"
+          end
+        end
     end
   end
 end