galago-router 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ca65e8d3da9c0e6e460c0b264402285bd9d2dfa
-  data.tar.gz: 774adf1034c62b50bd690092cc6e1efc6e9dccaf
+  metadata.gz: 5cddf3cc990d2f88225ab9f7090d8675ea46b86d
+  data.tar.gz: 5bfc2cea67b7cb5ece9b4dcba8c645fc0bfb300c
 SHA512:
-  metadata.gz: e72781d341817aada32d6f133fecb622e6f58954491acbfdc3d5f7698301b8e8cd189addc592195478c431a9cc4cbffa4fa7539fb009baa8182eed08c25e1eeb
-  data.tar.gz: 8db3316782ebb5076861c3701db5ff52bd7ab6b51363d8ba87513cbf702457ec48978cf88f7f4a12badbec04571889ba7c493eef54962c33645d28c2be6a05bf
+  metadata.gz: e09b70383c09dd9f224fbf1915165281aa5af5eb25108edc5d331bc8cdc0d62d3a66aec4ecfdd31027282706912ccc548921de6f8ad59805110bc699dc22ccce
+  data.tar.gz: 7fea16179a6dcc3e70a1e07bd828c1d9deeeffa18ea0c73d927d4fe7dca4fae360bf18cfd59a06fc9324e2b1f6b7657ca0a222dc71b2861c07458dbe393ae852

data/README.md

@@ -1,6 +1,6 @@
 # Galago Router
 
-A rack router.
+Simple, efficient routing for rack applications.
 
 ## Installation
 
@@ -40,6 +40,40 @@ end
 run router
 ```
 
+## Routes
+
+### OPTIONS
+
+OPTIONS endpoints are automatically defined for each resource provided. The
+response will contain an ALLOW header listing the request methods the resource
+supports.
+
+### HEAD
+
+HEAD endpoints are automatically defined for each resource that supports GET.
+
+
+## Environment
+
+The router adds information about the route that was called to the environment.
+All requests will have the following keys added:
+
+| Key                  | Example Value |
+| :------------------- | :------------ |
+| galago_router.path   | '/users/:id'  |
+| galago_router.params | { id: 42 }    |
+
+
+## Responses
+
+### 405 Method Not Allowed
+
+In the event a path is requested with an unsupported method, the router will return a method not allowed response.
+This consists of a 405 status code and an 'Allow' header listing the valid request methods. 
+
+More information: http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
+
+
 ## Contributing
 
 1. Fork it

data/lib/galago/router.rb

@@ -18,25 +18,27 @@ module Galago
     attr_reader :routes
 
     def initialize(&block)
-      @routes = REQUEST_METHODS.each_with_object({}) do |request_method, routes|
-        routes[request_method] = []
-        routes
-      end
-
+      @routes = []
       Router::DSL.new(self, block) if block_given?
     end
 
     def add_route(request_method, path, application)
-      route = Route.new(request_method, path, application)
-      routes[route.request_method] << route
+      if route = find_route_by_raw_path(path)
+        route.add_endpoint(request_method, application)
+      else
+        route = Route.new(path)
+        route.add_endpoint(request_method, application)
+        @routes << route
+      end
     end
 
     def has_route?(request_method, path)
-      find_route(request_method, path) ? true : false
+      route = find_route(path)
+      route && route.allowed_methods.include?(request_method)
     end
 
     def call(env)
-      if route = find_route(env['REQUEST_METHOD'], env['PATH_INFO'])
+      if route = find_route(env['PATH_INFO'])
         route.call(env)
       else
         Rack::Response.new("Not Found", 404).finish
@@ -45,15 +47,12 @@ module Galago
 
     private
 
-    def find_route(request_method, path)
-      routes = routes_for_request_method(request_method)
-      route = routes.detect { |route| route.recognizes_path?(path) }
+    def find_route(path)
+      routes.find { |route| route.recognizes_path?(path) }
     end
 
-    def routes_for_request_method(request_method)
-      routes.fetch(request_method.to_s.upcase) do
-        raise RequestMethodInvalid.new(request_method)
-      end
+    def find_route_by_raw_path(raw_path)
+      routes.find { |route| route.path.to_s == raw_path }
     end
 
   end

data/lib/galago/router/dsl.rb

@@ -15,6 +15,7 @@ module Galago
 
       def get(path, options)
         add_route("GET", path, options[:to])
+        add_route("HEAD", path, Rack::Head.new(options[:to]))
       end
 
       def patch(path, options)

data/lib/galago/router/path.rb

@@ -24,11 +24,14 @@ module Galago
         @path_parameters ||= @path.scan(/\:(\w+)/).flatten
       end
 
-      def add_path_params_to_env(env)
+      def params_from(env)
         request = Rack::Request.new(env)
+        params = request.params
 
         if path_params = identify_params_in_path(request.path)
-          path_params.each { |key, value| request.update_param(key, value) }
+          params.merge(path_params)
+        else
+          params
         end
       end
 
@@ -49,7 +52,7 @@ module Galago
 
       def identify_params_in_path(path)
         if match = regex.match(path)
-          named_parameters.zip(match.captures)
+          Hash[named_parameters.zip(match.captures)]
         end
       end
 

data/lib/galago/router/route.rb

@@ -2,15 +2,19 @@ module Galago
   class Router
     class Route
 
-      attr_reader :request_method, :path, :action
+      attr_reader :path
 
-      def initialize(request_method, path, action)
-        @request_method = request_method.to_s.upcase
+      def initialize(path)
         @path = Router::Path.new(path)
-        @action = action
+        @endpoints = { 'OPTIONS' => options }
+      end
+
+      def add_endpoint(request_method, endpoint)
+        @endpoints[request_method] = endpoint
+      end
 
-        validate_action!
-        validate_request_method!
+      def allowed_methods
+        @endpoints.keys.sort
       end
 
       def recognizes_path?(request_path)
@@ -18,21 +22,23 @@ module Galago
       end
 
       def call(env)
-        @path.add_path_params_to_env(env)
-        action.call(env)
+        env['galago_router.path'] = @path.to_s
+        env['galago_router.params'] = @path.params_from(env)
+
+        endpoint = @endpoints.fetch(env['REQUEST_METHOD'], method_not_allowed)
+        endpoint.call(env)
       end
 
       private
 
-      def validate_action!
-        action.respond_to?(:call) or raise Router::ActionInvalid.new(action)
+      def method_not_allowed
+        ->(env) { [405, { 'Allow' => allowed_methods.join(', ') }, []] }
       end
 
-      def validate_request_method!
-        unless Router::REQUEST_METHODS.include?(request_method)
-          raise Router::RequestMethodInvalid.new(request_method)
-        end
+      def options
+        ->(env) { [200, { 'Allow' => allowed_methods.join(', ') }, []] }
       end
+
     end
   end
 end

data/lib/galago/router/version.rb

@@ -1,5 +1,5 @@
 module Galago
   class Router
-    VERSION = '0.1.1'
+    VERSION = '0.2.0'
   end
 end

data/spec/galago/features/head_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module Galago
+  describe "Routes" do
+    describe "HEAD" do
+
+      let(:app) do
+        Galago::Router.new do
+          get  '/users',    to: ->(env) { Rack::Response.new('get').finish }
+          put '/users/:id', to: ->(env) { Rack::Response.new('put').finish }
+        end
+      end
+
+      context "when a resource responds to GET requests" do
+        it "adds a HEAD request to the resource" do
+          head '/users'
+          expect(last_response.status).to eql 200
+        end
+
+        it "has no response body" do
+          head '/users'
+          expect(last_response.body).to eql ''
+        end
+
+        it "knows how large the content body would have been" do
+          head '/users'
+
+          content_length = last_response.headers['Content-Length']
+          expect(content_length).to eql 'get'.length.to_s
+        end
+
+        it "has the same headers as the GET request" do
+          get '/users'
+          get_headers = last_response.headers
+
+          head '/users'
+          head_headers = last_response.headers
+
+          expect(get_headers).to eql head_headers
+        end
+      end
+
+      context "when a resource does not respond to GET requests" do
+        it "returns a 405 method not allowed" do
+          head '/users/1'
+          expect(last_response.status).to eql 405
+        end
+      end
+
+    end
+  end
+end

data/spec/galago/features/options_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Galago
+  describe "Routes" do
+    describe "OPTIONS" do
+      let(:app) do
+        Galago::Router.new do
+          get  '/users', to: lambda { |env| [200, {}, ['get']] }
+          post '/users', to: lambda { |env| [200, {}, ['post']] }
+        end
+      end
+
+      context "when the resource has been defined" do
+        it "returns 200" do
+          options '/users'
+          expect(last_response.status).to eql 200
+        end
+
+        it "lists which request methods have been defined" do
+          options '/users'
+
+          allow_header = last_response.headers['Allow']
+          expect(allow_header).to eql 'GET, HEAD, OPTIONS, POST'
+        end
+      end
+
+      context "when the resource has not been defined" do
+        it "returns 404" do
+          options '/users/42'
+          expect(last_response.status).to eql 404
+        end
+      end
+
+    end
+  end
+end

data/spec/galago/router/path_spec.rb

@@ -61,19 +61,18 @@ module Galago
       end
     end
 
-    describe "#add_path_params_to_env" do
+    describe "#params_from" do
       let(:env) do
-        { 'rack.input' => anything }
+        { 'rack.input' => '' }
       end
 
       it "adds the params" do
         env['PATH_INFO'] = '/users/21/posts/42'
 
         path = Router::Path.new('/users/:user_id/posts/:id')
-        path.add_path_params_to_env(env)
+        params = path.params_from(env)
 
-        request = Rack::Request.new(env)
-        expect(request.params).to eql({
+        expect(params).to eql({
           'user_id' => '21',
           'id'      => '42'
         })
@@ -83,10 +82,9 @@ module Galago
         env['PATH_INFO'] = '/users'
 
         path = Router::Path.new('/users')
-        path.add_path_params_to_env(env)
+        params = path.params_from(env)
 
-        request = Rack::Request.new(env)
-        expect(request.params).to be_empty
+        expect(params).to be_empty
       end
     end
 

data/spec/galago/router/route_spec.rb

@@ -1,88 +1,128 @@
 require 'spec_helper'
+require 'pry'
 
 module Galago
   describe Router::Route do
     context "#call" do
       let(:env) do
-        { 'PATH_INFO' => '/foo' }
+        { 'rack.input' => '' }
       end
 
       let(:action) do
         lambda { |env| "foo" }
       end
 
-      it "adds the path's params to the env" do
-        route = Router::Route.new('GET', '/foo', action)
-        expect(route.path).to receive(:add_path_params_to_env).with(env)
+      context "when the request method is allowed" do
+        it "adds the named params to the env" do
+          env['PATH_INFO'] = '/users/bob'
 
-        route.call(env)
-      end
+          route = Router::Route.new('/users/:name')
+          route.add_endpoint('GET', action)
 
-      it "calls the route's action" do
-        route = Router::Route.new('GET', '/bar', action)
-        expect(action).to receive(:call).with(env)
+          route.call(env)
 
-        route.call(env)
-      end
-    end
+          extracted_params = env['galago_router.params']
+          expect(extracted_params).to eql('name' => 'bob')
+        end
 
-    context "#initialize" do
-      context "request method" do
-        it "errors when an invalid request method is provided" do
-          expect { Router::Route.new('foo', anything, lambda {})
-          }.to raise_error Router::RequestMethodInvalid
+        it "adds the path to the env" do
+          route = Router::Route.new('/foo/:id')
+          route.add_endpoint('GET', action)
+
+          route.call(env)
+
+          expect(env['galago_router.path']).to eql '/foo/:id'
         end
 
-        it "remembers the request method" do
-          Router::REQUEST_METHODS.each do |request_method|
-            route = Router::Route.new(request_method, anything, lambda {})
-            expect(route.request_method).to eql request_method
-          end
+        it "calls the route's action" do
+          route = Router::Route.new('/bar')
+          route.add_endpoint('GET', action)
+
+          expect(action).to receive(:call).with(env)
+
+          env['REQUEST_METHOD'] = 'GET'
+          route.call(env)
         end
       end
 
-      context "#recognizes?" do
-        it "recognizes a paths with no named parameters" do
-          path = Router::Path.new('/users')
-          expect(path).to be_recognizes('/users')
+      context "when the request method is not allowed" do
+        let(:route) do
+          route = Router::Route.new('/foo')
+          route.add_endpoint('GET', lambda { |env| 'foo' })
+          route.add_endpoint('PUT', lambda { |env| 'foo' })
+          route
         end
 
-        it "recognizes a path with named parameters" do
-          path = Router::Path.new('/users/:id')
-          expect(path).to be_recognizes('/users/32')
-        end
-      end
+        it "has a 405 status code" do
+          env['REQUEST_METHOD'] = 'DELETE'
+          response = route.call(env)
 
-      context "#named_parameters" do
-        it "has none when no segments start with a ':'" do
-          path = Router::Path.new('/users')
-          expect(path).to have(0).named_parameters
+          status = response[0]
+          expect(status).to eql(405)
         end
 
-        it "returns segments starting with a ':'" do
-          path = Router::Path.new('/accounts/:account_id/users/:id')
-          expect(path.named_parameters).to eql ['account_id', 'id']
+        it "sets the 'Allow' header" do
+          env['REQUEST_METHOD'] = 'DELETE'
+          response = route.call(env)
+
+          headers = response[1]
+          expect(headers['Allow']).to eql 'GET, OPTIONS, PUT'
         end
       end
+    end
 
-      context "path" do
-        it "remembers the path" do
-          route = Router::Route.new('GET', '/foo', lambda {})
-          expect(route.path.to_s).to eql '/foo'
-        end
+    context "allowed_methods" do
+      let(:route) { Router::Route.new('/users/:id/posts') }
+
+      it "allows OPTIONS by default" do
+        expect(route.allowed_methods).to eql ['OPTIONS']
       end
 
-      context "action" do
-        it "raises an error when the action does not respond to call" do
-          expect { Router::Route.new('PATCH', '/foo', :action)
-          }.to raise_error Router::ActionInvalid
-        end
+      it "has an allowed method for each endpoint" do
+        route.add_endpoint('POST', anything)
+        route.add_endpoint('PUT', anything)
 
-        it "remembers the action" do
-          action = Proc.new { 'action' }
-          route = Router::Route.new('GET', '/foo', action)
-          expect(route.action).to eql action
-        end
+        expect(route.allowed_methods).to eql ['OPTIONS', 'POST', 'PUT']
+      end
+
+      it "lists the allowed methods in alphabetical order" do
+        route.add_endpoint('POST', anything)
+        route.add_endpoint('DELETE', anything)
+        route.add_endpoint('GET', anything)
+
+        allowed_methods = route.allowed_methods
+        expect(allowed_methods).to eql ['DELETE', 'GET', 'OPTIONS', 'POST']
+      end
+    end
+
+    context "#recognizes?" do
+      it "recognizes a paths with no named parameters" do
+        path = Router::Path.new('/users')
+        expect(path).to be_recognizes('/users')
+      end
+
+      it "recognizes a path with named parameters" do
+        path = Router::Path.new('/users/:id')
+        expect(path).to be_recognizes('/users/32')
+      end
+    end
+
+    context "#named_parameters" do
+      it "has none when no segments start with a ':'" do
+        path = Router::Path.new('/users')
+        expect(path).to have(0).named_parameters
+      end
+
+      it "returns segments starting with a ':'" do
+        path = Router::Path.new('/accounts/:account_id/users/:id')
+        expect(path.named_parameters).to eql ['account_id', 'id']
+      end
+    end
+
+    context "path" do
+      it "remembers the path" do
+        route = Router::Route.new('/foo')
+        expect(route.path.to_s).to eql '/foo'
       end
     end
   end

data/spec/galago/router/version_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Galago
   describe 'Router::VERSION' do
     it "current" do
-      expect(Router::VERSION).to eql '0.1.1'
+      expect(Router::VERSION).to eql '0.2.0'
     end
   end
 end

data/spec/galago/router_spec.rb

@@ -12,11 +12,11 @@ module Galago
           delete '/foo' , to: lambda { |env| 'bar' }
         end
 
-        expect(router).to have_route(:get, '/foo')
-        expect(router).to have_route(:post, '/foo')
-        expect(router).to have_route(:patch, '/foo')
-        expect(router).to have_route(:put, '/foo')
-        expect(router).to have_route(:delete, '/foo')
+        expect(router).to have_route('GET', '/foo')
+        expect(router).to have_route('POST', '/foo')
+        expect(router).to have_route('PATCH', '/foo')
+        expect(router).to have_route('PUT', '/foo')
+        expect(router).to have_route('DELETE', '/foo')
       end
 
       it 'adds the namespace to the route' do
@@ -32,13 +32,13 @@ module Galago
           end
         end
 
-        expect(router).to have_route(:get, '/foo')
-        expect(router).to have_route(:post, '/foo')
+        expect(router).to have_route('GET', '/foo')
+        expect(router).to have_route('POST', '/foo')
 
-        expect(router).to have_route(:get, '/foo/1')
-        expect(router).to have_route(:patch, '/foo/2')
-        expect(router).to have_route(:put, '/foo/3')
-        expect(router).to have_route(:delete, '/foo/4')
+        expect(router).to have_route('GET', '/foo/1')
+        expect(router).to have_route('PATCH', '/foo/2')
+        expect(router).to have_route('PUT', '/foo/3')
+        expect(router).to have_route('DELETE', '/foo/4')
       end
 
       it 'can have multiple namespaces' do
@@ -57,10 +57,10 @@ module Galago
           end
         end
 
-        expect(router).to have_route(:get, '/foo')
-        expect(router).to have_route(:get, '/foo/bar')
-        expect(router).to have_route(:get, '/foo/bar/1')
-        expect(router).to have_route(:get, '/hello')
+        expect(router).to have_route('GET', '/foo')
+        expect(router).to have_route('GET', '/foo/bar')
+        expect(router).to have_route('GET', '/foo/bar/1')
+        expect(router).to have_route('GET', '/hello')
       end
     end
 
@@ -71,48 +71,43 @@ module Galago
 
       it "stores the route" do
         router = Router.new
-        router.add_route(:get, '/users', rack_app)
+        router.add_route('GET', '/users', rack_app)
 
-        expect(router).to have_route(:get, '/users')
-      end
-
-      it "raises an error when an invalid http verb is provided" do
-        router = Router.new
-
-        expect { router.add_route(:foo, '/foo', rack_app)
-        }.to raise_error Router::RequestMethodInvalid
+        expect(router).to have_route('GET', '/users')
       end
     end
 
     describe "has_route?" do
       it "returns true when the route has been added" do
         router = Router.new
-        router.add_route(:post, '/users', lambda {})
+        router.add_route('POST', '/users', lambda {})
 
-        expect(router).to have_route(:post, '/users')
+        expect(router).to have_route('POST', '/users')
       end
 
       it "returns true when the route has a path param" do
         router = Router.new
-        router.add_route(:get, '/users/:id', lambda {})
+        router.add_route('GET', '/users/:id', lambda {})
 
-        expect(router).to have_route(:get, '/users/42')
+        expect(router).to have_route('GET', '/users/42')
       end
 
       it "returns false when the route has not been added" do
         router = Router.new
-        router.add_route(:post, '/users', lambda {})
+        router.add_route('POST', '/users', lambda {})
 
-        expect(router).not_to have_route(:get, '/users')
+        expect(router).not_to have_route('GET', '/users')
       end
     end
 
     describe "#call" do
       it "calls the rack app when the route is found" do
-        router = Router.new
-        router.add_route(:get, '/foo', lambda { |env| [200, {}, 'bar'] })
+        router = Router.new do
+          get '/foo', to: lambda { |env| [200, {}, 'bar'] }
+        end
 
         response = router.call({
+          'rack.input' => '',
           'REQUEST_METHOD' => 'GET',
           'PATH_INFO' => '/foo'
         })
@@ -124,6 +119,7 @@ module Galago
         router = Router.new
 
         response = router.call({
+          'rack.input' => '',
           'REQUEST_METHOD' => 'GET',
           'PATH_INFO' => '/bar'
         })
@@ -134,5 +130,27 @@ module Galago
       end
     end
 
+    describe "responses" do
+      context "method not allowed" do
+        let(:app) do
+          Router.new do
+            get '/foo', to: lambda { |env| [200, {}, ['foo']] }
+          end
+        end
+
+        it 'sets the status code to 405' do
+          post '/foo'
+          expect(last_response.status).to eql(405)
+        end
+
+        it "sets the 'Allow' header to the allowed methods" do
+          post '/foo'
+
+          allow = last_response.headers.fetch('Allow')
+          expect(allow).to eql 'GET, HEAD, OPTIONS'
+        end
+      end
+    end
+
   end
 end

data/spec/spec_helper.rb

@@ -8,3 +8,4 @@ RSpec.configure do |config|
 
   config.include Rack::Test::Methods
 end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: galago-router
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Joe Karayusuf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-18 00:00:00.000000000 Z
+date: 2014-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -116,6 +116,8 @@ files:
 - lib/galago/router/path.rb
 - lib/galago/router/route.rb
 - lib/galago/router/version.rb
+- spec/galago/features/head_spec.rb
+- spec/galago/features/options_spec.rb
 - spec/galago/router/path_spec.rb
 - spec/galago/router/route_spec.rb
 - spec/galago/router/version_spec.rb
@@ -146,6 +148,8 @@ signing_key:
 specification_version: 4
 summary: ''
 test_files:
+- spec/galago/features/head_spec.rb
+- spec/galago/features/options_spec.rb
 - spec/galago/router/path_spec.rb
 - spec/galago/router/route_spec.rb
 - spec/galago/router/version_spec.rb