http_router 0.0.1

data/lib/http_router.rb

@@ -0,0 +1,250 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require 'rack'
+require 'rack/uri_escape'
+
+class HttpRouter
+  autoload :Node,     'http_router/node'
+  autoload :Root,     'http_router/root'
+  autoload :Variable, 'http_router/variable'
+  autoload :Glob,     'http_router/glob'
+  autoload :Route,    'http_router/route'
+  autoload :Response, 'http_router/response'
+  autoload :Path,     'http_router/path'
+
+  UngeneratableRouteException = Class.new(RuntimeError)
+  MissingParameterException   = Class.new(RuntimeError)
+  TooManyParametersException  = Class.new(RuntimeError)
+  RoutingError                = Struct.new(:status, :headers)
+
+  attr_reader :routes
+
+  def initialize(options = nil)
+    reset!
+    @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
+  end
+
+  def ignore_trailing_slash?
+    @ignore_trailing_slash
+  end
+
+  def redirect_trailing_slash?
+    @redirect_trailing_slash
+  end
+
+  def reset!
+    @root = Root.new(self)
+    @routes = {}
+  end
+
+  def default(app)
+    @default_app = app
+  end
+  
+  def split(path, with_delimiter = false)
+    path.slice!(0) if path[0] == ?/
+    with_delimiter ? path.split('(/)') : path.split('/')
+  end
+
+  def add(path, options = nil)
+    path = path.dup
+    partially_match       = extract_partial_match(path)
+    trailing_slash_ignore = extract_trailing_slash(path)
+    paths                 = compile(path, options)
+    
+    route = Route.new(self, options && options[:default_values])
+    route.trailing_slash_ignore = trailing_slash_ignore
+    route.partially_match = partially_match
+    paths.each_with_index do |path, i|
+      current_node = @root
+      path.parts.each { |part| current_node = current_node.add(part) }
+      working_set = current_node.add_request_methods(options)
+      working_set.each do |current_node|
+        current_node.value = path
+        path.route = route
+        route.paths << current_node.value
+      end
+    end
+    route
+  end
+
+  def get(path, options = {})
+    options[:conditions] ||= {}
+    options[:conditions][:request_method] = ['HEAD', 'GET'] #TODO, this should be able to take an array
+    add(path, options)
+  end
+
+  def post(path, options = {})
+    options[:conditions] ||= {}
+    options[:conditions][:request_method] = 'POST'
+    add(path, options)
+  end
+
+  def put(path, options = {})
+    options[:conditions] ||= {}
+    options[:conditions][:request_method] = 'PUT'
+    add(path, options)
+  end
+
+  def delete(path, options = {})
+    options[:conditions] ||= {}
+    options[:conditions][:request_method] = 'DELETE'
+    add(path, options)
+  end
+
+  def only_get(path, options = {})
+    options[:conditions] ||= {}
+    options[:conditions][:request_method] = "GET"
+    add(path, options)
+  end
+
+  def extract_partial_match(path)
+    if path[-1] == ?*
+      path.slice!(-1)
+      true
+    else
+      false
+    end
+  end
+
+  def extract_trailing_slash(path)
+    if path[-2, 2] == '/?'
+      path.slice!(-2, 2)
+      true
+    else
+      false
+    end
+  end
+
+  def extract_extension(path)
+    if match = path.match(/^(.*)(\.:([a-zA-Z_]+))$/)
+      path.replace(match[1])
+      Variable.new(self, match[3].to_sym)
+    elsif match = path.match(/^(.*)(\.([a-zA-Z_]+))$/)
+      path.replace(match[1])
+      match[3]
+    end
+  end
+
+  def compile(path, options)
+    start_index = 0
+    end_index = 1
+
+    paths = [""]
+    chars = path.split('')
+
+    chars.each do |c|
+      case c
+        when '('
+          # over current working set, double paths
+          (start_index...end_index).each do |path_index|
+            paths << paths[path_index].dup
+          end
+          start_index = end_index
+          end_index = paths.size
+        when ')'
+          start_index -= end_index - start_index
+        else
+          (start_index...end_index).each do |path_index|
+            paths[path_index] << c
+          end
+      end
+    end
+    
+    variables = {}
+    paths.map do |path|
+      original_path = path.dup
+      extension = extract_extension(path)
+      new_path = split(path).map do |part|
+        case part[0]
+        when ?:
+          v_name = part[1, part.size].to_sym
+          variables[v_name] ||= Variable.new(self, v_name, options && options[:matches_with] && options && options[:matches_with][v_name])
+        when ?*
+          v_name = part[1, part.size].to_sym
+          variables[v_name] ||= Glob.new(self, v_name, options && options[:matches_with] && options && options[:matches_with][v_name])
+        else
+          part_segments = part.split(/(:[a-zA-Z_]+)/)
+          if part_segments.size > 1
+            index = 0
+            part_segments.map do |seg|
+              new_seg = if seg[0] == ?:
+                next_index = index + 1
+                scan_regex = if next_index == part_segments.size
+                  /^[^\/]+/
+                else
+                  /^.*?(?=#{Regexp.quote(part_segments[next_index])})/
+                end
+                v_name = seg[1, seg.size].to_sym
+                variables[v_name] ||= Variable.new(self, v_name, scan_regex)
+              else
+                /^#{Regexp.quote(seg)}/
+              end
+              index += 1
+              new_seg
+            end
+          else
+            part
+          end
+        end
+      end
+      new_path.flatten!
+      Path.new(original_path, new_path, extension)
+    end
+  end
+
+  def call(env)
+    request = Rack::Request.new(env)
+    if redirect_trailing_slash? && (request.head? || request.get?) && request.path_info[-1] == ?/
+      response = Rack::Response.new
+      response.redirect(request.path_info[0, request.path_info.size - 1], 302)
+      response.finish
+    else
+      response = recognize(request)
+      env['router'] = self
+      if response.is_a?(RoutingError)
+        [response.status, response.headers, []]
+      elsif response && response.route.dest && response.route.dest.respond_to?(:call)
+        process_params(env, response)
+        consume_path!(request, response) if response.partial_match?
+        #if response.rest
+        #  request.env["SCRIPT_NAME"] += request.env["PATH_INFO"][0, -response.rest.size]
+        #  request.env["PATH_INFO"] = response.rest || ''
+        #end
+        response.route.dest.call(env)
+      else
+        @default_app.call(env)
+      end
+    end
+  end
+
+  def consume_path!(request, response)
+    request.env["SCRIPT_NAME"] = (request.env["SCRIPT_NAME"] + response.matched_path)
+    request.env["PATH_INFO"] = 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
+    end
+  end
+
+  def recognize(env)
+    response = @root.find(env.is_a?(Hash) ? Rack::Request.new(env) : env)
+  end
+
+  def url(route, *args)
+    case route
+      when Symbol
+        url(@routes[route], *args)
+      when nil
+        raise UngeneratableRouteException.new
+      else
+        route.url(*args)
+    end
+  end
+end

data/lib/rack/uri_escape.rb

@@ -0,0 +1,38 @@
+unless Rack::Utils.respond_to?(:uri_escape)
+  module Rack
+    module Utils
+      def uri_escape(s)
+        s.to_s.gsub(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) {
+          '%'<<$1.unpack('H2'*$1.size).join('%').upcase
+        }
+      end
+      module_function :uri_escape
+    end
+  end
+end
+
+unless Rack::Utils.respond_to?(:uri_escape!)
+  module Rack
+    module Utils
+      def uri_escape!(s)
+        s.to_s.gsub!(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) {
+          '%'<<$1.unpack('H2'*$1.size).join('%').upcase
+        }
+      end
+      module_function :uri_escape!
+    end
+  end
+end
+
+unless Rack::Utils.respond_to?(:uri_unescape)
+  module Rack
+    module Utils
+      def uri_unescape(s)
+        gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+          [$1.delete('%')].pack('H*')
+        }
+      end
+      module_function :uri_unescape
+    end
+  end
+end

data/spec/generate_spec.rb

@@ -0,0 +1,54 @@
+describe "HttpRouter#generate" do
+  before(:each) do
+    @router = HttpRouter.new
+  end
+
+  context("static paths") do
+    ['/', '/test', '/test/time', '/one/more/what', '/test.html'].each do |path|
+      it "should generate #{path.inspect}" do
+        route = @router.add(path)
+        @router.url(route).should == path
+      end
+    end
+  end
+
+  context("dynamic paths") do
+    it "should generate from a hash" do
+      @router.add("/:var").name(:test)
+      @router.url(:test, :var => 'test').should == '/test'
+    end
+
+    it "should generate from an array" do
+      @router.add("/:var").name(:test)
+      @router.url(:test, 'test').should == '/test'
+    end
+
+    it "should generate with a format" do
+      @router.add("/test.:format").name(:test)
+      @router.url(:test, 'html').should == '/test.html'
+    end
+
+    it "should generate with a format as a hash" do
+      @router.add("/test.:format").name(:test)
+      @router.url(:test, :format => 'html').should == '/test.html'
+    end
+
+    it "should generate with an optional format" do
+      @router.add("/test(.:format)").name(:test)
+      @router.url(:test, 'html').should == '/test.html'
+      @router.url(:test).should == '/test'
+    end
+
+    context "with optional parts" do
+      it "should generate both" do
+        @router.add("/:var1(/:var2)").name(:test)
+        @router.url(:test, 'var').should == '/var'
+        @router.url(:test, 'var', 'fooz').should == '/var/fooz'
+        @router.url(:test, :var1 => 'var').should == '/var'
+        @router.url(:test, :var1 => 'var', :var2 => 'fooz').should == '/var/fooz'
+        proc{@router.url(:test, :var2 => 'fooz').should == '/var/fooz'}.should raise_error(HttpRouter::UngeneratableRouteException)
+      end
+    end
+
+  end
+end

data/spec/rack/dispatch_spec.rb

@@ -0,0 +1,113 @@
+route_set = HttpRouter.new
+route_set.extend(CallWithMockRequestMixin)
+
+describe "Usher (for rack) 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 "Usher (for rack) route dispatching" do
+  before(:each) do
+    route_set.reset!
+    @app = MockApp.new("Hello World!")
+  end
+
+  describe "HTTP GET" do
+    before(:each) do
+      route_set.reset!
+      route_set.add('/sample', :conditions => {: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
+  end
+
+  describe "HTTP POST" do
+    before(:each) do
+      route_set.reset!
+      route_set.add('/sample', :conditions => {:request_method => '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.add('/sample', :conditions => {:request_method => 'POST'}).to(@app)
+    route_set.add('/sample', :conditions => {:request_method => 'PUT'}).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').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/spec/rack/generate_spec.rb

@@ -0,0 +1,27 @@
+route_set = HttpRouter.new
+route_set.extend(CallWithMockRequestMixin)
+
+describe "Usher (for rack) route generation" do
+  before(:each) do
+    route_set.reset!
+    @app = MockApp.new("Hello World!")
+    route_set.add("/fixed").name(:fixed)
+    route_set.add("/named/simple/:named_simple_var").name(:simple)
+    route_set.add("/named/optional(/:named_optional_var)").name(:optional)
+  end
+  
+  describe "named routes" do
+    it "should generate a fixed path" do
+      route_set.url(:fixed).should == "/fixed"
+    end
+    
+    it "should generate a named path route" do
+      route_set.url(:simple, :named_simple_var => "the_var").should == "/named/simple/the_var"
+    end
+
+    it "should generate a named route with options" do
+      route_set.url(:optional).should == "/named/optional"
+      route_set.url(:optional, :named_optional_var => "the_var").should == "/named/optional/the_var"
+    end
+  end
+end

data/spec/rack/route_spec.rb

@@ -0,0 +1,70 @@
+describe "Rack interface extensions for Usher::Route" do
+  before(:each) do
+    @route_set = HttpRouter.new
+    @app = MockApp.new("Hello World!")
+    @env = Rack::MockRequest.env_for("/index.html")
+  end
+
+  describe "basic functinality" do
+    it "should set redirect headers" do
+      @route_set.get("/index.html").redirect("/")
+      raw_response = @route_set.call(@env)
+      response = Rack::MockResponse.new(*raw_response)
+      response.should be_redirect
+    end
+
+    it "should redirect '/index.html' to '/'" do
+      @route_set.get("/index.html").redirect("/")
+      status, headers, body = @route_set.call(@env)
+      headers["Location"].should eql("/")
+    end
+
+    it "should redirect '/:id.html' to '/:id'" do
+      @route_set.get("/:id.html").redirect('/#{params[:id]}')
+      @env = Rack::MockRequest.env_for("/123.html")
+      status, headers, body = @route_set.call(@env)
+      headers["Location"].should eql("/123")
+    end
+  end
+
+  describe "static file serving" do
+    it "should serve from a static directory" do
+      @route_set.get("/static").serves_static_from(File.dirname(__FILE__))
+      @env = Rack::MockRequest.env_for("/static/#{File.basename(__FILE__)}")
+      status, headers, body = @route_set.call(@env)
+      body.path.should == File.join(File.dirname(__FILE__), File.basename(__FILE__))
+    end
+
+    it "should serve a specific file" do
+      @route_set.get("/static-file").serves_static_from(__FILE__)
+      @env = Rack::MockRequest.env_for("/static-file")
+      status, headers, body = @route_set.call(@env)
+      body.path.should == __FILE__
+    end
+  end
+
+  describe "chaining" do
+    it "should be chainable" do
+      @route_set.get("/index.html").redirect("/").name(:root)
+      url = @route_set.url(:root)
+      url.should eql("/index.html")
+    end
+
+    it "should not influence actual invoking" do
+      @route_set.get("/index.html").redirect("/").name(:root)
+      @route_set.call(@env)
+    end
+  end
+
+  describe "custom status" do
+    it "should enable to set custom HTTP status" do
+      @route_set.get("/index.html").redirect("/", 303)
+      status, headers, body = @route_set.call(@env)
+      status.should eql(303)
+    end
+
+    it "should raise an exception if given HTTP code isn't a redirection" do
+      lambda { @route_set.get("/index.html").redirect("/", 200) }.should raise_error(ArgumentError)
+    end
+  end
+end