sinatra-respond_to 0.3.8

data/Changelog.rdoc

@@ -0,0 +1,62 @@
+=== 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/Manifest.txt

@@ -0,0 +1,17 @@
+Changelog.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+lib/sinatra/respond_to.rb
+lib/sinatra/respond_to/version.rb
+spec/spec_helper.rb
+spec/extension_spec.rb
+spec/app/production_error_app.rb
+spec/app/test_app.rb
+spec/app/unreachable_static.txt
+spec/app/public/static.txt
+spec/app/public/static folder/.keep
+spec/app/views/layout.html.haml
+spec/app/views/resource.html.haml
+spec/app/views/resource.js.erb
+spec/app/views/resource.xml.builder

data/README.rdoc

@@ -0,0 +1,151 @@
+= 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 charset for appropriate types
+* Handles setting the content type depending on what is being served
+* Automatically can adjust XMLHttpRequests to return Javascript
+
+== SYNOPSIS:
+
+    require 'sinatra'
+    require 'sinatra/respond_to'
+
+    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 <tt>charset</tt> 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
+<tt>set</tt> utility.
+
+* <tt>default\_charset - utf-8</tt>
+    Assumes all text documents are encoded using this character set.
+    This can be overridden within the respond_to block for the appropriate format
+* <tt>default\_content - :html</tt>
+    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.
+* <tt>assume\_xhr\_is\_js - true</tt>
+    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 0.9.4 - 0.10
+
+== 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
+      content_type :css, :charset => 'utf-8'
+      sass :style   # => renders views/style.sass
+    end
+
+They need to be changed to the following.  Note that you no longer have to set the content\_type or charset.
+
+    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:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== ISSUES
+
+Sinatra has a bug that affects Classic style applications and extensions see 215[https://sinatra.lighthouseapp.com/projects/9779/tickets/215-extensions-cannot-define-before-filters-for-classic-apps] and 180[https://sinatra.lighthouseapp.com/projects/9779/tickets/180-better-route-inheritence].
+I have worked around this by explicitly registering RespondTo with the top level Sinatra::Application when
+requiring sinatra/respond\_to.
+
+* {Extensions cannot define before filters for classic apps}[https://sinatra.lighthouseapp.com/projects/9779/tickets/215-extensions-cannot-define-before-filters-for-classic-apps]
+* {Better route inheritence}[https://sinatra.lighthouseapp.com/projects/9779/tickets/180-better-route-inheritence]
+
+== 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,42 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require File.expand_path(File.join('.', 'lib', 'sinatra', 'respond_to', 'version'))
+
+Hoe.plugin :gemcutter
+Hoe.plugin :clean
+Hoe.plugin :git
+
+Hoe.spec 'sinatra-respond_to' do
+  developer('Chris Hoffman', 'cehoffman@gmail.com')
+  extra_deps << ['sinatra', '>= 0.9.4']
+  extra_dev_deps << ['hoe', '>= 2.5.0']
+  extra_dev_deps << ['rspec', '>= 1.3.0']
+  extra_dev_deps << ['rcov', '>= 0.9.7.1']
+  extra_dev_deps << ['rack-test', '>= 0.5.3']
+  extra_dev_deps << ['haml', ">= 2.0"]
+  extra_dev_deps << ['builder', '>= 2.0']
+  self.readme_file = 'README.rdoc'
+  self.history_file = 'Changelog.rdoc'
+  self.test_globs = 'spec/*_spec.rb'
+  self.version = ::Sinatra::RespondTo::Version
+end
+
+begin
+  require 'spec/rake/spectask'
+  desc "Run specs"
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_files = FileList['spec/*_spec.rb']
+    t.spec_opts = %w(-fp --color)
+
+    t.rcov = true
+    t.rcov_opts << '--text-summary'
+    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+    t.rcov_opts << '--exclude' << 'pkg,spec'
+  end
+rescue LoadError
+  puts "RSpec not available. Install it with sudo gem install rspec."
+end
+
+# vim: syntax=ruby

data/lib/sinatra/respond_to.rb

@@ -0,0 +1,206 @@
+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
+
+    TEXT_MIME_TYPES = [:txt, :html, :js, :json, :xml, :rss, :atom, :css, :asm, :c, :cc, :conf,
+                       :csv, :cxx, :diff, :dtd, :f, :f77, :f90, :for, :gemspec, :h, :hh, :htm,
+                       :log, :mathml, :mml, :p, :pas, :pl, :pm, :py, :rake, :rb, :rdf, :rtf, :ru,
+                       :s, :sgm, :sgml, :sh, :svg, :svgz, :text, :wsdl, :xhtml, :xsl, :xslt, :yaml,
+                       :yml, :ics]
+
+    def self.registered(app)
+      app.helpers RespondTo::Helpers
+
+      app.set :default_charset, 'utf-8'
+      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
+        unless options.static? && options.public? && (request.get? || request.head?) && static_file?(request.path_info)
+          request.path_info.sub! %r{\.([^\./]+)$}, ''
+
+          format request.xhr? && options.assume_xhr_is_js? ? :js : $1 || options.default_content
+
+          charset options.default_charset if Sinatra::RespondTo::TEXT_MIME_TYPES.include? format
+        end
+      end
+
+     app.configure :development do |dev|
+        # Very, very, very hackish but only for development at least
+        # Modifies the regex matching /__sinatra__/:image.png to not have the extension
+        ["GET", "HEAD"].each do |verb|
+          dev.routes[verb][1][0] = Regexp.new(dev.routes[verb][1][0].source.gsub(/\\\.[^\.\/]+\$$/, '$'))
+        end
+
+        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 "builder do |xml|\n  xml << yield\nend"
+                   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
+        private
+          def render_with_format(*args)
+            args[1] = "#{args[1]}.#{format}".to_sym if args[1].is_a?(::Symbol)
+            render_without_format *args
+          rescue Errno::ENOENT
+            raise MissingTemplate, "#{args[1]}.#{args[0]}"
+          end
+          alias_method :render_without_format, :render
+          alias_method :render, :render_with_format
+
+          def lookup_layout_with_format(*args)
+            args[1] = "#{args[1]}.#{format}".to_sym if args[1].is_a?(::Symbol)
+            lookup_layout_without_format *args
+          end
+          alias_method :lookup_layout_without_format, :lookup_layout
+          alias_method :lookup_layout, :lookup_layout_with_format
+      end
+    end
+
+    module Helpers
+      def format(val=nil)
+        unless val.nil?
+          mime_type = media_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'].sub!(/^[^;]+/, mime_type)
+        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.media_type(type).nil?
+          self[type] = handler
+        end
+
+        yield wants
+
+        raise UnhandledFormat  if wants[format].nil?
+        wants[format].call
+      end
+    end
+  end
+
+  # Get around before filter problem for classic applications by registering
+  # with the context they are run in explicitly instead of Sinatra::Default
+  Sinatra::Application.register RespondTo
+end

data/lib/sinatra/respond_to/version.rb

@@ -0,0 +1,5 @@
+module Sinatra
+  module RespondTo
+    Version = '0.3.8'
+  end
+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,53 @@
+require 'sinatra/base'
+require 'erb'
+require 'haml'
+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 }
+    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,393 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Sinatra::RespondTo do
+  def media_type(sym)
+    Sinatra::Base.media_type(sym)
+  end
+
+  describe "options" do
+    it "should initialize with :default_charset set to 'utf-8'" do
+      TestApp.default_charset.should == 'utf-8'
+    end
+
+    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{#{media_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{#{media_type(:js)}}
+
+      # Put back the option, no side effects here
+      TestApp.enable :assume_xhr_is_js
+    end
+  end
+
+  describe "extension routing" do
+    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{#{media_type(:xml)}}
+    end
+
+    it "should set the character set to the default character set" do
+      get "/default_charset"
+
+      last_response['Content-Type'].should =~ %r{charset=#{TestApp.default_charset}}
+    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 not set the character set when requesting a non text resource" do
+      get "/resource.png"
+
+      last_response['Content-Type'].should_not =~ /charset/
+    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{#{media_type(TestApp.default_content)}}
+    end
+
+    it "should set the default character when no extension" do
+      get "/normal-no-respond_to"
+
+      last_response['Content-Type'].should =~ %r{charset=#{TestApp.default_charset}}
+    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{#{media_type(:css)}}
+    end
+
+    it "should set the default charset when given an extension" do
+      get "/normal-no-respond_to.css"
+
+      last_response['Content-Type'].should =~ %r{charset=#{TestApp.default_charset}}
+    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 error message for a missing template when in development" do
+        get '/missing-template'
+
+        last_response.body.should =~ /missing\.html\.haml/
+      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::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(media_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
+    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,19 @@
+#$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'spec'
+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')
+
+Spec::Runner.configure do |config|
+  def app
+    @app ||= ::Rack::Builder.new do
+      run ::TestApp
+    end
+  end
+
+  config.include ::Rack::Test::Methods
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification 
+name: sinatra-respond_to
+version: !ruby/object:Gem::Version 
+  version: 0.3.8
+platform: ruby
+authors: 
+- Chris Hoffman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-30 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: gemcutter
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.7.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: haml
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+    version: 
+description: A respond_to style Rails block for baked-in web service support in Sinatra
+email: 
+- cehoffman@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+files: 
+- Changelog.rdoc
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/sinatra/respond_to.rb
+- lib/sinatra/respond_to/version.rb
+- spec/spec_helper.rb
+- spec/extension_spec.rb
+- spec/app/production_error_app.rb
+- spec/app/test_app.rb
+- spec/app/unreachable_static.txt
+- spec/app/public/static.txt
+- spec/app/public/static folder/.keep
+- spec/app/views/layout.html.haml
+- spec/app/views/resource.html.haml
+- spec/app/views/resource.js.erb
+- spec/app/views/resource.xml.builder
+has_rdoc: true
+homepage: http://www.github.com/cehoffman/sinatra-respond_to
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: sinatra-respond_to
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A respond_to style Rails block for baked-in web service support in Sinatra
+test_files: 
+- spec/extension_spec.rb