hobby 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8c721c77a7b912fa113e730de3ff58cdf8866e06
+  data.tar.gz: 4590a7005e8597a277cae934955b30b0a981b1b4
+SHA512:
+  metadata.gz: 2bb9aa2ee633d3d06c85a7e41dd1a1b59bb4d870c48de2b351846b7e38566e1f17731bb94894bcec50e917e1fbcfab51d7784d6175ae89db37476918373d3403
+  data.tar.gz: efa3483ccf3ea59cc6e6e16dd4280713eaef4e7a04b1ac1cd66c07e42344cd42efb6a52ddabab7cf4ed2fee032926264fb6f7224f8750e555976309d29665364

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/.travis.yml

@@ -0,0 +1,9 @@
+---
+rvm:
+  - 2.0.0
+  - 2.1.2
+  - ruby-head
+addons:
+  code_climate:
+    repo_token:
+      secure: "bogVqPmJ2KlI2XK3Ln9Ki8vG08WTvKbKfvYm4ErD1A+2t3vg61utFKxJS8R3P5QKuDDIIX98eQC7r+gPeGEYwT+tDDFMnBsGQZcaeXJCYZQ3qLN36GpnPmpeZ3tTZwop5aT1AmMCF0IllDWYCjcWzeEZan23Eqt5YOyzTGAnr4g="

data/CHANGELOG.md

@@ -0,0 +1,53 @@
+# 0.6.0
+
+* Change the implementation of `Hobbit::Base#halt`. This new implementation is
+more rack compliant.
+* Test hobbit with [oktobertest](https://github.com/patriciomacadden/oktobertest)
+instead of minitest (Because reasons!).
+
+# 0.5.1 (Unreleased)
+
+* A class is an object too, so allow to `run` classes.
+* Add `Hobbit::Request`, which sets the path info to `/` if its empty (instead
+of doing that on the call method).
+
+# 0.5.0
+
+* Refactor `Hobbit::Base#halt`. It now sets the status, merges the headers and
+writes the body (using `Hobbit::Response#write`) when given a fixnum, a hash or
+a string.
+* `Hobbit::Response` headers and body are not accessors anymore. This is
+because when you set the body directly, the `Content-Length` is not calculated
+(it's calculated on `#write`).
+
+# 0.4.4
+
+* Refactor `Hobbit::Response`.
+
+# 0.4.3
+
+* Calculate the `Content-Length` of a `Hobbit::Response` using `#bytesize`
+instead of `#size`.
+
+# 0.4.2
+
+* Add `Hobbit::Response#redirect`, that was missing since `Hobbit::Response`
+isn't a `Rack::Response` subclass.
+
+# 0.4.1
+
+* `Hobbit::Response` now returns the `Content-Length` header as a string.
+
+# 0.4.0
+
+* Add halt method.
+
+# 0.3.1
+
+* Remove unused `attr_accessor` (`:length`) from `Hobbit::Response`.
+
+# 0.3.0
+
+* `Hobbit::Response` is no longer a subclass of `Rack::Response`.
+* Forward `#map` and `#use` methods to `Rack::Builder` instead of define these
+methods.

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Patricio Mac Adden
+
+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,378 @@
+# Hobbit [![Build Status](http://img.shields.io/travis/patriciomacadden/hobbit.svg)](https://travis-ci.org/patriciomacadden/hobbit) [![Code Climate](http://img.shields.io/codeclimate/github/patriciomacadden/hobbit.svg)](https://codeclimate.com/github/patriciomacadden/hobbit) [![Code Climate Coverage](http://img.shields.io/codeclimate/coverage/github/patriciomacadden/hobbit.svg)](https://codeclimate.com/github/patriciomacadden/hobbit) [![Dependency Status](http://img.shields.io/gemnasium/patriciomacadden/hobbit.svg)](https://gemnasium.com/patriciomacadden/hobbit) [![Gem Version](http://img.shields.io/gem/v/hobbit.svg)](http://badge.fury.io/rb/hobbit)
+
+A minimalistic microframework built on top of [Rack](http://rack.github.io/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hobbit'
+# or this if you want to use hobbit master
+# gem 'hobbit', github: 'patriciomacadden/hobbit'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install hobbit
+```
+
+## Features
+
+* DSL inspired by [Sinatra](http://www.sinatrarb.com/).
+* [Speed](https://github.com/luislavena/bench-micro).
+* Extensible with standard ruby classes and modules, with no extra logic. See
+[hobbit-contrib](https://github.com/patriciomacadden/hobbit-contrib).
+* Zero configuration.
+
+## Philosophy
+
+* [Don't repeat yourself](http://en.wikipedia.org/wiki/Don't_repeat_yourself)
+* Encourages the understanding and use of [Rack](http://rack.github.io/) and
+its extensions instead of providing such functionality.
+
+## Usage
+
+Hobbit applications are just instances of classes that inherits from
+`Hobbit::Base`, which complies the
+[Rack SPEC](http://rubydoc.info/github/rack/rack/master/file/SPEC).
+
+### Hello World example
+
+Create a file called `app.rb`:
+
+```ruby
+require 'hobbit'
+
+class App < Hobbit::Base
+  get '/' do
+    'Hello World!'
+  end
+end
+```
+
+Create a `config.ru` file:
+
+```ruby
+require './app'
+
+run App.new # or just `run App`
+```
+
+Run it with `rackup`:
+
+```bash
+$ rackup
+```
+
+View your app at [http://localhost:9292](http://localhost:9292).
+
+### Routes
+
+Every route is composed of a verb, a path (optional) and a block. When an
+incoming request matches a route, the block is executed and a response is sent
+back to the client. The return value of the block will be the `body` of the
+response. The `headers` and `status code` of the response will be calculated by
+`Hobbit::Response`, but you could modify it anyway you want it.
+
+See an example:
+
+```ruby
+class App < Hobbit::Base
+  get '/' do
+    # ...
+  end
+
+  post '/' do
+    # ...
+  end
+
+  put '/' do
+    # ...
+  end
+
+  patch '/' do
+    # ...
+  end
+
+  delete '/' do
+    # ...
+  end
+
+  options '/' do
+    # ...
+  end
+end
+```
+
+When a route gets called you have this methods available:
+
+* `env`: The Rack environment.
+* `request`: a `Hobbit::Request` instance.
+* `response`: a `Hobbit::Response` instance.
+
+And any other method defined in your application.
+
+#### Available methods
+
+* `delete`
+* `get`
+* `head`
+* `options`
+* `patch`
+* `post`
+* `put`
+
+**Note**: Since most browsers don't support methods other than **GET** and
+**POST** you must use the `Rack::MethodOverride` middleware. (See
+[Rack::MethodOverride](https://github.com/rack/rack/blob/master/lib/rack/methodoverride.rb)).
+
+#### Routes with parameters
+
+Besides the standard `GET` and `POST` parameters, you can have routes with
+parameters:
+
+```ruby
+require 'hobbit'
+
+class App < Hobbit::Base
+  # matches both /hi/hobbit and /hi/patricio
+  get '/hi/:name' do
+    # request.params is filled with the route paramters, like this:
+    "Hello #{request.params[:name]}"
+  end
+end
+```
+
+#### Redirecting
+
+If you look at Hobbit implementation, you may notice that there is no
+`redirect` method (or similar). This is because such functionality is provided
+by [Rack::Response](https://github.com/rack/rack/blob/master/lib/rack/response.rb)
+and for now we [don't wan't to repeat ourselves](http://en.wikipedia.org/wiki/Don't_repeat_yourself)
+(obviously you can create an extension!). So, if you want to redirect to
+another route, do it like this:
+
+```ruby
+require 'hobbit'
+
+class App < Hobbit::Base
+  get '/' do
+    response.redirect '/hi'
+  end
+
+  get '/hi' do
+    'Hello World!'
+  end
+end
+```
+
+#### Halting
+
+To immediately stop a request within route you can use `halt`. 
+
+```ruby
+require 'hobbit'
+
+class App < Hobbit::Base
+  use Rack::Session::Cookie, secret: SecureRandom.hex(64)
+
+  def session
+    env['rack.session']
+  end
+
+  get '/' do
+    response.status = 401
+    halt response.finish
+  end
+end
+```
+
+### Built on top of rack
+
+Each Hobbit application is a Rack stack (See this
+[blog post](http://m.onkey.org/ruby-on-rack-2-the-builder) for more
+information).
+
+#### Mapping applications
+
+You can mount any Rack application to the stack by using the `map` class
+method:
+
+```ruby
+require 'hobbit'
+
+class InnerApp < Hobbit::Base
+  # gets called when path_info = '/inner'
+  get do
+    'Hello InnerApp!'
+  end
+end
+
+class App < Hobbit::Base
+  map('/inner') { run InnerApp.new }
+
+  get '/' do
+    'Hello App!'
+  end
+end
+```
+
+#### Using middleware
+
+You can add any Rack middleware to the stack by using the `use` class method:
+
+```ruby
+require 'hobbit'
+
+class App < Hobbit::Base
+  use Rack::Session::Cookie, secret: SecureRandom.hex(64)
+  use Rack::ShowExceptions
+
+  def session
+    env['rack.session']
+  end
+
+  get '/' do
+    session[:name] = 'hobbit'
+  end
+
+  # more routes...
+end
+
+run App.new
+```
+
+### Security
+
+By default, Hobbit (nor Rack) comes without any protection against web
+attacks. The use of [rack-protection](https://github.com/rkh/rack-protection)
+is highly recommended:
+
+```ruby
+require 'hobbit'
+require 'rack/protection'
+require 'securerandom'
+
+class App < Hobbit::Base
+  use Rack::Session::Cookie, secret: SecureRandom.hex(64)
+  use Rack::Protection
+
+  get '/' do
+    'Hello World!'
+  end
+end
+```
+
+See the [rack-protection](https://github.com/rkh/rack-protection)
+documentation for futher information.
+
+### Testing
+
+[rack-test](https://github.com/brynary/rack-test) is highly recommended. See
+an example:
+
+In `app.rb`:
+
+```ruby
+require 'hobbit'
+
+class App < Hobbit::Base
+  get '/' do
+    'Hello World!'
+  end
+end
+```
+
+In `app_spec.rb`:
+
+```ruby
+require 'minitest/autorun'
+# imagine that app.rb and app_spec.rb are stored in the same directory
+require 'app'
+
+describe App do
+  include Rack::Test::Methods
+
+  def app
+    App.new
+  end
+
+  describe 'GET /' do
+    it 'must be ok' do
+      get '/'
+      last_response.must_be :ok?
+      last_response.body.must_match /Hello World!/
+    end
+  end
+end
+```
+
+See the [rack-test](https://github.com/brynary/rack-test) documentation
+for futher information.
+
+### Extensions
+
+You can extend Hobbit by creating standard ruby modules. See an example:
+
+```ruby
+module MyExtension
+  def do_something
+    # do something
+  end
+end
+
+class App < Hobbit::Base
+  include MyExtension
+
+  get '/' do
+    do_something
+    'Hello World!'
+  end
+end
+```
+
+#### Hobbit::Contrib
+
+[hobbit-contrib](https://github.com/patriciomacadden/hobbit-contrib) is a ruby
+gem that comes with a lot of hobbit extensions, such as:
+
+* `Hobbit::Render`: provides basic template rendering.
+* `Hobbit::Session`: provides helper methods for handling user sessions.
+* `Hobbit::Environment`: provides helper methods for handling application
+environments.
+* `Hobbit::Filter`: provides helper class methods for handling Sinatra-like
+filters.
+* `Hobbit::ErrorHandling`: provides helper class methods for handling
+Sinatra-like error handling.
+
+... And many more!
+
+## Community
+
+* [Wiki](https://github.com/patriciomacadden/hobbit/wiki): Guides, how-tos and recipes
+* IRC: [#hobbitrb](irc://chat.freenode.net/#hobbitrb) on [http://freenode.net](http://freenode.net)
+
+## Presentations
+
+* Building web applications in Ruby, by [Krzysztof Wawer](https://github.com/wafcio)
+([english](https://speakerdeck.com/wafcio/hobbit-english), [polish](https://speakerdeck.com/wafcio/hobbit))
+
+## 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
+
+## License
+
+See the [LICENSE](https://github.com/patriciomacadden/hobbit/blob/master/LICENSE).

data/Rakefile

@@ -0,0 +1,4 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new

data/hobby.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'hobby'
+  spec.version       = '0.0.0'
+  spec.authors       = ['Patricio Mac Adden']
+  spec.email         = ['patriciomacadden@gmail.com']
+  spec.description   = %q{A minimalistic microframework built on top of rack}
+  spec.summary       = %q{A minimalistic microframework built on top of rack}
+  spec.homepage      = 'https://github.com/patriciomacadden/hobbit'
+  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_dependency 'include_constants'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'codeclimate-test-reporter'
+  spec.add_development_dependency 'rack-test'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'minitest-power_assert'
+end

data/lib/hobby/app.rb

@@ -0,0 +1,66 @@
+module Hobby
+  class App
+    class << self
+      def members
+        @members ||= {}
+      end
+
+      [:builder, :router].each do |member|
+        define_method member do |&custom_member|
+          if custom_member
+            members[member] = custom_member.call
+          else
+            members[member] ||= Hobby.const_get(member.capitalize).new
+          end
+        end
+      end
+
+      Verbs.each do |verb|
+        define_method verb.downcase do |path, &route|
+          router.add_route verb, path, &route
+        end
+      end
+
+      alias :_new :new
+      def new *args, &block
+        builder.run _new(*args, &block)
+        builder
+      end
+
+      extend Forwardable
+      delegate [:map, :use] => :builder
+    end
+
+    attr_reader :env, :request, :response
+
+    def call env
+      dup.handle env
+    end
+
+    def handle env
+      @env      = env
+      @request  = Request.new @env
+      @response = Response.new
+
+      catch(:halt) { route_eval }
+    end
+
+    private
+
+    def halt response
+      throw :halt, response
+    end
+
+    def route_eval
+      route = self.class.router.route_for request
+
+      if route
+        response.write instance_eval &route
+      else
+        response.status = 404
+      end
+
+      response.finish
+    end
+  end
+end

data/lib/hobby/router/route.rb

@@ -0,0 +1,20 @@
+class Hobby::Router
+  class Route
+    attr_reader :compiled_path, :extra_params, :path
+    def initialize(path, &block)
+      @path  = path
+      @block = block
+
+      @extra_params = []
+      compiled_path = path.gsub(/:\w+/) do |match|
+        @extra_params << match.gsub(':', '').to_sym
+        '([^/?#]+)'
+      end
+      @compiled_path = /^#{compiled_path}$/
+    end
+
+    def to_proc
+      @block
+    end
+  end
+end

data/lib/hobby/router.rb

@@ -0,0 +1,29 @@
+module Hobby
+  class Router
+    require_relative 'router/route'
+
+    def initialize
+      @routes = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def add_route(verb, path, &block)
+      @routes[verb] << Route.new(path, &block)
+      self
+    end
+
+    def route_for(request)
+      route = @routes[request.request_method].detect do |route|
+        route.compiled_path =~ request.path_info
+      end
+
+      if route
+        $~.captures.each_with_index do |value, index|
+          param = route.extra_params[index]
+          request.params[param] = value
+        end
+      end
+
+      route
+    end
+  end
+end

data/lib/hobby.rb

@@ -0,0 +1,10 @@
+require 'rack'
+require 'forwardable'
+require 'include_constants'
+
+module Hobby
+  Verbs = %w!DELETE GET HEAD OPTIONS PATCH POST PUT!
+  require 'hobby/app'
+  autoload :Router, 'hobby/router'
+  include_constants :Builder, :Request, :Response, from: Rack
+end

data/test/helper.rb

@@ -0,0 +1,5 @@
+require 'hobby'
+require 'rack/test'
+
+require 'minitest-power_assert'
+require 'minitest/autorun'

data/test/test_app.rb

@@ -0,0 +1,189 @@
+require_relative 'helper'
+
+module Minitest
+  class Test
+    include Rack::Test::Methods
+
+    def mock_app(&block)
+      @app = Class.new(Hobby::App, &block).new
+    end
+
+    def app
+      @app
+    end
+  end
+end
+
+describe Hobby::App do
+  describe :main_app do
+    before do
+      mock_app do
+        Hobby::Verbs.each do |verb|
+          class_eval "#{verb.downcase}('/') { '#{verb}' }"
+          class_eval "#{verb.downcase}('/route.json') { '#{verb} /route.json' }"
+          class_eval "#{verb.downcase}('/route/:id.json') { request.params[:id] }"
+          class_eval "#{verb.downcase}('/:name') { request.params[:name] }"
+        end
+      end
+    end
+
+    Hobby::Verbs.each do |verb|
+      describe 'when the request matches a route' do
+        it "matches #{verb} ''" do
+          send verb.downcase, ''
+          assert last_response.ok?
+          assert_equal verb, last_response.body
+        end
+
+        it 'matches #{verb} /' do
+          send verb.downcase, '/'
+          assert last_response.ok?
+          assert_equal verb, last_response.body
+        end
+
+        it 'matches #{verb} /route.json' do
+          send verb.downcase, '/route.json'
+          assert last_response.ok?
+          assert_equal "#{verb} /route.json", last_response.body
+        end
+
+        it 'matches #{verb} /route/:id.json' do
+          send verb.downcase, '/route/1.json'
+          assert last_response.ok?
+          assert_equal '1', last_response.body
+        end
+
+        it 'matches #{verb} /:name' do
+          send verb.downcase, '/hobbit'
+          assert last_response.ok?
+          assert_equal 'hobbit', last_response.body
+
+          send verb.downcase, '/hello-hobbit'
+          assert last_response.ok?
+          assert_equal 'hello-hobbit', last_response.body
+        end
+      end
+
+      describe 'when the request not matches a route' do
+        it 'responds with 404 status code' do
+          send verb.downcase, '/not/found'
+          assert last_response.not_found?
+          assert_equal '', last_response.body
+        end
+      end
+    end
+  end
+
+  describe :map_app do
+    before do
+      mock_app do
+        map '/map' do
+          run Proc.new { |env| [200, {}, ['from map']] }
+        end
+
+        get('/') { 'hello world' }
+      end
+    end
+
+    it 'mounts an application to the rack stack' do
+      get '/map'
+      assert_equal 'from map', last_response.body
+    end
+  end
+
+  describe :use_app do
+    before do
+      mock_app do
+        middleware = Class.new do
+          def initialize(app = nil)
+            @app = app
+          end
+
+          def call(env)
+            request = Rack::Request.new(env)
+            @app.call(env) unless request.path_info == '/use'
+            [200, {}, 'from use']
+          end
+        end
+
+        use middleware
+
+        get('/') { 'hello world' }
+      end
+    end
+
+    it 'adds a middleware to the rack stack' do
+      get '/use'
+      assert_equal 'from use', last_response.body
+    end
+  end
+
+  describe :halt_app do
+    before do
+      mock_app do
+        get '/halt' do
+          response.status = 501
+          halt response.finish
+        end
+
+        get '/halt_finished' do
+          halt [404, {}, ['Not found']]
+        end
+      end
+    end
+
+    it 'halts the execution with a response' do
+      get '/halt'
+      assert { last_response.status == 501 }
+    end
+
+    it 'halts the execution with a finished response' do
+      get '/halt_finished'
+      assert { last_response.status == 404 }
+    end
+  end
+
+  describe :router_app do
+    before do
+      mock_app do
+        router do
+          Class.new do
+            def add_route(*)
+            end
+
+            def route_for _request
+              Proc.new { 'for any route' }
+            end
+          end.new
+        end
+      end
+    end
+
+    it 'returns for any route' do
+      get '/'
+      assert { last_response.body == 'for any route' }
+
+      get '/some-other-route'
+      assert { last_response.body == 'for any route' }
+    end
+  end
+
+  describe :custom_members do
+    before do
+      mock_app do
+        builder { Rack::Builder.new }
+        Request = Rack::Request
+        Response = Rack::Response
+
+        get '/' do
+          'it works'
+        end
+      end
+    end
+
+    it 'works' do
+      get '/'
+      assert { last_response.body == 'it works' }
+    end
+  end
+end

data/test/test_router.rb

@@ -0,0 +1,65 @@
+require_relative 'helper'
+
+def request_to path, request_method: 'GET'
+  Hobby::Request.new Rack::MockRequest.env_for "http://example.com:8080/#{path}", method: request_method
+end
+
+describe Hobby::Router do
+  before do
+    @router = Hobby::Router.new
+    @route = -> { :wrapped }
+  end
+
+  it 'works' do
+    @router.add_route 'GET', '/ololo', &@route
+
+    route = @router.route_for request_to 'ololo'
+    assert { route.to_proc.call == :wrapped }
+
+    route = @router.route_for request_to 'ololo2'
+    assert { route.nil? }
+
+    route = @router.route_for request_to 'ololo', request_method: 'POST'
+    assert { route.nil? }
+  end
+
+  it 'with .' do
+    @router.add_route 'GET', '/route.json', &@route
+
+    route = @router.route_for request_to 'route.json'
+    assert { route.to_proc.call == :wrapped }
+  end
+
+  it 'with -' do
+    @router.add_route 'GET', '/hello-world', &@route
+
+    route = @router.route_for request_to 'hello-world'
+    assert { route.to_proc.call == :wrapped }
+  end
+
+  it 'with params' do
+    @router
+      .add_route 'GET', '/hello/:name' do :first end
+      .add_route 'GET', '/say/:something/to/:someone' do :second end
+
+    request = request_to 'hello/ololo'
+    route = @router.route_for request
+    assert { route.to_proc.call == :first }
+    assert { request.params[:name] == 'ololo'}
+
+    request = request_to 'say/nothing/to/no_one'
+    route = @router.route_for request
+    assert { route.to_proc.call == :second }
+    assert { request.params[:something] == 'nothing'}
+    assert { request.params[:someone] == 'no_one'}
+  end
+
+  it 'with . and params' do
+    @router.add_route 'GET', '/route/:id.json', &@route
+
+    request = request_to 'route/42.json'
+    route = @router.route_for request
+    assert { route.to_proc.call == :wrapped }
+    assert { request.params[:id] == '42' }
+  end
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: hobby
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Patricio Mac Adden
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-16 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: include_constants
+  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: codeclimate-test-reporter
+  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: minitest
+  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: minitest-power_assert
+  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: A minimalistic microframework built on top of rack
+email:
+- patriciomacadden@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- hobby.gemspec
+- lib/hobby.rb
+- lib/hobby/app.rb
+- lib/hobby/router.rb
+- lib/hobby/router/route.rb
+- test/helper.rb
+- test/test_app.rb
+- test/test_router.rb
+homepage: https://github.com/patriciomacadden/hobbit
+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.4.5
+signing_key: 
+specification_version: 4
+summary: A minimalistic microframework built on top of rack
+test_files:
+- test/helper.rb
+- test/test_app.rb
+- test/test_router.rb
+has_rdoc: