reactive-mvc 0.2.0

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2008-2009 Pascal Hurni
+Copyright (c) 2004-2007 David Heinemeier Hansson
+
+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/Manifest

@@ -0,0 +1,34 @@
+LICENSE
+Manifest
+README
+Rakefile
+lib/reactive-mvc.rb
+lib/reactive-mvc/controller.rb
+lib/reactive-mvc/controller/base.rb
+lib/reactive-mvc/controller/filters.rb
+lib/reactive-mvc/controller/flash.rb
+lib/reactive-mvc/controller/helpers.rb
+lib/reactive-mvc/controller/layout.rb
+lib/reactive-mvc/controller/output.rb
+lib/reactive-mvc/controller/rescue.rb
+lib/reactive-mvc/dispatcher.rb
+lib/reactive-mvc/view.rb
+lib/reactive-mvc/view/base.rb
+lib/reactive-mvc/view/helpers.rb
+lib/reactive-mvc/view/partials.rb
+lib/reactive-mvc/view/paths.rb
+lib/reactive-mvc/view/renderable.rb
+lib/reactive-mvc/view/renderable_partial.rb
+lib/reactive-mvc/view/template.rb
+lib/reactive-mvc/view/template_error.rb
+lib/reactive-mvc/view/template_handler.rb
+lib/reactive-mvc/view/template_handlers.rb
+lib/reactive-mvc/view/template_handlers/builder.rb
+lib/reactive-mvc/view/template_handlers/erb.rb
+lib/reactive-mvc/view/template_handlers/ruby_code.rb
+reactive_app_generators/mvc/USAGE
+reactive_app_generators/mvc/mvc_generator.rb
+reactive_app_generators/mvc/templates/application_controller.rb
+reactive_generators/controller/USAGE
+reactive_generators/controller/controller_generator.rb
+reactive_generators/controller/templates/controller.rb

data/README

@@ -0,0 +1,30 @@
+== reactive-mvc
+
+Reactive plugin that dispatches requests to a local MVC machinery.
+
+Version::  0.2.0
+Author::   Pascal Hurni
+Email::    phi@ruby-reactive.org
+Homepage:: http://www.ruby-reactive.org
+
+== Description
+
+Provides a local MVC machinery to handle requests of the reactive application.
+The machinery is mapped to what is done in RubyOnRails, so you'll have rails like
+controllers, rails like views and helpers.
+
+Because Reactive is Model and View agnostic, this plugin alone will
+not do the complete job.
+
+== Configuration
+
+<paths> :mvc::         Path to the root of the mvc files. Defaults to "app"
+<paths> :model::       Path for model files. Defaults to ":mvc/models"
+<paths> :views::       Array of paths for views. Defaults to ":mvc/views"
+<paths> :controller::  Path for controllers. Defaults to ":mvc/controllers"
+<paths> :helper::      Path for view helpers. Defaults to ":mvc/helpers"
+
+== Requirements
+
+* reactive-core >= 0.2.0
+* activesupport >= 2.0.0

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rubygems'
+
+unless Gem.source_index.find_name('reactive-dev').empty?
+  require 'reactive-dev/tasks/plugin'
+end

data/lib/reactive-mvc.rb

@@ -0,0 +1,26 @@
+Reactive::Initializer.configure :mvc do
+  Reactive.configuration.paths[:mvc] = Reactive.configuration.reactive_mvc.root_path || Reactive.path_for("app")
+  Reactive.configuration.paths[:views] = Reactive.configuration.reactive_mvc.view_paths || [Reactive.path_for(:mvc, "views")]
+  Reactive.configuration.paths[:model] = Reactive.configuration.reactive_mvc.model_path || Reactive.path_for(:mvc, "models")
+  Reactive.configuration.paths[:helper] = Reactive.configuration.reactive_mvc.helper_path || Reactive.path_for(:mvc, "helpers")
+  Reactive.configuration.paths[:controller] = Reactive.configuration.reactive_mvc.controller_path || Reactive.path_for(:mvc, "controllers")
+  Reactive.configuration.paths[:test] = Reactive.configuration.reactive_mvc.test_path || Reactive.path_for("test")
+end
+
+Reactive::Initializer.init :mvc do
+  require 'reactive-mvc/dispatcher'
+  require 'reactive-mvc/controller'
+  require 'reactive-mvc/view'
+
+# TODO: Seems that this is not required? So how does ruby load application_controller.rb ???
+#  ActiveSupport::Dependencies.load_paths |= [:model, :helper, :controller].collect {|dir_id| Reactive.path_for dir_id}
+
+  Reactive::Mvc::Controller::Base.logger = Reactive::Mvc::View::Base.logger = Reactive.configuration.reactive_mvc.logger || Reactive.logger
+  
+  Reactive::Dispatcher::Base.register(:mvc, Reactive::Mvc::Dispatcher)
+
+  ActiveSupport::Dependencies.load_paths.push Reactive.configuration.paths[:model], Reactive.configuration.paths[:helper], Reactive.configuration.paths[:controller]
+  
+  # TODO: modify the behaviour of paths directly in Controller::Base
+  Reactive::Mvc::Controller::Base.view_paths = Reactive.configuration.paths[:views]
+end

data/lib/reactive-mvc/controller.rb

@@ -0,0 +1,16 @@
+require 'reactive-mvc/controller/base'
+require 'reactive-mvc/controller/rescue'
+require 'reactive-mvc/controller/flash'
+require 'reactive-mvc/controller/filters'
+require 'reactive-mvc/controller/layout'
+require 'reactive-mvc/controller/helpers'
+require 'reactive-mvc/controller/output'
+
+Reactive::Mvc::Controller::Base.class_eval do
+  include Reactive::Mvc::Controller::Flash
+  include Reactive::Mvc::Controller::Filters
+  include Reactive::Mvc::Controller::Layout
+  include Reactive::Mvc::Controller::Rescue
+  include Reactive::Mvc::Controller::Helpers
+  include Reactive::Mvc::Controller::Output
+end

data/lib/reactive-mvc/controller/base.rb

@@ -0,0 +1,405 @@
+module Reactive::Mvc
+  module Controller
+    class Error < Reactive::Error #:nodoc:
+    end
+  
+    class MethodNotAllowed < Error #:nodoc:
+      attr_reader :allowed_methods
+
+      def initialize(*allowed_methods)
+        super("Only #{allowed_methods.to_sentence} requests are allowed.")
+        @allowed_methods = allowed_methods
+      end
+
+      def allowed_methods_header
+        allowed_methods.map { |method_symbol| method_symbol.to_s.upcase } * ', '
+      end
+
+      def handle_response!(response)
+        response.headers['Allow'] ||= allowed_methods_header
+      end
+    end
+
+    class NotImplemented < MethodNotAllowed #:nodoc:
+    end
+
+    class UnknownController < Error #:nodoc:
+    end
+
+    class UnknownAction < Error #:nodoc:
+    end
+
+    class MissingFile < Error #:nodoc:
+    end
+
+    class RenderError < Error #:nodoc:
+    end
+
+    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
+      
+      # Controller specific instance variables which will not be accessible inside views.
+      cattr_reader :protected_instance_variables
+      @@protected_instance_variables = %w(@assigns @performed_redirect @performed_render @parent_controller
+                                          @action_name @before_filter_chain_aborted @_params @_flash @_response)
+
+      # 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
+
+      # 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
+      
+      @@template_classes = {}
+      
+      class << self
+      
+        def process(request, response) #, method = :perform_action, *arguments)
+          new.process(request, response) #, method, *arguments)
+        end
+      
+        def register_template_class(format, klass)
+          @@template_classes[format.to_sym] = klass
+        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
+          read_inheritable_attribute(:hidden_actions) || write_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:
+        assign_params(request)
+        initialize_template_class(response)
+        assign_shortcuts(request, response)
+
+        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(:file => default_template_name, :layout => true)
+          elsif !options.is_a?(Hash)
+            raise RenderError, "You called render with invalid options : #{options.inspect}"
+          end
+        
+          layout = pick_layout(options)
+          logger.info("Rendering template within #{layout}") if logger && layout
+
+          if options.has_key?(:text)
+            text = layout ? @template.render(options.merge(:text => options[:text], :layout => layout)) : options[:text]
+            render_for_text(text, options[:status])
+
+          else
+            if file = options[:file]
+              render_for_file(file, options[:status], layout, options[:locals] || {})
+
+            elsif template = options[:template]
+              render_for_file(template, options[:status], layout, options[:locals] || {})
+
+            elsif inline = options[:inline]
+              render_for_text(@template.render(options.merge(:layout => layout)), options[:status])
+
+            elsif action_name = options[:action]
+              render_for_file(default_template_name(action_name.to_s), options[:status], layout)
+
+            elsif options[:partial]
+              options[:partial] = default_template_name if options[:partial] == true
+              if layout
+                render_for_text(@template.render(:text => @template.render(options), :layout => layout), options[:status])
+              else
+                render_for_text(@template.render(options), options[:status])
+              end
+
+            elsif options[:nothing]
+              render_for_text("", options[:status])
+
+            else
+              render_for_file(default_template_name, options[:status], layout)
+            end
+          end
+        end
+
+        # Renders according to the same rules as <tt>render</tt>, but returns the result in a string instead
+        # of sending it as the response body to the browser.
+        def render_to_string(options = nil, &block) #:doc:
+          render(options, &block)
+        ensure
+          erase_render_results
+          reset_variables_added_to_assigns
+        end
+
+        # Clears the rendered results, allowing for another render to be performed.
+        def erase_render_results #:nodoc:
+          response.clear
+          @performed_render = false
+        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
+
+      private
+
+        def render_for_file(template_path, status = nil, layout = nil, locals = {}) #:nodoc:
+          logger.info("Rendering #{template_path}" + (status ? " (#{status})" : '')) if logger
+          render_for_text(@template.render(:file => template_path, :locals => locals, :layout => layout), status)
+        end
+
+        def render_for_text(text = nil, status = nil) #:nodoc:
+          @performed_render = true
+          (instance_variable_names - protected_instance_variables).each {|name| response.variables[name[1..-1].to_sym] = instance_variable_get(name)}
+          response.body = text.to_s
+          # when will we get a proc? TODO investigate: response.body = text.is_a?(Proc) ? text : text.to_s
+        end
+
+        def assign_params(request)
+          @action_name = request.params[:action] || 'index'
+          @format = request.format
+          @_params = request.params.clone
+          @_params.delete(:controller)
+          @_params.delete(:action)
+        end
+
+        def initialize_template_class(response)
+          # Find the suitable Template class for the format of the request TODO: use class inheritable attr instead
+          template_class = @@template_classes[@format] || Reactive::Mvc::View::Base
+          #unless template_class = @@template_classes[@format]
+          #  raise "You must assign a template class through Reactive::Controller::Base.register_template_class before processing a request\n" +
+          #         "This may also happen when no view provider is configured. Check that you have one in config/environment.rb with config.gem 'your_view_provider'"
+          #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
+        end
+
+        def log_processing
+          if logger && logger.info?
+            logger.info "Processing #{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 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?
+            default_render
+          else
+            raise UnknownAction, "No action responded to #{action_name}", caller
+          end
+        end
+      
+        def performed?
+          @performed_render || @performed_redirect
+        end
+
+        def action_methods
+          self.class.action_methods
+        end
+
+        def self.action_methods
+        @action_methods ||=
+          # All public instance methods of this class, including ancestors
+          public_instance_methods(true).map { |m| m.to_s }.to_set -
+          # Except for public instance methods of Base and its ancestors
+          Base.public_instance_methods(true).map { |m| m.to_s } +
+          # Be sure to include shadowed public instance methods of this class
+          public_instance_methods(false).map { |m| m.to_s } -
+          # And always exclude explicitly hidden actions
+          hidden_actions
+        end
+
+        def reset_variables_added_to_assigns
+          @template.instance_variable_set("@assigns_added", nil)
+        end
+         
+        def template_exists?(template_name = default_template_name)
+          @template.template_exists?(template_name)         # TODO: Contract with the View provider!!!
+        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.controller_path}/#{action_name}"
+        end
+
+        def strip_out_controller(path)
+          path.split('/', 2).last
+        end
+
+        def template_path_includes_controller?(path)
+          self.controller_path.split('/')[-1] == path.split('/')[0]
+        end
+
+        def process_cleanup
+        end
+    end
+
+  end
+
+end