rack-router 0.0.1 → 0.1.0

data/README.md

@@ -1,6 +1,6 @@
 # Rack::Router
 
-A router for rack apps
+A simple router for rack apps
 
 ## Installation
 
@@ -18,7 +18,7 @@ Or install it yourself as:
 
 ## Usage
 
-Coming soon...
+See [config.ru](http://github.com/pjb3/rack-router/tree/master/config.ru)
 
 ## Contributing
 

data/Rakefile

@@ -1,2 +1,10 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs = ["lib"]
+  t.test_files = FileList["test/*_test.rb"]
+end
+
+task :default => :test

data/config.ru

@@ -0,0 +1,9 @@
+require 'rack/router'
+require 'rack/lobster'
+
+router = Rack::Router.new do
+  get "/hello/:name" => proc{|env| [200, { "Content-Type" => "text/html" }, ["<h1>Hello, #{env['rack.route_params'][:name]}</h1>"] ] }
+  get "/lobster" => Rack::Lobster.new
+end
+
+run router

data/lib/rack-router.rb

@@ -1,5 +1 @@
-module Rack
-  module Router
-    # Your code goes here...
-  end
-end
+require 'rack/router'

data/lib/rack/route.rb

@@ -0,0 +1,88 @@
+module Rack
+  class Route
+
+    attr_accessor :pattern, :app, :constraints
+
+    PATH_INFO = 'PATH_INFO'.freeze
+    DEFAULT_WILDCARD_NAME = :paths
+    WILDCARD_PATTERN = /\/\*(.*)/.freeze
+    NAMED_SEGMENTS_PATTERN = /\/:([^$\/]+)/.freeze
+    NAMED_SEGMENTS_REPLACEMENT_PATTERN = /\/:([^$\/]+)/.freeze
+    DOT = '.'.freeze
+
+    def initialize(pattern, app, constraints=nil)
+      if pattern.to_s.strip.empty?
+        raise ArgumentError.new("pattern cannot be blank")
+      end
+
+      unless app.respond_to?(:call)
+        raise ArgumentError.new("app must be callable")
+      end
+
+      @pattern = pattern
+      @app = app
+      @constraints = constraints
+    end
+
+    def regexp
+      @regexp ||= compile
+    end
+
+    def compile
+      src = if pattern_match = pattern.match(WILDCARD_PATTERN)
+        @wildcard_name = if pattern_match[1].to_s.strip.empty?
+          DEFAULT_WILDCARD_NAME
+        else
+          pattern_match[1].to_sym
+        end
+        pattern.gsub(WILDCARD_PATTERN,'(?:/(.*)|)')
+      elsif pattern_match = pattern.match(NAMED_SEGMENTS_PATTERN)
+        pattern.gsub(NAMED_SEGMENTS_REPLACEMENT_PATTERN, '/(?<\1>[^$/]+)')
+      else
+        pattern
+      end
+      Regexp.new("\\A#{src}\\Z")
+    end
+
+    def match(path)
+      if path.to_s.strip.empty?
+        raise ArgumentError.new("path is required")
+      end
+
+      if path_match = path.split(DOT).first.match(regexp)
+        params = if @wildcard_name
+          { @wildcard_name => path_match[1].to_s.split('/') }
+        else
+          Hash[path_match.names.map(&:to_sym).zip(path_match.captures)]
+        end
+
+        if meets_constraints(params)
+          params
+        end
+      end
+    end
+
+    def meets_constraints(params)
+      if constraints
+        constraints.each do |param, constraint|
+          unless params[param].to_s.match(constraint)
+            return false
+          end
+        end
+      end
+      true
+    end
+
+    def eql?(o)
+      o.is_a?(self.class) &&
+        o.pattern == pattern &&
+        o.app == app &&
+        o.constraints == constraints
+    end
+    alias == eql?
+
+    def hash
+      pattern.hash ^ app.hash ^ constraints.hash
+    end
+  end
+end

data/lib/rack/router.rb

@@ -0,0 +1,81 @@
+require 'rack/route'
+
+module Rack
+
+  class Router
+
+    HEAD = 'HEAD'.freeze
+    GET = 'GET'.freeze
+    POST = 'POST'.freeze
+    PUT = 'PUT'.freeze
+    DELETE = 'DELETE'.freeze
+    REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+    PATH_INFO = 'PATH_INFO'.freeze
+    ROUTE_PARAMS = 'rack.route_params'.freeze
+    DEFAULT_NOT_FOUND_BODY = '<h1>Not Found</h1>'.freeze
+    DEFAULT_NOT_FOUND_RESPONSE = [404,
+      {
+        "Content-Type" => "text/html",
+        "Content-Length" => DEFAULT_NOT_FOUND_BODY.length.to_s
+      }, [DEFAULT_NOT_FOUND_BODY]]
+
+    def initialize(&block)
+      @routes = {}
+      routes(&block)
+    end
+
+    def routes(&block)
+      instance_eval(&block) if block
+      @routes
+    end
+
+    def get(route_spec)
+      route(GET, route_spec)
+    end
+
+    def post(route_spec)
+      route(POST, route_spec)
+    end
+
+    def put(route_spec)
+      route(PUT, route_spec)
+    end
+
+    def delete(route_spec)
+      route(DELETE, route_spec)
+    end
+
+    def route(method, route_spec)
+      route = Route.new(route_spec.first.first, route_spec.first.last)
+      @routes[method] ||= []
+      @routes[method] << route
+      route
+    end
+
+    def call(env)
+      if app = match(env)
+        app.call(env)
+      else
+        not_found(env)
+      end
+    end
+
+    def match(env)
+      request_method = env[REQUEST_METHOD]
+      request_method = GET if request_method == HEAD
+      if method_routes = @routes[request_method]
+        method_routes.each do |route|
+          if params = route.match(env[PATH_INFO])
+            env[ROUTE_PARAMS] = params
+            return route.app
+          end
+        end
+      end
+    end
+
+    def not_found(env)
+      DEFAULT_NOT_FOUND_RESPONSE
+    end
+  end
+end
+

data/rack-router.gemspec

@@ -11,5 +11,5 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "rack-router"
   gem.require_paths = ["lib"]
-  gem.version       = "0.0.1"
+  gem.version       = "0.1.0"
 end

data/test/route_test.rb

@@ -0,0 +1,68 @@
+require "test/unit"
+require "rack/route"
+
+class RouteTest < Test::Unit::TestCase
+
+  def test_match
+    match "/*"         , "/"             , :paths => []
+    match "/*"         , "/foo"          , :paths => %w[foo]
+    match "/*"         , "/foo/bar/baz"  , :paths => %w[foo bar baz]
+    match "/*stuff"    , "/"             , :stuff => []
+    match "/*stuff"    , "/foo"          , :stuff => %w[foo]
+    match "/*stuff"    , "/foo/bar/baz"  , :stuff => %w[foo bar baz]
+    match "/foo/*"     , "/"             , nil
+    match "/foo/*"     , "/foo"          , :paths => []
+    match "/foo/*"     , "/foo/bar/baz"  , :paths => %w[bar baz]
+    match "/foo/*stuff", "/"             , nil
+    match "/foo/*stuff", "/foo"          , :stuff => []
+    match "/foo/*stuff", "/foo/bar/baz"  , :stuff => %w[bar baz]
+    match "/"          , "/"             , {}
+    match "/"          , "/foo"          , nil
+    match "/foo"       , "/"             , nil
+    match "/foo"       , "/foo"          , {}
+    match "/:id"       , "/42"           , { :id => "42" }
+    match "/:id"       , "/"             , nil
+    match "/posts/:id" , "/posts/42"     , { :id => "42" }
+    match "/posts/:id" , "/posts"        , nil
+    match "/:x/:y"     , "/a/b"          , { :x => "a" , :y => "b" }
+    match "/posts/:id" , "/posts/42.html", { :id => "42" }
+  end
+
+  def test_match_with_constraints
+    r = route("/posts/:year/:month/:day/:slug",
+              :year => /\A\d{4}\Z/,
+              :month => /\A\d{1,2}\Z/,
+              :day => /\A\d{1,2}\Z/)
+    assert_equal({
+      :year => "2012",
+      :month => "9",
+      :day => "20",
+      :slug => "test"
+    }, r.match("/posts/2012/9/20/test"))
+    assert_equal(nil, r.match("/posts/2012/9/20"))
+    assert_equal(nil, r.match("/posts/2012/x/20/test"))
+  end
+
+  def test_eql
+    app  = lambda{|env| [200, {}, [""]] }
+    assert_equal(
+      Rack::Route.new("/", app),
+      Rack::Route.new("/", app))
+  end
+
+  private
+  def route(path, constraints=nil)
+    Rack::Route.new(path, lambda{|env| [200, {}, [""]] }, constraints)
+  end
+
+  def match(pattern, path, params)
+    msg = "#{caller[0]} expected route #{pattern} to "
+    if params
+      msg << "match #{path} and return #{params.inspect}"
+    else
+      msg << "no match #{path}"
+    end
+    assert_equal(params, route(pattern).match(path), msg)
+  end
+end
+

data/test/router_test.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require 'rack/router'
+
+class RouterTest < Test::Unit::TestCase
+  def test_call
+    app1  = lambda{|env| [200, {}, [env["rack.route_params"][:id]]] }
+    app2  = lambda{|env| [200, {}, ["2"]] }
+
+    router = Rack::Router.new do
+      post "/stuff" => app2
+      put "/it" => app2
+      delete "/remove" => app2
+      get "/:id" => app1
+    end
+
+    assert_equal({
+      "POST" => [Rack::Route.new("/stuff", app2)],
+      "PUT" => [Rack::Route.new("/it", app2)],
+      "DELETE" => [Rack::Route.new("/remove", app2)],
+      "GET"  => [Rack::Route.new("/:id", app1)]
+    }, router.routes)
+
+    assert_equal ["42"], router.call("REQUEST_METHOD" => "GET", "PATH_INFO" => "/42").last
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-router
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -23,8 +23,13 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- config.ru
 - lib/rack-router.rb
+- lib/rack/route.rb
+- lib/rack/router.rb
 - rack-router.gemspec
+- test/route_test.rb
+- test/router_test.rb
 homepage: https://github.com/pjb3/rack-router
 licenses: []
 post_install_message: 
@@ -49,4 +54,6 @@ rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A simple router for rack apps
-test_files: []
+test_files:
+- test/route_test.rb
+- test/router_test.rb