actionpack 3.2.19 → 4.0.0

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

@@ -0,0 +1,196 @@
+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
+
+          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
+
+          @names          = nil
+          @optional_names = nil
+          @required_names = nil
+          @re             = nil
+          @offsets        = nil
+        end
+
+        def ast
+          @spec.grep(Nodes::Symbol).each do |node|
+            re = @requirements[node.to_sym]
+            node.regexp = re if re
+          end
+
+          @spec.grep(Nodes::Star).each do |node|
+            node = node.left
+            node.regexp = @requirements[node.to_sym] || /(.+)/
+          end
+
+          @spec
+        end
+
+        def names
+          @names ||= spec.grep(Nodes::Symbol).map { |n| n.name }
+        end
+
+        def required_names
+          @required_names ||= names - optional_names
+        end
+
+        def optional_names
+          @optional_names ||= spec.grep(Nodes::Group).map { |group|
+            group.grep(Nodes::Symbol)
+          }.flatten.map { |n| n.name }.uniq
+        end
+
+        class RegexpOffsets < Journey::Visitors::Visitor # :nodoc:
+          attr_reader :offsets
+
+          def initialize(matchers)
+            @matchers      = matchers
+            @capture_count = [0]
+          end
+
+          def visit(node)
+            super
+            @capture_count
+          end
+
+          def visit_SYMBOL(node)
+            node = node.to_sym
+
+            if @matchers.key?(node)
+              re = /#{@matchers[node]}|/
+              @capture_count.push((re.match('').length - 1) + (@capture_count.last || 0))
+            else
+              @capture_count << (@capture_count.last || 0)
+            end
+          end
+        end
+
+        class AnchoredRegexp < Journey::Visitors::Visitor # :nodoc:
+          def initialize(separator, matchers)
+            @separator = separator
+            @matchers  = matchers
+            @separator_re = "([^#{separator}]+)"
+            super()
+          end
+
+          def accept(node)
+            %r{\A#{visit node}\Z}
+          end
+
+          def visit_CAT(node)
+            [visit(node.left), visit(node.right)].join
+          end
+
+          def visit_SYMBOL(node)
+            node = node.to_sym
+
+            return @separator_re unless @matchers.key?(node)
+
+            re = @matchers[node]
+            "(#{re})"
+          end
+
+          def visit_GROUP(node)
+            "(?:#{visit node.left})?"
+          end
+
+          def visit_LITERAL(node)
+            Regexp.escape(node.left)
+          end
+          alias :visit_DOT :visit_LITERAL
+
+          def visit_SLASH(node)
+            node.left
+          end
+
+          def visit_STAR(node)
+            re = @matchers[node.left.to_sym] || '.+'
+            "(#{re})"
+          end
+        end
+
+        class UnanchoredRegexp < AnchoredRegexp # :nodoc:
+          def accept(node)
+            %r{\A#{visit node}}
+          end
+        end
+
+        class MatchData # :nodoc:
+          attr_reader :names
+
+          def initialize(names, offsets, match)
+            @names   = names
+            @offsets = offsets
+            @match   = match
+          end
+
+          def captures
+            (length - 1).times.map { |i| self[i + 1] }
+          end
+
+          def [](x)
+            idx = @offsets[x - 1] + x
+            @match[idx]
+          end
+
+          def length
+            @offsets.length
+          end
+
+          def post_match
+            @match.post_match
+          end
+
+          def to_s
+            @match.to_s
+          end
+        end
+
+        def match(other)
+          return unless match = to_regexp.match(other)
+          MatchData.new(names, offsets, match)
+        end
+        alias :=~ :match
+
+        def source
+          to_regexp.source
+        end
+
+        def to_regexp
+          @re ||= regexp_visitor.new(@separators, @requirements).accept spec
+        end
+
+        private
+
+          def regexp_visitor
+            @anchored ? AnchoredRegexp : UnanchoredRegexp
+          end
+
+          def offsets
+            return @offsets if @offsets
+
+            viz = RegexpOffsets.new(@requirements)
+            @offsets = viz.accept(spec)
+          end
+      end
+    end
+  end
+end

data/lib/action_dispatch/journey/route.rb

@@ -0,0 +1,124 @@
+module ActionDispatch
+  module Journey # :nodoc:
+    class Route # :nodoc:
+      attr_reader :app, :path, :defaults, :name
+
+      attr_reader :constraints
+      alias :conditions :constraints
+
+      attr_accessor :precedence
+
+      ##
+      # +path+ is a path constraint.
+      # +constraints+ is a hash of constraints to be applied to this route.
+      def initialize(name, app, path, constraints, defaults = {})
+        @name        = name
+        @app         = app
+        @path        = path
+
+        @constraints = constraints
+        @defaults    = defaults
+        @required_defaults = nil
+        @required_parts    = nil
+        @parts             = nil
+        @decorated_ast     = nil
+        @precedence        = 0
+      end
+
+      def ast
+        @decorated_ast ||= begin
+          decorated_ast = path.ast
+          decorated_ast.grep(Nodes::Terminal).each { |n| n.memo = self }
+          decorated_ast
+        end
+      end
+
+      def requirements # :nodoc:
+        # needed for rails `rake routes`
+        path.requirements.merge(@defaults).delete_if { |_,v|
+          /.+?/ == v
+        }
+      end
+
+      def segments
+        path.names
+      end
+
+      def required_keys
+        required_parts + required_defaults.keys
+      end
+
+      def score(constraints)
+        required_keys = path.required_names
+        supplied_keys = constraints.map { |k,v| v && k.to_s }.compact
+
+        return -1 unless (required_keys - supplied_keys).empty?
+
+        score = (supplied_keys & path.names).length
+        score + (required_defaults.length * 2)
+      end
+
+      def parts
+        @parts ||= segments.map { |n| n.to_sym }
+      end
+      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)
+      end
+
+      def optional_parts
+        path.optional_names.map { |n| n.to_sym }
+      end
+
+      def required_parts
+        @required_parts ||= path.required_names.map { |n| n.to_sym }
+      end
+
+      def required_default?(key)
+        (constraints[:required_defaults] || []).include?(key)
+      end
+
+      def required_defaults
+        @required_defaults ||= @defaults.dup.delete_if do |k,_|
+          parts.include?(k) || !required_default?(k)
+        end
+      end
+
+      def matches?(request)
+        constraints.all? do |method, value|
+          next true unless request.respond_to?(method)
+
+          case value
+          when Regexp, String
+            value === request.send(method).to_s
+          when Array
+            value.include?(request.send(method))
+          when TrueClass
+            request.send(method).present?
+          when FalseClass
+            request.send(method).blank?
+          else
+            value === request.send(method)
+          end
+        end
+      end
+
+      def ip
+        constraints[:ip] || //
+      end
+
+      def verb
+        constraints[:request_method] || //
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module ActionDispatch
+  module Journey # :nodoc:
+    class Router # :nodoc:
+      class Strexp # :nodoc:
+        class << self
+          alias :compile :new
+        end
+
+        attr_reader :path, :requirements, :separators, :anchor
+
+        def initialize(path, requirements, separators, anchor = true)
+          @path         = path
+          @requirements = requirements
+          @separators   = separators
+          @anchor       = anchor
+        end
+
+        def names
+          @path.scan(/:\w+/).map { |s| s.tr(':', '') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'uri'
+
+module ActionDispatch
+  module Journey # :nodoc:
+    class Router # :nodoc:
+      class Utils # :nodoc:
+        # Normalizes URI path.
+        #
+        # Strips off trailing slash and ensures there is a leading slash.
+        #
+        #   normalize_path("/foo")  # => "/foo"
+        #   normalize_path("/foo/") # => "/foo"
+        #   normalize_path("foo")   # => "/foo"
+        #   normalize_path("")      # => "/"
+        def self.normalize_path(path)
+          path = "/#{path}"
+          path.squeeze!('/')
+          path.sub!(%r{/+\Z}, '')
+          path = '/' if path == ''
+          path
+        end
+
+        # 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
+        end
+
+        Parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+
+        def self.escape_path(path)
+          Parser.escape(path.to_s, UriEscape::UNSAFE_SEGMENT)
+        end
+
+        def self.escape_fragment(fragment)
+          Parser.escape(fragment.to_s, UriEscape::UNSAFE_FRAGMENT)
+        end
+
+        def self.unescape_uri(uri)
+          Parser.unescape(uri)
+        end
+      end
+    end
+  end
+end

data/lib/action_dispatch/journey/router.rb

@@ -0,0 +1,166 @@
+require 'action_dispatch/journey/router/utils'
+require 'action_dispatch/journey/router/strexp'
+require 'action_dispatch/journey/routes'
+require 'action_dispatch/journey/formatter'
+
+before = $-w
+$-w = false
+require 'action_dispatch/journey/parser'
+$-w = before
+
+require 'action_dispatch/journey/route'
+require 'action_dispatch/journey/path/pattern'
+
+module ActionDispatch
+  module Journey # :nodoc:
+    class Router # :nodoc:
+      class RoutingError < ::StandardError # :nodoc:
+      end
+
+      # :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
+      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)
+
+          unless route.path.anchored
+            env['SCRIPT_NAME'] = (script_name.to_s + match.to_s).chomp('/')
+            env['PATH_INFO']   = match.post_match
+          end
+
+          env[@params_key] = (set_params || {}).merge parameters
+
+          status, headers, body = route.app.call(env)
+
+          if 'pass' == headers['X-Cascade']
+            env['SCRIPT_NAME'] = script_name
+            env['PATH_INFO']   = path_info
+            env[@params_key]   = set_params
+            next
+          end
+
+          return [status, headers, body]
+        end
+
+        return [404, {'X-Cascade' => 'pass'}, ['Not Found']]
+      end
+
+      def recognize(req)
+        find_routes(req.env).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')
+          end
+
+          yield(route, nil, parameters)
+        end
+      end
+
+      def visualizer
+        tt     = GTG::Builder.new(ast).transition_table
+        groups = partitioned_routes.first.map(&:ast).group_by { |a| a.to_s }
+        asts   = groups.values.map { |v| v.first }
+        tt.visualizer(asts)
+      end
+
+      private
+
+        def partitioned_routes
+          routes.partitioned_routes
+        end
+
+        def ast
+          routes.ast
+        end
+
+        def simulator
+          routes.simulator
+        end
+
+        def custom_routes
+          partitioned_routes.last
+        end
+
+        def filter_routes(path)
+          return [] unless ast
+          data = simulator.match(path)
+          data ? data.memos : []
+        end
+
+        def find_routes env
+          req = request_class.new(env)
+
+          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.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]
+          }
+        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
+        end
+    end
+  end
+end

data/lib/action_dispatch/journey/routes.rb

@@ -0,0 +1,75 @@
+module ActionDispatch
+  module Journey # :nodoc:
+    # The Routing table. Contains all routes for a system. Routes can be
+    # added to the table by calling Routes#add_route.
+    class Routes # :nodoc:
+      include Enumerable
+
+      attr_reader :routes, :named_routes
+
+      def initialize
+        @routes             = []
+        @named_routes       = {}
+        @ast                = nil
+        @partitioned_routes = nil
+        @simulator          = nil
+      end
+
+      def length
+        routes.length
+      end
+      alias :size :length
+
+      def last
+        routes.last
+      end
+
+      def each(&block)
+        routes.each(&block)
+      end
+
+      def clear
+        routes.clear
+      end
+
+      def partitioned_routes
+        @partitioned_routes ||= routes.partition do |r|
+          r.path.anchored && r.ast.grep(Nodes::Symbol).all?(&:default_regexp?)
+        end
+      end
+
+      def ast
+        @ast ||= begin
+          asts = partitioned_routes.first.map(&:ast)
+          Nodes::Or.new(asts) unless asts.empty?
+        end
+      end
+
+      def simulator
+        @simulator ||= begin
+          gtg = GTG::Builder.new(ast).transition_table
+          GTG::Simulator.new(gtg)
+        end
+      end
+
+      # Add a route to the routing table.
+      def add_route(app, path, conditions, defaults, name = nil)
+        route = Route.new(name, app, path, conditions, defaults)
+
+        route.precedence = routes.length
+        routes << route
+        named_routes[name] = route if name && !named_routes[name]
+        clear_cache!
+        route
+      end
+
+      private
+
+        def clear_cache!
+          @ast                = nil
+          @partitioned_routes = nil
+          @simulator          = nil
+        end
+    end
+  end
+end

data/lib/action_dispatch/journey/scanner.rb

@@ -0,0 +1,61 @@
+require 'strscan'
+
+module ActionDispatch
+  module Journey # :nodoc:
+    class Scanner # :nodoc:
+      def initialize
+        @ss = nil
+      end
+
+      def scan_setup(str)
+        @ss = StringScanner.new(str)
+      end
+
+      def eos?
+        @ss.eos?
+      end
+
+      def pos
+        @ss.pos
+      end
+
+      def pre_match
+        @ss.pre_match
+      end
+
+      def next_token
+        return if @ss.eos?
+
+        until token = scan || @ss.eos?; end
+        token
+      end
+
+      private
+
+        def scan
+          case
+            # /
+          when text = @ss.scan(/\//)
+            [:SLASH, text]
+          when text = @ss.scan(/\*\w+/)
+            [:STAR, text]
+          when text = @ss.scan(/\(/)
+            [:LPAREN, text]
+          when text = @ss.scan(/\)/)
+            [:RPAREN, text]
+          when text = @ss.scan(/\|/)
+            [:OR, text]
+          when text = @ss.scan(/\./)
+            [:DOT, text]
+          when text = @ss.scan(/:\w+/)
+            [:SYMBOL, text]
+          when text = @ss.scan(/[\w%\-~]+/)
+            [:LITERAL, text]
+            # any char
+          when text = @ss.scan(/./)
+            [:LITERAL, text]
+          end
+        end
+    end
+  end
+end