rack-mount 0.6.13 → 0.8.3

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

@@ -2,8 +2,8 @@ require 'rack/mount/utils'
 
 module Rack::Mount
   module Analysis
-    class Splitting < Frequency
-      NULL = "\0".freeze
+    class Splitting
+      NULL = "\0"
 
       class Key < Struct.new(:method, :index, :separators)
         def self.split(value, separator_pattern)
@@ -26,26 +26,44 @@ module Rack::Mount
         end
       end
 
+      def initialize(*keys)
+        clear
+        keys.each { |key| self << key }
+      end
+
       def clear
-        @boundaries = {}
-        super
+        @raw_keys = []
+        @key_frequency = Analysis::Histogram.new
+        self
       end
 
       def <<(key)
-        super
-        key.each_pair do |k, v|
-          analyze_capture_boundaries(v, @boundaries[k] ||= Histogram.new)
+        raise ArgumentError unless key.is_a?(Hash)
+        @raw_keys << key
+        nil
+      end
+
+      def possible_keys
+        @possible_keys ||= begin
+          @raw_keys.map do |key|
+            key.inject({}) { |requirements, (method, requirement)|
+              process_key(requirements, method, requirement)
+              requirements
+            }
+          end
         end
       end
 
-      def separators(key)
-        @separators ||= {}
-        @separators[key] ||= lookup_separators(key)
+      def report
+        @report ||= begin
+          possible_keys.each { |keys| keys.each_pair { |key, _| @key_frequency << key } }
+          return [] if @key_frequency.count <= 1
+          @key_frequency.keys_in_upper_quartile
+        end
       end
-      attr_writer :separators
 
-      def lookup_separators(key)
-        @boundaries[key].keys_in_upper_quartile
+      def expire!
+        @possible_keys = @report = nil
       end
 
       def process_key(requirements, method, requirement)
@@ -55,40 +73,22 @@ module Rack::Mount
             requirements[Key.new(method, index, Regexp.union(*separators))] = value
           end
         else
-          super
-        end
-      end
-
-      private
-        def analyze_capture_boundaries(regexp, boundaries) #:nodoc:
-          return boundaries unless regexp.is_a?(Regexp)
-
-          parts = Utils.parse_regexp(regexp)
-          parts.each_with_index do |part, index|
-            if part.is_a?(Regin::Group)
-              if index > 0
-                previous = parts[index-1]
-                if previous.is_a?(Regin::Character) && previous.literal?
-                  boundaries << previous.to_s
-                end
-              end
-
-              if inside = part.expression[0]
-                if inside.is_a?(Regin::Character) && inside.literal?
-                  boundaries << inside.to_s
-                end
-              end
+          if requirement.is_a?(Regexp)
+            expression = Utils.parse_regexp(requirement)
 
-              if index < parts.length
-                following = parts[index+1]
-                if following.is_a?(Regin::Character) && following.literal?
-                  boundaries << following.to_s
-                end
-              end
+            if expression.is_a?(Regin::Expression) && expression.anchored_to_line?
+              expression = Regin::Expression.new(expression.reject { |e| e.is_a?(Regin::Anchor) })
+              return requirements[method] = expression.to_s if expression.literal?
             end
           end
 
-          boundaries
+          requirements[method] = requirement
+        end
+      end
+
+      private
+        def separators(key)
+          key == :path_info ? ["/", "."] : []
         end
 
         def generate_split_keys(regexp, separators) #:nodoc:

data/lib/rack/mount/code_generation.rb

@@ -71,8 +71,11 @@ module Rack::Mount
       def optimize_recognize!
         Utils.debug "optimizing recognize"
 
+        uses_cache = false
+
         keys = @recognition_keys.map { |key|
           if key.respond_to?(:call_source)
+            uses_cache = true
             key.call_source(:cache, :obj)
           else
             "obj.#{key}"
@@ -85,7 +88,7 @@ module Rack::Mount
 
         instance_eval(<<-RUBY, __FILE__, __LINE__)
           def recognize(obj)
-            cache = {}
+            #{"cache = {}" if uses_cache}
             container = @recognition_graph[#{keys}]
             optimize_container_iterator(container) unless container.respond_to?(:optimized_each)
 
@@ -110,7 +113,7 @@ module Rack::Mount
       def remove_metaclass_method(symbol)
         metaclass = class << self; self; end
         Utils.silence_debug { metaclass.send(:remove_method, symbol) }
-      rescue NameError => e
+      rescue NameError
         nil
       end
   end

data/lib/rack/mount/multimap.rb

@@ -1,12 +1,16 @@
-begin
-  require 'nested_multimap'
-rescue LoadError
-  $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/multimap'))
-  require 'nested_multimap'
-end
-
 module Rack::Mount
-  class Multimap < NestedMultimap #:nodoc:
+  class Multimap #:nodoc:
+    def initialize(default = [])
+      @hash = Hash.new(default)
+    end
+
+    def initialize_copy(original)
+      @hash = Hash.new(original.default.dup)
+      original.hash.each_pair do |key, container|
+        @hash[key] = container.dup
+      end
+    end
+
     def store(*args)
       keys  = args.dup
       value = keys.pop
@@ -26,7 +30,7 @@ module Rack::Mount
           @hash.each_pair { |k, _|
             if k =~ key
               args[0] = k
-              super(*args)
+              _store(*args)
             end
           }
 
@@ -34,12 +38,19 @@ module Rack::Mount
           default[*keys.dup] = value
         end
       else
-        super(*args)
+        _store(*args)
       end
     end
     alias_method :[]=, :store
 
-    undef :index, :invert
+    def [](*keys)
+      i, l, r, k = 0, keys.length, self, self.class
+      while r.is_a?(k)
+        r = i < l ? r.hash[keys[i]] : r.default
+        i += 1
+      end
+      r
+    end
 
     def height
       containers_with_default.max { |a, b| a.length <=> b.length }.length
@@ -49,5 +60,78 @@ module Rack::Mount
       lengths = containers_with_default.map { |e| e.length }
       lengths.inject(0) { |sum, len| sum += len }.to_f / lengths.size
     end
+
+    def containers_with_default
+      containers = []
+      each_container_with_default { |container| containers << container }
+      containers
+    end
+
+    protected
+      def _store(*args)
+        keys  = args
+        value = args.pop
+
+        raise ArgumentError, 'wrong number of arguments (1 for 2)' unless value
+
+        if keys.length > 1
+          update_container(keys.shift) do |container|
+            container = self.class.new(container) unless container.is_a?(self.class)
+            container[*keys] = value
+            container
+          end
+        elsif keys.length == 1
+          update_container(keys.first) do |container|
+            container << value
+            container
+          end
+        else
+          self << value
+        end
+      end
+
+      def <<(value)
+        @hash.each_value { |container| container << value }
+        self.default << value
+        self
+      end
+
+      def each_container_with_default(&block)
+        @hash.each_value do |container|
+          iterate_over_container(container, &block)
+        end
+        iterate_over_container(default, &block)
+        self
+      end
+
+      def default
+        @hash.default
+      end
+
+      def default=(value)
+        @hash.default = value
+      end
+
+      def hash
+        @hash
+      end
+
+    private
+      def update_container(key)
+        container = @hash[key]
+        container = container.dup if container.equal?(default)
+        container = yield(container)
+        @hash[key] = container
+      end
+
+      def iterate_over_container(container)
+        if container.respond_to?(:each_container_with_default)
+          container.each_container_with_default do |value|
+            yield value
+          end
+        else
+          yield container
+        end
+      end
   end
 end

data/lib/rack/mount/prefix.rb

@@ -10,7 +10,7 @@ module Rack::Mount
     KEY = 'rack.mount.prefix'.freeze
 
     def initialize(app, prefix = nil)
-      @app, @prefix = app, prefix.freeze
+      @app, @prefix = app, prefix
       freeze
     end
 

data/lib/rack/mount/route.rb

@@ -54,10 +54,9 @@ module Rack::Mount
       @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[method] = Hash[condition.named_captures.map { |k, v|
+          [k.to_sym, v.last - 1]
+        }].freeze
       }
       @named_captures.freeze
 
@@ -83,7 +82,7 @@ module Rack::Mount
 
 
     def generation_keys
-      @conditions.inject({}) { |keys, (method, condition)|
+      @conditions.inject({}) { |keys, (_, condition)|
         if condition.respond_to?(:required_defaults)
           keys.merge!(condition.required_defaults)
         else
@@ -98,12 +97,9 @@ module Rack::Mount
 
     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
-        }
+        result = Hash[@conditions.map { |m, condition|
+          [m, condition.generate(params, recall, options)] if condition.respond_to?(:generate)
+        }]
         return nil if result.values.compact.empty?
       else
         if condition = @conditions[method]

data/lib/rack/mount/route_set.rb

@@ -25,7 +25,9 @@ module Rack::Mount
       @named_routes = {}
 
       @recognition_key_analyzer = Analysis::Splitting.new
-      @generation_key_analyzer  = Analysis::Frequency.new
+
+      @generation_keys = [:controller, :action]
+      @generation_route_keys = []
 
       @request_class = options.delete(:request_class) || Rack::Request
       @valid_conditions = @request_class.public_instance_methods.map! { |m| m.to_sym }
@@ -69,7 +71,7 @@ module Rack::Mount
       @recognition_key_analyzer << route.conditions
 
       @named_routes[route.name] = route if route.name
-      @generation_key_analyzer << route.generation_keys
+      @generation_route_keys << route.generation_keys
 
       expire!
       route
@@ -125,7 +127,7 @@ module Rack::Mount
 
     # 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.
+    # match, then catch status code is returned.
     #
     # This method can only be invoked after the RouteSet has been
     # finalized.
@@ -144,9 +146,16 @@ module Rack::Mount
           env[Prefix::KEY] = matches[:path_info].to_s
         end
 
-        env[@parameters_key] = params
+        old_params = env[@parameters_key]
+        env[@parameters_key] = (old_params || {}).merge(params)
+
         result = route.app.call(env)
-        return result unless result[1][X_CASCADE] == PASS
+
+        if result[1][X_CASCADE] == PASS
+          env[@parameters_key] = old_params
+        else
+          return result
+        end
       end
 
       request || [404, {'Content-Type' => 'text/html', 'X-Cascade' => 'pass'}, ['Not Found']]
@@ -160,7 +169,7 @@ module Rack::Mount
     # 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
+    # If no named route is given, it will fall back to a slower
     # generation search.
     #   url(env, :controller => "people", :action => "show", :id => "1")
     #     # => "/people/1"
@@ -249,7 +258,6 @@ module Rack::Mount
 
       @recognition_keys  = build_recognition_keys
       @recognition_graph = build_recognition_graph
-      @generation_keys   = build_generation_keys
       @generation_graph  = build_generation_graph
 
       self
@@ -261,9 +269,10 @@ module Rack::Mount
     def freeze
       unless frozen?
         rehash
+        stubbed_request_class
 
         @recognition_key_analyzer = nil
-        @generation_key_analyzer  = nil
+        @generation_route_keys    = nil
         @valid_conditions         = nil
 
         @routes.each { |route| route.freeze }
@@ -273,26 +282,6 @@ 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,
@@ -307,12 +296,7 @@ module Rack::Mount
         @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]
+        @generation_graph = nil
       end
 
       # An internal helper method for constructing a nested set from
@@ -350,7 +334,7 @@ module Rack::Mount
         build_nested_route_set(@generation_keys) { |k, i|
           throw :skip unless @routes[i].significant_params?
 
-          if k = @generation_key_analyzer.possible_keys[i][k]
+          if k = @generation_route_keys[i][k]
             k.to_s
           else
             nil
@@ -358,12 +342,6 @@ module Rack::Mount
         }
       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

data/lib/rack/mount/utils.rb

@@ -116,7 +116,7 @@ module Rack::Mount
     module_function :regexp_anchored?
 
     def normalize_extended_expression(regexp)
-      return regexp unless regexp.options & Regexp::EXTENDED != 0
+      return regexp if (regexp.options & Regexp::EXTENDED) == 0
       source = regexp.source
       source.gsub!(/#.+$/, '')
       source.gsub!(/\s+/, '')

data/lib/rack/mount/vendor/regin/regin/group.rb

@@ -1,6 +1,6 @@
 module Regin
   class Group
-    attr_reader :expression, :quantifier, :capture, :index, :name
+    attr_reader :expression, :quantifier, :lookahead, :capture, :index, :name
 
     def initialize(expression, options = {})
       @quantifier = @index = @name = nil
@@ -8,6 +8,7 @@ module Regin
       @expression = expression.dup(options)
 
       @quantifier = options[:quantifier] if options.key?(:quantifier)
+      @lookahead  = options[:lookahead] if options.key?(:lookahead)
       @capture    = options[:capture] if options.key?(:capture)
       @index      = options[:index] if options.key?(:index)
       @name       = options[:name] if options.key?(:name)
@@ -21,11 +22,15 @@ module Regin
     #
     # A Group is literal if its expression is literal and it has no quantifier.
     def literal?
-      quantifier.nil? && expression.literal?
+      quantifier.nil? && lookahead.nil? && expression.literal?
     end
 
     def to_s(parent = false)
-      if !expression.options?
+      if lookahead == :postive
+        "(?=#{expression.to_s(parent)})#{quantifier}"
+      elsif lookahead == :negative
+        "(?!#{expression.to_s(parent)})#{quantifier}"
+      elsif !expression.options?
         "(#{capture ? '' : '?:'}#{expression.to_s(parent)})#{quantifier}"
       elsif capture == false
         "#{expression.to_s}#{quantifier}"