actionpack 3.2.22.5 → 5.2.4

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/middleware.rb

@@ -1,39 +0,0 @@
-module ActionController
-  class Middleware < Metal
-    class ActionMiddleware
-      def initialize(controller, app)
-        @controller, @app = controller, app
-      end
-
-      def call(env)
-        request = ActionDispatch::Request.new(env)
-        @controller.build(@app).dispatch(:index, request)
-      end
-    end
-
-    class << self
-      alias build new
-
-      def new(app)
-        ActionMiddleware.new(self, app)
-      end
-    end
-
-    attr_internal :app
-
-    def process(action)
-      response = super
-      self.status, self.headers, self.response_body = response if response.is_a?(Array)
-      response
-    end
-
-    def initialize(app)
-      super()
-      @_app = app
-    end
-
-    def index
-      call(env)
-    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

data/lib/action_controller/record_identifier.rb

@@ -1,85 +0,0 @@
-require 'active_support/core_ext/module'
-
-module ActionController
-  # The record identifier encapsulates a number of naming conventions for dealing with records, like Active Records or
-  # Active Resources or pretty much any other model type that has an id. These patterns are then used to try elevate
-  # the view actions to a higher logical level. Example:
-  #
-  #   # routes
-  #   resources :posts
-  #
-  #   # view
-  #   <%= div_for(post) do %>    <div id="post_45" class="post">
-  #     <%= post.body %>           What a wonderful world!
-  #   <% end %>                  </div>
-  #
-  #   # controller
-  #   def update
-  #     post = Post.find(params[:id])
-  #     post.update_attributes(params[:post])
-  #
-  #     redirect_to(post) # Calls polymorphic_url(post) which in turn calls post_url(post)
-  #   end
-  #
-  # As the example above shows, you can stop caring to a large extent what the actual id of the post is.
-  # You just know that one is being assigned and that the subsequent calls in redirect_to expect that
-  # same naming convention and allows you to write less code if you follow it.
-  module RecordIdentifier
-    extend self
-
-    JOIN = '_'.freeze
-    NEW = 'new'.freeze
-
-    # The DOM class convention is to use the singular form of an object or class. Examples:
-    #
-    #   dom_class(post)   # => "post"
-    #   dom_class(Person) # => "person"
-    #
-    # If you need to address multiple instances of the same class in the same view, you can prefix the dom_class:
-    #
-    #   dom_class(post, :edit)   # => "edit_post"
-    #   dom_class(Person, :edit) # => "edit_person"
-    def dom_class(record_or_class, prefix = nil)
-      singular = ActiveModel::Naming.param_key(record_or_class)
-      prefix ? "#{prefix}#{JOIN}#{singular}" : singular
-    end
-
-    # The DOM id convention is to use the singular form of an object or class with the id following an underscore.
-    # If no id is found, prefix with "new_" instead. Examples:
-    #
-    #   dom_id(Post.find(45))       # => "post_45"
-    #   dom_id(Post.new)            # => "new_post"
-    #
-    # If you need to address multiple instances of the same class in the same view, you can prefix the dom_id:
-    #
-    #   dom_id(Post.find(45), :edit) # => "edit_post_45"
-    def dom_id(record, prefix = nil)
-      if record_id = record_key_for_dom_id(record)
-        "#{dom_class(record, prefix)}#{JOIN}#{record_id}"
-      else
-        dom_class(record, prefix || NEW)
-      end
-    end
-
-  protected
-
-    # Returns a string representation of the key attribute(s) that is suitable for use in an HTML DOM id.
-    # This can be overwritten to customize the default generated string representation if desired.
-    # If you need to read back a key from a dom_id in order to query for the underlying database record,
-    # you should write a helper like 'person_record_from_dom_id' that will extract the key either based
-    # on the default implementation (which just joins all key attributes with '_') or on your own
-    # overwritten version of the method. By default, this implementation passes the key string through a
-    # method that replaces all characters that are invalid inside DOM ids, with valid ones. You need to
-    # make sure yourself that your dom ids are valid, in case you overwrite this method.
-    def record_key_for_dom_id(record)
-      record = record.to_model if record.respond_to?(:to_model)
-      key = record.to_key
-      key ? sanitize_dom_id(key.join('_')) : key
-    end
-
-    # Replaces characters that are invalid in HTML DOM ids with valid ones.
-    def sanitize_dom_id(candidate_id)
-      candidate_id # TODO implement conversion to valid DOM id values
-    end
-  end
-end

data/lib/action_controller/vendor/html-scanner/html/document.rb

@@ -1,68 +0,0 @@
-require 'html/tokenizer'
-require 'html/node'
-require 'html/selector'
-require 'html/sanitizer'
-
-module HTML #:nodoc:
-  # A top-level HTML document. You give it a body of text, and it will parse that
-  # text into a tree of nodes.
-  class Document #:nodoc:
-
-    # The root of the parsed document.
-    attr_reader :root
-
-    # Create a new Document from the given text.
-    def initialize(text, strict=false, xml=false)
-      tokenizer = Tokenizer.new(text)
-      @root = Node.new(nil)
-      node_stack = [ @root ]
-      while token = tokenizer.next
-        node = Node.parse(node_stack.last, tokenizer.line, tokenizer.position, token, strict)
-
-        node_stack.last.children << node unless node.tag? && node.closing == :close
-        if node.tag?
-          if node_stack.length > 1 && node.closing == :close
-            if node_stack.last.name == node.name
-              if node_stack.last.children.empty?
-                node_stack.last.children << Text.new(node_stack.last, node.line, node.position, "")
-              end
-              node_stack.pop
-            else
-              open_start = node_stack.last.position - 20
-              open_start = 0 if open_start < 0
-              close_start = node.position - 20
-              close_start = 0 if close_start < 0
-              msg = <<EOF.strip
-ignoring attempt to close #{node_stack.last.name} with #{node.name}
-  opened at byte #{node_stack.last.position}, line #{node_stack.last.line}
-  closed at byte #{node.position}, line #{node.line}
-  attributes at open: #{node_stack.last.attributes.inspect}
-  text around open: #{text[open_start,40].inspect}
-  text around close: #{text[close_start,40].inspect}
-EOF
-              strict ? raise(msg) : warn(msg)
-            end
-          elsif !node.childless?(xml) && node.closing != :close
-            node_stack.push node
-          end
-        end
-      end
-    end
-
-    # Search the tree for (and return) the first node that matches the given
-    # conditions. The conditions are interpreted differently for different node
-    # types, see HTML::Text#find and HTML::Tag#find.
-    def find(conditions)
-      @root.find(conditions)
-    end
-
-    # Search the tree for (and return) all nodes that match the given
-    # conditions. The conditions are interpreted differently for different node
-    # types, see HTML::Text#find and HTML::Tag#find.
-    def find_all(conditions)
-      @root.find_all(conditions)
-    end
-
-  end
-
-end