rack-mount 0.0.1 → 0.0.2

data/lib/rack/mount/prefix.rb

@@ -2,29 +2,28 @@ require 'rack/mount/utils'
 
 module Rack::Mount
   class Prefix #:nodoc:
-    KEY = 'rack.mount.prefix'.freeze
+    EMPTY_STRING = ''.freeze
+    PATH_INFO    = 'PATH_INFO'.freeze
+    SCRIPT_NAME  = 'SCRIPT_NAME'.freeze
+    SLASH        = '/'.freeze
 
-    def initialize(app, prefix = nil)
+    def initialize(app, prefix)
       @app, @prefix = app, prefix.freeze
       freeze
     end
 
     def call(env)
-      if prefix = env[KEY] || @prefix
-        old_path_info = env[Const::PATH_INFO].dup
-        old_script_name = env[Const::SCRIPT_NAME].dup
+      old_path_info = env[PATH_INFO].dup
+      old_script_name = env[SCRIPT_NAME].dup
 
-        begin
-          env[Const::PATH_INFO] = Utils.normalize_path(env[Const::PATH_INFO].sub(prefix, Const::EMPTY_STRING))
-          env[Const::PATH_INFO] = Const::EMPTY_STRING if env[Const::PATH_INFO] == Const::SLASH
-          env[Const::SCRIPT_NAME] = Utils.normalize_path(env[Const::SCRIPT_NAME].to_s + prefix)
-          @app.call(env)
-        ensure
-          env[Const::PATH_INFO] = old_path_info
-          env[Const::SCRIPT_NAME] = old_script_name
-        end
-      else
+      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
     end
   end

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

@@ -1,98 +1,88 @@
-require 'rack/mount/meta_method'
-
 module Rack::Mount
   module Recognition
     module CodeGeneration #:nodoc:
-      def _expired_call(env) #:nodoc:
+      def _expired_recognize(env) #:nodoc:
         raise 'route set not finalized'
       end
 
       def rehash
         super
-        optimize_call!
+        optimize_recognize!
       end
 
       private
         def expire!
           class << self
-            alias_method :call, :_expired_call
+            undef :recognize
+            alias_method :recognize, :_expired_recognize
           end
 
           super
         end
 
         def optimize_container_iterator(container)
-          m = MetaMethod.new(:optimized_each, :req)
-          m << 'env = req.env'
+          body = []
 
           container.each_with_index { |route, i|
-            path_info_unanchored = route.conditions[:path_info] &&
-              !Utils.regexp_anchored?(route.conditions[:path_info])
-            m << "route = self[#{i}]"
-            m << 'routing_args = route.defaults.dup'
+            body << "route = self[#{i}]"
+            body << 'params = route.defaults.dup'
 
-            m << matchers = MetaMethod::Condition.new do |body|
-              body << "env[#{@parameters_key.inspect}] = routing_args"
-              body << "response = route.app.call(env)"
-              body << "return response unless response[0].to_i == 417"
+            conditions = []
+            route.conditions.each do |method, condition|
+              b = []
+              b << "if m = obj.#{method}.match(#{condition.inspect})"
+              b << 'matches = m.captures' if route.named_captures[method].any?
+              b << 'p = nil' if route.named_captures[method].any?
+              b << route.named_captures[method].map { |k, j| "params[#{k.inspect}] = p if p = matches[#{j}]" }.join('; ')
+              b << 'true'
+              b << 'end'
+              conditions << "(#{b.join('; ')})"
             end
 
-            route.conditions.each do |method, condition|
-              matchers << MetaMethod::Block.new do |matcher|
-                matcher << c = MetaMethod::Condition.new("m = req.#{method}.match(#{condition.inspect})") do |b|
-                  b << "matches = m.captures" if route.named_captures[method].any?
-                  route.named_captures[method].each do |k, i|
-                    b << MetaMethod::Condition.new("p = matches[#{i}]") do |c2|
-                      c2 << "routing_args[#{k.inspect}] = Utils.unescape_uri(p)"
-                    end
-                  end
-                  if method == :path_info && !Utils.regexp_anchored?(condition)
-                    b << "env[Prefix::KEY] = m.to_s"
-                  end
-                  b << "true"
-                end
-                c.else = MetaMethod::Block.new("false")
+            body << <<-RUBY
+              if #{conditions.join(' && ')}
+                yield route, params
               end
-            end
+            RUBY
           }
 
-          m << 'nil'
-          # puts "\n#{m.inspect}"
-          container.instance_eval(m, __FILE__, __LINE__)
+          container.instance_eval(<<-RUBY, __FILE__, __LINE__)
+            def optimized_each(obj)
+              #{body.join("\n")}
+              nil
+            end
+          RUBY
         end
 
-        def optimize_call!
-          method = MetaMethod.new(:call, :env)
+        def optimize_recognize!
+          keys = @recognition_keys.map { |key|
+            if key.is_a?(Array)
+              key.call_source(:cache, :obj)
+            else
+              "obj.#{key}"
+            end
+          }.join(', ')
 
-          if @routes.empty?
-            method << 'env[Const::EXPECT] != Const::CONTINUE ? Const::NOT_FOUND_RESPONSE : Const::EXPECTATION_FAILED_RESPONSE'
-          else
-            method << 'begin'
-            method << 'set_expectation = env[Const::EXPECT] != Const::CONTINUE'
-            method << 'env[Const::EXPECT] = Const::CONTINUE if set_expectation'
+          instance_eval(<<-RUBY, __FILE__, __LINE__)
+            undef :recognize
+            def recognize(obj, &block)
+              cache = {}
+              container = @recognition_graph[#{keys}]
+              optimize_container_iterator(container) unless container.respond_to?(:optimized_each)
 
-            method << 'env[Const::PATH_INFO] = Utils.normalize_path(env[Const::PATH_INFO])'
-            method << "req = #{@request_class.name}.new(env)"
-            cache = false
-            keys = @recognition_keys.map { |key|
-              if key.is_a?(Array)
-                cache = true
-                key.call_source(:cache, :req)
+              if block_given?
+                container.optimized_each(obj) do |route, params|
+                  yield route, params
+                end
               else
-                "req.#{key}"
+                container.optimized_each(obj) do |route, params|
+                  return route, params
+                end
               end
-            }.join(', ')
-            method << 'cache = {}' if cache
-            method << "container = @recognition_graph[#{keys}]"
-            method << "optimize_container_iterator(container) unless container.respond_to?(:optimized_each)"
-            method << "container.optimized_each(req) || (set_expectation ? Const::NOT_FOUND_RESPONSE : Const::EXPECTATION_FAILED_RESPONSE)"
-            method << 'ensure'
-            method << 'env.delete(Const::EXPECT) if set_expectation'
-            method << 'end'
-          end
 
-          # puts "\n#{method.inspect}"
-          instance_eval(method, __FILE__, __LINE__)
+              nil
+            end
+          RUBY
         end
     end
   end

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

@@ -1,4 +1,4 @@
-require 'rack/mount/prefix'
+require 'rack/mount/utils'
 
 module Rack::Mount
   module Recognition
@@ -8,12 +8,6 @@ module Rack::Mount
       def initialize(*args)
         super
 
-        # TODO: Don't explict check for :path_info condition
-        if @conditions.has_key?(:path_info) &&
-            !Utils.regexp_anchored?(@conditions[:path_info])
-          @app = Prefix.new(@app)
-        end
-
         @named_captures = {}
         @conditions.map { |method, condition|
           @named_captures[method] = condition.named_captures.inject({}) { |named_captures, (k, v)|
@@ -24,34 +18,25 @@ module Rack::Mount
         @named_captures.freeze
       end
 
-      def call(req)
-        env = req.env
-
-        routing_args = @defaults.dup
+      def recognize(obj)
+        params = @defaults.dup
         if @conditions.all? { |method, condition|
-          value = req.send(method)
+          value = obj.send(method)
           if m = value.match(condition)
             matches = m.captures
             @named_captures[method].each { |k, i|
               if v = matches[i]
-                # TODO: We only want to unescape params from
-                # uri related methods
-                routing_args[k] = Utils.unescape_uri(v)
+                params[k] = v
               end
             }
-            # TODO: Don't explict check for :path_info condition
-            if method == :path_info && !Utils.regexp_anchored?(condition)
-              env[Prefix::KEY] = m.to_s
-            end
             true
           else
             false
           end
         }
-          env[@set.parameters_key] = routing_args
-          @app.call(env)
+          params
         else
-          Const::EXPECTATION_FAILED_RESPONSE
+          nil
         end
       end
     end

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

@@ -7,7 +7,7 @@ module Rack::Mount
 
       # Adds recognition related concerns to RouteSet.new.
       def initialize(options = {})
-        @parameters_key = options.delete(:parameters_key) || Const::RACK_ROUTING_ARGS
+        @parameters_key = options.delete(:parameters_key) || 'rack.routing_args'
         @parameters_key.freeze
         @recognition_key_analyzer = Analysis::Frequency.new_with_module(Analysis::Splitting)
 
@@ -21,6 +21,33 @@ module Rack::Mount
         route
       end
 
+      def recognize(obj)
+        raise 'route set not finalized' unless @recognition_graph
+
+        cache = {}
+        keys = @recognition_keys.map { |key|
+          if key.is_a?(Array)
+            key.call(cache, obj)
+          else
+            obj.send(key)
+          end
+        }
+        @recognition_graph[*keys].each do |route|
+          if params = route.recognize(obj)
+            if block_given?
+              yield route, params
+            else
+              return route, params
+            end
+          end
+        end
+
+        nil
+      end
+
+      EXPECT    = 'Expect'.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.
@@ -30,27 +57,24 @@ module Rack::Mount
       def call(env)
         raise 'route set not finalized' unless @recognition_graph
 
-        set_expectation = env[Const::EXPECT] != Const::CONTINUE
-        env[Const::EXPECT] = Const::CONTINUE if set_expectation
+        set_expectation = env[EXPECT] != '100-continue'
+        env[EXPECT] = '100-continue' if set_expectation
 
-        env[Const::PATH_INFO] = Utils.normalize_path(env[Const::PATH_INFO])
+        env[PATH_INFO] = Utils.normalize_path(env[PATH_INFO])
 
-        cache = {}
         req = @request_class.new(env)
-        keys = @recognition_keys.map { |key|
-          if key.is_a?(Array)
-            key.call(cache, req)
-          else
-            req.send(key)
-          end
-        }
-        @recognition_graph[*keys].each do |route|
-          result = route.call(req)
+        recognize(req) do |route, 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) }
+
+          env[@parameters_key] = params
+          result = route.app.call(env)
           return result unless result[0].to_i == 417
         end
-        set_expectation ? Const::NOT_FOUND_RESPONSE : Const::EXPECTATION_FAILED_RESPONSE
+
+        set_expectation ? [404, {'Content-Type' => 'text/html'}, ['Not Found']] : [417, {'Content-Type' => 'text/html'}, ['Expectation failed']]
       ensure
-        env.delete(Const::EXPECT) if set_expectation
+        env.delete(EXPECT) if set_expectation
       end
 
       def rehash #:nodoc:

data/lib/rack/mount/regexp_with_named_groups.rb

@@ -1,7 +1,15 @@
-require 'rack/mount/utils'
-
 module Rack::Mount
-  unless Const::SUPPORTS_NAMED_CAPTURES
+  begin
+    eval('/(?<foo>.*)/').named_captures
+
+    class RegexpWithNamedGroups < Regexp
+      def self.supports_named_captures?
+        true
+      end
+    end
+  rescue SyntaxError, NoMethodError
+    require 'strscan'
+
     # A wrapper that adds shim named capture support to older
     # versions of Ruby.
     #
@@ -16,6 +24,10 @@ module Rack::Mount
     #
     #   /(?:<foo>[a-z]+)/
     class RegexpWithNamedGroups < Regexp
+      def self.supports_named_captures?
+        false
+      end
+
       def self.new(regexp) #:nodoc:
         if regexp.is_a?(RegexpWithNamedGroups)
           regexp
@@ -26,9 +38,25 @@ module Rack::Mount
 
       # Wraps Regexp with named capture support.
       def initialize(regexp)
-        regexp, @names = Utils.extract_named_captures(regexp)
+        regexp = Regexp.compile(regexp) unless regexp.is_a?(Regexp)
+        source, options = regexp.source, regexp.options
+        @names, scanner = [], StringScanner.new(source)
+
+        while scanner.skip_until(/\(/)
+          if scanner.scan(/\?:<([^>]+)>/)
+            @names << scanner[1]
+          elsif scanner.scan(/\?:/)
+            # ignore
+          else
+            @names << nil
+          end
+        end
+        source.gsub!(/\?:<([^>]+)>/, '')
+
+        @names = [] unless @names.any?
         @names.freeze
-        super(regexp)
+
+        super(source, options)
       end
 
       def names
@@ -43,7 +71,5 @@ module Rack::Mount
         named_captures
       end
     end
-  else
-    RegexpWithNamedGroups = Regexp
   end
 end

data/lib/rack/mount/route_set.rb

@@ -40,7 +40,7 @@ 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)
@@ -98,10 +98,12 @@ 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_nils!(k)
+            k.map! { |key| key || /.+/ }
+            graph[*k] = route
+          end
         end
         graph
       end

data/lib/rack/mount/strexp.rb

@@ -1,4 +1,4 @@
-require 'strscan'
+require 'rack/mount/strexp/parser'
 
 module Rack::Mount
   class Strexp < Regexp
@@ -24,14 +24,19 @@ module Rack::Mount
     def initialize(str, requirements = {}, separators = [])
       return super(str) if str.is_a?(Regexp)
 
-      re = Regexp.escape(str)
       requirements = requirements ? requirements.dup : {}
-
       normalize_requirements!(requirements, separators)
-      parse_dynamic_segments!(re, requirements)
-      parse_optional_segments!(re)
 
-      super("\\A#{re}\\Z")
+      parser = StrexpParser.new
+      parser.requirements = requirements
+
+      begin
+        re = parser.scan_str(str)
+      rescue Racc::ParseError => e
+        raise RegexpError, e.message
+      end
+
+      super(re)
     end
 
     private
@@ -52,40 +57,6 @@ module Rack::Mount
         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)
-      end
-
-      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 + ')?'
-          end
-        end
-        re << scanner.rest
-        str.replace(re)
-      end
-
       def regexp_has_modifiers?(regexp)
         regexp.options & (Regexp::IGNORECASE | Regexp::EXTENDED) != 0
       end