active_scaffold 3.3.3 → 3.4.0

data/lib/active_scaffold.rb

@@ -1,32 +1,16 @@
-unless Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR >= 1
-  raise "This version of ActiveScaffold requires Rails 3.1 or higher.  Please use an earlier version."
-end
-
-begin
-  require 'render_component'
-rescue LoadError
-end
-
-require 'active_scaffold/active_record_permissions'
-require 'active_scaffold/paginator'
-require 'active_scaffold/responds_to_parent'
-
-require 'active_scaffold/version'
-require 'active_scaffold/engine' unless defined? ACTIVE_SCAFFOLD_PLUGIN
-require 'json'  # for js_config
-
 module ActiveScaffold
+  autoload :ActiveRecordPermissions, 'active_scaffold/active_record_permissions'
   autoload :AttributeParams, 'active_scaffold/attribute_params'
+  autoload :Bridges, 'active_scaffold/bridges'
   autoload :Configurable, 'active_scaffold/configurable'
   autoload :Constraints, 'active_scaffold/constraints'
+  autoload :Core, 'active_scaffold/core'
+  autoload :DelayedSetup, 'active_scaffold/delayed_setup'
   autoload :Finder, 'active_scaffold/finder'
   autoload :MarkedModel, 'active_scaffold/marked_model'
-  autoload :Bridges, 'active_scaffold/bridges'
-
-  mattr_accessor :stylesheets
-  self.stylesheets = []
-  mattr_accessor :javascripts
-  self.javascripts = []
+  autoload :RespondsToParent, 'active_scaffold/responds_to_parent'
+  autoload :Tableless, 'active_scaffold/tableless'
+  autoload :Version, 'active_scaffold/version'
 
   def self.autoload_subdir(dir, mod=self, root = File.dirname(__FILE__))
     Dir["#{root}/active_scaffold/#{dir}/*.rb"].each { |file|
@@ -54,82 +38,16 @@ module ActiveScaffold
   end
 
   class ControllerNotFound < RuntimeError; end
-  class DependencyFailure < RuntimeError; end
   class MalformedConstraint < RuntimeError; end
   class RecordNotAllowed < SecurityError; end
   class ActionNotAllowed < SecurityError; end
   class ReverseAssociationRequired < RuntimeError; end
 
-  def self.included(base)
-    base.extend(ClassMethods)
-    base.module_eval do
-      # TODO: these should be in actions/core
-      before_filter :handle_user_settings
-      before_filter :check_input_device
-    end
-
-    base.helper_method :touch_device?
-    base.helper_method :hover_via_click?
-    base.helper_method :active_scaffold_constraints
-  end
-
-  def self.set_defaults(&block)
-    ActiveScaffold::Config::Core.configure &block
-  end
-  
-  def active_scaffold_config
-    self.class.active_scaffold_config
-  end
-
-  def active_scaffold_config_for(klass)
-    self.class.active_scaffold_config_for(klass)
-  end
-
-  def active_scaffold_session_storage_key(id = nil)
-    id ||= params[:eid] || "#{params[:controller]}#{"_#{nested.parent_id}" if nested?}"
-    "as:#{id}"
-  end
-
-  def active_scaffold_session_storage(id = nil)
-    session_index = active_scaffold_session_storage_key(id)
-    session[session_index] ||= {}
-    session[session_index]
-  end
-
-  def clear_storage
-    session_index = active_scaffold_session_storage_key
-    session.delete(session_index) unless session[session_index].present?
-  end
-
-  # at some point we need to pass the session and params into config. we'll just take care of that before any particular action occurs by passing those hashes off to the UserSettings class of each action.
-  def handle_user_settings
-    if self.class.uses_active_scaffold?
-      active_scaffold_config.actions.each do |action_name|
-        conf_instance = active_scaffold_config.send(action_name) rescue next
-        next if conf_instance.class::UserSettings == ActiveScaffold::Config::Base::UserSettings # if it hasn't been extended, skip it
-        storage = active_scaffold_config.store_user_settings ? active_scaffold_session_storage : {}
-        conf_instance.user = conf_instance.class::UserSettings.new(conf_instance, storage, params)
-      end
-    end
-  end
-
-  def check_input_device
-    if request.env["HTTP_USER_AGENT"] && request.env["HTTP_USER_AGENT"][/(iPhone|iPod|iPad)/i]
-      session[:input_device_type] = 'TOUCH'
-      session[:hover_supported] = false
-    else
-      session[:input_device_type] = 'MOUSE'
-      session[:hover_supported] = true
-    end if session[:input_device_type].nil?
-   end
-
-  def touch_device?
-    session[:input_device_type] == 'TOUCH'
-  end
-
-  def hover_via_click?
-    session[:hover_supported] == false
-  end
+  mattr_accessor :delayed_setup
+  mattr_accessor :stylesheets
+  self.stylesheets = []
+  mattr_accessor :javascripts
+  self.javascripts = []
   
   def self.js_framework=(framework)
     @@js_framework = framework
@@ -151,12 +69,10 @@ module ActiveScaffold
     @@js_config ||= {:scroll_on_close => :checkInViewport}
   end
 
-  # exclude bridges you do not need
+  # exclude bridges you do not need, add to an initializer
   # name of bridge subdir should be used to exclude it
   # eg
   #   ActiveScaffold.exclude_bridges = [:cancan, :ancestry]
-  #   if you are using Activescaffold as a gem add to initializer
-  #   if you are using Activescaffold as a plugin add to active_scaffold_env.rb
   def self.exclude_bridges=(bridges)
     @@exclude_bridges = bridges
   end
@@ -169,203 +85,11 @@ module ActiveScaffold
     File.dirname(__FILE__) + "/.."
   end
 
-  module ClassMethods
-    def active_scaffold(model_id = nil, &block)
-      extend Prefixes
-      # initialize bridges here
-      ActiveScaffold::Bridges.run_all
-
-      # converts Foo::BarController to 'bar' and FooBarsController to 'foo_bar' and AddressController to 'address'
-      model_id = self.to_s.split('::').last.sub(/Controller$/, '').pluralize.singularize.underscore unless model_id
-
-      # run the configuration
-      @active_scaffold_config = ActiveScaffold::Config::Core.new(model_id)
-      @active_scaffold_config_block = block
-      self.links_for_associations
-      
-      self.active_scaffold_superclasses_blocks.each {|superblock| self.active_scaffold_config.configure &superblock}
-      self.active_scaffold_config.sti_children = nil # reset sti_children if set in parent block
-      self.active_scaffold_config.configure &block if block_given?
-      self.active_scaffold_config._configure_sti unless self.active_scaffold_config.sti_children.nil?
-      self.active_scaffold_config._load_action_columns
-
-      # defines the attribute read methods on the model, so record.send() doesn't find protected/private methods instead
-      klass = self.active_scaffold_config.model
-      klass.define_attribute_methods unless klass.attribute_methods_generated?
-      # include the rest of the code into the controller: the action core and the included actions
-      module_eval do
-        include ActiveScaffold::Finder
-        include ActiveScaffold::Constraints
-        include ActiveScaffold::AttributeParams
-        include ActiveScaffold::Actions::Core
-        active_scaffold_config.actions.each do |mod|
-          name = mod.to_s.camelize
-          include "ActiveScaffold::Actions::#{name}".constantize
-
-          # sneak the action links from the actions into the main set
-          if link = active_scaffold_config.send(mod).link rescue nil
-            if link.is_a? Array
-              link.each {|current| active_scaffold_config.action_links.add_to_group(current, active_scaffold_config.send(mod).action_group)}
-            elsif link.is_a? ActiveScaffold::DataStructures::ActionLink
-              active_scaffold_config.action_links.add_to_group(link, active_scaffold_config.send(mod).action_group)
-            end
-          end
-        end
-      end
-      self._add_sti_create_links if self.active_scaffold_config.add_sti_create_links?
-    end
-
-    module Prefixes
-      def parent_prefixes
-        @parent_prefixes ||= super << 'active_scaffold_overrides'
-      end
-    end
-
-    # To be called after include action modules
-    def _add_sti_create_links
-      new_action_link = active_scaffold_config.action_links.collection['new']
-      unless new_action_link.nil? || active_scaffold_config.sti_children.empty?
-        active_scaffold_config.action_links.collection.delete('new')
-        active_scaffold_config.sti_children.each do |child|
-          new_sti_link = Marshal.load(Marshal.dump(new_action_link)) # deep clone
-          new_sti_link.label = as_(:create_model, :model => child.to_s.camelize.constantize.model_name.human)
-          new_sti_link.parameters = {:parent_sti => controller_path}
-          new_sti_link.controller = Proc.new { active_scaffold_controller_for(child.to_s.camelize.constantize).controller_path }
-          active_scaffold_config.action_links.collection.create.add(new_sti_link)
-        end
-      end
-    end
-
-    # Create the automatic column links. Note that this has to happen when configuration is *done*, because otherwise the Nested module could be disabled. Actually, it could still be disabled later, couldn't it?
-    def links_for_associations
-      return unless active_scaffold_config.actions.include? :list and active_scaffold_config.actions.include? :nested
-      active_scaffold_config.columns.each do |column|
-        next unless column.link.nil? and column.autolink?
-        #lazy load of action_link, cause it was really slowing down app in dev mode
-        #and might lead to trouble cause of cyclic constantization of controllers
-        #and might be unnecessary cause it is done before columns are configured
-        column.set_link(Proc.new {|col| link_for_association(col)})
-      end
-    end
-    
-    def active_scaffold_controller_for_column(column, options = {})
-      begin
-        if column.polymorphic_association?
-          :polymorph
-        elsif options.include?(:controller)
-          "#{options[:controller].to_s.camelize}Controller".constantize
-        else
-          active_scaffold_controller_for(column.association.klass)
-        end
-      rescue ActiveScaffold::ControllerNotFound
-        nil        
-      end
-    end
-    
-    def link_for_association(column, options = {})
-      controller = active_scaffold_controller_for_column(column, options)
-      
-      unless controller.nil?
-        options.reverse_merge! :position => :after, :type => :member, :controller => (controller == :polymorph ? controller : controller.controller_path), :column => column
-        options[:parameters] ||= {}
-        options[:parameters].reverse_merge! :association => column.association.name
-        if column.plural_association?
-          # note: we can't create nested scaffolds on :through associations because there's no reverse association.
-          
-          ActiveScaffold::DataStructures::ActionLink.new('index', options.merge(:refresh_on_close => true)) #unless column.through_association?
-        else
-          actions = controller.active_scaffold_config.actions unless controller == :polymorph
-          actions ||= [:create, :update, :show] 
-          column.actions_for_association_links.delete :new unless actions.include? :create
-          column.actions_for_association_links.delete :edit unless actions.include? :update
-          column.actions_for_association_links.delete :show unless actions.include? :show
-          ActiveScaffold::DataStructures::ActionLink.new(nil, options.merge(:html_options => {:class => column.name}))
-        end 
-      end
-    end
-    
-    def link_for_association_as_scope(scope, options = {})
-      options.reverse_merge! :label => scope, :position => :after, :type => :member, :controller => controller_path
-      options[:parameters] ||= {}
-      options[:parameters].reverse_merge! :named_scope => scope
-      ActiveScaffold::DataStructures::ActionLink.new('index', options)
-    end
-
-    def add_active_scaffold_path(path)
-      as_path = File.join(ActiveScaffold::Config::Core.plugin_directory, 'app', 'views')
-      index = view_paths.find_index { |p| p.to_s == as_path }
-      if index
-        self.view_paths = view_paths[0..index-1] + Array(path) + view_paths[index..-1]
-      else
-        append_view_path path
-      end
-    end
-
-    def active_scaffold_config
-      if @active_scaffold_config.nil?
-        self.superclass.active_scaffold_config if self.superclass.respond_to? :active_scaffold_config
-      else
-        @active_scaffold_config
-      end
-    end
-
-    def active_scaffold_config_block
-      @active_scaffold_config_block
-    end
-
-    def active_scaffold_superclasses_blocks
-      blocks = []
-      klass = self.superclass
-      while klass.respond_to? :active_scaffold_superclasses_blocks
-        blocks << klass.active_scaffold_config_block
-        klass = klass.superclass
-      end
-      blocks.compact.reverse
-    end
-
-    def active_scaffold_config_for(klass)
-      begin
-        controller = active_scaffold_controller_for(klass)
-      rescue ActiveScaffold::ControllerNotFound
-        config = ActiveScaffold::Config::Core.new(klass)
-        config._load_action_columns
-        config
-      else
-        controller.active_scaffold_config
-      end
-    end
-
-    # Tries to find a controller for the given ActiveRecord model.
-    # Searches in the namespace of the current controller for singular and plural versions of the conventional "#{model}Controller" syntax.
-    # You may override this method to customize the search routine.
-    def active_scaffold_controller_for(klass)
-      controller_namespace = self.to_s.split('::')[0...-1].join('::') + '::'
-      error_message = []
-      [controller_namespace, ''].each do |namespace|
-        ["#{klass.to_s.underscore.pluralize}", "#{klass.to_s.underscore.pluralize.singularize}"].each do |controller_name|
-          begin
-            controller = "#{namespace}#{controller_name.camelize}Controller".constantize
-          rescue NameError => error
-            # Only rescue NameError associated with the controller constant not existing - not other compile errors
-            if error.message["uninitialized constant #{controller}"]
-              error_message << "#{namespace}#{controller_name.camelize}Controller"
-              next
-            else
-              raise
-            end
-          end
-          raise ActiveScaffold::ControllerNotFound, "#{controller} missing ActiveScaffold", caller unless controller.uses_active_scaffold?
-          raise ActiveScaffold::ControllerNotFound, "ActiveScaffold on #{controller} is not for #{klass} model.", caller unless controller.active_scaffold_config.model.to_s == klass.to_s
-          return controller
-        end
-      end
-      raise ActiveScaffold::ControllerNotFound, "Could not find " + error_message.join(" or "), caller
-    end
-
-    def uses_active_scaffold?
-      !active_scaffold_config.nil?
-    end
+  def self.set_defaults(&block)
+    ActiveScaffold::Config::Core.configure &block
   end
 end
+require 'active_scaffold/engine'
+# TODO: clean up extensions. some could be organized for autoloading, and others could be removed entirely.
+Dir["#{File.dirname __FILE__}/active_scaffold/extensions/*.rb"].each { |file| require file }
 
-require 'active_scaffold_env'

data/lib/active_scaffold/actions/common_search.rb

@@ -1,26 +1,59 @@
 module ActiveScaffold::Actions
   module CommonSearch
-    protected
-    def store_search_params_into_session
-      if active_scaffold_config.store_user_settings
-        active_scaffold_session_storage[:search] = params.delete :search if params[:search]
-      else
-        @search_params = params.delete :search
+    def self.included(base)
+      unless base < InstanceMethods
+        base.send :include, InstanceMethods
+        base.before_filter :search_authorized_filter, :only => :show_search
+        base.before_filter :store_search_params_into_session, :only => [:index]
+        base.before_filter :do_search, :only => [:index]
+        base.helper_method :search_params
       end
     end
 
-    def search_params
-      @search_params || active_scaffold_session_storage[:search]
-    end
+    module InstanceMethods
+      def show_search
+        respond_to_action(search_partial || :search)
+      end
+      
+      protected
+      def do_search
+      end
+      
+      def search_partial
+        @_search_partial ||= if params[:kind].present? && active_scaffold_config.actions.include?(params[:kind])
+          params.delete(:kind)
+        else
+          active_scaffold_config.list.auto_search_partial
+        end
+      end
+      
+      def store_search_params_into_session
+        if active_scaffold_config.store_user_settings
+          active_scaffold_session_storage[:search] = params.delete :search if params[:search]
+        else
+          @search_params = params.delete :search
+        end
+      end
 
-    def search_ignore?
-      active_scaffold_config.list.always_show_search
-    end
-    
-    # The default security delegates to ActiveRecordPermissions.
-    # You may override the method to customize.
-    def search_authorized?
-      authorized_for?(:crud_type => :read)
+      def search_params
+        @search_params || active_scaffold_session_storage[:search]
+      end
+
+      def global_search_ignore?
+        active_scaffold_config.list.always_show_search == true
+      end
+      
+      # The default security delegates to ActiveRecordPermissions.
+      # You may override the method to customize.
+      def search_authorized?
+        authorized_for?(:crud_type => :read)
+      end
+      
+      def search_authorized_filter
+        action = active_scaffold_config.send(search_partial)
+        link = action.link || action.class.link
+        raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
+      end
     end
   end
 end

data/lib/active_scaffold/actions/core.rb

@@ -2,13 +2,15 @@ module ActiveScaffold::Actions
   module Core
     def self.included(base)
       base.class_eval do
-        prepend_before_filter :register_constraints_with_action_columns, :unless => :nested?
+        before_filter :register_constraints_with_action_columns, :unless => :nested?
         after_filter :clear_flashes
         after_filter :clear_storage
         rescue_from ActiveScaffold::RecordNotAllowed, ActiveScaffold::ActionNotAllowed, :with => :deny_access
       end
       base.helper_method :successful?
       base.helper_method :nested?
+      base.helper_method :embedded?
+      base.helper_method :loading_embedded?
       base.helper_method :calculate_query
       base.helper_method :new_model
     end
@@ -21,8 +23,12 @@ module ActiveScaffold::Actions
     end
     
     protected
+    def loading_embedded?
+      @loading_embedded ||= params.delete(:embedded)
+    end
+
     def embedded?
-      @embedded ||= params.delete(:embedded)
+      params[:eid]
     end
 
     def nested?
@@ -39,9 +45,10 @@ module ActiveScaffold::Actions
       @column = active_scaffold_config.columns[params.delete(:column)]
       unless @column.nil?
         @source_id = params.delete(:source_id)
-        @columns = @column.update_columns
+        @columns = @column.update_columns || []
         @scope = params.delete(:scope)
         @main_columns = active_scaffold_config.send(@scope ? :subform : (params[:id] ? :update : :create)).columns
+        @columns << @column.name if @column.options[:refresh_link] && @columns.exclude?(@column.name)
         
         if @column.send_form_on_update_column
           if @scope
@@ -53,17 +60,58 @@ module ActiveScaffold::Actions
             hash = params[:record]
             id = params[:id]
           end
-          @record = id ? find_if_allowed(id, :update) : new_model
-          @record = update_record_from_params(@record, @main_columns, hash)
-        else
+
+          # check permissions and support overriding to_param
+          record = find_if_allowed(id, :update) if id
+          # call update_record_from_params with new_model
+          # in other case some associations can be saved
           @record = new_model
+          copy_attributes(record, @record) if record
+          apply_constraints_to_record(@record) unless @scope
+          @record = update_record_from_params(@record, @main_columns, hash, true)
+        else
+          @record = params[:id] ? find_if_allowed(params[:id], :update) : new_model
+          if @record.new_record?
+            apply_constraints_to_record(@record) unless @scope
+          else
+            @record = @record.dup
+          end
           value = column_value_from_param_value(@record, @column, params.delete(:value))
           @record.send "#{@column.name}=", value
+          @record.id = params[:id]
         end
+        set_parent(@record) if @record.id.nil? && params[:parent_controller] && params[:child_association]
         
         after_render_field(@record, @column)
       end
     end
+
+    def set_parent(record)
+      parent_model = params[:parent_controller].singularize.camelize.constantize
+      association = parent_model.reflect_on_association(params[:child_association].to_sym).try(:reverse)
+      if association
+        parent = parent_model.new
+        copy_attributes(parent_model.find(params[:parent_id]), parent) if params[:parent_id]
+        parent.id = params[:parent_id]
+        parent = update_record_from_params(parent, active_scaffold_config_for(parent_model).send(params[:parent_id] ? :update : :create).columns, params[:record]) if @column.send_form_on_update_column
+        apply_constraints_to_record(parent) if params[:parent_id]
+        if record.class.reflect_on_association(association).collection?
+          record.send(association) << parent
+        else
+          record.send("#{association}=", parent)
+        end
+      end
+    end
+
+    def copy_attributes(orig, dst)
+      attributes = orig.attributes
+      if orig.class.respond_to? :protected_attributes
+        orig.class.protected_attributes.each { |attr| dst[attr] = orig[attr] }
+        attributes = attributes.except(*orig.class.protected_attributes)
+      end
+      dst.attributes = attributes
+      dst
+    end
     
     # override this method if you want to do something after render_field
     def after_render_field(record, column); end
@@ -134,19 +182,6 @@ module ActiveScaffold::Actions
     def return_to_main
       redirect_to main_path_to_return
     end
-
-    # Override this method on your controller to define conditions to be used when querying a recordset (e.g. for List). The return of this method should be any format compatible with the :conditions clause of ActiveRecord::Base's find.
-    def conditions_for_collection
-    end
-  
-    # Override this method on your controller to define joins to be used when querying a recordset (e.g. for List).  The return of this method should be any format compatible with the :joins clause of ActiveRecord::Base's find.
-    def joins_for_collection
-    end
-  
-    # Override this method on your controller to provide custom finder options to the find() call. The return of this method should be a hash.
-    def custom_finder_options
-      {}
-    end
   
     #Overide this method on your controller to provide model with named scopes
     def beginning_of_chain
@@ -157,13 +192,18 @@ module ActiveScaffold::Actions
     def conditions_from_params
       @conditions_from_params ||= begin
         conditions = {}
-        params.except(:controller, :action, :page, :sort, :sort_direction).each do |key, value|
+        params.except(:controller, :action, :page, :sort, :sort_direction, :id).each do |key, value|
           column = active_scaffold_config.model.columns_hash[key.to_s]
-          key = key.to_sym
           next unless column
+          key = key.to_sym
+          not_string = [:string, :text].exclude?(column.type)
           next if active_scaffold_constraints[key]
           next if nested? and nested.param_name == key
-          conditions[key] = column.type_cast(value)
+          conditions[key] = if value.is_a?(Array)
+            value.map {|v| v == '' && not_string ? nil : column.type_cast(v) }
+          else
+            value == '' && not_string ? nil : column.type_cast(value)
+          end
         end
         conditions
       end
@@ -181,8 +221,39 @@ module ActiveScaffold::Actions
       model.respond_to?(:build) ? model.build(build_options || {}) : model.new
     end
 
+    def objects_for_etag
+      @last_modified ||= @record.updated_at
+      [@record, ('xhr' if request.xhr?)]
+    end
+
+    def view_stale?
+      objects = objects_for_etag
+      if objects.is_a?(Array)
+        args = {:etag => objects.to_a}
+        args[:last_modified] = @last_modified if @last_modified
+      elsif objects.is_a?(Hash)
+        args = {:last_modified => @last_modified}.merge(objects)
+      else
+        args = objects
+      end
+      stale?(args)
+    end
+
+    def conditional_get_support?
+      request.get? && active_scaffold_config.conditional_get_support
+    end
+
+    def virtual_columns(columns)
+      columns.reject {|col| active_scaffold_config.model.columns_hash[col] || active_scaffold_config.model.reflect_on_association(col)}
+    end
+
+    def association_columns(columns)
+      columns.select {|col| active_scaffold_config.model.reflect_on_association(col)}
+    end
+
     private
     def respond_to_action(action)
+      return unless !conditional_get_support? || view_stale?
       respond_to do |type|
         action_formats.each do |format|
           type.send(format) do