actionpack 3.2.22.5 → 5.2.4

data/lib/action_view/asset_paths.rb

@@ -1,142 +0,0 @@
-require 'zlib'
-require 'active_support/core_ext/file'
-require 'action_controller/metal/exceptions'
-
-module ActionView
-  class AssetPaths #:nodoc:
-    attr_reader :config, :controller
-
-    def initialize(config, controller = nil)
-      @config = config
-      @controller = controller
-    end
-
-    # Add the extension +ext+ if not present. Return full or scheme-relative URLs otherwise untouched.
-    # Prefix with <tt>/dir/</tt> if lacking a leading +/+. Account for relative URL
-    # roots. Rewrite the asset path for cache-busting asset ids. Include
-    # asset host, if configured, with the correct request protocol.
-    #
-    # When :relative (default), the protocol will be determined by the client using current protocol
-    # When :request, the protocol will be the request protocol
-    # Otherwise, the protocol is used (E.g. :http, :https, etc)
-    def compute_public_path(source, dir, options = {})
-      source = source.to_s
-      return source if is_uri?(source)
-
-      source = rewrite_extension(source, dir, options[:ext]) if options[:ext]
-      source = rewrite_asset_path(source, dir, options)
-      source = rewrite_relative_url_root(source, relative_url_root)
-      source = rewrite_host_and_protocol(source, options[:protocol])
-      source
-    end
-
-    # Return the filesystem path for the source
-    def compute_source_path(source, dir, ext)
-      source = rewrite_extension(source, dir, ext) if ext
-
-      sources = []
-      sources << config.assets_dir
-      sources << dir unless source[0] == ?/
-      sources << source
-
-      File.join(sources)
-    end
-
-    def is_uri?(path)
-      path =~ %r{^[-a-z]+://|^(?:cid|data):|^//}i
-    end
-
-  private
-
-    def rewrite_extension(source, dir, ext)
-      raise NotImplementedError
-    end
-
-    def rewrite_asset_path(source, path = nil)
-      raise NotImplementedError
-    end
-
-    def rewrite_relative_url_root(source, relative_url_root)
-      relative_url_root && !source.starts_with?("#{relative_url_root}/") ? "#{relative_url_root}#{source}" : source
-    end
-
-    def has_request?
-      controller.respond_to?(:request)
-    end
-
-    def rewrite_host_and_protocol(source, protocol = nil)
-      host = compute_asset_host(source)
-      if host && !is_uri?(host)
-        if (protocol || default_protocol) == :request && !has_request?
-          host = nil
-        else
-          host = "#{compute_protocol(protocol)}#{host}"
-        end
-      end
-      host ? "#{host}#{source}" : source
-    end
-
-    def compute_protocol(protocol)
-      protocol ||= default_protocol
-      case protocol
-      when :relative
-        "//"
-      when :request
-        unless @controller
-          invalid_asset_host!("The protocol requested was :request. Consider using :relative instead.")
-        end
-        @controller.request.protocol
-      else
-        "#{protocol}://"
-      end
-    end
-
-    def default_protocol
-      @config.default_asset_host_protocol || (has_request? ? :request : :relative)
-    end
-
-    def invalid_asset_host!(help_message)
-      raise ActionController::RoutingError, "This asset host cannot be computed without a request in scope. #{help_message}"
-    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)
-      if host = asset_host_config
-        if host.respond_to?(:call)
-          args = [source]
-          arity = arity_of(host)
-          if (arity > 1 || arity < -2) && !has_request?
-            invalid_asset_host!("Remove the second argument to your asset_host Proc if you do not need the request, or make it optional.")
-          end
-          args << current_request if (arity > 1 || arity < 0) && has_request?
-          host.call(*args)
-        else
-          (host =~ /%d/) ? host % (Zlib.crc32(source) % 4) : host
-        end
-      end
-    end
-
-    def relative_url_root
-      config.relative_url_root
-    end
-
-    def asset_host_config
-      config.asset_host
-    end
-
-    # Returns the current request if one exists.
-    def current_request
-      controller.request if has_request?
-    end
-
-    # Returns the arity of a callable
-    def arity_of(callable)
-      callable.respond_to?(:arity) ? callable.arity : callable.method(:call).arity
-    end
-
-  end
-end

data/lib/action_view/base.rb

@@ -1,220 +0,0 @@
-require 'active_support/core_ext/module/attr_internal'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/array/wrap'
-require 'active_support/ordered_options'
-require 'action_view/log_subscriber'
-require 'active_support/core_ext/module/deprecation'
-
-module ActionView #:nodoc:
-  # = Action View Base
-  #
-  # Action View templates can be written in several ways. If the template file has a <tt>.erb</tt> extension then it uses a mixture of ERb
-  # (included in Ruby) and HTML. If the template file has a <tt>.builder</tt> extension then Jim Weirich's Builder::XmlMarkup library is used.
-  #
-  # == ERB
-  #
-  # You trigger ERB by using embeddings such as <% %>, <% -%>, and <%= %>. The <%= %> tag set is used when you want output. Consider the
-  # following loop for names:
-  #
-  #   <b>Names of all the people</b>
-  #   <% @people.each do |person| %>
-  #     Name: <%= person.name %><br/>
-  #   <% end %>
-  #
-  # The loop is setup in regular embedding tags <% %> and the name is written using the output embedding tag <%= %>. Note that this
-  # is not just a usage suggestion. Regular output functions like print or puts won't work with ERB templates. So this would be wrong:
-  #
-  #   <%# WRONG %>
-  #   Hi, Mr. <% puts "Frodo" %>
-  #
-  # If you absolutely must write from within a function use +concat+.
-  #
-  # <%- and -%> suppress leading and trailing whitespace, including the trailing newline, and can be used interchangeably with <% and %>.
-  #
-  # === Using sub templates
-  #
-  # Using sub templates allows you to sidestep tedious replication and extract common display structures in shared templates. The
-  # classic example is the use of a header and footer (even though the Action Pack-way would be to use Layouts):
-  #
-  #   <%= render "shared/header" %>
-  #   Something really specific and terrific
-  #   <%= render "shared/footer" %>
-  #
-  # As you see, we use the output embeddings for the render methods. The render call itself will just return a string holding the
-  # result of the rendering. The output embedding writes it to the current template.
-  #
-  # But you don't have to restrict yourself to static includes. Templates can share variables amongst themselves by using instance
-  # variables defined using the regular embedding tags. Like this:
-  #
-  #   <% @page_title = "A Wonderful Hello" %>
-  #   <%= render "shared/header" %>
-  #
-  # Now the header can pick up on the <tt>@page_title</tt> variable and use it for outputting a title tag:
-  #
-  #   <title><%= @page_title %></title>
-  #
-  # === Passing local variables to sub templates
-  #
-  # You can pass local variables to sub templates by using a hash with the variable names as keys and the objects as values:
-  #
-  #   <%= render "shared/header", { :headline => "Welcome", :person => person } %>
-  #
-  # These can now be accessed in <tt>shared/header</tt> with:
-  #
-  #   Headline: <%= headline %>
-  #   First name: <%= person.first_name %>
-  #
-  # If you need to find out whether a certain local variable has been assigned a value in a particular render call,
-  # you need to use the following pattern:
-  #
-  #   <% if local_assigns.has_key? :headline %>
-  #     Headline: <%= headline %>
-  #   <% end %>
-  #
-  # Testing using <tt>defined? headline</tt> will not work. This is an implementation restriction.
-  #
-  # === Template caching
-  #
-  # By default, Rails will compile each template to a method in order to render it. When you alter a template,
-  # Rails will check the file's modification time and recompile it in development mode.
-  #
-  # == Builder
-  #
-  # Builder templates are a more programmatic alternative to ERB. They are especially useful for generating XML content. An XmlMarkup object
-  # named +xml+ is automatically made available to templates with a <tt>.builder</tt> extension.
-  #
-  # Here are some basic examples:
-  #
-  #   xml.em("emphasized")                                 # => <em>emphasized</em>
-  #   xml.em { xml.b("emph & bold") }                      # => <em><b>emph &amp; bold</b></em>
-  #   xml.a("A Link", "href" => "http://onestepback.org")  # => <a href="http://onestepback.org">A Link</a>
-  #   xml.target("name" => "compile", "option" => "fast")  # => <target option="fast" name="compile"\>
-  #                                                        # NOTE: order of attributes is not specified.
-  #
-  # Any method with a block will be treated as an XML markup tag with nested markup in the block. For example, the following:
-  #
-  #   xml.div do
-  #     xml.h1(@person.name)
-  #     xml.p(@person.bio)
-  #   end
-  #
-  # would produce something like:
-  #
-  #   <div>
-  #     <h1>David Heinemeier Hansson</h1>
-  #     <p>A product of Danish Design during the Winter of '79...</p>
-  #   </div>
-  #
-  # A full-length RSS example actually used on Basecamp:
-  #
-  #   xml.rss("version" => "2.0", "xmlns:dc" => "http://purl.org/dc/elements/1.1/") do
-  #     xml.channel do
-  #       xml.title(@feed_title)
-  #       xml.link(@url)
-  #       xml.description "Basecamp: Recent items"
-  #       xml.language "en-us"
-  #       xml.ttl "40"
-  #
-  #       @recent_items.each do |item|
-  #         xml.item do
-  #           xml.title(item_title(item))
-  #           xml.description(item_description(item)) if item_description(item)
-  #           xml.pubDate(item_pubDate(item))
-  #           xml.guid(@person.firm.account.url + @recent_items.url(item))
-  #           xml.link(@person.firm.account.url + @recent_items.url(item))
-  #
-  #           xml.tag!("dc:creator", item.author_name) if item_has_creator?(item)
-  #         end
-  #       end
-  #     end
-  #   end
-  #
-  # More builder documentation can be found at http://builder.rubyforge.org.
-  class Base
-    include Helpers, ::ERB::Util, Context
-
-    # Specify the proc used to decorate input tags that refer to attributes with errors.
-    cattr_accessor :field_error_proc
-    @@field_error_proc = Proc.new{ |html_tag, instance| "<div class=\"field_with_errors\">#{html_tag}</div>".html_safe }
-
-    # How to complete the streaming when an exception occurs.
-    # This is our best guess: first try to close the attribute, then the tag.
-    cattr_accessor :streaming_completion_on_exception
-    @@streaming_completion_on_exception = %("><script type="text/javascript">window.location = "/500.html"</script></html>)
-
-    class_attribute :helpers
-    class_attribute :_routes
-
-    class << self
-      delegate :erb_trim_mode=, :to => 'ActionView::Template::Handlers::ERB'
-      delegate :logger, :to => 'ActionController::Base', :allow_nil => true
-
-      def cache_template_loading
-        ActionView::Resolver.caching?
-      end
-
-      def cache_template_loading=(value)
-        ActionView::Resolver.caching = value
-      end
-
-      def process_view_paths(value)
-        value.is_a?(PathSet) ?
-          value.dup : ActionView::PathSet.new(Array.wrap(value))
-      end
-      deprecate :process_view_paths
-
-      def xss_safe? #:nodoc:
-        true
-      end
-
-      # This method receives routes and helpers from the controller
-      # and return a subclass ready to be used as view context.
-      def prepare(routes, helpers) #:nodoc:
-        Class.new(self) do
-          if routes
-            include routes.url_helpers
-            include routes.mounted_helpers
-          end
-
-          if helpers
-            include helpers
-            self.helpers = helpers
-          end
-        end
-      end
-    end
-
-    attr_accessor :view_renderer
-    attr_internal :config, :assigns
-
-    delegate :lookup_context, :to => :view_renderer
-    delegate :formats, :formats=, :locale, :locale=, :view_paths, :view_paths=, :to => :lookup_context
-
-    def assign(new_assigns) # :nodoc:
-      @_assigns = new_assigns.each { |key, value| instance_variable_set("@#{key}", value) }
-    end
-
-    def initialize(context = nil, assigns = {}, controller = nil, formats = nil) #:nodoc:
-      @_config = ActiveSupport::InheritableOptions.new
-
-      # Handle all these for backwards compatibility.
-      # TODO Provide a new API for AV::Base and deprecate this one.
-      if context.is_a?(ActionView::Renderer)
-        @view_renderer = context
-      elsif
-        lookup_context = context.is_a?(ActionView::LookupContext) ?
-          context : ActionView::LookupContext.new(context)
-        lookup_context.formats  = formats if formats
-        lookup_context.prefixes = controller._prefixes if controller
-        @view_renderer = ActionView::Renderer.new(lookup_context)
-      end
-
-      assign(assigns)
-      assign_controller(controller)
-      _prepare_context
-    end
-
-    ActiveSupport.run_load_hooks(:action_view, self)
-  end
-end

data/lib/action_view/buffers.rb

@@ -1,43 +0,0 @@
-require 'active_support/core_ext/string/output_safety'
-
-module ActionView
-  class OutputBuffer < ActiveSupport::SafeBuffer #:nodoc:
-    def initialize(*)
-      super
-      encode! if encoding_aware?
-    end
-
-    def <<(value)
-      super(value.to_s)
-    end
-    alias :append= :<<
-    alias :safe_append= :safe_concat
-  end
-
-  class StreamingBuffer #:nodoc:
-    def initialize(block)
-      @block = block
-    end
-
-    def <<(value)
-      value = value.to_s
-      value = ERB::Util.h(value) unless value.html_safe?
-      @block.call(value)
-    end
-    alias :concat  :<<
-    alias :append= :<<
-
-    def safe_concat(value)
-      @block.call(value.to_s)
-    end
-    alias :safe_append= :safe_concat
-
-    def html_safe?
-      true
-    end
-
-    def html_safe
-      self
-    end
-  end
-end

data/lib/action_view/context.rb

@@ -1,36 +0,0 @@
-module ActionView
-  module CompiledTemplates #:nodoc:
-    # holds compiled template code
-  end
-
-  # = Action View Context
-  #
-  # Action View contexts are supplied to Action Controller to render template.
-  # The default Action View context is ActionView::Base.
-  #
-  # In order to work with ActionController, a Context must just include this module.
-  # The initialization of the variables used by the context (@output_buffer, @view_flow,
-  # and @virtual_path) is responsibility of the object that includes this module
-  # (although you can call _prepare_context defined below).
-  module Context
-    include CompiledTemplates
-    attr_accessor :output_buffer, :view_flow
-
-    # Prepares the context by setting the appropriate instance variables.
-    # :api: plugin
-    def _prepare_context
-      @view_flow     = OutputFlow.new
-      @output_buffer = nil
-      @virtual_path  = nil
-    end
-
-    # Encapsulates the interaction with the view flow so it
-    # returns the correct buffer on yield. This is usually
-    # overwriten by helpers to add more behavior.
-    # :api: plugin
-    def _layout_for(name=nil)
-      name ||= :layout
-      view_flow.get(name).html_safe
-    end
-  end
-end

data/lib/action_view/flows.rb

@@ -1,79 +0,0 @@
-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 }
-    end
-
-    # Called by _layout_for to read stored values.
-    def get(key)
-      @content[key]
-    end
-
-    # Called by each renderer object to set the layout contents.
-    def set(key, value)
-      @content[key] = value
-    end
-
-    # Called by content_for
-    def append(key, value)
-      @content[key] << value
-    end
-
-    # Called by provide
-    def append!(key, value)
-      @content[key] << value
-    end
-  end
-
-  class StreamingFlow < OutputFlow #:nodoc:
-    def initialize(view, fiber)
-      @view    = view
-      @parent  = nil
-      @child   = view.output_buffer
-      @content = view.view_flow.content
-      @fiber   = fiber
-      @root    = Fiber.current.object_id
-    end
-
-    # Try to get an 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.
-    def get(key)
-      return super if @content.key?(key)
-
-      if inside_fiber?
-        view = @view
-
-        begin
-          @waiting_for = key
-          view.output_buffer, @parent = @child, view.output_buffer
-          Fiber.yield
-        ensure
-          @waiting_for = nil
-          view.output_buffer, @child = @parent, view.output_buffer
-        end
-      end
-
-      super
-    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.
-    def append!(key, value)
-      super
-      @fiber.resume if @waiting_for == key
-    end
-
-    private
-
-    def inside_fiber?
-      Fiber.current.object_id != @root
-    end
-  end
-end

data/lib/action_view/helpers/active_model_helper.rb

@@ -1,50 +0,0 @@
-require 'active_support/core_ext/class/attribute_accessors'
-require 'active_support/core_ext/enumerable'
-require 'active_support/core_ext/object/blank'
-
-module ActionView
-  # = Active Model Helpers
-  module Helpers
-    module ActiveModelHelper
-    end
-
-    module ActiveModelInstanceTag
-      def object
-        @active_model_object ||= begin
-          object = super
-          object.respond_to?(:to_model) ? object.to_model : object
-        end
-      end
-
-      %w(content_tag to_date_select_tag to_datetime_select_tag to_time_select_tag).each do |meth|
-        module_eval "def #{meth}(*) error_wrapping(super) end", __FILE__, __LINE__
-      end
-
-      def tag(type, options, *)
-        tag_generate_errors?(options) ? error_wrapping(super) : super
-      end
-
-      def error_wrapping(html_tag)
-        if object_has_errors?
-          Base.field_error_proc.call(html_tag, self)
-        else
-          html_tag
-        end
-      end
-
-      def error_message
-        object.errors[@method_name]
-      end
-
-      private
-
-      def object_has_errors?
-        object.respond_to?(:errors) && object.errors.respond_to?(:full_messages) && error_message.any?
-      end
-
-      def tag_generate_errors?(options)
-        options['type'] != 'hidden'
-      end
-    end
-  end
-end

data/lib/action_view/helpers/asset_paths.rb

@@ -1,7 +0,0 @@
-ActiveSupport::Deprecation.warn "ActionView::Helpers::AssetPaths is deprecated. Please use ActionView::AssetPaths instead."
-
-module ActionView
-  module Helpers
-    AssetPaths = ::ActionView::AssetPaths
-  end
-end