render_component 1.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in foo.gemspec
+gemspec

data/README

@@ -0,0 +1,37 @@
+Components allow you to call other actions for their rendered response while executing another action. You can either delegate
+the entire response rendering or you can mix a partial response in with your other content.
+
+  class WeblogController < ActionController::Base
+    # Performs a method and then lets hello_world output its render
+    def delegate_action
+      do_other_stuff_before_hello_world
+      render_component :controller => "greeter",  :action => "hello_world", :params => { :person => "david" }
+    end
+  end
+
+  class GreeterController < ActionController::Base
+    def hello_world
+      render :text => "#{params[:person]} says, Hello World!"
+    end
+  end
+
+The same can be done in a view to do a partial rendering:
+
+  Let's see a greeting:
+  <%= render_component :controller => "greeter", :action => "hello_world" %>
+
+It is also possible to specify the controller as a class constant, bypassing the inflector
+code to compute the controller class at runtime:
+
+<%= render_component :controller => GreeterController, :action => "hello_world" %>
+
+== When to use components
+
+Components should be used with care. They're significantly slower than simply splitting reusable parts into partials and
+conceptually more complicated. Don't use components as a way of separating concerns inside a single application. Instead,
+reserve components to those rare cases where you truly have reusable view and controller elements that can be employed
+across many applications at once.
+
+So to repeat: Components are a special-purpose approach that can often be replaced with better use of partials and filters.
+
+Copyright (c) 2007 David Heinemeier Hansson, released under the MIT license

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+ 
+desc 'Default: run unit tests.'
+task :default => :test
+ 
+desc 'Test the components plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+ 
+desc 'Generate documentation for the components plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'Components'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1,3 @@
+require 'components'
+require 'action_dispatch/middleware/flash'
+ActionController::Base.send :include, Components

data/lib/components.rb

@@ -0,0 +1,140 @@
+module Components
+  def self.included(base) #:nodoc:
+    base.class_eval do
+      include InstanceMethods
+      extend ClassMethods
+      ActionView::Base.send(:include, HelperMethods)
+
+      # If this controller was instantiated to process a component request,
+      # +parent_controller+ points to the instantiator of this controller.
+      attr_accessor :parent_controller
+
+      alias_method_chain :session, :render_component
+      alias_method_chain :flash, :render_component
+      alias_method :component_request?, :parent_controller
+    end
+  end
+
+  module ClassMethods
+    # Track parent controller to identify component requests
+    def process_with_components(request, action, parent_controller = nil) #:nodoc:
+      controller = new
+      controller.parent_controller = parent_controller
+      controller.dispatch(action, request)
+    end
+  end
+
+  module HelperMethods
+    def render_component(options)
+      controller.send(:render_component_into_view, options)
+    end
+  end
+
+  module InstanceMethods
+    
+    protected
+      # Renders the component specified as the response for the current method
+      def render_component(options) #:doc:
+        component_logging(options) do
+          response = component_response(options, true)[2]
+          if response.redirect_url
+            redirect_to response.redirect_url
+          else
+            render :text => response.body, :status => response.status
+          end
+        end
+      end
+      
+      # Returns the component response as a string
+      def render_component_into_view(options) #:doc:
+        component_logging(options) do
+          response = component_response(options, false)[2]
+          if redirected = response.redirect_url
+            if redirected =~ %r{://}
+              location = URI.parse(redirected)
+              redirected = location.query ? "#{location.path}?#{location.query}" : location.path
+            end 
+            render_component_into_view(Rails.application.routes.recognize_path(redirected, { :method => nil }))
+          else
+            response.body.html_safe
+          end
+        end
+      end
+      
+      
+      def flash_with_render_component(refresh = false) #:nodoc:
+        if @component_flash.nil? || refresh
+          @component_flash =
+            if defined?(@parent_controller)
+              @parent_controller.flash
+            else
+              session['flash'] ||= ActionDispatch::Flash::FlashHash.new
+            end
+        end
+        @component_flash
+      end
+      
+      def session_with_render_component
+        #if defined?(@parent_controller)
+        if component_request?
+          @parent_controller.session
+        else
+          @_request.session
+        end
+      end
+      
+    private
+      def component_response(options, reuse_response)
+        klass = component_class(options)
+        component_request  = request_for_component(klass.controller_path, options)
+        # needed ???
+        #if reuse_response
+          #component_request.env["action_controller.instance"].instance_variable_set :@_response, request.env["action_controller.instance"].instance_variable_get(:@_response)  
+        #end
+        klass.process_with_components(component_request, options[:action], self)
+      end
+
+      # determine the controller class for the component request
+      def component_class(options)
+        if controller = options[:controller]
+          controller.is_a?(Class) ? controller : "#{controller.to_s.camelize}Controller".constantize
+        else
+          self.class
+        end
+      end
+
+      # Create a new request object based on the current request.
+      # NOT IMPLEMENTED FOR RAILS 3 SO FAR: The new request inherits the session from the current request,
+      # bypassing any session options set for the component controller's class
+      def request_for_component(controller_path, options)
+        if options.is_a? Hash
+          old_style_params = options.delete(:params)
+          options.merge!(old_style_params) unless old_style_params.nil?
+          
+          request_params = options.symbolize_keys
+          request_env = {}
+          
+          request.env.select {|key, value| key == key.upcase || key == 'rack.input'}.each {|item| request_env[item[0]] = item[1]}
+          
+          request_env['REQUEST_URI'] = url_for(options)
+          request_env["PATH_INFO"] = url_for(options.merge(:only_path => true))
+          request_env["action_dispatch.request.symbolized_path_parameters"] = request_params 
+          request_env["action_dispatch.request.parameters"] = request_params.with_indifferent_access
+          ActionDispatch::Request.new(request_env)
+        else
+          request
+        end
+      end
+
+      def component_logging(options)
+        if logger
+          logger.info "Start rendering component (#{options.inspect}): "
+          result = yield
+          logger.info "\n\nEnd of component rendering"
+          result
+        else
+          yield
+        end
+      end
+  end
+end

data/lib/render_component.rb

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

data/render_component.gemspec

@@ -0,0 +1,19 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "render_component"
+  s.version     = "1.0.0"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["David Heinemeier Hansson"]
+  s.email       = ["david@loudthinking.com"]
+  s.homepage    = "https://rubygems.org/gems/render_component"
+  s.summary     = %q{Rails plugin to render other actions for their rendered response}
+  s.description = %q{Components allow you to call other actions for their rendered response while executing another action}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('railties', '~>3.0.0')
+end

data/test/abstract_unit.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../../../../config/environment', __FILE__)
+require 'rails/test_help'
+
+$: << File.dirname(__FILE__) + "/../lib"
+require File.dirname(__FILE__) + "/../init"

data/test/components_test.rb

@@ -0,0 +1,156 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+class CallersController < ActionController::Base
+  def calling_from_controller
+    render_component(:controller => "callees", :action => "being_called")
+  end
+
+  def calling_from_controller_with_params
+    render_component(:controller => "callees", :action => "being_called", :params => { "name" => "David" })
+  end
+  
+  def calling_from_controller_with_session
+    session['name'] = 'Bernd'
+    render_component(:controller => "callees", :action => "being_called")
+  end
+
+  def calling_from_controller_with_different_status_code
+    render_component(:controller => "callees", :action => "blowing_up")
+  end
+
+  def calling_from_template
+    render :inline => "Ring, ring: <%= render_component(:controller => 'callees', :action => 'being_called') %>"
+  end
+
+  def internal_caller
+    render :inline => "Are you there? <%= render_component(:action => 'internal_callee') %>"
+  end
+
+  def internal_callee
+    render :text => "Yes, ma'am"
+  end
+
+  def set_flash
+    render_component(:controller => "callees", :action => "set_flash")
+  end
+
+  def use_flash
+    render_component(:controller => "callees", :action => "use_flash")
+  end
+
+  def calling_redirected
+    render_component(:controller => "callees", :action => "redirected")
+  end
+
+  def calling_redirected_as_string
+    render :inline => "<%= render_component(:controller => 'callees', :action => 'redirected') %>"
+  end
+
+  def rescue_action(e) raise end
+end
+
+class CalleesController < ActionController::Base
+  def being_called
+    render :text => "#{params[:name] || session[:name] || "Lady"} of the House, speaking"
+  end
+
+  def blowing_up
+    render :text => "It's game over, man, just game over, man!", :status => 500
+  end
+
+  def set_flash
+    flash[:notice] = 'My stoney baby'
+    render :text => 'flash is set'
+  end
+
+  def use_flash
+    render :text => flash[:notice] || 'no flash'
+  end
+
+  def redirected
+    redirect_to :controller => "callees", :action => "being_called"
+  end
+
+  def rescue_action(e) raise end
+end
+
+class ComponentsTest < ActionController::IntegrationTest #ActionController::TestCase
+  
+  def setup
+    @routes.draw do 
+      match 'callers/:action', :to => 'callers'
+      match 'callees/:action', :to => 'callees'
+    end
+  end
+  
+  def test_calling_from_controller
+    get '/callers/calling_from_controller'
+    assert_equal "Lady of the House, speaking", @response.body
+  end
+
+  def test_calling_from_controller_with_params
+    get '/callers/calling_from_controller_with_params'
+    assert_equal "David of the House, speaking", @response.body
+  end
+
+  def test_calling_from_controller_with_different_status_code
+    get '/callers/calling_from_controller_with_different_status_code'
+    assert_equal 500, @response.response_code
+  end
+ 
+  def test_calling_from_template
+    get '/callers/calling_from_template'
+    assert_equal "Ring, ring: Lady of the House, speaking", @response.body
+  end
+
+  def test_etag_is_set_for_parent_template_when_calling_from_template
+    get '/callers/calling_from_template'
+    expected_etag = etag_for("Ring, ring: Lady of the House, speaking")
+    assert_equal expected_etag, @response.headers['ETag']
+  end
+
+  def test_internal_calling
+    get '/callers/internal_caller'
+    assert_equal "Are you there? Yes, ma'am", @response.body
+  end
+
+  def test_flash
+    get '/callers/set_flash'
+    assert_equal 'My stoney baby', flash[:notice]
+    get '/callers/use_flash'
+    assert_equal 'My stoney baby', @response.body
+    get '/callers/use_flash'
+    assert_equal 'no flash', @response.body
+  end
+
+  def test_component_redirect_redirects
+    get '/callers/calling_redirected'
+    assert_redirected_to :controller=>"callees", :action => "being_called"
+  end
+
+
+  def test_component_multiple_redirect_redirects
+    test_component_redirect_redirects
+    test_internal_calling
+  end
+
+
+  def test_component_as_string_redirect_renders_redirected_action
+    get '/callers/calling_redirected_as_string'
+
+    assert_equal "Lady of the House, speaking", @response.body
+  end
+  
+  def test_calling_from_controller_with_session
+    get '/callers/calling_from_controller_with_session'
+    assert_equal "Bernd of the House, speaking", @response.body
+  end
+  
+  
+
+
+  protected
+    def etag_for(text)
+      %("#{Digest::MD5.hexdigest(text)}")
+    end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: render_component
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- David Heinemeier Hansson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-16 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: railties
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+description: Components allow you to call other actions for their rendered response while executing another action
+email: 
+- david@loudthinking.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- README
+- Rakefile
+- init.rb
+- lib/components.rb
+- lib/render_component.rb
+- render_component.gemspec
+- test/abstract_unit.rb
+- test/components_test.rb
+has_rdoc: true
+homepage: https://rubygems.org/gems/render_component
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Rails plugin to render other actions for their rendered response
+test_files: 
+- test/abstract_unit.rb
+- test/components_test.rb