cehoffman-sinatra-respond_to 0.3.3 → 0.3.4

data/README.markdown

@@ -5,10 +5,10 @@
 
     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
@@ -18,7 +18,7 @@
 
     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
@@ -26,10 +26,10 @@
         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
@@ -37,6 +37,20 @@
       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
@@ -61,16 +75,17 @@ Due to the way respond\_to works, all incoming requests have the extension strip
 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
+
+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
+
+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

data/Rakefile

@@ -11,4 +11,20 @@ begin
   end
 rescue LoadError
   puts "Jewler not available.  Install it with sugo gem install technicalpickles-jeweler -s http://gems.github.com"
+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' << '.gem,pkg,spec'
+  end
+rescue LoadError
+  puts "RSpec not available. Install it with sudo gem install rspec."
 end

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 3
+:patch: 4
 :major: 0
 :minor: 3

data/lib/sinatra/respond_to.rb

@@ -1,3 +1,5 @@
+require 'sinatra/base'
+
 # Simple note, accept header parsing was looked at but deamed
 # too much of an irregularity to deal with.  Problems with the header
 # differences from IE, Firefox, Safari, and every other UA causes
@@ -38,12 +40,14 @@ module Sinatra
       #
       # and the format will automatically be available in as <tt>format</tt>
       app.before do
-        unless options.static? && options.public? && ["GET", "HEAD"].include?(request.request_method) && static_file?(unescape(request.path_info))
+        unless options.static? && options.public? && ["GET", "HEAD"].include?(request.request_method) && static_file?(request.path_info)
           request.path_info.gsub! %r{\.([^\./]+)$}, ''
           format $1 || options.default_content
 
           # For the oh so common case of actually wanting Javascript from an XmlHttpRequest
           format :js if request.xhr? && options.assume_xhr_is_js?
+
+          charset options.default_charset if TEXT_MIME_TYPES.include? format
         end
       end
 
@@ -89,18 +93,23 @@ module Sinatra
 
         app.error MissingTemplate do
           content_type :html, :charset => 'utf-8'
+          response.status = 500 # If I can find out how to reference the error code from the exception, I would
 
           engine = request.env['sinatra.error'].message[/\.([^\.]+)$/, 1]
+          engine = 'haml' unless ['haml', 'builder', 'erb'].include? engine
+          
           path = request.path_info[/([^\/]+)$/, 1]
           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.html.#{engine}</small>\n<pre>#{escape_html(layout)}</pre>" if layout
+          layout = "<small>app.#{format}.#{engine}</small>\n<pre>#{escape_html(layout)}</pre>"
 
           (<<-HTML).gsub(/^ {10}/, '')
           <!DOCTYPE html>
@@ -120,7 +129,7 @@ module Sinatra
             <div id="c">
               Try this:<br />
               #{layout if layout}
-              <small>#{path}.html.#{engine}</small>
+              <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>
@@ -135,7 +144,7 @@ module Sinatra
       app.class_eval do
         private
           def render_with_format(*args)
-            args[1] = "#{args[1]}.#{format}".to_sym
+            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]}"
@@ -154,23 +163,43 @@ module Sinatra
 
     module Helpers
       def format(val=nil)
-        request.env['sinatra.respond_to.format'] = val.to_sym unless val.nil?
+        unless val.nil?
+          new_mime_type = media_type(val.to_sym)
+          fail "Unknown media type #{val}\nTry registering the extension with a mime type" if new_mime_type.nil?
+
+          request.env['sinatra.respond_to.format'] = val.to_sym
+          old_mime_type, params = response['Content-Type'].split(';', 2)
+          response['Content-Type'] = [new_mime_type, params].join(';')
+        end
+
         request.env['sinatra.respond_to.format']
       end
 
       def static_file?(path)
         return false unless path =~ /.*[^\/]$/
         public_dir = File.expand_path(options.public)
-        path = File.expand_path(File.join(public_dir, unescape(request.path_info)))
+        path = File.expand_path(File.join(public_dir, unescape(path)))
         return false if path[0, public_dir.length] != public_dir
-        return false unless File.file?(path)
-        true
+        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'].gsub!(/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, &block)
           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?
+          options = args.pop if args.last.is_a?(::Hash)
           self[type] = block
         end
 
@@ -178,12 +207,6 @@ module Sinatra
 
         handler = wants[format]
         raise UnhandledFormat  if handler.nil?
-
-        opts = [format]
-        opts << {:charset => options.default_charset} if TEXT_MIME_TYPES.include? format && response['Content-Type'] !~ /charset=/
-
-        content_type *opts
-
         handler.call
       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,3 @@
+builder do |xml|
+  xml.root "Some XML"
+end

data/spec/extension_spec.rb

@@ -0,0 +1,340 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Sinatra::RespondTo do
+  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 be_true
+    end
+  end
+
+  describe "assume_xhr_is_js" do
+    it "should set the content type to application/javascript for an XMLHttpRequest" do
+      header 'HTTP_X_REQUESTED_WITH', 'XMLHttpRequest'
+
+      get '/resource'
+
+      last_response['Content-Type'].should =~ %r{#{Rack::Mime.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 'HTTP_X_REQUESTED_WITH', 'XMLHttpRequest'
+      get '/resource'
+
+      last_response['Content-Type'].should_not =~ %r{#{Rack::Mime.mime_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{#{Rack::Mime.mime_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{#{Rack::Mime.mime_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{#{Rack::Mime.mime_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{#{Rack::Mime.mime_type(".css")}}
+    end
+  end
+
+  describe "error pages in development:" do
+    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 return 500 status when looking for a missing template in production" do
+        TestApp.set :environment, :production
+        get '/missing-template'
+
+        last_response.status.should == 500
+
+        TestApp.set :environment, :development
+      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 return with a 404 when an extension is not support in production" do
+        TestApp.set :environment, :production
+        get '/missing-template.txt'
+
+        last_response.status.should == 404
+
+        TestApp.set :environment, :development
+      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
+    end
+
+    describe "format" do
+      before(:each) do
+        stub!(:request).and_return(Rack::Request.new({}))
+      end
+
+      def media_type(sym)
+        Sinatra::Base.media_type(sym)
+      end
+
+      it "should set the correct mime type when given an extension" do
+        format :xml
+
+        response['Content-Type'].split(';').should include(Rack::Mime.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
+    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
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+#$:.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')
+
+Spec::Runner.configure do |config|
+  def app
+    @app = Rack::Builder.new do
+      run TestApp
+    end
+  end
+
+  config.include Rack::Test::Methods
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cehoffman-sinatra-respond_to
 version: !ruby/object:Gem::Version 
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors: 
 - Chris Hoffman
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-12 00:00:00 -07:00
+date: 2009-05-13 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -37,6 +37,15 @@ files:
 - Rakefile
 - VERSION.yml
 - lib/sinatra/respond_to.rb
+- 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
 post_install_message: 
@@ -63,5 +72,7 @@ rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: A respond_to style Rails block for baked-in web service support in Sinatra
-test_files: []
-
+test_files: 
+- spec/app/test_app.rb
+- spec/extension_spec.rb
+- spec/spec_helper.rb