actionview 4.2.11.3 → 5.2.7.1

data/lib/action_view/helpers/asset_url_helper.rb

@@ -1,10 +1,12 @@
-require 'zlib'
+# frozen_string_literal: true
+
+require "zlib"
 
 module ActionView
   # = Action View Asset URL Helpers
-  module Helpers
+  module Helpers #:nodoc:
     # This module provides methods for generating asset paths and
-    # urls.
+    # URLs.
     #
     #   image_path("rails.png")
     #   # => "/assets/rails.png"
@@ -27,30 +29,37 @@ module ActionView
     # Helpers take that into account:
     #
     #   image_tag("rails.png")
-    #   # => <img alt="Rails" src="http://assets.example.com/assets/rails.png" />
+    #   # => <img src="http://assets.example.com/assets/rails.png" />
     #   stylesheet_link_tag("application")
     #   # => <link href="http://assets.example.com/assets/application.css" media="screen" rel="stylesheet" />
     #
-    # Browsers typically open at most two simultaneous connections to a single
-    # host, which means your assets often have to wait for other assets to finish
-    # downloading. You can alleviate this by using a <tt>%d</tt> wildcard in the
-    # +asset_host+. For example, "assets%d.example.com". If that wildcard is
-    # present Rails distributes asset requests among the corresponding four hosts
-    # "assets0.example.com", ..., "assets3.example.com". With this trick browsers
-    # will open eight simultaneous connections rather than two.
+    # Browsers open a limited number of simultaneous connections to a single
+    # host. The exact number varies by browser and version. This limit may cause
+    # some asset downloads to wait for previous assets to finish before they can
+    # begin. You can use the <tt>%d</tt> wildcard in the +asset_host+ to
+    # distribute the requests over four hosts. For example,
+    # <tt>assets%d.example.com</tt> will spread the asset requests over
+    # "assets0.example.com", ..., "assets3.example.com".
     #
     #   image_tag("rails.png")
-    #   # => <img alt="Rails" src="http://assets0.example.com/assets/rails.png" />
+    #   # => <img src="http://assets0.example.com/assets/rails.png" />
     #   stylesheet_link_tag("application")
     #   # => <link href="http://assets2.example.com/assets/application.css" media="screen" rel="stylesheet" />
     #
-    # To do this, you can either setup four actual hosts, or you can use wildcard
-    # DNS to CNAME the wildcard to a single asset host. You can read more about
-    # setting up your DNS CNAME records from your ISP.
+    # This may improve the asset loading performance of your application.
+    # It is also possible the combination of additional connection overhead
+    # (DNS, SSL) and the overall browser connection limits may result in this
+    # solution being slower. You should be sure to measure your actual
+    # performance across targeted browsers both before and after this change.
+    #
+    # To implement the corresponding hosts you can either setup four actual
+    # hosts or use wildcard DNS to CNAME the wildcard to a single asset host.
+    # You can read more about setting up your DNS CNAME records from your ISP.
     #
     # Note: This is purely a browser performance optimization and is not meant
-    # for server load balancing. See http://www.die.net/musings/page_load_time/
-    # for background.
+    # for server load balancing. See https://www.die.net/musings/page_load_time/
+    # for background and https://www.browserscope.org/?category=network for
+    # connection limit data.
     #
     # Alternatively, you can exert more control over the asset host by setting
     # +asset_host+ to a proc like this:
@@ -59,7 +68,7 @@ module ActionView
     #     "http://assets#{Digest::MD5.hexdigest(source).to_i(16) % 2 + 1}.example.com"
     #   }
     #   image_tag("rails.png")
-    #   # => <img alt="Rails" src="http://assets1.example.com/assets/rails.png" />
+    #   # => <img src="http://assets1.example.com/assets/rails.png" />
     #   stylesheet_link_tag("application")
     #   # => <link href="http://assets2.example.com/assets/application.css" media="screen" rel="stylesheet" />
     #
@@ -78,7 +87,7 @@ module ActionView
     #      end
     #    }
     #   image_tag("rails.png")
-    #   # => <img alt="Rails" src="http://assets.example.com/assets/rails.png" />
+    #   # => <img src="http://assets.example.com/assets/rails.png" />
     #   stylesheet_link_tag("application")
     #   # => <link href="http://stylesheets.example.com/assets/application.css" media="screen" rel="stylesheet" />
     #
@@ -88,9 +97,9 @@ module ActionView
     # still sending assets for plain HTTP requests from asset hosts. If you don't
     # have SSL certificates for each of the asset hosts this technique allows you
     # to avoid warnings in the client about mixed media.
-    # Note that the request parameter might not be supplied, e.g. when the assets
-    # are precompiled via a Rake task. Make sure to use a Proc instead of a lambda,
-    # since a Proc allows missing parameters and sets them to nil.
+    # Note that the +request+ parameter might not be supplied, e.g. when the assets
+    # are precompiled via a Rake task. Make sure to use a +Proc+ instead of a lambda,
+    # since a +Proc+ allows missing parameters and sets them to +nil+.
     #
     #   config.action_controller.asset_host = Proc.new { |source, request|
     #     if request && request.ssl?
@@ -110,29 +119,86 @@ module ActionView
     module AssetUrlHelper
       URI_REGEXP = %r{^[-a-z]+://|^(?:cid|data):|^//}i
 
-      # Computes the path to asset in public directory. If :type
-      # options is set, a file extension will be appended and scoped
-      # to the corresponding public directory.
+      # This is the entry point for all assets.
+      # When using the asset pipeline (i.e. sprockets and sprockets-rails), the
+      # behavior is "enhanced". You can bypass the asset pipeline by passing in
+      # <tt>skip_pipeline: true</tt> to the options.
       #
       # All other asset *_path helpers delegate through this method.
       #
-      #   asset_path "application.js"                     # => /assets/application.js
-      #   asset_path "application", type: :javascript     # => /assets/application.js
-      #   asset_path "application", type: :stylesheet     # => /assets/application.css
-      #   asset_path "http://www.example.com/js/xmlhr.js" # => http://www.example.com/js/xmlhr.js
+      # === With the asset pipeline
+      #
+      # All options passed to +asset_path+ will be passed to +compute_asset_path+
+      # which is implemented by sprockets-rails.
+      #
+      #   asset_path("application.js") # => "/assets/application-60aa4fdc5cea14baf5400fba1abf4f2a46a5166bad4772b1effe341570f07de9.js"
+      #
+      # === Without the asset pipeline (<tt>skip_pipeline: true</tt>)
+      #
+      # Accepts a <tt>type</tt> option that can specify the asset's extension. No error
+      # checking is done to verify the source passed into +asset_path+ is valid
+      # and that the file exists on disk.
+      #
+      #   asset_path("application.js", skip_pipeline: true)                 # => "application.js"
+      #   asset_path("filedoesnotexist.png", skip_pipeline: true)           # => "filedoesnotexist.png"
+      #   asset_path("application", type: :javascript, skip_pipeline: true) # => "/javascripts/application.js"
+      #   asset_path("application", type: :stylesheet, skip_pipeline: true) # => "/stylesheets/application.css"
+      #
+      # === Options applying to all assets
+      #
+      # Below lists scenarios that apply to +asset_path+ whether or not you're
+      # using the asset pipeline.
+      #
+      # - All fully qualified URLs are returned immediately. This bypasses the
+      #   asset pipeline and all other behavior described.
+      #
+      #     asset_path("http://www.example.com/js/xmlhr.js") # => "http://www.example.com/js/xmlhr.js"
+      #
+      # - All assets that begin with a forward slash are assumed to be full
+      #   URLs and will not be expanded. This will bypass the asset pipeline.
+      #
+      #     asset_path("/foo.png") # => "/foo.png"
+      #
+      # - All blank strings will be returned immediately. This bypasses the
+      #   asset pipeline and all other behavior described.
+      #
+      #     asset_path("") # => ""
+      #
+      # - If <tt>config.relative_url_root</tt> is specified, all assets will have that
+      #   root prepended.
+      #
+      #     Rails.application.config.relative_url_root = "bar"
+      #     asset_path("foo.js", skip_pipeline: true) # => "bar/foo.js"
+      #
+      # - A different asset host can be specified via <tt>config.action_controller.asset_host</tt>
+      #   this is commonly used in conjunction with a CDN.
+      #
+      #     Rails.application.config.action_controller.asset_host = "assets.example.com"
+      #     asset_path("foo.js", skip_pipeline: true) # => "http://assets.example.com/foo.js"
+      #
+      # - An extension name can be specified manually with <tt>extname</tt>.
+      #
+      #     asset_path("foo", skip_pipeline: true, extname: ".js")     # => "/foo.js"
+      #     asset_path("foo.css", skip_pipeline: true, extname: ".js") # => "/foo.css.js"
       def asset_path(source, options = {})
+        raise ArgumentError, "nil is not a valid asset source" if source.nil?
+
         source = source.to_s
-        return "" unless source.present?
-        return source if source =~ URI_REGEXP
+        return "" if source.blank?
+        return source if URI_REGEXP.match?(source)
 
-        tail, source = source[/([\?#].+)$/], source.sub(/([\?#].+)$/, '')
+        tail, source = source[/([\?#].+)$/], source.sub(/([\?#].+)$/, "".freeze)
 
         if extname = compute_asset_extname(source, options)
           source = "#{source}#{extname}"
         end
 
         if source[0] != ?/
-          source = compute_asset_path(source, options)
+          if options[:skip_pipeline]
+            source = public_compute_asset_path(source, options)
+          else
+            source = compute_asset_path(source, options)
+          end
         end
 
         relative_url_root = defined?(config.relative_url_root) && config.relative_url_root
@@ -159,31 +225,35 @@ module ActionView
       #   asset_url "application.js", host: "http://cdn.example.com" # => http://cdn.example.com/assets/application.js
       #
       def asset_url(source, options = {})
-        path_to_asset(source, options.merge(:protocol => :request))
+        path_to_asset(source, options.merge(protocol: :request))
       end
       alias_method :url_to_asset, :asset_url # aliased to avoid conflicts with an asset_url named route
 
       ASSET_EXTENSIONS = {
-        javascript: '.js',
-        stylesheet: '.css'
+        javascript: ".js",
+        stylesheet: ".css"
       }
 
-      # Compute extname to append to asset path. Returns nil if
+      # Compute extname to append to asset path. Returns +nil+ if
       # nothing should be added.
       def compute_asset_extname(source, options = {})
         return if options[:extname] == false
         extname = options[:extname] || ASSET_EXTENSIONS[options[:type]]
-        extname if extname && File.extname(source) != extname
+        if extname && File.extname(source) != extname
+          extname
+        else
+          nil
+        end
       end
 
       # Maps asset types to public directory.
       ASSET_PUBLIC_DIRECTORIES = {
-        audio:      '/audios',
-        font:       '/fonts',
-        image:      '/images',
-        javascript: '/javascripts',
-        stylesheet: '/stylesheets',
-        video:      '/videos'
+        audio:      "/audios",
+        font:       "/fonts",
+        image:      "/images",
+        javascript: "/javascripts",
+        stylesheet: "/stylesheets",
+        video:      "/videos"
       }
 
       # Computes asset path to public directory. Plugins and
@@ -193,6 +263,7 @@ module ActionView
         dir = ASSET_PUBLIC_DIRECTORIES[options[:type]] || ""
         File.join(dir, source)
       end
+      alias :public_compute_asset_path :compute_asset_path
 
       # Pick an asset host for this source. Returns +nil+ if no host is set,
       # the host if no wildcard is set, the host interpolated with the
@@ -204,19 +275,21 @@ module ActionView
         host = options[:host]
         host ||= config.asset_host if defined? config.asset_host
 
-        if host.respond_to?(:call)
-          arity = host.respond_to?(:arity) ? host.arity : host.method(:call).arity
-          args = [source]
-          args << request if request && (arity > 1 || arity < 0)
-          host = host.call(*args)
-        elsif host =~ /%d/
-          host = host % (Zlib.crc32(source) % 4)
+        if host
+          if host.respond_to?(:call)
+            arity = host.respond_to?(:arity) ? host.arity : host.method(:call).arity
+            args = [source]
+            args << request if request && (arity > 1 || arity < 0)
+            host = host.call(*args)
+          elsif host.include?("%d")
+            host = host % (Zlib.crc32(source) % 4)
+          end
         end
 
         host ||= request.base_url if request && options[:protocol] == :request
         return unless host
 
-        if host =~ URI_REGEXP
+        if URI_REGEXP.match?(host)
           host
         else
           protocol = options[:protocol] || config.default_asset_host_protocol || (request ? :request : :relative)
@@ -242,14 +315,19 @@ module ActionView
       #   javascript_path "http://www.example.com/js/xmlhr"    # => http://www.example.com/js/xmlhr
       #   javascript_path "http://www.example.com/js/xmlhr.js" # => http://www.example.com/js/xmlhr.js
       def javascript_path(source, options = {})
-        path_to_asset(source, {type: :javascript}.merge!(options))
+        path_to_asset(source, { type: :javascript }.merge!(options))
       end
       alias_method :path_to_javascript, :javascript_path # aliased to avoid conflicts with a javascript_path named route
 
       # Computes the full URL to a JavaScript asset in the public javascripts directory.
       # This will use +javascript_path+ internally, so most of their behaviors will be the same.
+      # Since +javascript_url+ is based on +asset_url+ method you can set :host options. If :host
+      # options is set, it overwrites global +config.action_controller.asset_host+ setting.
+      #
+      #   javascript_url "js/xmlhr.js", host: "http://stage.example.com" # => http://stage.example.com/assets/js/xmlhr.js
+      #
       def javascript_url(source, options = {})
-        url_to_asset(source, {type: :javascript}.merge!(options))
+        url_to_asset(source, { type: :javascript }.merge!(options))
       end
       alias_method :url_to_javascript, :javascript_url # aliased to avoid conflicts with a javascript_url named route
 
@@ -264,14 +342,19 @@ module ActionView
       #   stylesheet_path "http://www.example.com/css/style"       # => http://www.example.com/css/style
       #   stylesheet_path "http://www.example.com/css/style.css"   # => http://www.example.com/css/style.css
       def stylesheet_path(source, options = {})
-        path_to_asset(source, {type: :stylesheet}.merge!(options))
+        path_to_asset(source, { type: :stylesheet }.merge!(options))
       end
       alias_method :path_to_stylesheet, :stylesheet_path # aliased to avoid conflicts with a stylesheet_path named route
 
       # Computes the full URL to a stylesheet asset in the public stylesheets directory.
       # This will use +stylesheet_path+ internally, so most of their behaviors will be the same.
+      # Since +stylesheet_url+ is based on +asset_url+ method you can set :host options. If :host
+      # options is set, it overwrites global +config.action_controller.asset_host+ setting.
+      #
+      #   stylesheet_url "css/style.css", host: "http://stage.example.com" # => http://stage.example.com/assets/css/style.css
+      #
       def stylesheet_url(source, options = {})
-        url_to_asset(source, {type: :stylesheet}.merge!(options))
+        url_to_asset(source, { type: :stylesheet }.merge!(options))
       end
       alias_method :url_to_stylesheet, :stylesheet_url # aliased to avoid conflicts with a stylesheet_url named route
 
@@ -289,14 +372,19 @@ module ActionView
       # The alias +path_to_image+ is provided to avoid that. Rails uses the alias internally, and
       # plugin authors are encouraged to do so.
       def image_path(source, options = {})
-        path_to_asset(source, {type: :image}.merge!(options))
+        path_to_asset(source, { type: :image }.merge!(options))
       end
       alias_method :path_to_image, :image_path # aliased to avoid conflicts with an image_path named route
 
       # Computes the full URL to an image asset.
       # This will use +image_path+ internally, so most of their behaviors will be the same.
+      # Since +image_url+ is based on +asset_url+ method you can set :host options. If :host
+      # options is set, it overwrites global +config.action_controller.asset_host+ setting.
+      #
+      #   image_url "edit.png", host: "http://stage.example.com" # => http://stage.example.com/assets/edit.png
+      #
       def image_url(source, options = {})
-        url_to_asset(source, {type: :image}.merge!(options))
+        url_to_asset(source, { type: :image }.merge!(options))
       end
       alias_method :url_to_image, :image_url # aliased to avoid conflicts with an image_url named route
 
@@ -310,16 +398,21 @@ module ActionView
       #   video_path("/trailers/hd.avi")                              # => /trailers/hd.avi
       #   video_path("http://www.example.com/vid/hd.avi")             # => http://www.example.com/vid/hd.avi
       def video_path(source, options = {})
-        path_to_asset(source, {type: :video}.merge!(options))
+        path_to_asset(source, { type: :video }.merge!(options))
       end
       alias_method :path_to_video, :video_path # aliased to avoid conflicts with a video_path named route
 
       # Computes the full URL to a video asset in the public videos directory.
       # This will use +video_path+ internally, so most of their behaviors will be the same.
+      # Since +video_url+ is based on +asset_url+ method you can set :host options. If :host
+      # options is set, it overwrites global +config.action_controller.asset_host+ setting.
+      #
+      #   video_url "hd.avi", host: "http://stage.example.com" # => http://stage.example.com/videos/hd.avi
+      #
       def video_url(source, options = {})
-        url_to_asset(source, {type: :video}.merge!(options))
+        url_to_asset(source, { type: :video }.merge!(options))
       end
-      alias_method :url_to_video, :video_url # aliased to avoid conflicts with an video_url named route
+      alias_method :url_to_video, :video_url # aliased to avoid conflicts with a video_url named route
 
       # Computes the path to an audio asset in the public audios directory.
       # Full paths from the document root will be passed through.
@@ -331,14 +424,19 @@ module ActionView
       #   audio_path("/sounds/horse.wav")                                # => /sounds/horse.wav
       #   audio_path("http://www.example.com/sounds/horse.wav")          # => http://www.example.com/sounds/horse.wav
       def audio_path(source, options = {})
-        path_to_asset(source, {type: :audio}.merge!(options))
+        path_to_asset(source, { type: :audio }.merge!(options))
       end
       alias_method :path_to_audio, :audio_path # aliased to avoid conflicts with an audio_path named route
 
       # Computes the full URL to an audio asset in the public audios directory.
       # This will use +audio_path+ internally, so most of their behaviors will be the same.
+      # Since +audio_url+ is based on +asset_url+ method you can set :host options. If :host
+      # options is set, it overwrites global +config.action_controller.asset_host+ setting.
+      #
+      #   audio_url "horse.wav", host: "http://stage.example.com" # => http://stage.example.com/audios/horse.wav
+      #
       def audio_url(source, options = {})
-        url_to_asset(source, {type: :audio}.merge!(options))
+        url_to_asset(source, { type: :audio }.merge!(options))
       end
       alias_method :url_to_audio, :audio_url # aliased to avoid conflicts with an audio_url named route
 
@@ -351,16 +449,21 @@ module ActionView
       #   font_path("/dir/font.ttf")                                  # => /dir/font.ttf
       #   font_path("http://www.example.com/dir/font.ttf")            # => http://www.example.com/dir/font.ttf
       def font_path(source, options = {})
-        path_to_asset(source, {type: :font}.merge!(options))
+        path_to_asset(source, { type: :font }.merge!(options))
       end
-      alias_method :path_to_font, :font_path # aliased to avoid conflicts with an font_path named route
+      alias_method :path_to_font, :font_path # aliased to avoid conflicts with a font_path named route
 
       # Computes the full URL to a font asset.
       # This will use +font_path+ internally, so most of their behaviors will be the same.
+      # Since +font_url+ is based on +asset_url+ method you can set :host options. If :host
+      # options is set, it overwrites global +config.action_controller.asset_host+ setting.
+      #
+      #   font_url "font.ttf", host: "http://stage.example.com" # => http://stage.example.com/fonts/font.ttf
+      #
       def font_url(source, options = {})
-        url_to_asset(source, {type: :font}.merge!(options))
+        url_to_asset(source, { type: :font }.merge!(options))
       end
-      alias_method :url_to_font, :font_url # aliased to avoid conflicts with an font_url named route
+      alias_method :url_to_font, :font_url # aliased to avoid conflicts with a font_url named route
     end
   end
 end

data/lib/action_view/helpers/atom_feed_helper.rb

@@ -1,8 +1,10 @@
-require 'set'
+# frozen_string_literal: true
+
+require "set"
 
 module ActionView
   # = Action View Atom Feed Helpers
-  module Helpers
+  module Helpers #:nodoc:
     module AtomFeedHelper
       # Adds easy defaults to writing Atom feeds with the Builder template engine (this does not work on ERB or any other
       # template languages).
@@ -16,7 +18,7 @@ module ActionView
       #     end
       #
       #   app/controllers/posts_controller.rb:
-      #     class PostsController < ApplicationController::Base
+      #     class PostsController < ApplicationController
       #       # GET /posts.html
       #       # GET /posts.atom
       #       def index
@@ -51,7 +53,7 @@ module ActionView
       # * <tt>:language</tt>: Defaults to "en-US".
       # * <tt>:root_url</tt>: The HTML alternative that this feed is doubling for. Defaults to / on the current host.
       # * <tt>:url</tt>: The URL for this feed. Defaults to the current URL.
-      # * <tt>:id</tt>: The id for this feed. Defaults to "tag:#{request.host},#{options[:schema_date]}:#{request.fullpath.split(".")[0]}"
+      # * <tt>:id</tt>: The id for this feed. Defaults to "tag:localhost,2005:/posts", in this case.
       # * <tt>:schema_date</tt>: The date at which the tag scheme for the feed was first used. A good default is the year you
       #   created the feed. See http://feedvalidator.org/docs/error/InvalidTAG.html for more information. If not specified,
       #   2005 is used (as an "I don't care" value).
@@ -103,7 +105,7 @@ module ActionView
         xml = options.delete(:xml) || eval("xml", block.binding)
         xml.instruct!
         if options[:instruct]
-          options[:instruct].each do |target,attrs|
+          options[:instruct].each do |target, attrs|
             if attrs.respond_to?(:keys)
               xml.instruct!(target, attrs)
             elsif attrs.respond_to?(:each)
@@ -112,13 +114,13 @@ module ActionView
           end
         end
 
-        feed_opts = {"xml:lang" => options[:language] || "en-US", "xmlns" => 'http://www.w3.org/2005/Atom'}
-        feed_opts.merge!(options).reject!{|k,v| !k.to_s.match(/^xml/)}
+        feed_opts = { "xml:lang" => options[:language] || "en-US", "xmlns" => "http://www.w3.org/2005/Atom" }
+        feed_opts.merge!(options).reject! { |k, v| !k.to_s.match(/^xml/) }
 
         xml.feed(feed_opts) do
           xml.id(options[:id] || "tag:#{request.host},#{options[:schema_date]}:#{request.fullpath.split(".")[0]}")
-          xml.link(:rel => 'alternate', :type => 'text/html', :href => options[:root_url] || (request.protocol + request.host_with_port))
-          xml.link(:rel => 'self', :type => 'application/atom+xml', :href => options[:url] || request.url)
+          xml.link(rel: "alternate", type: "text/html", href: options[:root_url] || (request.protocol + request.host_with_port))
+          xml.link(rel: "self", type: "application/atom+xml", href: options[:url] || request.url)
 
           yield AtomFeedBuilder.new(xml, self, options)
         end
@@ -132,13 +134,13 @@ module ActionView
         end
 
         private
-          # Delegate to xml builder, first wrapping the element in a xhtml
+          # Delegate to xml builder, first wrapping the element in an xhtml
           # namespaced div element if the method and arguments indicate
           # that an xhtml_block? is desired.
           def method_missing(method, *arguments, &block)
             if xhtml_block?(method, arguments)
               @xml.__send__(method, *arguments) do
-                @xml.div(:xmlns => 'http://www.w3.org/1999/xhtml') do |xhtml|
+                @xml.div(xmlns: "http://www.w3.org/1999/xhtml") do |xhtml|
                   block.call(xhtml)
                 end
               end
@@ -153,7 +155,7 @@ module ActionView
           def xhtml_block?(method, arguments)
             if XHTML_TAG_NAMES.include?(method.to_s)
               last = arguments.last
-              last.is_a?(Hash) && last[:type].to_s == 'xhtml'
+              last.is_a?(Hash) && last[:type].to_s == "xhtml"
             end
           end
       end
@@ -163,7 +165,7 @@ module ActionView
           @xml, @view, @feed_options = xml, view, feed_options
         end
 
-        # Accepts a Date or Time object and inserts it in the proper format. If nil is passed, current time in UTC is used.
+        # Accepts a Date or Time object and inserts it in the proper format. If +nil+ is passed, current time in UTC is used.
         def updated(date_or_time = nil)
           @xml.updated((date_or_time || Time.now.utc).xmlschema)
         end
@@ -174,7 +176,7 @@ module ActionView
         #
         # * <tt>:published</tt>: Time first published. Defaults to the created_at attribute on the record if one such exists.
         # * <tt>:updated</tt>: Time of update. Defaults to the updated_at attribute on the record if one such exists.
-        # * <tt>:url</tt>: The URL for this entry. Defaults to the polymorphic_url for the record.
+        # * <tt>:url</tt>: The URL for this entry or +false+ or +nil+ for not having a link tag. Defaults to the +polymorphic_url+ for the record.
         # * <tt>:id</tt>: The ID for this entry. Defaults to "tag:#{@view.request.host},#{@feed_options[:schema_date]}:#{record.class}/#{record.id}"
         # * <tt>:type</tt>: The TYPE for this entry. Defaults to "text/html".
         def entry(record, options = {})
@@ -189,15 +191,15 @@ module ActionView
               @xml.updated((options[:updated] || record.updated_at).xmlschema)
             end
 
-            type = options.fetch(:type, 'text/html')
+            type = options.fetch(:type, "text/html")
 
-            @xml.link(:rel => 'alternate', :type => type, :href => options[:url] || @view.polymorphic_url(record))
+            url = options.fetch(:url) { @view.polymorphic_url(record) }
+            @xml.link(rel: "alternate", type: type, href: url) if url
 
             yield AtomBuilder.new(@xml)
           end
         end
       end
-
     end
   end
 end