sinatra-contrib 2.0.0.rc1 → 2.0.0.rc2

data/spec/content_for/different_key.erb

@@ -1 +0,0 @@
-<% content_for :bar do %>bar<% end %>

data/spec/content_for/different_key.erubis

@@ -1 +0,0 @@
-<% content_for :bar do %>bar<% end %>

data/spec/content_for/different_key.haml

@@ -1,2 +0,0 @@
-- content_for :bar do
-  bar

data/spec/content_for/different_key.slim

@@ -1,2 +0,0 @@
-- content_for :bar do
-  | bar

data/spec/content_for/footer.erb

@@ -1,3 +0,0 @@
-<% if content_for? :foo %>
-  <%= yield_content :foo %>
-<% end %>

data/spec/content_for/footer.erubis

@@ -1,3 +0,0 @@
-<% if content_for? :foo %>
-  <%= yield_content :foo %>
-<% end %>

data/spec/content_for/footer.haml

@@ -1,2 +0,0 @@
-- if content_for? :foo
-  = yield_content :foo

data/spec/content_for/footer.slim

@@ -1,2 +0,0 @@
-- if content_for? :foo
-  = yield_content :foo

data/spec/content_for/layout.erb

@@ -1 +0,0 @@
-<%= yield_content :foo %>

data/spec/content_for/layout.erubis

@@ -1 +0,0 @@
-<%= yield_content :foo %>

data/spec/content_for/layout.haml

@@ -1 +0,0 @@
-= yield_content :foo

data/spec/content_for/layout.slim

@@ -1 +0,0 @@
-= yield_content :foo

data/spec/content_for/multiple_blocks.erb

@@ -1,4 +0,0 @@
-<% content_for :foo do %>foo<% end %>
-<% content_for :foo do %>bar<% end %>
-<% content_for :baz do %>WON'T RENDER ME<% end %>
-<% content_for :foo do %>baz<% end %>

data/spec/content_for/multiple_blocks.erubis

@@ -1,4 +0,0 @@
-<% content_for :foo do %>foo<% end %>
-<% content_for :foo do %>bar<% end %>
-<% content_for :baz do %>WON'T RENDER ME<% end %>
-<% content_for :foo do %>baz<% end %>

data/spec/content_for/multiple_blocks.haml

@@ -1,8 +0,0 @@
-- content_for :foo do
-  foo
-- content_for :foo do
-  bar
-- content_for :baz do
-  WON'T RENDER ME
-- content_for :foo do
-  baz

data/spec/content_for/multiple_blocks.slim

@@ -1,8 +0,0 @@
-- content_for :foo do
-  | foo
-- content_for :foo do
-  | bar
-- content_for :baz do
-  | WON'T RENDER ME
-- content_for :foo do
-  | baz

data/spec/content_for/multiple_yields.erb

@@ -1,3 +0,0 @@
-<%= yield_content :foo %>
-<%= yield_content :foo %>
-<%= yield_content :foo %>

data/spec/content_for/multiple_yields.erubis

@@ -1,3 +0,0 @@
-<%= yield_content :foo %>
-<%= yield_content :foo %>
-<%= yield_content :foo %>

data/spec/content_for/multiple_yields.haml

@@ -1,3 +0,0 @@
-= yield_content :foo
-= yield_content :foo
-= yield_content :foo

data/spec/content_for/multiple_yields.slim

@@ -1,3 +0,0 @@
-= yield_content :foo
-= yield_content :foo
-= yield_content :foo

data/spec/content_for/passes_values.erb

@@ -1 +0,0 @@
-<%= yield_content :foo, 1, 2 %>

data/spec/content_for/passes_values.erubis

@@ -1 +0,0 @@
-<%= yield_content :foo, 1, 2 %>

data/spec/content_for/passes_values.haml

@@ -1 +0,0 @@
-= yield_content :foo, 1, 2

data/spec/content_for/passes_values.slim

@@ -1 +0,0 @@
-== yield_content :foo, 1, 2

data/spec/content_for/same_key.erb

@@ -1 +0,0 @@
-<% content_for :foo do %>foo<% end %>

data/spec/content_for/same_key.erubis

@@ -1 +0,0 @@
-<% content_for :foo do %>foo<% end %>

data/spec/content_for/same_key.haml

@@ -1,2 +0,0 @@
-- content_for :foo do
-  foo

data/spec/content_for/same_key.slim

@@ -1,2 +0,0 @@
-- content_for :foo do
-  | foo

data/spec/content_for/takes_values.erb

@@ -1 +0,0 @@
-<% content_for :foo do |a, b| %><i><%= a %></i> <%= b %><% end %>

data/spec/content_for/takes_values.erubis

@@ -1 +0,0 @@
-<% content_for :foo do |a, b| %><i><%= a %></i> <%= b %><% end %>

data/spec/content_for/takes_values.haml

@@ -1,3 +0,0 @@
-- content_for :foo do |a, b|
-  %i= a
-  =b

data/spec/content_for/takes_values.slim

@@ -1,3 +0,0 @@
-- content_for :foo do |a, b|
-  i= a
-  = b

data/spec/content_for_spec.rb

@@ -1,241 +0,0 @@
-require 'spec_helper'
-
-describe Sinatra::ContentFor do
-  subject do
-    Sinatra.new do
-      helpers Sinatra::ContentFor
-      set :views, File.expand_path("../content_for", __FILE__)
-    end.new!
-  end
-
-  Tilt.prefer Tilt::ERBTemplate
-
-  extend Forwardable
-  def_delegators :subject, :content_for, :clear_content_for, :yield_content
-  def render(engine, template)
-    subject.send(:render, engine, template, :layout => false).gsub(/\s/, '')
-  end
-
-  describe "without templates" do
-    it 'renders blocks declared with the same key you use when rendering' do
-      content_for(:foo) { "foo" }
-      expect(yield_content(:foo)).to eq("foo")
-    end
-
-    it 'renders blocks more than once' do
-      content_for(:foo) { "foo" }
-      3.times { expect(yield_content(:foo)).to eq("foo") }
-    end
-
-    it 'does not render a block with a different key' do
-      content_for(:bar) { "bar" }
-      expect(yield_content(:foo)).to be_empty
-    end
-
-    it 'renders default content if no block matches the key and a default block is specified' do
-      content_for(:bar) { "bar" }
-      expect(yield_content(:foo) { "foo" }).to eq("foo")
-    end
-
-    it 'renders multiple blocks with the same key' do
-      content_for(:foo) { "foo" }
-      content_for(:foo) { "bar" }
-      content_for(:bar) { "WON'T RENDER ME" }
-      content_for(:foo) { "baz" }
-      expect(yield_content(:foo)).to eq("foobarbaz")
-    end
-
-    it 'renders multiple blocks more than once' do
-      content_for(:foo) { "foo" }
-      content_for(:foo) { "bar" }
-      content_for(:bar) { "WON'T RENDER ME" }
-      content_for(:foo) { "baz" }
-      3.times { expect(yield_content(:foo)).to eq("foobarbaz") }
-    end
-
-    it 'passes values to the blocks' do
-      content_for(:foo) { |a| a.upcase }
-      expect(yield_content(:foo, 'a')).to eq("A")
-      expect(yield_content(:foo, 'b')).to eq("B")
-    end
-
-    it 'clears named blocks with the specified key' do
-      content_for(:foo) { "foo" }
-      expect(yield_content(:foo)).to eq("foo")
-      clear_content_for(:foo)
-      expect(yield_content(:foo)).to be_empty
-    end
-
-    it 'takes an immediate value instead of a block' do
-      content_for(:foo, "foo")
-      expect(yield_content(:foo)).to eq("foo")
-    end
-  end
-
-  # TODO: liquid radius markaby builder nokogiri
-  engines = %w[erb erubis haml slim]
-
-  engines.each do |inner|
-    describe inner.capitalize do
-      before :all do
-        begin
-          require inner
-        rescue LoadError => e
-          skip "Skipping: " << e.message
-        end
-      end
-
-      describe "with yield_content in Ruby" do
-        it 'renders blocks declared with the same key you use when rendering' do
-          render inner, :same_key
-          expect(yield_content(:foo).strip).to eq("foo")
-        end
-
-        it 'renders blocks more than once' do
-          render inner, :same_key
-          3.times { expect(yield_content(:foo).strip).to eq("foo") }
-        end
-
-        it 'does not render a block with a different key' do
-          render inner, :different_key
-          expect(yield_content(:foo)).to be_empty
-        end
-
-        it 'renders default content if no block matches the key and a default block is specified' do
-          render inner, :different_key
-          expect(yield_content(:foo) { "foo" }).to eq("foo")
-        end
-
-        it 'renders multiple blocks with the same key' do
-          render inner, :multiple_blocks
-          expect(yield_content(:foo).gsub(/\s/, '')).to eq("foobarbaz")
-        end
-
-        it 'renders multiple blocks more than once' do
-          render inner, :multiple_blocks
-          3.times { expect(yield_content(:foo).gsub(/\s/, '')).to eq("foobarbaz") }
-        end
-
-        it 'passes values to the blocks' do
-          render inner, :takes_values
-          expect(yield_content(:foo, 1, 2).gsub(/\s/, '')).to eq("<i>1</i>2")
-        end
-      end
-
-      describe "with content_for in Ruby" do
-        it 'renders blocks declared with the same key you use when rendering' do
-          content_for(:foo) { "foo" }
-          expect(render(inner, :layout)).to eq("foo")
-        end
-
-        it 'renders blocks more than once' do
-          content_for(:foo) { "foo" }
-          expect(render(inner, :multiple_yields)).to eq("foofoofoo")
-        end
-
-        it 'does not render a block with a different key' do
-          content_for(:bar) { "foo" }
-          expect(render(inner, :layout)).to be_empty
-        end
-
-        it 'renders multiple blocks with the same key' do
-          content_for(:foo) { "foo" }
-          content_for(:foo) { "bar" }
-          content_for(:bar) { "WON'T RENDER ME" }
-          content_for(:foo) { "baz" }
-          expect(render(inner, :layout)).to eq("foobarbaz")
-        end
-
-        it 'renders multiple blocks more than once' do
-          content_for(:foo) { "foo" }
-          content_for(:foo) { "bar" }
-          content_for(:bar) { "WON'T RENDER ME" }
-          content_for(:foo) { "baz" }
-          expect(render(inner, :multiple_yields)).to eq("foobarbazfoobarbazfoobarbaz")
-        end
-
-        it 'passes values to the blocks' do
-          content_for(:foo) { |a,b| "<i>#{a}</i>#{b}" }
-          expect(render(inner, :passes_values)).to eq("<i>1</i>2")
-        end
-
-        it 'clears named blocks with the specified key' do
-          content_for(:foo) { "foo" }
-          expect(render(inner, :layout)).to eq("foo")
-          clear_content_for(:foo)
-          expect(render(inner, :layout)).to be_empty
-        end
-      end
-
-      describe "with content_for? in Ruby" do
-        it 'renders block if key is set' do
-          content_for(:foo) { "foot" }
-          expect(render(inner, :footer)).to eq("foot")
-        end
-
-        it 'does not render a block if different key' do
-          content_for(:different_key) { "foot" }
-          expect(render(inner, :footer)).to be_empty
-        end
-      end
-
-      engines.each do |outer|
-        describe "with yield_content in #{outer.capitalize}" do
-          def body
-            last_response.body.gsub(/\s/, '')
-          end
-
-          before :all do
-            begin
-              require outer
-            rescue LoadError => e
-              skip "Skipping: " << e.message
-            end
-          end
-
-          before do
-            mock_app do
-              helpers Sinatra::ContentFor
-              set inner, :layout_engine => outer
-              set :views, File.expand_path("../content_for", __FILE__)
-              get('/:view') { render(inner, params[:view].to_sym) }
-              get('/:layout/:view') do
-                render inner, params[:view].to_sym, :layout => params[:layout].to_sym
-              end
-            end
-          end
-
-          it 'renders blocks declared with the same key you use when rendering' do
-            expect(get('/same_key')).to be_ok
-            expect(body).to eq("foo")
-          end
-
-          it 'renders blocks more than once' do
-            expect(get('/multiple_yields/same_key')).to be_ok
-            expect(body).to eq("foofoofoo")
-          end
-
-          it 'does not render a block with a different key' do
-            expect(get('/different_key')).to be_ok
-            expect(body).to be_empty
-          end
-
-          it 'renders multiple blocks with the same key' do
-            expect(get('/multiple_blocks')).to be_ok
-            expect(body).to eq("foobarbaz")
-          end
-
-          it 'renders multiple blocks more than once' do
-            expect(get('/multiple_yields/multiple_blocks')).to be_ok
-            expect(body).to eq("foobarbazfoobarbazfoobarbaz")
-          end
-
-          it 'passes values to the blocks' do
-            expect(get('/passes_values/takes_values')).to be_ok
-            expect(body).to eq("<i>1</i>2")
-          end
-        end
-      end
-    end
-  end
-end

data/spec/cookies_spec.rb

@@ -1,826 +0,0 @@
-require 'spec_helper'
-
-describe Sinatra::Cookies do
-  def cookie_route(*cookies, &block)
-    result = nil
-    set_cookie(cookies)
-    @cookie_app.get('/') do
-      result = instance_eval(&block)
-      "ok"
-    end
-    get '/', {}, @headers || {}
-    expect(last_response).to be_ok
-    expect(body).to eq("ok")
-    result
-  end
-
-  def cookies(*set_cookies)
-    cookie_route(*set_cookies) { cookies }
-  end
-
-  before do
-    app = nil
-    mock_app do
-      helpers Sinatra::Cookies
-      app = self
-    end
-    @cookie_app = app
-    clear_cookies
-  end
-
-  describe :cookie_route do
-    it 'runs the block' do
-      ran = false
-      cookie_route { ran = true }
-      expect(ran).to be true
-    end
-
-    it 'returns the block result' do
-      expect(cookie_route { 42 }).to eq(42)
-    end
-  end
-
-  describe :== do
-    it 'is comparable to hashes' do
-      expect(cookies).to eq({})
-    end
-
-    it 'is comparable to anything that responds to to_hash' do
-      other = Struct.new(:to_hash).new({})
-      expect(cookies).to eq(other)
-    end
-  end
-
-  describe :[] do
-    it 'allows access to request cookies' do
-      expect(cookies("foo=bar")["foo"]).to eq("bar")
-    end
-
-    it 'takes symbols as keys' do
-      expect(cookies("foo=bar")[:foo]).to eq("bar")
-    end
-
-    it 'returns nil for missing keys' do
-      expect(cookies("foo=bar")['bar']).to be_nil
-    end
-
-    it 'allows access to response cookies' do
-      expect(cookie_route do
-        response.set_cookie 'foo', 'bar'
-        cookies['foo']
-      end).to eq('bar')
-    end
-
-    it 'favors response cookies over request cookies' do
-      expect(cookie_route('foo=bar') do
-        response.set_cookie 'foo', 'baz'
-        cookies['foo']
-      end).to eq('baz')
-    end
-
-
-    it 'takes the last value for response cookies' do
-      expect(cookie_route do
-        response.set_cookie 'foo', 'bar'
-        response.set_cookie 'foo', 'baz'
-        cookies['foo']
-      end).to eq('baz')
-    end
-  end
-
-  describe :[]= do
-    it 'sets cookies to httponly' do
-      expect(cookie_route do
-        cookies['foo'] = 'bar'
-        response['Set-Cookie'].lines.detect { |l| l.start_with? 'foo=' }
-      end).to include('HttpOnly')
-    end
-
-    it 'sets domain to nil if localhost' do
-      @headers = {'HTTP_HOST' => 'localhost'}
-      expect(cookie_route do
-        cookies['foo'] = 'bar'
-        response['Set-Cookie']
-      end).not_to include("domain")
-    end
-
-    it 'sets the domain' do
-      expect(cookie_route do
-        cookies['foo'] = 'bar'
-        response['Set-Cookie'].lines.detect { |l| l.start_with? 'foo=' }
-      end).to include('domain=example.org')
-    end
-
-    it 'sets path to / by default' do
-      expect(cookie_route do
-        cookies['foo'] = 'bar'
-        response['Set-Cookie'].lines.detect { |l| l.start_with? 'foo=' }
-      end).to include('path=/')
-    end
-
-    it 'sets path to the script_name if app is nested' do
-      expect(cookie_route do
-        request.script_name = '/foo'
-        cookies['foo'] = 'bar'
-        response['Set-Cookie'].lines.detect { |l| l.start_with? 'foo=' }
-      end).to include('path=/foo')
-    end
-
-    it 'sets a cookie' do
-      cookie_route { cookies['foo'] = 'bar' }
-      expect(cookie_jar['foo']).to eq('bar')
-    end
-
-    it 'adds a value to the cookies hash' do
-      expect(cookie_route do
-        cookies['foo'] = 'bar'
-        cookies['foo']
-      end).to eq('bar')
-    end
-  end
-
-  describe :assoc do
-    it 'behaves like Hash#assoc' do
-      cookies('foo=bar').assoc('foo') == ['foo', 'bar']
-    end
-  end if Hash.method_defined? :assoc
-
-  describe :clear do
-    it 'removes request cookies from cookies hash' do
-      jar = cookies('foo=bar')
-      expect(jar['foo']).to eq('bar')
-      jar.clear
-      expect(jar['foo']).to be_nil
-    end
-
-    it 'removes response cookies from cookies hash' do
-      expect(cookie_route do
-        cookies['foo'] = 'bar'
-        cookies.clear
-        cookies['foo']
-      end).to be_nil
-    end
-
-    it 'expires existing cookies' do
-      expect(cookie_route("foo=bar") do
-        cookies.clear
-        response['Set-Cookie']
-      end).to include("foo=;", "expires=", "1970 00:00:00")
-    end
-  end
-
-  describe :compare_by_identity? do
-    it { expect(cookies).not_to be_compare_by_identity }
-  end
-
-  describe :default do
-    it { expect(cookies.default).to be_nil }
-  end
-
-  describe :default_proc do
-    it { expect(cookies.default_proc).to be_nil }
-  end
-
-  describe :delete do
-    it 'removes request cookies from cookies hash' do
-      jar = cookies('foo=bar')
-      expect(jar['foo']).to eq('bar')
-      jar.delete 'foo'
-      expect(jar['foo']).to be_nil
-    end
-
-    it 'removes response cookies from cookies hash' do
-      expect(cookie_route do
-        cookies['foo'] = 'bar'
-        cookies.delete 'foo'
-        cookies['foo']
-      end).to be_nil
-    end
-
-    it 'expires existing cookies' do
-      expect(cookie_route("foo=bar") do
-        cookies.delete 'foo'
-        response['Set-Cookie']
-      end).to include("foo=;", "expires=", "1970 00:00:00")
-    end
-
-    it 'honours the app cookie_options' do
-      @cookie_app.class_eval do
-        set :cookie_options, {
-          :path => '/foo',
-          :domain => 'bar.com',
-          :secure => true,
-          :httponly => true
-        }
-      end
-      cookie_header = cookie_route("foo=bar") do
-        cookies.delete 'foo'
-        response['Set-Cookie']
-      end
-      expect(cookie_header).to include("path=/foo;", "domain=bar.com;", "secure;", "HttpOnly")
-    end
-
-    it 'does not touch other cookies' do
-      expect(cookie_route("foo=bar", "bar=baz") do
-        cookies.delete 'foo'
-        cookies['bar']
-      end).to eq('baz')
-    end
-
-    it 'returns the previous value for request cookies' do
-      expect(cookie_route("foo=bar") do
-        cookies.delete "foo"
-      end).to eq("bar")
-    end
-
-    it 'returns the previous value for response cookies' do
-      expect(cookie_route do
-        cookies['foo'] = 'bar'
-        cookies.delete "foo"
-      end).to eq("bar")
-    end
-
-    it 'returns nil for non-existing cookies' do
-      expect(cookie_route { cookies.delete("foo") }).to be_nil
-    end
-  end
-
-  describe :delete_if do
-    it 'deletes cookies that match the block' do
-      expect(cookie_route('foo=bar') do
-        cookies['bar'] = 'baz'
-        cookies['baz'] = 'foo'
-        cookies.delete_if { |*a| a.include? 'bar' }
-        cookies.values_at 'foo', 'bar', 'baz'
-      end).to eq([nil, nil, 'foo'])
-    end
-  end
-
-  describe :each do
-    it 'loops through cookies' do
-      keys = []
-      foo  = nil
-      bar  = nil
-
-      cookie_route('foo=bar', 'bar=baz') do
-        cookies.each do |key, value|
-          foo = value if key == 'foo'
-          bar = value if key == 'bar'
-          keys << key
-        end
-      end
-
-      expect(keys.sort).to eq(['bar', 'foo'])
-      expect(foo).to eq('bar')
-      expect(bar).to eq('baz')
-    end
-
-    it 'favors response over request cookies' do
-      seen = false
-      key = nil
-      value = nil
-      cookie_route('foo=bar') do
-        cookies[:foo] = 'baz'
-        cookies.each do |k,v|
-          key = k
-          value = v
-        end
-      end
-      expect(key).to eq('foo')
-      expect(value).to eq('baz')
-      expect(seen).to eq(false)
-    end
-
-    it 'does not loop through deleted cookies' do
-      cookie_route('foo=bar') do
-        cookies.delete :foo
-        cookies.each { fail }
-      end
-    end
-
-    it 'returns an enumerator' do
-      keys = []
-      cookie_route('foo=bar') do
-        enum = cookies.each
-        enum.each { |key, value| keys << key }
-      end
-      keys.each{ |key| expect(key).to eq('foo')}
-    end
-  end
-
-  describe :each_key do
-    it 'loops through cookies' do
-      keys = []
-
-      cookie_route('foo=bar', 'bar=baz') do
-        cookies.each_key do |key|
-          keys << key
-        end
-      end
-
-      expect(keys.sort).to eq(['bar', 'foo'])
-    end
-
-    it 'only yields keys once' do
-      seen = false
-      cookie_route('foo=bar') do
-        cookies[:foo] = 'baz'
-      end
-      expect(seen).to eq(false)
-    end
-
-    it 'does not loop through deleted cookies' do
-      cookie_route('foo=bar') do
-        cookies.delete :foo
-        cookies.each_key { fail }
-      end
-    end
-
-    it 'returns an enumerator' do
-      keys = []
-      cookie_route('foo=bar') do
-        enum = cookies.each_key
-        enum.each { |key|  keys << key }
-      end
-      keys.each{ |key| expect(key).to eq('foo')}
-    end
-  end
-
-  describe :each_pair do
-    it 'loops through cookies' do
-      keys = []
-      foo  = nil
-      bar  = nil
-
-      cookie_route('foo=bar', 'bar=baz') do
-        cookies.each_pair do |key, value|
-          foo = value if key == 'foo'
-          bar = value if key == 'bar'
-          keys << key
-        end
-      end
-
-      expect(keys.sort).to eq(['bar', 'foo'])
-      expect(foo).to eq('bar')
-      expect(bar).to eq('baz')
-    end
-
-    it 'favors response over request cookies' do
-      seen = false
-      key = nil
-      value = nil
-      cookie_route('foo=bar') do
-        cookies[:foo] = 'baz'
-        cookies.each_pair do |k, v|
-          key = k
-          value = v
-        end
-      end
-      expect(key).to eq('foo')
-      expect(value).to eq('baz')
-      expect(seen).to eq(false)
-    end
-
-    it 'does not loop through deleted cookies' do
-      cookie_route('foo=bar') do
-        cookies.delete :foo
-        cookies.each_pair { fail }
-      end
-    end
-
-    it 'returns an enumerator' do
-      keys = []
-      cookie_route('foo=bar') do
-        enum = cookies.each_pair
-        enum.each { |key, value| keys << key }
-      end
-      keys.each{ |key| expect(key).to eq('foo')}
-    end
-  end
-
-  describe :each_value do
-    it 'loops through cookies' do
-      values = []
-
-      cookie_route('foo=bar', 'bar=baz') do
-        cookies.each_value do |value|
-          values << value
-        end
-      end
-
-      expect(values.sort).to eq(['bar', 'baz'])
-    end
-
-    it 'favors response over request cookies' do
-      seen = false
-      value = nil
-      cookie_route('foo=bar') do
-        cookies[:foo] = 'baz'
-        cookies.each_value do |v|
-          value = v
-        end
-      end
-      expect(value).to eq('baz')
-    end
-
-    it 'does not loop through deleted cookies' do
-      cookie_route('foo=bar') do
-        cookies.delete :foo
-        cookies.each_value { fail }
-      end
-    end
-
-    it 'returns an enumerator' do
-      enum = nil
-      cookie_route('foo=bar') do
-        enum = cookies.each_value
-      end
-      enum.each { |value| expect(value).to eq('bar') }
-    end
-  end
-
-  describe :empty? do
-    it 'returns true if there are no cookies' do
-      expect(cookies).to be_empty
-    end
-
-    it 'returns false if there are request cookies' do
-      expect(cookies('foo=bar')).not_to be_empty
-    end
-
-    it 'returns false if there are response cookies' do
-      expect(cookie_route do
-        cookies['foo'] = 'bar'
-        cookies.empty?
-      end).to be false
-    end
-
-    it 'becomes true if response cookies are removed' do
-      expect(cookie_route do
-        cookies['foo'] = 'bar'
-        cookies.delete :foo
-        cookies.empty?
-      end).to be true
-    end
-
-    it 'becomes true if request cookies are removed' do
-      expect(cookie_route('foo=bar') do
-        cookies.delete :foo
-        cookies.empty?
-      end).to be_truthy
-    end
-
-    it 'becomes true after clear' do
-      expect(cookie_route('foo=bar', 'bar=baz') do
-        cookies['foo'] = 'bar'
-        cookies.clear
-        cookies.empty?
-      end).to be_truthy
-    end
-  end
-
-  describe :fetch do
-    it 'returns values from request cookies' do
-      expect(cookies('foo=bar').fetch('foo')).to eq('bar')
-    end
-
-    it 'returns values from response cookies' do
-      expect(cookie_route do
-        cookies['foo'] = 'bar'
-        cookies.fetch('foo')
-      end).to eq('bar')
-    end
-
-    it 'favors response over request cookies' do
-      expect(cookie_route('foo=baz') do
-        cookies['foo'] = 'bar'
-        cookies.fetch('foo')
-      end).to eq('bar')
-    end
-
-    it 'raises an exception if key does not exist' do
-      error = if defined? JRUBY_VERSION
-        IndexError
-      else
-        KeyError
-      end
-      expect { cookies.fetch('foo') }.to raise_exception(error)
-    end
-
-    it 'returns the block result if missing' do
-      expect(cookies.fetch('foo') { 'bar' }).to eq('bar')
-    end
-  end
-
-  describe :flatten do
-    it { expect(cookies('foo=bar').flatten).to eq({'foo' => 'bar'}.flatten) }
-  end if Hash.method_defined? :flatten
-
-  describe :has_key? do
-    it 'checks request cookies' do
-      expect(cookies('foo=bar')).to have_key('foo')
-    end
-
-    it 'checks response cookies' do
-      jar = cookies
-      jar['foo'] = 'bar'
-      expect(jar).to have_key(:foo)
-    end
-
-    it 'does not use deleted cookies' do
-      jar = cookies('foo=bar')
-      jar.delete :foo
-      expect(jar).not_to have_key('foo')
-    end
-  end
-
-  describe :has_value? do
-    it 'checks request cookies' do
-      expect(cookies('foo=bar')).to have_value('bar')
-    end
-
-    it 'checks response cookies' do
-      jar = cookies
-      jar[:foo] = 'bar'
-      expect(jar).to have_value('bar')
-    end
-
-    it 'does not use deleted cookies' do
-      jar = cookies('foo=bar')
-      jar.delete :foo
-      expect(jar).not_to have_value('bar')
-    end
-  end
-
-  describe :include? do
-    it 'checks request cookies' do
-      expect(cookies('foo=bar')).to include('foo')
-    end
-
-    it 'checks response cookies' do
-      jar = cookies
-      jar['foo'] = 'bar'
-      expect(jar).to include(:foo)
-    end
-
-    it 'does not use deleted cookies' do
-      jar = cookies('foo=bar')
-      jar.delete :foo
-      expect(jar).not_to include('foo')
-    end
-  end
-
-  describe :keep_if do
-    it 'removes entries' do
-      jar = cookies('foo=bar', 'bar=baz')
-      jar.keep_if { |*args| args == ['bar', 'baz'] }
-      expect(jar).to eq({'bar' => 'baz'})
-    end
-  end
-
-  describe :key do
-    it 'checks request cookies' do
-      expect(cookies('foo=bar').key('bar')).to eq('foo')
-    end
-
-    it 'checks response cookies' do
-      jar = cookies
-      jar['foo'] = 'bar'
-      expect(jar.key('bar')).to eq('foo')
-    end
-
-    it 'returns nil when missing' do
-      expect(cookies('foo=bar').key('baz')).to be_nil
-    end
-  end
-
-  describe :key? do
-    it 'checks request cookies' do
-      expect(cookies('foo=bar').key?('foo')).to be true
-    end
-
-    it 'checks response cookies' do
-      jar = cookies
-      jar['foo'] = 'bar'
-      expect(jar.key?(:foo)).to be true
-    end
-
-    it 'does not use deleted cookies' do
-      jar = cookies('foo=bar')
-      jar.delete :foo
-      expect(jar.key?('foo')).to be false
-    end
-  end
-
-  describe :keys do
-    it { expect(cookies('foo=bar').keys).to eq(['foo']) }
-  end
-
-  describe :length do
-    it { expect(cookies.length).to eq(0) }
-    it { expect(cookies('foo=bar').length).to eq(1) }
-  end
-
-  describe :member? do
-    it 'checks request cookies' do
-      expect(cookies('foo=bar').member?('foo')).to be true
-    end
-
-    it 'checks response cookies' do
-      jar = cookies
-      jar['foo'] = 'bar'
-      expect(jar.member?(:foo)).to be true
-    end
-
-    it 'does not use deleted cookies' do
-      jar = cookies('foo=bar')
-      jar.delete :foo
-      expect(jar.member?('foo')).to be false
-    end
-  end
-
-  describe :merge do
-    it 'is mergable with a hash' do
-      expect(cookies('foo=bar').merge(:bar => :baz)).to eq({"foo" => "bar", :bar => :baz})
-    end
-
-    it 'does not create cookies' do
-      jar = cookies('foo=bar')
-      jar.merge(:bar => 'baz')
-      expect(jar).not_to include(:bar)
-    end
-
-    it 'takes a block for conflict resolution' do
-      update = {'foo' => 'baz', 'bar' => 'baz'}
-      merged = cookies('foo=bar').merge(update) do |key, old, other|
-        expect(key).to   eq('foo')
-        expect(old).to   eq('bar')
-        expect(other).to eq('baz')
-        'foo'
-      end
-      expect(merged['foo']).to eq('foo')
-    end
-  end
-
-  describe :merge! do
-    it 'creates cookies' do
-      jar = cookies('foo=bar')
-      jar.merge! :bar => 'baz'
-      expect(jar).to include('bar')
-    end
-
-    it 'overrides existing values' do
-      jar = cookies('foo=bar')
-      jar.merge! :foo => "baz"
-      expect(jar["foo"]).to eq("baz")
-    end
-
-    it 'takes a block for conflict resolution' do
-      update = {'foo' => 'baz', 'bar' => 'baz'}
-      jar    = cookies('foo=bar')
-      jar.merge!(update) do |key, old, other|
-        expect(key).to   eq('foo')
-        expect(old).to   eq('bar')
-        expect(other).to eq('baz')
-        'foo'
-      end
-      expect(jar['foo']).to eq('foo')
-    end
-  end
-
-  describe :rassoc do
-    it 'behaves like Hash#assoc' do
-      cookies('foo=bar').rassoc('bar') == ['foo', 'bar']
-    end
-  end if Hash.method_defined? :rassoc
-
-  describe :reject do
-    it 'removes entries from new hash' do
-      jar = cookies('foo=bar', 'bar=baz')
-      sub = jar.reject { |*args| args == ['bar', 'baz'] }
-      expect(sub).to eq({'foo' => 'bar'})
-      expect(jar['bar']).to eq('baz')
-    end
-  end
-
-  describe :reject! do
-    it 'removes entries' do
-      jar = cookies('foo=bar', 'bar=baz')
-      jar.reject! { |*args| args == ['bar', 'baz'] }
-      expect(jar).to eq({'foo' => 'bar'})
-    end
-  end
-
-  describe :replace do
-    it 'replaces entries' do
-      jar = cookies('foo=bar', 'bar=baz')
-      jar.replace 'foo' => 'baz', 'baz' => 'bar'
-      expect(jar).to eq({'foo' => 'baz', 'baz' => 'bar'})
-    end
-  end
-
-  describe :set do
-    it 'sets a cookie' do
-      cookie_route { cookies.set('foo', value: 'bar') }
-      expect(cookie_jar['foo']).to eq('bar')
-    end
-
-    it 'sets a cookie with HttpOnly' do
-      expect(cookie_route do
-        request.script_name = '/foo'
-        cookies.set('foo', value: 'bar', httponly: true)
-        response['Set-Cookie'].lines.detect { |l| l.start_with? 'foo=' }
-      end).to include('HttpOnly')
-    end
-
-    it 'sets a cookie without HttpOnly' do
-      expect(cookie_route do
-        request.script_name = '/foo'
-        cookies.set('foo', value: 'bar', httponly: false)
-        response['Set-Cookie'].lines.detect { |l| l.start_with? 'foo=' }
-      end).not_to include('HttpOnly')
-    end
-  end
-
-  describe :select do
-    it 'removes entries from new hash' do
-      jar = cookies('foo=bar', 'bar=baz')
-      sub = jar.select { |*args| args != ['bar', 'baz'] }
-      expect(sub).to eq({'foo' => 'bar'}.select { true })
-      expect(jar['bar']).to eq('baz')
-    end
-  end
-
-  describe :select! do
-    it 'removes entries' do
-      jar = cookies('foo=bar', 'bar=baz')
-      jar.select! { |*args| args != ['bar', 'baz'] }
-      expect(jar).to eq({'foo' => 'bar'})
-    end
-  end if Hash.method_defined? :select!
-
-  describe :shift do
-    it 'removes from the hash' do
-      jar = cookies('foo=bar')
-      expect(jar.shift).to eq(['foo', 'bar'])
-      expect(jar).not_to include('bar')
-    end
-  end
-
-  describe :size do
-    it { expect(cookies.size).to eq(0) }
-    it { expect(cookies('foo=bar').size).to eq(1) }
-  end
-
-  describe :update do
-    it 'creates cookies' do
-      jar = cookies('foo=bar')
-      jar.update :bar => 'baz'
-      expect(jar).to include('bar')
-    end
-
-    it 'overrides existing values' do
-      jar = cookies('foo=bar')
-      jar.update :foo => "baz"
-      expect(jar["foo"]).to eq("baz")
-    end
-
-    it 'takes a block for conflict resolution' do
-      merge = {'foo' => 'baz', 'bar' => 'baz'}
-      jar   = cookies('foo=bar')
-      jar.update(merge) do |key, old, other|
-        expect(key).to   eq('foo')
-        expect(old).to   eq('bar')
-        expect(other).to eq('baz')
-        'foo'
-      end
-      expect(jar['foo']).to eq('foo')
-    end
-  end
-
-  describe :value? do
-    it 'checks request cookies' do
-      expect(cookies('foo=bar').value?('bar')).to be true
-    end
-
-    it 'checks response cookies' do
-      jar = cookies
-      jar[:foo] = 'bar'
-      expect(jar.value?('bar')).to be true
-    end
-
-    it 'does not use deleted cookies' do
-      jar = cookies('foo=bar')
-      jar.delete :foo
-      expect(jar.value?('bar')).to be false
-    end
-  end
-
-  describe :values do
-    it { expect(cookies('foo=bar', 'bar=baz').values.sort).to eq(['bar', 'baz']) }
-  end
-
-  describe :values_at do
-    it { expect(cookies('foo=bar', 'bar=baz').values_at('foo')).to eq(['bar']) }
-  end
-end