render_component_4 4.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2b25925b5536281831d8c613483166489b67ec1d
+  data.tar.gz: 0cfbfd0052ab37972b3245cd897f043938fa057c
+SHA512:
+  metadata.gz: f132ae42ab636a1c75b4e707aceea9f37a88a4a192ea9e1ddfeaf3076ba1a4a2b8f58bb66ae2ac6b160593b5d492f7877ae45d083b8d1cb2a0853fd2d999f2aa
+  data.tar.gz: d4b51c2d3dac0094ba6bf3f3d6b41c501a138d4b82afe52495f14c0c814b1c8403fdca972a9763243bd2ecbbb5e162719b07e9aeceae93376b7ebaa31879888c

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Sergio Cambra
+
+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/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,159 @@
+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
+        # disabling since this is breaking flash..
+        #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)
+                debugger
+                @parent_controller.flash
+              elsif session['flash'].class == String
+                warn "WARNING: something, somehow, has replaced the flash by a inspect.to_s output. >>>#{session['flash']}<<<"
+                session['flash'] = ActionDispatch::Flash::FlashHash.new
+              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)
+          options[:controller] = options[:controller].to_s if options[:controller] && options[:controller].is_a?(Symbol)
+          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 = 4
+    MINOR = 1
+    PATCH = 4
+
+    STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: render_component_4
+version: !ruby/object:Gem::Version
+  version: 4.1.4
+platform: ruby
+authors:
+- David Heinemeier Hansson
+- Sergio Cambra
+- Mathieu Jobin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+description: Components allow you to call other actions for their rendered response
+  while executing another action
+email:
+- david@loudthinking.com
+- sergio@programatica.es
+- mathieu@justbudget.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README
+files:
+- LICENSE.txt
+- README
+- lib/render_component.rb
+- lib/render_component/components.rb
+- lib/render_component/version.rb
+homepage: http://github.com/somekool/render_component
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: render actions in other controllers for their rendered response
+test_files: []
+has_rdoc: