active_scaffold 3.3.3 → 3.4.0

data/lib/active_scaffold/actions/create.rb

@@ -16,7 +16,7 @@ module ActiveScaffold::Actions
 
     protected
     def response_location
-      url_for(params_for(:action => "show", :id => @record.id)) if successful?
+      url_for(params_for(:action => "show", :id => @record.to_param)) if successful?
     end
 
     def new_respond_to_html
@@ -41,8 +41,8 @@ module ActiveScaffold::Actions
         if successful?
           flash[:info] = as_(:created_model, :model => @record.to_label)
           if action = active_scaffold_config.create.action_after_create
-            redirect_to params_for(:action => action, :id => @record.id)
-          elsif active_scaffold_config.create.persistent
+            redirect_to params_for(:action => action, :id => @record.to_param)
+          elsif params[:dont_close]
             redirect_to params_for(:action => "new")
           else
             return_to_main
@@ -59,19 +59,27 @@ module ActiveScaffold::Actions
 
     def create_respond_to_js
       do_refresh_list if successful? && active_scaffold_config.create.refresh_list && !render_parent?
+      if successful? && params[:dont_close] && !render_parent?
+        @saved_record = @record
+        do_new
+      end
       render :action => 'on_create'
     end
 
     def create_respond_to_xml
-      render :xml => response_object.to_xml(:only => active_scaffold_config.create.columns.names), :content_type => Mime::XML, :status => response_status, :location => response_location
+      render :xml => response_object.to_xml(:only => create_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(create_columns_names), :methods => virtual_columns(create_columns_names)), :content_type => Mime::XML, :status => response_status, :location => response_location
     end
 
     def create_respond_to_json
-      render :text => response_object.to_json(:only => active_scaffold_config.create.columns.names), :content_type => Mime::JSON, :status => response_status, :location => response_location
+      render :text => response_object.to_json(:only => create_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(create_columns_names), :methods => virtual_columns(create_columns_names)), :content_type => Mime::JSON, :status => response_status, :location => response_location
     end
 
     def create_respond_to_yaml
-      render :text => Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.create.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status, :location => response_location
+      render :text => Hash.from_xml(response_object.to_xml(:only => create_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(create_columns_names), :methods => virtual_columns(create_columns_names))).to_yaml, :content_type => Mime::YAML, :status => response_status, :location => response_location
+    end
+
+    def create_columns_names
+      active_scaffold_config.create.columns.names
     end
 
     # A simple method to find and prepare an example new record for the form
@@ -99,6 +107,7 @@ module ActiveScaffold::Actions
       rescue ActiveRecord::ActiveRecordError => ex
         flash[:error] = ex.message
         self.successful = false
+        @record ||= new_model # ensure @record exists or display form will fail
       end
     end
 

data/lib/active_scaffold/actions/field_search.rb

@@ -1,78 +1,86 @@
 module ActiveScaffold::Actions
   module FieldSearch
-    include ActiveScaffold::Actions::CommonSearch
     def self.included(base)
-      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 :field_search_params
-      base.helper_method :search_params
+      base.send :include, ActiveScaffold::Actions::CommonSearch
+      base.send :include, InstanceMethods
     end
+    
+    module InstanceMethods
 
-    # FieldSearch uses params[:search] and not @record because search conditions do not always pass the Model's validations.
-    # This facilitates for example, textual searches against associations via .search_sql
-    def show_search
-      @record = new_model
-      respond_to_action(:field_search)
-    end
+      # FieldSearch uses params[:search] and not @record because search conditions do not always pass the Model's validations.
+      # This facilitates for example, textual searches against associations via .search_sql
+      def show_search
+        @record = new_model
+        super
+      end
 
-    protected
-    
-    def store_search_params_into_session
-      set_field_search_default_params(active_scaffold_config.field_search.default_params) unless active_scaffold_config.field_search.default_params.nil?
-      super
-      active_scaffold_session_storage[:search] = nil if search_params.is_a?(String)
-    end
-    
-    def set_field_search_default_params(default_params)
-      if (params[:search].nil? && search_params.nil?) || (params[:search].is_a?(String) && params[:search].blank?)
-        params[:search] = default_params.is_a?(Proc) ? self.instance_eval(&default_params) : default_params
+      protected
+
+      def search_partial
+        super || :field_search
+      end
+      
+      def store_search_params_into_session
+        set_field_search_default_params(active_scaffold_config.field_search.default_params) unless active_scaffold_config.field_search.default_params.nil?
+        super
+      end
+      
+      def set_field_search_default_params(default_params)
+        if (params[:search].nil? && search_params.nil?) || (params[:search].is_a?(String) && params[:search].blank?)
+          params[:search] = default_params.is_a?(Proc) ? self.instance_eval(&default_params) : default_params
+        end
+      end
+      
+      def field_search_params
+        search_params.is_a?(Hash) ? search_params : {}
       end
-    end
-    
-    def field_search_params
-      search_params || {}
-    end
 
-    def field_search_respond_to_html
-      render(:action => "field_search")
-    end
-    
-    def field_search_respond_to_js
-      render(:partial => "field_search")
-    end
+      def field_search_respond_to_html
+        render(:action => "field_search")
+      end
+      
+      def field_search_respond_to_js
+        render(:partial => "field_search")
+      end
 
-    def do_search
-      unless search_params.blank?
-        filtered_columns = []
-        text_search = active_scaffold_config.field_search.text_search
-        columns = active_scaffold_config.field_search.columns
-        search_params.each do |key, value|
-          next unless columns.include? key
-          column = active_scaffold_config.columns[key]
-          search_condition = self.class.condition_for_column(column, value, text_search)
-          unless search_condition.blank?
-            self.active_scaffold_outer_joins << column.search_joins unless active_scaffold_config.list.user.count_includes.nil? && column.includes.present? && list_columns.include?(column)
-            self.active_scaffold_conditions << search_condition
-            filtered_columns << column
+      def do_search
+        if search_params.is_a?(Hash) && search_params.present?
+          filtered_columns = []
+          text_search = active_scaffold_config.field_search.text_search
+          columns = active_scaffold_config.field_search.columns
+          search_params.each do |key, value|
+            next unless columns.include? key
+            column = active_scaffold_config.columns[key]
+            search_condition = self.class.condition_for_column(column, value, text_search)
+            unless search_condition.blank?
+              if active_scaffold_config.list.user.count_includes.nil? && column.includes.present? && list_columns.include?(column)
+                self.active_scaffold_references << column.includes
+              elsif column.search_joins.present?
+                self.active_scaffold_outer_joins << column.search_joins
+              end
+              self.active_scaffold_conditions << search_condition
+              filtered_columns << column
+            end
           end
+          unless filtered_columns.blank?
+            @filtered = active_scaffold_config.field_search.human_conditions ? filtered_columns : true
+          end
+
+          active_scaffold_config.list.user.page = nil
+        else
+          super
         end
-        unless filtered_columns.blank?
-          @filtered = active_scaffold_config.field_search.human_conditions ? filtered_columns : true
-        end
+      end
 
-        active_scaffold_config.list.user.page = nil
+      def search_ignore?
+        active_scaffold_config.list.always_show_search == :field_search || global_search_ignore?
       end
-    end
 
-    private
-    
-    def search_authorized_filter
-      link = active_scaffold_config.field_search.link || active_scaffold_config.field_search.class.link
-      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
-    end
-    def field_search_formats
-      (default_formats + active_scaffold_config.formats + active_scaffold_config.field_search.formats).uniq
+      private
+      def field_search_formats
+        (default_formats + active_scaffold_config.formats + active_scaffold_config.field_search.formats).uniq
+      end
     end
   end
 end

data/lib/active_scaffold/actions/list.rb

@@ -1,14 +1,19 @@
 module ActiveScaffold::Actions
   module List
     def self.included(base)
-      base.before_filter :list_authorized_filter, :only => [:index, :row]
+      base.before_filter :list_authorized_filter, :only => :index
       base.helper_method :list_columns
     end
 
     def index
-      list
+      if params[:id] && !params[:id].is_a?(Array) && request.xhr?
+        row
+      else
+        list
+      end
     end
 
+    protected
     # get just a single row
     def row
       get_row
@@ -25,29 +30,29 @@ module ActiveScaffold::Actions
       respond_to_action(:list)
     end
 
-    protected
     def list_respond_to_html
-      if embedded?
+      if loading_embedded?
         render :action => 'list', :layout => false
       else
         render :action => 'list'
       end
     end
     def list_respond_to_js
-      if params[:adapter] || embedded?
+      if params[:adapter] || loading_embedded?
         render(:partial => 'list_with_header')
       else
+        @auto_pagination = params[:auto_pagination]
         render :partial => 'refresh_list', :formats => [:js]
       end
     end
     def list_respond_to_xml
-      render :xml => response_object.to_xml(:only => list_columns_names), :content_type => Mime::XML, :status => response_status
+      render :xml => response_object.to_xml(:only => list_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(list_columns_names), :methods => virtual_columns(list_columns_names)), :content_type => Mime::XML, :status => response_status
     end
     def list_respond_to_json
-      render :text => response_object.to_json(:only => list_columns_names), :content_type => Mime::JSON, :status => response_status
+      render :text => response_object.to_json(:only => list_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(list_columns_names), :methods => virtual_columns(list_columns_names)), :content_type => Mime::JSON, :status => response_status
     end
     def list_respond_to_yaml
-      render :text => Hash.from_xml(response_object.to_xml(:only => list_columns_names)).to_yaml, :content_type => Mime::YAML, :status => response_status
+      render :text => Hash.from_xml(response_object.to_xml(:only => list_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(list_columns_names), :methods => virtual_columns(list_columns_names))).to_yaml, :content_type => Mime::YAML, :status => response_status
     end
 
     def row_respond_to_html
@@ -61,19 +66,21 @@ module ActiveScaffold::Actions
     # The actual algorithm to prepare for the list view
     def set_includes_for_columns(action = :list)
       @cache_associations = true
-      columns = if respond_to?(:"#{action}_columns")
+      columns = if respond_to?(:"#{action}_columns", true)
         send(:"#{action}_columns")
       else
         active_scaffold_config.send(action).columns.collect_visible(:flatten => true)
       end
-      includes_for_list_columns = columns.map{ |c| c.includes }.flatten.uniq.compact
-      self.active_scaffold_includes.concat includes_for_list_columns
+      sorting = active_scaffold_config.list.user.sorting
+      columns_for_joins, columns_for_includes = columns.select{ |c| c.includes.present? }.partition {|c| sorting.sorts_on? c }
+      self.active_scaffold_preload.concat columns_for_includes.map(&:includes).flatten.uniq
+      self.active_scaffold_references.concat columns_for_joins.map(&:includes).flatten.uniq
     end
 
-    def get_row
+    def get_row(crud_type = :read)
       set_includes_for_columns
-      klass = beginning_of_chain.includes(active_scaffold_includes)
-      @record = find_if_allowed(params[:id], :read, klass)
+      klass = beginning_of_chain.preload(active_scaffold_preload)
+      @record = find_if_allowed(params[:id], crud_type, klass)
     end
 
     # The actual algorithm to prepare for the list view
@@ -83,15 +90,16 @@ module ActiveScaffold::Actions
       options = { :sorting => active_scaffold_config.list.user.sorting,
         :count_includes => active_scaffold_config.list.user.count_includes }
       paginate = (params[:format].nil?) ? (accepts? :html, :js) : ['html', 'js'].include?(params[:format])
-      if paginate
-        options.merge!({
-            :per_page => active_scaffold_config.list.user.per_page,
-            :page => active_scaffold_config.list.user.page,
-            :pagination => active_scaffold_config.list.pagination
-          })
+      options[:pagination] = active_scaffold_config.list.pagination if paginate
+      if options[:pagination]
+        options.merge!(
+          :per_page => active_scaffold_config.list.user.per_page,
+          :page => active_scaffold_config.list.user.page
+        )
       end
       if active_scaffold_config.list.auto_select_columns
-        options[:select] = active_scaffold_config.list.columns.map(&:select_columns).compact.flatten + active_scaffold_config.columns[active_scaffold_config.model.primary_key].select_columns
+        auto_select_columns = list_columns + [active_scaffold_config.columns[active_scaffold_config.model.primary_key]]
+        options[:select] = auto_select_columns.map { |c| quoted_select_columns(c.select_columns) }.compact.flatten
       end
 
       page = find_page(options)
@@ -103,6 +111,10 @@ module ActiveScaffold::Actions
       @page, @records = page, page.items
     end
 
+    def quoted_select_columns(columns)
+      columns.map { |c| active_scaffold_config.columns[c].try(:field) || c } if columns
+    end
+
     def do_refresh_list
       params.delete(:id)
       do_search if respond_to? :do_search, true
@@ -120,7 +132,7 @@ module ActiveScaffold::Actions
     def each_record_in_scope
       do_search if respond_to? :do_search, true
       set_includes_for_columns
-      append_to_query(beginning_of_chain, finder_options).all.each {|record| yield record}
+      append_to_query(beginning_of_chain, finder_options).each {|record| yield record}
     end
 
     # The default security delegates to ActiveRecordPermissions.
@@ -145,9 +157,7 @@ module ActiveScaffold::Actions
         @action_link = active_scaffold_config.action_links[action_name]
         if params[:id] && params[:id].to_i > 0
           crud_type ||= (request.post? || request.put?) ? :update : :delete
-          set_includes_for_columns
-          klass = beginning_of_chain.includes(active_scaffold_includes)
-          @record = find_if_allowed(params[:id], crud_type, klass)
+          get_row(crud_type)
           unless @record.nil?
             yield @record
           else
@@ -176,15 +186,26 @@ module ActiveScaffold::Actions
     end
 
     def action_update_respond_to_xml
-      render :xml => successful? ? "" : response_object.to_xml(:only => list_columns_names), :content_type => Mime::XML, :status => response_status
+      render :xml => successful? ? "" : response_object.to_xml(:only => list_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(list_columns_names), :methods => virtual_columns(list_columns_names)), :content_type => Mime::XML, :status => response_status
     end
 
     def action_update_respond_to_json
-      render :text => successful? ? "" : response_object.to_json(:only => list_columns_names), :content_type => Mime::JSON, :status => response_status
+      render :text => successful? ? "" : response_object.to_json(:only => list_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(list_columns_names), :methods => virtual_columns(list_columns_names)), :content_type => Mime::JSON, :status => response_status
     end
 
     def action_update_respond_to_yaml
-      render :text => successful? ? "" : Hash.from_xml(response_object.to_xml(:only => list_columns_names)).to_yaml, :content_type => Mime::YAML, :status => response_status
+      render :text => successful? ? "" : Hash.from_xml(response_object.to_xml(:only => list_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(list_columns_names), :methods => virtual_columns(list_columns_names))).to_yaml, :content_type => Mime::YAML, :status => response_status
+    end
+
+    def objects_for_etag
+      objects = if @list_columns
+        if active_scaffold_config.list.calculate_etag
+          @records.to_a
+        elsif active_scaffold_config.list.user.sorting
+          {:etag => active_scaffold_config.list.user.sorting.clause}
+        end
+      end
+      objects.present? ? objects : super
     end
 
     private

data/lib/active_scaffold/actions/nested.rb

@@ -5,7 +5,7 @@ module ActiveScaffold::Actions
     def self.included(base)
       super
       base.module_eval do
-        prepend_before_filter :set_nested
+        before_filter :set_nested
         before_filter :configure_nested
         include ActiveScaffold::Actions::Nested::ChildMethods if active_scaffold_config.model.reflect_on_all_associations.any? {|a| a.macro == :has_and_belongs_to_many}
       end
@@ -16,6 +16,7 @@ module ActiveScaffold::Actions
 
     protected
     def nested
+      set_nested unless defined? @nested
       @nested
     end
     
@@ -76,12 +77,20 @@ module ActiveScaffold::Actions
       if nested? && nested.association
         if nested.association.collection?
           nested_parent_record.send(nested.association.name)
-        elsif nested.association.options[:through] || nested.child_association.nil? # has_one :through doesn't need conditions, and without child_association is not possible to add them
+        elsif nested.association.options[:through] # has_one :through
+          active_scaffold_config.model.where(active_scaffold_config.model.primary_key => nested_parent_record.send(nested.association.name).try(:id))
+        elsif nested.child_association.nil? # without child_association is not possible to add conditions
           active_scaffold_config.model
         elsif nested.child_association.belongs_to?
           active_scaffold_config.model.where(nested.child_association.foreign_key => nested_parent_record)
         elsif nested.association.belongs_to?
-          active_scaffold_config.model.joins(nested.child_association.name).where(nested.association.active_record.table_name => {nested.association.active_record.primary_key => nested_parent_record}).readonly(false)
+          chain = active_scaffold_config.model.joins(nested.child_association.name)
+          table_name = if active_scaffold_config.model == nested.association.active_record
+            dependency = ActiveRecord::Associations::JoinDependency.new(chain.klass, chain.joins_values, [])
+            dependency.join_associations.find {|join| join.try(:reflection).try(:name) == nested.child_association.name}.try(:table).try(:right)
+          end
+          table_name ||= nested.association.active_record.table_name
+          chain.where(table_name => {nested.association.active_record.primary_key => nested_parent_record}).readonly(false)
         end
       elsif nested? && nested.scope
         nested_parent_record.send(nested.scope)
@@ -96,12 +105,11 @@ module ActiveScaffold::Actions
        
     def create_association_with_parent(record)
       if nested?
+        # has_many is done by beginning_of_chain and rails
         if (nested.belongs_to? || nested.has_one? || nested.habtm?) && nested.child_association
           parent = nested_parent_record(:read)
           case nested.child_association.macro
-          when :has_one
-            record.send("#{nested.child_association.name}=", parent)
-          when :belongs_to
+          when :has_one, :belongs_to
             record.send("#{nested.child_association.name}=", parent)
           when :has_many, :has_and_belongs_to_many
             record.send("#{nested.child_association.name}").send(:<<, parent)

data/lib/active_scaffold/actions/search.rb

@@ -1,48 +1,49 @@
 module ActiveScaffold::Actions
   module Search
-    include ActiveScaffold::Actions::CommonSearch
     def self.included(base)
-      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
+      base.send :include, ActiveScaffold::Actions::CommonSearch
+      base.send :include, InstanceMethods
     end
+    
+    module InstanceMethods
 
-    def show_search
-      respond_to_action(:search)
-    end
+      protected
+      def search_respond_to_html
+        render(:action => "search")
+      end
+      def search_respond_to_js
+        render(:partial => "search")
+      end
+      def do_search
+        if search_params.is_a?(String) && search_params.present?
+          query = search_params.to_s.strip
+          columns = active_scaffold_config.search.columns
+          text_search = active_scaffold_config.search.text_search
+          query = query.split(active_scaffold_config.search.split_terms) if active_scaffold_config.search.split_terms
+          search_conditions = self.class.create_conditions_for_columns(query, columns, text_search)
+          @filtered = !search_conditions.blank?
+          self.active_scaffold_conditions.concat search_conditions if @filtered
 
-    protected
-    def search_respond_to_html
-      render(:action => "search")
-    end
-    def search_respond_to_js
-      render(:partial => "search")
-    end
-    def do_search
-      query = search_params.to_s.strip rescue ''
-      unless query.empty?
-        columns = active_scaffold_config.search.columns
-        text_search = active_scaffold_config.search.text_search
-        query = query.split(active_scaffold_config.search.split_terms) if active_scaffold_config.search.split_terms
-        search_conditions = self.class.create_conditions_for_columns(query, columns, text_search)
-        @filtered = !search_conditions.blank?
-        self.active_scaffold_conditions.concat search_conditions if @filtered
+          references, outer_joins = columns.partition{ |column| column.includes.present? && list_columns.include?(column)}
+          outer_joins.collect! { |column| column.search_joins}
+          references.collect! { |column| column.includes }
+          self.active_scaffold_outer_joins.concat outer_joins.flatten.uniq.compact
+          self.active_scaffold_references.concat references.flatten.uniq.compact
 
-        outer_joins = columns.collect{ |column| column.search_joins unless column.includes.present? && list_columns.include?(column)}
-        self.active_scaffold_outer_joins.concat outer_joins.flatten.uniq.compact
+          active_scaffold_config.list.user.page = nil
+        else
+          super
+        end
+      end
 
-        active_scaffold_config.list.user.page = nil
+      def search_ignore?
+        active_scaffold_config.list.always_show_search == :search || global_search_ignore?
       end
-    end
 
-    private
-    def search_authorized_filter
-      link = active_scaffold_config.search.link || active_scaffold_config.search.class.link
-      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
-    end
-    def search_formats
-      (default_formats + active_scaffold_config.formats + active_scaffold_config.search.formats).uniq
+      private
+      def search_formats
+        (default_formats + active_scaffold_config.formats + active_scaffold_config.search.formats).uniq
+      end
     end
   end
 end