actionpack 4.1.16 → 4.2.0.beta1

data/lib/action_dispatch/journey/parser.y

@@ -1,11 +1,11 @@
 class ActionDispatch::Journey::Parser
-
+  options no_result_var
 token SLASH LITERAL SYMBOL LPAREN RPAREN DOT STAR OR
 
 rule
   expressions
-    : expressions expression  { result = Cat.new(val.first, val.last) }
-    | expression              { result = val.first }
+    : expression expressions  { Cat.new(val.first, val.last) }
+    | expression              { val.first }
     | or
     ;
   expression
@@ -14,13 +14,14 @@ rule
     | star
     ;
   group
-    : LPAREN expressions RPAREN { result = Group.new(val[1]) }
+    : LPAREN expressions RPAREN { Group.new(val[1]) }
     ;
   or
-    : expressions OR expression { result = Or.new([val.first, val.last]) }
+    : expression OR expression { Or.new([val.first, val.last]) }
+    | expression OR or { Or.new([val.first, val.last]) }
     ;
   star
-    : STAR       { result = Star.new(Symbol.new(val.last)) }
+    : STAR       { Star.new(Symbol.new(val.last)) }
     ;
   terminal
     : symbol
@@ -29,16 +30,16 @@ rule
     | dot
     ;
   slash
-    : SLASH              { result = Slash.new('/') }
+    : SLASH              { Slash.new('/') }
     ;
   symbol
-    : SYMBOL             { result = Symbol.new(val.first) }
+    : SYMBOL             { Symbol.new(val.first) }
     ;
   literal
-    : LITERAL            { result = Literal.new(val.first) }
+    : LITERAL            { Literal.new(val.first) }
     ;
   dot
-    : DOT                { result = Dot.new(val.first) }
+    : DOT                { Dot.new(val.first) }
     ;
 
 end

data/lib/action_dispatch/journey/path/pattern.rb

@@ -1,27 +1,20 @@
+require 'action_dispatch/journey/router/strexp'
+
 module ActionDispatch
   module Journey # :nodoc:
     module Path # :nodoc:
       class Pattern # :nodoc:
         attr_reader :spec, :requirements, :anchored
 
-        def initialize(strexp)
-          parser = Journey::Parser.new
-
-          @anchored = true
+        def self.from_string string
+          new Journey::Router::Strexp.build(string, {}, ["/.?"], true)
+        end
 
-          case strexp
-          when String
-            @spec         = parser.parse(strexp)
-            @requirements = {}
-            @separators   = "/.?"
-          when Router::Strexp
-            @spec         = parser.parse(strexp.path)
-            @requirements = strexp.requirements
-            @separators   = strexp.separators.join
-            @anchored     = strexp.anchor
-          else
-            raise ArgumentError, "Bad expression: #{strexp}"
-          end
+        def initialize(strexp)
+          @spec         = strexp.ast
+          @requirements = strexp.requirements
+          @separators   = strexp.separators.join
+          @anchored     = strexp.anchor
 
           @names          = nil
           @optional_names = nil
@@ -30,6 +23,10 @@ module ActionDispatch
           @offsets        = nil
         end
 
+        def build_formatter
+          Visitors::FormatBuilder.new.accept(spec)
+        end
+
         def ast
           @spec.grep(Nodes::Symbol).each do |node|
             re = @requirements[node.to_sym]
@@ -53,9 +50,9 @@ module ActionDispatch
         end
 
         def optional_names
-          @optional_names ||= spec.grep(Nodes::Group).map { |group|
+          @optional_names ||= spec.grep(Nodes::Group).flat_map { |group|
             group.grep(Nodes::Symbol)
-          }.flatten.map { |n| n.name }.uniq
+          }.map { |n| n.name }.uniq
         end
 
         class RegexpOffsets < Journey::Visitors::Visitor # :nodoc:

data/lib/action_dispatch/journey/route.rb

@@ -16,14 +16,6 @@ module ActionDispatch
         @app         = app
         @path        = path
 
-        # Unwrap any constraints so we can see what's inside for route generation.
-        # This allows the formatter to skip over any mounted applications or redirects
-        # that shouldn't be matched when using a url_for without a route name.
-        while app.is_a?(Routing::Mapper::Constraints) do
-          app = app.app
-        end
-        @dispatcher  = app.is_a?(Routing::RouteSet::Dispatcher)
-
         @constraints = constraints
         @defaults    = defaults
         @required_defaults = nil
@@ -31,6 +23,7 @@ module ActionDispatch
         @parts             = nil
         @decorated_ast     = nil
         @precedence        = 0
+        @path_formatter    = @path.build_formatter
       end
 
       def ast
@@ -72,15 +65,7 @@ module ActionDispatch
       alias :segment_keys :parts
 
       def format(path_options)
-        path_options.delete_if do |key, value|
-          value.to_s == defaults[key].to_s && !required_parts.include?(key)
-        end
-
-        Visitors::Formatter.new(path_options).accept(path.spec)
-      end
-
-      def optimized_path
-        Visitors::OptimizedPath.new.accept(path.spec)
+        @path_formatter.evaluate path_options
       end
 
       def optional_parts
@@ -106,7 +91,7 @@ module ActionDispatch
       end
 
       def dispatcher?
-        @dispatcher
+        @app.dispatcher?
       end
 
       def matches?(request)

data/lib/action_dispatch/journey/router.rb

@@ -20,62 +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('/')
-            matched_path = match.post_match
-            env['PATH_INFO']   = matched_path
-            env['PATH_INFO']   = "/" + matched_path unless matched_path.start_with? "/"
+            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
 
@@ -85,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
 
@@ -123,33 +93,34 @@ 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) }
+          if req.env["REQUEST_METHOD"] === "HEAD"
+            routes.concat get_routes_as_head(routes)
+          end
+
+          routes.select! { |r| r.matches?(req) }
+          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|
+          routes.select { |r|
             r.verb === "GET" && !(r.verb === "HEAD")
           }.map! { |r|
             Route.new(r.name,
@@ -160,8 +131,6 @@ module ActionDispatch
                         route.precedence = r.precedence + precedence
                       end
           }
-          routes.flatten!
-          routes
         end
     end
   end

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

@@ -6,18 +6,21 @@ module ActionDispatch
           alias :compile :new
         end
 
-        attr_reader :path, :requirements, :separators, :anchor
+        attr_reader :path, :requirements, :separators, :anchor, :ast
 
-        def initialize(path, requirements, separators, anchor = true)
+        def self.build(path, requirements, separators, anchor = true)
+          parser = Journey::Parser.new
+          ast = parser.parse path
+          new ast, path, requirements, separators, anchor
+        end
+
+        def initialize(ast, path, requirements, separators, anchor = true)
+          @ast          = ast
           @path         = path
           @requirements = requirements
           @separators   = separators
           @anchor       = anchor
         end
-
-        def names
-          @path.scan(/:\w+/).map { |s| s.tr(':', '') }
-        end
       end
     end
   end

data/lib/action_dispatch/journey/routes.rb

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

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,11 +81,41 @@ 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
       class Each < Visitor # :nodoc:
         attr_reader :block
@@ -52,8 +125,8 @@ module ActionDispatch
         end
 
         def visit(node)
-          super
           block.call(node)
+          super
         end
       end
 
@@ -77,90 +150,6 @@ module ActionDispatch
         end
       end
 
-      class OptimizedPath < Visitor # :nodoc:
-        def accept(node)
-          Array(visit(node))
-        end
-
-        private
-
-          def visit_CAT(node)
-            [visit(node.left), visit(node.right)].flatten
-          end
-
-          def visit_SYMBOL(node)
-            node.left[1..-1].to_sym
-          end
-
-          def visit_STAR(node)
-            visit(node.left)
-          end
-
-          def visit_GROUP(node)
-            []
-          end
-
-          %w{ LITERAL SLASH DOT }.each do |t|
-            class_eval %{ def visit_#{t}(n); n.left; end }, __FILE__, __LINE__
-          end
-      end
-
-      # Used for formatting urls (url_for)
-      class Formatter < Visitor # :nodoc:
-        attr_reader :options
-
-        def initialize(options)
-          @options  = options
-        end
-
-        private
-          def escape_path(value)
-            Router::Utils.escape_path(value)
-          end
-
-          def escape_segment(value)
-            Router::Utils.escape_segment(value)
-          end
-
-          def visit(node, optional = false)
-            case node.type
-            when :LITERAL, :SLASH, :DOT
-              node.left
-            when :STAR
-              visit_STAR(node.left)
-            when :GROUP
-              visit(node.left, true)
-            when :CAT
-              visit_CAT(node, optional)
-            when :SYMBOL
-              visit_SYMBOL(node, node.to_sym)
-            end
-          end
-
-          def visit_CAT(node, optional)
-            left = visit(node.left, optional)
-            right = visit(node.right, optional)
-
-            if optional && !(right && left)
-              ""
-            else
-              [left, right].join
-            end
-          end
-
-          def visit_STAR(node)
-            if value = options[node.to_sym]
-              escape_path(value)
-            end
-          end
-
-          def visit_SYMBOL(node, name)
-            if value = options[name]
-              name == :controller ? escape_path(value) : escape_segment(value)
-            end
-          end
-      end
-
       class Dot < Visitor # :nodoc:
         def initialize
           @nodes = []