sinatra-namespace 0.6.1 → 1.0

metadata

@@ -1,118 +1,55 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: sinatra-namespace
-version: !ruby/object:Gem::Version 
-  hash: 5
-  prerelease: false
-  segments: 
-  - 0
-  - 6
-  - 1
-  version: 0.6.1
+version: !ruby/object:Gem::Version
+  version: '1.0'
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Konstantin Haase
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-11-03 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: sinatra
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+date: 2011-10-28 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra-contrib
+  requirement: &2156732360 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 1
-        - 1
-        version: "1.1"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: sinatra-test-helper
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 0
-        - 5
-        - 0
-        version: 0.5.0
-  type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rspec
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 1
-        - 3
-        - 0
-        version: 1.3.0
-  type: :development
-  version_requirements: *id003
-description: Adds namespaces to Sinatra, allows namespaces to have local helpers.
+  version_requirements: *2156732360
+description: ! 'Dummy gem, sinatra-namespace is now part of sinatra-contrib: http://www.sinatrarb.com/contrib/'
 email: konstantin.mailinglists@googlemail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- LICENSE
-- README.md
-- lib/sinatra/namespace.rb
-- sinatra-namespace.gemspec
-- spec/sinatra/namespace_spec.rb
-- spec/spec_helper.rb
-has_rdoc: yard
-homepage: http://github.com/rkh/sinatra-namespace
+files: []
+homepage: http://github.com/sinatra/sinatra-contrib
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Adds namespaces to Sinatra, allows namespaces to have local helpers.
+summary: Dummy gem, sinatra-namespace is now part of sinatra-contrib.
 test_files: []
-

data/LICENSE

@@ -1,27 +0,0 @@
-copyright (c) 2010 Konstantin Haase.  All rights reserved.
-
-Developed by: Konstantin Haase
-              http://github.com/rkh/big_band
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to
-deal with 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:
-  1. Redistributions of source code must retain the above copyright notice,
-     this list of conditions and the following disclaimers.
-  2. Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimers in the
-     documentation and/or other materials provided with the distribution.
-  3. Neither the name of Konstantin Haase, nor the names of other contributors
-     may be used to endorse or promote products derived from this Software without
-     specific prior written permission.
-
-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
-CONTRIBUTORS 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
-WITH THE SOFTWARE.

data/README.md

@@ -1,166 +0,0 @@
-# Sinatra::Namespace
-
-Adds namespaces to [Sinatra](http://sinatrarb.com). Allows namespaces to have local helpers.
-
-## Features
-
-### Nesting by prefix
-
-    require "sinatra"
-    require "sinatra/namespace"
-    
-    namespace '/blog' do
-      get { haml :index }
-    
-      get '/:entry_id' do |id|
-        @entry = Entry.find(id)
-        haml :entry
-      end
-    end
-
-### Nesting by condition
-
-    require "sinatra"
-    require "sinatra/namespace"
-    
-    namespace :host_name => "www.example.com" do
-      # ...
-    end
-    
-    namespace :host_name => "api.example.com" do
-      # ...
-    end
-
-### Local helpers, filters and error handling
-
-    require "sinatra"
-    require "sinatra/namespace"
-    
-    helpers do
-      def title
-        "foo bar"
-      end
-      
-      def posts
-        Post.all
-      end
-    end
-    
-    get "/" do
-      haml :index
-    end
-    
-    namspace "/ruby" do
-      before { @an_important_note = "filters work, too" }
-      
-      after do
-        @an_important_note = nil # don't tell
-      end
-      
-      not_found do
-        "ruby does not know this ditty"
-      end
-      
-      helpers do
-        def posts
-          super.where :topic => "ruby"
-        end
-      end
-      
-      get { haml :index }
-      
-      get "/new" do
-        haml :new, {}, :object => Post.new(:topic => "ruby")
-      end
-    end
-
-### With modules
-
-Modular style (you can of course use the `namespace` method there, too):
-
-    require "sinatra/base"
-    require "sinatra/namespace"
-    
-    class Application < Sinatra::Base
-      def title
-        "foo bar"
-      end
-      
-      def posts
-        Post.all
-      end
-      
-      module RubyPosts
-        # If you would have called that module Ruby, you would not have to set
-        # your prefix by hand, ain't that cool, huh?
-        prefix "/ruby"
-        
-        def posts
-          super.where :topic => "ruby"
-        end
-        
-        get { haml :index }
-
-        get "/new" do
-          haml :new, {}, :object => Post.new(:topic => "ruby")
-        end
-      end
-    end
-
-Wait, did that module turn into a namespace all by itself? No, actually it got turned into one by `Application` when it
-tried to call `prefix`, which is not defined.
-
-You can influence that behavior by setting `auto_namespace`:
-
-    class Application < Sinatra::Base
-      # enables auto namespacing, is default
-      enable :auto_namespace
-      
-      # disables auto namespacing
-      disable :auto_namespace
-      
-      # triggers auto namespaceing only on prefix and get
-      set :auto_namespace, :only => [:prefix, :get]
-      
-      # triggers auto namespacing on all public methods of Sinatra::Namspace::NestedMethods except prefix
-      set :auto_namespace, :except => :prefix
-    end
-
-So, how does one create a namespace from a module without that auto detection? Simple:
-
-    Application.make_namespace SomeModule, :prefix => "/somewhere"
-
-
-Installation
-------------
-
-    gem install sinatra-namespace
-
-Alternatives
-------------
-
-Sinatra::Namespace is made for sharing some state/helpers.
-If that is no what you are looking for, you have two alternative directions.
-
-Simple prefixing, shares all state/helpers:
-
-    require "sinatra/base"
-    
-    admin_prefix = "/this/is/the/admin/prefix"
-    get(admin_prefix) { haml :admin_index }
-    get("#{admin_prefix}/new_user") { haml :new_user }
-    get("#{admin_prefix}/admin_stuff") { haml :admin_stuff }
-
-Middleware, shares no state/helpers:
-
-    require "sinatra/base"
-    
-    class Application < Sinatra::Base
-      class AdminNamespace < Sinatra::Base
-        get("admin/prefix") { haml :admin_index }
-        get("admin/new_user") { haml :new_user }
-        get("admin/admin_stuff") { haml :admin_stuff }
-      end
-      
-      use AdminNamespace
-    end

data/lib/sinatra/namespace.rb

@@ -1,157 +0,0 @@
-require 'sinatra/base'
-
-module Sinatra
-  module Namespace
-    module NestedMethods
-      DONT_FORWARD = %w[call configure disable enable new register reset! run! set use template layout]
-      attr_reader :prefix, :options, :base
-
-      def get(name = nil, options = {}, &block)     prefixed(:get,    name, options, &block) end
-      def put(name = nil, options = {}, &block)     prefixed(:put,    name, options, &block) end
-      def post(name = nil, options = {}, &block)    prefixed(:post,   name, options, &block) end
-      def delete(name = nil, options = {}, &block)  prefixed(:delete, name, options, &block) end
-      def head(name = nil, options = {}, &block)    prefixed(:head,   name, options, &block) end
-      def before(name = "*", &block)                prefixed(:before, name,          &block) end
-      def after(name = "*", &block)                 prefixed(:after,  name,          &block) end
-
-      def helpers(*list, &block)
-        include(*list) unless list.empty?
-        class_eval(&block) if block
-      end
-
-      def settings
-        return base if base.is_a? Class
-        base.settings
-      end
-
-      def respond_to?(*args)
-        return true if super
-        base.respond_to?(*args) and forward(args.first)
-      end
-
-      def errors
-        @errors ||= {}
-      end
-
-      def not_found(&block)
-        error(404, &block)
-      end
-
-      def error(codes = Exception, &block)
-        [*codes].each { |c| errors[c] = block }
-      end
-
-      private
-
-      def prefixed_path(name)
-        if prefix.is_a? Regexp or name.is_a? Regexp
-          path = /#{prefix}#{name}/
-          path = /^#{path}$/ if base.is_a? Class
-          path
-        else
-          prefix.to_s + name.to_s
-        end
-      end
-
-      def prefixed(method, name, *args, &block)
-        if name.respond_to? :key?
-          args.unshift name
-          name = nil
-        end
-        options.each { |o, a| settings.send(o, *a ) }
-        base.send(method, prefixed_path(name), *args, &block)
-      end
-
-      def forward?(name)
-        not DONT_FORWARD.include? name.to_s
-      end
-
-      def method_missing(name, *args, &block)
-        return super unless base.respond_to? name and forward? name
-        base.send(name, *args, &block)
-      end
-    end
-
-    module ClassMethods
-      def namespace(prefix = nil, options = {}, &block)
-        Namespace.setup(self, prefix, options, Module.new, &block)
-      end
-
-      def make_namespace(mod, options = {})
-        options[:base] ||= self
-        Namespace.make_namespace(mod, options)
-      end
-
-      def make_namespace?(klass, meth)
-        return false if !auto_namespace? or klass.is_a? NestedMethods
-        meths = NestedMethods.instance_methods.map { |m| m.to_s }
-        if auto_namespace != true
-          meths = [auto_namespace[:only]].flatten.map { |m| m.to_s } if auto_namespace.include? :only
-          [auto_namespace[:except]].flatten.each { |m| meths.delete m.to_s } if auto_namespace.include? :except
-        end
-        meths.include? meth.to_s
-      end
-    end
-
-    module ModularMethods
-      def setup(base, prefix = nil, options = {}, mixin = nil, &block)
-        prefix, options = nil, prefix if options.empty? and prefix.respond_to? :key?
-        prefix ||= ""
-        mixin  ||= self
-        mixin.class_eval { @prefix, @options, @base = prefix, options, base }
-        mixin.extend ClassMethods, NestedMethods
-        mixin.send(:define_method, :error_block!) do |*keys|
-          if block = keys.inject(nil) { |b,k| b ||= mixin.errors[k] }
-            instance_eval(&block)
-          else
-            super(*keys)
-          end
-        end
-        mixin.before { extend mixin }
-        mixin.class_eval(&block) if block
-        mixin
-      end
-    end
-
-    module NamespaceDetector
-      Module.send(:include, self)
-      def method_missing(meth, *args, &block)
-        return super if is_a? Class or !name
-        base = Object
-        detected = name.split('::').any? do |name|
-          base = base.const_get(name)
-          base < Sinatra::Base
-        end
-        if detected and base.make_namespace?(self, meth)
-          Sinatra::Namespace.make_namespace self, :base => base
-          send(meth, *args, &block)
-        else
-          super
-        end
-      end
-    end
-
-    extend ModularMethods
-
-    def self.make_namespace(mod, options = {})
-      from = caller[0] =~ /make_namespace/ ? caller[1] : caller[0]
-      base = options.delete(:base) || options.delete(:for)
-      options[:prefix] ||= '/' << mod.name.gsub(/^#{base.name}::/, '').
-        gsub(/::/, '/').gsub(/([a-z\d]+)([A-Z][a-z])/,'\1_\2').downcase
-      setup base, options.delete(:prefix), options, mod
-    end
-
-    def self.included(klass)
-      klass.extend ModularMethods
-      super
-    end
-
-    def self.registered(klass)
-      klass.extend ClassMethods
-      klass.enable :auto_namespace
-    end
-  end
-
-  Delegator.delegate :namespace
-  register Namespace
-end

data/sinatra-namespace.gemspec

@@ -1,20 +0,0 @@
-Gem::Specification.new do |s|
-  # Get the facts.
-  s.name             = "sinatra-namespace"
-  s.version          = "0.6.1"
-  s.description      = "Adds namespaces to Sinatra, allows namespaces to have local helpers."
-
-  # Dependencies
-  s.add_dependency "sinatra", "~> 1.1"
-  s.add_development_dependency "sinatra-test-helper", "~> 0.5.0"
-  s.add_development_dependency "rspec", "~> 1.3.0"
-
-  # Those should be about the same in any BigBand extension.
-  s.authors          = ["Konstantin Haase"]
-  s.email            = "konstantin.mailinglists@googlemail.com"
-  s.files            = `git ls-files`.split("\n")
-  s.has_rdoc         = 'yard'
-  s.homepage         = "http://github.com/rkh/#{s.name}"
-  s.require_paths    = ["lib"]
-  s.summary          = s.description
-end

data/spec/sinatra/namespace_spec.rb

@@ -1,300 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-describe Sinatra::Namespace do
-  it_should_behave_like 'sinatra'
-
-  it "should delegate namespace" do
-    Sinatra::Delegator.private_instance_methods.map(&:to_s).should include("namespace")
-  end
-
-  [:get, :head, :post, :put, :delete].each do |verb|
-    describe "HTTP #{verb.to_s.upcase}" do
-      before :each do
-        Object.send :remove_const, :App if Object.const_defined? :App
-        class ::App < Sinatra::Base
-          register Sinatra::Namespace
-        end
-        app App
-      end
-
-      describe :namespace do
-        it "should add routes including prefix to the base app" do
-          app.namespace "/foo" do
-            send(verb, "/bar") { "baz" }
-          end
-          browse_route(verb, "/foo/bar").should be_ok
-          browse_route(verb, "/foo/bar").body.should == "baz" unless verb == :head
-        end
-
-        it "should allows adding routes with no path" do
-          app.namespace "/foo" do
-            send(verb) { "bar" }
-          end
-          browse_route(verb, "/foo").should be_ok
-          browse_route(verb, "/foo").body.should == "bar" unless verb == :head
-        end
-
-        it "allows nesting" do
-          app.namespace "/foo" do
-            namespace "/bar" do
-              namespace "/baz" do
-                send(verb) { 'foobarbaz' }
-              end
-            end
-          end
-          browse_route(verb, "/foo/bar/baz").should be_ok
-          browse_route(verb, "/foo/bar/baz").body.should == "foobarbaz" unless verb == :head
-        end
-
-        it "allows regular expressions" do
-          app.namespace %r{/\d\d} do
-            send(verb) { "foo" }
-            namespace %r{/\d\d} do
-              send(verb) { "bar" }
-            end
-            namespace "/0000" do
-              send(verb) { "baz" }
-            end
-          end
-          browse_route(verb, '/20').should be_ok
-          browse_route(verb, '/20').body.should == "foo" unless verb == :head
-          browse_route(verb, '/20/20').should be_ok
-          browse_route(verb, '/20/20').body.should == "bar" unless verb == :head
-          browse_route(verb, '/20/0000').should be_ok
-          browse_route(verb, '/20/0000').body.should == "baz" unless verb == :head
-          browse_route(verb, '/20/200').should_not be_ok
-        end
-      end
-
-      describe :filters do
-        it 'should trigger before filters for namespaces' do
-          app.before { settings.set :foo, 0 }
-          app.namespace('/foo') do
-            before { settings.set :foo, settings.foo + 1 }
-            send(verb) { }
-          end
-          browse_route(verb, '/foo').should be_ok
-          app.foo.should == 1
-        end
-        it 'should trigger after filters for namespaces' do
-          $foo = 0
-          app.after { $foo += 2 }
-          app.namespace('/foo') do
-            after { $foo += 1 }
-            send(verb) { }
-          end
-          browse_route(verb, '/foo').should be_ok
-          $foo.should == 3
-        end
-      end
-
-      describe :make_namespace do
-        it "extends modules make_namespace is called on" do
-          mod = Module.new
-          mod.should_not respond_to(verb)
-          app.make_namespace(mod, :prefix => "/foo")
-          mod.should respond_to(verb)
-        end
-
-        it "returns the module" do
-          mod = Module.new
-          app.make_namespace(mod, :prefix => "/foo").should == mod
-        end
-
-        it "sets base" do
-          app.make_namespace(Module.new, :prefix => "/foo").base.should == app
-        end
-
-        it "sets prefix" do
-          app.make_namespace(Module.new, :prefix => "/foo").prefix.should == "/foo"
-        end
-
-        it "automatically sets a prefix based on module name if none is given" do
-          # FooBar = Module.new  <= does not work in Ruby 1.9
-          module ::FooBar; end
-          app.make_namespace ::FooBar
-          ::FooBar.prefix.should == "/foo_bar"
-        end
-
-        it "does not add the application name to auto-generated prefixes" do
-          #App::FooBar = Module.new <= does not work in Ruby 1.9
-          class ::App < Sinatra::Base; module FooBar; end; end
-          app.make_namespace App::FooBar
-          App::FooBar.prefix.should == "/foo_bar"
-        end
-      end
-
-      describe :auto_namespace do
-        before do
-          class ::App < Sinatra::Base; module Foo; end; end
-        end
-
-        it "detects #{verb}" do
-          App::Foo.should_not respond_to(verb)
-          App::Foo.send(verb, "/bar") { "baz" }
-          App::Foo.should respond_to(verb)
-          browse_route(verb, "/foo/bar").should be_ok
-          browse_route(verb, "/foo/bar").body.should == "baz" unless verb == :head
-        end
-
-        it "ignores #{verb} if auto namespaceing is disabled" do
-          app.disable :auto_namespace
-          App::Foo.should_not respond_to(verb)
-          proc { App::Foo.send(verb, "/bar") { "baz" } }.should raise_error(NameError)
-          App::Foo.should_not respond_to(verb)
-        end
-
-        it "ignores #{verb} if told to via :except" do
-          app.set :auto_namespace, :except => verb
-          App::Foo.should_not respond_to(verb)
-          proc { App::Foo.send(verb, "/bar") { "baz" } }.should raise_error(NameError)
-          App::Foo.should_not respond_to(verb)
-        end
-
-        it "does not ignore #{verb} if not included in :except" do
-          app.set :auto_namespace, :except => ["prefix"]
-          App::Foo.should_not respond_to(verb)
-          App::Foo.send(verb, "/bar") { "baz" }
-          App::Foo.should respond_to(verb)
-        end
-
-        it "does ignore #{verb} if not included in :only" do
-          app.set :auto_namespace, :only => "prefix"
-          App::Foo.should_not respond_to(verb)
-          proc { App::Foo.send(verb, "/bar") { "baz" } }.should raise_error(NameError)
-          App::Foo.should_not respond_to(verb)
-        end
-
-        it "does not ignore #{verb} if included in :only" do
-          app.set :auto_namespace, :only => ["prefix", verb]
-          App::Foo.should_not respond_to(verb)
-          App::Foo.send(verb, "/bar") { "baz" }
-          App::Foo.should respond_to(verb)
-        end
-
-        it "detects prefix" do
-          App::Foo.should_not respond_to(:prefix)
-          App::Foo.prefix.should == "/foo"
-        end
-      end
-
-      describe :helpers do
-        it "makes helpers defined inside a namespace not available to routes outside that namespace" do
-          helpers { define_method(:foo) { 42 } }
-          app.namespace("/foo").helpers { define_method(:bar) { 42 } }
-          app.new.should respond_to(:foo)
-          app.new.should_not respond_to(:bar)
-        end
-
-        it "allows overwriting helpers for routes within a namespace" do
-          helpers { define_method(:foo) { "foo" } }
-          define_route(verb, "/foo") { foo }
-          app.namespace("/bar") do
-            define_method(:foo) { "bar" }
-            send(verb, "/foo") { foo }
-          end
-          browse_route(verb, "/foo").should be_ok
-          browse_route(verb, "/bar/foo").should be_ok
-          unless verb == :head
-            browse_route(verb, "/foo").body.should == "foo"
-            browse_route(verb, "/bar/foo").body.should == "bar"
-          end
-        end
-
-        it "allows accessing helpers defined outside the namespace" do
-          helpers { define_method(:foo) { "foo" } }
-          app.namespace("/foo").send(verb, "") { foo }
-          browse_route(verb, "/foo").should be_ok
-          browse_route(verb, "/foo").body.should == "foo" unless verb == :head
-        end
-
-        it "allows calling super in helpers overwritten inside a namespace" do
-          helpers { define_method(:foo) { "foo" } }
-          app.namespace("/foo") do
-            define_method(:foo) { super().upcase }
-            send(verb) { foo }
-          end
-          browse_route(verb, "/foo").should be_ok
-          browse_route(verb, "/foo").body.should == "FOO" unless verb == :head
-        end
-      end
-
-    end
-  end
-
-  describe :errors do
-    it "should allow custom error handlers with not found" do
-      app.namespace('/de') do
-        not_found { 'nicht gefunden' }
-      end
-      get('/foo').status.should     == 404
-      last_response.body.should_not == 'nicht gefunden'
-      get('/en/foo').status.should  == 404
-      last_response.body.should_not == 'nicht gefunden'
-      get('/de/foo').status.should  == 404
-      last_response.body.should     == 'nicht gefunden'
-    end
-
-    it "should allow custom error handlers with error" do
-      app.namespace('/de') do
-        error(404) { 'nicht gefunden' }
-      end
-      get('/foo').status.should     == 404
-      last_response.body.should_not == 'nicht gefunden'
-      get('/en/foo').status.should  == 404
-      last_response.body.should_not == 'nicht gefunden'
-      get('/de/foo').status.should  == 404
-      last_response.body.should     == 'nicht gefunden'
-    end
-  end
-
-  describe 'conditions' do
-    it 'allows using conditions' do
-      app.namespace(:host_name => 'example.com') do
-        get('/') { 'yes' }
-      end
-      app.get('/') { 'no' }
-      get('/', {}, { 'HTTP_HOST' => 'example.com' })
-      last_response.body.should == 'yes'
-      get('/', {}, { 'HTTP_HOST' => 'example.org' })
-      last_response.body.should == 'no'
-    end
-
-    it 'allows combining conditions with a prefix' do
-      app.namespace('/foo', :host_name => 'example.com') do
-        get { 'yes' }
-      end
-      app.get('/foo') { 'no' }
-      get('/foo', {}, { 'HTTP_HOST' => 'example.com' })
-      last_response.body.should == 'yes'
-      get('/foo', {}, { 'HTTP_HOST' => 'example.org' })
-      last_response.body.should == 'no'
-    end
-  end
-
-  describe 'memory' do
-    before do
-      app.namespace('/foo') { get('/bar') { 'blah' }}
-    end
-
-    def measure
-      100.times { get('/foo/bar') }
-      GC.start
-      # ObjectSpace.each_object.to_a.size
-      sum = 0
-      ObjectSpace.each_object { sum += 1 }
-      sum
-    end
-
-    it 'should not leak objects' do
-      if Monkey::Engine.mri?
-        measure
-        2.times do
-          first   = measure
-          second  = measure
-          second.should <= first + 3
-        end
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,3 +0,0 @@
-require "sinatra/rspec/shared"
-require "sinatra/namespace"
-require "monkey/engine"