RubyGems - rack-respond_to - Versions diffs - 0.9.8 - Mend

rack-respond_to 0.9.8

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 (15) hide show

data/.gitignore ADDED

@@ -0,0 +1,4 @@
+pkg/
+doc/
+*.gem
+.yardoc

data/LICENSE ADDED

@@ -0,0 +1,19 @@
+Copyright © 2009 Martin Aumont (mynyml)
+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/Manifest ADDED

@@ -0,0 +1,14 @@
+.gitignore
+LICENSE
+Manifest
+README.md
+Rakefile
+TODO
+docs.watchr
+examples/recommended_use.ru
+examples/simple_app.ru
+lib/rack/respond_to.rb
+rack-respond_to.gemspec
+specs.watchr
+test/test_helper.rb
+test/test_respond_to.rb

data/README.md ADDED

@@ -0,0 +1,66 @@
+Summary
+-------
+Rack convenience middleware that allows triggering different actions based on
+requested media type. Standalone version of the equivalent Rails functionality.
+Features
+--------
+* Based on familiar API (Rails)
+* Cascades down priority list of accepted media types
+* Handles wildcard 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)
+Install
+-------
+`gem install rack-respond_to`
+Example
+-------
+    require 'rack'
+    require 'rack/respond_to'
+    class App
+      include Rack::RespondTo #mixes in #respond_to
+      def call(env)
+        # 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 media types
+        # directly (this will take precedence over the env)
+        #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.selected_media_type}, [body]]
+      end
+    end
+    run App.new
+See the 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 `example.com/foo.xml` to trigger the
+`format.xml` block (`Rack::AbstractFormat` moves the extension's media type
+into `HTTP_ACCEPT` and makes it the highest ranked).
+  `gem install rack-abstract-format`
+See examples/recommended_use.ru for a complete example.
+Links
+-----
+* code: http://github.com/mynyml/rack-respond_to
+* docs: http://docs.github.com/mynyml/rack-respond_to
+* bugs: http://github.com/mynyml/rack-respond_to/issues

data/Rakefile ADDED

@@ -0,0 +1,38 @@
+def gem_opt
+  defined?(Gem) ? "-rubygems" : ""
+end
+# --------------------------------------------------
+# Tests
+# --------------------------------------------------
+task(:default => :"test:all")
+namespace(:test) do
+  desc "Run tests"
+  task(:all) do
+    exit system("ruby #{gem_opt} test/test_respond_to.rb")
+  end
+  desc "Run all tests on multiple ruby versions (requires rvm)"
+  task(:portability) do
+    versions = %w(  1.8.6  1.8.7  1.9  1.9.2  )
+    versions.each do |version|
+      system <<-BASH
+        bash -c 'source ~/.rvm/scripts/rvm;
+                 rvm use #{version};
+                 echo "--------- #{version} ----------";
+                 rake -s test:all'
+      BASH
+    end
+  end
+end
+# --------------------------------------------------
+# Docs
+# --------------------------------------------------
+desc "Generate YARD Documentation"
+task(:yardoc) do
+  require 'yard'
+  YARD::CLI::Yardoc.run *%w( -o doc/yard --readme README - LICENSE )
+end

data/TODO ADDED

File without changes

data/docs.watchr ADDED

@@ -0,0 +1,26 @@
+# Run me with:
+#   $ watchr docs.watchr
+require 'yard'
+# --------------------------------------------------
+# Watchr Rules
+# --------------------------------------------------
+watch( 'lib/.*\.rb'  ) { yard }
+watch( 'README.md'   ) { yard }
+watch( 'LICENSE'     ) { yard }
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+Signal.trap('QUIT') { yard        } # Ctrl-\
+Signal.trap('INT' ) { abort("\n") } # Ctrl-C
+# --------------------------------------------------
+# Helpers
+# --------------------------------------------------
+def yard
+  print "Updating yardocs... "; STDOUT.flush
+  YARD::CLI::Yardoc.run *%w( -o doc/yard --readme README.md --markup rdoc - LICENSE )
+  print "done\n"
+end

data/examples/recommended_use.ru ADDED

@@ -0,0 +1,40 @@
+# install required dependency:
+#   $sudo gem install rack-abstract-format
+#
+# run with:
+#   $rackup examples/recommended_use.ru -p 8080
+#
+# and request:
+#   localhost:8080/foo.html
+#   localhost:8080/foo.xml
+#
+require 'pathname'
+$:.unshift Pathname(__FILE__).dirname.parent + 'lib'
+require 'rack'
+require 'rack/abstract_format'
+require 'rack/respond_to'
+class App
+  include Rack::RespondTo
+  def call(env)
+    Rack::RespondTo.env = env
+    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>' }
+        format.xml  { '<body>xml</body>' }
+      end
+    end
+    [200, {'Content-Type' => Rack::RespondTo.selected_media_type || 'text/html'}, [body || '']]
+  end
+end
+use Rack::AbstractFormat
+run App.new

data/examples/simple_app.ru ADDED

@@ -0,0 +1,28 @@
+# run me with:
+#   $rackup examples/simple_app.ru
+#
+require 'pathname'
+$:.unshift Pathname(__FILE__).dirname.parent + 'lib'
+require 'rack'
+require 'rack/respond_to'
+class App
+  include Rack::RespondTo
+  def call(env)
+    Rack::RespondTo.media_types = %w( application/xml )
+    body = case env['PATH_INFO']
+    when '/'
+      respond_to do |format|
+        format.html { '<em>html</em>' }
+        format.xml  { '<body>xml</body>' }
+      end
+    end
+    [200, {'Content-Type' => Rack::RespondTo.selected_media_type || ''}, [body || '']]
+  end
+end
+run App.new

data/lib/rack/respond_to.rb ADDED

@@ -0,0 +1,193 @@
+require 'rack/accept_media_types'
+module Rack
+  # Based on Rails's API, and sinatra-respond_to (http://github.com/cehoffman/sinatra-respond_to)
+  #
+  # See examples/ directory for code examples.
+  #
+  module RespondTo
+    class << self
+      # 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 requested media types
+      # directly.
+      #
+      # ===== Example
+      #
+      #   RespondTo.media_types = ['application/xml']
+      #
+      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)
+        base.class_eval do
+          include InstanceMethods
+        end
+      end
+      # Cast format to media type
+      #
+      # ===== Example
+      #
+      #   RespondTo::MediaType('html') #=> 'text/html'
+      #   RespondTo::MediaType('htm')  #=> 'text/html'
+      #
+      def MediaType(format)
+        Rack::Mime.mime_type(format.sub(/^\./,'').insert(0,'.'))
+      end
+      alias :MimeType :MediaType
+      # Requested media types, in preferencial order
+      #
+      # ===== Examples
+      #
+      #   RespondTo.env['HTTP_ACCEPT'] #=> 'text/html,application/xml'
+      #   RespondTo.media_types        #=> ['text/html', 'application/xml']
+      #
+      #   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
+        def accept_list
+          self.env.nil? ? [] : Rack::AcceptMediaTypes.new(self.env['HTTP_ACCEPT'] || '')
+        end
+    end
+    module InstanceMethods
+      # Delegates to the equivalent class method.
+      def respond_to(&block)
+        self.class.respond_to(&block)
+      end
+    end
+    module ClassMethods
+      # Allows defining different actions and returns the one which corresponds
+      # to the highest ranking value in the RespondTo.media_types list.
+      #
+      # 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.
+      #
+      # Wildcard media types (*/*, text/*, etc.) will trigger the first
+      # matching format definition, so order matters if you expect the Accept
+      # header to contain any (a nil Accept header, for instance, will be
+      # turned into '*/*' as per rfc2616-sec14.1). Simply define the 'default'
+      # handler first (usually html), and it will work like a charm.
+      #
+      # ===== Examples
+      #
+      #   RespondTo.media_types = ['text/html', 'application/xml']
+      #
+      #   respond_to do |format|
+      #     format.html { 'html' }
+      #     format.xml  { 'xml'  }
+      #   end
+      #   #=> 'html'
+      #
+      #   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
+      #
+      #   RespondTo.media_types = ['*/*']
+      #
+      #   respond_to do |format|
+      #     format.html { 'html' }
+      #     format.xml  { 'xml'  }
+      #   end
+      #   #=> 'html'
+      #
+      #   RespondTo.media_types = ['*/*']
+      #
+      #   respond_to do |format|
+      #     format.xml  { 'xml'  }
+      #     format.html { 'html' }
+      #   end
+      #   #=> 'xml'
+      #
+      #   RespondTo.media_types = ['text/*']
+      #
+      #   respond_to do |format|
+      #     format.xml  { 'xml'  } # application/xml  (skip)
+      #     format.html { 'html' } # text/html        (match)
+      #     format.txt  { 'txt'  }
+      #   end
+      #   #=> 'html'
+      #
+      def respond_to
+        format = Format.new
+        yield format
+        type, handler = Helpers.match(RespondTo.media_types, format)
+        RespondTo.selected_media_type = type
+        handler.nil? ? nil : handler.call
+      end
+    end
+    # Helper methods, kept in a seperate namespace to avoid pollution.
+    module Helpers #:nodoc:
+      extend self
+      # TODO refactor
+      def match(media_types, format)
+        selected = []
+        accepted_types = media_types.map {|type| Regexp.escape(type).gsub(/\\\*/,'.*') }
+        accepted_types.each do |at|
+          format.each do |ht, handler|
+            (selected = [ht, handler]) and break if ht.match(at)
+          end
+          break unless selected.empty?
+        end
+        selected
+      end
+    end
+    # NOTE
+    # Array instead of hash because order matters (wildcard type matches first
+    # handler)
+    class Format < Array #:nodoc:
+      def method_missing(format, *args, &handler)
+        self << [RespondTo::MediaType(format.to_s), handler]
+      end
+    end
+  end
+end

data/rack-respond_to.gemspec ADDED

@@ -0,0 +1,16 @@
+spec = Gem::Specification.new do |s|
+  s.name                = "rack-respond_to"
+  s.version             = "0.9.8"
+  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"
+  s.email               = "mynyml@gmail.com"
+  s.homepage            = "http://github.com/mynyml/rack-respond_to"
+  s.rubyforge_project   = "rack-respond_to"
+  s.has_rdoc            =  false
+  s.require_path        = "lib"
+  s.files               =  File.read("Manifest").strip.split("\n")
+  s.add_dependency 'rack-accept-media-types', '>= 0.6'
+  s.add_development_dependency 'minitest'
+end

data/specs.watchr ADDED

@@ -0,0 +1,21 @@
+# Run me with:
+#   $ watchr specs.watchr
+# --------------------------------------------------
+# Watchr Rules
+# --------------------------------------------------
+watch( '^(lib|test)/.*\.rb' ) { rake }
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+Signal.trap('QUIT') { rake }        # Ctrl-\
+Signal.trap('INT' ) { abort("\n") } # Ctrl-C
+# --------------------------------------------------
+# Helpers
+# --------------------------------------------------
+def rake(task='')
+  system "rake -s #{task}"
+end

data/test/test_helper.rb ADDED

@@ -0,0 +1,20 @@
+require 'pathname'
+require 'minitest/autorun'
+require 'rack'
+begin
+  require 'ruby-debug'
+  require 'phocus'
+  require 'redgreen'
+rescue LoadError, RuntimeError
+end
+root = Pathname(__FILE__).dirname.parent.expand_path
+$:.unshift(root.join('lib'))
+require 'rack/respond_to'
+class MiniTest::Unit::TestCase
+  def self.test(name, &block)
+    define_method(:"test_#{name.gsub(/\s/,'_')}", &block)
+  end
+end

data/test/test_respond_to.rb ADDED

@@ -0,0 +1,188 @@
+require 'test/test_helper'
+class App
+  include Rack::RespondTo
+end
+class TestRespondTo < MiniTest::Unit::TestCase
+  def setup
+    Rack::RespondTo.selected_media_type = nil
+    Rack::RespondTo.media_types = nil
+    Rack::RespondTo.env = nil
+  end
+  ## api
+  test "env accessor" do
+    env = {'HTTP_ACCEPT' => 'text/html,application/xml'}
+    Rack::RespondTo.env = env
+    assert_equal env, Rack::RespondTo.env
+  end
+  test "media types accessor" do
+    Rack::RespondTo.media_types = %w( application/xml )
+    assert_equal %w( application/xml ), Rack::RespondTo.media_types
+    assert_equal %w( application/xml ), Rack::RespondTo.mime_types  #alias
+  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
+    assert_equal 'application/xml', Rack::RespondTo.selected_mime_type  #alias
+  end
+  test "mixin injects respond_to class method" do
+    assert App.respond_to?(:respond_to)
+  end
+  test "mixin injects respond_to instance method" do
+    assert App.new.respond_to?(:respond_to)
+  end
+  ## requested media types
+  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
+  ## respond_to
+  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 "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 "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
+  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 nil, body
+  end
+  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' }
+    end
+    assert_equal nil, body
+  end
+  test "respond_to handles synonymous formats" do
+    Rack::RespondTo.media_types = %w( text/html )
+    body = App.respond_to do |format|
+      format.htm { 'htm' } # htm/html
+      format.xml { 'xml' }
+    end
+    assert_equal 'htm', body
+    body = App.respond_to do |format|
+      format.html { 'html' } # htm/html
+      format.json { 'json' }
+    end
+    assert_equal 'html', body
+  end
+  test "respond_to handles types with special chars" do
+    Rack::RespondTo.media_types = %w( application/rss+xml )
+    body = App.respond_to do |format|
+      format.rss { 'rss' }
+    end
+    assert_equal 'rss', body
+    Rack::RespondTo.media_types = %w( video/x-msvideo )
+    body = App.respond_to do |format|
+      format.avi { 'avi' }
+    end
+    assert_equal 'avi', body
+    Rack::RespondTo.media_types = %w( application/x-bzip2 )
+    body = App.respond_to do |format|
+      format.bz2 { 'bz2' }
+    end
+    assert_equal 'bz2', 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
+  ## wildcard media types
+  test "wildcard type matches first handler" do
+    Rack::RespondTo.media_types = %w( */* )
+    body = App.respond_to do |format|
+      format.xml { 'xml' }
+      format.txt { 'txt' }
+    end
+    assert_equal 'xml', body
+    body = App.respond_to do |format|
+      format.txt { 'txt' }
+      format.xml { 'xml' }
+    end
+    assert_equal 'txt', body
+  end
+  test "wildcard subtype matches first handler for type" do
+    Rack::RespondTo.media_types = %w( text/* )
+    body = App.respond_to do |format|
+      format.xml { 'xml' }
+      format.txt { 'txt' }
+      format.htm { 'htm' }
+    end
+    assert_equal 'txt', body
+    body = App.respond_to do |format|
+      format.xml { 'xml' }
+      format.htm { 'htm' }
+      format.txt { 'txt' }
+    end
+    assert_equal 'htm', body
+    body = App.respond_to do |format|
+      format.xml { 'xml' }
+    end
+    assert_equal nil, body
+  end
+end

metadata ADDED

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: rack-respond_to
+version: !ruby/object:Gem::Version
+  version: 0.9.8
+platform: ruby
+authors:
+- Martin Aumont
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2010-01-29 00:00:00 -05:00
+default_executable:
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack-accept-media-types
+  type: :runtime
+  version_requirement:
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: "0.6"
+    version:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  type: :development
+  version_requirement:
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: "0"
+    version:
+description: Rack middleware port of Rails's respond_to feature.
+email: mynyml@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- LICENSE
+- Manifest
+- README.md
+- Rakefile
+- TODO
+- docs.watchr
+- examples/recommended_use.ru
+- examples/simple_app.ru
+- lib/rack/respond_to.rb
+- rack-respond_to.gemspec
+- specs.watchr
+- test/test_helper.rb
+- test/test_respond_to.rb
+has_rdoc: false
+homepage: http://github.com/mynyml/rack-respond_to
+licenses: []
+post_install_message:
+rdoc_options: []
+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: rack-respond_to
+rubygems_version: 1.3.5
+signing_key:
+specification_version: 3
+summary: Rack middleware port of Rails's respond_to feature
+test_files: []