rack-mount 0.6.1 → 0.6.2

data/lib/rack/mount.rb

@@ -11,32 +11,22 @@ module Rack #:nodoc:
   # other request attributes, session information, or even data dynamically
   # pulled from a database.
   module Mount
+    autoload :CodeGeneration, 'rack/mount/code_generation'
     autoload :GeneratableRegexp, 'rack/mount/generatable_regexp'
-    autoload :Mixover, 'rack/mount/mixover'
     autoload :Multimap, 'rack/mount/multimap'
     autoload :Prefix, 'rack/mount/prefix'
     autoload :RegexpWithNamedGroups, 'rack/mount/regexp_with_named_groups'
     autoload :Route, 'rack/mount/route'
     autoload :RouteSet, 'rack/mount/route_set'
-    autoload :RoutingError, 'rack/mount/exceptions'
+    autoload :RoutingError, 'rack/mount/route_set'
     autoload :Strexp, 'rack/mount/strexp'
     autoload :Utils, 'rack/mount/utils'
+    autoload :Version, 'rack/mount/version'
 
     module Analysis #:nodoc:
       autoload :Frequency, 'rack/mount/analysis/frequency'
       autoload :Histogram, 'rack/mount/analysis/histogram'
       autoload :Splitting, 'rack/mount/analysis/splitting'
     end
-
-    module Generation #:nodoc:
-      autoload :Route, 'rack/mount/generation/route'
-      autoload :RouteSet, 'rack/mount/generation/route_set'
-    end
-
-    module Recognition #:nodoc:
-      autoload :CodeGeneration, 'rack/mount/recognition/code_generation'
-      autoload :Route, 'rack/mount/recognition/route'
-      autoload :RouteSet, 'rack/mount/recognition/route_set'
-    end
   end
 end

data/lib/rack/mount/analysis/frequency.rb

@@ -3,8 +3,6 @@ require 'rack/mount/utils'
 module Rack::Mount
   module Analysis
     class Frequency #:nodoc:
-      extend Mixover
-
       def initialize(*keys)
         clear
         keys.each { |key| self << key }

data/lib/rack/mount/analysis/splitting.rb

@@ -2,7 +2,7 @@ require 'rack/mount/utils'
 
 module Rack::Mount
   module Analysis
-    module Splitting
+    class Splitting < Frequency
       NULL = "\0".freeze
 
       class Key < Struct.new(:method, :index, :separators)
@@ -67,7 +67,7 @@ module Rack::Mount
                 end
               end
 
-              if inside = part[0][0]
+              if inside = part.expression[0]
                 if inside.is_a?(Reginald::Character) && inside.literal?
                   boundaries << inside.to_s
                 end

data/lib/rack/mount/code_generation.rb

@@ -0,0 +1,113 @@
+module Rack::Mount
+  module CodeGeneration #:nodoc:
+    def _expired_recognize(env) #:nodoc:
+      raise 'route set not finalized'
+    end
+
+    def rehash
+      super
+      optimize_recognize!
+    end
+
+    private
+      def expire!
+        if @optimized_recognize_defined
+          remove_metaclass_method :recognize
+
+          class << self
+            alias_method :recognize, :_expired_recognize
+          end
+
+          @optimized_recognize_defined = false
+        end
+
+        super
+      end
+
+      def optimize_container_iterator(container)
+        body = []
+
+        container.each_with_index { |route, i|
+          body << "route = self[#{i}]"
+          body << 'matches = {}'
+          body << 'params = route.defaults.dup'
+
+          conditions = []
+          route.conditions.each do |method, condition|
+            b = []
+            if condition.is_a?(Regexp)
+              b << "if m = obj.#{method}.match(#{condition.inspect})"
+              b << "matches[:#{method}] = m"
+              if (named_captures = route.named_captures[method]) && named_captures.any?
+                b << 'captures = m.captures'
+                b << 'p = nil'
+                b << named_captures.map { |k, j| "params[#{k.inspect}] = p if p = captures[#{j}]" }.join('; ')
+              end
+            else
+              b << "if m = obj.#{method} == route.conditions[:#{method}]"
+            end
+            b << 'true'
+            b << 'end'
+            conditions << "(#{b.join('; ')})"
+          end
+
+          body << <<-RUBY
+            if #{conditions.join(' && ')}
+              yield route, matches, params
+            end
+          RUBY
+        }
+
+        container.instance_eval(<<-RUBY, __FILE__, __LINE__)
+          def optimized_each(obj)
+            #{body.join("\n")}
+            nil
+          end
+        RUBY
+      end
+
+      def optimize_recognize!
+        keys = @recognition_keys.map { |key|
+          if key.respond_to?(:call_source)
+            key.call_source(:cache, :obj)
+          else
+            "obj.#{key}"
+          end
+        }.join(', ')
+
+        @optimized_recognize_defined = true
+
+        remove_metaclass_method :recognize
+
+        instance_eval(<<-RUBY, __FILE__, __LINE__)
+          def recognize(obj)
+            cache = {}
+            container = @recognition_graph[#{keys}]
+            optimize_container_iterator(container) unless container.respond_to?(:optimized_each)
+
+            if block_given?
+              container.optimized_each(obj) do |route, matches, params|
+                yield route, matches, params
+              end
+            else
+              container.optimized_each(obj) do |route, matches, params|
+                return route, matches, params
+              end
+            end
+
+            nil
+          end
+        RUBY
+      end
+
+      # method_defined? can't distinguish between instance
+      # and meta methods. So we have to rescue if the method
+      # has not been defined in the metaclass yet.
+      def remove_metaclass_method(symbol)
+        metaclass = class << self; self; end
+        metaclass.send(:remove_method, symbol)
+      rescue NameError => e
+        nil
+      end
+  end
+end

data/lib/rack/mount/generatable_regexp.rb

@@ -121,7 +121,7 @@ module Rack::Mount
               if part.name
                 s << DynamicSegment.new(part.name, part.expression.to_regexp)
               else
-                s << parse_segments(part)
+                s << parse_segments(part.expression)
               end
             when Reginald::Expression
               return parse_segments(part)

data/lib/rack/mount/route.rb

@@ -9,11 +9,6 @@ module Rack::Mount
   # new Route objects. Instead use the factory method, RouteSet#add_route
   # to create new routes and add them to the set.
   class Route
-    extend Mixover
-
-    # Include generation and recognition concerns
-    include Generation::Route, Recognition::Route
-
     # Valid rack application to call if conditions are met
     attr_reader :app
 
@@ -27,6 +22,8 @@ module Rack::Mount
     # Symbol identifier for the route used with named route generations
     attr_reader :name
 
+    attr_reader :named_captures
+
     def initialize(app, conditions, defaults, name)
       unless app.respond_to?(:call)
         raise ArgumentError, 'app must be a valid rack application' \
@@ -54,9 +51,76 @@ module Rack::Mount
         @conditions[method] = pattern.freeze
       end
 
+      @named_captures = {}
+      @conditions.map { |method, condition|
+        next unless condition.respond_to?(:named_captures)
+        @named_captures[method] = condition.named_captures.inject({}) { |named_captures, (k, v)|
+          named_captures[k.to_sym] = v.last - 1
+          named_captures
+        }.freeze
+      }
+      @named_captures.freeze
+
+      if @conditions.has_key?(:path_info) &&
+          !Utils.regexp_anchored?(@conditions[:path_info])
+        @prefix = true
+        @app = Prefix.new(@app)
+      else
+        @prefix = false
+      end
+
       @conditions.freeze
     end
 
+    def prefix?
+      @prefix
+    end
+
+
+    def generation_keys
+      @conditions.inject({}) { |keys, (method, condition)|
+        if condition.respond_to?(:required_defaults)
+          keys.merge!(condition.required_defaults)
+        else
+          keys
+        end
+      }
+    end
+
+    def significant_params?
+      @has_significant_params ||= @conditions.any? { |method, condition|
+        (condition.respond_to?(:required_params) && condition.required_params.any?) ||
+          (condition.respond_to?(:required_defaults) && condition.required_defaults.any?)
+      }
+    end
+
+    def generate(method, params = {}, recall = {}, options = {})
+      if method.nil?
+        result = @conditions.inject({}) { |h, (m, condition)|
+          if condition.respond_to?(:generate)
+            h[m] = condition.generate(params, recall, options)
+          end
+          h
+        }
+        return nil if result.values.compact.empty?
+      else
+        if condition = @conditions[method]
+          if condition.respond_to?(:generate)
+            result = condition.generate(params, recall, options)
+          end
+        end
+      end
+
+      if result
+        @defaults.each do |key, value|
+          params.delete(key) if params[key] == value
+        end
+      end
+
+      result
+    end
+
+
     def inspect #:nodoc:
       "#<#{self.class.name} @app=#{@app.inspect} @conditions=#{@conditions.inspect} @defaults=#{@defaults.inspect} @name=#{@name.inspect}>"
     end

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,12 +19,19 @@ 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 = begin
-        conditions = @request_class.public_instance_methods
-        conditions.map! { |m| m.to_sym }
-        conditions
-      end
+      @valid_conditions = @request_class.public_instance_methods.map! { |m| m.to_sym }
+
+      extend CodeGeneration unless options[:_optimize] == false
+      @optimized_recognize_defined = false
 
       @routes = []
       expire!
@@ -49,26 +52,191 @@ module Rack::Mount
     # <tt>name</tt>:: Symbol identifier for the route used with named
     #                 route generations
     def add_route(app, conditions = {}, defaults = {}, name = nil)
-      validate_conditions!(conditions)
+      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
@@ -77,6 +245,10 @@ module Rack::Mount
     end
 
     def rehash #:nodoc:
+      @recognition_keys  = build_recognition_keys
+      @recognition_graph = build_recognition_graph
+      @generation_keys   = build_generation_keys
+      @generation_graph  = build_generation_graph
     end
 
     # Finalizes the set and builds optimized data structures. You *must*
@@ -85,7 +257,11 @@ module Rack::Mount
     def freeze
       unless frozen?
         rehash
-        flush!
+
+        @recognition_key_analyzer = nil
+        @generation_key_analyzer  = nil
+        @valid_conditions         = nil
+
         @routes.each { |route| route.freeze }
         @routes.freeze
       end
@@ -104,44 +280,35 @@ module Rack::Mount
         hash[:@recognition_graph] = graph.dup
       end
 
-      included_modules = (class << self; included_modules; end)
-      included_modules.reject! { |mod| mod == Kernel }
-      hash[:included_modules] = included_modules
-
       hash
     end
 
     def marshal_load(hash) #:nodoc:
-      hash.delete(:included_modules).reverse.each { |mod| extend(mod) }
-
       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:
-      end
+        @recognition_keys = @recognition_graph = nil
+        @recognition_key_analyzer.expire!
 
-      def flush! #:nodoc:
-        @valid_conditions = nil
+        @generation_keys = @generation_graph = nil
+        @generation_key_analyzer.expire!
       end
 
       def instance_variables_to_serialize
-        instance_variables.map { |ivar| ivar.to_sym }
-      end
-
-      def validate_conditions!(conditions)
-        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
+        instance_variables.map { |ivar| ivar.to_sym } - [:@stubbed_request_class, :@optimized_recognize_defined]
       end
 
       # An internal helper method for constructing a nested set from
@@ -162,5 +329,81 @@ module Rack::Mount
         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
+        @recognition_key_analyzer.report
+      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
+        @generation_key_analyzer.report
+      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