RubyGems - mynyml-rack-respond_to - Versions diffs - 0.9.5 → 0.9.6 - Mend

mynyml-rack-respond_to 0.9.5 → 0.9.6

Files changed (9) hide show

data/README CHANGED Viewed

@@ -1,7 +1,21 @@
 ===== Summary
 Rack convenience middleware that allows triggering different actions based on
-requested mime type. Standalone version of the equivalent Rails functionality.
+requested media type. Standalone version of the equivalent Rails functionality.
+RespondTo gets the requested media type from the Accept header, which contains
+a list of media types accepted/requested by the client, ordered by level of
+preference (see http://github.com/mynyml/rack-accept-media-types).
+===== Features
+* Based on familiar API (Rails)
+* Cascades down priority list of accepted media types
+* Simple to use
+* Simple code (~50 LOCs)
+* Flexible (standalone use)
+* Decently documented (examples/ dir, source docs/rdocs)
+* Compatible with other media type handling middleware (uses Rack::AcceptMediaTypes)
 ===== Installation
@@ -17,30 +31,32 @@ requested mime type. Standalone version of the equivalent Rails functionality.
     include Rack::RespondTo
     def call(env)
-      # Pass in the env, and RespondTo will retrieve the requested mime type
+      # Pass in the env, and RespondTo will retrieve the requested media types
       Rack::RespondTo.env = env
-      # Alternatively, to use standalone you can also assign the mime type
+      # Alternatively, to use standalone you can also assign the media types
       # directly (this will take precedence over the env)
-      #Rack::RespondTo.mime_type = 'text/html'
+      #Rack::RespondTo.media_types = ['text/html']
       body = respond_to do |format|
         format.html { '<em>html</em>' }
         format.xml  { '<body>xml</body>' }
       end
-      [200, {'Content-Type' => Rack::RespondTo.mime_type}, [body]]
+      [200, {'Content-Type' => Rack::RespondTo.selected_media_type}, [body]]
     end
   end
   run App.new
+See examples/simple_app.ru for an executable example.
 ===== Tips
 Use together with Rack::AbstractFormat to respond to routes based on url
 extensions. For example, if you want <tt>example.com/foo.xml</tt> to trigger
-the <tt>format.xml</tt> block (Rack::AbstractFormat moves the extension into
-HTTP_ACCEPT).
+the <tt>format.xml</tt> block (Rack::AbstractFormat moves the extension's media
+type into HTTP_ACCEPT and makes it the highest ranked).
   sudo gem install mynyml-rack-abstract-format --source=http://gems.github.com/

data/Rakefile CHANGED Viewed

@@ -22,7 +22,7 @@ end
 spec = Gem::Specification.new do |s|
   s.name            = 'rack-respond_to'
-  s.version         = '0.9.5'
+  s.version         = '0.9.6'
   s.summary         = "Rack middleware port of Rails's respond_to feature"
   s.description     = "Rack middleware port of Rails's respond_to feature"
   s.author          = "Martin Aumont"

data/TODO CHANGED Viewed

@@ -1,4 +1,4 @@
-o handle wildcard content-types?
+o handle wildcard content-types
   e.g. */* matches first format block
     Rack::RespondTo.mime_type = '*/*'
@@ -15,8 +15,8 @@ o handle wildcard content-types?
     end
     body #=> 'xml'
-o cascade down accept types priority instead of only responding to prefered
-type. e.g:
+x cascade down accept types priority instead of only responding to prefered
+  type. e.g:
     env['HTTP_ACCEPT'] #=> 'text/plain,text/html;q=0.9,application/xml;q=0.8'

data/examples/recommended_use.ru CHANGED Viewed

@@ -25,6 +25,8 @@ class App
     request = Rack::Request.new(env)
     body = case request.path_info
+    when '/'
+      "try foo<em>.html</em> and foo<em>.xml</em>"
     when '/foo'
       respond_to do |format|
         format.html { '<em>html</em>' }
@@ -32,10 +34,9 @@ class App
       end
     end
-    [200, {'Content-Type' => Rack::RespondTo.mime_type}, [body]]
+    [200, {'Content-Type' => Rack::RespondTo.selected_media_type || 'text/html'}, [body]]
   end
 end
 use Rack::AbstractFormat
 run App.new

data/examples/simple_app.ru CHANGED Viewed

@@ -13,7 +13,7 @@ class App
   include Rack::RespondTo
   def call(env)
-    Rack::RespondTo.mime_type = 'application/xml'
+    Rack::RespondTo.media_types = %w( application/xml )
     body = case env['PATH_INFO']
     when '/'
@@ -23,7 +23,7 @@ class App
       end
     end
-    [200, {'Content-Type' => Rack::RespondTo.mime_type}, [body]]
+    [200, {'Content-Type' => Rack::RespondTo.selected_media_type}, [body]]
   end
 end

data/lib/rack/respond_to.rb CHANGED Viewed

@@ -8,26 +8,39 @@ module Rack
   #
   module RespondTo
     class << self
-      # Assign the environment directly to fetch the mime type from
+      # Assign the environment directly to fetch the requested media types from
       # env['HTTP_ACCEPT'] ('Accept:' request header).
       #
       # ===== Example
       #
       #   def call(env)
       #     Rack::RespondTo.env = env
+      #     #...
       #   end
       #
       attr_accessor :env
-      # If used completely standalone, you can assign the request mime_type directly.
+      # If used completely standalone, you can assign the requested media types
+      # directly.
       #
       # ===== Example
       #
-      #   RespondTo.mime_type = 'application/xml'
+      #   RespondTo.media_types = ['application/xml']
       #
-      attr_accessor :mime_type
-      alias :media_type= :mime_type=
-      alias :media_type  :mime_type
+      attr_accessor :media_types
+      alias :mime_types= :media_types=
+      alias :mime_types  :media_types
+      # Contains the media type that was responded to. Set after the respond_to
+      # block is called.
+      #
+      # Useful for setting the response's Content-Type:
+      #
+      #   [200, {'Content-Type' => RespondTo.selected_media_type}, [body]]
+      #
+      attr_accessor :selected_media_type
+      alias :selected_mime_type= :selected_media_type=
+      alias :selected_mime_type  :selected_media_type
       def included(base) #:nodoc:
         base.extend(ClassMethods)
@@ -36,34 +49,35 @@ module Rack
         end
       end
-      # Mime type requested.
+      # Cast format to media type
       #
-      # Useful for setting content type:
+      # ===== Example
       #
-      #   [200, {'Content-Type' => Rack::RespondTo.mime_type}, [body]]
+      #   RespondTo::MediaType('html') #=> 'text/html'
+      #   RespondTo::MediaType('htm')  #=> 'text/html'
       #
-      def mime_type
-        @mime_type || accept
+      def MediaType(format)
+        Rack::Mime.mime_type(format.sub(/^\./,'').insert(0,'.'))
       end
+      alias :MimeType :MediaType
-      # Cast format to mime type
+      # Requested media types, in preferencial order
       #
-      # ===== Example
+      # ===== Examples
       #
-      #   RespondTo::MimeType('html') #=> 'text/html'
+      #   RespondTo.env['HTTP_ACCEPT'] #=> 'text/html,application/xml'
+      #   RespondTo.media_types        #=> ['text/html', 'application/xml']
       #
-      def MimeType(format)
-        Rack::Mime.mime_type(format.sub(/^\./,'').insert(0,'.'))
+      #   RespondTo.env['HTTP_ACCEPT'] #=> 'text/html;q=0.7,application/xml;q=0.9,application/json;q=0.8'
+      #   RespondTo.media_types        #=> ['application/xml', 'application/json', 'text/html']
+      #
+      def media_types
+        @media_types || accept_list
       end
       private
-        # The mime type retained from the HTTP_ACCEPT header's list
-        #
-        # ===== Returns
-        # String:: first mime type from header's list or nil if none
-        #
-        def accept
-          Rack::AcceptMediaTypes.new(self.env['HTTP_ACCEPT'] || '').prefered unless self.env.nil?
+        def accept_list
+          self.env.nil? ? [] : Rack::AcceptMediaTypes.new(self.env['HTTP_ACCEPT'] || '')
         end
     end
@@ -75,30 +89,53 @@ module Rack
     end
     module ClassMethods
       # Allows defining different actions and returns the one which corresponds
-      # to the current RespondTo.mime_type.
+      # to the highest ranking value in the RespondTo.media_types list.
       #
-      # ===== Example
+      # If no handler is defined for the highest ranking value, respond_to will
+      # cascade down the RespondTo.media_types list until it finds a match.
+      # Returns nil if there is no match.
       #
-      #   RespondTo.mime_type = 'text/html'
+      # ===== Examples
+      #
+      #   RespondTo.media_types = ['text/html', 'application/xml']
       #
       #   respond_to do |format|
-      #     format.html { '<em>html</em>' }
-      #     format.xml  { '<content>xml</content>' }
+      #     format.html { 'html' }
+      #     format.xml  { 'xml'  }
       #   end
-      #   #=> '<em>html</em>'
+      #   #=> 'html'
       #
-      def respond_to(&block)
+      #   RespondTo.media_types = ['text/html', 'application/xml']
+      #
+      #   respond_to do |format|
+      #     format.xml  { 'xml' }
+      #     format.txt  { 'txt'  }
+      #   end
+      #   #=> 'xml'
+      #
+      #   RespondTo.media_types = ['text/html', 'application/json']
+      #
+      #   respond_to do |format|
+      #     format.xml  { 'xml' }
+      #     format.txt  { 'txt'  }
+      #   end
+      #   #=> nil
+      #
+      def respond_to
         format = Format.new
-        block.call(format)
-        handler = format[RespondTo.mime_type]
+        yield format
+        type = RespondTo.media_types.detect {|type| format[type] }
+        RespondTo.selected_media_type = type
+        handler = format[type]
         handler.nil? ? nil : handler.call
       end
     end
     class Format < Hash #:nodoc:
       def method_missing(format, *args, &handler)
-        self[RespondTo::MimeType(format.to_s)] = handler
+        self[RespondTo::MediaType(format.to_s)] = handler
       end
     end
   end

data/rack-respond_to.gemspec CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-respond_to
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.9.6
 platform: ruby
 authors:
 - Martin Aumont
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2009-06-08 00:00:00 -04:00
+date: 2009-06-09 00:00:00 -04:00
 default_executable:
 dependencies:
 - !ruby/object:Gem::Dependency

data/test/test_respond_to.rb CHANGED Viewed

@@ -7,7 +7,9 @@ end
 class TestRespondTo < Test::Unit::TestCase
   def setup
-    Rack::RespondTo.mime_type = nil
+    Rack::RespondTo.selected_media_type = nil
+    Rack::RespondTo.media_types = nil
+    Rack::RespondTo.env = nil
   end
   ## api
@@ -18,13 +20,21 @@ class TestRespondTo < Test::Unit::TestCase
     assert_equal env, Rack::RespondTo.env
   end
-  test "mime type accessor" do
-    Rack::RespondTo.mime_type = 'application/xml'
-    assert_equal 'application/xml', Rack::RespondTo.mime_type
+  test "media types accessor" do
+    Rack::RespondTo.media_types = %w( application/xml )
+    assert_equal %w( application/xml ), Rack::RespondTo.media_types
     # alias
-    Rack::RespondTo.media_type = 'application/xml'
-    assert_equal 'application/xml', Rack::RespondTo.media_type
+    Rack::RespondTo.media_types = %w( application/xml )
+    assert_equal %w( application/xml ), Rack::RespondTo.media_types
+  end
+  test "selected media type reader" do
+    Rack::RespondTo.media_types = %w( application/xml )
+    body = App.respond_to do |format|
+      format.xml { 'xml' }
+    end
+    assert_equal 'application/xml', Rack::RespondTo.selected_media_type
   end
   test "mixin injects respond_to class method" do
@@ -35,59 +45,54 @@ class TestRespondTo < Test::Unit::TestCase
     assert App.new.respond_to?(:respond_to)
   end
-  ## mime type
+  ## requested media types
-  test "mime type is extracted from header (first in list)" do
-    Rack::RespondTo.env = {'HTTP_ACCEPT' => 'text/html,application/xml'}
-    assert_equal 'text/html', Rack::RespondTo.mime_type
-    Rack::RespondTo.env = {'HTTP_ACCEPT' => 'application/xml,text/html'}
-    assert_equal 'application/xml', Rack::RespondTo.mime_type
+  test "explicitly specified media types take precedence over header's" do
+    Rack::RespondTo.env = {'HTTP_ACCEPT' => 'text/html'}
+    Rack::RespondTo.media_types = %w( text/plain )
+    assert_equal %w( text/plain ), Rack::RespondTo.media_types
   end
-  test "mime type with empty header" do
-    assert_nothing_raised do
-      Rack::RespondTo.env = {'HTTP_ACCEPT' => ''}
-      Rack::RespondTo.mime_type = nil
-      assert_equal nil, Rack::RespondTo.mime_type
-    end
-  end
+  ## respond_to
-  test "mime type with nil header" do
-    assert_nothing_raised do
-      Rack::RespondTo.env = {}
-      Rack::RespondTo.mime_type = nil
-      assert_equal nil, Rack::RespondTo.mime_type
+  test "respond_to returns block for highest ranking format" do
+    Rack::RespondTo.env = {'HTTP_ACCEPT' => 'application/xml;q=0.8,text/plain;q=0.9'}
+    body = App.respond_to do |format|
+      format.xml { 'xml' }
+      format.txt { 'txt' }
     end
+    assert_equal 'txt', body
   end
-  test "mime type without source" do
-    assert_nothing_raised do
-      Rack::RespondTo.env = nil
-      Rack::RespondTo.mime_type = nil
-      assert_equal nil, Rack::RespondTo.mime_type
+  test "cascades down the Accept header's list to find suitable type" do
+    Rack::RespondTo.env = {'HTTP_ACCEPT' => 'text/html,text/plain;q=0.9'}
+    body = App.respond_to do |format|
+      format.xml { 'xml' }
+      format.txt { 'txt' }
     end
+    assert_equal 'txt', body
   end
-  test "explicitly specified mime type takes precedence over env's" do
-    Rack::RespondTo.env = {'HTTP_ACCEPT' => 'text/html'}
-    Rack::RespondTo.mime_type = 'text/plain'
-    assert_equal 'text/plain', Rack::RespondTo.mime_type
+  test "respond_to with no matching format" do
+    Rack::RespondTo.media_types = %w( text/html )
+    body = App.respond_to do |format|
+      format.xml { 'xml' }
+      format.txt { 'txt' }
+    end
+    assert_equal nil, body
   end
-  ## respond_to
-  test "respond_to returns block for requested format" do
-    Rack::RespondTo.mime_type = 'application/xml'
+  test "respond_to with empty type list" do
+    Rack::RespondTo.media_types = []
     body = App.respond_to do |format|
       format.xml { 'xml' }
       format.txt { 'txt' }
     end
-    assert_equal 'xml', body
+    assert_equal nil, body
   end
-  test "respond_to with no matching format" do
-    Rack::RespondTo.mime_type = 'text/html'
+  test "respond_to with nil type list" do
+    Rack::RespondTo.media_types = nil
     body = App.respond_to do |format|
       format.xml { 'xml' }
       format.txt { 'txt' }
@@ -96,7 +101,7 @@ class TestRespondTo < Test::Unit::TestCase
   end
   test "respond_to handles synonymous formats" do
-    Rack::RespondTo.mime_type = 'text/html'
+    Rack::RespondTo.media_types = %w( text/html )
     body = App.respond_to do |format|
       format.htm { 'htm' } # htm/html
@@ -110,4 +115,15 @@ class TestRespondTo < Test::Unit::TestCase
     end
     assert_equal 'html', body
   end
+  test "repond_to sets selected media type" do
+    Rack::RespondTo.media_types = %w( text/html text/plain )
+    assert_equal nil, Rack::RespondTo.selected_media_type
+    body = App.respond_to do |format|
+      format.xml { 'xml' }
+      format.txt { 'txt' }
+    end
+    assert_equal 'txt', body
+    assert_equal 'text/plain', Rack::RespondTo.selected_media_type
+  end
 end

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mynyml-rack-respond_to
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.9.6
 platform: ruby
 authors:
 - Martin Aumont
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2009-06-07 21:00:00 -07:00
+date: 2009-06-08 21:00:00 -07:00
 default_executable:
 dependencies:
 - !ruby/object:Gem::Dependency