galago-router 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12e8872da7d883013a2edaa73193d11f9ebe00a6
-  data.tar.gz: 27e804be87b65711ab84cd2fe7c674f6cda45efb
+  metadata.gz: 24dc9a36ea2bca4e8d75e2722b5ae5a78010d19f
+  data.tar.gz: 39497251884dfba4e67bc8746029734b13a87642
 SHA512:
-  metadata.gz: 05eadb6f0ad527e2a73d8087bc1a6c3724d894d5a75340b20118c4ac80e2b7e58c8536f1e41bf864b493e50967953284a618ce558acea7a27f3cd12ee3e9829c
-  data.tar.gz: 920319b3d504dd72f4f5dea98ec94cca38a661798cc7219e24f113773d0a5e77e1a461329f0e842999930166508f784fcdfb250d580acd75729310cfa0b301f7
+  metadata.gz: 7cba7c52f27784cb3fe98ab0b199f8d88dfd911808bdeece4039d969fa44eec49feefc99f9b908505a5003268a58aa82780daea0a197b722dcbcf2791a372286
+  data.tar.gz: 41bf1fdb47a22e7cdd7a873c3f8209c5ceedabaa60387bf37e2f0eb1e9a229c028dc7065383b4fa3a9b1cebaf34f1a3bf3dd289e4111e442e299f938794f56ef

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 *.rbc
+*.swp
 .bundle
 .config
 .yardoc

data/README.md

@@ -1,13 +1,12 @@
-# Galago
+# Galago Router
 
-Galago is an API micro framework for Ruby.
-I am building it to gain more appreciation for existing tools.
+A rack router.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'galago'
+    gem 'galago-router'
 
 And then execute:
 
@@ -15,39 +14,24 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install galago
+    $ gem install galago-router
 
 ## Usage
 
 ```ruby
-module GitHub::Application < Galago::Application
-  routes do
-    get '/users' do
-      users = User.all
-    end
-
-    post '/users' do
-      user = User.create! params['user']
-    end
-
-    patch '/users/:name' do
-      user = User.find_by_name params['name']
-      user.update! params['user']
-    end
-
-    put '/users/:name' do
-      user = User.find_by_name params['name']
-      user.update! params['user']
-    end
-
-    delete '/users/:name' do
-      user = User.find_by_name params['name']
-      user.destroy!
-    end
-  end
+# config.ru
+require 'galago/router'
+require 'rack/lobster'
+
+router = Galago::Router.new do
+  get    '/lobsters',       to: Rack::Lobster.new
+  post   '/lobsters',       to: Rack::Lobster.new
+  patch  '/lobsters/:name', to: Rack::Lobster.new
+  put    '/lobsters/:name', to: Rack::Lobster.new
+  delete '/lobsters/:name', to: Rack::Lobster.new
 end
 
-run GitHub::Application
+run router
 ```
 
 ## Contributing

data/examples/echo_param.ru

@@ -0,0 +1,19 @@
+require 'galago/router'
+
+EchoParams = lambda { |env|
+  params = Rack::Request.new(env).params
+  Rack::Response.new(params).finish
+}
+
+router = Galago::Router.new do
+  get '/echo_params', to: EchoParams
+  get '/echo_params/:name', to: EchoParams
+
+  post '/echo_params', to: EchoParams
+  put '/echo_params/:name', to: EchoParams
+
+  delete '/echo_params', to: EchoParams
+end
+
+run router
+

data/examples/lobster.ru

@@ -0,0 +1,9 @@
+require 'galago/router'
+require 'rack/lobster'
+
+router = Galago::Router.new do
+  get '/lobster', to: Rack::Lobster.new
+end
+
+run router
+

data/lib/galago/router/dsl.rb

@@ -1,28 +1,30 @@
 module Galago
-  class Router::DSL
-    def initialize(router, block)
-      @router = router
-      instance_eval(&block)
-    end
+  class Router
+    class DSL
+      def initialize(router, block)
+        @router = router
+        instance_eval(&block)
+      end
 
-    def get(path, options)
-      @router.add_route("GET", path, options[:to])
-    end
+      def get(path, options)
+        @router.add_route("GET", path, options[:to])
+      end
 
-    def patch(path, options)
-      @router.add_route("PATCH", path, options[:to])
-    end
+      def patch(path, options)
+        @router.add_route("PATCH", path, options[:to])
+      end
 
-    def post(path, options)
-      @router.add_route("POST", path, options[:to])
-    end
+      def post(path, options)
+        @router.add_route("POST", path, options[:to])
+      end
 
-    def put(path, options)
-      @router.add_route("PUT", path, options[:to])
-    end
+      def put(path, options)
+        @router.add_route("PUT", path, options[:to])
+      end
 
-    def delete(path, options)
-      @router.add_route("DELETE", path, options[:to])
+      def delete(path, options)
+        @router.add_route("DELETE", path, options[:to])
+      end
     end
   end
 end

data/lib/galago/router/errors.rb

@@ -1,21 +1,23 @@
 module Galago
-  class Router::ActionInvalid < ArgumentError
-    def initialize(action)
-      @action = action
-    end
+  class Router
+    class ActionInvalid < ArgumentError
+      def initialize(action)
+        @action = action
+      end
 
-    def message
-      "Action does not have a call method: #{@action.inspect}"
+      def message
+        "Action does not have a call method: #{@action.inspect}"
+      end
     end
-  end
 
-  class Router::RequestMethodInvalid < ArgumentError
-    def initialize(request_method)
-      @request_method = request_method
-    end
+    class RequestMethodInvalid < ArgumentError
+      def initialize(request_method)
+        @request_method = request_method
+      end
 
-    def message
-      "Got: #{@request_method}\nExpected one of: #{REQUEST_METHODS}"
+      def message
+        "Got: #{@request_method}\nExpected one of: #{REQUEST_METHODS}"
+      end
     end
   end
 end

data/lib/galago/router/path.rb

@@ -1,44 +1,49 @@
 module Galago
-  class Router::Path
+  class Router
+    class Path
 
-    def initialize(path)
-      @path = path.to_s
-    end
+      def initialize(path)
+        @path = path.to_s
+      end
 
-    def recognizes?(request_path)
-      request_path =~ regex
-    end
+      def recognizes?(request_path)
+        request_path =~ regex
+      end
 
-    def named_parameters
-      @path_parameters ||= @path.scan(/\:(\w+)/).flatten
-    end
+      def named_parameters
+        @path_parameters ||= @path.scan(/\:(\w+)/).flatten
+      end
+
+      def add_path_params_to_env(env)
+        request = Rack::Request.new(env)
 
-    def add_path_params_to_env(env)
-      request = Rack::Request.new(env)
-      identify_params_in_path(request.path).each do |key, value|
-        request.update_param(key, value)
+        if path_params = identify_params_in_path(request.path)
+          path_params.each { |key, value| request.update_param(key, value) }
+        end
       end
-    end
 
-    def identify_params_in_path(request_path)
-      values = regex.match(request_path).captures
-      Hash[named_parameters.zip(values)]
-    end
+      def to_s
+        @path
+      end
 
-    def to_s
-      @path
-    end
+      private
 
-    private
+      def regex
+        @regex_path ||= convert_path_to_regex(@path)
+      end
 
-    def regex
-      @regex_path ||= convert_path_to_regex(@path)
-    end
+      def convert_path_to_regex(path)
+        regexp = path.to_s.gsub(/\:\w+/, '([\w-]+)')
+        Regexp.new("^#{regexp}$")
+      end
 
-    def convert_path_to_regex(path)
-      regexp = path.to_s.gsub(/\:\w+/, '([\w-]+)')
-      Regexp.new("^#{regexp}$")
-    end
+      def identify_params_in_path(path)
+        if match = regex.match(path)
+          named_parameters.zip(match.captures)
+        end
+      end
 
+    end
   end
 end
+

data/lib/galago/router/route.rb

@@ -1,36 +1,39 @@
 module Galago
-  class Router::Route
+  class Router
+    class Route
 
-    attr_reader :request_method, :path, :action
+      attr_reader :request_method, :path, :action
 
-    def initialize(request_method, path, action)
-      @request_method = request_method.to_s.upcase
-      @path = Router::Path.new(path)
-      @action = action
+      def initialize(request_method, path, action)
+        @request_method = request_method.to_s.upcase
+        @path = Router::Path.new(path)
+        @action = action
 
-      validate_action!
-      validate_request_method!
-    end
+        validate_action!
+        validate_request_method!
+      end
 
-    def recognizes_path?(request_path)
-      @path.recognizes?(request_path)
-    end
+      def recognizes_path?(request_path)
+        @path.recognizes?(request_path)
+      end
 
-    def call(env)
-      @path.add_path_params_to_env(env)
-      action.call(env)
-    end
+      def call(env)
+        @path.add_path_params_to_env(env)
+        action.call(env)
+      end
 
-    private
+      private
 
-    def validate_action!
-      action.respond_to?(:call) or raise Router::ActionInvalid.new(action)
-    end
+      def validate_action!
+        action.respond_to?(:call) or raise Router::ActionInvalid.new(action)
+      end
 
-    def validate_request_method!
-      unless Router::REQUEST_METHODS.include?(request_method)
-        raise Router::RequestMethodInvalid.new(request_method)
+      def validate_request_method!
+        unless Router::REQUEST_METHODS.include?(request_method)
+          raise Router::RequestMethodInvalid.new(request_method)
+        end
       end
     end
   end
 end
+

data/lib/galago/router/version.rb

@@ -1,5 +1,5 @@
 module Galago
   class Router
-    VERSION = '0.0.1'
+    VERSION = '0.0.2'
   end
 end

data/lib/galago/router.rb

@@ -1,22 +1,11 @@
+require 'galago/router/dsl'
+require 'galago/router/errors'
+require 'galago/router/path'
+require 'galago/router/route'
+require 'galago/router/version'
+
 module Galago
   class Router
-    require 'galago/router/dsl'
-    require 'galago/router/errors'
-    require 'galago/router/path'
-    require 'galago/router/route'
-    require 'galago/router/version'
-
-    def self.call(env)
-      router.process_request(env)
-    end
-
-    def self.routes(&block)
-      Router::DSL.new(router, block)
-    end
-
-    def self.router
-      @router ||= Router.new
-    end
 
     REQUEST_METHODS = [
       "GET",
@@ -28,11 +17,13 @@ module Galago
 
     attr_reader :routes
 
-    def initialize
+    def initialize(&block)
       @routes = REQUEST_METHODS.each_with_object({}) do |request_method, routes|
         routes[request_method] = []
         routes
       end
+
+      Router::DSL.new(self, block) if block_given?
     end
 
     def add_route(request_method, path, application)
@@ -44,7 +35,7 @@ module Galago
       find_route(request_method, path) ? true : false
     end
 
-    def process_request(env)
+    def call(env)
       if route = find_route(env['REQUEST_METHOD'], env['PATH_INFO'])
         route.call(env)
       else

data/spec/galago/router/path_spec.rb

@@ -68,22 +68,5 @@ module Galago
       end
     end
 
-    describe "#identify_params_in_path" do
-      it "identifies each param and its value" do
-        path = Router::Path.new('/users/:user_id/posts/:id')
-        path_params = path.identify_params_in_path('/users/1/posts/2')
-
-        expect(path_params).to eql({
-          'user_id' => '1',
-          'id'      => '2'
-        })
-      end
-
-      it "returns empty when no path params are present" do
-        path = Router::Path.new('/users')
-        expect(path.identify_params_in_path('/users')).to be_empty
-      end
-    end
-
   end
 end

data/spec/galago/router/route_spec.rb

@@ -2,6 +2,30 @@ require 'spec_helper'
 
 module Galago
   describe Router::Route do
+    context "#call" do
+      let(:env) do
+        { 'PATH_INFO' => '/foo' }
+      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)
+
+        route.call(env)
+      end
+
+      it "calls the route's action" do
+        route = Router::Route.new('GET', '/bar', action)
+        expect(action).to receive(:call).with(env)
+
+        route.call(env)
+      end
+    end
+
     context "#initialize" do
       context "request method" do
         it "errors when an invalid request method is provided" do
@@ -41,25 +65,6 @@ module Galago
         end
       end
 
-      context "#identify_params_in_path" do
-        it "does not find named parameters when the path has none" do
-          path = Router::Path.new('/accounts')
-          identified_parameters = path.identify_params_in_path('/accounts')
-
-          expect(identified_parameters).to be_empty
-        end
-
-        it "maps the names for params in the path" do
-          path = Router::Path.new('/accounts/:account_id/users/:id')
-          identified_parameters = path.identify_params_in_path('/accounts/42/users/11')
-
-          expect(identified_parameters).to eql({
-            'account_id' => '42',
-            'id'         => '11'
-          })
-        end
-      end
-
       context "path" do
         it "remembers the path" do
           route = Router::Route.new('GET', '/foo', lambda {})

data/spec/galago/router/version_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 module Galago
   describe 'Router::VERSION' do
-    it "0.0.1" do
-      expect(Router::VERSION).to eql '0.0.1'
+    it "current" do
+      expect(Router::VERSION).to eql '0.0.2'
     end
   end
 end

data/spec/galago/router_spec.rb

@@ -2,18 +2,9 @@ require 'spec_helper'
 
 module Galago
   describe Router do
-    let(:router) { Class.new(Router) }
-
-    describe '.call' do
-      it 'tells the router to process the request' do
-        expect(router.router).to receive(:process_request).with('env')
-        router.call('env')
-      end
-    end
-
     describe '.routes' do
       it 'adds the specified routes' do
-        router.routes do
+        router = Router.new do
           get    '/foo' , to: lambda { |env| 'bar' }
           post   '/foo' , to: lambda { |env| 'bar' }
           patch  '/foo' , to: lambda { |env| 'bar' }
@@ -21,22 +12,11 @@ module Galago
           delete '/foo' , to: lambda { |env| 'bar' }
         end
 
-        expect(router.router).to have_route(:get, '/foo')
-        expect(router.router).to have_route(:post, '/foo')
-        expect(router.router).to have_route(:patch, '/foo')
-        expect(router.router).to have_route(:put, '/foo')
-        expect(router.router).to have_route(:delete, '/foo')
-      end
-    end
-
-    describe '.router' do
-      it 'builds an instance if the router' do
-        expect(router.router).to be_a Router
-      end
-
-      it 'remembers the router that was built' do
-        router_id = router.router.object_id
-        expect(router.router.object_id).to eql router_id
+        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
     end
 
@@ -83,12 +63,12 @@ module Galago
       end
     end
 
-    describe "process_request" do
+    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'] })
 
-        response = router.process_request({
+        response = router.call({
           'REQUEST_METHOD' => 'GET',
           'PATH_INFO' => '/foo'
         })
@@ -99,7 +79,7 @@ module Galago
       it "returns 404 when no route matchs the path" do
         router = Router.new
 
-        response = router.process_request({
+        response = router.call({
           'REQUEST_METHOD' => 'GET',
           'PATH_INFO' => '/bar'
         })

data/spec/spec_helper.rb

@@ -7,12 +7,4 @@ RSpec.configure do |config|
   config.formatter = :documentation
 
   config.include Rack::Test::Methods
-
-  def application(&block)
-    let(:app) do
-      klass = Class.new(Galago::Router)
-      klass.class_eval(&block)
-      klass
-    end
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: galago-router
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Joe Karayusuf
@@ -106,8 +106,9 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- galago.gemspec
-- lib/galago.rb
+- examples/echo_param.ru
+- examples/lobster.ru
+- galago-router.gemspec
 - lib/galago/router.rb
 - lib/galago/router/dsl.rb
 - lib/galago/router/errors.rb

data/lib/galago.rb

@@ -1,2 +0,0 @@
-module Galago
-end