galago-router 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 12e8872da7d883013a2edaa73193d11f9ebe00a6
+  data.tar.gz: 27e804be87b65711ab84cd2fe7c674f6cda45efb
+SHA512:
+  metadata.gz: 05eadb6f0ad527e2a73d8087bc1a6c3724d894d5a75340b20118c4ac80e2b7e58c8536f1e41bf864b493e50967953284a618ce558acea7a27f3cd12ee3e9829c
+  data.tar.gz: 920319b3d504dd72f4f5dea98ec94cca38a661798cc7219e24f113773d0a5e77e1a461329f0e842999930166508f784fcdfb250d580acd75729310cfa0b301f7

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in galago.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Joe Karayusuf
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# Galago
+
+Galago is an API micro framework for Ruby.
+I am building it to gain more appreciation for existing tools.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'galago'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install galago
+
+## 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
+end
+
+run GitHub::Application
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/galago.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'galago/router/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "galago-router"
+  spec.version       = Galago::Router::VERSION
+  spec.authors       = ["Joe Karayusuf"]
+  spec.email         = ["jkarayusuf@gmail.com"]
+  spec.description   = %q{Rack router}
+  spec.summary       = %q{}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'rack'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/galago.rb

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

data/lib/galago/router.rb

@@ -0,0 +1,69 @@
+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",
+      "PATCH",
+      "POST",
+      "PUT",
+      "DELETE"
+    ]
+
+    attr_reader :routes
+
+    def initialize
+      @routes = REQUEST_METHODS.each_with_object({}) do |request_method, routes|
+        routes[request_method] = []
+        routes
+      end
+    end
+
+    def add_route(request_method, path, application)
+      route = Route.new(request_method, path, application)
+      routes[route.request_method] << route
+    end
+
+    def has_route?(request_method, path)
+      find_route(request_method, path) ? true : false
+    end
+
+    def process_request(env)
+      if route = find_route(env['REQUEST_METHOD'], env['PATH_INFO'])
+        route.call(env)
+      else
+        Rack::Response.new("Not Found", 404).finish
+      end
+    end
+
+    private
+
+    def find_route(request_method, path)
+      routes = routes_for_request_method(request_method)
+      route = routes.detect { |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
+    end
+
+  end
+end

data/lib/galago/router/dsl.rb

@@ -0,0 +1,28 @@
+module Galago
+  class Router::DSL
+    def initialize(router, block)
+      @router = router
+      instance_eval(&block)
+    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 post(path, options)
+      @router.add_route("POST", 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])
+    end
+  end
+end

data/lib/galago/router/errors.rb

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

data/lib/galago/router/path.rb

@@ -0,0 +1,44 @@
+module Galago
+  class Router::Path
+
+    def initialize(path)
+      @path = path.to_s
+    end
+
+    def recognizes?(request_path)
+      request_path =~ regex
+    end
+
+    def named_parameters
+      @path_parameters ||= @path.scan(/\:(\w+)/).flatten
+    end
+
+    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)
+      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
+
+    private
+
+    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
+
+  end
+end

data/lib/galago/router/route.rb

@@ -0,0 +1,36 @@
+module Galago
+  class Router::Route
+
+    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
+
+      validate_action!
+      validate_request_method!
+    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
+
+    private
+
+    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)
+      end
+    end
+  end
+end

data/lib/galago/router/version.rb

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

data/spec/galago/router/path_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module Galago
+  describe Router::Path do
+
+    describe "#recognizes?" do
+      it "recognizes exact matches" do
+        path = Router::Path.new('/users')
+        expect(path).to be_recognizes '/users'
+      end
+
+      it "recognizes parameters matches" do
+        path = Router::Path.new('/users/:id')
+        expect(path).to be_recognizes '/users/1'
+      end
+
+      it "does not recognize exact param matches" do
+        path = Router::Path.new('/users/:id')
+        expect(path).not_to be_recognizes '/users/:id'
+      end
+    end
+
+    describe "#to_s" do
+      it "returns the path as a string" do
+        path = Router::Path.new(:foo)
+        expect(path.to_s).to eql 'foo'
+      end
+    end
+
+    describe "#named_parameters" do
+      it "returns path segments starting with a ':'" do
+        path = Router::Path.new('/users/:user_id/posts/:id')
+        expect(path.named_parameters).to eql ['user_id', 'id']
+      end
+
+      it "returns empty when no segments begin with a ':'" do
+        path = Router::Path.new('/users')
+        expect(path.named_parameters).to be_empty
+      end
+    end
+
+    describe "#add_path_params_to_env" do
+      let(:env) do
+        { 'rack.input' => anything }
+      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)
+
+        request = Rack::Request.new(env)
+        expect(request.params).to eql({
+          'user_id' => '21',
+          'id'      => '42'
+        })
+      end
+
+      it "does not add params when no path params exist" do
+        env['PATH_INFO'] = '/users'
+
+        path = Router::Path.new('/users')
+        path.add_path_params_to_env(env)
+
+        request = Rack::Request.new(env)
+        expect(request.params).to be_empty
+      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

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module Galago
+  describe Router::Route do
+    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
+        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
+        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 "#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 {})
+          expect(route.path.to_s).to eql '/foo'
+        end
+      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 "remembers the action" do
+          action = Proc.new { 'action' }
+          route = Router::Route.new('GET', '/foo', action)
+          expect(route.action).to eql action
+        end
+      end
+    end
+  end
+end
+

data/spec/galago/router/version_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+module Galago
+  describe 'Router::VERSION' do
+    it "0.0.1" do
+      expect(Router::VERSION).to eql '0.0.1'
+    end
+  end
+end

data/spec/galago/router_spec.rb

@@ -0,0 +1,114 @@
+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
+          get    '/foo' , to: lambda { |env| 'bar' }
+          post   '/foo' , to: lambda { |env| 'bar' }
+          patch  '/foo' , to: lambda { |env| 'bar' }
+          put    '/foo' , to: lambda { |env| 'bar' }
+          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
+      end
+    end
+
+    describe "#add_route" do
+      let(:rack_app) do
+        lambda { |env| "RackApp" }
+      end
+
+      it "stores the route" do
+        router = Router.new
+        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
+      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 {})
+
+        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 {})
+
+        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 {})
+
+        expect(router).not_to have_route(:get, '/users')
+      end
+    end
+
+    describe "process_request" 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({
+          'REQUEST_METHOD' => 'GET',
+          'PATH_INFO' => '/foo'
+        })
+
+        expect(response).to eql [200, {}, 'bar']
+      end
+
+      it "returns 404 when no route matchs the path" do
+        router = Router.new
+
+        response = router.process_request({
+          'REQUEST_METHOD' => 'GET',
+          'PATH_INFO' => '/bar'
+        })
+
+        expect(response[0]).to eql(404)
+        expect(response[1]).to eql({ 'Content-Length' => '9' })
+        expect(response[2].body).to eql(['Not Found'])
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'galago/router'
+require 'rack/test'
+require 'pry'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  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

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: galago-router
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joe Karayusuf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rack router
+email:
+- jkarayusuf@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- galago.gemspec
+- lib/galago.rb
+- lib/galago/router.rb
+- lib/galago/router/dsl.rb
+- lib/galago/router/errors.rb
+- lib/galago/router/path.rb
+- lib/galago/router/route.rb
+- lib/galago/router/version.rb
+- spec/galago/router/path_spec.rb
+- spec/galago/router/route_spec.rb
+- spec/galago/router/version_spec.rb
+- spec/galago/router_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: ''
+test_files:
+- spec/galago/router/path_spec.rb
+- spec/galago/router/route_spec.rb
+- spec/galago/router/version_spec.rb
+- spec/galago/router_spec.rb
+- spec/spec_helper.rb
+has_rdoc: