rack-mount 0.4.7 → 0.5.0

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

@@ -5,11 +5,7 @@ module Rack::Mount
     module Splitting
       NULL = "\0".freeze
 
-      class Key < Array
-        def initialize(method, index, separators)
-          replace([method, index, separators])
-        end
-
+      class Key < Struct.new(:method, :index, :separators)
         def self.split(value, separator_pattern)
           keys = value.split(separator_pattern)
           keys.shift if keys[0] == ''
@@ -18,11 +14,15 @@ module Rack::Mount
         end
 
         def call(cache, obj)
-          (cache[self[0]] ||= self.class.split(obj.send(self[0]), self[2]))[self[1]]
+          (cache[method] ||= self.class.split(obj.send(method), separators))[index]
         end
 
         def call_source(cache, obj)
-          "(#{cache}[:#{self[0]}] ||= Analysis::Splitting::Key.split(#{obj}.#{self[0]}, #{self[2].inspect}))[#{self[1]}]"
+          "(#{cache}[:#{method}] ||= Analysis::Splitting::Key.split(#{obj}.#{method}, #{separators.inspect}))[#{index}]"
+        end
+
+        def inspect
+          "#{method}[#{index}]"
         end
       end
 

data/lib/rack/mount/mixover.rb

@@ -4,6 +4,12 @@ module Rack::Mount
   # metaclass. This allows mixins to be stacked ontop of the instance
   # methods.
   module Mixover
+    def self.extended(klass)
+      klass.instance_eval do
+        @extended_modules = []
+      end
+    end
+
     module InstanceMethods #:nodoc:
       def dup
         obj = super
@@ -15,33 +21,40 @@ module Rack::Mount
 
     # Replaces include with a lazy version.
     def include(*mod)
-      (@included_modules ||= []).push(*mod)
+      extended_modules.push(*mod)
+    end
+
+    def extended_modules
+      Thread.current[extended_modules_thread_local_key] || @extended_modules
     end
 
     def new(*args, &block) #:nodoc:
       obj = allocate
       obj.extend(InstanceMethods)
-      (@included_modules ||= []).each { |mod| obj.extend(mod) }
+      extended_modules.each { |mod| obj.extend(mod) }
       obj.send(:initialize, *args, &block)
       obj
     end
 
     # Create a new class without an included module.
     def new_without_module(mod, *args, &block)
-      old_included_modules = (@included_modules ||= []).dup
-      @included_modules.delete(mod)
+      (Thread.current[extended_modules_thread_local_key] = extended_modules.dup).delete(mod)
       new(*args, &block)
     ensure
-      @included_modules = old_included_modules
+      Thread.current[extended_modules_thread_local_key] = nil
     end
 
     # Create a new class temporarily with a module.
     def new_with_module(mod, *args, &block)
-      old_included_modules = (@included_modules ||= []).dup
-      include(mod)
+      (Thread.current[extended_modules_thread_local_key] = extended_modules.dup).push(*mod)
       new(*args, &block)
     ensure
-      @included_modules = old_included_modules
+      Thread.current[extended_modules_thread_local_key] = nil
     end
+
+    private
+      def extended_modules_thread_local_key
+        "mixover_extended_modules_#{object_id}"
+      end
   end
 end

data/lib/rack/mount/prefix.rb

@@ -7,23 +7,29 @@ module Rack::Mount
     SCRIPT_NAME  = 'SCRIPT_NAME'.freeze
     SLASH        = '/'.freeze
 
-    def initialize(app, prefix)
+    KEY = 'rack.mount.prefix'.freeze
+
+    def initialize(app, prefix = nil)
       @app, @prefix = app, prefix.freeze
       freeze
     end
 
     def call(env)
-      old_path_info = env[PATH_INFO].dup
-      old_script_name = env[SCRIPT_NAME].dup
+      if prefix = env[KEY] || @prefix
+        old_path_info = env[PATH_INFO].dup
+        old_script_name = env[SCRIPT_NAME].dup
 
-      begin
-        env[PATH_INFO] = Utils.normalize_path(env[PATH_INFO].sub(@prefix, EMPTY_STRING))
-        env[PATH_INFO] = EMPTY_STRING if env[PATH_INFO] == SLASH
-        env[SCRIPT_NAME] = Utils.normalize_path(env[SCRIPT_NAME].to_s + @prefix)
+        begin
+          env[PATH_INFO] = Utils.normalize_path(env[PATH_INFO].sub(prefix, EMPTY_STRING))
+          env[PATH_INFO] = EMPTY_STRING if env[PATH_INFO] == SLASH
+          env[SCRIPT_NAME] = Utils.normalize_path(env[SCRIPT_NAME].to_s + prefix)
+          @app.call(env)
+        ensure
+          env[PATH_INFO] = old_path_info
+          env[SCRIPT_NAME] = old_script_name
+        end
+      else
         @app.call(env)
-      ensure
-        env[PATH_INFO] = old_path_info
-        env[SCRIPT_NAME] = old_script_name
       end
     end
   end

data/lib/rack/mount/recognition/code_generation.rb

@@ -39,6 +39,7 @@ module Rack::Mount
 
           container.each_with_index { |route, i|
             body << "route = self[#{i}]"
+            body << 'matches = {}'
             body << 'params = route.defaults.dup'
 
             conditions = []
@@ -46,10 +47,11 @@ module Rack::Mount
               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 << 'matches = m.captures'
+                  b << 'captures = m.captures'
                   b << 'p = nil'
-                  b << named_captures.map { |k, j| "params[#{k.inspect}] = p if p = matches[#{j}]" }.join('; ')
+                  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}]"
@@ -61,7 +63,7 @@ module Rack::Mount
 
             body << <<-RUBY
               if #{conditions.join(' && ')}
-                yield route, params
+                yield route, matches, params
               end
             RUBY
           }
@@ -76,7 +78,7 @@ module Rack::Mount
 
         def optimize_recognize!
           keys = @recognition_keys.map { |key|
-            if key.is_a?(Array)
+            if key.respond_to?(:call_source)
               key.call_source(:cache, :obj)
             else
               "obj.#{key}"
@@ -94,12 +96,12 @@ module Rack::Mount
               optimize_container_iterator(container) unless container.respond_to?(:optimized_each)
 
               if block_given?
-                container.optimized_each(obj) do |route, params|
-                  yield route, params
+                container.optimized_each(obj) do |route, matches, params|
+                  yield route, matches, params
                 end
               else
-                container.optimized_each(obj) do |route, params|
-                  return route, params
+                container.optimized_each(obj) do |route, matches, params|
+                  return route, matches, params
                 end
               end
 

data/lib/rack/mount/recognition/route.rb

@@ -17,16 +17,31 @@ module Rack::Mount
           }.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
+      end
+
+      def prefix?
+        @prefix
       end
 
       def recognize(obj)
-        params = @defaults.dup
+        matches = {}
+        params  = @defaults.dup
+
         if @conditions.all? { |method, condition|
           value = obj.send(method)
           if condition.is_a?(Regexp) && (m = value.match(condition))
-            matches = m.captures
+            matches[method] = m
+            captures = m.captures
             @named_captures[method].each { |k, i|
-              if v = matches[i]
+              if v = captures[i]
                 params[k] = v
               end
             }
@@ -37,7 +52,7 @@ module Rack::Mount
             false
           end
         }
-          params
+          return matches, params
         else
           nil
         end

data/lib/rack/mount/recognition/route_set.rb

@@ -26,18 +26,19 @@ module Rack::Mount
 
         cache = {}
         keys = @recognition_keys.map { |key|
-          if key.is_a?(Array)
+          if key.respond_to?(:call_source)
             key.call(cache, obj)
           else
             obj.send(key)
           end
         }
         @recognition_graph[*keys].each do |route|
-          if params = route.recognize(obj)
+          matches, params = route.recognize(obj)
+          if matches && params
             if block_given?
-              yield route, params
+              yield route, matches, params
             else
-              return route, params
+              return route, matches, params
             end
           end
         end
@@ -62,10 +63,14 @@ module Rack::Mount
 
         request = nil
         req = @request_class.new(env)
-        recognize(req) do |route, params|
+        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
@@ -81,6 +86,15 @@ module Rack::Mount
         super
       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!
           @recognition_keys = @recognition_graph = nil

data/lib/rack/mount/strexp.rb

@@ -21,13 +21,14 @@ module Rack::Mount
     #
     #   Strexp.compile('src/*files')
     #     # => %r{\Asrc/(?<files>.+)\Z}
-    def initialize(str, requirements = {}, separators = [])
+    def initialize(str, requirements = {}, separators = [], anchor = true)
       return super(str) if str.is_a?(Regexp)
 
       requirements = requirements ? requirements.dup : {}
       normalize_requirements!(requirements, separators)
 
       parser = StrexpParser.new
+      parser.anchor = anchor
       parser.requirements = requirements
 
       begin

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

@@ -20,7 +20,7 @@ else
   REGEXP_NAMED_CAPTURE = '(?:<%s>%s)'.freeze
 end
 
-attr_accessor :requirements
+attr_accessor :anchor, :requirements
 ##### State transition tables begin ###
 
 racc_action_table = [
@@ -114,7 +114,7 @@ Racc_debug_parser = false
 # reduce 0 omitted
 
 def _reduce_1(val, _values, result)
- result = "\\A#{val.join}\\Z" 
+ result = anchor ? "\\A#{val.join}\\Z" : "\\A#{val.join}" 
     result
 end
 

data/lib/rack/mount/utils.rb

@@ -88,6 +88,17 @@ module Rack::Mount
     end
     module_function :build_nested_query
 
+    # Determines whether the regexp must match the entire string.
+    #
+    #   regexp_anchored?(/^foo$/) # => true
+    #   regexp_anchored?(/foo/)   # => false
+    #   regexp_anchored?(/^foo/)  # => false
+    #   regexp_anchored?(/foo$/)  # => false
+    def regexp_anchored?(regexp)
+     regexp.source =~ /\A(\\A|\^).*(\\Z|\$)\Z/ ? true : false
+    end
+    module_function :regexp_anchored?
+
     def normalize_extended_expression(regexp)
       return regexp unless regexp.options & Regexp::EXTENDED != 0
       source = regexp.source

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rack-mount
 version: !ruby/object:Gem::Version 
-  version: 0.4.7
+  version: 0.5.0
 platform: ruby
 authors: 
 - Joshua Peek