render_component_vho 3.0.2

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 vhochstein
+
+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

@@ -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,60 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+require './lib/render_component/version.rb'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "render_component_vho"
+  gem.version = RenderComponent::Version::STRING
+  gem.homepage = "http://github.com/vhochstein/render_component"
+  gem.license = "MIT"
+  gem.summary = %Q{render actions in other controllers for their rendered response}
+  gem.description = %Q{Components allow you to call other actions for their rendered response while executing another action}
+  gem.email = "david@loudthinking.com"
+  gem.authors = ["David Heinemeier Hansson"]
+  gem.add_runtime_dependency 'railties', '~>3.0.0'
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+
+require 'rake/testtask'
+desc 'Test the components plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+
+desc 'Generate documentation for the components plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "render_component #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1,2 @@
+RENDER_COMPONENT_PLUGIN = true
+require 'render_component'

data/lib/render_component.rb

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

data/lib/render_component/components.rb

@@ -0,0 +1,153 @@
+module RenderComponent
+  module Components
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        include InstanceMethods
+        extend ClassMethods
+        helper 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
+            request_env["action_dispatch.request.path_parameters"] = Hash[request_params.select{|key, value| [:controller, :action].include?(key)}].with_indifferent_access
+            request_env["warden"] = request.env["warden"] if (request.env.has_key?("warden"))
+            component_request = ActionDispatch::Request.new(request_env)
+
+            # its an internal request request forgery protection has to be disabled
+            # because otherwise forgery detection might raise an error
+            component_request.instance_eval do
+              def forgery_whitelisted?
+                true
+              end
+            end
+            component_request
+          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
+end

data/lib/render_component/version.rb

@@ -0,0 +1,9 @@
+module RenderComponent
+  module Version
+    MAJOR = 3
+    MINOR = 0
+    PATCH = 2
+
+    STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+  end
+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,153 @@
+--- !ruby/object:Gem::Specification 
+name: render_component_vho
+version: !ruby/object:Gem::Version 
+  hash: 3
+  prerelease: false
+  segments: 
+  - 3
+  - 0
+  - 2
+  version: 3.0.2
+platform: ruby
+authors: 
+- David Heinemeier Hansson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-26 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: shoulda
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: bundler
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id002
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id003
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: rcov
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: railties
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  requirement: *id005
+  type: :runtime
+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: 
+- LICENSE.txt
+- README
+files: 
+- .document
+- LICENSE.txt
+- README
+- Rakefile
+- init.rb
+- lib/render_component.rb
+- lib/render_component/components.rb
+- lib/render_component/version.rb
+- test/abstract_unit.rb
+- test/components_test.rb
+has_rdoc: true
+homepage: http://github.com/vhochstein/render_component
+licenses: 
+- MIT
+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: render actions in other controllers for their rendered response
+test_files: 
+- test/abstract_unit.rb
+- test/components_test.rb