rack-conneg 0.1.2

data/README.rdoc

@@ -0,0 +1,38 @@
+= Description
+Content negotiation for Rack applications, including a Rails-style respond_to block.
+
+= Features
+
+* Allows both file-extension-based and Accept: header-based content negotiation
+* Allows certain routes to pass through without negotiation (useful for static files, etc.)
+* Falls back to a pre-set type if negotiation fails
+* Injects a respond_to method with default handler into the application's namespace
+* Injects negotiated_type and negotiated_ext methods both into the application and into Rack::Request
+
+= Sinatra Example
+
+  require 'sinatra'
+  require 'rack/conneg'
+
+  use(Rack::Conneg) { |conneg|
+    conneg.set :accept_all_extensions, false
+    conneg.set :fallback, :html
+    conneg.ignore('/public/')
+    conneg.provide([:json, :xml])
+  }
+
+  before do
+    content_type negotiated_type
+  end
+  
+  get '/hello' do
+    response = { :message => 'Hello, World!' }
+    respond_to do |wants|
+      wants.json  { response.to_json         }
+      wants.xml   { response.to_xml          }
+      wants.other { 
+        content_type 'text/plain'
+        error 406, "Not Acceptable" 
+      }
+    end
+  end

data/lib/rack/conneg.rb

@@ -0,0 +1,149 @@
+require 'rack'
+require 'rack/mime'
+
+module Rack #:nodoc:#
+  
+  class Conneg
+    
+    VERSION = '0.1.2'
+    
+    def initialize(app)
+      @app = app
+      @ignores = []
+      @opts = { 
+        :accept_all_extensions => false,
+        :fallback => 'text/html'
+      }
+      @types = []
+
+      @app.class.module_eval {
+        def negotiated_ext  ; @rack_conneg_ext  ; end #:nodoc:#
+        def negotiated_type ; @rack_conneg_type ; end #:nodoc:#
+        def respond_to
+          wants = { '*/*' => Proc.new { raise TypeError, "No handler for #{@rack_conneg_type}" } }
+          def wants.method_missing(ext, *args, &handler)
+            type = ext == :other ? '*/*' : Rack::Mime::MIME_TYPES[".#{ext.to_s}"]
+            self[type] = handler
+          end
+
+          yield wants
+
+          (wants[@rack_conneg_type] || wants['*/*']).call
+        end
+      }
+      
+      if block_given?
+        yield self
+      end
+    end
+    
+    def call(env)
+      extension = nil
+      path_info = env['PATH_INFO']
+      unless @ignores.find { |ignore| ignore.match(path_info) }
+        # First, check to see if there's an explicit type requested
+        # via the file extension
+        mime_type = Rack::Mime.mime_type(::File.extname(path_info),nil)
+        if mime_type
+          env['PATH_INFO'] = path_info.sub!(/(\..+?)$/,'')
+          extension = $1
+          if !(accept_all_extensions? || @types.include?(mime_type))
+            mime_type = nil
+          end
+        else
+          # Create an array of types out of the HTTP_ACCEPT header, sorted
+          # by q value and original order
+          accept_types = env['HTTP_ACCEPT'].split(/,/)
+          accept_types.each_with_index { |t,i|
+            (accept_type,weight) = t.split(/;/)
+            weight = weight.nil? ? 1.0 : weight.split(/\=/).last.to_f
+            accept_types[i] = { :type => accept_type, :weight => weight, :order => i }
+          }
+          accept_types.sort! { |a,b| 
+            ord = b[:weight] <=> a[:weight] 
+            if ord == 0
+              ord = a[:order] <=> b[:order]
+            end
+            ord
+          }
+          
+          # Find the first item in accept_types that matches a registered
+          # content type
+          accept_types.find { |t|
+            re = %r{^#{t[:type].gsub(/\*/,'.+')}$}
+            @types.find { |type| re.match(type) ? mime_type = type : nil }
+          }
+        end
+        
+        mime_type ||= fallback
+        @app.instance_variable_set('@rack_conneg_ext',env['rack.conneg.ext'] = extension)
+        @app.instance_variable_set('@rack_conneg_type',env['rack.conneg.type'] = mime_type)
+      end
+      @app.call(env) unless @app.nil?
+    end
+    
+    # Should content negotiation accept any file extention passed as part of the URI path, 
+    # even if it's not one of the registered provided types?
+    def accept_all_extensions?
+      @opts[:accept_all_extensions] ? true : false
+    end
+    
+    # What MIME type should be used as a fallback if negotiation fails? Defaults to 'text/html'
+    # since that's what's used to deliver most error message content.
+    def fallback
+      find_mime_type(@opts[:fallback])
+    end
+    
+    # Specifies a route prefix or Regexp that should be ignored by the content negotiator. Use
+    # for static files or any other route that should be passed through unaltered.
+    def ignore(route)
+      route_re = route.kind_of?(Regexp) ? route : %r{^#{route}}
+      @ignores << route_re
+    end
+    
+    # Register one or more content types that the application offers. Can be a content type string,
+    # a file extension, or a symbol (e.g., 'application/xml', '.xml', and :xml are all equivalent).
+    def provide(*args)
+      args.flatten.each { |type|
+        mime_type = find_mime_type(type)
+        @types << mime_type
+      }
+    end
+    
+    # Set a content negotiation option. Valid options are:
+    # * :accept_all_extensions - true if all file extensions should be mapped to MIME types whether
+    #   or not their associated types are specifically provided
+    # * :fallback - a content type string, file extention, or symbol representing the MIME type to
+    #   fall back on if negotiation fails
+    def set(key, value)
+      opt_key = key.to_sym
+      if !@opts.include?(opt_key)
+        raise IndexError, "Unknown option: #{key.to_s}"
+      end
+      @opts[opt_key] = value
+    end
+    
+    private
+    def find_mime_type(type)
+      valid_types = Rack::Mime::MIME_TYPES.values
+      mime_type = nil
+      if type =~ %r{^[^/]+/[^/]+}
+        mime_type = type
+      else
+        ext = type.to_s
+        ext = ".#{ext}" unless ext =~ /^\./
+        mime_type = Rack::Mime.mime_type(ext,nil)
+      end
+      unless valid_types.include?(mime_type)
+        raise ValueError, "Unknown MIME type: #{mime_type}"
+      end
+      return mime_type
+    end
+  end
+  
+  class Request
+    def negotiated_ext  ; @env['rack.conneg.ext']  ; end
+    def negotiated_type ; @env['rack.conneg.type'] ; end
+  end
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: rack-conneg
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Michael B. Klein
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-10 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+description: Middleware that provides both file extension and HTTP_ACCEPT-type content negotiation for Rack applications
+email: Michael.Klein@oregonstate.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- lib/rack/conneg.rb
+has_rdoc: true
+homepage: 
+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: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Content Negotiation middleware for Rack applications
+test_files: []
+