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

mynyml-rack-respond_to 0.9.5 → 0.9.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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