active_scaffold 3.4.17 → 3.4.18

data/lib/active_scaffold/actions/search.rb

@@ -4,16 +4,18 @@ module ActiveScaffold::Actions
       base.send :include, ActiveScaffold::Actions::CommonSearch
       base.send :include, InstanceMethods
     end
-    
-    module InstanceMethods
 
+    module InstanceMethods
       protected
+
       def search_respond_to_html
-        render(:action => "search")
+        render(:action => 'search')
       end
+
       def search_respond_to_js
-        render(:partial => "search")
+        render(:partial => 'search')
       end
+
       def do_search
         if search_params.is_a?(String) && search_params.present?
           query = search_params.to_s.strip
@@ -22,13 +24,13 @@ module ActiveScaffold::Actions
           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
+          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
+          references, outer_joins = columns.partition { |column| column.includes.present? && list_columns.include?(column) }
+          outer_joins.collect!(&:search_joins)
+          references.collect!(&:includes)
+          active_scaffold_outer_joins.concat outer_joins.flatten.uniq.compact
+          active_scaffold_references.concat references.flatten.uniq.compact
 
           active_scaffold_config.list.user.page = nil
         else
@@ -41,6 +43,7 @@ module ActiveScaffold::Actions
       end
 
       private
+
       def search_formats
         (default_formats + active_scaffold_config.formats + active_scaffold_config.search.formats).uniq
       end

data/lib/active_scaffold/actions/show.rb

@@ -7,12 +7,12 @@ module ActiveScaffold::Actions
     def show
       # rest destroy falls back to rest show in case of disabled javascript
       # just render action_confirmation message for destroy
-      unless params.delete :destroy_action
-        do_show
-        respond_to_action(:show)
-      else
+      if params.delete :destroy_action
         @record = find_if_allowed(params[:id], :read) if params[:id]
         action_confirmation_respond_to_html(:destroy)
+      else
+        do_show
+        respond_to_action(:show)
       end
     end
 
@@ -55,14 +55,18 @@ 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)
+      !send(:authorized_for?, :crud_type => :read)
     end
+
     private
+
     def show_authorized_filter
       link = active_scaffold_config.show.link || active_scaffold_config.show.class.link
-      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
+      raise ActiveScaffold::ActionNotAllowed unless send(link.security_method)
     end
+
     def show_formats
       (default_formats + active_scaffold_config.formats + active_scaffold_config.show.formats).uniq
     end

data/lib/active_scaffold/actions/subform.rb

@@ -20,7 +20,7 @@ module ActiveScaffold::Actions
       # NOTE: we don't check whether the user is allowed to update this record, because if not, we'll still let them associate the record. we'll just refuse to do more than associate, is all.
       @record = @column.association.klass.find(params[:associated_id]) if params[:associated_id]
       if @record
-        if association = active_scaffold_config.columns[params[:child_association]].association.reverse
+        if (association = active_scaffold_config.columns[params[:child_association]].association.reverse)
           if @record.class.reflect_on_association(association).collection?
             @record.send(association) << @parent_record
           else
@@ -32,6 +32,5 @@ module ActiveScaffold::Actions
       end
       @scope = params[:scope]
     end
-
   end
 end

data/lib/active_scaffold/actions/update.rb

@@ -22,6 +22,7 @@ module ActiveScaffold::Actions
     end
 
     protected
+
     def edit_respond_to_html
       if successful?
         render(:action => 'update')
@@ -29,12 +30,13 @@ module ActiveScaffold::Actions
         return_to_main
       end
     end
+
     def edit_respond_to_js
       render(:partial => 'update_form')
     end
-    
+
     def update_respond_to_html
-      if params[:iframe]=='true' # was this an iframe post ?
+      if params[:iframe] == 'true' # was this an iframe post ?
         do_refresh_list if successful? && active_scaffold_config.update.refresh_list && !render_parent?
         responds_to_parent do
           render :action => 'on_update', :formats => [:js], :layout => false
@@ -54,7 +56,7 @@ module ActiveScaffold::Actions
         end
       end
     end
-    
+
     def update_respond_to_js
       if successful?
         if !render_parent? && active_scaffold_config.actions.include?(:list)
@@ -70,15 +72,15 @@ module ActiveScaffold::Actions
       end
       render :action => 'on_update'
     end
-    
+
     def update_respond_to_xml
       render :xml => response_object.to_xml(:only => update_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(update_columns_names), :methods => virtual_columns(update_columns_names)), :content_type => Mime::XML, :status => response_status
     end
-    
+
     def update_respond_to_json
       render :text => response_object.to_json(:only => update_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(update_columns_names), :methods => virtual_columns(update_columns_names)), :content_type => Mime::JSON, :status => response_status
     end
-    
+
     def update_respond_to_yaml
       render :text => Hash.from_xml(response_object.to_xml(:only => update_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(update_columns_names), :methods => virtual_columns(update_columns_names))).to_yaml, :content_type => Mime::YAML, :status => response_status
     end
@@ -109,7 +111,7 @@ module ActiveScaffold::Actions
           # errors to @record can be added by update_record_from_params when association fails to set and ActiveRecord::RecordNotSaved is raised
           self.successful = [@record.errors.empty? && @record.valid?, @record.associated_valid?].all? # this syntax avoids a short-circuit
           if successful?
-            @record.save! and @record.save_associated!
+            @record.save! && @record.save_associated!
             after_update_save(@record)
           else
             # some associations such as habtm are saved before saved is called on parent object
@@ -121,11 +123,11 @@ module ActiveScaffold::Actions
         @record.errors.add(:base, as_(:version_inconsistency))
         self.successful = false
       rescue ActiveRecord::RecordNotSaved => exception
-        logger.warn {
+        logger.warn do
           "\n\n#{exception.class} (#{exception.message}):\n    " +
-          Rails.backtrace_cleaner.clean(exception.backtrace).join("\n    ") +
-          "\n\n"
-        }
+            Rails.backtrace_cleaner.clean(exception.backtrace).join("\n    ") +
+            "\n\n"
+        end
         @record.errors.add(:base, as_(:record_not_saved)) if @record.errors.empty?
         self.successful = false
       rescue ActiveRecord::ActiveRecordError => ex
@@ -140,30 +142,31 @@ module ActiveScaffold::Actions
       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
+      return unless @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?
-          value = column_value_from_param_value(@record, @column, value)
-          value = [] if value.nil? && @column.form_ui && @column.plural_association?
-        end
-        @record.send("#{@column.name}=", value)
-        before_update_save(@record)
-        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
+      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("#{@column.name}=", value)
+      before_update_save(@record)
+      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
-        after_update_save(@record)
       end
+      after_update_save(@record)
     end
 
     # override this method if you want to inject data in the record (or its associated objects) before the save
@@ -182,17 +185,22 @@ module ActiveScaffold::Actions
     def update_authorized?(record = nil)
       (!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
       link = active_scaffold_config.update.link || active_scaffold_config.update.class.link
-      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
+      raise ActiveScaffold::ActionNotAllowed unless send(link.security_method)
     end
+
     def edit_formats
       (default_formats + active_scaffold_config.formats).uniq
     end
+
     def update_formats
       (default_formats + active_scaffold_config.formats + active_scaffold_config.update.formats).uniq
     end

data/lib/active_scaffold/active_record_permissions.rb

@@ -14,14 +14,12 @@ module ActiveScaffold
     # ActiveRecordPermissions needs to know what method on your ApplicationController will return the current user,
     # if available. This defaults to the :current_user method. You may configure this in your environment.rb if you
     # have a different setup.
-    def self.current_user_method=(v); @@current_user_method = v; end
-    def self.current_user_method; @@current_user_method; end
+    mattr_accessor :current_user_method
     @@current_user_method = :current_user
 
     # Whether the default permission is permissive or not
     # If set to true, then everything's allowed until configured otherwise
-    def self.default_permission=(v); @@default_permission = v; end
-    def self.default_permission; @@default_permission; end
+    mattr_accessor :default_permission
     @@default_permission = true
 
     # This is a module aimed at making the current_user available to ActiveRecord models for permissions.
@@ -35,7 +33,7 @@ module ActiveScaffold
         # because the object may change (someone may log in or out). So we give ActiveRecord a proc that ties to the
         # current_user_method on this ApplicationController.
         def assign_current_user_to_models
-          ActiveRecord::Base.current_user_proc = proc {send(ActiveRecordPermissions.current_user_method)}
+          ActiveRecord::Base.current_user_proc = proc { send(ActiveRecordPermissions.current_user_method) }
         end
       end
 
@@ -50,6 +48,7 @@ module ActiveScaffold
           def current_user_proc
             Thread.current[:current_user_proc]
           end
+
           def current_user_proc=(proc_value)
             Thread.current[:current_user_proc] = proc_value
           end
@@ -93,7 +92,7 @@ module ActiveScaffold
         # options[:column] should be the name of a model attribute
         # options[:action] is the name of a method
         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])
+          raise ArgumentError, "unknown crud type #{options[:crud_type]}" if options[:crud_type] && ![:create, :read, :update, :delete].include?(options[:crud_type])
 
           # collect other possibly-related methods that actually exist
           methods = cached_authorized_for_methods(options)
@@ -101,10 +100,10 @@ module ActiveScaffold
           return send(methods.first) if methods.one?
 
           # if any method returns false, then return false
-          return false if methods.any? {|m| !send(m)}
+          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
@@ -121,21 +120,21 @@ module ActiveScaffold
           # 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 [method] if method and respond_to?(method)
+          return [method] if method && 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 [method] if method and respond_to?(method)
+          return [method] if method && 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)}
+            crud_type_security_method(options[:crud_type])
+          ].compact.select { |m| respond_to?(m) }
         end
-        
+
         private
 
         def column_security_method(column)
@@ -151,7 +150,7 @@ module ActiveScaffold
         end
 
         def column_and_crud_type_security_method(column, crud_type)
-          "#{column}_authorized_for_#{crud_type}?" if column and crud_type
+          "#{column}_authorized_for_#{crud_type}?" if column && crud_type
         end
       end
     end

data/lib/active_scaffold/attribute_params.rb

@@ -32,10 +32,11 @@ module ActiveScaffold
   # }
   module AttributeParams
     protected
+
     # workaround to update counters when belongs_to changes on persisted record on Rails 3
     # workaround to update counters when polymorphic has_many changes on persisted record
-    # TODO remove when rails3 support is removed and counter cache for polymorphic has_many association works on rails4 (works on rails4.2)
-    def has_many_counter_cache_hack(parent_record, column, value)
+    # TODO: remove when rails3 support is removed and counter cache for polymorphic has_many association works on rails4 (works on rails4.2)
+    def hack_for_has_many_counter_cache(parent_record, column, value)
       association = parent_record.association(column.name)
       counter_attr = association.send(:cached_counter_attribute_name)
       difference = value.select(&:persisted?).size - parent_record.send(counter_attr)
@@ -61,24 +62,22 @@ module ActiveScaffold
       end
       parent_record.send "#{column.name}=", value if parent_record.persisted?
     end
-    
-    # TODO remove when has_many_counter_cache_hack is not needed
-    def has_many_counter_cache_hack?(parent_record, column)
-      if column.association.try(:macro) == :has_many && parent_record.association(column.name).send(:has_cached_counter?)
-        if Rails.version < '4.0' # rails 3 needs this hack always
-          true
-        else # rails 4 needs this hack for polymorphic has_many
-          column.association.options[:as]
-        end
+
+    # TODO: remove when hack_for_has_many_counter_cache is not needed
+    def hack_for_has_many_counter_cache?(parent_record, column)
+      return unless column.association.try(:macro) == :has_many && parent_record.association(column.name).send(:has_cached_counter?)
+      if Rails.version < '4.0' # rails 3 needs this hack always
+        true
+      else # rails 4 needs this hack for polymorphic has_many
+        column.association.options[:as]
       end
     end
 
     # workaround for updating counters twice bug on rails4 (https://github.com/rails/rails/pull/14849)
-    # TODO remove when pull request is merged and no version with bug is supported
+    # TODO: remove when pull request is merged and no version with bug is supported
     def counter_cache_hack?(column, value)
-      if Rails.version >= '4.0' && !value.is_a?(Hash)
-        column.association.try(:belongs_to?) && column.association.options[:counter_cache] && !column.association.options[:polymorphic]
-      end
+      return unless Rails.version >= '4.0' && !value.is_a?(Hash)
+      column.association.try(:belongs_to?) && column.association.options[:counter_cache] && !column.association.options[:polymorphic]
     end
 
     # Takes attributes (as from params[:record]) and applies them to the parent_record. Also looks for
@@ -102,16 +101,16 @@ module ActiveScaffold
         begin
           # Set any passthrough parameters that may be associated with this column (ie, file column "keep" and "temp" attributes)
           unless column.params.empty?
-            column.params.each{|p| parent_record.send("#{p}=", attributes[p]) if attributes.has_key? p}
+            column.params.each { |p| parent_record.send("#{p}=", attributes[p]) if attributes.key? p }
           end
 
-          if multi_parameter_attributes.has_key? column.name.to_s
+          if multi_parameter_attributes.key? column.name.to_s
             parent_record.send(:assign_multiparameter_attributes, multi_parameter_attributes[column.name.to_s])
-          elsif attributes.has_key? column.name
+          elsif attributes.key? column.name
             value = update_column_from_params(parent_record, column, attributes[column.name], avoid_changes)
           end
-        rescue
-          logger.error "#{$!.class.name}: #{$!.message} -- on the ActiveScaffold column = :#{column.name} for #{parent_record.inspect}#{" with value #{value}" if value}"
+        rescue StandardError => e
+          logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column = :#{column.name} for #{parent_record.inspect}#{" with value #{value}" if value}"
           raise
         end
       end
@@ -119,7 +118,7 @@ module ActiveScaffold
       flash[:warning] = parent_record.errors.to_a.join("\n") if parent_record.errors.present?
       parent_record
     end
-    
+
     def update_column_from_params(parent_record, column, attribute, avoid_changes = false)
       value = column_value_from_param_value(parent_record, column, attribute, avoid_changes)
       if avoid_changes && column.plural_association?
@@ -129,8 +128,8 @@ module ActiveScaffold
         parent_record.association(column.name).target = value
       else
         begin
-          if has_many_counter_cache_hack?(parent_record, column)
-            has_many_counter_cache_hack(parent_record, column, value)
+          if hack_for_has_many_counter_cache?(parent_record, column)
+            hack_for_has_many_counter_cache(parent_record, column, value)
           else
             parent_record.send "#{column.name}=", value
           end
@@ -149,14 +148,14 @@ module ActiveScaffold
       # convert the value, possibly by instantiating associated objects
       form_ui = column.form_ui || column.column.try(:type)
       if form_ui && self.respond_to?("column_value_for_#{form_ui}_type", true)
-        self.send("column_value_for_#{form_ui}_type", parent_record, column, value)
+        send("column_value_for_#{form_ui}_type", parent_record, column, value)
       elsif value.is_a?(Hash)
         column_value_from_param_hash_value(parent_record, column, value, avoid_changes)
       else
         column_value_from_param_simple_value(parent_record, column, value)
       end
     end
-    
+
     def datetime_conversion_for_value(column)
       if column.column
         column.column.type == :date ? :to_date : :to_time
@@ -164,9 +163,9 @@ module ActiveScaffold
         :to_time
       end
     end
-    
+
     def column_value_for_datetime_type(parent_record, column, value)
-      new_value = self.class.condition_value_for_datetime(column, value, self.datetime_conversion_for_value(column))
+      new_value = self.class.condition_value_for_datetime(column, value, datetime_conversion_for_value(column))
       if new_value.nil? && value.present?
         parent_record.errors.add column.name, :invalid
       end
@@ -192,15 +191,15 @@ module ActiveScaffold
         # convert empty strings into nil. this works better with 'null => true' columns (and validations),
         # and 'null => false' columns should just convert back to an empty string.
         # ... but we can at least check the ConnectionAdapter::Column object to see if nulls are allowed
-        value = nil if value.is_a? String and value.empty? and !column.column.nil? and column.column.null
+        value = nil if value.is_a?(String) && value.empty? && !column.column.nil? && column.column.null
         value
       end
     end
 
     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.present?}
+      if value && !value.empty?
+        ids = value.select(&:present?)
         ids.empty? ? [] : column.association.klass.find(ids)
       else
         []
@@ -211,13 +210,13 @@ module ActiveScaffold
       if column.singular_association?
         manage_nested_record_from_params(parent_record, column, value, avoid_changes)
       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, avoid_changes) unless value == ""}.compact
+        # HACK: to be able to delete all associated records, hash will include "0" => ""
+        value.collect { |_, val| manage_nested_record_from_params(parent_record, column, val, avoid_changes) unless val.blank? }.compact
       else
         value
       end
     end
-    
+
     def manage_nested_record_from_params(parent_record, column, attributes, avoid_changes = false)
       return nil unless build_record_from_params(attributes, column, parent_record)
       record = find_or_create_for_params(attributes, column, parent_record)
@@ -242,7 +241,7 @@ module ActiveScaffold
     def find_or_create_for_params(params, parent_column, parent_record)
       current = parent_record.send(parent_column.name)
       klass = parent_column.association.klass
-      if params.has_key? klass.primary_key
+      if params.key? klass.primary_key
         record_from_current_or_find(klass, params[klass.primary_key], current)
       elsif klass.authorized_for?(:crud_type => :create)
         parent_column.association.klass.new
@@ -252,12 +251,12 @@ module ActiveScaffold
     # Attempts to find an instance of klass (which must be an ActiveRecord object) with id primary key
     # Returns record from current if it's included or find from DB
     def record_from_current_or_find(klass, id, current)
-      if current and current.is_a? ActiveRecord::Base and current.id.to_s == id
-      # modifying the current object of a singular association
+      if current && current.is_a?(ActiveRecord::Base) && current.id.to_s == id
+        # modifying the current object of a singular association
         current
-      elsif current and current.respond_to?(:any?) and current.any? {|o| o.id.to_s == id}
-      # modifying one of the current objects in a plural association
-        current.detect {|o| o.id.to_s == id}
+      elsif current && current.respond_to?(:any?) && current.any? { |o| o.id.to_s == id }
+        # modifying one of the current objects in a plural association
+        current.detect { |o| o.id.to_s == id }
       else # attaching an existing but not-current object
         klass.find(id)
       end
@@ -276,17 +275,17 @@ module ActiveScaffold
     # This isn't a literal emptiness - it's an attempt to discern whether the user intended it to be empty or not.
     def attributes_hash_is_empty?(hash, klass)
       ignore_column_types = [:boolean]
-      hash.all? do |key,value|
+      hash.all? do |key, value|
         # convert any possible multi-parameter attributes like 'created_at(5i)' to simply 'created_at'
         parts = key.to_s.split('(')
-        #old style date form management... ignore them too
+        # old style date form management... ignore them too
         ignore_column_types = [:boolean, :datetime, :date, :time] if parts.length > 1
         column_name = parts.first
         column = klass.columns_hash[column_name]
 
         # booleans and datetimes will always have a value. so we ignore them when checking whether the hash is empty.
         # this could be a bad idea. but the current situation (excess record entry) seems worse.
-        next true if column and ignore_column_types.include?(column.type)
+        next true if column && ignore_column_types.include?(column.type)
 
         # defaults are pre-filled on the form. we can't use them to determine if the user intends a new row.
         next true if value == column_default_value(column_name, klass, column)
@@ -300,7 +299,7 @@ module ActiveScaffold
         end
       end
     end
-    
+
     def column_default_value(column_name, klass, column)
       column.default.to_s if column
     end