journey 1.0.0.rc1

data/lib/journey/route.rb

@@ -0,0 +1,92 @@
+module Journey
+  class Route
+    attr_reader :app, :path, :verb, :defaults, :ip, :name
+
+    attr_reader :constraints
+    alias :conditions :constraints
+
+    ##
+    # +path+ is a path constraint.
+    # +constraints+ is a hash of constraints to be applied to this route.
+    def initialize name, app, path, constraints, defaults = {}
+      constraints  = constraints.dup
+      @name        = name
+      @app         = app
+      @path        = path
+      @verb        = constraints[:request_method] || //
+      @ip          = constraints.delete(:ip) || //
+
+      @constraints = constraints
+      @constraints.keep_if { |_,v| Regexp === v || String === v }
+      @defaults    = defaults
+      @required_defaults = nil
+      @required_parts    = nil
+      @parts             = nil
+      @decorated_ast     = nil
+    end
+
+    def ast
+      return @decorated_ast if @decorated_ast
+
+      @decorated_ast = path.ast
+      @decorated_ast.grep(Nodes::Terminal).each { |n| n.memo = self }
+      @decorated_ast
+    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
+      path.required_names.map { |x| x.to_sym } + 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
+      (defaults.keys - required_parts).each do |key|
+        path_options.delete key if defaults[key].to_s == path_options[key].to_s
+      end
+
+      formatter      = Visitors::Formatter.new(path_options)
+
+      formatted_path = formatter.accept(path.spec)
+      formatted_path.gsub(/\/\x00/, '')
+    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_defaults
+      @required_defaults ||= begin
+        matches = parts
+        @defaults.dup.delete_if { |k,_| matches.include? k }
+      end
+    end
+  end
+end

data/lib/journey/router.rb

@@ -0,0 +1,138 @@
+require 'journey/core-ext/hash'
+require 'journey/router/utils'
+require 'journey/router/strexp'
+require 'journey/routes'
+require 'journey/formatter'
+
+before = $-w
+$-w = false
+require 'journey/parser'
+$-w = before
+
+require 'journey/route'
+require 'journey/path/pattern'
+
+module Journey
+  class Router
+    class RoutingError < ::StandardError
+    end
+
+    VERSION = '1.0.0.rc1'
+
+    class NullReq # :nodoc:
+      attr_reader :env
+      def initialize env
+        @env = env
+      end
+
+      def request_method
+        env['REQUEST_METHOD']
+      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
+          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
+      addr       = env['REMOTE_ADDR']
+      req        = request_class.new env
+
+      routes = filter_routes(env['PATH_INFO']) + custom_routes.find_all { |r|
+        r.path.match(env['PATH_INFO'])
+      }
+
+      routes.find_all { |r|
+        r.constraints.all? { |k,v| v === req.send(k) } &&
+          r.verb === env['REQUEST_METHOD']
+      }.reject { |r| addr && !(r.ip === addr) }.map { |r|
+        match_data  = r.path.match(env['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
+  end
+end

data/lib/journey/router/strexp.rb

@@ -0,0 +1,22 @@
+module Journey
+  class Router
+    class Strexp
+      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

data/lib/journey/router/utils.rb

@@ -0,0 +1,57 @@
+require 'uri'
+
+module Journey
+  class Router
+    class Utils
+      # 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
+        # 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}"
+        if RUBY_VERSION >= '1.9'
+          UNSAFE_SEGMENT  = Regexp.new("[^#{safe_segment}]", false).freeze
+          UNSAFE_FRAGMENT = Regexp.new("[^#{safe_fragment}]", false).freeze
+        else
+          UNSAFE_SEGMENT = Regexp.new("[^#{safe_segment}]", false, 'N').freeze
+          UNSAFE_FRAGMENT = Regexp.new("[^#{safe_fragment}]", false, 'N').freeze
+        end
+      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

data/lib/journey/routes.rb

@@ -0,0 +1,74 @@
+module Journey
+  ###
+  # The Routing table.  Contains all routes for a system.  Routes can be
+  # added to the table by calling Routes#add_route
+  class Routes
+    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 { |r|
+        r.path.anchored && r.ast.grep(Nodes::Symbol).all? { |n| n.default_regexp?  }
+      }
+    end
+
+    def ast
+      return @ast if @ast
+      return if partitioned_routes.first.empty?
+
+      asts = partitioned_routes.first.map { |r| r.ast }
+      @ast = Nodes::Or.new(asts)
+    end
+
+    def simulator
+      return @simulator if @simulator
+
+      gtg = GTG::Builder.new(ast).transition_table
+      @simulator = GTG::Simulator.new gtg
+    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)
+
+      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

data/lib/journey/scanner.rb

@@ -0,0 +1,58 @@
+require 'strscan'
+
+module Journey
+  class Scanner
+    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(/\*/)
+        [: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