active_scaffold 3.2.20 → 3.3.0.rc

data/lib/active_scaffold/actions/list.rb

@@ -55,25 +55,25 @@ module ActiveScaffold::Actions
     end
     
     def row_respond_to_js
-      render
+      render :action => 'row'
     end
 
     # The actual algorithm to prepare for the list view
-    def set_includes_for_list_columns
+    def set_includes_for_columns(action = :list)
       @cache_associations = true
-      includes_for_list_columns = active_scaffold_config.list.columns.collect{ |c| c.includes }.flatten.uniq.compact
+      includes_for_list_columns = active_scaffold_config.send(action).columns.collect{ |c| c.includes }.flatten.uniq.compact
       self.active_scaffold_includes.concat includes_for_list_columns
     end
     
     def get_row
-      set_includes_for_list_columns
+      set_includes_for_columns
       klass = beginning_of_chain.includes(active_scaffold_includes)
       @record = find_if_allowed(params[:id], :read, klass)
     end
 
     # The actual algorithm to prepare for the list view
     def do_list
-      set_includes_for_list_columns
+      set_includes_for_columns
 
       options = { :sorting => active_scaffold_config.list.user.sorting,
         :count_includes => active_scaffold_config.list.user.count_includes }
@@ -96,6 +96,7 @@ module ActiveScaffold::Actions
     end
     
     def do_refresh_list
+      params.delete(:id)
       do_search if respond_to? :do_search
       do_list
     end
@@ -135,7 +136,9 @@ module ActiveScaffold::Actions
         @action_link = active_scaffold_config.action_links[action_name]
         if params[:id] && params[:id] && params[:id].to_i > 0
           crud_type ||= (request.post? || request.put?) ? :update : :delete
-          @record = find_if_allowed(params[:id], crud_type)
+          set_includes_for_columns
+          klass = beginning_of_chain.includes(active_scaffold_includes)
+          @record = find_if_allowed(params[:id], crud_type, klass)
           unless @record.nil?
             yield @record
           else

data/lib/active_scaffold/actions/mark.rb

@@ -29,7 +29,7 @@ module ActiveScaffold::Actions
     def mark_respond_to_js
       if params[:id]
         do_search if respond_to? :do_search
-        set_includes_for_list_columns
+        set_includes_for_columns if active_scaffold_config.actions.include? :list
         @page = find_page(:pagination => active_scaffold_config.mark.mark_all_mode != :page)
         render :action => 'on_mark'
       else

data/lib/active_scaffold/actions/nested.rb

@@ -37,7 +37,7 @@ module ActiveScaffold::Actions
         else
           as_(:nested_for_model, :nested_model => active_scaffold_config.list.label, :parent_model => nested_parent_record.to_label)
         end
-        if nested.sorted?
+        if nested.sorted? && !active_scaffold_config.nested.ignore_order_from_association
           active_scaffold_config.list.user.nested_default_sorting = {:table_name => active_scaffold_config.model.model_name, :default_sorting => nested.default_sorting}
         end
       end
@@ -73,16 +73,18 @@ module ActiveScaffold::Actions
     end
     
     def beginning_of_chain
-      if nested? && nested.association && !nested.association.belongs_to?
+      if nested? && nested.association
         if nested.association.collection?
-          nested.parent_scope.send(nested.association.name)
-        elsif nested.association.options[:through] # has_one :through doesn't need conditions
+          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
           active_scaffold_config.model
         elsif nested.child_association.belongs_to?
-          active_scaffold_config.model.where(nested.child_association.foreign_key => nested.parent_scope)
+          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)
         end
       elsif nested? && nested.scope
-        nested.parent_scope.send(nested.scope)
+        nested_parent_record.send(nested.scope)
       else
         active_scaffold_config.model
       end

data/lib/active_scaffold/actions/show.rb

@@ -41,7 +41,9 @@ module ActiveScaffold::Actions
     # A simple method to retrieve and prepare a record for showing.
     # May be overridden to customize show routine
     def do_show
-      @record = find_if_allowed(params[:id], :read)
+      set_includes_for_columns(:show) if active_scaffold_config.actions.include? :list
+      klass = beginning_of_chain.includes(active_scaffold_includes)
+      @record = find_if_allowed(params[:id], :read, klass)
     end
 
     # The default security delegates to ActiveRecordPermissions.
@@ -49,6 +51,9 @@ module ActiveScaffold::Actions
     def show_authorized?(record = nil)
       (record || self).send(:authorized_for?, :crud_type => :read)
     end
+    def show_ignore?(record = nil)
+      !self.send(:authorized_for?, :crud_type => :read)
+    end
     private 
     def show_authorized_filter
       link = active_scaffold_config.show.link || active_scaffold_config.show.class.link

data/lib/active_scaffold/actions/update.rb

@@ -18,7 +18,7 @@ module ActiveScaffold::Actions
     # for inline (inlist) editing
     def update_column
       do_update_column
-      @column_span_id = params[:editor_id] || params[:editorId]
+      @column_span_id = params.delete(:editor_id) || params.delete(:editorId)
     end
 
     protected
@@ -35,7 +35,7 @@ module ActiveScaffold::Actions
     def update_respond_to_html
       if params[:iframe]=='true' # was this an iframe post ?
         responds_to_parent do
-          render :action => 'on_update.js', :layout => false
+          render :action => 'on_update', :formats => [:js], :layout => false
         end
       else # just a regular post
         if successful?
@@ -48,7 +48,13 @@ module ActiveScaffold::Actions
     end
     def update_respond_to_js
       if successful?
-        do_refresh_list if update_refresh_list? && !render_parent?
+        if !render_parent? && active_scaffold_config.actions.include?(:list)
+          if update_refresh_list?
+            do_refresh_list
+          else
+            get_row
+          end
+        end
         flash.now[:info] = as_(:updated_model, :model => @record.to_label) if active_scaffold_config.update.persistent
       end
       render :action => 'on_update'
@@ -62,6 +68,7 @@ module ActiveScaffold::Actions
     def update_respond_to_yaml
       render :text => Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.update.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status
     end
+
     # A simple method to find and prepare a record for editing
     # May be overridden to customize the record (set default values, etc.)
     def do_edit
@@ -81,7 +88,7 @@ module ActiveScaffold::Actions
         active_scaffold_config.model.transaction do
           @record = update_record_from_params(@record, active_scaffold_config.update.columns, attributes) unless options[:no_record_param_update]
           before_update_save(@record)
-          self.successful = [@record.valid?, @record.associated_valid?].all? {|v| v == true} # this syntax avoids a short-circuit
+          self.successful = [@record.valid?, @record.associated_valid?].all? # this syntax avoids a short-circuit
           if successful?
             @record.save! and @record.save_associated!
             after_update_save(@record)
@@ -104,23 +111,33 @@ module ActiveScaffold::Actions
     end
 
     def do_update_column
-      @record = active_scaffold_config.model.find(params[:id])
-      if @record.authorized_for?(:crud_type => :update, :column => params[:column])
-        column = active_scaffold_config.columns[params[:column].to_sym]
-        unless @record.column_for_attribute(params[:column]).nil? || @record.column_for_attribute(params[:column]).null
-          if @record.column_for_attribute(params[:column]).default == true
-            params[:value] ||= false
-          else
-            params[:value] ||= @record.column_for_attribute(params[:column]).default
-          end
+      # delete from params so update :table won't break urls, also they shouldn't be used in sort links too
+      value = params.delete(:value)
+      column = params.delete(:column).to_sym
+      params.delete(:original_html)
+      params.delete(:original_value)
+
+      @record = find_if_allowed(params[:id], :read)
+      if @record.authorized_for?(:crud_type => :update, :column => column)
+        @column = active_scaffold_config.columns[column]
+        value ||= unless @column.column.nil? || @column.column.null
+          @column.column.default == true ? false : @column.column.default
         end
-        unless column.nil?
-          params[:value] = column_value_from_param_value(@record, column, params[:value])
-          params[:value] = [] if params[:value].nil? && column.form_ui && column.plural_association?
+        unless @column.nil?
+          value = column_value_from_param_value(@record, @column, value)
+          value = [] if value.nil? && @column.form_ui && @column.plural_association?
         end
-        @record.send("#{params[:column]}=", params[:value])
+        @record.send("#{@column.name}=", value)
         before_update_save(@record)
-        @record.save
+        self.successful = @record.save
+        if self.successful? && active_scaffold_config.actions.include?(:list)
+          if @column.inplace_edit_update == :table
+            params.delete(:id)
+            do_list
+          elsif @column.inplace_edit_update
+            get_row
+          end
+        end
         after_update_save(@record)
       end
     end
@@ -139,7 +156,10 @@ module ActiveScaffold::Actions
     # The default security delegates to ActiveRecordPermissions.
     # You may override the method to customize.
     def update_authorized?(record = nil)
-      (!nested? || !nested.readonly?) && (record || self).send(:authorized_for?, :crud_type => :update)
+      (!nested? || !nested.readonly?) && (record || self).authorized_for?(:crud_type => :update)
+    end
+    def update_ignore?(record = nil)
+      !self.authorized_for?(:crud_type => :update)
     end
     private
     def update_authorized_filter

data/lib/active_scaffold/active_record_permissions.rb

@@ -65,6 +65,10 @@ module ActiveRecordPermissions
     def self.included(base)
       base.extend SecurityMethods
       base.send :include, SecurityMethods
+      class << base
+        attr_accessor :class_security_methods
+        attr_accessor :instance_security_methods
+      end
     end
 
     # Because any class-level queries get delegated to the instance level via a new record,
@@ -85,34 +89,47 @@ module ActiveRecordPermissions
       def authorized_for?(options = {})
         raise ArgumentError, "unknown crud type #{options[:crud_type]}" if options[:crud_type] and ![:create, :read, :update, :delete].include?(options[:crud_type])
 
+        # collect other possibly-related methods that actually exist
+        methods = cached_authorized_for_methods(options)
+        return ActiveRecordPermissions.default_permission if methods.empty?
+        return send(methods.first) if methods.one?
+
+        # if any method returns false, then return false
+        return false if methods.any? {|m| !send(m)}
+        true
+      end
+      
+      def cached_authorized_for_methods(options)
+        key = "#{options[:crud_type]}##{options[:column]}##{options[:action]}"
+        if self.is_a? Class
+          self.class_security_methods ||= {}
+          self.class_security_methods[key] ||= authorized_for_methods(options)
+        else
+          self.class.instance_security_methods ||= {}
+          self.class.instance_security_methods[key] ||= authorized_for_methods(options)
+        end
+      end
+
+      def authorized_for_methods(options)
         # column_authorized_for_crud_type? has the highest priority over other methods,
         # you can disable a crud verb and enable that verb for a column
         # (for example, disable update and enable inplace_edit in a column)
         method = column_and_crud_type_security_method(options[:column], options[:crud_type])
-        return send(method) if method and respond_to?(method)
+        return [method] if method and respond_to?(method)
 
         # authorized_for_action? has higher priority than other methods,
         # you can disable a crud verb and enable an action with that crud verb
         # (for example, disable update and enable an action with update as crud type)
         method = action_security_method(options[:action])
-        return send(method) if method and respond_to?(method)
+        return [method] if method and respond_to?(method)
 
         # collect other possibly-related methods that actually exist
         methods = [
           column_security_method(options[:column]),
           crud_type_security_method(options[:crud_type]),
         ].compact.select {|m| respond_to?(m)}
-
-        # if any method returns false, then return false
-        return false if methods.any? {|m| !send(m)}
-
-        # if any method actually exists then it must've returned true, so return true
-        return true unless methods.empty?
-
-        # if no method exists, return the default permission
-        return ActiveRecordPermissions.default_permission
       end
-
+      
       private
 
       def column_security_method(column)

data/lib/active_scaffold/attribute_params.rb

@@ -66,7 +66,7 @@ module ActiveScaffold
       if parent_record.new_record?
         parent_record.class.reflect_on_all_associations.each do |a|
           next unless [:has_one, :has_many].include?(a.macro) and not (a.options[:through] || a.options[:finder_sql])
-          next unless association_proxy = parent_record.send(a.name)
+          next unless (association_proxy = parent_record.send(a.name)).present?
 
           raise ActiveScaffold::ReverseAssociationRequired, "Association #{a.name} in class #{parent_record.class.name}: In order to support :has_one and :has_many where the parent record is new and the child record(s) validate the presence of the parent, ActiveScaffold requires the reverse association (the belongs_to)." unless a.reverse
 
@@ -100,11 +100,18 @@ module ActiveScaffold
 
     def column_value_from_param_simple_value(parent_record, column, value)
       if column.singular_association?
-        # it's a single id
-        column.association.klass.find(value) if value and not value.empty?
+        if value.present?
+          if column.polymorphic_association?
+            class_name = parent_record.send(column.association.foreign_type)
+            class_name.constantize.find(value) if class_name
+          else
+            # it's a single id
+            column.association.klass.find(value)
+          end
+        end
       elsif column.plural_association?
         column_plural_assocation_value_from_value(column, Array(value))
-      elsif column.number? && [:i18n_number, :currency].include?(column.options[:format])
+      elsif column.number? && [:i18n_number, :currency].include?(column.options[:format]) && column.form_ui != :number
         self.class.i18n_number_to_native_format(value)
       else
         # convert empty strings into nil. this works better with 'null => true' columns (and validations),
@@ -118,7 +125,7 @@ module ActiveScaffold
     def column_plural_assocation_value_from_value(column, value)
       # it's an array of ids
       if value and not value.empty?
-        ids = value.select {|id| id.respond_to?(:empty?) ? !id.empty? : true}
+        ids = value.select {|id| id.present?}
         ids.empty? ? [] : column.association.klass.find(ids)
       end
     end
@@ -137,7 +144,7 @@ module ActiveScaffold
         manage_nested_record_from_params(parent_record, column, value)
       elsif column.plural_association?
         # HACK to be able to delete all associated records, hash will include "0" => ""
-        value.collect {|key, value| manage_nested_record_from_params(parent_record, column, value) unless value == ""}.compact
+        value.sort.collect {|key, value| manage_nested_record_from_params(parent_record, column, value) unless value == ""}.compact
       else
         value
       end
@@ -190,7 +197,7 @@ module ActiveScaffold
         if value.is_a?(Hash)
           attributes_hash_is_empty?(value, klass)
         elsif value.is_a?(Array)
-          value.all?(&:blank?)
+          value.any? {|id| id.respond_to?(:empty?) ? !id.empty? : true}
         else
           value.respond_to?(:empty?) ? value.empty? : false
         end

data/lib/active_scaffold/bridges/calendar_date_select.rb

@@ -3,7 +3,7 @@ class ActiveScaffold::Bridges::CalendarDateSelect < ActiveScaffold::DataStructur
     # check to see if the old bridge was installed.  If so, warn them
     # we can detect this by checking to see if the bridge was installed before calling this code
        
-    if ActiveScaffold::Config::Core.instance_methods.include?("initialize_with_calendar_date_select".send(::ActiveScaffold::METHOD_CONVERSION))
+    if ActiveScaffold::Config::Core.instance_methods.include?("initialize_with_calendar_date_select")
       raise RuntimeError, "We've detected that you have active_scaffold_calendar_date_select_bridge installed.  This plugin has been moved to core.  Please remove active_scaffold_calendar_date_select_bridge to prevent any conflicts"
     end
     

data/lib/active_scaffold/bridges/cancan/cancan_bridge.rb

@@ -11,8 +11,7 @@ module CanCan
   module Ability
     def as_action_aliases
       alias_action :list, :row, :show_search, :render_field, :to => :read
-      alias_action :update_column, :add_association, :edit_associated, 
-        :edit_associated, :new_existing, :add_existing, :to => :update
+      alias_action :update_column, :edit_associated, :new_existing, :add_existing, :to => :update
       alias_action :delete, :destroy_existing, :to => :destroy
     end
   end

data/lib/active_scaffold/bridges/carrierwave/list_ui.rb

@@ -1,7 +1,7 @@
 module ActiveScaffold
   module Helpers
     module ListColumnHelpers
-      def active_scaffold_column_carrierwave(column, record)
+      def active_scaffold_column_carrierwave(record, column)
         carrierwave = record.send("#{column.name}")
         return nil unless !carrierwave.file.blank?
         thumbnail_style = ActiveScaffold::Bridges::Carrierwave::CarrierwaveBridgeHelpers.thumbnail_style

data/lib/active_scaffold/bridges/chosen.rb

@@ -0,0 +1,14 @@
+class ActiveScaffold::Bridges::Chosen < ActiveScaffold::DataStructures::Bridge
+  def self.install
+    require File.join(File.dirname(__FILE__), "chosen/helpers.rb")
+  end
+  def self.install?
+    super && [:jquery, :prototype].include?(ActiveScaffold.js_framework)
+  end
+  def self.stylesheets
+    'chosen'
+  end
+  def self.javascripts
+    ["chosen-#{ActiveScaffold.js_framework}", "#{ActiveScaffold.js_framework}/active_scaffold_chosen"]
+  end
+end

data/lib/active_scaffold/bridges/chosen/helpers.rb

@@ -0,0 +1,48 @@
+class ActiveScaffold::Bridges::Chosen
+  module Helpers
+    def self.included(base)
+      base.class_eval do
+        include FormColumnHelpers
+        include SearchColumnHelpers
+      end
+    end
+
+    module FormColumnHelpers
+      # requires RecordSelect plugin to be installed and configured.
+      def active_scaffold_input_chosen(column, html_options)
+        html_options[:class] << ' chosen'
+        if column.plural_association?
+          associated_options, select_options = active_scaffold_plural_association_options(column)
+          options = {:selected => associated_options.collect {|a| a[1]}, :include_blank => as_(:_select_)}
+
+          html_options.update(:multiple => true).update(column.options[:html_options] || {})
+          options.update(column.options)
+          html_options[:name] = "#{html_options[:name]}[]" if html_options[:multiple] == true && !html_options[:name].to_s.ends_with?("[]")
+
+          if optgroup = options.delete(:optgroup)
+            select(:record, column.name, grouped_options_for_select(column, select_options, optgroup), options, html_options)
+          else
+            collection_select(:record, column.name, select_options, :id, :to_label, options, html_options)
+          end
+        else
+          active_scaffold_input_select(column, html_options)
+        end
+      end
+    end
+
+    module SearchColumnHelpers
+      def active_scaffold_search_chosen(column, options)
+        options[:class] << ' chosen'
+        active_scaffold_search_select(column, options)
+      end
+      
+      def active_scaffold_search_multi_chosen(column, options)
+        options[:class] << ' chosen'
+        options[:multiple] = true
+        active_scaffold_search_select(column, options)
+      end
+    end
+  end
+end
+
+ActionView::Base.class_eval { include ActiveScaffold::Bridges::Chosen::Helpers }