scaffolding_extensions 1.0.0

data/lib/scaffolding_extensions/controller.rb

@@ -0,0 +1,79 @@
+module ScaffoldingExtensions
+  # This holds instance methods that are shared between controllers.
+  module Controller
+    private
+      # Respond "Method not allowed" if the action requested is nonidempotent and the method used isn't POST
+      def scaffold_check_nonidempotent_requests
+        scaffold_method_not_allowed if scaffolded_nonidempotent_method?(scaffold_request_action) && scaffold_request_method != 'POST'
+      end
+      
+      # Force the given value into an array.  If the items is currently an array,
+      # return it.  If the item is nil or false, return the empty array.  Otherwise,
+      # return an array with the value as the only member.
+      def scaffold_force_array(value)
+        if value
+          Array === value ? value : [value]
+        else
+          []
+        end
+      end
+      
+      # Returns path to the given scaffold template file
+      def scaffold_path(template_name)
+        File.join(self.class.scaffold_template_dir, "#{template_name}.rhtml")
+      end
+      
+      # Redirect to the appropriate form for the scaffolded model
+      #
+      # You can override this method on multiple levels.  You can override a single
+      # action for all models via scaffold_#{action}_redirect (e.g.
+      # scaffold_edit_redirect or scaffold_new_redirect):
+      #
+      #   def scaffold_#{action}_redirect(suffix, notice)
+      #     # suffix is the suffix for the model, e.g. '_blog'
+      #     # notice is a string with content suitable for the flash
+      #   end
+      #
+      # You can override a single action for a single model via
+      # scaffold_#{action}#{suffix}_redirect (e.g. scaffold_edit_blog_redirect
+      # or scaffold_new_post_redirect):
+      #
+      #   def scaffold_#{action}#{suffix}_redirect(notice)
+      #     # notice is a string with content suitable for the flash
+      #   end
+      #
+      # scaffold_#{action}#{suffix}_redirect has higher priority, and will be
+      # use even if scaffold_#{action}_redirect is defined, so you can override
+      # for the general case and override again for cases for specific models.
+      def scaffold_redirect(action, suffix, notice=nil, oid=nil)
+        action_suffix = "#{action}#{suffix}"
+        meth = "scaffold_#{action_suffix}_redirect"
+        return send(meth, notice) if respond_to?(meth)
+        meth = "scaffold_#{action}_redirect"
+        return send(meth, suffix, notice) if respond_to?(meth)
+        scaffold_flash[:notice] = notice if notice
+        scaffold_redirect_to(scaffold_url(action_suffix, oid ? {:id=>oid} : {}))
+      end
+      
+      # Converts the value to an array, converts all values of the array to integers,
+      # removes all 0 values, and returns the array.
+      def scaffold_select_ids(value)
+        scaffold_force_array(value).collect{|x| x.to_i}.delete_if{|x| x == 0}
+      end
+      
+      # Return whether scaffolding defined the method, whether or not it was overwritten
+      def scaffolded_method?(method_name)
+        self.class.scaffolded_methods.include?(method_name)
+      end
+      
+      # Return whether scaffolding defined the method, if the method is nonidempotent
+      def scaffolded_nonidempotent_method?(method_name)
+        self.class.scaffolded_nonidempotent_methods.include?(method_name)
+      end
+      
+      # Return true if the item was requested with XMLHttpRequest, false otherwise
+      def scaffold_xhr?
+        scaffold_request_env['HTTP_X_REQUESTED_WITH'] =~ /XMLHttpRequest/i
+      end
+  end
+end

data/lib/scaffolding_extensions/controller/action_controller.rb

@@ -0,0 +1,116 @@
+module ScaffoldingExtensions
+  class << self
+    private
+      # ActionController::Base is generally used with Rails, which holds model files
+      # in app/models/
+      def model_files
+        @model_files ||= Dir["#{RAILS_ROOT}/app/models/*.rb"]
+      end
+  end
+
+  # Helper methods for ActionController::Base that override the defaults in Scaffolding Extensions
+  module ActionControllerHelper
+    private
+      # ActionController::Base requires that params that are desired to be lists have
+      # the suffix '[]'
+      def scaffold_param_list_suffix
+        '[]'
+      end
+      
+      # ActionController::Base allows easy access to the CSRF token via token_tag
+      def scaffold_token_tag
+        token_tag
+      end
+  end
+  
+  # Instance methods for ActionController::Base related necessary for Scaffolding Extensions
+  module ActionController
+    private
+      def scaffold_flash
+        flash
+      end
+      
+      def scaffold_method_not_allowed
+        head(:method_not_allowed)
+      end
+      
+      def scaffold_redirect_to(url)
+        redirect_to(url)
+      end
+      
+      # Renders user provided template if it exists, otherwise renders a scaffold template.
+      # If a layout is specified (either in the controller or as an render_option), use that layout,
+      # otherwise uses the scaffolded layout.  If :inline is one of the render_options,
+      # use the contents of it as the template without the layout.
+      def scaffold_render_template(action, options = {}, render_options = {})
+        suffix = options[:suffix]
+        suffix_action = "#{action}#{suffix}"
+        @scaffold_options ||= options
+        @scaffold_suffix ||= suffix
+        @scaffold_class ||= @scaffold_options[:class]
+        render_options = if template_exists?("#{self.class.controller_path}/#{suffix_action}")
+          {:action=>suffix_action}.merge(render_options)
+        elsif render_options.include?(:inline)
+          headers['Content-Type'] = 'text/javascript' if @scaffold_javascript
+          render_options.merge(:layout=>false)
+        else
+          if active_layout || render_options.include?(:layout)
+            {:file=>scaffold_path(action), :layout=>active_layout}.merge(render_options)
+          else
+            @content = render_to_string({:file=>scaffold_path(action)}.merge(render_options))
+            {:file=>scaffold_path("layout")}
+          end
+        end
+        render(render_options)
+      end
+      
+      def scaffold_request_action
+        params[:action]
+      end
+      
+      def scaffold_request_env
+        request.env
+      end
+      
+      def scaffold_request_id
+        params[:id]
+      end
+      
+      def scaffold_request_method
+        request.method.to_s.upcase
+      end
+      
+      def scaffold_request_param(v)
+        params[v]
+      end
+      
+      def scaffold_session
+        session
+      end
+      
+      def scaffold_url(action, options = {})
+        url_for(options.merge(:action=>action, :only_path=>true))
+      end
+  end
+  
+  # Class methods for ActionController::Base related necessary for Scaffolding Extensions
+  module MetaActionController
+    private
+      # Adds a before filter for checking nonidempotent requests use method POST
+      def scaffold_setup_helper
+        helper ScaffoldingExtensions::Helper
+        helper ScaffoldingExtensions::ActionControllerHelper
+        helper ScaffoldingExtensions::PrototypeHelper
+        include ScaffoldingExtensions::Controller
+        include ScaffoldingExtensions::ActionController
+        helper_method "scaffolded_method?", "scaffolded_nonidempotent_method?", :scaffold_url, :scaffold_flash, :scaffold_session
+        before_filter :scaffold_check_nonidempotent_requests
+      end
+  end
+end
+
+# Add class methods necessary for Scaffolding Extensions
+class ActionController::Base
+  extend ScaffoldingExtensions::MetaController
+  extend ScaffoldingExtensions::MetaActionController
+end

data/lib/scaffolding_extensions/controller/camping.rb

@@ -0,0 +1,150 @@
+begin
+  require 'erubis'
+  ERB = Erubis::Eruby
+rescue
+  require 'erb'
+end
+require 'cgi'
+
+module ScaffoldingExtensions
+  class << self
+    private
+      # Camping doesn't have a default location for models, so assume none
+      def model_files
+        @model_files ||= []
+      end
+  end
+  
+  module CampingHelper
+    private
+      # Camping doesn't include u
+      def u(s)
+        CGI.escape(s.to_s)
+      end
+      
+      # Camping doesn't include h
+      def h(s)
+        CGI.escapeHTML(s.to_s)
+      end
+  end
+
+  # Instance methods for the Camping Controller related necessary for Scaffolding Extensions
+  module CampingController
+    private
+      # Camping doesn't provide a suitable flash.  You can hack one together using
+      # session if you really need it.
+      def scaffold_flash
+        {}
+      end
+      
+      # Not the most elegent approach, as this just raises an ArgumentError.
+      def scaffold_method_not_allowed
+        raise ArgumentError, 'Method Not Allowed'
+      end
+      
+      # Seems as though redirect doesn't include the protocol, which is pretty weird,
+      # but it does work.
+      def scaffold_redirect_to(url)
+        redirect(url)
+      end
+      
+      # In order to override the default templates, you need to set 
+      # @scaffold_template_dir and then create a template file inside that
+      # to override the template (make sure the default templates are also
+      # in this folder). It doesn't support user modifiable layouts,
+      # so you'll have to modify the layout.rhtml file in @scaffold_template_dir.
+      def scaffold_render_template(action, options = {}, render_options = {})
+        suffix = options[:suffix]
+        suffix_action = "#{action}#{suffix}"
+        @scaffold_options ||= options
+        @scaffold_suffix ||= suffix
+        @scaffold_class ||= @scaffold_options[:class]
+        if render_options.include?(:inline)
+          headers = {}
+          headers['Content-Type'] = 'text/javascript' if @scaffold_javascript
+          r(200, ERB.new(render_options[:inline]).result(binding), headers)
+        else
+          @content = ERB.new(File.read(scaffold_path(File.exists?(scaffold_path(suffix_action)) ? suffix_action : action))).result(binding)
+          ERB.new(File.read(scaffold_path('layout'))).result(binding)
+        end
+      end
+      
+      def scaffold_request_action
+        @scaffold_method
+      end
+      
+      def scaffold_request_env
+        @env
+      end
+      
+      def scaffold_request_id
+        @input[:id] || @scaffold_request_id
+      end
+      
+      def scaffold_request_method
+        @scaffold_request_method
+      end
+      
+      def scaffold_request_param(v)
+        @input[v]
+      end
+      
+      # You need to enable Camping's session support for this to work, 
+      # otherwise, this will always be the empty hash. The session data
+      # is only used for access control, so if you aren't using 
+      # scaffold_session_value, it shouldn't matter.
+      def scaffold_session
+        @state || {}
+      end
+      
+      # Treats the id option as special, appending it to the path.
+      # Uses the rest of the options as query string parameters.
+      def scaffold_url(action, options = {})
+        escaped_options = {}
+        options.each{|k,v| escaped_options[u(k.to_s)] = u(v.to_s)}
+        id = escaped_options.delete('id')
+        id = id ? "/#{id}" : ''
+        id << "?#{escaped_options.to_a.collect{|k,v| "#{k}=#{v}"}.join('&')}" unless escaped_options.empty?
+        "#{@scaffold_path}/#{action}#{id}"
+      end
+  end
+  
+  # Class methods for the Camping Controller necessary for Scaffolding Extensions
+  module MetaCampingController
+    include ScaffoldingExtensions::MetaController
+    private
+      # Defines get and post methods for the controller that
+      # set necessary variables and then call the correct scaffold method
+      def scaffold_setup_helper
+        include ScaffoldingExtensions::Controller
+        include ScaffoldingExtensions::CampingController
+        include ScaffoldingExtensions::Helper
+        include ScaffoldingExtensions::PrototypeHelper
+        include ScaffoldingExtensions::CampingHelper
+        define_method(:get) do |path, meth, id|
+          @scaffold_request_method = 'GET'
+          @scaffold_path = path
+          @scaffold_method = meth.empty? ? 'index' : meth
+          @scaffold_request_id = id.empty? ? nil : id
+          scaffold_method_not_allowed if scaffolded_nonidempotent_method?(meth)
+          send(@scaffold_method)
+        end
+        define_method(:post) do |path, meth, id|
+          @scaffold_request_method = 'POST'
+          @scaffold_path = path
+          @scaffold_method = meth.empty? ? 'index' : meth
+          @scaffold_request_id = id.empty? ? nil : id
+          send(@scaffold_method)
+        end
+      end
+  end
+end
+
+# Create a route class, and automatically extend it with
+# MetaCampingController so scaffold methods can be used directly
+# inside of it.
+def scaffold_R(root)
+  r = Camping::Controllers::R("(#{root})/?([^/]*)/?([^/]*)")
+  r.send(:extend, ScaffoldingExtensions::MetaCampingController)
+  r
+end

data/lib/scaffolding_extensions/controller/ramaze.rb

@@ -0,0 +1,116 @@
+module ScaffoldingExtensions
+  class << self
+    private
+      # Ramaze's default location for models is model/
+      def model_files
+        @model_files ||= Dir["model/*.rb"]
+      end
+  end
+
+  # Instance methods for Ramaze::Controller related necessary for Scaffolding Extensions
+  module RamazeController
+    private
+      def scaffold_flash
+        flash
+      end
+      
+      def scaffold_method_not_allowed
+        respond('Method not allowed', 405)
+      end
+      
+      def scaffold_redirect_to(url)
+        redirect(url)
+      end
+      
+      # Renders user provided template if it exists, otherwise renders a scaffold template.
+      # If a layout is specified (either in the controller or as an render_option), use that layout,
+      # otherwise uses the scaffolded layout.  If :inline is one of the render_options,
+      # use the contents of it as the template without the layout.
+      def scaffold_render_template(action, options = {}, render_options = {})
+        suffix = options[:suffix]
+        suffix_action = "#{action}#{suffix}"
+        @scaffold_options ||= options
+        @scaffold_suffix ||= suffix
+        @scaffold_class ||= @scaffold_options[:class]
+        unless ::Ramaze::Action.current.template
+          if render_options.include?(:inline)
+            response['Content-Type'] = 'text/javascript' if @scaffold_javascript
+            render_options[:inline]
+          else
+            ::Ramaze::Action.current.template = scaffold_path(action)
+          end
+        end
+      end
+      
+      def scaffold_request_action
+        ::Ramaze::Action.current.name
+      end
+      
+      def scaffold_request_env
+        request.env
+      end
+      
+      def scaffold_request_id
+        request.params['id']
+      end
+      
+      def scaffold_request_method
+        request.env['REQUEST_METHOD']
+      end
+      
+      def scaffold_request_param(v)
+        request.params[v.to_s]
+      end
+      
+      def scaffold_session
+        session
+      end
+      
+      # Treats the id option as special (appending it so the list of options),
+      # which requires a lambda router.
+      def scaffold_url(action, options = {})
+        escaped_options = {}
+        options.each{|k,v| escaped_options[u(k.to_s)] = u(v.to_s)}
+        escaped_options['id'] ? Rs(action, escaped_options.delete('id'), escaped_options) : Rs(action, escaped_options)
+      end
+  end
+  
+  # Class methods for Ramaze::Controller related necessary for Scaffolding Extensions
+  module MetaRamazeController
+    DENY_LAYOUT_RE = %r{\A(scaffold_auto_complete_for|associations|add|remove)_}
+    
+    private
+      # Denies the layout to names that match DENY_LAYOUT_RE (the Ajax methods).
+      # Sets request.params['id'] if it was given as part of the request path.
+      # Checks nonidempotent requests require POST.
+      def scaffold_define_method(name, &block)
+        deny_layout(name) if DENY_LAYOUT_RE.match(name)
+        scaffolded_methods.add(name)
+        define_method(name) do |*args|
+          scaffold_check_nonidempotent_requests
+          request.params['id'] = args.shift if args.length > 0
+          instance_eval(&block)
+        end
+      end
+      
+      # Adds a default scaffolded layout if none has been set.  Activates the Erubis
+      # engine.  Includes the necessary scaffolding helper and controller methods.
+      def scaffold_setup_helper
+        engine :Erubis
+        include ScaffoldingExtensions::Controller
+        include ScaffoldingExtensions::RamazeController
+        include ScaffoldingExtensions::Helper
+        include ScaffoldingExtensions::PrototypeHelper
+        unless trait[:layout][:all]
+          layout(:scaffold_layout) 
+          define_method(:scaffold_layout){::Ramaze::Action.current.template = scaffold_path(:layout)}
+        end
+      end
+  end
+end
+
+# Add class methods necessary for Scaffolding Extensions
+class Ramaze::Controller
+  extend ScaffoldingExtensions::MetaController
+  extend ScaffoldingExtensions::MetaRamazeController
+end