actionpack 4.0.1 → 4.2.11.1

data/lib/action_view/helpers/asset_url_helper.rb

@@ -1,355 +0,0 @@
-require 'zlib'
-
-module ActionView
-  # = Action View Asset URL Helpers
-  module Helpers
-    # This module provides methods for generating asset paths and
-    # urls.
-    #
-    #   image_path("rails.png")
-    #   # => "/assets/rails.png"
-    #
-    #   image_url("rails.png")
-    #   # => "http://www.example.com/assets/rails.png"
-    #
-    # === Using asset hosts
-    #
-    # By default, Rails links to these assets on the current host in the public
-    # folder, but you can direct Rails to link to assets from a dedicated asset
-    # server by setting <tt>ActionController::Base.asset_host</tt> in the application
-    # configuration, typically in <tt>config/environments/production.rb</tt>.
-    # For example, you'd define <tt>assets.example.com</tt> to be your asset
-    # host this way, inside the <tt>configure</tt> block of your environment-specific
-    # configuration files or <tt>config/application.rb</tt>:
-    #
-    #   config.action_controller.asset_host = "assets.example.com"
-    #
-    # Helpers take that into account:
-    #
-    #   image_tag("rails.png")
-    #   # => <img alt="Rails" 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.
-    #
-    #   image_tag("rails.png")
-    #   # => <img alt="Rails" 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.
-    #
-    # 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.
-    #
-    # Alternatively, you can exert more control over the asset host by setting
-    # +asset_host+ to a proc like this:
-    #
-    #   ActionController::Base.asset_host = Proc.new { |source|
-    #     "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" />
-    #   stylesheet_link_tag("application")
-    #   # => <link href="http://assets2.example.com/assets/application.css" media="screen" rel="stylesheet" />
-    #
-    # The example above generates "http://assets1.example.com" and
-    # "http://assets2.example.com". This option is useful for example if
-    # you need fewer/more than four hosts, custom host names, etc.
-    #
-    # As you see the proc takes a +source+ parameter. That's a string with the
-    # absolute path of the asset, for example "/assets/rails.png".
-    #
-    #    ActionController::Base.asset_host = Proc.new { |source|
-    #      if source.ends_with?('.css')
-    #        "http://stylesheets.example.com"
-    #      else
-    #        "http://assets.example.com"
-    #      end
-    #    }
-    #   image_tag("rails.png")
-    #   # => <img alt="Rails" 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" />
-    #
-    # Alternatively you may ask for a second parameter +request+. That one is
-    # particularly useful for serving assets from an SSL-protected page. The
-    # example proc below disables asset hosting for HTTPS connections, while
-    # 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.
-    #
-    #   config.action_controller.asset_host = Proc.new { |source, request|
-    #     if request.ssl?
-    #       "#{request.protocol}#{request.host_with_port}"
-    #     else
-    #       "#{request.protocol}assets.example.com"
-    #     end
-    #   }
-    #
-    # You can also implement a custom asset host object that responds to +call+
-    # and takes either one or two parameters just like the proc.
-    #
-    #   config.action_controller.asset_host = AssetHostingWithMinimumSsl.new(
-    #     "http://asset%d.example.com", "https://asset1.example.com"
-    #   )
-    #
-    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.
-      #
-      # All other asset *_path helpers delegate through this method.
-      #
-      #   asset_path "application.js"                     # => /application.js
-      #   asset_path "application", type: :javascript     # => /javascripts/application.js
-      #   asset_path "application", type: :stylesheet     # => /stylesheets/application.css
-      #   asset_path "http://www.example.com/js/xmlhr.js" # => http://www.example.com/js/xmlhr.js
-      def asset_path(source, options = {})
-        source = source.to_s
-        return "" unless source.present?
-        return source if source =~ URI_REGEXP
-
-        tail, source = source[/([\?#].+)$/], source.sub(/([\?#].+)$/, '')
-
-        if extname = compute_asset_extname(source, options)
-          source = "#{source}#{extname}"
-        end
-
-        if source[0] != ?/
-          source = compute_asset_path(source, options)
-        end
-
-        relative_url_root = defined?(config.relative_url_root) && config.relative_url_root
-        if relative_url_root
-          source = "#{relative_url_root}#{source}" unless source.starts_with?("#{relative_url_root}/")
-        end
-
-        if host = compute_asset_host(source, options)
-          source = "#{host}#{source}"
-        end
-
-        "#{source}#{tail}"
-      end
-      alias_method :path_to_asset, :asset_path # aliased to avoid conflicts with a asset_path named route
-
-      # Computes the full URL to a asset in the public directory. This
-      # will use +asset_path+ internally, so most of their behaviors
-      # will be the same.
-      def asset_url(source, options = {})
-        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'
-      }
-
-      # 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
-      end
-
-      # Maps asset types to public directory.
-      ASSET_PUBLIC_DIRECTORIES = {
-        audio:      '/audios',
-        font:       '/fonts',
-        image:      '/images',
-        javascript: '/javascripts',
-        stylesheet: '/stylesheets',
-        video:      '/videos'
-      }
-
-      # Computes asset path to public directory. Plugins and
-      # extensions can override this method to point to custom assets
-      # or generate digested paths or query strings.
-      def compute_asset_path(source, options = {})
-        dir = ASSET_PUBLIC_DIRECTORIES[options[:type]] || ""
-        File.join(dir, source)
-      end
-
-      # 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
-      # numbers 0-3 if it contains <tt>%d</tt> (the number is the source hash mod 4),
-      # or the value returned from invoking call on an object responding to call
-      # (proc or otherwise).
-      def compute_asset_host(source = "", options = {})
-        request = self.request if respond_to?(:request)
-        host = config.asset_host if defined? config.asset_host
-        host ||= request.base_url if request && options[:protocol] == :request
-
-        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)
-        end
-
-        return unless host
-
-        if host =~ URI_REGEXP
-          host
-        else
-          protocol = options[:protocol] || config.default_asset_host_protocol || (request ? :request : :relative)
-          case protocol
-          when :relative
-            "//#{host}"
-          when :request
-            "#{request.protocol}#{host}"
-          else
-            "#{protocol}://#{host}"
-          end
-        end
-      end
-
-      # Computes the path to a javascript asset in the public javascripts directory.
-      # If the +source+ filename has no extension, .js will be appended (except for explicit URIs)
-      # Full paths from the document root will be passed through.
-      # Used internally by javascript_include_tag to build the script path.
-      #
-      #   javascript_path "xmlhr"                              # => /javascripts/xmlhr.js
-      #   javascript_path "dir/xmlhr.js"                       # => /javascripts/dir/xmlhr.js
-      #   javascript_path "/dir/xmlhr"                         # => /dir/xmlhr.js
-      #   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))
-      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.
-      def javascript_url(source, 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
-
-      # Computes the path to a stylesheet asset in the public stylesheets directory.
-      # If the +source+ filename has no extension, <tt>.css</tt> will be appended (except for explicit URIs).
-      # Full paths from the document root will be passed through.
-      # Used internally by +stylesheet_link_tag+ to build the stylesheet path.
-      #
-      #   stylesheet_path "style"                                  # => /stylesheets/style.css
-      #   stylesheet_path "dir/style.css"                          # => /stylesheets/dir/style.css
-      #   stylesheet_path "/dir/style.css"                         # => /dir/style.css
-      #   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))
-      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.
-      def stylesheet_url(source, 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
-
-      # Computes the path to an image asset.
-      # Full paths from the document root will be passed through.
-      # Used internally by +image_tag+ to build the image path:
-      #
-      #   image_path("edit")                                         # => "/assets/edit"
-      #   image_path("edit.png")                                     # => "/assets/edit.png"
-      #   image_path("icons/edit.png")                               # => "/assets/icons/edit.png"
-      #   image_path("/icons/edit.png")                              # => "/icons/edit.png"
-      #   image_path("http://www.example.com/img/edit.png")          # => "http://www.example.com/img/edit.png"
-      #
-      # If you have images as application resources this method may conflict with their named routes.
-      # 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))
-      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.
-      def image_url(source, 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
-
-      # Computes the path to a video asset in the public videos directory.
-      # Full paths from the document root will be passed through.
-      # Used internally by +video_tag+ to build the video path.
-      #
-      #   video_path("hd")                                            # => /videos/hd
-      #   video_path("hd.avi")                                        # => /videos/hd.avi
-      #   video_path("trailers/hd.avi")                               # => /videos/trailers/hd.avi
-      #   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))
-      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.
-      def video_url(source, 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
-
-      # Computes the path to an audio asset in the public audios directory.
-      # Full paths from the document root will be passed through.
-      # Used internally by +audio_tag+ to build the audio path.
-      #
-      #   audio_path("horse")                                            # => /audios/horse
-      #   audio_path("horse.wav")                                        # => /audios/horse.wav
-      #   audio_path("sounds/horse.wav")                                 # => /audios/sounds/horse.wav
-      #   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))
-      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.
-      def audio_url(source, 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
-
-      # Computes the path to a font asset.
-      # Full paths from the document root will be passed through.
-      #
-      #   font_path("font")                                           # => /assets/font
-      #   font_path("font.ttf")                                       # => /assets/font.ttf
-      #   font_path("dir/font.ttf")                                   # => /assets/dir/font.ttf
-      #   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))
-      end
-      alias_method :path_to_font, :font_path # aliased to avoid conflicts with an 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.
-      def font_url(source, 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
-    end
-  end
-end

data/lib/action_view/helpers/atom_feed_helper.rb

@@ -1,203 +0,0 @@
-require 'set'
-
-module ActionView
-  # = Action View Atom Feed Helpers
-  module Helpers
-    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).
-      #
-      # Full usage example:
-      #
-      #   config/routes.rb:
-      #     Basecamp::Application.routes.draw do
-      #       resources :posts
-      #       root to: "posts#index"
-      #     end
-      #
-      #   app/controllers/posts_controller.rb:
-      #     class PostsController < ApplicationController::Base
-      #       # GET /posts.html
-      #       # GET /posts.atom
-      #       def index
-      #         @posts = Post.all
-      #
-      #         respond_to do |format|
-      #           format.html
-      #           format.atom
-      #         end
-      #       end
-      #     end
-      #
-      #   app/views/posts/index.atom.builder:
-      #     atom_feed do |feed|
-      #       feed.title("My great blog!")
-      #       feed.updated(@posts[0].created_at) if @posts.length > 0
-      #
-      #       @posts.each do |post|
-      #         feed.entry(post) do |entry|
-      #           entry.title(post.title)
-      #           entry.content(post.body, type: 'html')
-      #
-      #           entry.author do |author|
-      #             author.name("DHH")
-      #           end
-      #         end
-      #       end
-      #     end
-      #
-      # The options for atom_feed are:
-      #
-      # * <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>: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).
-      # * <tt>:instruct</tt>: Hash of XML processing instructions in the form {target => {attribute => value, }} or {target => [{attribute => value, }, ]}
-      #
-      # Other namespaces can be added to the root element:
-      #
-      #   app/views/posts/index.atom.builder:
-      #     atom_feed({'xmlns:app' => 'http://www.w3.org/2007/app',
-      #         'xmlns:openSearch' => 'http://a9.com/-/spec/opensearch/1.1/'}) do |feed|
-      #       feed.title("My great blog!")
-      #       feed.updated((@posts.first.created_at))
-      #       feed.tag!(openSearch:totalResults, 10)
-      #
-      #       @posts.each do |post|
-      #         feed.entry(post) do |entry|
-      #           entry.title(post.title)
-      #           entry.content(post.body, type: 'html')
-      #           entry.tag!('app:edited', Time.now)
-      #
-      #           entry.author do |author|
-      #             author.name("DHH")
-      #           end
-      #         end
-      #       end
-      #     end
-      #
-      # The Atom spec defines five elements (content rights title subtitle
-      # summary) which may directly contain xhtml content if type: 'xhtml'
-      # is specified as an attribute. If so, this helper will take care of
-      # the enclosing div and xhtml namespace declaration. Example usage:
-      #
-      #    entry.summary type: 'xhtml' do |xhtml|
-      #      xhtml.p pluralize(order.line_items.count, "line item")
-      #      xhtml.p "Shipped to #{order.address}"
-      #      xhtml.p "Paid by #{order.pay_type}"
-      #    end
-      #
-      #
-      # <tt>atom_feed</tt> yields an +AtomFeedBuilder+ instance. Nested elements yield
-      # an +AtomBuilder+ instance.
-      def atom_feed(options = {}, &block)
-        if options[:schema_date]
-          options[:schema_date] = options[:schema_date].strftime("%Y-%m-%d") if options[:schema_date].respond_to?(:strftime)
-        else
-          options[:schema_date] = "2005" # The Atom spec copyright date
-        end
-
-        xml = options.delete(:xml) || eval("xml", block.binding)
-        xml.instruct!
-        if options[:instruct]
-          options[:instruct].each do |target,attrs|
-            if attrs.respond_to?(:keys)
-              xml.instruct!(target, attrs)
-            elsif attrs.respond_to?(:each)
-              attrs.each { |attr_group| xml.instruct!(target, attr_group) }
-            end
-          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/)}
-
-        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)
-
-          yield AtomFeedBuilder.new(xml, self, options)
-        end
-      end
-
-      class AtomBuilder #:nodoc:
-        XHTML_TAG_NAMES = %w(content rights title subtitle summary).to_set
-
-        def initialize(xml)
-          @xml = xml
-        end
-
-        private
-          # Delegate to xml builder, first wrapping the element in a 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|
-                  block.call(xhtml)
-                end
-              end
-            else
-              @xml.__send__(method, *arguments, &block)
-            end
-          end
-
-          # True if the method name matches one of the five elements defined
-          # in the Atom spec as potentially containing XHTML content and
-          # if type: 'xhtml' is, in fact, specified.
-          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'
-            end
-          end
-      end
-
-      class AtomFeedBuilder < AtomBuilder #:nodoc:
-        def initialize(xml, view, feed_options = {})
-          @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.
-        def updated(date_or_time = nil)
-          @xml.updated((date_or_time || Time.now.utc).xmlschema)
-        end
-
-        # Creates an entry tag for a specific record and prefills the id using class and id.
-        #
-        # Options:
-        #
-        # * <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>: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 = {})
-          @xml.entry do
-            @xml.id(options[:id] || "tag:#{@view.request.host},#{@feed_options[:schema_date]}:#{record.class}/#{record.id}")
-
-            if options[:published] || (record.respond_to?(:created_at) && record.created_at)
-              @xml.published((options[:published] || record.created_at).xmlschema)
-            end
-
-            if options[:updated] || (record.respond_to?(:updated_at) && record.updated_at)
-              @xml.updated((options[:updated] || record.updated_at).xmlschema)
-            end
-
-            type = options.fetch(:type, 'text/html')
-
-            @xml.link(:rel => 'alternate', :type => type, :href => options[:url] || @view.polymorphic_url(record))
-
-            yield AtomBuilder.new(@xml)
-          end
-        end
-      end
-
-    end
-  end
-end