sinatra-contrib 1.4.7 → 2.0.0.beta1

data/lib/sinatra/reloader.rb

@@ -55,7 +55,8 @@ module Sinatra
   #
   # You can refine the reloading policy with +also_reload+ and
   # +dont_reload+, to customize which files should, and should not, be
-  # reloaded, respectively.
+  # reloaded, respectively. You can also use +after_reload+ to execute a
+  # block after any file being reloaded.
   #
   # === Classic Application
   #
@@ -66,6 +67,9 @@ module Sinatra
   #
   #     also_reload '/path/to/some/file'
   #     dont_reload '/path/to/other/file'
+  #     after_reload do
+  #       puts 'reloaded'
+  #     end
   #
   #     # Your classic application code goes here...
   #
@@ -81,6 +85,9 @@ module Sinatra
   #         register Sinatra::Reloader
   #         also_reload '/path/to/some/file'
   #         dont_reload '/path/to/other/file'
+  #         after_reload do
+  #           puts 'reloaded'
+  #         end
   #       end
   #
   #       # Your modular application code goes here...
@@ -205,6 +212,12 @@ module Sinatra
 
     MUTEX_FOR_PERFORM = Mutex.new
 
+    # Allow a block to be executed after any file being reloaded
+    @@after_reload = []
+    def after_reload(&block)
+      @@after_reload  << block
+    end
+
     # When the extension is registered it extends the Sinatra application
     # +klass+ with the modules +BaseMethods+ and +ExtensionMethods+ and
     # defines a before filter to +perform+ the reload of the modified files.
@@ -236,6 +249,7 @@ module Sinatra
         require watcher.path
         watcher.update
       end
+      @@after_reload.each(&:call)
     end
 
     # Contains the methods defined in Sinatra::Base that are overridden.

data/lib/sinatra/required_params.rb

@@ -0,0 +1,71 @@
+require 'sinatra/base'
+
+module Sinatra
+  # = Sinatra::RequiredParams
+  #
+  # Ensure required query parameters
+  #
+  # == Usage
+  #
+  # Set required query parameter keys in the argument.
+  # It'll halt with 400 if requried keys don't exist.
+  #
+  #   get '/simple_keys' do
+  #     required_params :p1, :p2
+  #   end
+  #
+  # Complicated pattern is also fine.
+  #
+  #   get '/complicated_keys' do
+  #     required_params :p1, :p2 => [:p3, :p4]
+  #   end
+  #
+  # === Classic Application
+  #
+  # In a classic application simply require the helpers, and start using them:
+  #
+  #     require "sinatra"
+  #     require "sinatra/required_params"
+  #
+  #     # The rest of your classic application code goes here...
+  #
+  # === Modular Application
+  #
+  # In a modular application you need to require the helpers, and then tell
+  # the application to use them:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/required_params"
+  #
+  #     class MyApp < Sinatra::Base
+  #       helpers Sinatra::RequiredParams
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  module RequiredParams
+    def required_params(*keys)
+      _required_params(params, *keys)
+    end
+
+    private
+
+    def _required_params(p, *keys)
+      keys.each do |key|
+        if key.is_a?(Hash)
+          _required_params(p, *key.keys)
+          key.each do |k, v|
+            _required_params(p[k.to_s], v)
+          end
+        elsif key.is_a?(Array)
+          _required_params(p, *key)
+        else
+          halt 400 unless p.has_key?(key.to_s)
+        end
+      end
+      true
+    end
+  end
+
+  helpers RequiredParams
+end

data/lib/sinatra/respond_with.rb

@@ -1,8 +1,6 @@
 require 'sinatra/json'
 require 'sinatra/base'
 
-$KCODE = "UTF-8" unless RUBY_VERSION > "1.9.0"
-
 module Sinatra
   #
   # = Sinatra::RespondWith
@@ -117,7 +115,7 @@ module Sinatra
             @app.halt result
           end
         end
-        @app.halt 406
+        @app.halt 500, "Unknown template engine"
       end
 
       def method_missing(method, *args, &block)
@@ -179,7 +177,11 @@ module Sinatra
           if Tilt.respond_to?(:mappings)
             klass = Tilt.mappings[Tilt.normalize(engine)].first
           else
-            klass = Tilt[engine]
+            begin
+              klass = Tilt[engine]
+            rescue LoadError
+              next
+            end
           end
           find_template(settings.views, template, klass) do |file|
             next unless File.exist? file
@@ -249,7 +251,7 @@ module Sinatra
       }
       engines.default = []
       (defined? JRUBY_VERSION) ? jrubyify(engines) : engines
-    end  
+    end
 
     def self.registered(base)
       base.set :ext_map, Hash.new { |h,k| h[k] = [] }

data/sinatra-contrib.gemspec

@@ -1,10 +1,11 @@
 # -*- encoding: utf-8 -*-
 
-# Run `rake sinatra-contrib.gemspec` to update the gemspec.
-require File.expand_path('../lib/sinatra/contrib/version', __FILE__)
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "sinatra/version"
+
 Gem::Specification.new do |s|
   s.name        = "sinatra-contrib"
-  s.version     = Sinatra::Contrib::VERSION
+  s.version     = Sinatra::VERSION
   s.description = "Collection of useful Sinatra extensions"
   s.homepage    = "http://github.com/sinatra/sinatra-contrib"
   s.license     = "MIT"
@@ -137,7 +138,6 @@ Gem::Specification.new do |s|
     "lib/sinatra/contrib/version.rb",
     "lib/sinatra/cookies.rb",
     "lib/sinatra/custom_logger.rb",
-    "lib/sinatra/decompile.rb",
     "lib/sinatra/engine_tracking.rb",
     "lib/sinatra/extension.rb",
     "lib/sinatra/json.rb",
@@ -147,6 +147,7 @@ Gem::Specification.new do |s|
     "lib/sinatra/reloader.rb",
     "lib/sinatra/respond_with.rb",
     "lib/sinatra/streaming.rb",
+    "lib/sinatra/required_params.rb",
     "lib/sinatra/test_helpers.rb",
     "sinatra-contrib.gemspec",
     "spec/capture_spec.rb",
@@ -192,7 +193,6 @@ Gem::Specification.new do |s|
     "spec/content_for_spec.rb",
     "spec/cookies_spec.rb",
     "spec/custom_logger_spec.rb",
-    "spec/decompile_spec.rb",
     "spec/extension_spec.rb",
     "spec/json_spec.rb",
     "spec/link_header_spec.rb",
@@ -210,17 +210,21 @@ Gem::Specification.new do |s|
     "spec/respond_with/not_html.sass",
     "spec/respond_with_spec.rb",
     "spec/spec_helper.rb",
-    "spec/streaming_spec.rb"
+    "spec/streaming_spec.rb",
+    "spec/required_params_spec.rb",
   ]
 
-  s.add_dependency "sinatra",   "~> 1.4.0"
+  s.required_ruby_version = '>= 2.2.0'
+
+  s.add_dependency "sinatra", Sinatra::VERSION
+  s.add_dependency "mustermann",  "1.0.0.beta2"
   s.add_dependency "backports", ">= 2.0"
   s.add_dependency "tilt",      ">= 1.3", "< 3"
   s.add_dependency "rack-test"
-  s.add_dependency "rack-protection"
+  s.add_dependency "rack-protection", Sinatra::VERSION
   s.add_dependency "multi_json"
 
-  s.add_development_dependency "rspec", "~> 2.3"
+  s.add_development_dependency "rspec", "~> 3.4"
   s.add_development_dependency "haml"
   s.add_development_dependency "erubis"
   s.add_development_dependency "slim"
@@ -229,7 +233,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "builder"
   s.add_development_dependency "liquid"
   s.add_development_dependency "redcarpet"
-  s.add_development_dependency "RedCloth"
+  s.add_development_dependency "RedCloth", "~> 4.2.9"
   s.add_development_dependency "asciidoctor"
   s.add_development_dependency "radius"
   s.add_development_dependency "coffee-script"

data/spec/capture_spec.rb

@@ -23,11 +23,11 @@ describe Sinatra::Capture do
     require "#{engine}"
 
     it "captures content" do
-      render(engine, "simple_#{lang}").should == "Say Hello World!"
+      expect(render(engine, "simple_#{lang}")).to eq("Say Hello World!")
     end
 
     it "allows nested captures" do
-      render(engine, "nested_#{lang}").should == "Say Hello World!"
+      expect(render(engine, "nested_#{lang}")).to eq("Say Hello World!")
     end
   end
 
@@ -39,12 +39,12 @@ describe Sinatra::Capture do
     it_behaves_like "a template language", :erb
 
     it "handles utf-8 encoding" do
-      render(:erb, "utf_8").should == "UTF-8 –"
+      expect(render(:erb, "utf_8")).to eq("UTF-8 –")
     end
 
     it "handles ISO-8859-1 encoding" do
-      render(:erb, "iso_8859_1").should == "ISO-8859-1 -"
-    end if RUBY_VERSION >= '1.9'
+      expect(render(:erb, "iso_8859_1")).to eq("ISO-8859-1 -")
+    end
   end
 end
 

data/spec/config_file/key_value.yml

@@ -1,5 +1,6 @@
 ---
 foo: bar
+bar: <%= "bar" %>
 something: 42
 nested:
   a: 1

data/spec/config_file_spec.rb

@@ -12,19 +12,19 @@ describe Sinatra::ConfigFile do
 
   it 'should set options from a simple config_file' do
     config_file 'key_value.yml'
-    settings.foo.should == 'bar'
-    settings.something.should == 42
+    expect(settings.foo).to eq('bar')
+    expect(settings.something).to eq(42)
   end
 
   it 'should create indifferent hashes' do
     config_file 'key_value.yml'
-    settings.nested['a'].should == 1
-    settings.nested[:a].should == 1
+    expect(settings.nested['a']).to eq(1)
+    expect(settings.nested[:a]).to eq(1)
   end
 
-  it 'should render options in ERB tags' do
-    config_file 'key_value.yml.erb'
-    settings.foo.should == "bar"
+  it 'should render options in ERB tags when using .yml files' do
+    config_file 'key_value.yml'
+    settings.bar.should == "bar"
     settings.something.should == 42
     settings.nested['a'].should == 1
     settings.nested[:a].should == 1
@@ -32,31 +32,45 @@ describe Sinatra::ConfigFile do
     settings.nested[:b].should == 2
   end
 
+  it 'should render options in ERB tags when using .yml.erb files' do
+    config_file 'key_value.yml.erb'
+    expect(settings.foo).to eq("bar")
+    expect(settings.something).to eq(42)
+    expect(settings.nested['a']).to eq(1)
+    expect(settings.nested[:a]).to eq(1)
+    expect(settings.nested['b']).to eq(2)
+    expect(settings.nested[:b]).to eq(2)
+  end
+
+  it 'should raise error if config file extension is not .yml or .erb' do
+    expect{ config_file 'config.txt' }.to raise_error(Sinatra::ConfigFile::UnsupportedConfigType)
+  end
+
   it 'should recognize env specific settings per file' do
     config_file 'with_envs.yml'
-    settings.foo.should == 'test'
+    expect(settings.foo).to eq('test')
   end
 
   it 'should recognize env specific settings per setting' do
     config_file 'with_nested_envs.yml'
-    settings.database[:adapter].should == 'sqlite'
+    expect(settings.database[:adapter]).to eq('sqlite')
   end
 
   it 'should not set present values to nil if the current env is missing' do
     # first let's check the test is actually working properly
     config_file('missing_env.yml') { set :foo => 42, :environment => :production }
-    settings.foo.should == 10
+    expect(settings.foo).to eq(10)
     # now test it
     config_file('missing_env.yml') { set :foo => 42, :environment => :test }
-    settings.foo.should == 42
+    expect(settings.foo).to eq(42)
   end
 
   it 'should prioritize settings in latter files' do
     # first let's check the test is actually working properly
     config_file 'key_value.yml'
-    settings.foo.should == 'bar'
+    expect(settings.foo).to eq('bar')
     # now test it
     config_file 'key_value_override.yml'
-    settings.foo.should == 'foo'
+    expect(settings.foo).to eq('foo')
   end
 end

data/spec/content_for/footer.haml

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

data/spec/content_for/footer.slim

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

data/spec/content_for_spec.rb

@@ -11,7 +11,7 @@ describe Sinatra::ContentFor do
   Tilt.prefer Tilt::ERBTemplate
 
   extend Forwardable
-  def_delegators :subject, :content_for, :yield_content
+  def_delegators :subject, :content_for, :clear_content_for, :yield_content
   def render(engine, template)
     subject.send(:render, engine, template, :layout => false).gsub(/\s/, '')
   end
@@ -19,17 +19,22 @@ describe Sinatra::ContentFor do
   describe "without templates" do
     it 'renders blocks declared with the same key you use when rendering' do
       content_for(:foo) { "foo" }
-      yield_content(:foo).should == "foo"
+      expect(yield_content(:foo)).to eq("foo")
     end
 
     it 'renders blocks more than once' do
       content_for(:foo) { "foo" }
-      3.times { yield_content(:foo).should == "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" }
-      yield_content(:foo).should be_empty
+      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
@@ -37,7 +42,7 @@ describe Sinatra::ContentFor do
       content_for(:foo) { "bar" }
       content_for(:bar) { "WON'T RENDER ME" }
       content_for(:foo) { "baz" }
-      yield_content(:foo).should == "foobarbaz"
+      expect(yield_content(:foo)).to eq("foobarbaz")
     end
 
     it 'renders multiple blocks more than once' do
@@ -45,13 +50,25 @@ describe Sinatra::ContentFor do
       content_for(:foo) { "bar" }
       content_for(:bar) { "WON'T RENDER ME" }
       content_for(:foo) { "baz" }
-      3.times { yield_content(:foo).should == "foobarbaz" }
+      3.times { expect(yield_content(:foo)).to eq("foobarbaz") }
     end
 
     it 'passes values to the blocks' do
       content_for(:foo) { |a| a.upcase }
-      yield_content(:foo, 'a').should == "A"
-      yield_content(:foo, 'b').should == "B"
+      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
 
@@ -64,56 +81,61 @@ describe Sinatra::ContentFor do
         begin
           require inner
         rescue LoadError => e
-          pending "Skipping: " << e.message
+          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
-          yield_content(:foo).strip.should == "foo"
+          expect(yield_content(:foo).strip).to eq("foo")
         end
 
         it 'renders blocks more than once' do
           render inner, :same_key
-          3.times { yield_content(:foo).strip.should == "foo" }
+          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
-          yield_content(:foo).should be_empty
+          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
-          yield_content(:foo).gsub(/\s/, '').should == "foobarbaz"
+          expect(yield_content(:foo).gsub(/\s/, '')).to eq("foobarbaz")
         end
 
         it 'renders multiple blocks more than once' do
           render inner, :multiple_blocks
-          3.times { yield_content(:foo).gsub(/\s/, '').should == "foobarbaz" }
+          3.times { expect(yield_content(:foo).gsub(/\s/, '')).to eq("foobarbaz") }
         end
 
         it 'passes values to the blocks' do
           render inner, :takes_values
-          yield_content(:foo, 1, 2).gsub(/\s/, '').should == "<i>1</i>2"
+          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" }
-          render(inner, :layout).should == "foo"
+          expect(render(inner, :layout)).to eq("foo")
         end
 
         it 'renders blocks more than once' do
           content_for(:foo) { "foo" }
-          render(inner, :multiple_yields).should == "foofoofoo"
+          expect(render(inner, :multiple_yields)).to eq("foofoofoo")
         end
 
         it 'does not render a block with a different key' do
           content_for(:bar) { "foo" }
-          render(inner, :layout).should be_empty
+          expect(render(inner, :layout)).to be_empty
         end
 
         it 'renders multiple blocks with the same key' do
@@ -121,7 +143,7 @@ describe Sinatra::ContentFor do
           content_for(:foo) { "bar" }
           content_for(:bar) { "WON'T RENDER ME" }
           content_for(:foo) { "baz" }
-          render(inner, :layout).should == "foobarbaz"
+          expect(render(inner, :layout)).to eq("foobarbaz")
         end
 
         it 'renders multiple blocks more than once' do
@@ -129,24 +151,31 @@ describe Sinatra::ContentFor do
           content_for(:foo) { "bar" }
           content_for(:bar) { "WON'T RENDER ME" }
           content_for(:foo) { "baz" }
-          render(inner, :multiple_yields).should == "foobarbazfoobarbazfoobarbaz"
+          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}" }
-          render(inner, :passes_values).should == "<i>1</i>2"
+          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" }
-          render(inner, :footer).should == "foot"
+          expect(render(inner, :footer)).to eq("foot")
         end
 
         it 'does not render a block if different key' do
           content_for(:different_key) { "foot" }
-          render(inner, :footer).should be_empty
+          expect(render(inner, :footer)).to be_empty
         end
       end
 
@@ -160,7 +189,7 @@ describe Sinatra::ContentFor do
             begin
               require outer
             rescue LoadError => e
-              pending "Skipping: " << e.message
+              skip "Skipping: " << e.message
             end
           end
 
@@ -177,33 +206,33 @@ describe Sinatra::ContentFor do
           end
 
           it 'renders blocks declared with the same key you use when rendering' do
-            get('/same_key').should be_ok
-            body.should == "foo"
+            expect(get('/same_key')).to be_ok
+            expect(body).to eq("foo")
           end
 
           it 'renders blocks more than once' do
-            get('/multiple_yields/same_key').should be_ok
-            body.should == "foofoofoo"
+            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
-            get('/different_key').should be_ok
-            body.should be_empty
+            expect(get('/different_key')).to be_ok
+            expect(body).to be_empty
           end
 
           it 'renders multiple blocks with the same key' do
-            get('/multiple_blocks').should be_ok
-            body.should == "foobarbaz"
+            expect(get('/multiple_blocks')).to be_ok
+            expect(body).to eq("foobarbaz")
           end
 
           it 'renders multiple blocks more than once' do
-            get('/multiple_yields/multiple_blocks').should be_ok
-            body.should == "foobarbazfoobarbazfoobarbaz"
+            expect(get('/multiple_yields/multiple_blocks')).to be_ok
+            expect(body).to eq("foobarbazfoobarbazfoobarbaz")
           end
 
           it 'passes values to the blocks' do
-            get('/passes_values/takes_values').should be_ok
-            body.should == "<i>1</i>2"
+            expect(get('/passes_values/takes_values')).to be_ok
+            expect(body).to eq("<i>1</i>2")
           end
         end
       end