reactive 0.1.0

data/lib/controller.rb

@@ -0,0 +1,23 @@
+
+require 'controller/base'
+require 'controller/flash'
+require 'controller/filters'
+require 'controller/layout'
+require 'controller/helpers'
+
+Reactive::Controller::Base.class_eval do
+  include Reactive::Controller::Flash
+  include Reactive::Controller::Filters
+  include Reactive::Controller::Layout
+  include Reactive::Controller::Helpers
+
+=begin
+  include ActionController::Benchmarking
+  include ActionController::Rescue
+  include ActionController::MimeResponds
+  include ActionController::Verification
+  include ActionController::Streaming
+  include ActionController::Components
+  include ActionController::RecordIdentifier
+=end
+end

data/lib/controller/base.rb

@@ -0,0 +1,442 @@
+
+module Reactive
+  module Controller
+  
+    class Error < StandardError; end #:nodoc:
+    class UnknownAction < Error; end #:nodoc:
+    class MissingTemplate < Error; end #:nodoc:
+    class RenderError < Error; end #:nodoc:
+    class DoubleRenderError < Error #:nodoc:
+      DEFAULT_MESSAGE = "Render and/or redirect were called multiple times in this action. Please note that you may only call render OR redirect, and at most once per action. Also note that neither redirect nor render terminate execution of the action, so if you want to exit an action after redirecting, you need to do something like \"redirect_to(...) and return\"."
+
+      def initialize(message = nil)
+        super(message || DEFAULT_MESSAGE)
+      end
+    end
+  
+    class Base
+
+      # The logger is used for generating information on the action run-time (including benchmarking) if available.
+      # Can be set to nil for no logging. Compatible with both Ruby's own Logger and Log4r loggers.
+      cattr_accessor :logger
+
+      # Determines which template class should be used by the Controllers.
+      cattr_accessor :template_class
+
+      # Turn on +ignore_missing_templates+ if you want to unit test actions without making the associated templates.
+      cattr_accessor :ignore_missing_templates
+
+      # Returns the name of the action this controller is processing.
+      attr_reader :action_name
+
+      # Holds the request object that will be used by the dispatcher.
+      attr_internal :request
+
+      # Holds the response object that will be used by the dispatcher.
+      attr_internal :response
+
+      # Holds a hash of all the parameters passed to the action. Accessed like <tt>params["post_id"]</tt>
+      # to get the post_id. No type casts are made, so all values are of the initial type of the request.
+      attr_internal :params
+
+      # Templates that are exempt from layouts
+      @@exempt_from_layout = Set.new #Set.new([/\.rb$/])
+      
+      class << self
+      
+        def process(request, response, method = :perform_action, *arguments)
+          new.process(request, response, method, *arguments)
+        end
+
+        # Converts the class name from something like "OneModule::TwoModule::NeatController" to "NeatController".
+        def controller_class_name
+          @controller_class_name ||= name.demodulize
+        end
+
+        # Converts the class name from something like "OneModule::TwoModule::NeatController" to "neat".
+        def controller_name
+          @controller_name ||= controller_class_name.sub(/Controller$/, '').underscore
+        end
+
+        # Converts the class name from something like "OneModule::TwoModule::NeatController" to "one_module/two_module/neat".
+        def controller_path
+          @controller_path ||= name.gsub(/Controller$/, '').underscore
+        end
+
+        # Return an array containing the names of public methods that have been marked hidden from the action processor.
+        # By default, all methods defined in ActionController::Base and included modules are hidden.
+        # More methods can be hidden using <tt>hide_actions</tt>.
+        def hidden_actions
+          unless read_inheritable_attribute(:hidden_actions)
+            write_inheritable_attribute(:hidden_actions, Controller::Base.public_instance_methods.map(&:to_s))
+          end
+
+          read_inheritable_attribute(:hidden_actions)
+        end
+
+        # Hide each of the given methods from being callable as actions.
+        def hide_action(*names)
+          write_inheritable_attribute(:hidden_actions, hidden_actions | names.map(&:to_s))
+        end
+
+        ## View load paths determine the bases from which template references can be made. So a call to
+        ## render("test/template") will be looked up in the view load paths array and the closest match will be
+        ## returned.
+        def view_paths
+          @view_paths || superclass.view_paths
+        end
+
+        def view_paths=(value)
+          @view_paths = value
+        end
+
+        # Adds a view_path to the front of the view_paths array.
+        # If the current class has no view paths, copy them from 
+        # the superclass.  This change will be visible for all future requests.
+        #
+        #   ArticleController.prepend_view_path("views/default")
+        #   ArticleController.prepend_view_path(["views/default", "views/custom"])
+        #
+        def prepend_view_path(path)
+          @view_paths = superclass.view_paths.dup if @view_paths.nil?
+          view_paths.unshift(*path)
+        end
+        
+        # Adds a view_path to the end of the view_paths array.
+        # If the current class has no view paths, copy them from 
+        # the superclass. This change will be visible for all future requests.
+        #
+        #   ArticleController.append_view_path("views/default")
+        #   ArticleController.append_view_path(["views/default", "views/custom"])
+        #
+        def append_view_path(path)
+          @view_paths = superclass.view_paths.dup if @view_paths.nil?
+          view_paths.push(*path)
+        end
+
+      end
+    
+      # Extracts the action_name from the request parameters and performs that action.
+      def process(request, response, method = :perform_action, *arguments) #:nodoc:
+        initialize_template_class(response)
+        assign_params(request.params)
+        assign_shortcuts(request, response)
+        forget_variables_added_to_assigns
+
+        log_processing
+        send(method, *arguments)
+
+        response
+      ensure
+        process_cleanup
+      end
+
+      # Converts the class name from something like "OneModule::TwoModule::NeatController" to "NeatController".
+      def controller_class_name
+        self.class.controller_class_name
+      end
+
+      # Converts the class name from something like "OneModule::TwoModule::NeatController" to "neat".
+      def controller_name
+        self.class.controller_name
+      end
+
+      # Converts the class name from something like "OneModule::TwoModule::NeatController" to "one_module/two_module/neat".
+      def controller_path
+        self.class.controller_path
+      end
+
+      self.view_paths = []
+      
+      # View load paths for controller.
+      def view_paths
+        (@template || self.class).view_paths
+      end
+    
+      def view_paths=(value)
+        (@template || self.class).view_paths = value
+      end
+
+      # Adds a view_path to the front of the view_paths array.
+      # This change affects the current request only.
+      #
+      #   self.prepend_view_path("views/default")
+      #   self.prepend_view_path(["views/default", "views/custom"])
+      #
+      def prepend_view_path(path)
+        (@template || self.class).prepend_view_path(path)
+      end
+      
+      # Adds a view_path to the end of the view_paths array.
+      # This change affects the current request only.
+      #
+      #   self.append_view_path("views/default")
+      #   self.append_view_path(["views/default", "views/custom"])
+      #
+      def append_view_path(path)
+        (@template || self.class).append_view_path(path)
+      end
+
+      protected
+        # render
+        def render(options = nil, &block) #:doc:
+          raise DoubleRenderError, "Can only render or redirect once per action" if performed?
+
+          if options.nil?
+            return render_for_file(default_template_name, nil, true)
+          else
+            if options == :update
+              options = { :update => true }
+            elsif !options.is_a?(Hash)
+              raise RenderError, "You called render with invalid options : #{options}"
+            end
+          end
+
+          if text = options[:text]
+            render_for_text(text, options[:status])
+
+          else
+            if file = options[:file]
+              render_for_file(file, options[:status], options[:use_full_path], options[:locals] || {})
+
+            elsif template = options[:template]
+              render_for_file(template, options[:status], true)
+
+            elsif inline = options[:inline]
+              add_variables_to_assigns
+              render_for_text(@template.render_template(options[:type], inline, nil, options[:locals] || {}), options[:status])
+
+            elsif action_name = options[:action]
+              template = default_template_name(action_name.to_s)
+              if options[:layout] && !template_exempt_from_layout?(template)
+                render_with_a_layout(:file => template, :status => options[:status], :use_full_path => true, :layout => true)              
+              else
+                render_with_no_layout(:file => template, :status => options[:status], :use_full_path => true)
+              end            
+
+            elsif partial = options[:partial]
+              partial = default_template_name if partial == true
+              add_variables_to_assigns
+
+              if collection = options[:collection]
+                render_for_text(
+                  @template.send!(:render_partial_collection, partial, collection, 
+                  options[:spacer_template], options[:locals]), options[:status]
+                )
+              else
+                render_for_text(
+                  @template.send!(:render_partial, partial, 
+                  ActionView::Base::ObjectWrapper.new(options[:object]), options[:locals]), options[:status]
+                )
+              end
+
+            elsif options[:update]
+              raise NotImplementedError
+              add_variables_to_assigns
+              @template.send! :evaluate_assigns
+
+              generator = ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.new(@template, &block)
+              response.content_type = Mime::JS
+              render_for_text(generator.to_s)
+
+            elsif options[:nothing]
+              render_for_text(" ", options[:status])
+
+            else
+              render_for_file(default_template_name, options[:status], true)
+            end
+          end
+        end
+      
+        def render_for_file(template_path, status = nil, use_full_path = false, locals = {}) #:nodoc:
+#puts "Controller#render_for_file(#{template_path}) request: #{request.inspect}"
+          add_variables_to_assigns
+          assert_existence_of_template_file(template_path) if use_full_path
+          logger.info("Rendering #{template_path}" + (status ? " (#{status})" : '')) if logger
+          render_for_text(@template.render_file(template_path, use_full_path, locals), status)
+        end
+
+        def render_for_text(text = nil, status = nil) #:nodoc:
+          @performed_render = true
+          response.result = text.to_s
+          # when will we get a proc? TODO investigate: response.body = text.is_a?(Proc) ? text : text.to_s
+        end
+
+        # Redirects to the target specified in +options+. This parameter can take one of three forms:
+        #
+        # * <tt>Hash</tt> - The URL will be generated by calling url_for with the +options+.
+        # * <tt>Record</tt> - The URL will be generated by calling url_for with the +options+, which will reference a named URL for that record.
+        #
+        # Examples:
+        #   redirect_to :action => "show", :id => 5
+        #   redirect_to post
+        #   redirect_to articles_url
+        #
+        def redirect_to(options = {}) #:doc: 
+          raise DoubleRenderError if performed?
+          logger.info("Redirected to #{options}") if logger && logger.info?
+          response.redirected_to = options
+          @performed_redirect = true
+        end
+
+        def assign_params(params)
+          @action_name = params[:action] || 'index'
+          @_params = params.clone
+          @_params.delete(:controller)
+          @_params.delete(:action)
+        end
+
+        def initialize_template_class(response)
+          unless @@template_class
+            raise "You must assign a template class through Reactive::Controller::Base.template_class= before processing a request"
+          end
+
+          response.template = @@template_class.new(view_paths, {}, self)
+          response.template.extend self.class.master_helper_module
+          response.redirected_to = nil
+          @performed_render = @performed_redirect = false
+        end
+
+        def assign_shortcuts(request, response)
+          @_request = request
+          @_response = response
+          @template = response.template
+          @assigns  = @_response.template.assigns
+        end
+
+        def log_processing
+          if logger && logger.info?
+            logger.info "\n\nProcessing #{controller_class_name}\##{action_name}"
+            logger.info "  Parameters: #{respond_to?(:filter_parameters) ? filter_parameters(@_params).inspect : @_params.inspect}"
+          end
+        end
+
+        def default_render #:nodoc:
+          render
+        end
+
+        def perform_action
+          if self.class.action_methods.include?(action_name)
+            send(action_name)
+            default_render unless performed?
+          elsif respond_to? :method_missing
+            method_missing action_name
+            default_render unless performed?
+          elsif template_exists? && template_public?
+            default_render
+          else
+            raise UnknownAction, "No action responded to #{action_name}", caller
+          end
+        end
+      
+        def perform_init
+          template_name = "application"
+          #TODO: refactor this
+          if true #if template_exists?(template_name) && template_public?(template_name)
+            render :template => template_name, :layout => false
+          else
+            raise MissingTemplate, "Missing #{template_name} (the initial view) in view path #{view_paths.join(':')}"
+          end
+        end
+
+        def performed?
+          @performed_render || @performed_redirect
+        end
+
+        def action_methods
+          self.class.action_methods
+        end
+
+        def self.action_methods
+          @action_methods ||= Set.new(public_instance_methods.map(&:to_s)) - hidden_actions
+        end
+
+        def add_variables_to_assigns
+          unless @variables_added
+            add_instance_variables_to_assigns
+#TODO            add_class_variables_to_assigns if view_controller_internals
+            @variables_added = true
+          end
+        end
+
+        def forget_variables_added_to_assigns
+          @variables_added = nil
+        end
+
+        def reset_variables_added_to_assigns
+          @template.instance_variable_set("@assigns_added", nil)
+        end
+
+        def add_instance_variables_to_assigns
+          @@protected_variables_cache ||= Set.new(protected_instance_variables)
+          instance_variables.each do |var|
+            next if @@protected_variables_cache.include?(var)
+            @assigns[var[1..-1]] = instance_variable_get(var)
+          end
+        end
+
+        def add_class_variables_to_assigns
+          %w(view_paths logger template_class ignore_missing_templates).each do |cvar|
+            @assigns[cvar] = self.send(cvar)
+          end
+        end
+
+        def protected_instance_variables
+#          if view_controller_internals
+            %w(@assigns @performed_redirect @performed_render)
+#          else
+#            %w(@assigns @performed_redirect @performed_render
+#               @_request @request @_response @response @_params @params
+#               @template @request_origin @parent_controller)
+#          end
+        end
+         
+        def template_exists?(template_name = default_template_name)
+          @template.file_exists?(template_name)
+        end
+
+        def template_public?(template_name = default_template_name)
+          @template.file_public?(template_name)
+        end
+
+        def template_exempt_from_layout?(template_name = default_template_name)
+          extension = @template && @template.pick_template_extension(template_name)
+          name_with_extension = !template_name.include?('.') && extension ? "#{template_name}.#{extension}" : template_name
+          @@exempt_from_layout.any? { |ext| name_with_extension =~ ext }
+        end
+
+        def assert_existence_of_template_file(template_name)
+  return true
+          unless template_exists?(template_name) || ignore_missing_templates
+            full_template_path = template_name.include?('.') ? template_name : "#{template_name}.#{@template.template_format}.rb"
+            display_paths = view_paths.join(':')
+            template_type = (template_name =~ /layouts/i) ? 'layout' : 'template'
+            raise(MissingTemplate, "Missing #{template_type} #{full_template_path} in view path #{display_paths}")
+          end
+        end
+
+        def default_template_name(action_name = self.action_name)
+          if action_name
+            action_name = action_name.to_s
+            if action_name.include?('/') && template_path_includes_controller?(action_name)
+              action_name = strip_out_controller(action_name)
+            end
+          end
+          "#{self.class.controller_path}/#{action_name}"
+        end
+
+        def strip_out_controller(path)
+          path.split('/', 2).last
+        end
+
+        def template_path_includes_controller?(path)
+          self.class.controller_path.split('/')[-1] == path.split('/')[0]
+        end
+
+        def process_cleanup
+        end
+    end
+
+  end
+
+end