tobias-sinatra-respond_to 0.6.0

data/.gitignore

@@ -0,0 +1,5 @@
+.bundle
+.DS_Store
+pkg/
+coverage/
+coverage.info

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--profile

data/Changelog.rdoc

@@ -0,0 +1,81 @@
+=== 0.5.0 / 2010-08-22
+
+* Requires Sinatra 1.x
+* Allow specifying format through a format param to the url
+
+=== 0.4.0 / 2010-01-30
+
+* Specify that when running into unknown template languages the error message defaults to a generic template example
+* Update code example
+* Update supported sinatra versions in README
+* Remove issues section because I believe it has been corrected
+* Update development error message for new builder syntax
+* Remove redundant hoe dependency and update rcov opts
+* Fix the media_type -> mime_type conversion on Sinatra 0.9
+* Fix rendering with extensions, e.g. resource.html.haml
+* Add spec and passing code for content_type usage
+* Changed how development error images are shown
+* Update media_type to mime_type for Sinatra 1.0 while maintaining backward compat
+
+=== 0.3.8 / 2010-01-30
+
+* Need to bump because of wrong gem name
+* Fix some issues in the README
+
+=== 0.3.7 / 2010-01-30
+
+* Update builder template for how sinatra handles this now
+* Update spec tests for 1.9
+* Update XMLHttpResponse test for new rack-test
+* Regenerated gemspec for version 0.3.6
+
+=== 0.3.6 / 2009-07-31
+
+* Version bump to 0.3.6
+* solving incompatibility between 1.9 to fully qualify TEXT_MIME_TYPES check
+
+=== 0.3.5 / 2009-05-14
+
+* Regenerated gemspec for version 0.3.5
+* Version bump to 0.3.5
+* better testing of environment expectations, workarounds for sinatra environment switching
+* problem in spec, wasn't checking for right thing
+* spec for reaching the /__sinatra__/*.png images
+* couple more tests for charset and format helpers
+* reduce regex use and simplify others
+* some more code cleaning
+* simplification and readability
+* add some more specification for respond_to
+
+=== 0.3.4 / 2009-05-13
+
+* updated gemspec
+* Version bump to 0.3.4
+* updated readme
+* passing code for tests
+* tests and tests
+* typo in readme
+* allow for content_type setting automatically when not using respond_to
+* make it a bit clearer in readme that outside of respond_to content_type is not set
+* bumped gem version in gemspec
+* noted the change in classic applications, the gem now works around this but not following extension writing guidelines
+
+=== 0.3.3 / 2009-05-12
+
+* Version bump to 0.3.3
+* Version bump to 0.3.2
+* spec referenced file not in repository
+
+=== 0.3.1 / 2009-05-11
+
+* Version bump to 0.3.1
+* add sinatra as a dependency
+* allow overriding default charset in respond_to
+* install instructions
+* first gem
+* Version bump to 0.0.0
+* missing end in example
+* add caveats about existing routes
+* fix a little error in example
+* updated readme and license
+

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    sinatra-respond_to (0.5.0)
+      sinatra (~> 1.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    haml (3.0.22)
+    rack (1.2.1)
+    rack-test (0.5.6)
+      rack (>= 1.0)
+    rcov (0.9.9)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+    sinatra (1.1.0)
+      rack (~> 1.1)
+      tilt (~> 1.1)
+    tilt (1.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  builder (>= 2.0)
+  bundler (~> 1.0.0)
+  haml (>= 2.0)
+  rack-test (~> 0.5.6)
+  rcov (~> 0.9.8)
+  rspec (~> 2.0.1)
+  sinatra (~> 1.1)
+  sinatra-respond_to!

data/README.md

@@ -0,0 +1,145 @@
+# sinatra-respond\_to
+
+* http://www.github.com/cehoffman/sinatra-respond\_to
+
+## DESCRIPTION:
+
+A respond\_to style Rails block for baked-in web service support in Sinatra
+
+## FEATURES/PROBLEMS:
+
+* Handles setting the content type depending on what is being served
+* Automatically can adjust XMLHttpRequests to return Javascript
+
+## SYNOPSIS:
+
+Allows urls of the form **/posts**, **/posts.rss**, and **/posts?format=atom** to route to the same Sinatra block and format specific respond\_to block.
+
+    require 'sinatra'
+    require 'sinatra/respond_to'
+    
+    Sinatra::Application.register Sinatra::RespondTo
+
+    get '/posts' do
+      @posts = Post.recent
+
+      respond_to do |wants|
+        wants.html { haml :posts }      # => views/posts.html.haml, also sets content_type to text/html
+        wants.rss { haml :posts }       # => views/posts.rss.haml, also sets content_type to application/rss+xml
+        wants.atom { haml :posts }      # => views/posts.atom.haml, also sets content_type to appliation/atom+xml
+      end
+    end
+
+    get '/post/:id' do
+      @post = Post.find(params[:id])
+
+      respond_to do |wants|
+        wants.html { haml :post }       # => views/post.html.haml, also sets content_type to text/html
+        wants.xhtml { haml :post }      # => views/post.xhtml.haml, also sets content_type to application/xhtml+xml
+        wants.xml { @post.to_xml }      # => sets content_type to application/xml
+        wants.js { erb :post }          # => views/post.js.erb, also sets content_type to application/javascript
+      end
+    end
+
+    get '/comments/:id' do
+      @comment = Comment.find(params[:id])
+
+      respond_to do |wants|
+        wants.html { haml :comment }    # => views/comment.html.haml, also sets content_type to text/html
+        wants.json { @comment.to_json } # => sets content_type to application/json
+        wants.js { erb :comment }       # => views/comment.js.erb, also sets content_type to application/javascript
+      end
+    end
+
+To change the character set of the response, there is a `charset` helper.  For example
+
+    get '/iso-8859-1' do
+      charset 'iso-8859-1'
+      "This is now sent using iso-8859-1 character set"
+    end
+
+    get '/respond_to-mixed' do
+      respond_to do |wants|
+        wants.html { charset 'iso-8859-1'; "Some html in iso-8859-1" }
+        wants.xml { builder :utf-8-xml }    # => this is returned in the default character set
+      end
+    end
+
+## CONFIGURATION:
+
+There a few options available for configuring the default behavior of respond\_to using Sinatra's `set` utility.
+
+* **default\_content - :html**
+      When a user vists a url without an extension, for example /post this will be
+      the assumed content to serve first.  Expects a symbol as used in setting content_type.
+* **assume\_xhr\_is\_js - true**
+      To avoid headaches with accept headers, and appending .js to urls, this will
+      cause the default format for all XmlHttpRequests to be classified as wanting Javascript
+      in the response.
+
+## REQUIREMENTS:
+
+* sinatra 1.1
+
+If you would like to use Sinatra 1.0, use version `0.5.0`.
+
+## INSTALL:
+
+    $ gem install sinatra-respond_to
+
+## CAVEATS:
+Due to the way respond\_to works, all incoming requests have the extension striped from the request.path\_info. This causes routes like the following to fail.
+
+    get '/style.css' do
+      sass :style   # => renders views/style.sass
+    end
+
+They need to be changed to the following.
+
+    get '/style' do
+      sass :style   # => renders views/style.css.sass
+    end
+
+If you want to ensure the route only gets called for css requests try this.  This will use sinatra's built in accept header matching.
+
+    get '/style', :provides => :css do
+      sass :style
+    end
+
+## DEVELOPERS:
+
+After checking out the source, run:
+
+    $ bundle install
+    $ rake spec
+
+This task will install any missing dependencies, run the tests/specs, and generate the RDoc.
+
+## Contributors
+
+* [Ryan Schenk](http://github.com/rschenk/)
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009-2010 Chris Hoffman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+begin
+  require 'rspec/core/rake_task'
+  desc 'Run specs'
+  RSpec::Core::RakeTask.new do |t|
+    t.rcov = true
+    t.rcov_opts = ['--sort coverage --text-summary --sort-reverse']
+    t.rcov_opts << "--comments --exclude spec,pkg,#{ENV['GEM_HOME']}"
+  end
+rescue LoadError
+  puts 'RSpec not available, try a bundle install'
+end

data/lib/sinatra/respond_to.rb

@@ -0,0 +1,219 @@
+require 'sinatra/base'
+
+# Accept header parsing was looked at but deemed
+# too much of an irregularity to deal with.  Problems with the header
+# differences from IE, Firefox, Safari, and every other UA causes
+# problems with the expected output.  The general expected behavior
+# would be serve html when no extension provided, but most UAs say
+# they will accept application/xml with out a quality indicator, meaning
+# you'd get the xml block served insead.  Just plain retarded, use the
+# extension and you'll never be suprised.
+
+module Sinatra
+  module RespondTo
+    class UnhandledFormat < Sinatra::NotFound; end
+    class MissingTemplate < Sinatra::NotFound
+      def code; 500 end
+    end
+
+    def self.registered(app)
+      app.helpers RespondTo::Helpers
+
+      app.set :default_content, :html
+      app.set :assume_xhr_is_js, true
+
+      # We remove the trailing extension so routes
+      # don't have to be of the style
+      #
+      #   get '/resouce.:format'
+      #
+      # They can instead be of the style
+      #
+      #   get '/resource'
+      #
+      # and the format will automatically be available in <tt>format</tt>
+      app.before do
+        # Let through sinatra image urls in development
+        next if self.class.development? && request.path_info =~ %r{/__sinatra__/.*?.png}
+
+        unless options.static? && options.public? && (request.get? || request.head?) && static_file?(request.path_info)
+          if request.params.has_key? 'format'
+            format params['format']
+          else
+            # Sinatra relies on a side-effect from path_info= to
+            # determine its routes. A direct string change (e.g., sub!)
+            # would bypass that -- and fail to have the effect we're looking
+            # for.
+            request.path_info = request.path_info.sub %r{\.([^\./]+)$}, ''
+
+            # Thanks to Sinatra, users can call:
+            #
+            #    set :default_content, :foo
+            #    set :default_content, proc { :foo }
+            #    set :default_content, proc { |bar| :foo }
+            #
+            # And get the same result from options.default_content(request).
+            _format   = options.assume_xhr_is_js? ? :js : $1 if request.xhr?
+            _format ||= options.default_content(request)
+
+            format _format
+          end
+        end
+      end
+
+     app.configure :development do |dev|
+        dev.error UnhandledFormat do
+          content_type :html, :charset => 'utf-8'
+
+          (<<-HTML).gsub(/^ {10}/, '')
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <style type="text/css">
+            body { text-align:center;font-family:helvetica,arial;font-size:22px;
+              color:#888;margin:20px}
+            #c {margin:0 auto;width:500px;text-align:left}
+            </style>
+          </head>
+          <body>
+            <h2>Sinatra doesn't know this ditty.</h2>
+            <img src='/__sinatra__/404.png'>
+            <div id="c">
+              Try this:
+              <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  respond_to do |wants|\n    wants.#{format} { "Hello World" }\n  end\nend</pre>
+            </div>
+          </body>
+          </html>
+          HTML
+        end
+
+        dev.error MissingTemplate do
+          content_type :html, :charset => 'utf-8'
+          response.status = request.env['sinatra.error'].code
+
+          engine = request.env['sinatra.error'].message.split('.').last
+          engine = 'haml' unless ['haml', 'builder', 'erb'].include? engine
+
+          path = File.basename(request.path_info)
+          path = "root" if path.nil? || path.empty?
+
+          format = engine == 'builder' ? 'xml' : 'html'
+
+          layout = case engine
+                   when 'haml' then "!!!\n%html\n  %body= yield"
+                   when 'erb' then "<html>\n  <body>\n    <%= yield %>\n  </body>\n</html>"
+                   when 'builder' then "xml << yield"
+                   end
+
+          layout = "<small>app.#{format}.#{engine}</small>\n<pre>#{escape_html(layout)}</pre>"
+
+          (<<-HTML).gsub(/^ {10}/, '')
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <style type="text/css">
+            body { text-align:center;font-family:helvetica,arial;font-size:22px;
+              color:#888;margin:20px}
+            #c {margin:0 auto;width:500px;text-align:left;}
+            small {float:right;clear:both;}
+            pre {clear:both;}
+            </style>
+          </head>
+          <body>
+            <h2>Sinatra can't find #{request.env['sinatra.error'].message}</h2>
+            <img src='/__sinatra__/500.png'>
+            <div id="c">
+              Try this:<br />
+              #{layout}
+              <small>#{path}.#{format}.#{engine}</small>
+              <pre>Hello World!</pre>
+              <small>application.rb</small>
+              <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  respond_to do |wants|\n    wants.#{engine == 'builder' ? 'xml' : 'html'} { #{engine} :#{path}#{",\n#{' '*32}layout => :app" if layout} }\n  end\nend</pre>
+            </div>
+          </body>
+          </html>
+          HTML
+        end
+
+      end
+
+      app.class_eval do
+        # Changes in 1.0 Sinatra reuse render for layout so we store the
+        # original value to tell us if this is an automatic attempt to do a
+        # layout call.  If it is, it might fail with Errno::ENOENT and we want
+        # to pass that back to sinatra since it isn't a MissingTemplate error
+        alias :render_without_format :render
+        def render(*args, &block)
+          assumed_layout = args[1] == :layout
+          args[1] = "#{args[1]}.#{format}".to_sym if args[1].is_a?(::Symbol)
+          render_without_format *args, &block
+        rescue Errno::ENOENT => e
+          raise MissingTemplate, "#{args[1]}.#{args[0]}" unless assumed_layout
+          raise e
+        end
+        private :render
+      end
+    end
+
+    module Helpers
+      # Patch the content_type function to remember the set type
+      # This helps cut down on time in the format helper so it
+      # doesn't have to do a reverse lookup on the header
+      def self.included(klass)
+        klass.class_eval do
+          alias :content_type_without_save :content_type
+          def content_type(*args)
+            @_format = args.first.to_sym
+            content_type_without_save *args
+          end
+        end
+      end
+
+      def format(val=nil)
+        unless val.nil?
+          mime_type = ::Sinatra::Base.mime_type(val)
+          fail "Unknown media type #{val}\nTry registering the extension with a mime type" if mime_type.nil?
+
+          @_format = val.to_sym
+          response['Content-Type'] ? response['Content-Type'].sub!(/^[^;]+/, mime_type) : content_type(@_format)
+        end
+
+        @_format
+      end
+
+      # This is mostly just a helper so request.path_info isn't changed when
+      # serving files from the public directory
+      def static_file?(path)
+        public_dir = File.expand_path(options.public)
+        path = File.expand_path(File.join(public_dir, unescape(path)))
+
+        path[0, public_dir.length] == public_dir && File.file?(path)
+      end
+
+      def charset(val=nil)
+        fail "Content-Type must be set in order to specify a charset" if response['Content-Type'].nil?
+
+        if response['Content-Type'] =~ /charset=[^;]+/
+          response['Content-Type'].sub!(/charset=[^;]+/, (val == '' && '') || "charset=#{val}")
+        else
+          response['Content-Type'] += ";charset=#{val}"
+        end unless val.nil?
+
+        response['Content-Type'][/charset=([^;]+)/, 1]
+      end
+
+      def respond_to(&block)
+        wants = {}
+        def wants.method_missing(type, *args, &handler)
+          ::Sinatra::Base.send(:fail, "Unknown media type for respond_to: #{type}\nTry registering the extension with a mime type") if ::Sinatra::Base.mime_type(type).nil?
+          self[type] = handler
+        end
+
+        yield wants
+
+        raise UnhandledFormat  if wants[format].nil?
+        wants[format].call
+      end
+    end
+  end
+end

data/lib/sinatra/respond_to/version.rb

@@ -0,0 +1,5 @@
+module Sinatra
+  module RespondTo
+    Version = '0.6.0'
+  end
+end

data/sinatra-respond_to.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sinatra/respond_to/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'tobias-sinatra-respond_to'
+  s.version     = Sinatra::RespondTo::Version
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Chris Hoffman']
+  s.email       = ['cehoffman@gmail.com']
+  s.homepage    = 'http://github.com/cehoffman/sinatra-respond_to'
+  s.summary     = 'A respond_to style Rails block for baked-in web service support in Sinatra'
+
+  s.required_rubygems_version = '>= 1.3.6'
+
+  s.add_runtime_dependency 'sinatra', '~> 1.1'
+
+  s.add_development_dependency 'rspec', '~> 2.0.1'
+  s.add_development_dependency 'rack-test', '~> 0.5.6'
+  s.add_development_dependency 'rcov', '~> 0.9.8'
+  s.add_development_dependency 'builder', '>= 2.0'
+  s.add_development_dependency 'haml', '>= 2.0'
+  s.add_development_dependency 'bundler', '~> 1.0.0'
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables  = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_path = 'lib'
+end

data/spec/app/production_error_app.rb

@@ -0,0 +1,9 @@
+class ProductionErrorApp < Sinatra::Base
+  set :environment, :production
+  register Sinatra::RespondTo
+  get '/missing-template' do
+    respond_to do |wants|
+      wants.html { haml :missing }
+    end
+  end
+end

data/spec/app/public/static.txt

@@ -0,0 +1 @@
+A static file

data/spec/app/test_app.rb

@@ -0,0 +1,55 @@
+require 'sinatra/base'
+require 'erb'
+require 'haml'
+require 'sass'
+require 'builder'
+
+class TestApp < Sinatra::Base
+  register Sinatra::RespondTo
+
+  set :views, File.join(File.dirname(__FILE__), 'views')
+  set :public, File.join(File.dirname(__FILE__), 'public')
+
+  get '/resource' do
+    respond_to do |wants|
+      wants.html { haml :resource }
+      wants.json { "We got some json" }
+      wants.xml { builder :resource }
+      wants.js { erb :resource }
+      wants.png { }
+    end
+  end
+
+  get '/default_charset' do
+    respond_to do |wants|
+      wants.html { "Should set charcter set to default_charset" }
+    end
+  end
+
+  get '/iso-8859-1' do
+    respond_to do |wants|
+      wants.html { charset 'iso-8859-1'; "Should have character set of iso-8859-1" }
+    end
+  end
+
+  get '/normal-no-respond_to' do
+    "Just some plain old text"
+  end
+
+  get '/style.css' do
+    "This route should fail"
+  end
+
+  get '/style-no-extension', :provides => :css do
+    "Should succeed only when browser accepts text/css"
+  end
+
+  get '/missing-template' do
+    respond_to do |wants|
+      wants.html { haml :missing }
+      wants.xml { builder :missing }
+      wants.js { erb :missing }
+      wants.css { sass :missing }
+    end
+  end
+end

data/spec/app/unreachable_static.txt

@@ -0,0 +1 @@
+Unreachable static file

data/spec/app/views/layout.html.haml

@@ -0,0 +1,2 @@
+%html
+  %body= yield

data/spec/app/views/resource.html.haml

@@ -0,0 +1 @@
+Hello from HTML

data/spec/app/views/resource.js.erb

@@ -0,0 +1,3 @@
+$(function () {
+  return '<%= "Hiya from javascript" %>'
+});

data/spec/app/views/resource.xml.builder

@@ -0,0 +1 @@
+xml.root "Some XML"

data/spec/extension_spec.rb

@@ -0,0 +1,382 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Sinatra::RespondTo do
+  def mime_type(sym)
+    ::Sinatra::Base.mime_type(sym)
+  end
+
+  describe "options" do
+    it "should initialize with :default_content set to :html" do
+      TestApp.default_content.should == :html
+    end
+
+    it "should initialize with :assume_xhr_is_js set to true" do
+      TestApp.assume_xhr_is_js == true
+    end
+  end
+
+  describe "assume_xhr_is_js" do
+    it "should set the content type to application/javascript for an XMLHttpRequest" do
+      header 'X_REQUESTED_WITH', 'XMLHttpRequest'
+
+      get '/resource'
+
+      last_response['Content-Type'].should =~ %r{#{mime_type(:js)}}
+    end
+
+    it "should not set the content type to application/javascript for an XMLHttpRequest when assume_xhr_is_js is false" do
+      TestApp.disable :assume_xhr_is_js
+      header 'X_REQUESTED_WITH', 'XMLHttpRequest'
+      get '/resource'
+
+      last_response['Content-Type'].should_not =~ %r{#{mime_type(:js)}}
+
+      # Put back the option, no side effects here
+      TestApp.enable :assume_xhr_is_js
+    end
+  end
+
+  describe "extension routing" do
+    it "should use a format parameter before sniffing out the extension" do
+      get "/resource?format=xml"
+      last_response.body.should =~ %r{\s*<root>Some XML</root>\s*}
+    end
+    
+    it "breaks routes expecting an extension" do
+      # In test_app.rb the route is defined as get '/style.css' instead of get '/style'
+      get "/style.css"
+
+      last_response.should_not be_ok
+    end
+
+    it "should pick the default content option for routes with out an extension, and render haml templates" do
+      get "/resource"
+
+      last_response.body.should =~ %r{\s*<html>\s*<body>Hello from HTML</body>\s*</html>\s*}
+    end
+
+    it "should render for a template using builder" do
+      get "/resource.xml"
+
+      last_response.body.should =~ %r{\s*<root>Some XML</root>\s*}
+    end
+
+    it "should render for a template using erb" do
+      get "/resource.js"
+
+      last_response.body.should =~ %r{'Hiya from javascript'}
+    end
+
+    it "should return string literals in block" do
+      get "/resource.json"
+
+      last_response.body.should =~ %r{We got some json}
+    end
+
+    # This will fail if the above is failing
+    it "should set the appropriate content-type for route with an extension" do
+      get "/resource.xml"
+
+      last_response['Content-Type'].should =~ %r{#{mime_type(:xml)}}
+    end
+
+    it "should honor a change in character set in block" do
+      get "/iso-8859-1"
+
+      last_response['Content-Type'].should =~ %r{charset=iso-8859-1}
+    end
+
+    it "should return not found when path does not exist" do
+      get "/nonexistant-path.txt"
+
+      last_response.status.should == 404
+    end
+
+    describe "for static files" do
+      before(:all) do
+        TestApp.enable :static
+      end
+
+      after(:all) do
+        TestApp.disable :static
+      end
+
+      it "should allow serving static files from public directory" do
+        get '/static.txt'
+
+        last_response.body.should == "A static file"
+      end
+
+      it "should only serve files when static routing is enabled" do
+        TestApp.disable :static
+        get '/static.txt'
+
+        last_response.should_not be_ok
+        last_response.body.should_not == "A static file"
+
+        TestApp.enable :static
+      end
+
+      it "should not allow serving static files from outside the public directory" do
+        get '/../unreachable_static.txt'
+
+        last_response.should_not be_ok
+        last_response.body.should_not == "Unreachable static file"
+      end
+    end
+  end
+
+  describe "routes not using respond_to" do
+    it "should set the default content type when no extension" do
+      get "/normal-no-respond_to"
+
+      last_response['Content-Type'].should =~ %r{#{mime_type(TestApp.default_content)}}
+    end
+
+    it "should set the appropriate content type when given an extension" do
+      get "/normal-no-respond_to.css"
+
+      last_response['Content-Type'].should =~ %r{#{mime_type(:css)}}
+    end
+  end
+
+  describe "error pages in production" do
+    before(:each) do
+      @app = Rack::Builder.new { run ::ProductionErrorApp }
+    end
+
+    describe Sinatra::RespondTo::MissingTemplate do
+      it "should return 404 status when looking for a missing template in production" do
+        get '/missing-template'
+
+        last_response.status.should == 404
+        last_response.body.should_not =~ /Sinatra can't find/
+      end
+    end
+
+    describe Sinatra::RespondTo::UnhandledFormat do
+      it "should return with a 404 when an extension is not supported in production" do
+        get '/missing-template.txt'
+
+        last_response.status.should == 404
+        last_response.body.should_not =~ /respond_to/
+      end
+    end
+  end
+
+  describe "error pages in development:" do
+
+    it "should allow access to the /__sinatra__/*.png images" do
+      get '/__sinatra__/404.png'
+
+      last_response.should be_ok
+    end
+
+    describe Sinatra::RespondTo::MissingTemplate do
+      it "should return 500 status when looking for a missing template" do
+        get '/missing-template'
+
+        last_response.status.should == 500
+      end
+
+      it "should provide a helpful generic error message for a missing template when in development" do
+        get '/missing-template.css'
+
+        last_response.body.should =~ /missing-template\.html\.haml/
+        last_response.body.should =~ %r{get '/missing-template' do respond_to do |wants| wants.html \{ haml :missing-template, layout => :app \} end end}
+      end
+
+      it "should show the /__sinatra__/500.png" do
+        get '/missing-template'
+
+        last_response.body.should =~ %r{src='/__sinatra__/500.png'}
+      end
+
+      it "should provide a contextual code example for the template engine" do
+        # Haml
+        get '/missing-template'
+
+        last_response.body.should =~ %r{app.html.haml}
+        last_response.body.should =~ %r{missing-template.html.haml}
+        last_response.body.should =~ %r{get '/missing-template' do respond_to do |wants| wants.html \{ haml :missing-template, layout => :app \} end end}
+
+        # ERB
+        get '/missing-template.js'
+
+        last_response.body.should =~ %r{app.html.erb}
+        last_response.body.should =~ %r{missing-template.html.erb}
+        last_response.body.should =~ %r{get '/missing-template' do respond_to do |wants| wants.html \{ erb :missing-template, layout => :app \} end end}
+
+        # Builder
+        get '/missing-template.xml'
+
+        last_response.body.should =~ %r{app.xml.builder}
+        last_response.body.should =~ %r{missing-template.xml.builder}
+        last_response.body.should =~ %r{get '/missing-template' do respond_to do |wants| wants.xml \{ builder :missing-template, layout => :app \} end end}
+      end
+    end
+
+    describe Sinatra::RespondTo::UnhandledFormat do
+      it "should return with a 404 when an extension is not supported" do
+        get '/missing-template.txt'
+
+        last_response.status.should == 404
+      end
+
+      it "should provide a helpful error message for an unhandled format" do
+        get '/missing-template.txt'
+
+        last_response.body.should =~ %r{get '/missing-template' do respond_to do |wants| wants.txt \{ "Hello World" \} end end}
+      end
+
+      it "should show the /__sinatra__/404.png" do
+        get '/missing-template.txt'
+
+        last_response.body.should =~ %r{src='/__sinatra__/404.png'}
+      end
+    end
+  end
+
+  describe "helpers:" do
+    include Sinatra::Helpers
+    include Sinatra::RespondTo::Helpers
+
+    before(:each) do
+      stub!(:response).and_return({'Content-Type' => 'text/html'})
+    end
+
+    describe "charset" do
+      it "should set the working charset when called with a non blank string" do
+        response['Content-Type'].should_not =~ /charset/
+
+        charset 'utf-8'
+
+        response['Content-Type'].split(';').should include("charset=utf-8")
+      end
+
+      it "should remove the charset when called with a blank string" do
+        charset 'utf-8'
+        charset ''
+
+        response['Content-Type'].should_not =~ /charset/
+      end
+
+      it "should return the current charset when called with nothing" do
+        charset 'utf-8'
+
+        charset.should == 'utf-8'
+      end
+
+      it "should fail when the response does not have a Content-Type" do
+        response.delete('Content-Type')
+
+        lambda { charset }.should raise_error
+      end
+
+      it "should not modify the Content-Type when given no argument" do
+        response['Content-Type'] = "text/html;charset=iso-8859-1"
+
+        charset
+
+        response['Content-Type'].should == "text/html;charset=iso-8859-1"
+      end
+    end
+
+    describe "format" do
+      before(:each) do
+        stub!(:request).and_return(Sinatra::Request.new({}))
+      end
+
+      it "should set the correct mime type when given an extension" do
+        format :xml
+
+        response['Content-Type'].split(';').should include(mime_type(:xml))
+      end
+
+      it "should fail when set to an unknown extension type" do
+        lambda { format :bogus }.should raise_error
+      end
+
+      it "should return the current mime type extension" do
+        format :js
+
+        format.should == :js
+      end
+
+      it "should not modify the Content-Type when given no argument" do
+        response['Content-Type'] = "application/xml;charset=utf-8"
+
+        format
+
+        response['Content-Type'].should == "application/xml;charset=utf-8"
+      end
+
+      it "should not return nil when only content_type sets headers" do
+        settings = mock('settings')
+        settings.should_receive(:default_encoding).and_return('utf-8')
+        stub!(:settings).and_return(settings)
+
+        content_type :xhtml
+
+        format.should == :xhtml
+      end
+    end
+
+    describe "static_file?" do
+      before(:all) do
+        TestApp.enable :static
+        @static_folder = "/static folder/"
+        @reachable_static_file = "/static.txt"
+        @unreachable_static_file = "/../unreachable_static.txt"
+      end
+
+      after(:all) do
+        TestApp.disable :static
+      end
+
+      def options
+        TestApp
+      end
+
+      def unescape(path)
+        Rack::Utils.unescape(path)
+      end
+
+      it "should return true if the request path points to a file in the public directory" do
+        static_file?(@reachable_static_file).should be_true
+      end
+
+      it "should return false when pointing to files outside of the public directory" do
+        static_file?(@unreachable_static_file).should be_false
+      end
+
+      it "should return false when the path is for a folder" do
+        static_file?(@static_folder).should be_false
+      end
+    end
+
+    describe "respond_to" do
+      before(:each) do
+        stub!(:request).and_return(Sinatra::Request.new({}))
+      end
+
+      it "should fail for an unknown extension" do
+        lambda do
+          respond_to do |wants|
+            wants.bogus
+          end
+        end.should raise_error
+      end
+
+      it "should call the block corresponding to the current format" do
+        format :html
+
+        respond_to do |wants|
+          wants.js { "Some JS" }
+          wants.html { "Some HTML" }
+          wants.xml { "Some XML" }
+        end.should == "Some HTML"
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+#$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+require 'rack/test'
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'sinatra', 'respond_to')
+require File.join(File.dirname(__FILE__), 'app', 'test_app')
+require File.join(File.dirname(__FILE__), 'app', 'production_error_app')
+
+RSpec.configure do |config|
+  def app
+    @app ||= ::Rack::Builder.new do
+      run ::TestApp
+    end
+  end
+
+  config.include ::Rack::Test::Methods
+end

metadata

@@ -0,0 +1,208 @@
+--- !ruby/object:Gem::Specification 
+name: tobias-sinatra-respond_to
+version: !ruby/object:Gem::Version 
+  hash: 7
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 0
+  version: 0.6.0
+platform: ruby
+authors: 
+- Chris Hoffman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-10 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 1
+        version: "1.1"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 2
+        - 0
+        - 1
+        version: 2.0.1
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 5
+        - 6
+        version: 0.5.6
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: haml
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id007
+description: 
+email: 
+- cehoffman@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Changelog.rdoc
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/sinatra/respond_to.rb
+- lib/sinatra/respond_to/version.rb
+- sinatra-respond_to.gemspec
+- spec/app/production_error_app.rb
+- spec/app/public/static folder/.keep
+- spec/app/public/static.txt
+- spec/app/test_app.rb
+- spec/app/unreachable_static.txt
+- spec/app/views/layout.html.haml
+- spec/app/views/resource.html.haml
+- spec/app/views/resource.js.erb
+- spec/app/views/resource.xml.builder
+- spec/extension_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/cehoffman/sinatra-respond_to
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A respond_to style Rails block for baked-in web service support in Sinatra
+test_files: 
+- spec/app/production_error_app.rb
+- spec/app/public/static folder/.keep
+- spec/app/public/static.txt
+- spec/app/test_app.rb
+- spec/app/unreachable_static.txt
+- spec/app/views/layout.html.haml
+- spec/app/views/resource.html.haml
+- spec/app/views/resource.js.erb
+- spec/app/views/resource.xml.builder
+- spec/extension_spec.rb
+- spec/spec_helper.rb