http_router 0.10.2 → 0.11.0

data/.gitignore

@@ -4,4 +4,5 @@ pkg
 rdoc
 Gemfile.lock
 .rvmrc
-*.rbc
+*.rbc
+js/npm-debug.log

data/Rakefile

@@ -96,10 +96,12 @@ namespace :test do
             c = $1
             raise "out was nil" if out.nil?
             test = out.shift
-            c.gsub!(/Last-Modified:.*?[\r\n]*/)
-            test.gsub!(/Last-Modified:.*?[\r\n]*/)
-            raise "expected #{c.inspect}, received #{test.inspect}" unless c.strip == test.strip
-            assertion_count += 1
+            if c['Last-Modified'] == test['Last-Modified']
+              assertion_count += 1
+            else
+              raise "expected #{c.inspect}, received #{test.inspect}" unless c.strip == test.strip
+              assertion_count += 1
+            end
           end
         end
         raise "no assertions were raised in #{example}" if assertion_count.zero?
@@ -131,7 +133,7 @@ namespace :test do
             msg = expected.dup
             msg << " was expected to be "
             msg << "\#{__example_runner.inspect}"
-            current_example << "raise \"#{msg.gsub('"', '\\"')}\" unless __example_runner.strip == #{expected}\n" if in_example
+            current_example << "raise \"#{msg.gsub('"', '\\"')}\" unless (__example_runner.respond_to?(:strip) ? __example_runner.strip : __example_runner) == #{expected}\n" if in_example
           when ''
             unless current_example.empty?
               examples << current_example

data/benchmarks/gen2.rb

@@ -10,7 +10,7 @@ u.add('/simple')
 u.add('/simple/:variable')                                                                           .name(:one_variable).to{}
 u.add('/simple/:var1/:var2/:var3')                                                                   .name(:three_variables).to{}
 u.add('/simple/:v1/:v2/:v3/:v4/:v5/:v6/:v7/:v8')                                                     .name(:eight_variables).to{}
-u.add('/with_condition/:cond1/:cond2').matching(:cond1 => /^\d+$/, :cond2 => /^[a-z]+$/)             .name(:two_conditions).to{}
+u.add('/with_condition/:cond1/:cond2').matches_with(:cond1 => /^\d+$/, :cond2 => /^[a-z]+$/)             .name(:two_conditions).to{}
 
 TIMES = 50_000
 

data/benchmarks/rack_mount.rb

@@ -3,12 +3,13 @@ require 'rbench'
 require 'rack'
 require 'rack/mount'
 #require '../usher/lib/usher'
-require 'lib/http_router'
+$: << 'lib'
+require 'http_router'
 
 set = Rack::Mount::RouteSet.new do |set|
   set.add_route(proc{|env| [200, {'Content-type'=>'text/html'}, []]}, {:path => '/simple'}, {}, :simple)
   set.add_route(proc{|env| [200, {'Content-type'=>'text/html'}, []]}, {:path => '/simple/again'}, {}, :again)
-  set.add_route(proc{|env| [200, {'Content-type'=>'text/html'}, []]}, {:path => '/dynamic/:variable'}, {}, :variable)
+  set.add_route(proc{|env| [200, {'Content-type'=>'text/html'}, []]}, {:path => %r{/simple/(.*?)}}, {}, :more)
 end
 
 #u = Usher::Interface.for(:rack)
@@ -16,32 +17,25 @@ end
 #u.add('/simple/again').to(proc{|env| [200, {'Content-type'=>'text/html'}, []]})
 #u.add('/dynamic/anything').to(proc{|env| [200, {'Content-type'=>'text/html'}, []]})
 
-hr = HttpRouter.new
-hr.add('/simple').to(proc{|env| [200, {'Content-type'=>'text/html'}, []]})
-hr.add('/simple/again').to(proc{|env| [200, {'Content-type'=>'text/html'}, []]})
-hr.add('/dynamic/anything').to(proc{|env| [200, {'Content-type'=>'text/html'}, []]})
-
 TIMES = 50_000
 
 simple_env = Rack::MockRequest.env_for('/simple')
 simple2_env = Rack::MockRequest.env_for('/simple/again')
-simple_and_dynamic_env = Rack::MockRequest.env_for('/dynamic/anything')
+dynamic_env = Rack::MockRequest.env_for('/simple/something')
 
-3.times do
 
   RBench.run(TIMES) do
 
     report "2 levels, static" do
-      set.url(simple_env, :simple)
+      set.call(simple_env).first == 200 or raise
     end
 
     report "4 levels, static" do
-      set.url(simple_env, :again)
+      set.call(simple2_env).first == 200 or raise
     end
 
-    report "4 levels, 1 dynamic" do
-      set.url(simple_env, :variable, {:variable => 'onemore'})
+    report "4 levels, static" do
+      set.call(dynamic_env).first == 200 or raise
     end
 
   end
-end

data/examples/rack_mapper.ru

@@ -1,19 +1,18 @@
 require 'http_router'
-HttpRouter::Rack.override_rack_builder!
+run HttpRouter.new do
+  add('/get/:id', :match_with => {:id => /\d+/}) { |env|
+    [200, {'Content-type' => 'text/plain'}, ["My id is #{env['router.params'][:id]}, which is a number\n"]]
+  }
 
-map('/get/:id', :matching => {:id => /\d+/}) { |env|
-  [200, {'Content-type' => 'text/plain'}, ["My id is #{env['router.params'][:id]}, which is a number\n"]]
-}
-
-# you have post, get, head, put and delete.
-post('/get/:id') { |env|
-  [200, {'Content-type' => 'text/plain'}, ["My id is #{env['router.params'][:id]} and you posted!\n"]]
-}
-
-map('/get/:id') { |env|
-  [200, {'Content-type' => 'text/plain'}, ["My id is #{env['router.params'][:id]}\n"]]
-}
+  # you have post, get, head, put and delete.
+  post('/get/:id') { |env|
+    [200, {'Content-type' => 'text/plain'}, ["My id is #{env['router.params'][:id]} and you posted!\n"]]
+  }
 
+  map('/get/:id') { |env|
+    [200, {'Content-type' => 'text/plain'}, ["My id is #{env['router.params'][:id]}\n"]]
+  }
+end
 
 # $ curl http://127.0.0.1:3000/get/foo
 # => My id is foo

data/examples/variable_with_regex.ru

@@ -1,7 +1,7 @@
 require 'http_router'
 
 run HttpRouter.new {
-  get('/get/:id').matching(:id => /\d+/).to { |env| [200, {'Content-type' => 'text/plain'}, ["id is #{Integer(env['router.params'][:id]) * 2} * 2\n"]]}
+  get('/get/:id', :id => /\d+/).to { |env| [200, {'Content-type' => 'text/plain'}, ["id is #{Integer(env['router.params'][:id]) * 2} * 2\n"]]}
 }
 
 # $ curl http://127.0.0.1:3000/get/123

data/http_router.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rbench'
   s.add_development_dependency 'json'
   s.add_development_dependency 'phocus'
-  s.add_development_dependency 'bundler',  '~> 1.0.0'
+  s.add_development_dependency 'bundler'
   s.add_development_dependency 'thin',  '= 1.2.8'
 
   if s.respond_to? :specification_version then

data/lib/http_router.rb

@@ -7,25 +7,29 @@ require 'http_router/node'
 require 'http_router/request'
 require 'http_router/response'
 require 'http_router/route'
-require 'http_router/rack'
-require 'http_router/regex_route'
+require 'http_router/generator'
+require 'http_router/route_helper'
+require 'http_router/generation_helper'
+require 'http_router/regex_route_generation'
 require 'http_router/util'
 
 class HttpRouter
-
-  attr_reader :root, :routes, :known_methods, :named_routes, :nodes
-  attr_accessor :default_app, :url_mount
-
   # Raised when a url is not able to be generated for the given parameters
   InvalidRouteException       = Class.new(RuntimeError)
   # Raised when a Route is not able to be generated due to a missing parameter.
   MissingParameterException   = Class.new(RuntimeError)
-  # Raised when a Route is compiled twice
-  DoubleCompileError          = Class.new(RuntimeError)
   # Raised an invalid request value is used
   InvalidRequestValueError    = Class.new(RuntimeError)
   # Raised when there are extra parameters passed in to #url
   TooManyParametersException  = Class.new(RuntimeError)
+  # Raised when there are left over options
+  LeftOverOptions             = Class.new(RuntimeError)
+
+  RecognizeResponse           = Struct.new(:matches, :acceptable_methods)
+
+  attr_reader :root, :routes, :named_routes, :nodes
+  attr_writer :route_class
+  attr_accessor :default_app, :url_mount, :default_host, :default_port, :default_scheme
 
   # Creates a new HttpRouter.
   # Can be called with either <tt>HttpRouter.new(proc{|env| ... }, { .. options .. })</tt> or with the first argument omitted.
@@ -34,14 +38,13 @@ class HttpRouter
   # * :default_app -- Default application used if there is a non-match on #call. Defaults to 404 generator.
   # * :ignore_trailing_slash -- Ignore a trailing / when attempting to match. Defaults to +true+.
   # * :redirect_trailing_slash -- On trailing /, redirect to the same path without the /. Defaults to +false+.
-  # * :known_methods -- Array of http methods tested for 405s.
   def initialize(*args, &blk)
     default_app, options     = args.first.is_a?(Hash) ? [nil, args.first] : [args.first, args[1]]
-    @options = options
+    @options                 = options
     @default_app             = default_app || options && options[:default_app] || proc{|env| ::Rack::Response.new("Not Found", 404, {'X-Cascade' => 'pass'}).finish }
     @ignore_trailing_slash   = options && options.key?(:ignore_trailing_slash) ? options[:ignore_trailing_slash] : true
     @redirect_trailing_slash = options && options.key?(:redirect_trailing_slash) ? options[:redirect_trailing_slash] : false
-    @known_methods           = Set.new(options && options[:known_methods] || [])
+    @route_class             = Route
     reset!
     instance_eval(&blk) if blk
   end
@@ -62,33 +65,55 @@ class HttpRouter
   #
   # Returns the route object.
   def add(*args, &app)
-    opts = args.last.is_a?(Hash) ? args.pop : {}
+    uncompile
+    opts = args.last.is_a?(Hash) ? args.pop : nil
     path = args.first
-    route = add_route((Regexp === path ? RegexRoute : Route).new(self, path, opts))
+    route = route_class.new
+    add_route route
+    route.path = path if path
+    route.process_opts(opts) if opts
     route.to(app) if app
     route
   end
 
   def add_route(route)
     @routes << route
-    route
+    @named_routes[route.name] << route if route.name
+    route.router = self
+  end
+
+  # Extends the route class with custom features.
+  #
+  # Example:
+  #   router = HttpRouter.new { extend_route { attr_accessor :controller } }
+  #   router.add('/foo', :controller => :foo).to{|env| [200, {}, ['foo!']]}
+  #   matches, other_methods = router.recognize(Rack::MockRequest.env_for('/foo'))
+  #   matches.first.route.controller
+  #   # ==> :foo
+  def extend_route(&blk)
+    @route_class = Class.new(Route) if @route_class == Route
+    @route_class.class_eval(&blk)
+    @extended_route_class = nil
+  end
+
+  def route_class
+    @extended_route_class ||= begin
+      @route_class.send(:include, RouteHelper)
+      @route_class.send(:include, GenerationHelper)
+      @route_class
+    end
   end
 
   # Adds a path that only responds to the request method +GET+.
   #
   # Returns the route object.
-  def get(path, opts = {}, &app); add_with_request_method(path, :get, opts, &app); end
+  def get(path, opts = {}, &app); add_with_request_method(path, [:get, :head], opts, &app); end
 
   # Adds a path that only responds to the request method +POST+.
   #
   # Returns the route object.
   def post(path, opts = {}, &app); add_with_request_method(path, :post, opts, &app); end
 
-  # Adds a path that only responds to the request method +HEAD+.
-  #
-  # Returns the route object.
-  def head(path, opts = {}, &app); add_with_request_method(path, :head, opts, &app); end
-
   # Adds a path that only responds to the request method +DELETE+.
   #
   # Returns the route object.
@@ -99,35 +124,50 @@ class HttpRouter
   # Returns the route object.
   def put(path, opts = {}, &app); add_with_request_method(path, :put, opts, &app); end
 
+  # Adds a path that only responds to the request method +PATCH+.
+  #
+  # Returns the route object.
+  def patch(path, opts = {}, &app); add_with_request_method(path, :patch, opts, &app); end
+
+  # Adds a path that only responds to the request method +OPTIONS+.
+  #
+  # Returns the route object.
+  def trace(path, opts = {}, &app); add_with_request_method(path, :trace, opts, &app); end
+
   # Adds a path that only responds to the request method +OPTIONS+.
   #
   # Returns the route object.
-  def options(path, opts = {}, &app); add_with_request_method(path, :options, opts, &app); end
+  def conenct(path, opts = {}, &app); add_with_request_method(path, :conenct, opts, &app); end
 
   # Performs recoginition without actually calling the application and returns an array of all
   # matching routes or nil if no match was found.
-  def recognize(env)
-    call(env, false)
+  def recognize(env, &callback)
+    if callback
+      request = call(env, &callback)
+      [request.called?, request.acceptable_methods]
+    else
+      matches = []
+      callback ||= Proc.new {|match| matches << match}
+      request = call(env, &callback)
+      [matches.empty? ? nil : matches, request.acceptable_methods]
+    end
   end
 
   # Rack compatible #call. If matching route is found, and +dest+ value responds to #call, processing will pass to the matched route. Otherwise,
   # the default application will be called. The router will be available in the env under the key <tt>router</tt>. And parameters matched will
   # be available under the key <tt>router.params</tt>.
-  def call(env, perform_call = true)
-    rack_request = ::Rack::Request.new(env)
-    request = Request.new(rack_request.path_info, rack_request, perform_call)
-    response = catch(:success) { @root[request] }
-    if perform_call
-      response or no_response(env)
-    else
-      request.matches.empty? ? nil : request.matches
-    end
+  def call(env, &callback)
+    compile
+    call(env, &callback)
   end
+  alias_method :compiling_call, :call
 
   # Resets the router to a clean state.
   def reset!
+    uncompile
     @routes, @named_routes, @root = [], Hash.new{|h,k| h[k] = []}, Node::Root.new(self)
     @default_app = Proc.new{ |env| ::Rack::Response.new("Your request couldn't be found", 404).finish }
+    @default_host, @default_port, @default_scheme = 'localhost', 80, 'http'
   end
 
   # Assigns the default application.
@@ -140,22 +180,32 @@ class HttpRouter
   #
   # Example:
   #   router = HttpRouter.new
-  #   router.add('/:foo.:format').name(:test).to{|env| [200, {}, []]}
-  #   router.url(:test, 123, 'html')
+  #   router.add('/:foo.:format', :name => :test).to{|env| [200, {}, []]}
+  #   router.path(:test, 123, 'html')
   #   # ==> "/123.html"
-  #   router.url(:test, 123, :format => 'html')
+  #   router.path(:test, 123, :format => 'html')
   #   # ==> "/123.html"
-  #   router.url(:test, :foo => 123, :format => 'html')
+  #   router.path(:test, :foo => 123, :format => 'html')
   #   # ==> "/123.html"
-  #   router.url(:test, :foo => 123, :format => 'html', :fun => 'inthesun')
+  #   router.path(:test, :foo => 123, :format => 'html', :fun => 'inthesun')
   #   # ==> "/123.html?fun=inthesun"
   def url(route, *args)
-    case route
-    when Symbol then @named_routes.key?(route) && @named_routes[route].each{|r| url = r.url(*args); return url if url}
-    when Route  then return route.url(*args)
-    end
-    raise(InvalidRouteException)
+    compile
+    url(route, *args)
   end
+  alias_method :compiling_url, :url
+
+  def url_ns(route, *args)
+    compile
+    url_ns(route, *args)
+  end
+  alias_method :compiling_url_ns, :url_ns
+
+  def path(route, *args)
+    compile
+    path(route, *args)
+  end
+  alias_method :compiling_path, :path
 
   # This method is invoked when a Path object gets called with an env. Override it to implement custom path processing.
   def process_destination_path(path, env)
@@ -182,14 +232,8 @@ class HttpRouter
   def clone(klass = self.class)
     cloned_router = klass.new(@options)
     @routes.each do |route|
-      new_route = route.clone(cloned_router)
+      new_route = route.create_clone(cloned_router)
       cloned_router.add_route(new_route)
-      new_route.name(route.named) if route.named
-      begin
-        new_route.to route.dest.clone
-      rescue
-        new_route.to route.dest
-      end
     end
     cloned_router
   end
@@ -204,21 +248,14 @@ class HttpRouter
     env['PATH_INFO'] = ''
   end
 
-  def no_response(env)
-    supported_methods = @known_methods.select do |m|
-      next if m == env['REQUEST_METHOD']
-      test_env = ::Rack::Request.new(env.clone)
-      test_env.env['REQUEST_METHOD'] = m
-      test_env.env['_HTTP_ROUTER_405_TESTING_ACCEPTANCE'] = true
-      test_request = Request.new(test_env.path_info, test_env, 405)
-      @root[test_request]
-      !test_request.matches.empty?
-    end
-    supported_methods.empty? ? @default_app.call(env) : [405, {'Allow' => supported_methods.sort.join(", ")}, []]
+  def no_response(request, env)
+    request.acceptable_methods.empty? ?
+      @default_app.call(env) : [405, {'Allow' => request.acceptable_methods.sort.join(", ")}, []]
   end
 
   def to_s
-    "#<HttpRouter:0x#{object_id.to_s(16)} number of routes (#{routes.size}) ignore_trailing_slash? (#{ignore_trailing_slash?}) redirect_trailing_slash? (#{redirect_trailing_slash?}) known_methods (#{known_methods.to_a.join(', ')})>"
+    compile
+    "#<HttpRouter:0x#{object_id.to_s(16)} number of routes (#{routes.size}) ignore_trailing_slash? (#{ignore_trailing_slash?}) redirect_trailing_slash? (#{redirect_trailing_slash?})>"
   end
 
   def inspect
@@ -226,9 +263,69 @@ class HttpRouter
     "#{to_s}\n#{'=' * head.size}\n#{@root.inspect}"
   end
 
+  def uncompile
+    return unless @compiled
+    instance_eval "undef :path;   alias :path   :compiling_path
+                   undef :url;    alias :url    :compiling_url
+                   undef :url_ns; alias :url_ns :compiling_url_ns
+                   undef :call;   alias :call   :compiling_call", __FILE__, __LINE__
+    @root.uncompile
+    @compiled = false
+  end
+
+  def raw_url(route, *args)
+    case route
+    when Symbol then @named_routes.key?(route) && @named_routes[route].each{|r| url = r.url(*args); return url if url}
+    when Route  then return route.url(*args)
+    end
+    raise(InvalidRouteException.new "No route (url) could be generated for #{route.inspect}")
+  end
+
+  def raw_url_ns(route, *args)
+    case route
+    when Symbol then @named_routes.key?(route) && @named_routes[route].each{|r| url = r.url_ns(*args); return url if url}
+    when Route  then return route.url_ns(*args)
+    end
+    raise(InvalidRouteException.new "No route (url_ns) could be generated for #{route.inspect}")
+  end
+
+  def raw_path(route, *args)
+    case route
+    when Symbol then @named_routes.key?(route) && @named_routes[route].each{|r| path = r.path(*args); return path if path}
+    when Route  then return route.path(*args)
+    end
+    raise(InvalidRouteException.new "No route (path) could be generated for #{route.inspect}")
+  end
+
+  def raw_call(env, &blk)
+    rack_request = ::Rack::Request.new(env)
+    request = Request.new(rack_request.path_info, rack_request)
+    if blk
+      @root.call(request, &blk)
+      request
+    else
+      @root.call(request) or no_response(request, env)
+    end
+  end
+
   private
+  def compile
+    return if @compiled
+    @root.compile(@routes)
+    @named_routes.each do |_, routes|
+      routes.sort!{|r1, r2| r2.max_param_count <=> r1.max_param_count }
+    end
+
+    instance_eval "undef :path;   alias :path   :raw_path
+                   undef :url;    alias :url    :raw_url
+                   undef :url_ns; alias :url_ns :raw_url_ns
+                   undef :call;   alias :call   :raw_call", __FILE__, __LINE__
+    @compiled = true
+  end
+
   def add_with_request_method(path, method, opts = {}, &app)
-    route = add(path, opts).send(method.to_sym)
+    opts[:request_method] = method
+    route = add(path, opts)
     route.to(app) if app
     route
   end