actionpack 3.2.19 → 4.2.11.3

data/lib/action_controller/caching/pages.rb

@@ -1,187 +0,0 @@
-require 'fileutils'
-require 'active_support/core_ext/class/attribute_accessors'
-
-module ActionController #:nodoc:
-  module Caching
-    # Page caching is an approach to caching where the entire action output of is stored as a HTML file that the web server
-    # can serve without going through Action Pack. This is the fastest way to cache your content as opposed to going dynamically
-    # through the process of generating the content. Unfortunately, this incredible speed-up is only available to stateless pages
-    # where all visitors are treated the same. Content management systems -- including weblogs and wikis -- have many pages that are
-    # a great fit for this approach, but account-based systems where people log in and manipulate their own data are often less
-    # likely candidates.
-    #
-    # Specifying which actions to cache is done through the <tt>caches_page</tt> class method:
-    #
-    #   class WeblogController < ActionController::Base
-    #     caches_page :show, :new
-    #   end
-    #
-    # This will generate cache files such as <tt>weblog/show/5.html</tt> and <tt>weblog/new.html</tt>, which match the URLs used
-    # that would normally trigger dynamic page generation. Page caching works by configuring a web server to first check for the
-    # existence of files on disk, and to serve them directly when found, without passing the request through to Action Pack.
-    # This is much faster than handling the full dynamic request in the usual way.
-    #
-    # Expiration of the cache is handled by deleting the cached file, which results in a lazy regeneration approach where the cache
-    # is not restored before another hit is made against it. The API for doing so mimics the options from +url_for+ and friends:
-    #
-    #   class WeblogController < ActionController::Base
-    #     def update
-    #       List.update(params[:list][:id], params[:list])
-    #       expire_page :action => "show", :id => params[:list][:id]
-    #       redirect_to :action => "show", :id => params[:list][:id]
-    #     end
-    #   end
-    #
-    # Additionally, you can expire caches using Sweepers that act on changes in the model to determine when a cache is supposed to be
-    # expired.
-    module Pages
-      extend ActiveSupport::Concern
-
-      included do
-        # The cache directory should be the document root for the web server and is set using <tt>Base.page_cache_directory = "/document/root"</tt>.
-        # For Rails, this directory has already been set to Rails.public_path (which is usually set to <tt>Rails.root + "/public"</tt>). Changing
-        # this setting can be useful to avoid naming conflicts with files in <tt>public/</tt>, but doing so will likely require configuring your
-        # web server to look in the new location for cached files.
-        class_attribute :page_cache_directory
-        self.page_cache_directory ||= ''
-
-        # Most Rails requests do not have an extension, such as <tt>/weblog/new</tt>. In these cases, the page caching mechanism will add one in
-        # order to make it easy for the cached files to be picked up properly by the web server. By default, this cache extension is <tt>.html</tt>.
-        # If you want something else, like <tt>.php</tt> or <tt>.shtml</tt>, just set Base.page_cache_extension. In cases where a request already has an
-        # extension, such as <tt>.xml</tt> or <tt>.rss</tt>, page caching will not add an extension. This allows it to work well with RESTful apps.
-        class_attribute :page_cache_extension
-        self.page_cache_extension ||= '.html'
-
-        # The compression used for gzip. If false (default), the page is not compressed.
-        # If can be a symbol showing the ZLib compression method, for example, :best_compression
-        # or :best_speed or an integer configuring the compression level.
-        class_attribute :page_cache_compression
-        self.page_cache_compression ||= false
-      end
-
-      module ClassMethods
-        # Expires the page that was cached with the +path+ as a key. Example:
-        #   expire_page "/lists/show"
-        def expire_page(path)
-          return unless perform_caching
-          path = page_cache_path(path)
-
-          instrument_page_cache :expire_page, path do
-            File.delete(path) if File.exist?(path)
-            File.delete(path + '.gz') if File.exist?(path + '.gz')
-          end
-        end
-
-        # Manually cache the +content+ in the key determined by +path+. Example:
-        #   cache_page "I'm the cached content", "/lists/show"
-        def cache_page(content, path, extension = nil, gzip = Zlib::BEST_COMPRESSION)
-          return unless perform_caching
-          path = page_cache_path(path, extension)
-
-          instrument_page_cache :write_page, path do
-            FileUtils.makedirs(File.dirname(path))
-            File.open(path, "wb+") { |f| f.write(content) }
-            if gzip
-              Zlib::GzipWriter.open(path + '.gz', gzip) { |f| f.write(content) }
-            end
-          end
-        end
-
-        # Caches the +actions+ using the page-caching approach that'll store
-        # the cache in a path within the page_cache_directory that
-        # matches the triggering url.
-        #
-        # You can also pass a :gzip option to override the class configuration one.
-        #
-        # Usage:
-        #
-        #   # cache the index action
-        #   caches_page :index
-        #
-        #   # cache the index action except for JSON requests
-        #   caches_page :index, :if => Proc.new { |c| !c.request.format.json? }
-        #
-        #   # don't gzip images
-        #   caches_page :image, :gzip => false
-        def caches_page(*actions)
-          return unless perform_caching
-          options = actions.extract_options!
-
-          gzip_level = options.fetch(:gzip, page_cache_compression)
-          gzip_level = case gzip_level
-          when Symbol
-            Zlib.const_get(gzip_level.to_s.upcase)
-          when Fixnum
-            gzip_level
-          when false
-            nil
-          else
-            Zlib::BEST_COMPRESSION
-          end
-
-          after_filter({:only => actions}.merge(options)) do |c|
-            c.cache_page(nil, nil, gzip_level)
-          end
-        end
-
-        private
-          def page_cache_file(path, extension)
-            name = (path.empty? || path == "/") ? "/index" : URI.parser.unescape(path.chomp('/'))
-            unless (name.split('/').last || name).include? '.'
-              name << (extension || self.page_cache_extension)
-            end
-            return name
-          end
-
-          def page_cache_path(path, extension = nil)
-            page_cache_directory.to_s + page_cache_file(path, extension)
-          end
-
-          def instrument_page_cache(name, path)
-            ActiveSupport::Notifications.instrument("#{name}.action_controller", :path => path){ yield }
-          end
-      end
-
-      # Expires the page that was cached with the +options+ as a key. Example:
-      #   expire_page :controller => "lists", :action => "show"
-      def expire_page(options = {})
-        return unless self.class.perform_caching
-
-        if options.is_a?(Hash)
-          if options[:action].is_a?(Array)
-            options[:action].each do |action|
-              self.class.expire_page(url_for(options.merge(:only_path => true, :action => action)))
-            end
-          else
-            self.class.expire_page(url_for(options.merge(:only_path => true)))
-          end
-        else
-          self.class.expire_page(options)
-        end
-      end
-
-      # Manually cache the +content+ in the key determined by +options+. If no content is provided, the contents of response.body is used.
-      # If no options are provided, the url of the current request being handled is used. Example:
-      #   cache_page "I'm the cached content", :controller => "lists", :action => "show"
-      def cache_page(content = nil, options = nil, gzip = Zlib::BEST_COMPRESSION)
-        return unless self.class.perform_caching && caching_allowed?
-
-        path = case options
-          when Hash
-            url_for(options.merge(:only_path => true, :format => params[:format]))
-          when String
-            options
-          else
-            request.path
-        end
-
-        if (type = Mime::LOOKUP[self.content_type]) && (type_symbol = type.symbol).present?
-          extension = ".#{type_symbol}"
-        end
-
-        self.class.cache_page(content || response.body, path, extension, gzip)
-      end
-
-    end
-  end
-end

data/lib/action_controller/caching/sweeping.rb

@@ -1,97 +0,0 @@
-module ActionController #:nodoc:
-  module Caching
-    # Sweepers are the terminators of the caching world and responsible for expiring caches when model objects change.
-    # They do this by being half-observers, half-filters and implementing callbacks for both roles. A Sweeper example:
-    #
-    #   class ListSweeper < ActionController::Caching::Sweeper
-    #     observe List, Item
-    #
-    #     def after_save(record)
-    #       list = record.is_a?(List) ? record : record.list
-    #       expire_page(:controller => "lists", :action => %w( show public feed ), :id => list.id)
-    #       expire_action(:controller => "lists", :action => "all")
-    #       list.shares.each { |share| expire_page(:controller => "lists", :action => "show", :id => share.url_key) }
-    #     end
-    #   end
-    #
-    # The sweeper is assigned in the controllers that wish to have its job performed using the <tt>cache_sweeper</tt> class method:
-    #
-    #   class ListsController < ApplicationController
-    #     caches_action :index, :show, :public, :feed
-    #     cache_sweeper :list_sweeper, :only => [ :edit, :destroy, :share ]
-    #   end
-    #
-    # In the example above, four actions are cached and three actions are responsible for expiring those caches.
-    #
-    # You can also name an explicit class in the declaration of a sweeper, which is needed if the sweeper is in a module:
-    #
-    #   class ListsController < ApplicationController
-    #     caches_action :index, :show, :public, :feed
-    #     cache_sweeper OpenBar::Sweeper, :only => [ :edit, :destroy, :share ]
-    #   end
-    module Sweeping
-      extend ActiveSupport::Concern
-
-      module ClassMethods #:nodoc:
-        def cache_sweeper(*sweepers)
-          configuration = sweepers.extract_options!
-
-          sweepers.each do |sweeper|
-            ActiveRecord::Base.observers << sweeper if defined?(ActiveRecord) and defined?(ActiveRecord::Base)
-            sweeper_instance = (sweeper.is_a?(Symbol) ? Object.const_get(sweeper.to_s.classify) : sweeper).instance
-
-            if sweeper_instance.is_a?(Sweeper)
-              around_filter(sweeper_instance, :only => configuration[:only])
-            else
-              after_filter(sweeper_instance, :only => configuration[:only])
-            end
-          end
-        end
-      end
-    end
-
-    if defined?(ActiveRecord) and defined?(ActiveRecord::Observer)
-      class Sweeper < ActiveRecord::Observer #:nodoc:
-        attr_accessor :controller
-
-        def before(controller)
-          self.controller = controller
-          callback(:before) if controller.perform_caching
-          true # before method from sweeper should always return true
-        end
-
-        def after(controller)
-          self.controller = controller
-          callback(:after) if controller.perform_caching
-          # Clean up, so that the controller can be collected after this request
-          self.controller = nil
-        end
-
-        protected
-          # gets the action cache path for the given options.
-          def action_path_for(options)
-            Actions::ActionCachePath.new(controller, options).path
-          end
-
-          # Retrieve instance variables set in the controller.
-          def assigns(key)
-            controller.instance_variable_get("@#{key}")
-          end
-
-        private
-          def callback(timing)
-            controller_callback_method_name = "#{timing}_#{controller.controller_name.underscore}"
-            action_callback_method_name     = "#{controller_callback_method_name}_#{controller.action_name}"
-
-            __send__(controller_callback_method_name) if respond_to?(controller_callback_method_name, true)
-            __send__(action_callback_method_name)     if respond_to?(action_callback_method_name, true)
-          end
-
-          def method_missing(method, *arguments, &block)
-            return unless @controller
-            @controller.__send__(method, *arguments, &block)
-          end
-      end
-    end
-  end
-end

data/lib/action_controller/deprecated/integration_test.rb

@@ -1,2 +0,0 @@
-ActionController::Integration = ActionDispatch::Integration
-ActionController::IntegrationTest = ActionDispatch::IntegrationTest

data/lib/action_controller/deprecated/performance_test.rb

@@ -1 +0,0 @@
-ActionController::PerformanceTest = ActionDispatch::PerformanceTest

data/lib/action_controller/deprecated.rb

@@ -1,3 +0,0 @@
-ActionController::AbstractRequest = ActionController::Request = ActionDispatch::Request
-ActionController::AbstractResponse = ActionController::Response = ActionDispatch::Response
-ActionController::Routing = ActionDispatch::Routing

data/lib/action_controller/metal/compatibility.rb

@@ -1,65 +0,0 @@
-require 'active_support/deprecation'
-
-module ActionController
-  module Compatibility
-    extend ActiveSupport::Concern
-
-    # Temporary hax
-    included do
-      ::ActionController::UnknownAction = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('ActionController::UnknownAction', '::AbstractController::ActionNotFound')
-      ::ActionController::DoubleRenderError = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('ActionController::DoubleRenderError', '::AbstractController::DoubleRenderError')
-
-      # ROUTES TODO: This should be handled by a middleware and route generation
-      # should be able to handle SCRIPT_NAME
-      self.config.relative_url_root = ENV['RAILS_RELATIVE_URL_ROOT']
-
-      def self.default_charset=(new_charset)
-        ActiveSupport::Deprecation.warn "Setting default charset at controller level" \
-          " is deprecated, please use `config.action_dispatch.default_charset` instead", caller
-        ActionDispatch::Response.default_charset = new_charset
-      end
-
-      self.protected_instance_variables = %w(
-        @_status @_headers @_params @_env @_response @_request
-        @_view_runtime @_stream @_url_options @_action_has_layout
-      )
-
-      def rescue_action(env)
-        ActiveSupport::Deprecation.warn "Calling `rescue_action` is deprecated and will be removed in Rails 4.0.", caller
-        raise env["action_dispatch.rescue.exception"]
-      end
-    end
-
-    # For old tests
-    def initialize_template_class(*)
-      ActiveSupport::Deprecation.warn "Calling `initialize_template_class` is deprecated and has no effect anymore.", caller
-    end
-
-    def assign_shortcuts(*)
-      ActiveSupport::Deprecation.warn "Calling `assign_shortcuts` is deprecated and has no effect anymore.", caller
-    end
-
-    def _normalize_options(options)
-      options[:text] = nil if options.delete(:nothing) == true
-      options[:text] = " " if options.key?(:text) && options[:text].nil?
-      super
-    end
-
-    def render_to_body(options)
-      options[:template].sub!(/^\//, '') if options.key?(:template)
-      super || " "
-    end
-
-    def _handle_method_missing
-      ActiveSupport::Deprecation.warn "Using `method_missing` to handle non" \
-        " existing actions is deprecated and will be removed in Rails 4.0, " \
-        " please use `action_missing` instead.", caller
-      method_missing(@_action_name.to_sym)
-    end
-
-    def method_for_action(action_name)
-      super || ((self.class.public_method_defined?(:method_missing) ||
-        self.class.protected_method_defined?(:method_missing)) && "_handle_method_missing")
-    end
-  end
-end

data/lib/action_controller/metal/responder.rb

@@ -1,286 +0,0 @@
-require 'active_support/json'
-
-module ActionController #:nodoc:
-  # Responsible for exposing a resource to different mime requests,
-  # usually depending on the HTTP verb. The responder is triggered when
-  # <code>respond_with</code> is called. The simplest case to study is a GET request:
-  #
-  #   class PeopleController < ApplicationController
-  #     respond_to :html, :xml, :json
-  #
-  #     def index
-  #       @people = Person.all
-  #       respond_with(@people)
-  #     end
-  #   end
-  #
-  # When a request comes in, for example for an XML response, three steps happen:
-  #
-  #   1) the responder searches for a template at people/index.xml;
-  #
-  #   2) if the template is not available, it will invoke <code>#to_xml</code> on the given resource;
-  #
-  #   3) if the responder does not <code>respond_to :to_xml</code>, call <code>#to_format</code> on it.
-  #
-  # === Builtin HTTP verb semantics
-  #
-  # The default \Rails responder holds semantics for each HTTP verb. Depending on the
-  # content type, verb and the resource status, it will behave differently.
-  #
-  # Using \Rails default responder, a POST request for creating an object could
-  # be written as:
-  #
-  #   def create
-  #     @user = User.new(params[:user])
-  #     flash[:notice] = 'User was successfully created.' if @user.save
-  #     respond_with(@user)
-  #   end
-  #
-  # Which is exactly the same as:
-  #
-  #   def create
-  #     @user = User.new(params[:user])
-  #
-  #     respond_to do |format|
-  #       if @user.save
-  #         flash[:notice] = 'User was successfully created.'
-  #         format.html { redirect_to(@user) }
-  #         format.xml { render :xml => @user, :status => :created, :location => @user }
-  #       else
-  #         format.html { render :action => "new" }
-  #         format.xml { render :xml => @user.errors, :status => :unprocessable_entity }
-  #       end
-  #     end
-  #   end
-  #
-  # The same happens for PUT and DELETE requests.
-  #
-  # === Nested resources
-  #
-  # You can supply nested resources as you do in <code>form_for</code> and <code>polymorphic_url</code>.
-  # Consider the project has many tasks example. The create action for
-  # TasksController would be like:
-  #
-  #   def create
-  #     @project = Project.find(params[:project_id])
-  #     @task = @project.comments.build(params[:task])
-  #     flash[:notice] = 'Task was successfully created.' if @task.save
-  #     respond_with(@project, @task)
-  #   end
-  #
-  # Giving several resources ensures that the responder will redirect to
-  # <code>project_task_url</code> instead of <code>task_url</code>.
-  #
-  # Namespaced and singleton resources require a symbol to be given, as in
-  # polymorphic urls. If a project has one manager which has many tasks, it
-  # should be invoked as:
-  #
-  #   respond_with(@project, :manager, @task)
-  #
-  # Note that if you give an array, it will be treated as a collection,
-  # so the following is not equivalent:
-  #
-  #   respond_with [@project, :manager, @task]
-  #
-  # === Custom options
-  #
-  # <code>respond_with</code> also allows you to pass options that are forwarded
-  # to the underlying render call. Those options are only applied for success
-  # scenarios. For instance, you can do the following in the create method above:
-  #
-  #   def create
-  #     @project = Project.find(params[:project_id])
-  #     @task = @project.comments.build(params[:task])
-  #     flash[:notice] = 'Task was successfully created.' if @task.save
-  #     respond_with(@project, @task, :status => 201)
-  #   end
-  #
-  # This will return status 201 if the task was saved successfully. If not,
-  # it will simply ignore the given options and return status 422 and the
-  # resource errors. To customize the failure scenario, you can pass a
-  # a block to <code>respond_with</code>:
-  #
-  #   def create
-  #     @project = Project.find(params[:project_id])
-  #     @task = @project.comments.build(params[:task])
-  #     respond_with(@project, @task, :status => 201) do |format|
-  #       if @task.save
-  #         flash[:notice] = 'Task was successfully created.'
-  #       else
-  #         format.html { render "some_special_template" }
-  #       end
-  #     end
-  #   end
-  #
-  # Using <code>respond_with</code> with a block follows the same syntax as <code>respond_to</code>.
-  class Responder
-    attr_reader :controller, :request, :format, :resource, :resources, :options
-
-    ACTIONS_FOR_VERBS = {
-      :post => :new,
-      :put => :edit
-    }
-
-    def initialize(controller, resources, options={})
-      @controller = controller
-      @request = @controller.request
-      @format = @controller.formats.first
-      @resource = resources.last
-      @resources = resources
-      @options = options
-      @action = options.delete(:action)
-      @default_response = options.delete(:default_response)
-    end
-
-    delegate :head, :render, :redirect_to,   :to => :controller
-    delegate :get?, :post?, :put?, :delete?, :to => :request
-
-    # Undefine :to_json and :to_yaml since it's defined on Object
-    undef_method(:to_json) if method_defined?(:to_json)
-    undef_method(:to_yaml) if method_defined?(:to_yaml)
-
-    # Initializes a new responder an invoke the proper format. If the format is
-    # not defined, call to_format.
-    #
-    def self.call(*args)
-      new(*args).respond
-    end
-
-    # Main entry point for responder responsible to dispatch to the proper format.
-    #
-    def respond
-      method = "to_#{format}"
-      respond_to?(method) ? send(method) : to_format
-    end
-
-    # HTML format does not render the resource, it always attempt to render a
-    # template.
-    #
-    def to_html
-      default_render
-    rescue ActionView::MissingTemplate => e
-      navigation_behavior(e)
-    end
-
-    # to_js simply tries to render a template. If no template is found, raises the error.
-    def to_js
-      default_render
-    end
-
-    # All other formats follow the procedure below. First we try to render a
-    # template, if the template is not available, we verify if the resource
-    # responds to :to_format and display it.
-    #
-    def to_format
-      if get? || !has_errors? || response_overridden?
-        default_render
-      else
-        display_errors
-      end
-    rescue ActionView::MissingTemplate => e
-      api_behavior(e)
-    end
-
-  protected
-
-    # This is the common behavior for formats associated with browsing, like :html, :iphone and so forth.
-    def navigation_behavior(error)
-      if get?
-        raise error
-      elsif has_errors? && default_action
-        render :action => default_action
-      else
-        redirect_to navigation_location
-      end
-    end
-
-    # This is the common behavior for formats associated with APIs, such as :xml and :json.
-    def api_behavior(error)
-      raise error unless resourceful?
-
-      if get?
-        display resource
-      elsif post?
-        display resource, :status => :created, :location => api_location
-      else
-        head :no_content
-      end
-    end
-
-    # Checks whether the resource responds to the current format or not.
-    #
-    def resourceful?
-      resource.respond_to?("to_#{format}")
-    end
-
-    # Returns the resource location by retrieving it from the options or
-    # returning the resources array.
-    #
-    def resource_location
-      options[:location] || resources
-    end
-    alias :navigation_location :resource_location
-    alias :api_location :resource_location
-
-    # If a response block was given, use it, otherwise call render on
-    # controller.
-    #
-    def default_render
-      if @default_response
-        @default_response.call(options)
-      else
-        controller.default_render(options)
-      end
-    end
-
-    # Display is just a shortcut to render a resource with the current format.
-    #
-    #   display @user, :status => :ok
-    #
-    # For XML requests it's equivalent to:
-    #
-    #   render :xml => @user, :status => :ok
-    #
-    # Options sent by the user are also used:
-    #
-    #   respond_with(@user, :status => :created)
-    #   display(@user, :status => :ok)
-    #
-    # Results in:
-    #
-    #   render :xml => @user, :status => :created
-    #
-    def display(resource, given_options={})
-      controller.render given_options.merge!(options).merge!(format => resource)
-    end
-
-    def display_errors
-      controller.render format => resource_errors, :status => :unprocessable_entity
-    end
-
-    # Check whether the resource has errors.
-    #
-    def has_errors?
-      resource.respond_to?(:errors) && !resource.errors.empty?
-    end
-
-    # By default, render the <code>:edit</code> action for HTML requests with failure, unless
-    # the verb is POST.
-    #
-    def default_action
-      @action ||= ACTIONS_FOR_VERBS[request.request_method_symbol]
-    end
-
-    def resource_errors
-      respond_to?("#{format}_resource_errors", true) ? send("#{format}_resource_errors") : resource.errors
-    end
-
-    def json_resource_errors
-      {:errors => resource.errors}
-    end
-
-    def response_overridden?
-      @default_response.present?
-    end
-  end
-end

data/lib/action_controller/metal/session_management.rb

@@ -1,14 +0,0 @@
-module ActionController #:nodoc:
-  module SessionManagement #:nodoc:
-    extend ActiveSupport::Concern
-
-    included do
-      ActiveSupport::Deprecation.warn "ActionController::SessionManagement " \
-       "is deprecated because it has no contents since Rails 3.1", caller
-    end
-
-    module ClassMethods
-
-    end
-  end
-end

data/lib/action_controller/railties/paths.rb

@@ -1,25 +0,0 @@
-module ActionController
-  module Railties
-    module Paths
-      def self.with(app)
-        Module.new do
-          define_method(:inherited) do |klass|
-            super(klass)
-
-            if namespace = klass.parents.detect { |m| m.respond_to?(:railtie_helpers_paths) }
-              paths = namespace.railtie_helpers_paths
-            else
-              paths = app.helpers_paths
-            end
-
-            klass.helpers_path = paths
-
-            if klass.superclass == ActionController::Base && ActionController::Base.include_all_helpers
-              klass.helper :all
-            end
-          end
-        end
-      end
-    end
-  end
-end