cehoffman-sinatra-respond_to 0.3.1

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2009 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/README.markdown

@@ -0,0 +1,88 @@
+## About
+
+
+## Examples
+
+    require 'sinatra'
+    require 'sinatra/respond_to'
+    register Sinatra::RespondTo         # => Due to bug in sinatra for classic applications and extensions, see Issues
+    
+    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
+
+## 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><br />
+    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><br />
+    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><br />
+    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.
+
+## Installing
+    sudo gem install cehoffman-sinatra-respond_to --source=http://gems.github.com
+
+## Cavaets
+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
+
+    get '/style', :provides => :css do
+      sass :style
+    end
+
+## Issues
+
+Sinatra has a bug that affects Classic style applications and extensions see [#215][215] and [#180][180].
+For this reason you'll have explicitly register Sinatra::RespondTo for classic applications just like for
+non-classic applications.
+
+[215]: https://sinatra.lighthouseapp.com/projects/9779/tickets/215-extensions-cannot-define-before-filters-for-classic-apps "Extensions cannot define before filters for classic apps"
+[180]: https://sinatra.lighthouseapp.com/projects/9779/tickets/180-better-route-inheritence "Better route inheritence"
+

data/Rakefile

@@ -0,0 +1,14 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |spec|
+    spec.name = 'sinatra-respond_to'
+    spec.summary = 'A respond_to style Rails block for baked-in web service support in Sinatra'
+    spec.email = 'cehoffman@gmail.com'
+    spec.homepage = 'http://github.com/cehoffman/sinatra-respond_to'
+    spec.description = spec.summary
+    spec.authors = ["Chris Hoffman"]
+    spec.add_dependency('sinatra', '>=0.9.1.3')
+  end
+rescue LoadError
+  puts "Jewler not available.  Install it with sugo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

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

data/lib/sinatra/respond_to.rb

@@ -0,0 +1,185 @@
+# 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
+# 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' unless app.respond_to?(:default_charset)
+      app.set :default_content, :html unless app.respond_to?(:default_content)
+      app.set :assume_xhr_is_js, true unless app.respond_to?(:assume_xhr_is_js)
+
+      # 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 as <tt>format</tt>
+      app.before do
+        unless options.static? && options.public? && ["GET", "HEAD"].include?(request.request_method) && static_file?(unescape(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?
+        end
+      end
+
+      # Replace all routes that have an ending extension with one that doesn't
+      # Most generally a fix for the __sinatra__ routes in development
+      # app.routes.each_pair do |verb, subroutes|
+      #   subroutes.each do |subroute|
+      #     subroute[0] = Regexp.new(subroute[0].source.gsub(/\\\.[^\.\/]+\$$/, '$'))
+      #   end
+      # end
+
+     app.configure :development do
+        # 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|
+          app.routes[verb][1][0] = Regexp.new(app.routes[verb][1][0].source.gsub(/\\\.[^\.\/]+\$$/, '$'))
+        end
+
+        app.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
+
+        app.error MissingTemplate do
+          content_type :html, :charset => 'utf-8'
+
+          engine = request.env['sinatra.error'].message[/\.([^\.]+)$/, 1]
+          path = request.path_info[/([^\/]+)$/, 1]
+
+          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
+
+          (<<-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 if layout}
+              <small>#{path}.html.#{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 lookup_template_with_format(*args)
+            args[1] = "#{args[1]}.#{format}".to_sym
+            lookup_template_without_format *args
+          rescue Errno::ENOENT
+            raise MissingTemplate, "#{args[1]}.#{args[0]}"
+          end
+          alias_method :lookup_template_without_format, :lookup_template
+          alias_method :lookup_template, :lookup_template_with_format
+      end
+    end
+
+    module Helpers
+      def format(val=nil)
+        request.env['sinatra.respond_to.format'] = val.to_sym unless val.nil?
+        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)))
+        return false if path[0, public_dir.length] != public_dir
+        return false unless File.file?(path)
+        true
+      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?
+          self[type] = block
+        end
+
+        yield wants
+
+        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
+  end
+
+  register RespondTo
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: cehoffman-sinatra-respond_to
+version: !ruby/object:Gem::Version 
+  version: 0.3.1
+platform: ruby
+authors: 
+- Chris Hoffman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-11 00:00:00 -07: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.1.3
+    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: 
+- LICENSE
+- README.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION.yml
+- lib/sinatra/respond_to.rb
+has_rdoc: true
+homepage: http://github.com/cehoffman/sinatra-respond_to
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+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: []
+