hobby 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c721c77a7b912fa113e730de3ff58cdf8866e06
-  data.tar.gz: 4590a7005e8597a277cae934955b30b0a981b1b4
+  metadata.gz: 42e7f7a0e7818909ac5d95c50484655aab19fac1
+  data.tar.gz: 7b0f857a9f4ceb6dfdb0eff86d6d546d2b285a6a
 SHA512:
-  metadata.gz: 2bb9aa2ee633d3d06c85a7e41dd1a1b59bb4d870c48de2b351846b7e38566e1f17731bb94894bcec50e917e1fbcfab51d7784d6175ae89db37476918373d3403
-  data.tar.gz: efa3483ccf3ea59cc6e6e16dd4280713eaef4e7a04b1ac1cd66c07e42344cd42efb6a52ddabab7cf4ed2fee032926264fb6f7224f8750e555976309d29665364
+  metadata.gz: d2f3740ca3b95e942af4bf6dc4fb5f8d5acfdd21bd6c48f0544b8f262de0f004856a31547f3739ad440a11195c80a0348e4c4237afb026d4fa566dc6cb138ad2
+  data.tar.gz: fe87a3f5ca1be2c5ee1a346cdeb9e26800c642e4de8251217f8461ba91c8dbb63c7b52ea1a208edb35f6851d27b47e385df4bfb153849065e826fc1b2ace1fed

data/Gemfile

@@ -1,3 +1,10 @@
 source 'https://rubygems.org'
 
+gem 'devtools', github: 'mbj/devtools'
+gem 'minitest'
+gem 'minitest-power_assert'
+gem 'rack-test'
+gem 'pry'
+gem 'awesome_print'
+
 gemspec

data/LICENSE

@@ -1,4 +1,5 @@
 Copyright (c) 2013 Patricio Mac Adden
+Copyright (c) 2015 Anatoly Cherno
 
 MIT License
 

data/hobby.gemspec

@@ -4,12 +4,11 @@ $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.version       = '0.0.1'
+  spec.authors       = ['Anatoly Cherno']
+  spec.email         = ['anatoly.cherno@gmail.com']
+  spec.summary       = %q{A minimal DSL over rack}
+  spec.homepage      = 'https://github.com/ch1c0t/hobby'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files`.split($/)
@@ -18,12 +17,4 @@ Gem::Specification.new do |spec|
   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

@@ -1,66 +1,59 @@
 module Hobby
-  class App
-    class << self
-      def members
-        @members ||= {}
-      end
+  module App
+    def self.included app
+      app.extend Singleton
+      app.builder, app.router = Rack::Builder.new, Router.new
+      app.request, app.response = Rack::Request, Rack::Response
+    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
+    module Singleton
+      attr_accessor :builder, :router, :request, :response
+
+      def new (*)
+        builder.run super
+        builder.to_app
       end
 
+      extend Forwardable
+      delegate [:map, :use] => :builder
+
       Verbs.each do |verb|
-        define_method verb.downcase do |path, &route|
+        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
+    protected
+      def handle env
+        route = self.class.router.route_for (@env = env)
 
-      catch(:halt) { route_eval }
-    end
+        if route
+          response.write instance_exec &route
+        else
+          response.status = 404
+        end
 
-    private
+        response
+      end
 
-    def halt response
-      throw :halt, response
-    end
+    private
+      attr_reader :env
 
-    def route_eval
-      route = self.class.router.route_for request
+      def request
+        @request ||= self.class.request.new env
+      end
 
-      if route
-        response.write instance_eval &route
-      else
-        response.status = 404
+      def response
+        @response ||= self.class.response.new
       end
 
-      response.finish
-    end
+      def my
+        env.fetch :path_params, {}
+      end
   end
 end

data/lib/hobby/router.rb

@@ -1,29 +1,41 @@
 module Hobby
   class Router
-    require_relative 'router/route'
-
     def initialize
-      @routes = Hash.new { |hash, key| hash[key] = [] }
+      @routes = Routes.new
+    end
+
+    def add_route verb, path, &route
+      path = nil if path.eql? '/'
+      @routes["#{verb}#{path}"] = route
     end
 
-    def add_route(verb, path, &block)
-      @routes[verb] << Route.new(path, &block)
-      self
+    def route_for env
+      route, params = @routes["#{env['REQUEST_METHOD']}#{env['PATH_INFO']}"]
+      env[:path_params] = params if params
+      route
     end
 
-    def route_for(request)
-      route = @routes[request.request_method].detect do |route|
-        route.compiled_path =~ request.path_info
+    class Routes < Hash
+      def initialize
+        @patterns = {}
+        super { |hash, key| hash[key] = find key }
       end
 
-      if route
-        $~.captures.each_with_index do |value, index|
-          param = route.extra_params[index]
-          request.params[param] = value
+      def []= key, route
+        if key.include? ?:
+          string = key.gsub(/(:\w+)/) { "(?<#{$1[1..-1]}>[^/?#]+)" }
+          @patterns[/^#{string}$/] = route
+        else
+          super and super "#{key}/", route
         end
       end
 
-      route
+      private
+
+      def find key
+        _, route = @patterns.find { |pattern, _| pattern.match key }
+        [route, $~.names.map(&:to_sym).zip($~.captures).to_h] if route
+      end
     end
   end
 end

data/lib/hobby/rspec/router.rb

@@ -0,0 +1,35 @@
+module Hobby::RSpec
+  module Router
+    extend self
+    SOME_ROUTE = ->{}
+
+    def env_for path, verb = 'GET'
+      {'REQUEST_METHOD' => verb, 'PATH_INFO' => path }
+    end
+
+    def add_routes *routes
+      routes.each { |route| subject.add_route 'GET', route, &SOME_ROUTE }
+    end
+
+    extend RSpec::Matchers::DSL
+    
+    define :find_route do |path, verb = 'GET'|
+      match do |subject|
+        env = env_for path, verb
+        route = subject.route_for env
+
+        params_are_ok = (@params ? (@params.to_a - env[:path_params].to_a).empty? : true)
+
+        (route == SOME_ROUTE) && params_are_ok
+      end
+
+      chain :and_set_params do |**params|
+        @params = params
+      end
+    end
+
+    def self.included example_group
+      example_group.extend self
+    end
+  end
+end

data/lib/hobby.rb

@@ -1,10 +1,9 @@
 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
+
+require 'hobby/router'
+require 'hobby/app'

data/spec/app_spec.rb

@@ -0,0 +1,146 @@
+require 'helper'
+require 'rack/test'
+
+$sources = {}
+
+Dir['spec/apps/*.rb'].each do |file|
+  name = File.basename file, '.rb'
+
+  eval %!
+    class #{name}
+      class << self
+        attr_accessor :app
+      end
+    end
+  !
+
+  $sources[Object.const_get name] = IO.read file
+end
+
+def build_app described_class
+  body = $sources[described_class]
+
+  eval %!
+    Class.new do
+      include Hobby::App
+      #{body}
+    end
+  !
+end
+
+describe Hobby::App do
+  include Rack::Test::Methods
+
+  describe '.new' do
+    context 'an app with nested app(s)' do
+      let(:subject) { build_app(Nested).new }
+      it { should be_a Rack::URLMap }
+    end
+
+    context 'an app without nested app(s)' do
+      let(:subject) { build_app(Main).new }
+      it { should be_a Hobby::App }
+    end
+  end
+
+  describe '#call' do
+    def app
+      build_app(Main).new
+    end
+
+    context 'when a route was found' do
+      it 'evaluates the route' do
+        get '/existent'
+
+        assert { last_response.ok? }
+        assert { last_response.body == 'existent' }
+      end
+    end
+
+    context 'when a route was not found' do
+      it 'responds with 404 status code' do
+        get '/nonexistent/route'
+
+        assert { last_response.not_found? }
+        assert { last_response.body.empty? }
+      end
+    end
+
+    it 'gives a distinct object to each request' do
+      get '/first'
+      assert { last_response.body == 'first' }
+
+      get '/second'
+      assert { last_response.body != 'first' }
+      assert { last_response.body == 'second' }
+    end
+  end
+
+  describe :integration do
+    before do
+      described_class.app = build_app described_class
+    end
+
+    def app
+      described_class.app.new
+    end
+
+    describe Map do
+      it 'mounts an application to the rack stack' do
+        get '/map'
+        assert { last_response.body == 'from map' }
+      end
+    end
+
+    describe Use do
+      it 'adds a middleware to the rack stack' do
+        get '/use'
+        assert { last_response.body == 'from use' }
+      end
+    end
+
+    describe WithoutPath do
+      it 'is accessible as /' do
+        get '/'
+        assert { last_response.body == 'root' }
+      end
+    end
+
+    describe OneRouteRouter do
+      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 Env do
+      it do
+        get '/query_string?1=2&3=4'
+        assert { last_response.body == '1=2&3=4' }
+      end
+
+      it do
+        get '/access_params?key=value'
+        assert { last_response.body == 'value' }
+      end
+
+      it do
+        get '/access_path_params_via_my'
+        assert { last_response.body == 'true' }
+
+        get '/access_path_params_via_env'
+        assert { last_response.body == 'true' }
+      end
+    end
+
+    describe Nested do
+      it do
+        get '/nested'
+        assert { last_response.body == 'a:b:c' }
+      end
+    end
+  end
+end

data/spec/apps/Env.rb

@@ -0,0 +1,15 @@
+get '/query_string' do
+  env['QUERY_STRING']
+end
+
+get '/access_params' do
+  request.params['key']
+end
+
+get '/access_path_params_via_my' do
+  my[:key].nil?
+end
+
+get '/access_path_params_via_env' do
+  env[:path_params].nil?
+end

data/spec/apps/Main.rb

@@ -0,0 +1,4 @@
+Hobby::Verbs.each do |verb|
+  class_eval "#{verb.downcase}('/') { '#{verb}' }"
+  class_eval "#{verb.downcase}('/:name') { my[:name] }"
+end

data/spec/apps/Map.rb

@@ -0,0 +1,5 @@
+map '/map' do
+  run Proc.new { |env| [200, {}, ['from map']] }
+end
+
+get('/') { 'hello world' }

data/spec/apps/Nested.rb

@@ -0,0 +1,17 @@
+map('/nested') do
+  nested_app = Class.new do
+    include Hobby::App
+
+    def initialize first, second
+      @a = first
+      @b = second
+      @c = yield
+    end
+
+    get do
+      "#{@a}:#{@b}:#{@c}"
+    end
+  end
+
+  run nested_app.new(:a, :b) { :c }
+end

data/spec/apps/OneRouteRouter.rb

@@ -0,0 +1,8 @@
+self.router = Class.new {
+  def add_route(*)
+  end
+
+  def route_for _request
+    -> { 'for any route' }
+  end
+}.new

data/spec/apps/Use.rb

@@ -0,0 +1,15 @@
+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' }

data/spec/apps/WithoutPath.rb

@@ -0,0 +1,3 @@
+get do
+  'root'
+end

data/spec/helper.rb

@@ -0,0 +1,21 @@
+require 'devtools/spec_helper'
+
+require 'hobby'
+require 'hobby/rspec/router'
+
+require 'minitest'
+require 'minitest-power_assert'
+Minitest::Assertions.prepend Minitest::PowerAssert::Assertions
+
+if defined? Mutant
+  class Mutant::Selector::Expression
+    def call _subject
+      integration.all_tests
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec, :minitest
+  config.include Hobby::RSpec::Router, type: :router
+end

data/spec/router_group_spec.rb

@@ -0,0 +1,46 @@
+require 'helper'
+
+describe Hobby::RSpec::Router do
+  before do
+    @Group = Class.new do
+      def subject
+        @router ||= Hobby::Router.new
+      end
+    end.include described_class
+  end
+
+  it 'contains a few helpers in its singleton' do
+    [:env_for, :add_routes, :find_route].each do |name|
+      assert { @Group.respond_to? name }
+    end
+  end
+
+  describe 'env_for' do
+    context 'two arguments passed' do
+      it 'returns an environment' do
+        env = { "REQUEST_METHOD" => 'POST', "PATH_INFO" => '/some_path' }
+        assert { env == (@Group.env_for '/some_path', 'POST') }
+      end
+    end
+
+    context 'one argument passed' do
+      it 'defaults to GET' do
+        env = { "REQUEST_METHOD" => 'GET', "PATH_INFO" => '/some_path' }
+        assert { env == (@Group.env_for '/some_path') }
+      end
+    end
+  end
+
+  describe 'add_routes' do
+    it do
+      routes = %w! first second third!
+      group = @Group.new
+
+      group.add_routes *routes
+
+      routes.each do |route|
+        expect(group.subject.route_for group.env_for 'first').to be_truthy
+      end
+    end
+  end
+end

data/spec/router_spec.rb

@@ -0,0 +1,37 @@
+require 'helper'
+
+describe Hobby::Router, type: :router do
+  routes = %w!
+    /with.dot
+    /with-hyphen
+    /hello/:name
+    /say/:something/to/:someone
+    /route/:id.json
+    /existent/only/for/GET
+  !
+
+  before { add_routes *routes }
+
+  it { should find_route '/with.dot' }
+  it { should find_route '/with-hyphen' }
+  it { should find_route '/with.dot/' }
+  it { should find_route '/with-hyphen/' }
+
+  it { should find_route '/existent/only/for/GET' }
+  it { should_not find_route '/nonexistent' }
+  it { should_not find_route '/existent/only/for/GET', 'POST' }
+
+  it { should find_route('/hello/ololo').and_set_params(name: 'ololo') }
+  it { should find_route('/route/66.json').and_set_params(id: '66') }
+  it do
+    should find_route('/say/nothing/to/no_one').
+           and_set_params(something: 'nothing', someone: 'no_one')
+  end
+
+
+  it 'memoizes requests with params' do
+    subject.route_for env_for '/hello/ololo'
+
+    assert { subject.instance_variable_get(:@routes).include? 'GET/hello/ololo' }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hobby
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
-- Patricio Mac Adden
+- Anatoly Cherno
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-16 00:00:00.000000000 Z
+date: 2016-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -24,107 +24,9 @@ dependencies:
     - - ">="
       - !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
+description: 
 email:
-- patriciomacadden@gmail.com
+- anatoly.cherno@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -140,11 +42,19 @@ files:
 - 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
+- lib/hobby/rspec/router.rb
+- spec/app_spec.rb
+- spec/apps/Env.rb
+- spec/apps/Main.rb
+- spec/apps/Map.rb
+- spec/apps/Nested.rb
+- spec/apps/OneRouteRouter.rb
+- spec/apps/Use.rb
+- spec/apps/WithoutPath.rb
+- spec/helper.rb
+- spec/router_group_spec.rb
+- spec/router_spec.rb
+homepage: https://github.com/ch1c0t/hobby
 licenses:
 - MIT
 metadata: {}
@@ -164,12 +74,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: A minimalistic microframework built on top of rack
+summary: A minimal DSL over rack
 test_files:
-- test/helper.rb
-- test/test_app.rb
-- test/test_router.rb
-has_rdoc: 
+- spec/app_spec.rb
+- spec/apps/Env.rb
+- spec/apps/Main.rb
+- spec/apps/Map.rb
+- spec/apps/Nested.rb
+- spec/apps/OneRouteRouter.rb
+- spec/apps/Use.rb
+- spec/apps/WithoutPath.rb
+- spec/helper.rb
+- spec/router_group_spec.rb
+- spec/router_spec.rb

data/lib/hobby/router/route.rb

@@ -1,20 +0,0 @@
-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/test/helper.rb

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

data/test/test_app.rb

@@ -1,189 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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