response_for_rails 0.4.0

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+rdoc/
+.rvmrc
+Gemfile.lock
+tmp/

data/CHANGELOG

@@ -0,0 +1,22 @@
+* 0.4.0 - Gemified [Josh Goebel, Ian White]
+  * The gem is called `response_for_rails`, see related `rc_rails` and `response_for_rc_rails`
+  * Removed Ardes namespace
+
+* 0.3.2 - Rails 3.1 compat
+
+* 0.2.2 - Fixed bug where response_for would clobber a respond_to if if the respond_to relied on default render [thanks Tom Stuart for the bug report]
+
+* Added VERSION introspection, this is 0.2.1
+
+* To facilitate making reusable chunks of actions and responses, simply extend Ardes::ResponsesModule into
+  your action modules.  See Ardes::ResponsesModule for details
+
+* now intercepting template_exists? to decide whether to render a response for an action
+  that has no action method defined.  (Removes somewhat mysterious behaviour of empty
+  actions being defined)
+
+* tagged v0.2.0 - API change, and major internal simplifications - see http://blog.ardes.com/response_for
+
+* tagged v0.1.0
+  
+* initial release of response_for

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock.development

@@ -0,0 +1,109 @@
+PATH
+  remote: .
+  specs:
+    response_for_rails (0.4.0)
+      rails (>= 3.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.2.2)
+      actionpack (= 3.2.2)
+      mail (~> 2.4.0)
+    actionpack (3.2.2)
+      activemodel (= 3.2.2)
+      activesupport (= 3.2.2)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.1)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.1)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.2)
+    activemodel (3.2.2)
+      activesupport (= 3.2.2)
+      builder (~> 3.0.0)
+    activerecord (3.2.2)
+      activemodel (= 3.2.2)
+      activesupport (= 3.2.2)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.2)
+      activemodel (= 3.2.2)
+      activesupport (= 3.2.2)
+    activesupport (3.2.2)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    hike (1.2.1)
+    i18n (0.6.0)
+    journey (1.0.3)
+    json (1.6.5)
+    mail (2.4.4)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.17.2)
+    multi_json (1.1.0)
+    polyglot (0.3.3)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (3.2.2)
+      actionmailer (= 3.2.2)
+      actionpack (= 3.2.2)
+      activerecord (= 3.2.2)
+      activeresource (= 3.2.2)
+      activesupport (= 3.2.2)
+      bundler (~> 1.0)
+      railties (= 3.2.2)
+    railties (3.2.2)
+      actionpack (= 3.2.2)
+      activesupport (= 3.2.2)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.6)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    rspec-rails (2.8.1)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      railties (>= 3.0)
+      rspec (~> 2.8.0)
+    sprockets (2.1.2)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.5)
+    thor (0.14.6)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.32)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  response_for_rails!
+  rspec (>= 2.5.0)
+  rspec-rails (>= 2.5.0)
+  sqlite3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007-2012 Ian White - ian.w.white@ardes.com
+
+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,126 @@
+= response_for
+
+The gem is called *response_for_rails*
+
+response_for (see ResponseFor::ActionController::ClassMethods) allows you to decorate the respond_to block of actions on subclassed controllers.  This works nicely with http://github.com/ianwhite/resources_controller
+
+response_for's functionality can be summed up in one sentence:
+
+<b>"response_for allows you to specify default responses for any action (or before filter) that doesn't render or redirect"</b>
+
+Actions typically do two things - interact with models, and render a response.  The above simple idea allows you to decouple these
+two functions (where appropriate), which means abstraction of common patterns becomes possible.
+
+== For Rails 3.0 and higher
+
+Simply add the response_for_rails gem to your Gemfile
+
+  gem "response_for_rails"
+
+== Older rails
+
+=== For Rails 2.2 thru 2.3
+
+For these older versions of rails please checkout the 0.2-stable-rails2.1 branch. Plugin install on rails 2.2 and up can fetch from a branch.
+
+  ./script/plugin install git://github.com/ianwhite/response_for.git -r 0.2-stable-rails2.1
+
+=== For Rails 2.1
+
+  cd vendor/plugins
+  git clone git://github.com/ianwhite/response_for.git
+  cd response_for
+  git checkout 0.2-stable-rails2.1
+  rmdir -f .git
+
+=== For Rails 2.0 
+
+Please checkout the 0.1-stable-rails2.0 branch.  Same general instructions for Rails 2.1 should work.
+
+== Run the specs
+
+To get set up for development, do the following:
+
+  git clone git://github.com/ianwhite/response_for
+  cd response_for
+  cp Gemfile.lock.development Gemfile.lock
+  bundle
+  rake
+
+== Example
+
+  class FooController < ApplicationController
+    def index
+      @foos = Foo.find(:all)
+      # default response - render html
+    end
+  end
+  
+  # this controller needs to respond_to fbml on index. 
+  # Using response_for, we don't need to repeat '@foos = Foo.find(1)'
+  class SpecialFooController < FooController
+    response_for :index do |format|
+      format.fbml { render :inline => turn_into_facebook(@foos) }
+    end
+  end
+
+== History
+
+NOTE: 0.2-stable has BC-breaking API changes, and is supported only for Rails >= 2.1.x.  Version 0.2.0 was released on Sept 14th 2008.
+You should use 0.1-stable in your existing projects until you have runs your specs and whatnot.
+
+If you want to know more about why I changed the API in 0.2 read on
+
+
+=== Why change the API in 0.2?
+
+repsonse_for <= v0.1 intercepted respond_to calls to allow overriding of these by class level declarations.  This turns out to have some 
+headaches, such as:
+
+* If you have some bail-out code in before_filters which uses respond_to, then response_for tries to overwrite this.  This meant that I had
+  to write response_for to only kick in once before_filters had run.  This made for some funky smelling code.
+* Sometimes your bail out code runs after the before_filters, in a superclass action for example, or just as part of your action (perhaps in
+  another method).  The above hack doesn't work for this case (the before_filters have run).  The solution in this case was to use
+  respond_to_without_response_for in any bail out code.
+* Conceptually, overriding code declared in methods, with code declared at the class level, is weird.  Here's an example
+
+    class FooController < SuperclassController
+      response_for :index # override Superclass's index respond_to
+    
+      def index
+        respond_to  # one might expect this to override the above, as its declared later - but it wont!
+      end
+    end
+
+So, in 0.2 a much simpler idea is behind response_for - you can declare a default response for an action which will be performed
+if <b>that that action has not already performed a render or redirect</b>.  This means that all of your bail out code written with
+respond_to will do what it's supposed to.
+
+==== Rewriting for 0.2
+
+If you're upgrading, you just need to convert any actions you want to override from this:
+
+  def index
+    @things = Thing.all
+    respond_to do |format|
+      format.html
+      format.xml { render :xml => @things }
+    end
+  end
+  
+to this:
+
+  def index
+    @things = Thing.all
+  end
+  
+  response_for :index |format|
+    format.html
+    format.xml { render :xml => @things }
+  end
+
+== Previous Versions: 0.1
+
+There is a branch for rails 2.0 users on this release.  If you are using rails 2.0, then you want the 0.1-stable-rails2.0 branch.  If you are
+using rails >= 2.1 then use the 0.1-stable branch
+

data/Rakefile

@@ -0,0 +1,32 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ResponseFor'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+task :default => [:spec]
+
+desc "Run the specs"
+RSpec::Core::RakeTask.new(:spec => []) do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+end

data/lib/response_for/action_controller.rb

@@ -0,0 +1,151 @@
+module ResponseFor #:nodoc:
+  # included into ActionController::Base
+  module ActionController
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        alias_method_chain :default_render, :response_for
+      end
+    end
+    
+    module ClassMethods
+      # response_for allows you to specify a default response for your actions that don't specify a
+      # respond_to block.
+      # 
+      # Using response_for, you may keep the response logic out of the action, so that it can be overriden easily
+      # without having to rewrite the entire action.  This is very useful when subclassing controllers.
+      #
+      # == Usage
+      #
+      #   response_for :action1 [, :action2], [,:types => [:mime, :type, :list]] [ do |format| ... end] # or
+      #
+      # === Example
+      #
+      #   class FooController < ApplicationController
+      #     def index
+      #       @foos = Foo.find(:all)
+      #     end
+      #   
+      #     def show
+      #       @foo = Foo.find(params[:id])
+      #     end
+      #   end
+      #   
+      #   # this controller needs to respond_to fbml on index, and
+      #   # js, html and xml (templates) on index and show
+      #   class SpecialFooController < FooController
+      #     response_for :index do |format|
+      #       format.fbml { render :inline => turn_into_facebook(@foos) }
+      #     end
+      #   
+      #     response_for :index, :show, :types => [:html, :xml, :js]
+      #   end
+      #
+      # === when response_for kicks in
+      # 
+      # response_for only kicks in if the action (or any filters) have not already redirected or rendered.
+      # 
+      # This means that if you foresee wanting to override your action's responses, you should write them without
+      # a respond_to block, but with a response_for block (the latter can be overridden by subsequent response_fors, the 
+      # former cannot)
+      # 
+      # === Other examples 
+      #
+      #   response_for :index, :types => [:fbml]    # index will respond to fbml and try to render, say, index.fbml.builder
+      #
+      #   response_for :update do |format|          # this example is for a resources_controller controller
+      #     if !(resource.new_record? || resource.changed?) # => resource.saved?
+      #       format.js { render(:update) {|page| page.replace dom_id(resource), :partial => resource }}
+      #     else
+      #       format.js { render(:update) {|page| page.visual_effect :shake, dom_id(resource) }}
+      #     end
+      #   end
+      #
+      # === Notes
+      #
+      # * If the before_filters or action renders or redirects, then response_for will not be invoked.
+      # * you can stack up multiple response_for calls, the most recent has precedence
+      # * the specifed block is executed within the controller instance, so you can use controller
+      #   instance methods and instance variables (i.e. you can make it look just like a regular
+      #   respond_to block).
+      # * you can add a response_for an action that has no action method defined.  This is just like
+      #   defining a template for an action that has no action method defined.
+      # * you can combine the :types option with a block, the block has precedence if you specify the
+      #   same mime type in both.
+      def response_for(*actions, &block)
+        (options = actions.extract_options!).assert_valid_keys(:types)
+        
+        types_block = if options[:types]
+          proc {|responder| Array(options[:types]).each {|type| responder.send type}}
+        end
+        
+        # store responses against action names
+        actions.collect(&:to_s).each do |action|
+          action_responses[action] ||= []
+          action_responses[action].unshift types_block if types_block
+          action_responses[action].unshift block if block
+        end
+      end
+    
+      # remove any response for the specified actions.  If no arguments are given,
+      # then all repsonses for all actions are removed
+      def remove_response_for(*actions)
+        if actions.empty?
+          instance_variable_set('@action_responses', nil)
+        else
+          actions.each {|action| action_responses.delete(action.to_s)}
+        end
+      end
+      
+      # return action_responses Hash. On initialize, set and return hash whose values are copies of superclass action_responses, if any
+      def action_responses
+        instance_variable_get('@action_responses') || instance_variable_set('@action_responses', copy_of_each_of_superclass_action_responses)
+      end
+      
+      # takes any responses from the argument (a controller, or responses module) and adds them to this controller's responses
+      def include_responses_from(responses_container)
+        responses_container.action_responses.each do |action, responses|
+          action_responses[action] ||= []
+          action_responses[action].unshift(*responses)
+        end
+      end
+      
+    private
+      def copy_of_each_of_superclass_action_responses
+        (superclass.action_responses rescue {}).inject({}){|m,(k,v)| m.merge(k => v.dup)}
+      end
+    end
+    
+  protected
+    # return the responses defined by response_for for the current action
+    def action_responses
+      self.class.action_responses[action_name] || []
+    end
+    
+    # respond_to sets the content type on the response, so we use that to tell
+    # if respond_to has been performed
+    def respond_to_performed?
+      (response && response.content_type) ? true : false
+    end
+    
+    # if the response.content_type has not been set (if it has, then responthere are responses for the current action, then respond_to them
+    #
+    # we rescue the case where there were no responses, so that the default_render
+    # action will be performed
+    def respond_to_action_responses
+      if !respond_to_performed? && action_responses.any?
+        respond_to do |responder|
+          action_responses.each {|response| instance_exec(responder, &response) }
+        end
+      end
+    end
+    
+    # this method is invoked if we've got to the end of an action without
+    # performing, which is when we respond_to any repsonses defined 
+    def default_render_with_response_for(*args)
+      respond_to_action_responses
+      default_render_without_response_for(*args) unless performed?
+    end
+    
+  end
+end

data/lib/response_for/railtie.rb

@@ -0,0 +1,9 @@
+module ResponseFor
+  class Railtie < Rails::Railtie #:nodoc:
+    initializer 'response_for' do
+      ActiveSupport.on_load(:action_controller) do
+        include ResponseFor::ActionController
+      end      
+    end
+  end
+end

data/lib/response_for/responses_module.rb

@@ -0,0 +1,47 @@
+module ResponseFor#:nodoc:
+  # Extension to facilitate writing responses in mixins
+  #
+  # extend this into your own module to have it act as a response_for namespace
+  # when this module is included into a controller, the responses will be copied
+  # over, along with the actions.
+  #
+  # NOTE: If you are defining self.included on your module, make sure you put the
+  # extend ResponseFor::ResponsesModule *after* self.included method definition.
+  #
+  # Example:
+  #
+  #  module MyActions
+  #    extend ResponseFor::ResponsesModule
+  #
+  #    def foo
+  #      do_foo
+  #    end
+  #
+  #    response_for :foo do |format|
+  #      format.html { # do a response }
+  #    end
+  #  end
+  #
+  #  class AController < ApplicationController
+  #    include MyActions
+  #    # now this controller has foo and response_for :foo
+  #  end
+  module ResponsesModule
+    include ResponseFor::ActionController::ClassMethods
+    
+    def self.extended(mixin)
+      class << mixin
+        def included_with_responses(controller_class)
+          controller_class.include_responses_from(self)
+          included_without_responses(controller_class)
+        end
+        alias_method_chain :included, :responses
+      end
+    end
+  end
+end
+
+# BC
+module Ardes
+  ResponsesModule = ResponseFor::ResponsesModule
+end

data/lib/response_for/version.rb

@@ -0,0 +1,3 @@
+module ResponseFor
+  VERSION = "0.4.0"
+end

data/lib/response_for.rb

@@ -0,0 +1,7 @@
+require 'response_for/railtie' if defined?(Rails)
+require 'response_for/action_controller'
+require 'response_for/responses_module'
+require 'response_for/version'
+
+module ResponseFor
+end

data/lib/response_for_rails.rb

@@ -0,0 +1,7 @@
+require 'response_for/railtie' if defined?(Rails)
+require 'response_for/action_controller'
+require 'response_for/responses_module'
+require 'response_for/version'
+
+module ResponseFor
+end

data/response_for.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require 'response_for/version'
+version = ResponseFor::VERSION
+
+Gem::Specification.new do |s|
+  s.name        = "response_for_rails"
+  s.version     = version
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ian White"]
+  s.email       = "ian.w.white@gmail.com"
+  s.homepage    = "http://github.com/ianwhite/response_for"
+  s.summary     = "response_for-#{version}"
+  s.description = "response_for allows you to decorate the respond_to block of actions on subclassed controllers."
+
+  s.rubygems_version   = "1.3.7"
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {spec}/*`.split("\n")
+  s.extra_rdoc_files = [ "README.rdoc" ]
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.require_path     = "lib"
+
+  s.add_runtime_dependency "rails", '>= 3.0.0'
+  s.add_development_dependency "rspec", '>= 2.5.0'
+  s.add_development_dependency "rspec-rails", '>= 2.5.0'
+  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency "rspec-rails", '>= 2.5.0'
+end

data/spec/app/database.yml

@@ -0,0 +1,5 @@
+test:
+  adapter: sqlite3
+  database: tmp/test.sqlite3
+  pool: 5
+  timeout: 5000

data/spec/app/views/error_in_template_spec/test/error_in_template.html.erb

@@ -0,0 +1 @@
+<% raise "Boom!" %>

data/spec/app/views/pick_template_spec/template_only/an_action.atom.erb

@@ -0,0 +1 @@
+body of an_action.atom

data/spec/app/views/pick_template_spec/template_only/an_action.html.erb

@@ -0,0 +1 @@
+body of an_action.html

data/spec/app/views/pick_template_spec/template_only/an_action.js.erb

@@ -0,0 +1 @@
+body of an_action.js

data/spec/app/views/pick_template_spec/template_only/an_action.xml.erb

@@ -0,0 +1 @@
+body of an_action.xml

data/spec/app/views/stop_at_respond_to_spec/test/index.atom.builder

@@ -0,0 +1 @@
+xml.description "body of index.atom.builder"

data/spec/app/views/stop_at_respond_to_spec/test/index.html.erb

@@ -0,0 +1 @@
+body of index.html.erb

data/spec/controllers/default_rails_behaviour_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+module DefaultRailsBehaviourSpec
+  class TestController < ApplicationController
+    def two_respond_tos
+      respond_to {|f| f.html { first }}
+      respond_to {|f| f.html { second }}
+      render :text => ""
+    end
+  
+    def two_responses
+      respond_to do |f|
+        f.html { first }
+        f.html { second }
+      end
+      render :text => ""
+    end
+  end
+
+  describe TestController do
+    #before(:all) do
+    #  Rails.application.routes.draw do
+    #    namespace :default_rails_behaviour_spec do
+    #      match 'test/:action' => 'test'
+    #    end
+    #  end
+    #end
+    #after(:all) { Rails.application.routes.clear! }
+    
+    describe "GET :two_respond_tos" do
+      after { get :two_respond_tos }
+    
+      it "should recieve first and second in order" do
+        @controller.should_receive(:first).once.ordered
+        @controller.should_receive(:second).once.ordered
+      end
+    end
+  
+    describe "GET :two_responses" do
+      after { get :two_responses }
+    
+      it "should only receive first and NOT second" do
+        @controller.should_receive(:first).once
+        @controller.should_not_receive(:second)
+      end
+    end
+  end
+end