rack-mount 0.0.1 → 0.6.13

data/lib/rack/mount/route_set.rb

@@ -3,16 +3,12 @@ require 'rack/mount/route'
 require 'rack/mount/utils'
 
 module Rack::Mount
-  class RouteSet
-    extend Mixover
-
-    # Include generation and recognition concerns
-    include Generation::RouteSet, Recognition::RouteSet
-    include Recognition::CodeGeneration
+  class RoutingError < StandardError; end
 
+  class RouteSet
     # Initialize a new RouteSet without optimizations
-    def self.new_without_optimizations(*args, &block)
-      new_without_module(Recognition::CodeGeneration, *args, &block)
+    def self.new_without_optimizations(options = {}, &block)
+      new(options.merge(:_optimize => false), &block)
     end
 
     # Basic RouteSet initializer.
@@ -23,7 +19,20 @@ module Rack::Mount
     # - <tt>Generation::RouteSet.new</tt>
     # - <tt>Recognition::RouteSet.new</tt>
     def initialize(options = {}, &block)
+      @parameters_key = options.delete(:parameters_key) || 'rack.routing_args'
+      @parameters_key.freeze
+
+      @named_routes = {}
+
+      @recognition_key_analyzer = Analysis::Splitting.new
+      @generation_key_analyzer  = Analysis::Frequency.new
+
       @request_class = options.delete(:request_class) || Rack::Request
+      @valid_conditions = @request_class.public_instance_methods.map! { |m| m.to_sym }
+
+      extend CodeGeneration unless options[:_optimize] == false
+      @optimized_recognize_defined = false
+
       @routes = []
       expire!
 
@@ -40,28 +49,194 @@ module Rack::Mount
     #                       Conditions may be expressed as strings or
     #                       regexps to match against.
     # <tt>defaults</tt>:: A hash of values that always gets merged in
-    # <tt>name</tt>:: Symbol identifier for the route used with named 
+    # <tt>name</tt>:: Symbol identifier for the route used with named
     #                 route generations
     def add_route(app, conditions = {}, defaults = {}, name = nil)
-      route = Route.new(self, app, conditions, defaults, name)
+      unless conditions.is_a?(Hash)
+        raise ArgumentError, 'conditions must be a Hash'
+      end
+
+      unless conditions.all? { |method, pattern|
+          @valid_conditions.include?(method)
+        }
+        raise ArgumentError, 'conditions may only include ' +
+          @valid_conditions.inspect
+      end
+
+      route = Route.new(app, conditions, defaults, name)
       @routes << route
+
+      @recognition_key_analyzer << route.conditions
+
+      @named_routes[route.name] = route if route.name
+      @generation_key_analyzer << route.generation_keys
+
       expire!
       route
     end
 
-    # See <tt>Recognition::RouteSet#call</tt>
+    def recognize(obj)
+      raise 'route set not finalized' unless @recognition_graph
+
+      cache = {}
+      keys = @recognition_keys.map { |key|
+        if key.respond_to?(:call)
+          key.call(cache, obj)
+        else
+          obj.send(key)
+        end
+      }
+
+      @recognition_graph[*keys].each do |route|
+        matches = {}
+        params  = route.defaults.dup
+
+        if route.conditions.all? { |method, condition|
+            value = obj.send(method)
+            if condition.is_a?(Regexp) && (m = value.match(condition))
+              matches[method] = m
+              captures = m.captures
+              route.named_captures[method].each do |k, i|
+                if v = captures[i]
+                  params[k] = v
+                end
+              end
+              true
+            elsif value == condition
+              true
+            else
+              false
+            end
+          }
+          if block_given?
+            yield route, matches, params
+          else
+            return route, matches, params
+          end
+        end
+      end
+
+      nil
+    end
+
+    X_CASCADE = 'X-Cascade'.freeze
+    PASS      = 'pass'.freeze
+    PATH_INFO = 'PATH_INFO'.freeze
+
+    # Rack compatible recognition and dispatching method. Routes are
+    # tried until one returns a non-catch status code. If no routes
+    # match, the catch status code is returned.
+    #
+    # This method can only be invoked after the RouteSet has been
+    # finalized.
     def call(env)
-      raise NotImplementedError
+      raise 'route set not finalized' unless @recognition_graph
+
+      env[PATH_INFO] = Utils.normalize_path(env[PATH_INFO])
+
+      request = nil
+      req = @request_class.new(env)
+      recognize(req) do |route, matches, params|
+        # TODO: We only want to unescape params from uri related methods
+        params.each { |k, v| params[k] = Utils.unescape_uri(v) if v.is_a?(String) }
+
+        if route.prefix?
+          env[Prefix::KEY] = matches[:path_info].to_s
+        end
+
+        env[@parameters_key] = params
+        result = route.app.call(env)
+        return result unless result[1][X_CASCADE] == PASS
+      end
+
+      request || [404, {'Content-Type' => 'text/html', 'X-Cascade' => 'pass'}, ['Not Found']]
     end
 
-    # See <tt>Generation::RouteSet#url</tt>
-    def url(*args)
-      raise NotImplementedError
+    # Generates a url from Rack env and identifiers or significant keys.
+    #
+    # To generate a url by named route, pass the name in as a +Symbol+.
+    #   url(env, :dashboard) # => "/dashboard"
+    #
+    # Additional parameters can be passed in as a hash
+    #   url(env, :people, :id => "1") # => "/people/1"
+    #
+    # If no name route is given, it will fall back to a slower
+    # generation search.
+    #   url(env, :controller => "people", :action => "show", :id => "1")
+    #     # => "/people/1"
+    def url(env, *args)
+      named_route, params = nil, {}
+
+      case args.length
+      when 2
+        named_route, params = args[0], args[1].dup
+      when 1
+        if args[0].is_a?(Hash)
+          params = args[0].dup
+        else
+          named_route = args[0]
+        end
+      else
+        raise ArgumentError
+      end
+
+      only_path = params.delete(:only_path)
+      recall = env[@parameters_key] || {}
+
+      unless result = generate(:all, named_route, params, recall,
+          :parameterize => lambda { |name, param| Utils.escape_uri(param) })
+        return
+      end
+
+      parts, params = result
+      return unless parts
+
+      params.each do |k, v|
+        if v
+          params[k] = v
+        else
+          params.delete(k)
+        end
+      end
+
+      req = stubbed_request_class.new(env)
+      req._stubbed_values = parts.merge(:query_string => Utils.build_nested_query(params))
+      only_path ? req.fullpath : req.url
     end
 
-    # See <tt>Generation::RouteSet#generate</tt>
-    def generate(*args)
-      raise NotImplementedError
+    def generate(method, *args) #:nodoc:
+      raise 'route set not finalized' unless @generation_graph
+
+      method = nil if method == :all
+      named_route, params, recall, options = extract_params!(*args)
+      merged = recall.merge(params)
+      route = nil
+
+      if named_route
+        if route = @named_routes[named_route.to_sym]
+          recall = route.defaults.merge(recall)
+          url = route.generate(method, params, recall, options)
+          [url, params]
+        else
+          raise RoutingError, "#{named_route} failed to generate from #{params.inspect}"
+        end
+      else
+        keys = @generation_keys.map { |key|
+          if k = merged[key]
+            k.to_s
+          else
+            nil
+          end
+        }
+        @generation_graph[*keys].each do |r|
+          next unless r.significant_params?
+          if url = r.generate(method, params, recall, options)
+            return [url, params]
+          end
+        end
+
+        raise RoutingError, "No route matches #{params.inspect}"
+      end
     end
 
     # Number of routes in the set
@@ -70,6 +245,14 @@ module Rack::Mount
     end
 
     def rehash #:nodoc:
+      Utils.debug "rehashing"
+
+      @recognition_keys  = build_recognition_keys
+      @recognition_graph = build_recognition_graph
+      @generation_keys   = build_generation_keys
+      @generation_graph  = build_generation_graph
+
+      self
     end
 
     # Finalizes the set and builds optimized data structures. You *must*
@@ -78,6 +261,11 @@ module Rack::Mount
     def freeze
       unless frozen?
         rehash
+
+        @recognition_key_analyzer = nil
+        @generation_key_analyzer  = nil
+        @valid_conditions         = nil
+
         @routes.each { |route| route.freeze }
         @routes.freeze
       end
@@ -85,8 +273,46 @@ module Rack::Mount
       super
     end
 
+    def marshal_dump #:nodoc:
+      hash = {}
+
+      instance_variables_to_serialize.each do |ivar|
+        hash[ivar] = instance_variable_get(ivar)
+      end
+
+      if graph = hash[:@recognition_graph]
+        hash[:@recognition_graph] = graph.dup
+      end
+
+      hash
+    end
+
+    def marshal_load(hash) #:nodoc:
+      hash.each do |ivar, value|
+        instance_variable_set(ivar, value)
+      end
+    end
+
+    protected
+      def recognition_stats
+        { :keys => @recognition_keys,
+          :keys_size => @recognition_keys.size,
+          :graph_size => @recognition_graph.size,
+          :graph_height => @recognition_graph.height,
+          :graph_average_height => @recognition_graph.average_height }
+      end
+
     private
       def expire! #:nodoc:
+        @recognition_keys = @recognition_graph = nil
+        @recognition_key_analyzer.expire!
+
+        @generation_keys = @generation_graph = nil
+        @generation_key_analyzer.expire!
+      end
+
+      def instance_variables_to_serialize
+        instance_variables.map { |ivar| ivar.to_sym } - [:@stubbed_request_class, :@optimized_recognize_defined]
       end
 
       # An internal helper method for constructing a nested set from
@@ -98,12 +324,94 @@ module Rack::Mount
       def build_nested_route_set(keys, &block)
         graph = Multimap.new
         @routes.each_with_index do |route, index|
-          k = keys.map { |key| block.call(key, index) }
-          Utils.pop_trailing_nils!(k)
-          k.map! { |key| key || /.+/ }
-          graph[*k] = route
+          catch(:skip) do
+            k = keys.map { |key| block.call(key, index) }
+            Utils.pop_trailing_blanks!(k)
+            k.map! { |key| key || /.*/ }
+            graph[*k] = route
+          end
         end
         graph
       end
+
+      def build_recognition_graph
+        build_nested_route_set(@recognition_keys) { |k, i|
+          @recognition_key_analyzer.possible_keys[i][k]
+        }
+      end
+
+      def build_recognition_keys
+        keys = @recognition_key_analyzer.report
+        Utils.debug "recognition keys - #{keys.inspect}"
+        keys
+      end
+
+      def build_generation_graph
+        build_nested_route_set(@generation_keys) { |k, i|
+          throw :skip unless @routes[i].significant_params?
+
+          if k = @generation_key_analyzer.possible_keys[i][k]
+            k.to_s
+          else
+            nil
+          end
+        }
+      end
+
+      def build_generation_keys
+        keys = @generation_key_analyzer.report
+        Utils.debug "generation keys - #{keys.inspect}"
+        keys
+      end
+
+      def extract_params!(*args)
+        case args.length
+        when 4
+          named_route, params, recall, options = args
+        when 3
+          if args[0].is_a?(Hash)
+            params, recall, options = args
+          else
+            named_route, params, recall = args
+          end
+        when 2
+          if args[0].is_a?(Hash)
+            params, recall = args
+          else
+            named_route, params = args
+          end
+        when 1
+          if args[0].is_a?(Hash)
+            params = args[0]
+          else
+            named_route = args[0]
+          end
+        else
+          raise ArgumentError
+        end
+
+        named_route ||= nil
+        params  ||= {}
+        recall  ||= {}
+        options ||= {}
+
+        [named_route, params.dup, recall.dup, options.dup]
+      end
+
+      def stubbed_request_class
+        @stubbed_request_class ||= begin
+          klass = Class.new(@request_class)
+          klass.public_instance_methods.each do |method|
+            next if method =~ /^__|object_id/
+            klass.class_eval <<-RUBY
+              def #{method}(*args, &block)
+                @_stubbed_values[:#{method}] || super
+              end
+            RUBY
+          end
+          klass.class_eval { attr_accessor :_stubbed_values }
+          klass
+        end
+      end
   end
 end

data/lib/rack/mount/strexp/parser.y

@@ -0,0 +1,34 @@
+class Rack::Mount::StrexpParser
+rule
+  target: expr { result = anchor ? "\\A#{val.join}\\Z" : "\\A#{val.join}" }
+
+  expr: expr token { result = val.join }
+      | token
+
+  token: PARAM {
+           name = val[0].to_sym
+           requirement = requirements[name]
+           result = REGEXP_NAMED_CAPTURE % [name, requirement]
+         }
+       | GLOB {
+           name = val[0].to_sym
+           requirement = requirements[name]
+           result = REGEXP_NAMED_CAPTURE % [name, '.+' || requirement]
+         }
+       | LPAREN expr RPAREN { result = "(?:#{val[1]})?" }
+       | CHAR { result = Regexp.escape(val[0]) }
+end
+
+---- header ----
+require 'rack/mount/utils'
+require 'rack/mount/strexp/tokenizer'
+
+---- inner
+
+if Regin.regexp_supports_named_captures?
+  REGEXP_NAMED_CAPTURE = '(?<%s>%s)'.freeze
+else
+  REGEXP_NAMED_CAPTURE = '(?:<%s>%s)'.freeze
+end
+
+attr_accessor :anchor, :requirements

data/lib/rack/mount/strexp/tokenizer.rb

@@ -0,0 +1,83 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.5.beta1
+# from lexical definition file "lib/rack/mount/strexp/tokenizer.rex".
+#++
+
+require 'racc/parser'
+class Rack::Mount::StrexpParser < Racc::Parser
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader   :lineno
+  attr_reader   :filename
+  attr_accessor :state
+
+  def scan_setup(str)
+    @ss = StringScanner.new(str)
+    @lineno =  1
+    @state  = nil
+  end
+
+  def action
+    yield
+  end
+
+  def scan_str(str)
+    scan_setup(str)
+    do_parse
+  end
+  alias :scan :scan_str
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_setup(f.read)
+    end
+  end
+
+  def scan_file( filename )
+    load_file(filename)
+    do_parse
+  end
+
+
+  def next_token
+    return if @ss.eos?
+
+    text = @ss.peek(1)
+    @lineno  +=  1  if text == "\n"
+    token = case @state
+    when nil
+      case
+      when (text = @ss.scan(/\\(\(|\)|:|\*)/))
+         action { [:CHAR,  @ss[1]] }
+
+      when (text = @ss.scan(/\:([a-zA-Z_]\w*)/))
+         action { [:PARAM, @ss[1]] }
+
+      when (text = @ss.scan(/\*([a-zA-Z_]\w*)/))
+         action { [:GLOB,  @ss[1]] }
+
+      when (text = @ss.scan(/\(/))
+         action { [:LPAREN, text]  }
+
+      when (text = @ss.scan(/\)/))
+         action { [:RPAREN, text]  }
+
+      when (text = @ss.scan(/./))
+         action { [:CHAR,   text]  }
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    else
+      raise  ScanError, "undefined state: '" + state.to_s + "'"
+    end  # case state
+    token
+  end  # def next_token
+
+end # class

data/lib/rack/mount/strexp/tokenizer.rex

@@ -0,0 +1,12 @@
+class Rack::Mount::StrexpParser
+macro
+  RESERVED  \(|\)|:|\*
+  ALPHA_U   [a-zA-Z_]
+rule
+  \\({RESERVED})   { [:CHAR,  @ss[1]] }
+  \:({ALPHA_U}\w*) { [:PARAM, @ss[1]] }
+  \*({ALPHA_U}\w*) { [:GLOB,  @ss[1]] }
+  \(               { [:LPAREN, text]  }
+  \)               { [:RPAREN, text]  }
+  .                { [:CHAR,   text]  }
+end

data/lib/rack/mount/strexp.rb

@@ -1,93 +1,68 @@
-require 'strscan'
+require 'rack/mount/strexp/parser'
 
 module Rack::Mount
-  class Strexp < Regexp
-    # Parses segmented string expression and converts it into a Regexp
-    #
-    #   Strexp.compile('foo')
-    #     # => %r{\Afoo\Z}
-    #
-    #   Strexp.compile('foo/:bar', {}, ['/'])
-    #     # => %r{\Afoo/(?<bar>[^/]+)\Z}
-    #
-    #   Strexp.compile(':foo.example.com')
-    #     # => %r{\A(?<foo>.+)\.example\.com\Z}
-    #
-    #   Strexp.compile('foo/:bar', {:bar => /[a-z]+/}, ['/'])
-    #     # => %r{\Afoo/(?<bar>[a-z]+)\Z}
-    #
-    #   Strexp.compile('foo(.:extension)')
-    #     # => %r{\Afoo(\.(?<extension>.+))?\Z}
-    #
-    #   Strexp.compile('src/*files')
-    #     # => %r{\Asrc/(?<files>.+)\Z}
-    def initialize(str, requirements = {}, separators = [])
-      return super(str) if str.is_a?(Regexp)
+  class Strexp
+    class << self
+      # Parses segmented string expression and converts it into a Regexp
+      #
+      #   Strexp.compile('foo')
+      #     # => %r{\Afoo\Z}
+      #
+      #   Strexp.compile('foo/:bar', {}, ['/'])
+      #     # => %r{\Afoo/(?<bar>[^/]+)\Z}
+      #
+      #   Strexp.compile(':foo.example.com')
+      #     # => %r{\A(?<foo>.+)\.example\.com\Z}
+      #
+      #   Strexp.compile('foo/:bar', {:bar => /[a-z]+/}, ['/'])
+      #     # => %r{\Afoo/(?<bar>[a-z]+)\Z}
+      #
+      #   Strexp.compile('foo(.:extension)')
+      #     # => %r{\Afoo(\.(?<extension>.+))?\Z}
+      #
+      #   Strexp.compile('src/*files')
+      #     # => %r{\Asrc/(?<files>.+)\Z}
+      def compile(str, requirements = {}, separators = [], anchor = true)
+        return Regexp.compile(str) if str.is_a?(Regexp)
 
-      re = Regexp.escape(str)
-      requirements = requirements ? requirements.dup : {}
+        requirements = requirements ? requirements.dup : {}
+        normalize_requirements!(requirements, separators)
 
-      normalize_requirements!(requirements, separators)
-      parse_dynamic_segments!(re, requirements)
-      parse_optional_segments!(re)
+        parser = StrexpParser.new
+        parser.anchor = anchor
+        parser.requirements = requirements
 
-      super("\\A#{re}\\Z")
-    end
-
-    private
-      def normalize_requirements!(requirements, separators)
-        requirements.each do |key, value|
-          if value.is_a?(Regexp)
-            if regexp_has_modifiers?(value)
-              requirements[key] = value
-            else
-              requirements[key] = value.source
-            end
-          else
-            requirements[key] = Regexp.escape(value)
-          end
+        begin
+          re = parser.scan_str(str)
+        rescue Racc::ParseError => e
+          raise RegexpError, e.message
         end
-        requirements.default ||= separators.any? ?
-          "[^#{separators.join}]+" : '.+'
-        requirements
-      end
 
-      def parse_dynamic_segments!(str, requirements)
-        re, pos, scanner = '', 0, StringScanner.new(str)
-        while scanner.scan_until(/(:|\\\*)([a-zA-Z_]\w*)/)
-          pre, pos = scanner.pre_match[pos..-1], scanner.pos
-          if pre =~ /(.*)\\\\\Z/
-            re << $1 + scanner.matched
-          else
-            name = scanner[2].to_sym
-            requirement = scanner[1] == ':' ?
-              requirements[name] : '.+'
-            re << pre + Const::REGEXP_NAMED_CAPTURE % [name, requirement]
-          end
-        end
-        re << scanner.rest
-        str.replace(re)
+        Regexp.compile(re)
       end
+      alias_method :new, :compile
 
-      def parse_optional_segments!(str)
-        re, pos, scanner = '', 0, StringScanner.new(str)
-        while scanner.scan_until(/\\\(|\\\)/)
-          pre, pos = scanner.pre_match[pos..-1], scanner.pos
-          if pre =~ /(.*)\\\\\Z/
-            re << $1 + scanner.matched
-          elsif scanner.matched == '\\('
-            # re << pre + '(?:'
-            re << pre + '('
-          elsif scanner.matched == '\\)'
-            re << pre + ')?'
+      private
+        def normalize_requirements!(requirements, separators)
+          requirements.each do |key, value|
+            if value.is_a?(Regexp)
+              if regexp_has_modifiers?(value)
+                requirements[key] = value
+              else
+                requirements[key] = value.source
+              end
+            else
+              requirements[key] = Regexp.escape(value)
+            end
           end
+          requirements.default ||= separators.any? ?
+            "[^#{separators.join}]+" : '.+'
+          requirements
         end
-        re << scanner.rest
-        str.replace(re)
-      end
 
-      def regexp_has_modifiers?(regexp)
-        regexp.options & (Regexp::IGNORECASE | Regexp::EXTENDED) != 0
-      end
+        def regexp_has_modifiers?(regexp)
+          regexp.options & (Regexp::IGNORECASE | Regexp::EXTENDED) != 0
+        end
+    end
   end
 end