http_router 0.4.1 → 0.5.0

data/lib/http_router/route.rb

@@ -1,6 +1,8 @@
+require 'strscan'
+
 class HttpRouter
   class Route
-    attr_reader :dest, :paths, :path, :matches_with
+    attr_reader :dest, :paths, :path, :matches_with, :original_path
     attr_accessor :trailing_slash_ignore, :partially_match, :default_values
 
     def initialize(router, path)
@@ -24,6 +26,10 @@ class HttpRouter
       end
     end
 
+    def to_s
+      "#{@original_path} conditions: #{@conditions.inspect} default_values: #{@default_values.inspect} name: #{named.inspect}"
+    end
+
     # Returns the options used to create this route.
     def as_options
       {:matching => @matches_with, :conditions => @conditions, :default_values => @default_values, :name => @name, :partial => @partially_match, :arbitrary => @arbitrary}
@@ -199,8 +205,14 @@ class HttpRouter
           working_set = current_node.add_request_methods(@conditions)
           working_set.map!{|node| node.add_arbitrary(@arbitrary)}
           working_set.each do |current_node|
-            current_node.value = path
+            case current_node.value
+            when nil
+              current_node.value = [path]
+            else
+              current_node.value << path
+            end
           end
+          path.variable_names.each{|vn| router.variable_names << vn} unless path.static?
         end
       end
       self
@@ -240,6 +252,11 @@ class HttpRouter
 
     # Generates a URL for this route. See HttpRouter#url for how the arguments for this are structured.
     def url(*args)
+      result, extra_params = url_with_params(*args)
+      router.append_querystring(result, extra_params)
+    end
+
+    def url_with_params(*args)
       options = args.last.is_a?(Hash) ? args.pop : nil
       options = options.nil? ? default_values.dup : default_values.merge(options) if default_values
       options.delete_if{ |k,v| v.nil? } if options
@@ -249,19 +266,15 @@ class HttpRouter
         matching_path(args, options)
       end
       raise UngeneratableRouteException unless path
+      result, params = path.url(args, options)
       mount_point = router.url_mount && router.url_mount.url(options)
-      result = path.url(args, options)
-      mount_point ? File.join(mount_point, result) : result
+      mount_point ? [File.join(mount_point, result), params] : [result, params]
     end
 
     def significant_variable_names
       @significant_variable_names ||= @path.scan(/(^|[^\\])[:\*]([a-zA-Z0-9_]+)/).map{|p| p.last.to_sym}
     end
 
-    private
-
-    attr_reader :router
-
     def matching_path(params, other_hash = nil)
       if @paths.size == 1
         @paths.first
@@ -285,6 +298,10 @@ class HttpRouter
       end
     end
 
+    private
+
+    attr_reader :router
+
     def extract_partial_match(path)
       path[-1] == ?* && path.slice!(-1)
     end
@@ -337,32 +354,46 @@ class HttpRouter
     end
 
     def generate_interstitial_parts(part)
-      part_segments = part.scan(/:[a-zA-Z_0-9]+|[^:]+/)
+      part_segments = []
+      scanner = StringScanner.new(part)
+      while !scanner.eos?
+        if scanner.scan(/\\[:\*]/)
+          part_segments << [:static, ''] if part_segments.last.nil? or part_segments.last.first == :variable
+          part_segments.last.last << scanner.matched[-1].chr
+        elsif scanner.scan(/\\/)
+          # do nothing
+        elsif scanner.scan(/:[a-zA_Z0-9_]+/)
+          part_segments << [:variable, scanner.matched]
+        elsif scanner.scan(/./)
+          part_segments << [:static, ''] if part_segments.last.nil? or part_segments.last.first == :variable
+          part_segments.last.last << scanner.matched
+        end
+      end
       priority = 0
       if part_segments.size > 1
         index = 0
-        segs = part_segments.map do |seg|
-          new_seg = if seg[0] == ?:
+        segs = part_segments.map do |(type, seg)|
+          new_seg = if type == :variable
             next_index = index + 1
             v_name = seg[1, seg.size].to_sym
             matcher = @matches_with[v_name]
             scan_regex = if next_index == part_segments.size
               matcher || /^[^\/]+/
             else
-              /^#{matcher || '[^\/]+?'}(?=#{Regexp.quote(part_segments[next_index])})/
+              /^#{matcher || '[^\/]+?'}(?=#{Regexp.quote(part_segments[next_index].last)})/
             end
-            priority += 1
             router.variable(v_name, scan_regex)
           else
-            /^#{Regexp.quote(seg)}/
+            priority += seg.size
+            Static.new("^#{Regexp.quote(seg)}")
           end
           index += 1
           new_seg
         end
-        segs.each { |seg| seg.priority = priority if seg.respond_to?(:priority=) }
+        segs.each {|seg| seg.priority = priority}
         segs
       else
-        part
+        [part_segments.last.last]
       end
     end
 

data/lib/http_router/static.rb

@@ -0,0 +1,5 @@
+class HttpRouter
+  class Static < Regexp
+    attr_accessor :priority
+  end
+end

data/lib/http_router/variable.rb

@@ -3,11 +3,8 @@ class HttpRouter
     attr_reader :name, :matches_with
     attr_accessor :priority
 
-    def initialize(router, name, matches_with = nil)
-      @router = router
-      @name = name
-      @matches_with = matches_with
-      @priority = 0
+    def initialize(router, name, matches_with = nil, priority = 0)
+      @router, @name, @matches_with, @priority = router, name, matches_with, priority
     end
 
     def matches?(parts)

data/lib/http_router/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 class HttpRouter #:nodoc
-  VERSION = '0.4.1'
+  VERSION = '0.5.0'
 end

data/lib/http_router.rb

@@ -4,9 +4,9 @@ require 'url_mount'
 require 'http_router/node'
 require 'http_router/root'
 require 'http_router/variable'
+require 'http_router/static'
 require 'http_router/glob'
 require 'http_router/route'
-require 'http_router/response'
 require 'http_router/path'
 require 'http_router/optional_compiler'
 require 'http_router/parts'
@@ -31,7 +31,7 @@ class HttpRouter
   # Raised when there is a potential conflict of variable names within your Route.
   AmbiguousVariableException       = Class.new(RuntimeError)
 
-  attr_reader :named_routes, :routes, :root, :request_methods_specified
+  attr_reader :named_routes, :routes, :root, :request_methods_specified, :variable_names
   attr_accessor :url_mount
 
   # Creates a new HttpRouter.
@@ -41,23 +41,16 @@ 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+.
-  # * :middleware -- On recognition, store the route Response in env['router.response'] and always call the default app. Defaults to +false+.
   def initialize(*args, &block)
     default_app, options = args.first.is_a?(Hash) ? [nil, args.first] : [args.first, args[1]]
     @options                   = options
     @default_app               = default_app || options && options[:default_app] || proc{|env| ::Rack::Response.new("Not Found", 404).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
-    @middleware                = options && options.key?(:middleware) ? options[:middleware] : false
-    @request_methods_specified = Set.new
-    @routes                    = []
-    @named_routes              = {}
     @init_block                = block
+    @handle_unavailable_route  = Proc.new{ raise UngeneratableRouteException }
     reset!
-    if block
-      instance_eval(&block)
-      @routes.each {|r| r.compile}
-    end
+    instance_eval(&block) if block
   end
 
   # Ignore trailing slash feature enabled? See #initialize for details.
@@ -73,8 +66,10 @@ class HttpRouter
   # Resets the router to a clean state.
   def reset!
     @root = Root.new(self)
-    @routes.clear
-    @named_routes.clear
+    @request_methods_specified = Set.new
+    @routes = []
+    @named_routes = {}
+    @variable_names = Set.new
   end
 
   # Assigns the default application.
@@ -135,18 +130,6 @@ class HttpRouter
     add(path, options).delete
   end
 
-  # Returns the HttpRouter::Response object if the env is matched, otherwise, returns +nil+.
-  def recognize(env)
-    response = recognize_full(env)
-    response.is_a?(Array) ? response.first : response
-  end
-
-  # Returns the HttpRouter::Response object if the env is matched, an array of HttpRouter::Response objects or otherwise, returns +nil+. If it
-  # returns an array, this represents a set of possible matches.
-  def recognize_full(env)
-    @root.find(env.is_a?(Hash) ? ::Rack::Request.new(env) : env)
-  end
-
   # Generate a URL for a specified route. This will accept a list of variable values plus any other variable names named as a hash.
   # This first value must be either the Route object or the name of the route.
   #
@@ -164,8 +147,18 @@ class HttpRouter
   def url(route, *args)
     case route
     when Symbol then url(@named_routes[route], *args)
-    when nil    then raise UngeneratableRouteException
-    else             route.url(*args)
+    when Route  then route.url(*args)
+    when nil    then @handle_unavailable_route.call(:url, *args)
+    else             
+    end
+  end
+
+  def url_with_params(route, *args)
+    case route
+    when Symbol then url_with_params(@named_routes[route], *args)
+    when Route  then route.url_with_params(*args)
+    when nil    then @handle_unavailable_route.call(:url_with_params, *args)
+    else             
     end
   end
 
@@ -180,33 +173,14 @@ class HttpRouter
       response.redirect(request.path_info[0, request.path_info.size - 1], 302)
       response.finish
     else
-      env['router'] = self
-      if response = recognize_full(request) and !@middleware
-        if response.is_a?(Array)
-          call_env = env.dup
-          response.each do |match|
-            if match.route.dest.respond_to?(:call)
-              process_params(call_env, match)
-              consume_path!(call_env, match)
-              app_response = match.route.dest.call(call_env)
-              return app_response unless app_response.first == 404 or app_response.first == 410
-            else
-              return response
-            end
-          end
-        elsif response.matched? && response.route.dest
-          process_params(env, response)
-          return response.route.dest.call(env) if response.route.dest.respond_to?(:call)
-        elsif !response.matched?
-          return [response.status, response.headers, []]
-        end
-        process_params(env, response)
-      end
-      env['router.response'] = response
-      @default_app.call(env)
+      @root.call(request) || @default_app.call(request.env)
     end
   end
 
+  def recognize(env)
+    @root.recognize(env)
+  end
+
   # Returns a new node
   def node(*args)
     Node.new(self, *args)
@@ -266,20 +240,19 @@ class HttpRouter
     s.to_s.gsub!(/((?:%[0-9a-fA-F]{2})+)/n){ [$1.delete('%')].pack('H*') }
   end
 
-  private
-
-  def consume_path!(env, response)
-    env["SCRIPT_NAME"] = (env["SCRIPT_NAME"] + response.matched_path)
-    env["PATH_INFO"] = response.remaining_path.nil? || response.remaining_path == '' ? '/' : response.remaining_path
-  end
-
-  def process_params(env, response)
-    if env.key?('router.params')
-      env['router.params'].merge!(response.route.default_values) if response.route.default_values
-      env['router.params'].merge!(response.params_as_hash)
-    else
-      env['router.params'] = response.route.default_values ? response.route.default_values.merge(response.params_as_hash) : response.params_as_hash
+  def append_querystring(uri, params)
+    if params && !params.empty?
+      uri_size = uri.size
+      params.each do |k,v|
+        case v
+        when Array
+          v.each { |v_part| uri << '&' << ::Rack::Utils.escape(k.to_s) << '%5B%5D=' << ::Rack::Utils.escape(v_part.to_s) }
+        else
+          uri << '&' << ::Rack::Utils.escape(k.to_s) << '=' << ::Rack::Utils.escape(v.to_s)
+        end
+      end
+      uri[uri_size] = ??
     end
+    uri
   end
-
 end

data/test/helper.rb

@@ -0,0 +1,74 @@
+require 'minitest/autorun'
+require 'phocus'
+
+class HttpRouter::Route
+  def default_destination
+    to{|env| Rack::Response.new("Routing to #{to_s}").finish}
+  end
+end
+
+class MiniTest::Unit::TestCase
+  def router(*args, &blk)
+    @router ||= HttpRouter.new(*args, &blk)
+    if blk
+      @router.routes.each do |route|
+        route.default_destination if route.dest.nil?
+      end
+      @router.routes.size > 1 ? @router.routes : @router.routes.first
+    else
+      @router
+    end
+  end
+
+  def assert_body(expect, response)
+    response = router.call(response) if response.is_a?(Hash)
+    body = case expect
+    when Array  then []
+    when String then ""
+    else             raise
+    end
+    response.last.each {|p| body << p}
+    assert_equal expect, body
+  end
+  
+  def assert_header(header, response)
+    response = router.call(response) if response.is_a?(Hash)
+    header.each{|k, v| assert_equal v, response[1][k]}
+  end
+
+  def assert_status(status, response)
+    response = router.call(response) if response.is_a?(Hash)
+    assert_equal status, response.first
+  end
+
+  def assert_route(route, request, params = nil, &blk)
+    if route.is_a?(String)
+      router.reset!
+      route = router.add(route)
+    end
+    route.to{|env| Rack::Response.new("Routing to #{route.to_s}").finish} if route && !route.compiled?
+    request = Rack::MockRequest.env_for(request) if request.is_a?(String)
+    response = @router.call(request)
+    if route
+      dest = "Routing to #{route.to_s}"
+      assert_equal [dest], response.last.body
+      if params
+        assert_equal params.size, request['router.params'].size
+        params.each { |k, v| assert_equal v, request['router.params'][k] }
+      elsif !request['router.params'].nil? and !request['router.params'].empty?
+        raise "Wasn't expecting any parameters, got #{request['router.params'].inspect}"
+      end
+    else
+      assert_equal 404, response.first
+    end
+  end
+  
+  def assert_generate(path, route, *args)
+    if route.is_a?(String)
+      router.reset!
+      route = router.add(route).to(path.to_sym)
+    end
+    route.to{|env| Rack::Response.new("Routing to #{route.to_s}").finish} if route.respond_to?(:compiled?) && !route.compiled?
+    assert_equal path, router.url(route, *args)
+  end
+end

data/test/rack/test_dispatch.rb

@@ -0,0 +1,120 @@
+#describe "HttpRouter route dispatching with redirect_on_trailing_delimiters" do
+#  before(:each) do
+#    @route_set = HttpRouter.new(:redirect_trailing_slash => true)
+#    @route_set.extend(CallWithMockRequestMixin)
+#    @app = MockApp.new("Hello World!")
+#    @route_set.add('/sample').to(@app)
+#  end
+#
+#  it "should dispatch a request" do
+#    response = @route_set.call_with_mock_request('/sample/')
+#    response.headers["Location"].should == "/sample"
+#  end
+#
+#end
+#
+#describe "HttpRouter route dispatching" do
+#  before(:each) do
+#    @route_set = HttpRouter.new(:redirect_trailing_slash => true)
+#    @route_set.extend(CallWithMockRequestMixin)
+#    @app = MockApp.new("Hello World!")
+#  end
+#
+#  describe "HTTP GET" do
+#    before(:each) do
+#      @route_set.reset!
+#      @route_set.add('/sample').request_method('GET').to(@app)
+#    end
+#
+#    it "should dispatch a request" do
+#      response = @route_set.call_with_mock_request
+#      response.body.should eql("Hello World!")
+#    end
+#
+#    it "should write router.params" do
+#      response = @route_set.call_with_mock_request
+#      @app.env["router.params"].should == {}
+#    end
+#
+#    it "should write router.params for default values" do
+#      @route_set.add("/foobar", :default_values => {:hi => :there}).compile
+#      response = @route_set.call_with_mock_request("/foobar")
+#      env = Rack::MockRequest.env_for("/foobar")
+#      @route_set.call(env)
+#      env['router.params'].should == {:hi => :there}
+#    end
+#  end
+#
+#  describe "HTTP POST" do
+#    before(:each) do
+#      @route_set.reset!
+#      @route_set.add('/sample').post.to(@app)
+#      @route_set.add('/sample').to(MockApp.new("You shouldn't get here if you are using POST"))
+#    end
+#
+#    it "should dispatch a POST request" do
+#      response = @route_set.call_with_mock_request('/sample', 'POST')
+#      response.body.should eql("Hello World!")
+#    end
+#
+#    it "shouldn't dispatch a GET request" do
+#      response = @route_set.call_with_mock_request('/sample', 'GET')
+#      response.body.should eql("You shouldn't get here if you are using POST")
+#    end
+#
+#    it "should write router.params" do
+#      response = @route_set.call_with_mock_request("/sample", 'POST')
+#      @app.env["router.params"].should == {}
+#    end
+#  end
+#
+#  it "should returns HTTP 405 if the method mis-matches" do
+#    @route_set.reset!
+#    @route_set.post('/sample').to(@app)
+#    @route_set.put('/sample').to(@app)
+#    response = @route_set.call_with_mock_request('/sample', 'GET')
+#    response.status.should eql(405)
+#    response['Allow'].should == 'POST, PUT'
+#  end
+#
+#  it "should returns HTTP 404 if route doesn't exist" do
+#    response = @route_set.call_with_mock_request("/not-existing-url")
+#    response.status.should eql(404)
+#  end
+#
+#  describe "shortcuts" do
+#    describe "get" do
+#      before(:each) do
+#        @route_set.reset!
+#        @route_set.get('/sample').head.to(@app)
+#      end
+#
+#      it "should dispatch a GET request" do
+#        response = @route_set.call_with_mock_request("/sample", "GET")
+#        response.body.should eql("Hello World!")
+#      end
+#
+#      it "should dispatch a HEAD request" do
+#        response = @route_set.call_with_mock_request("/sample", "HEAD")
+#        response.body.should eql("Hello World!")
+#      end
+#    end
+#  end
+#
+#  describe "non rack app destinations" do
+#    it "should route to a default application when using a hash" do
+#      $captures = []
+#      @default_app = lambda do |e|
+#        $captures << :default
+#        Rack::Response.new("Default").finish
+#      end
+#      @router = HttpRouter.new
+#      @router.default(@default_app)
+#      @router.add("/default").to(:action => "default")
+#      response = @router.call(Rack::MockRequest.env_for("/default"))
+#      $captures.should == [:default]
+#    end
+#  end
+#
+#end
+#

data/test/rack/test_route.rb

@@ -0,0 +1,44 @@
+class TestRouteExtensions < MiniTest::Unit::TestCase
+  
+  def test_redirect
+    router.get("/index.html").redirect("/")
+    response = router.call(Rack::MockRequest.env_for("/index.html"))
+    assert_header({'Location' => '/'}, response)
+    assert_status 302, response
+  end
+
+  def test_redirect_with_params
+    router.get("/:id.html").redirect('/#{params[:id]}')
+    response = router.call(Rack::MockRequest.env_for("/123.html"))
+    assert_header({'Location' => '/123'}, response)
+    assert_status 302, response
+  end
+
+  def test_static_directory
+    router.get("/static").static(File.dirname(__FILE__))
+    status, headers, body = router.call(Rack::MockRequest.env_for("/static/#{File.basename(__FILE__)}"))
+    assert_equal File.join(File.dirname(__FILE__), File.basename(__FILE__)), body.path
+  end
+
+  def test_static_file
+    router.get("/static-file").static(__FILE__)
+    status, headers, body = router.call(Rack::MockRequest.env_for("/static-file"))
+    assert_equal __FILE__, body.path
+  end
+
+  def test_chainable
+    router.get("/index.html").redirect("/").name(:root)
+    assert_equal "/index.html", router.url(:root)
+  end
+
+  def test_custom_status
+    router.get("/index.html").redirect("/", 303)
+    response = router.call(Rack::MockRequest.env_for("/index.html"))
+    assert_header({'Location' => '/'}, response)
+    assert_status 303, response
+  end
+
+  def test_raise_error_on_invalid_status
+    assert_raises(ArgumentError) { router.get("/index.html").redirect("/", 200) }
+  end
+end

data/test/rack/test_urlmap.rb

@@ -0,0 +1,12 @@
+class TestRackUrlmap < MiniTest::Unit::TestCase
+
+  def test_map_urls
+    HttpRouter::Rack.override_rack_urlmap!
+    map = Rack::URLMap.new(
+      "http://www.example.org/test" => proc {|env| [200, {}, ['test']]},
+      "http://www.example.org/:test" => proc {|env| [200, {}, ['variable']]}
+    )
+    assert_equal 'test',     map.call(Rack::MockRequest.env_for('http://www.example.org/test')).last.join
+    assert_equal 'variable', map.call(Rack::MockRequest.env_for('http://www.example.org/whhhaaa')).last.join
+  end
+end