actionview 4.2.10 → 5.1.0

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 initialize(name, template)
-        @name, @template = name, template
+      def self.call(name, template, view_paths = nil)
+        new(name, template, view_paths).dependencies
+      end
+
+      def initialize(name, template, view_paths = nil)
+        @name, @template, @view_paths = name, template, view_paths
       end
 
       def dependencies
@@ -91,7 +105,6 @@ module ActionView
       attr_reader :name, :template
       private :name, :template
 
-
       private
         def source
           template.source
@@ -106,15 +119,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}"
@@ -123,7 +141,7 @@ module ActionView
 
         def add_static_dependency(dependencies, dependency)
           if dependency
-            if dependency.include?('/')
+            if dependency.include?("/")
               dependencies << dependency
             else
               dependencies << "#{directory}/#{dependency}"
@@ -131,8 +149,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,126 @@
-require 'thread_safe'
-require 'action_view/dependency_tracker'
-require 'monitor'
+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
+      def logger
+        ActionView::Base.logger || NullLogger
+      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
+      # Create a dependency tree for template named +name+.
+      def tree(name, finder, partial = false, seen = {})
+        logical_name = name.gsub(%r|/_|, "/")
 
-    attr_reader :name, :finder, :options
+        options = {}
+        options[:formats] = [finder.rendered_format] if finder.rendered_format
 
-    def initialize(options)
-      @name, @finder = options.values_at(:name, :finder)
-      @options = options.except(:name, :finder)
-    end
+        if template = finder.disable_cache { finder.find_all(logical_name, [], partial, [], options).first }
+          finder.rendered_format ||= template.formats.first
 
-    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 node = seen[template.identifier] # handle cycles in the tree
+            node
+          else
+            node = seen[template.identifier] = Node.create(name, logical_name, template, partial)
 
-    def dependencies
-      DependencyTracker.find_dependencies(name, template)
-    rescue ActionView::MissingTemplate
-      logger.try :error, "  '#{name}' file doesn't exist, so no dependencies"
-      []
-    end
+            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
+          unless name.include?("#") # Dynamic template partial names can never be tracked
+            logger.error "  Couldn't find template for digesting: #{name}"
+          end
 
-    def nested_dependencies
-      dependencies.collect do |dependency|
-        dependencies = PartialDigestor.new(name: dependency, finder: finder).nested_dependencies
-        dependencies.any? ? { dependency => dependencies } : dependency
+          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

@@ -1,11 +1,11 @@
-require 'active_support/core_ext/string/output_safety'
+require "active_support/core_ext/string/output_safety"
 
 module ActionView
   class OutputFlow #:nodoc:
     attr_reader :content
 
     def initialize
-      @content = Hash.new { |h,k| h[k] = ActiveSupport::SafeBuffer.new }
+      @content = Hash.new { |h, k| h[k] = ActiveSupport::SafeBuffer.new }
     end
 
     # Called by _layout_for to read stored values.
@@ -23,7 +23,6 @@ module ActionView
       @content[key] << value
     end
     alias_method :append!, :append
-
   end
 
   class StreamingFlow < OutputFlow #:nodoc:
@@ -37,9 +36,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 +58,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
@@ -69,8 +67,8 @@ module ActionView
 
     private
 
-    def inside_fiber?
-      Fiber.current.object_id != @root
-    end
+      def inside_fiber?
+        Fiber.current.object_id != @root
+      end
   end
 end

data/lib/action_view/gem_version.rb

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

data/lib/action_view/helpers/active_model_helper.rb

@@ -1,5 +1,5 @@
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/enumerable'
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/enumerable"
 
 module ActionView
   # = Active Model Helpers
@@ -37,13 +37,13 @@ module ActionView
 
       private
 
-      def object_has_errors?
-        object.respond_to?(:errors) && object.errors.respond_to?(:[]) && error_message.present?
-      end
+        def object_has_errors?
+          object.respond_to?(:errors) && object.errors.respond_to?(:[]) && error_message.present?
+        end
 
-      def tag_generate_errors?(options)
-        options['type'] != 'hidden'
-      end
+        def tag_generate_errors?(options)
+          options["type"] != "hidden"
+        end
     end
   end
 end

data/lib/action_view/helpers/asset_tag_helper.rb

@@ -1,7 +1,7 @@
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/hash/keys'
-require 'action_view/helpers/asset_url_helper'
-require 'action_view/helpers/tag_helper'
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/hash/keys"
+require "action_view/helpers/asset_url_helper"
+require "action_view/helpers/tag_helper"
 
 module ActionView
   # = Action View Asset Tag Helpers
@@ -35,18 +35,37 @@ module ActionView
       # When the Asset Pipeline is enabled, you can pass the name of your manifest as
       # source, and include other JavaScript or CoffeeScript files inside the manifest.
       #
+      # ==== Options
+      #
+      # When the last parameter is a hash you can add HTML attributes using that
+      # parameter. The following options are supported:
+      #
+      # * <tt>:extname</tt>  - Append an extension to the generated url unless the extension
+      #   already exists. This only applies for relative urls.
+      # * <tt>:protocol</tt>  - Sets the protocol of the generated url, this option only
+      #   applies when a relative url and +host+ options are provided.
+      # * <tt>:host</tt>  - When a relative url is provided the host is added to the
+      #   that path.
+      # * <tt>:skip_pipeline</tt>  - This option is used to bypass the asset pipeline
+      #   when it is set to true.
+      #
+      # ==== Examples
+      #
       #   javascript_include_tag "xmlhr"
-      #   # => <script src="/assets/xmlhr.js?1284139606"></script>
+      #   # => <script src="/assets/xmlhr.debug-1284139606.js"></script>
+      #
+      #   javascript_include_tag "xmlhr", host: "localhost", protocol: "https"
+      #   # => <script src="https://localhost/assets/xmlhr.debug-1284139606.js"></script>
       #
       #   javascript_include_tag "template.jst", extname: false
-      #   # => <script src="/assets/template.jst?1284139606"></script>
+      #   # => <script src="/assets/template.debug-1284139606.jst"></script>
       #
       #   javascript_include_tag "xmlhr.js"
-      #   # => <script src="/assets/xmlhr.js?1284139606"></script>
+      #   # => <script src="/assets/xmlhr.debug-1284139606.js"></script>
       #
       #   javascript_include_tag "common.javascript", "/elsewhere/cools"
-      #   # => <script src="/assets/common.javascript?1284139606"></script>
-      #   #    <script src="/elsewhere/cools.js?1423139606"></script>
+      #   # => <script src="/assets/common.javascript.debug-1284139606.js"></script>
+      #   #    <script src="/elsewhere/cools.debug-1284139606.js"></script>
       #
       #   javascript_include_tag "http://www.example.com/xmlhr"
       #   # => <script src="http://www.example.com/xmlhr"></script>
@@ -55,12 +74,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", "skip_pipeline").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,8 +110,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", "skip_pipeline").symbolize_keys
         sources.uniq.map { |source|
           tag_options = {
             "rel" => "stylesheet",
@@ -136,9 +154,9 @@ 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
+          "href"  => url_options.is_a?(Hash) ? url_for(url_options.merge(only_path: false)) : url_options
         )
       end
 
@@ -169,11 +187,11 @@ module ActionView
       #
       #   favicon_link_tag 'mb-icon.png', rel: 'apple-touch-icon', type: 'image/png'
       #   # => <link href="/assets/mb-icon.png" rel="apple-touch-icon" type="image/png" />
-      def favicon_link_tag(source='favicon.ico', options={})
-        tag('link', {
-          :rel  => 'shortcut icon',
-          :type => 'image/x-icon',
-          :href => path_to_image(source)
+      def favicon_link_tag(source = "favicon.ico", options = {})
+        tag("link", {
+          rel: "shortcut icon",
+          type: "image/x-icon",
+          href: path_to_image(source, skip_pipeline: options.delete(:skip_pipeline))
         }.merge!(options.symbolize_keys))
       end
 
@@ -205,13 +223,16 @@ 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" />
-      def image_tag(source, options={})
+      #   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)
+        src = options[:src] = path_to_image(source, skip_pipeline: options.delete(:skip_pipeline))
 
-        unless src =~ /^(?:cid|data):/ || src.blank?
-          options[:alt] = options.fetch(:alt){ image_alt(src) }
+        unless src.start_with?("cid:") || src.start_with?("data:") || src.blank?
+          options[:alt] = options.fetch(:alt) { image_alt(src) }
         end
 
         options[:width], options[:height] = extract_dimensions(options.delete(:size)) if options[:size]
@@ -236,7 +257,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,
@@ -254,6 +275,8 @@ module ActionView
       # * <tt>:size</tt> - Supplied as "{Width}x{Height}" or "{Number}", so "30x45" becomes
       #   width="30" and height="45", and "50" becomes width="50" and height="50".
       #   <tt>:size</tt> will be ignored if the value is not in the correct format.
+      # * <tt>:poster_skip_pipeline</tt> will bypass the asset pipeline when using
+      #   the <tt>:poster</tt> option instead using an asset in the public folder.
       #
       # ==== Examples
       #
@@ -261,10 +284,12 @@ module ActionView
       #   # => <video src="/videos/trailer"></video>
       #   video_tag("trailer.ogg")
       #   # => <video src="/videos/trailer.ogg"></video>
-      #   video_tag("trailer.ogg", controls: true, autobuffer: true)
-      #   # => <video autobuffer="autobuffer" controls="controls" src="/videos/trailer.ogg" ></video>
+      #   video_tag("trailer.ogg", controls: true, preload: 'none')
+      #   # => <video preload="none" controls="controls" src="/videos/trailer.ogg" ></video>
       #   video_tag("trailer.m4v", size: "16x10", poster: "screenshot.png")
       #   # => <video src="/videos/trailer.m4v" width="16" height="10" poster="/assets/screenshot.png"></video>
+      #   video_tag("trailer.m4v", size: "16x10", poster: "screenshot.png", poster_skip_pipeline: true)
+      #   # => <video src="/videos/trailer.m4v" width="16" height="10" poster="screenshot.png"></video>
       #   video_tag("/trailers/hd.avi", size: "16x16")
       #   # => <video src="/trailers/hd.avi" width="16" height="16"></video>
       #   video_tag("/trailers/hd.avi", size: "16")
@@ -278,9 +303,12 @@ module ActionView
       #   video_tag(["trailer.ogg", "trailer.flv"], size: "160x120")
       #   # => <video height="120" width="160"><source src="/videos/trailer.ogg" /><source src="/videos/trailer.flv" /></video>
       def video_tag(*sources)
-        multiple_sources_tag('video', sources) do |options|
-          options[:poster] = path_to_image(options[:poster]) if options[:poster]
-          options[:width], options[:height] = extract_dimensions(options.delete(:size)) if options[:size]
+        options = sources.extract_options!.symbolize_keys
+        public_poster_folder = options.delete(:poster_skip_pipeline)
+        sources << options
+        multiple_sources_tag_builder("video", sources) do |tag_options|
+          tag_options[:poster] = path_to_image(tag_options[:poster], skip_pipeline: public_poster_folder) if tag_options[:poster]
+          tag_options[:width], tag_options[:height] = extract_dimensions(tag_options.delete(:size)) if tag_options[:size]
         end
       end
 
@@ -297,33 +325,41 @@ module ActionView
       #   audio_tag("sound.wav", "sound.mid")
       #   # => <audio><source src="/audios/sound.wav" /><source src="/audios/sound.mid" /></audio>
       def audio_tag(*sources)
-        multiple_sources_tag('audio', sources)
+        multiple_sources_tag_builder("audio", sources)
       end
 
       private
-        def multiple_sources_tag(type, sources)
-          options = sources.extract_options!.symbolize_keys
+        def multiple_sources_tag_builder(type, sources)
+          options       = sources.extract_options!.symbolize_keys
+          skip_pipeline = options.delete(:skip_pipeline)
           sources.flatten!
 
           yield options if block_given?
 
           if sources.size > 1
             content_tag(type, options) do
-              safe_join sources.map { |source| tag("source", :src => send("path_to_#{type}", source)) }
+              safe_join sources.map { |source| tag("source", src: send("path_to_#{type}", source, skip_pipeline: skip_pipeline)) }
             end
           else
-            options[:src] = send("path_to_#{type}", sources.first)
+            options[:src] = send("path_to_#{type}", sources.first, skip_pipeline: skip_pipeline)
             content_tag(type, nil, options)
           end
         end
 
         def extract_dimensions(size)
-          if size =~ %r{\A\d+x\d+\z}
-            size.split('x')
-          elsif size =~ %r{\A\d+\z}
+          size = size.to_s
+          if /\A\d+x\d+\z/.match?(size)
+            size.split("x")
+          elsif /\A\d+\z/.match?(size)
             [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