actionpack 3.2.19 → 4.2.11.3

data/lib/action_dispatch/middleware/templates/rescues/routing_error.html.erb

@@ -0,0 +1,32 @@
+<header>
+  <h1>Routing Error</h1>
+</header>
+<div id="container">
+  <h2><%= h @exception.message %></h2>
+  <% unless @exception.failures.empty? %>
+    <p>
+      <h2>Failure reasons:</h2>
+      <ol>
+      <% @exception.failures.each do |route, reason| %>
+        <li><code><%= route.inspect.delete('\\') %></code> failed because <%= reason.downcase %></li>
+      <% end %>
+      </ol>
+    </p>
+  <% end %>
+
+  <%= render template: "rescues/_trace" %>
+
+  <% if @routes_inspector %>
+    <h2>
+      Routes
+    </h2>
+
+    <p>
+      Routes match in priority from top to bottom
+    </p>
+
+    <%= @routes_inspector.format(ActionDispatch::Routing::HtmlTableFormatter.new(self)) %>
+  <% end %>
+
+  <%= render template: "rescues/_request_and_response" %>
+</div>

data/lib/action_dispatch/middleware/templates/rescues/routing_error.text.erb

@@ -0,0 +1,11 @@
+Routing Error
+
+<%= @exception.message %>
+<% unless @exception.failures.empty? %>
+Failure reasons:
+<% @exception.failures.each do |route, reason| %>
+  - <%= route.inspect.delete('\\') %></code> failed because <%= reason.downcase %>
+<% end %>
+<% end %>
+
+<%= render template: "rescues/_trace", format: :text %>

data/lib/action_dispatch/middleware/templates/rescues/template_error.html.erb

@@ -0,0 +1,20 @@
+<header>
+  <h1>
+    <%= @exception.original_exception.class.to_s %> in
+    <%= @request.parameters["controller"].camelize if @request.parameters["controller"] %>#<%= @request.parameters["action"] %>
+  </h1>
+</header>
+
+<div id="container">
+  <p>
+    Showing <i><%= @exception.file_name %></i> where line <b>#<%= @exception.line_number %></b> raised:
+  </p>
+  <pre><code><%= h @exception.message %></code></pre>
+
+  <%= render template: "rescues/_source" %>
+
+  <p><%= @exception.sub_template_message %></p>
+
+  <%= render template: "rescues/_trace" %>
+  <%= render template: "rescues/_request_and_response" %>
+</div>

data/lib/action_dispatch/middleware/templates/rescues/template_error.text.erb

@@ -0,0 +1,7 @@
+<%= @exception.original_exception.class.to_s %> in <%= @request.parameters["controller"].camelize if @request.parameters["controller"] %>#<%= @request.parameters["action"] %>
+
+Showing <%= @exception.file_name %> where line #<%= @exception.line_number %> raised:
+<%= @exception.message %>
+<%= @exception.sub_template_message %>
+<%= render template: "rescues/_trace", format: :text %>
+<%= render template: "rescues/_request_and_response", format: :text %>

data/lib/action_dispatch/middleware/templates/rescues/unknown_action.html.erb

@@ -0,0 +1,6 @@
+<header>
+  <h1>Unknown action</h1>
+</header>
+<div id="container">
+  <h2><%= h @exception.message %></h2>
+</div>

data/lib/action_dispatch/middleware/templates/rescues/unknown_action.text.erb

@@ -0,0 +1,3 @@
+Unknown action
+
+<%= @exception.message %>

data/lib/action_dispatch/middleware/templates/routes/_route.html.erb

@@ -0,0 +1,16 @@
+<tr class='route_row' data-helper='path'>
+  <td data-route-name='<%= route[:name] %>'>
+    <% if route[:name].present? %>
+      <%= route[:name] %><span class='helper'>_path</span>
+    <% end %>
+  </td>
+  <td data-route-verb='<%= route[:verb] %>'>
+    <%= route[:verb] %>
+  </td>
+  <td data-route-path='<%= route[:path] %>' data-regexp='<%= route[:regexp] %>'>
+    <%= route[:path] %>
+  </td>
+  <td data-route-reqs='<%= route[:reqs] %>'>
+    <%= route[:reqs] %>
+  </td>
+</tr>

data/lib/action_dispatch/middleware/templates/routes/_table.html.erb

@@ -0,0 +1,200 @@
+<% content_for :style do %>
+  #route_table {
+    margin: 0;
+    border-collapse: collapse;
+  }
+
+  #route_table thead tr {
+    border-bottom: 2px solid #ddd;
+  }
+
+  #route_table thead tr.bottom {
+    border-bottom: none;
+  }
+
+  #route_table thead tr.bottom th {
+    padding: 10px 0;
+    line-height: 15px;
+  }
+
+  #route_table tbody tr {
+    border-bottom: 1px solid #ddd;
+  }
+
+  #route_table tbody tr:nth-child(odd) {
+    background: #f2f2f2;
+  }
+
+  #route_table tbody.exact_matches,
+  #route_table tbody.fuzzy_matches {
+    background-color: LightGoldenRodYellow;
+    border-bottom: solid 2px SlateGrey;
+  }
+
+  #route_table tbody.exact_matches tr,
+  #route_table tbody.fuzzy_matches tr {
+    background: none;
+    border-bottom: none;
+  }
+
+  #route_table td {
+    padding: 4px 30px;
+  }
+
+  #path_search {
+    width: 80%;
+    font-size: inherit;
+  }
+<% end %>
+
+<table id='route_table' class='route_table'>
+  <thead>
+    <tr>
+      <th>Helper</th>
+      <th>HTTP Verb</th>
+      <th>Path</th>
+      <th>Controller#Action</th>
+    </tr>
+    <tr class='bottom'>
+      <th><%# Helper %>
+        <%= link_to "Path", "#", 'data-route-helper' => '_path',
+                    title: "Returns a relative path (without the http or domain)" %> /
+        <%= link_to "Url", "#", 'data-route-helper' => '_url',
+                    title: "Returns an absolute url (with the http and domain)"   %>
+      </th>
+      <th><%# HTTP Verb %>
+      </th>
+      <th><%# Path %>
+        <%= search_field(:path, nil, id: 'search', placeholder: "Path Match") %>
+      </th>
+      <th><%# Controller#action %>
+      </th>
+    </tr>
+  </thead>
+  <tbody class='exact_matches' id='exact_matches'>
+  </tbody>
+  <tbody class='fuzzy_matches' id='fuzzy_matches'>
+  </tbody>
+  <tbody>
+    <%= yield %>
+  </tbody>
+</table>
+
+<script type='text/javascript'>
+  // Iterates each element through a function
+  function each(elems, func) {
+    if (!elems instanceof Array) { elems = [elems]; }
+    for (var i = 0, len = elems.length; i < len; i++) {
+      func(elems[i]);
+    }
+  }
+
+  // Sets innerHTML for an element
+  function setContent(elem, text) {
+    elem.innerHTML = text;
+  }
+
+  // Enables path search functionality
+  function setupMatchPaths() {
+    // Check if the user input (sanitized as a path) matches the regexp data attribute
+    function checkExactMatch(section, elem, value) {
+      var string = sanitizePath(value),
+          regexp = elem.getAttribute("data-regexp");
+
+      showMatch(string, regexp, section, elem);
+    }
+
+    // Check if the route path data attribute contains the user input
+    function checkFuzzyMatch(section, elem, value) {
+      var string = elem.getAttribute("data-route-path"),
+          regexp = value;
+
+      showMatch(string, regexp, section, elem);
+    }
+
+    // Display the parent <tr> element in the appropriate section when there's a match
+    function showMatch(string, regexp, section, elem) {
+      if(string.match(RegExp(regexp))) {
+        section.appendChild(elem.parentNode.cloneNode(true));
+      }
+    }
+
+    // Check if there are any matched results in a section
+    function checkNoMatch(section, defaultText, noMatchText) {
+      if (section.innerHTML === defaultText) {
+        setContent(section, defaultText + noMatchText);
+      }
+    }
+
+    // Ensure path always starts with a slash "/" and remove params or fragments
+    function sanitizePath(path) {
+      var path = path.charAt(0) == '/' ? path : "/" + path;
+      return path.replace(/\#.*|\?.*/, '');
+    }
+
+    var regexpElems     = document.querySelectorAll('#route_table [data-regexp]'),
+        searchElem      = document.querySelector('#search'),
+        exactMatches    = document.querySelector('#exact_matches'),
+        fuzzyMatches    = document.querySelector('#fuzzy_matches');
+
+    // Remove matches when no search value is present
+    searchElem.onblur = function(e) {
+      if (searchElem.value === "") {
+        setContent(exactMatches, "");
+        setContent(fuzzyMatches, "");
+      }
+    }
+
+    // On key press perform a search for matching paths
+    searchElem.onkeyup = function(e){
+      var userInput         = searchElem.value,
+          defaultExactMatch = '<tr><th colspan="4">Paths Matching (' + escape(sanitizePath(userInput)) +'):</th></tr>',
+          defaultFuzzyMatch = '<tr><th colspan="4">Paths Containing (' + escape(userInput) +'):</th></tr>',
+          noExactMatch      = '<tr><th colspan="4">No Exact Matches Found</th></tr>',
+          noFuzzyMatch      = '<tr><th colspan="4">No Fuzzy Matches Found</th></tr>';
+
+      // Clear out results section
+      setContent(exactMatches, defaultExactMatch);
+      setContent(fuzzyMatches, defaultFuzzyMatch);
+
+      // Display exact matches and fuzzy matches
+      each(regexpElems, function(elem) {
+        checkExactMatch(exactMatches, elem, userInput);
+        checkFuzzyMatch(fuzzyMatches, elem, userInput);
+      })
+
+      // Display 'No Matches' message when no matches are found
+      checkNoMatch(exactMatches, defaultExactMatch, noExactMatch);
+      checkNoMatch(fuzzyMatches, defaultFuzzyMatch, noFuzzyMatch);
+    }
+  }
+
+  // Enables functionality to toggle between `_path` and `_url` helper suffixes
+  function setupRouteToggleHelperLinks() {
+
+    // Sets content for each element
+    function setValOn(elems, val) {
+      each(elems, function(elem) {
+        setContent(elem, val);
+      });
+    }
+
+    // Sets onClick event for each element
+    function onClick(elems, func) {
+      each(elems, function(elem) {
+        elem.onclick = func;
+      });
+    }
+
+    var toggleLinks = document.querySelectorAll('#route_table [data-route-helper]');
+    onClick(toggleLinks, function(){
+      var helperTxt   = this.getAttribute("data-route-helper"),
+          helperElems = document.querySelectorAll('[data-route-name] span.helper');
+
+      setValOn(helperElems, helperTxt);
+    });
+  }
+
+  setupMatchPaths();
+  setupRouteToggleHelperLinks();
+</script>

data/lib/action_dispatch/railtie.rb

@@ -1,34 +1,47 @@
 require "action_dispatch"
 
 module ActionDispatch
-  class Railtie < Rails::Railtie
+  class Railtie < Rails::Railtie # :nodoc:
     config.action_dispatch = ActiveSupport::OrderedOptions.new
     config.action_dispatch.x_sendfile_header = nil
     config.action_dispatch.ip_spoofing_check = true
     config.action_dispatch.show_exceptions = true
-    config.action_dispatch.best_standards_support = true
     config.action_dispatch.tld_length = 1
     config.action_dispatch.ignore_accept_header = false
     config.action_dispatch.rescue_templates = { }
     config.action_dispatch.rescue_responses = { }
     config.action_dispatch.default_charset = nil
+    config.action_dispatch.rack_cache = false
+    config.action_dispatch.http_auth_salt = 'http authentication'
+    config.action_dispatch.signed_cookie_salt = 'signed cookie'
+    config.action_dispatch.encrypted_cookie_salt = 'encrypted cookie'
+    config.action_dispatch.encrypted_signed_cookie_salt = 'signed encrypted cookie'
+    config.action_dispatch.perform_deep_munge = true
 
-    config.action_dispatch.rack_cache = {
-      :metastore => "rails:/",
-      :entitystore => "rails:/",
-      :verbose => false
+    config.action_dispatch.default_headers = {
+      'X-Frame-Options' => 'SAMEORIGIN',
+      'X-XSS-Protection' => '1; mode=block',
+      'X-Content-Type-Options' => 'nosniff'
     }
 
+    config.eager_load_namespaces << ActionDispatch
+
     initializer "action_dispatch.configure" do |app|
       ActionDispatch::Http::URL.tld_length = app.config.action_dispatch.tld_length
       ActionDispatch::Request.ignore_accept_header = app.config.action_dispatch.ignore_accept_header
+      ActionDispatch::Request::Utils.perform_deep_munge = app.config.action_dispatch.perform_deep_munge
       ActionDispatch::Response.default_charset = app.config.action_dispatch.default_charset || app.config.encoding
+      ActionDispatch::Response.default_headers = app.config.action_dispatch.default_headers
 
       ActionDispatch::ExceptionWrapper.rescue_responses.merge!(config.action_dispatch.rescue_responses)
       ActionDispatch::ExceptionWrapper.rescue_templates.merge!(config.action_dispatch.rescue_templates)
 
       config.action_dispatch.always_write_cookie = Rails.env.development? if config.action_dispatch.always_write_cookie.nil?
       ActionDispatch::Cookies::CookieJar.always_write_cookie = config.action_dispatch.always_write_cookie
+
+      ActionDispatch.test_app = app
+
+      ActionDispatch::Routing::RouteSet.relative_url_root = app.config.relative_url_root
     end
   end
 end

data/lib/action_dispatch/request/session.rb

@@ -0,0 +1,193 @@
+require 'rack/session/abstract/id'
+
+module ActionDispatch
+  class Request < Rack::Request
+    # Session is responsible for lazily loading the session from store.
+    class Session # :nodoc:
+      ENV_SESSION_KEY         = Rack::Session::Abstract::ENV_SESSION_KEY # :nodoc:
+      ENV_SESSION_OPTIONS_KEY = Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY # :nodoc:
+
+      # Singleton object used to determine if an optional param wasn't specified
+      Unspecified = Object.new
+
+      def self.create(store, env, default_options)
+        session_was = find env
+        session     = Request::Session.new(store, env)
+        session.merge! session_was if session_was
+
+        set(env, session)
+        Options.set(env, Request::Session::Options.new(store, env, default_options))
+        session
+      end
+
+      def self.find(env)
+        env[ENV_SESSION_KEY]
+      end
+
+      def self.set(env, session)
+        env[ENV_SESSION_KEY] = session
+      end
+
+      class Options #:nodoc:
+        def self.set(env, options)
+          env[ENV_SESSION_OPTIONS_KEY] = options
+        end
+
+        def self.find(env)
+          env[ENV_SESSION_OPTIONS_KEY]
+        end
+
+        def initialize(by, env, default_options)
+          @by       = by
+          @env      = env
+          @delegate = default_options.dup
+        end
+
+        def [](key)
+          if key == :id
+            @delegate.fetch(key) {
+              @delegate[:id] = @by.send(:extract_session_id, @env)
+            }
+          else
+            @delegate[key]
+          end
+        end
+
+        def []=(k,v);         @delegate[k] = v; end
+        def to_hash;          @delegate.dup; end
+        def values_at(*args); @delegate.values_at(*args); end
+      end
+
+      def initialize(by, env)
+        @by       = by
+        @env      = env
+        @delegate = {}
+        @loaded   = false
+        @exists   = nil # we haven't checked yet
+      end
+
+      def id
+        options[:id]
+      end
+
+      def options
+        Options.find @env
+      end
+
+      def destroy
+        clear
+        options = self.options || {}
+        new_sid = @by.send(:destroy_session, @env, options[:id], options)
+        options[:id] = new_sid # Reset session id with a new value or nil
+
+        # Load the new sid to be written with the response
+        @loaded = false
+        load_for_write!
+      end
+
+      def [](key)
+        load_for_read!
+        @delegate[key.to_s]
+      end
+
+      def has_key?(key)
+        load_for_read!
+        @delegate.key?(key.to_s)
+      end
+      alias :key? :has_key?
+      alias :include? :has_key?
+
+      def keys
+        @delegate.keys
+      end
+
+      def values
+        @delegate.values
+      end
+
+      def []=(key, value)
+        load_for_write!
+        @delegate[key.to_s] = value
+      end
+
+      def clear
+        load_for_write!
+        @delegate.clear
+      end
+
+      def to_hash
+        load_for_read!
+        @delegate.dup.delete_if { |_,v| v.nil? }
+      end
+
+      def update(hash)
+        load_for_write!
+        @delegate.update stringify_keys(hash)
+      end
+
+      def delete(key)
+        load_for_write!
+        @delegate.delete key.to_s
+      end
+
+      def fetch(key, default=Unspecified, &block)
+        load_for_read!
+        if default == Unspecified
+          @delegate.fetch(key.to_s, &block)
+        else
+          @delegate.fetch(key.to_s, default, &block)
+        end
+      end
+
+      def inspect
+        if loaded?
+          super
+        else
+          "#<#{self.class}:0x#{(object_id << 1).to_s(16)} not yet loaded>"
+        end
+      end
+
+      def exists?
+        return @exists unless @exists.nil?
+        @exists = @by.send(:session_exists?, @env)
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def empty?
+        load_for_read!
+        @delegate.empty?
+      end
+
+      def merge!(other)
+        load_for_write!
+        @delegate.merge!(other)
+      end
+
+      private
+
+      def load_for_read!
+        load! if !loaded? && exists?
+      end
+
+      def load_for_write!
+        load! unless loaded?
+      end
+
+      def load!
+        id, session = @by.load_session @env
+        options[:id] = id
+        @delegate.replace(stringify_keys(session))
+        @loaded = true
+      end
+
+      def stringify_keys(other)
+        other.each_with_object({}) { |(key, value), hash|
+          hash[key.to_s] = value
+        }
+      end
+    end
+  end
+end

data/lib/action_dispatch/request/utils.rb

@@ -0,0 +1,35 @@
+module ActionDispatch
+  class Request < Rack::Request
+    class Utils # :nodoc:
+
+      mattr_accessor :perform_deep_munge
+      self.perform_deep_munge = true
+
+      class << self
+        # Remove nils from the params hash
+        def deep_munge(hash, keys = [])
+          return hash unless perform_deep_munge
+
+          hash.each do |k, v|
+            keys << k
+            case v
+            when Array
+              v.grep(Hash) { |x| deep_munge(x, keys) }
+              v.compact!
+              if v.empty?
+                hash[k] = nil
+                ActiveSupport::Notifications.instrument("deep_munge.action_controller", keys: keys)
+              end
+            when Hash
+              deep_munge(v, keys)
+            end
+            keys.pop
+          end
+
+          hash
+        end
+      end
+    end
+  end
+end
+

data/lib/action_dispatch/routing/endpoint.rb

@@ -0,0 +1,10 @@
+module ActionDispatch
+  module Routing
+    class Endpoint # :nodoc:
+      def dispatcher?;   false; end
+      def redirect?;     false; end
+      def matches?(req); true;  end
+      def app;           self;  end
+    end
+  end
+end