actionpack 4.0.1 → 4.2.11.1

data/lib/action_dispatch/journey/router/utils.rb

@@ -1,5 +1,3 @@
-require 'uri'
-
 module ActionDispatch
   module Journey # :nodoc:
     class Router # :nodoc:
@@ -15,7 +13,7 @@ module ActionDispatch
         #   normalize_path("")      # => "/"
         #   normalize_path("/%ab")  # => "/%AB"
         def self.normalize_path(path)
-          path = "/#{path}"
+          path = "/#{path}".force_encoding(Encoding::UTF_8)
           path.squeeze!('/')
           path.sub!(%r{/+\Z}, '')
           path.gsub!(/(%[a-f0-9]{2})/) { $1.upcase }
@@ -25,31 +23,69 @@ module ActionDispatch
 
         # URI path and fragment escaping
         # http://tools.ietf.org/html/rfc3986
-        module UriEscape # :nodoc:
-          # Symbol captures can generate multiple path segments, so include /.
-          reserved_segment  = '/'
-          reserved_fragment = '/?'
-          reserved_pchar    = ':@&=+$,;%'
-
-          safe_pchar    = "#{URI::REGEXP::PATTERN::UNRESERVED}#{reserved_pchar}"
-          safe_segment  = "#{safe_pchar}#{reserved_segment}"
-          safe_fragment = "#{safe_pchar}#{reserved_fragment}"
-          UNSAFE_SEGMENT  = Regexp.new("[^#{safe_segment}]", false).freeze
-          UNSAFE_FRAGMENT = Regexp.new("[^#{safe_fragment}]", false).freeze
+        class UriEncoder # :nodoc:
+          ENCODE   = "%%%02X".freeze
+          US_ASCII = Encoding::US_ASCII
+          UTF_8    = Encoding::UTF_8
+          EMPTY    = "".force_encoding(US_ASCII).freeze
+          DEC2HEX  = (0..255).to_a.map{ |i| ENCODE % i }.map{ |s| s.force_encoding(US_ASCII) }
+
+          ALPHA = "a-zA-Z".freeze
+          DIGIT = "0-9".freeze
+          UNRESERVED = "#{ALPHA}#{DIGIT}\\-\\._~".freeze
+          SUB_DELIMS = "!\\$&'\\(\\)\\*\\+,;=".freeze
+
+          ESCAPED  = /%[a-zA-Z0-9]{2}/.freeze
+
+          FRAGMENT = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/\?]/.freeze
+          SEGMENT  = /[^#{UNRESERVED}#{SUB_DELIMS}:@]/.freeze
+          PATH     = /[^#{UNRESERVED}#{SUB_DELIMS}:@\/]/.freeze
+
+          def escape_fragment(fragment)
+            escape(fragment, FRAGMENT)
+          end
+
+          def escape_path(path)
+            escape(path, PATH)
+          end
+
+          def escape_segment(segment)
+            escape(segment, SEGMENT)
+          end
+
+          def unescape_uri(uri)
+            encoding = uri.encoding == US_ASCII ? UTF_8 : uri.encoding
+            uri.gsub(ESCAPED) { [$&[1, 2].hex].pack('C') }.force_encoding(encoding)
+          end
+
+          protected
+            def escape(component, pattern)
+              component.gsub(pattern){ |unsafe| percent_encode(unsafe) }.force_encoding(US_ASCII)
+            end
+
+            def percent_encode(unsafe)
+              safe = EMPTY.dup
+              unsafe.each_byte { |b| safe << DEC2HEX[b] }
+              safe
+            end
         end
 
-        Parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+        ENCODER = UriEncoder.new
 
         def self.escape_path(path)
-          Parser.escape(path.to_s, UriEscape::UNSAFE_SEGMENT)
+          ENCODER.escape_path(path.to_s)
+        end
+
+        def self.escape_segment(segment)
+          ENCODER.escape_segment(segment.to_s)
         end
 
         def self.escape_fragment(fragment)
-          Parser.escape(fragment.to_s, UriEscape::UNSAFE_FRAGMENT)
+          ENCODER.escape_fragment(fragment.to_s)
         end
 
         def self.unescape_uri(uri)
-          Parser.unescape(uri)
+          ENCODER.unescape_uri(uri)
         end
       end
     end

data/lib/action_dispatch/journey/router.rb

@@ -20,60 +20,32 @@ module ActionDispatch
       # :nodoc:
       VERSION = '2.0.0'
 
-      class NullReq # :nodoc:
-        attr_reader :env
-        def initialize(env)
-          @env = env
-        end
-
-        def request_method
-          env['REQUEST_METHOD']
-        end
-
-        def path_info
-          env['PATH_INFO']
-        end
-
-        def ip
-          env['REMOTE_ADDR']
-        end
-
-        def [](k)
-          env[k]
-        end
-      end
-
-      attr_reader :request_class, :formatter
       attr_accessor :routes
 
-      def initialize(routes, options)
-        @options       = options
-        @params_key    = options[:parameters_key]
-        @request_class = options[:request_class] || NullReq
-        @routes        = routes
+      def initialize(routes)
+        @routes = routes
       end
 
-      def call(env)
-        env['PATH_INFO'] = Utils.normalize_path(env['PATH_INFO'])
-
-        find_routes(env).each do |match, parameters, route|
-          script_name, path_info, set_params = env.values_at('SCRIPT_NAME',
-                                                             'PATH_INFO',
-                                                             @params_key)
+      def serve(req)
+        find_routes(req).each do |match, parameters, route|
+          set_params  = req.path_parameters
+          path_info   = req.path_info
+          script_name = req.script_name
 
           unless route.path.anchored
-            env['SCRIPT_NAME'] = (script_name.to_s + match.to_s).chomp('/')
-            env['PATH_INFO']   = match.post_match
+            req.script_name = (script_name.to_s + match.to_s).chomp('/')
+            req.path_info = match.post_match
+            req.path_info = "/" + req.path_info unless req.path_info.start_with? "/"
           end
 
-          env[@params_key] = (set_params || {}).merge parameters
+          req.path_parameters = set_params.merge parameters
 
-          status, headers, body = route.app.call(env)
+          status, headers, body = route.app.serve(req)
 
           if 'pass' == headers['X-Cascade']
-            env['SCRIPT_NAME'] = script_name
-            env['PATH_INFO']   = path_info
-            env[@params_key]   = set_params
+            req.script_name     = script_name
+            req.path_info       = path_info
+            req.path_parameters = set_params
             next
           end
 
@@ -83,14 +55,14 @@ module ActionDispatch
         return [404, {'X-Cascade' => 'pass'}, ['Not Found']]
       end
 
-      def recognize(req)
-        find_routes(req.env).each do |match, parameters, route|
+      def recognize(rails_req)
+        find_routes(rails_req).each do |match, parameters, route|
           unless route.path.anchored
-            req.env['SCRIPT_NAME'] = match.to_s
-            req.env['PATH_INFO']   = match.post_match.sub(/^([^\/])/, '/\1')
+            rails_req.script_name = match.to_s
+            rails_req.path_info   = match.post_match.sub(/^([^\/])/, '/\1')
           end
 
-          yield(route, nil, parameters)
+          yield(route, parameters)
         end
       end
 
@@ -121,45 +93,51 @@ module ActionDispatch
 
         def filter_routes(path)
           return [] unless ast
-          data = simulator.match(path)
-          data ? data.memos : []
+          simulator.memos(path) { [] }
         end
 
-        def find_routes env
-          req = request_class.new(env)
-
+        def find_routes req
           routes = filter_routes(req.path_info).concat custom_routes.find_all { |r|
             r.path.match(req.path_info)
           }
-          routes.concat get_routes_as_head(routes)
 
-          routes.sort_by!(&:precedence).select! { |r| r.matches?(req) }
+          routes =
+            if req.request_method == "HEAD"
+              match_head_routes(routes, req)
+            else
+              match_routes(routes, req)
+            end
+
+          routes.sort_by!(&:precedence)
 
           routes.map! { |r|
             match_data  = r.path.match(req.path_info)
-            match_names = match_data.names.map { |n| n.to_sym }
-            match_values = match_data.captures.map { |v| v && Utils.unescape_uri(v) }
-            info = Hash[match_names.zip(match_values).find_all { |_, y| y }]
-
-            [match_data, r.defaults.merge(info), r]
+            path_parameters = r.defaults.dup
+            match_data.names.zip(match_data.captures) { |name,val|
+              path_parameters[name.to_sym] = Utils.unescape_uri(val) if val
+            }
+            [match_data, path_parameters, r]
           }
         end
 
-        def get_routes_as_head(routes)
-          precedence = (routes.map(&:precedence).max || 0) + 1
-          routes = routes.select { |r|
-            r.verb === "GET" && !(r.verb === "HEAD")
-          }.map! { |r|
-            Route.new(r.name,
-                      r.app,
-                      r.path,
-                      r.conditions.merge(request_method: "HEAD"),
-                      r.defaults).tap do |route|
-                        route.precedence = r.precedence + precedence
-                      end
-          }
-          routes.flatten!
-          routes
+        def match_head_routes(routes, req)
+          verb_specific_routes = routes.reject { |route| route.verb == // }
+          head_routes = match_routes(verb_specific_routes, req)
+
+          if head_routes.empty?
+            begin
+              req.request_method = "GET"
+              match_routes(routes, req)
+            ensure
+              req.request_method = "HEAD"
+            end
+          else
+            head_routes
+          end
+        end
+
+        def match_routes(routes, req)
+          routes.select { |r| r.matches?(req) }
         end
     end
   end

data/lib/action_dispatch/journey/routes.rb

@@ -15,6 +15,10 @@ module ActionDispatch
         @simulator          = nil
       end
 
+      def empty?
+        routes.empty?
+      end
+
       def length
         routes.length
       end

data/lib/action_dispatch/journey/scanner.rb

@@ -39,18 +39,18 @@ module ActionDispatch
             [:SLASH, text]
           when text = @ss.scan(/\*\w+/)
             [:STAR, text]
-          when text = @ss.scan(/\(/)
+          when text = @ss.scan(/(?<!\\)\(/)
             [:LPAREN, text]
-          when text = @ss.scan(/\)/)
+          when text = @ss.scan(/(?<!\\)\)/)
             [:RPAREN, text]
           when text = @ss.scan(/\|/)
             [:OR, text]
           when text = @ss.scan(/\./)
             [:DOT, text]
-          when text = @ss.scan(/:\w+/)
+          when text = @ss.scan(/(?<!\\):\w+/)
             [:SYMBOL, text]
-          when text = @ss.scan(/[\w%\-~]+/)
-            [:LITERAL, text]
+          when text = @ss.scan(/(?:[\w%\-~!$&'*+,;=@]|\\:|\\\(|\\\))+/)
+            [:LITERAL, text.tr('\\', '')]
             # any char
           when text = @ss.scan(/./)
             [:LITERAL, text]

data/lib/action_dispatch/journey/visitors.rb

@@ -1,14 +1,57 @@
 # encoding: utf-8
 
-require 'thread_safe'
-
 module ActionDispatch
   module Journey # :nodoc:
+    class Format
+      ESCAPE_PATH    = ->(value) { Router::Utils.escape_path(value) }
+      ESCAPE_SEGMENT = ->(value) { Router::Utils.escape_segment(value) }
+
+      class Parameter < Struct.new(:name, :escaper)
+        def escape(value); escaper.call value; end
+      end
+
+      def self.required_path(symbol)
+        Parameter.new symbol, ESCAPE_PATH
+      end
+
+      def self.required_segment(symbol)
+        Parameter.new symbol, ESCAPE_SEGMENT
+      end
+
+      def initialize(parts)
+        @parts      = parts
+        @children   = []
+        @parameters = []
+
+        parts.each_with_index do |object,i|
+          case object
+          when Journey::Format
+            @children << i
+          when Parameter
+            @parameters << i
+          end
+        end
+      end
+
+      def evaluate(hash)
+        parts = @parts.dup
+
+        @parameters.each do |index|
+          param = parts[index]
+          value = hash[param.name]
+          return ''.freeze unless value
+          parts[index] = param.escape value
+        end
+
+        @children.each { |index| parts[index] = parts[index].evaluate(hash) }
+
+        parts.join
+      end
+    end
+
     module Visitors # :nodoc:
       class Visitor # :nodoc:
-        DISPATCH_CACHE = ThreadSafe::Cache.new { |h,k|
-          h[k] = :"visit_#{k}"
-        }
+        DISPATCH_CACHE = {}
 
         def accept(node)
           visit(node)
@@ -38,9 +81,39 @@ module ActionDispatch
           def visit_STAR(n); unary(n); end
 
           def terminal(node); end
-          %w{ LITERAL SYMBOL SLASH DOT }.each do |t|
-            class_eval %{ def visit_#{t}(n); terminal(n); end }, __FILE__, __LINE__
+          def visit_LITERAL(n); terminal(n); end
+          def visit_SYMBOL(n);  terminal(n); end
+          def visit_SLASH(n);   terminal(n); end
+          def visit_DOT(n);     terminal(n); end
+
+          private_instance_methods(false).each do |pim|
+            next unless pim =~ /^visit_(.*)$/
+            DISPATCH_CACHE[$1.to_sym] = pim
+          end
+      end
+
+      class FormatBuilder < Visitor # :nodoc:
+        def accept(node); Journey::Format.new(super); end
+        def terminal(node); [node.left]; end
+
+        def binary(node)
+          visit(node.left) + visit(node.right)
+        end
+
+        def visit_GROUP(n); [Journey::Format.new(unary(n))]; end
+
+        def visit_STAR(n)
+          [Journey::Format.required_path(n.left.to_sym)]
+        end
+
+        def visit_SYMBOL(n)
+          symbol = n.to_sym
+          if symbol == :controller
+            [Journey::Format.required_path(symbol)]
+          else
+            [Journey::Format.required_segment(symbol)]
           end
+        end
       end
 
       # Loop through the requirements AST
@@ -52,8 +125,8 @@ module ActionDispatch
         end
 
         def visit(node)
-          super
           block.call(node)
+          super
         end
       end
 
@@ -77,58 +150,6 @@ module ActionDispatch
         end
       end
 
-      class OptimizedPath < String # :nodoc:
-        private
-
-        def visit_GROUP(node)
-          ""
-        end
-      end
-
-      # Used for formatting urls (url_for)
-      class Formatter < Visitor # :nodoc:
-        attr_reader :options, :consumed
-
-        def initialize(options)
-          @options  = options
-          @consumed = {}
-        end
-
-        private
-
-          def visit_GROUP(node)
-            if consumed == options
-              nil
-            else
-              route = visit(node.left)
-              route.include?("\0") ? nil : route
-            end
-          end
-
-          def terminal(node)
-            node.left
-          end
-
-          def binary(node)
-            [visit(node.left), visit(node.right)].join
-          end
-
-          def nary(node)
-            node.children.map { |c| visit(c) }.join
-          end
-
-          def visit_SYMBOL(node)
-            key = node.to_sym
-
-            if value = options[key]
-              consumed[key] = value
-              Router::Utils.escape_path(value)
-            else
-              "\0"
-            end
-          end
-      end
-
       class Dot < Visitor # :nodoc:
         def initialize
           @nodes = []

data/lib/action_dispatch/journey/visualizer/fsm.css

@@ -16,10 +16,6 @@ h2 {
   font-size: 0.5em;
 }
 
-div#chart-2 {
-  height: 350px;
-}
-
 .clearfix {display: inline-block; }
 .input { overflow: show;}
 .instruction { color: #666; padding: 0 30px 20px; font-size: 0.9em}

data/lib/action_dispatch/journey/visualizer/index.html.erb

@@ -2,13 +2,13 @@
 <html>
   <head>
     <title><%= title %></title>
-    <link rel="stylesheet" href="https://raw.github.com/gist/1706081/af944401f75ea20515a02ddb3fb43d23ecb8c662/reset.css" type="text/css">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/meyer-reset/2.0/reset.css" type="text/css">
     <style>
       <% stylesheets.each do |style| %>
         <%= style %>
       <% end %>
     </style>
-    <script src="https://raw.github.com/gist/1706081/df464722a05c3c2bec450b7b5c8240d9c31fa52d/d3.min.js" type="text/javascript"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/d3/3.4.8/d3.min.js" type="text/javascript"></script>
   </head>
   <body>
     <div id="wrapper">

data/lib/action_dispatch/middleware/callbacks.rb

@@ -1,6 +1,6 @@
 
 module ActionDispatch
-  # Provide callbacks to be executed before and after the request dispatch.
+  # Provides callbacks to be executed before and after dispatching the request.
   class Callbacks
     include ActiveSupport::Callbacks
 
@@ -8,14 +8,14 @@ module ActionDispatch
 
     class << self
       delegate :to_prepare, :to_cleanup, :to => "ActionDispatch::Reloader"
-    end
 
-    def self.before(*args, &block)
-      set_callback(:call, :before, *args, &block)
-    end
+      def before(*args, &block)
+        set_callback(:call, :before, *args, &block)
+      end
 
-    def self.after(*args, &block)
-      set_callback(:call, :after, *args, &block)
+      def after(*args, &block)
+        set_callback(:call, :after, *args, &block)
+      end
     end
 
     def initialize(app)