responders_backport 0.1.1

data/CHANGELOG

@@ -0,0 +1,7 @@
+# Version 0.1.1
+
+* attr_reader :response added.
+
+# Version 0.1
+
+* First release. Extracted from InheritedResources v1.0 (Rails 2.3.x)

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 George Guimarães and José Valim http://blog.plataformatec.com.br
+
+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.rdoc

@@ -0,0 +1,22 @@
+== Responders Backport for Rails 2.3.x
+
+Loving Rails 3 Responders[1] feature? Me too.
+
+Wants to use Responders in your Rails 2.3.x apps? Use InheritedResources. IR backports [2] Responder to your Rails 2.3.x apps and adds lots of useful and awesome features.
+
+However, in some cases we don't want to use all IR awesome features. So, I extracted Responders-backporting-stuff to a minimal lib. This is mainly to be use as a dependency by Restfulie (http://github.com/caelum/restfulie)
+
+
+=== Notes
+
+[1] Please see these posts about Responders :
+
+http://blog.plataformatec.com.br/2009/12/one-in-three-inherited-resources-has-scope-and-responders/
+
+http://blog.plataformatec.com.br/2009/08/inherited-resources-is-scopes-and-responder-fluent/
+
+
+[2] This is not entirely true, since Rails 3 Responders was actually *inspired* by InheritedResources new features to Rails 2.
+
+Copyright (c) 2010 George Guimarães and José Valim http://blog.plataformatec.com.br
+See the attached MIT License.

data/Rakefile

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require File.join(File.dirname(__FILE__), 'lib', 'responders_backport', 'version')
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "responders_backport"
+    s.version = RespondersBackport::VERSION
+    s.rubyforge_project = "responders_backport"
+    s.summary = "Bringing Rails 3 Responders to your obsolete Rails 2.3.x apps =)"
+    s.email = "george@plataformatec.com.br"
+    s.homepage = "http://github.com/plataformatec/responders_backport"
+    s.description = "Bringing Rails 3 Responders to your obsolete Rails 2.3.x apps =)"
+    s.authors = ['George Guimarães', 'José Valim']
+    s.files =  FileList["[A-Z]*", "init.rb", "{lib}/**/*"]
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler"
+end
+
+desc 'Run tests for RespondersBackport.'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for RespondersBackport.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RespondersBackport'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('MIT-LICENSE')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1 @@
+require 'responders_backport'

data/lib/responders_backport/respond_to.rb

@@ -0,0 +1,154 @@
+module ActionController #:nodoc:
+  class Base #:nodoc:
+    attr_accessor :formats
+
+    class_inheritable_accessor :mimes_for_respond_to, :responder, :instance_writer => false
+
+    self.responder = ActionController::Responder
+    self.mimes_for_respond_to = ActiveSupport::OrderedHash.new
+
+    if defined?(ApplicationController)
+      ApplicationController.responder ||= ActionController::Responder
+      ApplicationController.mimes_for_respond_to ||= ActiveSupport::OrderedHash.new
+    end
+
+    # Defines mimes that are rendered by default when invoking respond_with.
+    #
+    # Examples:
+    #
+    #   respond_to :html, :xml, :json
+    #
+    # All actions on your controller will respond to :html, :xml and :json.
+    #
+    # But if you want to specify it based on your actions, you can use only and
+    # except:
+    #
+    #   respond_to :html
+    #   respond_to :xml, :json, :except => [ :edit ]
+    #
+    # The definition above explicits that all actions respond to :html. And all
+    # actions except :edit respond to :xml and :json.
+    #
+    # You can specify also only parameters:
+    #
+    #   respond_to :rjs, :only => :create
+    #
+    def self.respond_to(*mimes)
+      options = mimes.extract_options!
+      clear_respond_to unless mimes_for_respond_to
+
+      only_actions   = Array(options.delete(:only))
+      except_actions = Array(options.delete(:except))
+
+      mimes.each do |mime|
+        mime = mime.to_sym
+        mimes_for_respond_to[mime]          = {}
+        mimes_for_respond_to[mime][:only]   = only_actions   unless only_actions.empty?
+        mimes_for_respond_to[mime][:except] = except_actions unless except_actions.empty?
+      end
+    end
+
+    # Clear all mimes in respond_to.
+    def self.clear_respond_to
+      write_inheritable_attribute(:mimes_for_respond_to, ActiveSupport::OrderedHash.new)
+    end
+
+    def respond_to(*mimes, &block)
+      raise ArgumentError, "respond_to takes either types or a block, never both" if mimes.any? && block_given?
+      if response = retrieve_response_from_mimes(mimes, &block)
+        response.call
+      end
+    end
+
+    def respond_with(*resources, &block)
+      if response = retrieve_response_from_mimes([], &block)
+        options = resources.extract_options!
+        options.merge!(:default_response => response)
+        (options.delete(:responder) || responder).call(self, resources, options)
+      end
+    end
+
+  protected
+
+    # Collect mimes declared in the class method respond_to valid for the
+    # current action.
+    #
+    def collect_mimes_from_class_level #:nodoc:
+      action = action_name.to_sym
+
+      mimes_for_respond_to.keys.select do |mime|
+        config = mimes_for_respond_to[mime]
+
+        if config[:except]
+          !config[:except].include?(action)
+        elsif config[:only]
+          config[:only].include?(action)
+        else
+          true
+        end
+      end
+    end
+
+    # Collects mimes and return the response for the negotiated format. Returns
+    # nil if :not_acceptable was sent to the client.
+    #
+    def retrieve_response_from_mimes(mimes, &block)
+      responder = ActionController::MimeResponds::Responder.new(self)
+      mimes = collect_mimes_from_class_level if mimes.empty?
+      mimes.each { |mime| responder.send(mime) }
+      block.call(responder) if block_given?
+
+      if format = responder.negotiate_mime
+        self.response.template.template_format = format.to_sym
+        self.response.content_type = format.to_s
+        self.formats = [ format.to_sym ]
+        responder.response_for(format) || proc { default_render }
+      else
+        head :not_acceptable
+        nil
+      end
+    end
+  end
+
+  module MimeResponds
+    class Responder #:nodoc:
+      attr_reader :order
+
+      def any(*args, &block)
+        if args.any?
+          args.each { |type| send(type, &block) }
+        else
+          custom(Mime::ALL, &block)
+        end
+      end
+      alias :all :any
+
+      def custom(mime_type, &block)
+        mime_type = mime_type.is_a?(Mime::Type) ? mime_type : Mime::Type.lookup(mime_type.to_s)
+        @order << mime_type
+        @responses[mime_type] ||= block
+      end
+
+      def response_for(mime)
+        @responses[mime] || @responses[Mime::ALL]
+      end
+
+      def negotiate_mime
+        @mime_type_priority.each do |priority|
+          if priority == Mime::ALL
+            return @order.first
+          elsif @order.include?(priority)
+            return priority
+          end
+        end
+
+        if @order.include?(Mime::ALL)
+          return Mime::SET.first if @mime_type_priority.first == Mime::ALL
+          return @mime_type_priority.first
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/responders_backport/responder.rb

@@ -0,0 +1,221 @@
+module ActionController #:nodoc:
+  # Responder is responsible to expose a resource for different mime requests,
+  # usually depending on the HTTP verb. The responder is triggered when
+  # respond_with is called. The simplest case to study is a GET request:
+  #
+  #   class PeopleController < ApplicationController
+  #     respond_to :html, :xml, :json
+  #
+  #     def index
+  #       @people = Person.find(:all)
+  #       respond_with(@people)
+  #     end
+  #   end
+  #
+  # When a request comes, for example with format :xml, three steps happen:
+  #
+  #   1) responder searches for a template at people/index.xml;
+  #
+  #   2) if the template is not available, it will invoke :to_xml in the given resource;
+  #
+  #   3) if the responder does not respond_to :to_xml, call :to_format on it.
+  #
+  # === Builtin HTTP verb semantics
+  #
+  # Rails default responder holds semantics for each HTTP verb. Depending on the
+  # content type, verb and the resource status, it will behave differently.
+  #
+  # Using Rails default responder, a POST request for creating an object could
+  # be written as:
+  #
+  #   def create
+  #     @user = User.new(params[:user])
+  #     flash[:notice] = 'User was successfully created.' if @user.save
+  #     respond_with(@user)
+  #   end
+  #
+  # Which is exactly the same as:
+  #
+  #   def create
+  #     @user = User.new(params[:user])
+  #
+  #     respond_to do |format|
+  #       if @user.save
+  #         flash[:notice] = 'User was successfully created.'
+  #         format.html { redirect_to(@user) }
+  #         format.xml { render :xml => @user, :status => :created, :location => @user }
+  #       else
+  #         format.html { render :action => "new" }
+  #         format.xml { render :xml => @user.errors, :status => :unprocessable_entity }
+  #       end
+  #     end
+  #   end
+  #
+  # The same happens for PUT and DELETE requests.
+  #
+  # === Nested resources
+  #
+  # You can given nested resource as you do in form_for and polymorphic_url.
+  # Consider the project has many tasks example. The create action for
+  # TasksController would be like:
+  #
+  #   def create
+  #     @project = Project.find(params[:project_id])
+  #     @task = @project.comments.build(params[:task])
+  #     flash[:notice] = 'Task was successfully created.' if @task.save
+  #     respond_with(@project, @task)
+  #   end
+  #
+  # Giving an array of resources, you ensure that the responder will redirect to
+  # project_task_url instead of task_url.
+  #
+  # Namespaced and singleton resources requires a symbol to be given, as in
+  # polymorphic urls. If a project has one manager which has many tasks, it
+  # should be invoked as:
+  #
+  #   respond_with(@project, :manager, @task)
+  #
+  # Check polymorphic_url documentation for more examples.
+  #
+  class Responder
+    attr_reader :controller, :request, :response, :format, :resource, :resources, :options
+
+    ACTIONS_FOR_VERBS = {
+      :post => :new,
+      :put => :edit
+    }
+
+    def initialize(controller, resources, options={})
+      @controller = controller
+      @request = controller.request
+      @response = controller.response
+      @format = controller.formats.first
+      @resource = resources.is_a?(Array) ? resources.last : resources
+      @resources = resources
+      @options = options
+      @action = options.delete(:action)
+      @default_response = options.delete(:default_response)
+    end
+
+    delegate :head, :render, :redirect_to,   :to => :controller
+    delegate :get?, :post?, :put?, :delete?, :to => :request
+
+    # Undefine :to_json and :to_yaml since it's defined on Object
+    undef_method(:to_json) if method_defined?(:to_json)
+    undef_method(:to_yaml) if method_defined?(:to_yaml)
+
+    # Initializes a new responder an invoke the proper format. If the format is
+    # not defined, call to_format.
+    #
+    def self.call(*args)
+      new(*args).respond
+    end
+
+    # Main entry point for responder responsible to dispatch to the proper format.
+    #
+    def respond
+      method = :"to_#{format}"
+      respond_to?(method) ? send(method) : to_format
+    end
+
+    # HTML format does not render the resource, it always attempt to render a
+    # template.
+    #
+    def to_html
+      default_render
+    rescue ActionView::MissingTemplate => e
+      navigation_behavior(e)
+    end
+
+    # All others formats follow the procedure below. First we try to render a
+    # template, if the template is not available, we verify if the resource
+    # responds to :to_format and display it.
+    #
+    def to_format
+      default_render
+    rescue ActionView::MissingTemplate => e
+      raise unless resourceful?
+      api_behavior(e)
+    end
+
+  protected
+
+    # This is the common behavior for "navigation" requests, like :html, :iphone and so forth.
+    def navigation_behavior(error)
+      if get?
+        raise error
+      elsif has_errors? && default_action
+        render :action => default_action
+      else
+        redirect_to resource_location
+      end
+    end
+
+    # This is the common behavior for "API" requests, like :xml and :json.
+    def api_behavior(error)
+      if get?
+        display resource
+      elsif has_errors?
+        display resource.errors, :status => :unprocessable_entity
+      elsif post?
+        display resource, :status => :created, :location => resource_location
+      else
+        head :ok
+      end
+    end
+
+    # Checks whether the resource responds to the current format or not.
+    #
+    def resourceful?
+      resource.respond_to?(:"to_#{format}")
+    end
+
+    # Returns the resource location by retrieving it from the options or
+    # returning the resources array.
+    #
+    def resource_location
+      options[:location] || resources
+    end
+
+    # If a given response block was given, use it, otherwise call render on
+    # controller.
+    #
+    def default_render
+      @default_response.call
+    end
+
+    # display is just a shortcut to render a resource with the current format.
+    #
+    #   display @user, :status => :ok
+    #
+    # For xml request is equivalent to:
+    #
+    #   render :xml => @user, :status => :ok
+    #
+    # Options sent by the user are also used:
+    #
+    #   respond_with(@user, :status => :created)
+    #   display(@user, :status => :ok)
+    #
+    # Results in:
+    #
+    #   render :xml => @user, :status => :created
+    #
+    def display(resource, given_options={})
+      controller.send :render, given_options.merge!(options).merge!(format => resource)
+    end
+
+    # Check if the resource has errors or not.
+    #
+    def has_errors?
+      resource.respond_to?(:errors) && !resource.errors.empty?
+    end
+
+    # By default, render the :edit action for html requests with failure, unless
+    # the verb is post.
+    #
+    def default_action
+      @action ||= ACTIONS_FOR_VERBS[request.method]
+    end
+  end
+end

data/lib/responders_backport/version.rb

@@ -0,0 +1,3 @@
+module RespondersBackport
+  VERSION = '0.1.1'.freeze
+end

data/lib/responders_backport.rb

@@ -0,0 +1,6 @@
+unless defined?(ActionController::Responder)
+  require 'responders_backport/responder'
+  require 'responders_backport/respond_to'
+end
+
+require 'responders_backport/version'

data/test/respond_to_test.rb

@@ -0,0 +1,155 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Project
+  def to_html
+    'Generated HTML'
+  end
+
+  def to_xml
+    'Generated XML'
+  end
+
+  [:to_json, :to_rss, :to_rjs].each do |method|
+    undef_method method if respond_to? method
+  end
+end
+
+class ProjectsController < ActionController::Base
+  respond_to :html
+  respond_to :xml,  :except => :edit
+  respond_to :rjs,  :only => :edit
+  respond_to :rss,  :only => :index
+  respond_to :json, :except => :index
+  respond_to :csv,  :except => :index
+
+  def index
+    respond_with(Project.new)
+  end
+
+  def respond_with_resource
+    respond_with(Project.new)
+  end
+
+  def respond_with_resource_and_options
+    respond_with(Project.new, :location => 'http://test.host/')
+  end
+
+  def respond_with_resource_and_blocks
+    respond_with(Project.new) do |format|
+      format.json { render :text => 'Render JSON' }
+      format.rss  { render :text => 'Render RSS' }
+    end
+  end
+
+  # If the user request Mime::ALL and we have a template called action.html.erb,
+  # the html template should be rendered *unless* html is specified inside the
+  # block. This tests exactly this case.
+  #
+  def respond_to_skip_default_template
+    respond_with(Project.new) do |format|
+      format.html { render :text => 'Render HTML' }
+    end
+  end
+end
+
+class SuperProjectsController < ProjectsController
+end
+
+class RespondToFunctionalTest < ActionController::TestCase
+  tests ProjectsController
+
+  def test_respond_with_layout_rendering
+    @request.accept = 'text/html'
+    get :index
+    assert_equal 'Index HTML', @response.body.strip
+  end
+
+  def test_respond_with_calls_to_format_on_resource
+    @request.accept = 'application/xml'
+    get :index
+    assert_equal 'Generated XML', @response.body.strip
+  end
+
+  def test_respond_with_inherits_format
+    @request.accept = 'application/xml'
+    get :index
+    assert_equal 'Generated XML', @response.body.strip
+  end
+
+  def test_respond_with_renders_status_not_acceptable_if_mime_type_is_not_registered
+    @request.accept = 'text/csv'
+    get :index
+    assert_equal '406 Not Acceptable', @response.status
+  end
+
+  def test_respond_with_raises_error_if_could_not_respond
+    @request.accept = 'application/rss+xml'
+    assert_raise ActionView::MissingTemplate do
+      get :index
+    end
+  end
+
+  def test_respond_to_all
+    @request.accept = '*/*'
+    get :index
+    assert_equal 'Index HTML', @response.body.strip
+  end
+
+  def test_respond_with_sets_content_type_properly
+    @request.accept = 'text/html'
+    get :index
+    assert_equal 'text/html', @response.content_type
+    assert_equal :html, @response.template.template_format
+
+    @request.accept = 'application/xml'
+    get :index
+    assert_equal 'application/xml', @response.content_type
+    assert_equal :xml, @response.template.template_format
+  end
+
+  def test_respond_with_forwads_extra_options_to_render
+    @request.accept = 'application/xml'
+    get :respond_with_resource_and_options
+    assert_equal 'Generated XML', @response.body.strip
+    assert_equal 'http://test.host/', @response.headers['Location']
+  end
+
+  def test_respond_to_when_a_resource_is_given_as_option
+    @request.accept = 'text/html'
+    get :respond_with_resource
+    assert_equal 'RespondTo HTML', @response.body.strip
+
+    @request.accept = 'application/xml'
+    get :respond_with_resource
+    assert_equal 'Generated XML', @response.body.strip
+
+    @request.accept = 'application/rss+xml'
+    get :respond_with_resource
+    assert_equal '406 Not Acceptable', @response.status
+
+    @request.accept = 'application/json'
+    assert_raise ActionView::MissingTemplate do
+      get :respond_with_resource
+    end
+  end
+
+  def test_respond_to_overwrite_class_method_definition
+    @request.accept = 'application/rss+xml'
+    get :respond_with_resource_and_blocks
+    assert_equal 'Render RSS', @response.body.strip
+  end
+
+  def test_respond_to_first_configured_mime_in_respond_to_when_mime_type_is_all
+    @request.accept = '*/*'
+    assert_raise ActionView::MissingTemplate do
+      get :respond_with_resource_and_blocks
+    end
+    assert_equal 'text/html', @response.content_type
+  end
+
+  def test_respond_to_skip_default_template_when_it_is_in_block
+    @request.accept = '*/*'
+    get :respond_to_skip_default_template
+    assert_equal 'Render HTML', @response.body.strip
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+
+begin
+  gem "test-unit"
+rescue LoadError
+end
+
+begin
+  gem "ruby-debug"
+  require 'ruby-debug'
+rescue LoadError
+end
+
+require 'test/unit'
+
+ENV["RAILS_ENV"] = "test"
+RAILS_ROOT = "anywhere"
+
+require 'active_support'
+require 'action_controller'
+require 'action_controller/test_case'
+require 'action_controller/test_process'
+
+I18n.load_path << File.join(File.dirname(__FILE__), 'locales', 'en.yml')
+I18n.reload!
+
+class ApplicationController < ActionController::Base; end
+
+# Add RespondersBackport to load path and load the main file
+ActiveSupport::Dependencies.load_paths << File.expand_path(File.dirname(__FILE__) + '/../lib')
+require_dependency 'responders_backport'
+
+ActionController::Base.view_paths = File.join(File.dirname(__FILE__), 'views')
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/:action/:id'
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: responders_backport
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- "George Guimar\xC3\xA3es"
+- "Jos\xC3\xA9 Valim"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-15 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: Bringing Rails 3 Responders to your obsolete Rails 2.3.x apps =)
+email: george@plataformatec.com.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- CHANGELOG
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- init.rb
+- lib/responders_backport.rb
+- lib/responders_backport/respond_to.rb
+- lib/responders_backport/responder.rb
+- lib/responders_backport/version.rb
+has_rdoc: true
+homepage: http://github.com/plataformatec/responders_backport
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: responders_backport
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Bringing Rails 3 Responders to your obsolete Rails 2.3.x apps =)
+test_files: 
+- test/respond_to_test.rb
+- test/test_helper.rb