active_scaffold 3.4.17 → 3.4.18

data/lib/active_scaffold/extensions/reverse_associations.rb

@@ -16,7 +16,7 @@ module ActiveScaffold
       end
 
       def reverse(klass = nil)
-        unless defined? @reverse
+        unless defined? @reverse # rubocop:disable Style/IfUnlessModifier
           @reverse ||= inverse_of.try(:name)
         end
         @reverse || (autodetect_inverse(klass).try(:name) unless klass.nil?)
@@ -27,10 +27,10 @@ module ActiveScaffold
         klass ||= self.klass
 
         # name-based matching (association name vs self.active_record.to_s)
-        matches = self.reverse_matches(klass)
+        matches = reverse_matches(klass)
         if matches.length > 1
           matches.find_all do |assoc|
-            self.active_record.to_s.underscore.include? assoc.name.to_s.pluralize.singularize
+            active_record.to_s.underscore.include? assoc.name.to_s.pluralize.singularize
           end
         end
 
@@ -42,8 +42,9 @@ module ActiveScaffold
       def self.included(base)
         base.send :include, ActiveScaffold::ReverseAssociation::CommonMethods
       end
-      
+
       protected
+
       def reverse_matches(klass)
         reverse_matches = []
 
@@ -52,20 +53,20 @@ module ActiveScaffold
           next if assoc == self
           # skip over has_many :through associations
           next if assoc.options[:through]
-          next unless assoc.options[:polymorphic] or assoc.class_name == self.active_record.name
+          next unless assoc.options[:polymorphic] || assoc.class_name == active_record.name
 
-          case [assoc.macro, self.macro].find_all{|m| m == :has_and_belongs_to_many}.length
+          case [assoc.macro, macro].find_all { |m| m == :has_and_belongs_to_many }.length
             # if both are a habtm, then match them based on the join table
             when 2
-            next unless assoc.options[:join_table] == self.options[:join_table]
+              next unless assoc.options[:join_table] == options[:join_table]
 
             # if only one is a habtm, they do not match
             when 1
-            next
+              next
 
             # otherwise, match them based on the foreign_key
             when 0
-            next unless assoc.foreign_key.to_sym == self.foreign_key.to_sym
+              next unless assoc.foreign_key.to_sym == foreign_key.to_sym
           end
 
           reverse_matches << assoc
@@ -89,15 +90,14 @@ module ActiveScaffold
           next if assoc == self
           # only iterate has_many :through associations
           next unless assoc.options[:through]
-          next unless assoc.class_name == self.active_record.name
-          next unless assoc.through_reflection.class_name == self.through_reflection.class_name
-          
+          next unless assoc.class_name == active_record.name
+          next unless assoc.through_reflection.class_name == through_reflection.class_name
+
           reverse_matches << assoc
         end
         reverse_matches
       end
     end
-
   end
 end
 

data/lib/active_scaffold/extensions/routing_mapper.rb

@@ -1,14 +1,14 @@
 module ActionDispatch
   module Routing
     ACTIVE_SCAFFOLD_CORE_ROUTING = {
-        :collection => {:show_search => :get, :render_field => :post, :mark => :post},
-        :member => {:update_column => :post, :render_field => [:get, :post], :mark => :post}
+      :collection => {:show_search => :get, :render_field => :post, :mark => :post},
+      :member => {:update_column => :post, :render_field => [:get, :post], :mark => :post}
     }
     ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING = {
-        :collection => {:edit_associated => :get, :new_existing => :get, :add_existing => :post},
-        :member => {:edit_associated => :get, :destroy_existing => :delete}
+      :collection => {:edit_associated => :get, :new_existing => :get, :add_existing => :post},
+      :member => {:edit_associated => :get, :destroy_existing => :delete}
     }
-    
+
     class Mapper
       module Resources
         class ActiveScaffold < Resource
@@ -39,10 +39,10 @@ module ActionDispatch
           end
           as_association_routes if opts[:association]
         end
-        
+
         def as_association_routes
           resource_scope(:resource, ActiveScaffoldAssociation.new(parent_resource.name, parent_resource.options)) do
-            collection do 
+            collection do
               ActionDispatch::Routing::ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING[:collection].each do |name, type|
                 match(name, :via => type) if parent_resource.actions.include? name
               end
@@ -54,14 +54,14 @@ module ActionDispatch
             end
           end
         end
-        
+
         def as_nested_resources(*resources)
           options = resources.extract_options!
           resources.each do |resource|
             resources(resource, options.merge(:parent_scaffold => merge_module_scope(@scope[:module], parent_resource.plural), :association => resource)) { yield if block_given? }
           end
         end
-        
+
         def as_scoped_routes(*scopes)
           options = scopes.extract_options!
           scopes.each do |scope|

data/lib/active_scaffold/extensions/unsaved_associated.rb

@@ -9,15 +9,15 @@ class ActiveRecord::Base
   end
 
   def save_associated
-    with_unsaved_associated { |a| a.save and a.save_associated }
+    with_unsaved_associated { |a| a.save && a.save_associated }
   end
 
   def save_associated!
-    save_associated or raise(ActiveRecord::RecordNotSaved)
+    save_associated || raise(ActiveRecord::RecordNotSaved)
   end
 
   def no_errors_in_associated?
-    with_unsaved_associated {|a| a.errors.count == 0 and a.no_errors_in_associated?}
+    with_unsaved_associated { |a| a.errors.count == 0 && a.no_errors_in_associated? }
   end
 
   protected
@@ -33,10 +33,10 @@ class ActiveRecord::Base
   #
   # Otherwise the default behaviour of traversing all associations will be preserved.
   def associations_for_update
-    if self.respond_to?( :scaffold_update_nofollow )
-      self.class.reflect_on_all_associations.reject { |association| self.scaffold_update_nofollow.include?( association.name ) }
-    elsif self.respond_to?( :scaffold_update_follow )
-      self.class.reflect_on_all_associations.select { |association| self.scaffold_update_follow.include?( association.name ) }
+    if self.respond_to?(:scaffold_update_nofollow)
+      self.class.reflect_on_all_associations.reject { |association| scaffold_update_nofollow.include?(association.name) }
+    elsif self.respond_to?(:scaffold_update_follow)
+      self.class.reflect_on_all_associations.select { |association| scaffold_update_follow.include?(association.name) }
     else
       self.class.reflect_on_all_associations
     end
@@ -49,11 +49,11 @@ class ActiveRecord::Base
   # returns true otherwise, even when none of the associations have been instantiated. build wrapper methods accordingly.
   def with_unsaved_associated
     associations_for_update.all? do |assoc|
-      association_proxy = self.association(assoc.name)
+      association_proxy = association(assoc.name)
       if association_proxy.target.present?
         records = association_proxy.target
         records = [records] unless records.is_a? Array # convert singular associations into collections for ease of use
-        records.select {|r| r.unsaved? and not r.readonly?}.all? {|r| yield r} # must use select instead of find_all, which Rails overrides on association proxies for db access
+        records.select { |r| r.unsaved? && !r.readonly? }.all? { |r| yield r } # must use select instead of find_all, which Rails overrides on association proxies for db access
       else
         true
       end

data/lib/active_scaffold/finder.rb

@@ -1,7 +1,7 @@
 module ActiveScaffold
   module Finder
     def self.like_operator
-      @@like_operator ||= ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" ? "ILIKE" : "LIKE"
+      @@like_operator ||= ::ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? 'ILIKE' : 'LIKE'
     end
 
     module ClassMethods
@@ -24,11 +24,10 @@ module ActiveScaffold
         phrase = where_clauses.join(' OR ')
 
         tokens.collect do |value|
-          columns.inject([phrase]) do |condition, column|
+          columns.each_with_object([phrase]) do |column, condition|
             Array(column.search_sql).size.times do
               condition.push(column.text? ? like_pattern.sub('?', value) : ActiveScaffold::Core.column_type_cast(value, column.column))
             end
-            condition
           end
         end
       end
@@ -39,57 +38,62 @@ module ActiveScaffold
       def condition_for_column(column, value, text_search = :full)
         like_pattern = like_pattern(text_search)
         if self.respond_to?("condition_for_#{column.name}_column")
-          return self.send("condition_for_#{column.name}_column", column, value, like_pattern)
+          return send("condition_for_#{column.name}_column", column, value, like_pattern)
         end
-        return unless column and column.search_sql and not value.blank?
+        return unless column && column.search_sql && !value.blank?
         search_ui = column.search_ui || column.column.try(:type)
         begin
-          sql, *values = if search_ui && self.respond_to?("condition_for_#{search_ui}_type")
-            self.send("condition_for_#{search_ui}_type", column, value, like_pattern)
-          else
-            if column.search_sql.instance_of? Proc
-              column.search_sql.call(value)
+          sql, *values =
+            if search_ui && self.respond_to?("condition_for_#{search_ui}_type")
+              send("condition_for_#{search_ui}_type", column, value, like_pattern)
             else
-              case search_ui
-              when :boolean, :checkbox
-                ["%{search_sql} = ?", column.column ? ActiveScaffold::Core.column_type_cast(value, column.column) : value]
-              when :integer, :decimal, :float
-                condition_for_numeric(column, value)
-              when :string, :range
-                condition_for_range(column, value, like_pattern)
-              when :date, :time, :datetime, :timestamp
-                condition_for_datetime(column, value)
-              when :select, :multi_select, :country, :usa_state, :chosen, :multi_chosen
-                ["%{search_sql} in (?)", Array(value)]
+              if column.search_sql.instance_of? Proc
+                column.search_sql.call(value)
               else
-                if column.text?
-                  ["%{search_sql} #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', value)]
-                else
-                  ["%{search_sql} = ?", ActiveScaffold::Core.column_type_cast(value, column.column)]
-                end
+                condition_for_search_ui(column, value, like_pattern, search_ui)
               end
             end
-          end
           return nil unless sql
 
           conditions = [column.search_sql.collect { |search_sql| sql % {:search_sql => search_sql} }.join(' OR ')]
-          conditions += values*column.search_sql.size if values.present?
+          conditions += values * column.search_sql.size if values.present?
           conditions
-        rescue Exception => e
-          logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column :#{column.name}, search_ui = #{search_ui} in #{self.name}"
+        rescue StandardError => e
+          logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column :#{column.name}, search_ui = #{search_ui} in #{name}"
           raise e
         end
       end
 
+      def condition_for_search_ui(column, value, like_pattern, search_ui)
+        case search_ui
+        when :boolean, :checkbox
+          ['%{search_sql} = ?', column.column ? ActiveScaffold::Core.column_type_cast(value, column.column) : value]
+        when :integer, :decimal, :float
+          condition_for_numeric(column, value)
+        when :string, :range
+          condition_for_range(column, value, like_pattern)
+        when :date, :time, :datetime, :timestamp
+          condition_for_datetime(column, value)
+        when :select, :multi_select, :country, :usa_state, :chosen, :multi_chosen
+          ['%{search_sql} in (?)', Array(value)]
+        else
+          if column.text?
+            ["%{search_sql} #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', value)]
+          else
+            ['%{search_sql} = ?', ActiveScaffold::Core.column_type_cast(value, column.column)]
+          end
+        end
+      end
+
       def condition_for_numeric(column, value)
         if !value.is_a?(Hash)
-          ["%{search_sql} = ?", condition_value_for_numeric(column, value)]
-        elsif ActiveScaffold::Finder::NullComparators.include?(value[:opt])
+          ['%{search_sql} = ?', condition_value_for_numeric(column, value)]
+        elsif ActiveScaffold::Finder::NULL_COMPARATORS.include?(value[:opt])
           condition_for_null_type(column, value[:opt])
-        elsif value[:from].blank? or not ActiveScaffold::Finder::NumericComparators.include?(value[:opt])
+        elsif value[:from].blank? || !ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(value[:opt])
           nil
         elsif value[:opt] == 'BETWEEN'
-          ["(%{search_sql} BETWEEN ? AND ?)", condition_value_for_numeric(column, value[:from]), condition_value_for_numeric(column, value[:to])]
+          ['(%{search_sql} BETWEEN ? AND ?)', condition_value_for_numeric(column, value[:from]), condition_value_for_numeric(column, value[:to])]
         else
           ["%{search_sql} #{value[:opt]} ?", condition_value_for_numeric(column, value[:from])]
         end
@@ -100,20 +104,18 @@ module ActiveScaffold
           if column.text?
             ["%{search_sql} #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', value)]
           else
-            ["%{search_sql} = ?", ActiveScaffold::Core.column_type_cast(value, column.column)]
+            ['%{search_sql} = ?', ActiveScaffold::Core.column_type_cast(value, column.column)]
           end
-        elsif ActiveScaffold::Finder::NullComparators.include?(value[:opt])
+        elsif ActiveScaffold::Finder::NULL_COMPARATORS.include?(value[:opt])
           condition_for_null_type(column, value[:opt], like_pattern)
         elsif value[:from].blank?
           nil
-        elsif ActiveScaffold::Finder::StringComparators.values.include?(value[:opt])
+        elsif ActiveScaffold::Finder::STRING_COMPARATORS.values.include?(value[:opt])
           ["%{search_sql} #{ActiveScaffold::Finder.like_operator} ?", value[:opt].sub('?', value[:from])]
         elsif value[:opt] == 'BETWEEN'
-          ["(%{search_sql} BETWEEN ? AND ?)", value[:from], value[:to]]
-        elsif ActiveScaffold::Finder::NumericComparators.include?(value[:opt])
+          ['(%{search_sql} BETWEEN ? AND ?)', value[:from], value[:to]]
+        elsif ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(value[:opt])
           ["%{search_sql} #{value[:opt]} ?", value[:from]]
-        else
-          nil
         end
       end
 
@@ -135,7 +137,7 @@ module ActiveScaffold
 
       def condition_value_for_datetime(column, value, conversion = :to_time)
         if value.is_a? Hash
-          Time.zone.local(*[:year, :month, :day, :hour, :minute, :second].collect {|part| value[part].to_i}) rescue nil
+          Time.zone.local(*[:year, :month, :day, :hour, :minute, :second].collect { |part| value[part].to_i }) rescue nil
         elsif value.respond_to?(:strftime)
           if conversion == :to_time
             # Explicitly get the current zone, because TimeWithZone#to_time in rails 3.2.3 returns UTC.
@@ -150,11 +152,11 @@ module ActiveScaffold
           parts = Date._parse(value)
           format = I18n.translate "time.formats.#{column.options[:format] || :picker}", :default => '' if ActiveScaffold.js_framework == :jquery
           if format.blank?
-            time_parts = [[:hour, '%H'], [:min, '%M'], [:sec, '%S']].collect {|part, format_part| format_part if parts[part].present?}.compact
+            time_parts = [[:hour, '%H'], [:min, '%M'], [:sec, '%S']].collect { |part, format_part| format_part if parts[part].present? }.compact
             format = "#{I18n.t('date.formats.default')} #{time_parts.join(':')} #{'%z' if parts[:offset].present?}"
           else
             if parts[:hour]
-              [[:min, '%M'], [:sec, '%S']].each {|part, f| format.gsub!(":#{f}", '') unless parts[part].present?}
+              [[:min, '%M'], [:sec, '%S']].each { |part, f| format.gsub!(":#{f}", '') unless parts[part].present? }
             else
               value += ' 00:00:00'
             end
@@ -198,33 +200,31 @@ module ActiveScaffold
         from_value = condition_value_for_datetime(column, value[:from], conversion)
         to_value = condition_value_for_datetime(column, value[:to], conversion)
 
-        if from_value.nil? and to_value.nil?
+        if from_value.nil? && to_value.nil?
           nil
         elsif !from_value
-          ["%{search_sql} <= ?", to_value.to_s(:db)]
+          ['%{search_sql} <= ?', to_value.to_s(:db)]
         elsif !to_value
-          ["%{search_sql} >= ?", from_value.to_s(:db)]
+          ['%{search_sql} >= ?', from_value.to_s(:db)]
         else
-          ["%{search_sql} BETWEEN ? AND ?", from_value.to_s(:db), to_value.to_s(:db)]
+          ['%{search_sql} BETWEEN ? AND ?', from_value.to_s(:db), to_value.to_s(:db)]
         end
       end
 
       def condition_for_record_select_type(column, value, like_pattern = nil)
         if value.is_a?(Array)
-          ["%{search_sql} IN (?)", value]
+          ['%{search_sql} IN (?)', value]
         else
-          ["%{search_sql} = ?", value]
+          ['%{search_sql} = ?', value]
         end
       end
 
       def condition_for_null_type(column, value, like_pattern = nil)
-        case value.to_sym
-        when :null
-          ["%{search_sql} is null", []]
-        when :not_null
-          ["%{search_sql} is not null", []]
-        else
-          nil
+        case value.to_s
+        when 'null'
+          ['%{search_sql} is null', []]
+        when 'not_null'
+          ['%{search_sql} is not null', []]
         end
       end
 
@@ -238,7 +238,7 @@ module ActiveScaffold
       end
     end
 
-    NumericComparators = [
+    NUMERIC_COMPARATORS = [
       '=',
       '>=',
       '<=',
@@ -247,17 +247,12 @@ module ActiveScaffold
       '!=',
       'BETWEEN'
     ]
-    StringComparators = {
+    STRING_COMPARATORS = {
       :contains    => '%?%',
       :begins_with => '?%',
       :ends_with   => '%?'
     }
-    NullComparators = [
-      'null',
-      'not_null'
-    ]
-
-
+    NULL_COMPARATORS = %w(null not_null)
 
     def self.included(klass)
       klass.extend ClassMethods
@@ -282,7 +277,7 @@ module ActiveScaffold
 
     def active_scaffold_includes
       ActiveSupport::Deprecation.warn "active_scaffold_includes doesn't exist anymore, use active_scaffold_preload, active_scaffold_outer_joins or active_scaffold_references"
-      self.active_scaffold_preload
+      active_scaffold_preload
     end
 
     attr_writer :active_scaffold_habtm_joins
@@ -335,7 +330,7 @@ module ActiveScaffold
       record = klass.find(id)
       security_options = {:crud_type => security_options.to_sym} unless security_options.is_a? Hash
       raise ActiveScaffold::RecordNotAllowed, "#{klass} with id = #{id}" unless record.authorized_for? security_options
-      return record
+      record
     end
     # valid options may include:
     # * :sorting - a Sorting DataStructure (basically an array of hashes of field => direction, e.g. [{:field1 => 'asc'}, {:field2 => 'desc'}]). please note that multi-column sorting has some limitations: if any column in a multi-field sort uses method-based sorting, it will be ignored. method sorting only works for single-column sorting.
@@ -346,13 +341,15 @@ module ActiveScaffold
       full_includes = (active_scaffold_references.blank? ? nil : active_scaffold_references)
 
       # create a general-use options array that's compatible with Rails finders
-      finder_options = { :reorder => options[:sorting].try(:clause),
-                         :conditions => search_conditions,
-                         :joins => joins_for_finder,
-                         :outer_joins => active_scaffold_outer_joins,
-                         :preload => active_scaffold_preload,
-                         :includes => full_includes,
-                         :select => options[:select]}
+      finder_options = {
+        :reorder => options[:sorting].try(:clause),
+        :conditions => search_conditions,
+        :joins => joins_for_finder,
+        :outer_joins => active_scaffold_outer_joins,
+        :preload => active_scaffold_preload,
+        :includes => full_includes,
+        :select => options[:select]
+      }
       if Rails::VERSION::MAJOR >= 4
         if options[:sorting].try(:sorts_by_sql?)
           options[:sorting].each do |col, _|
@@ -368,7 +365,7 @@ module ActiveScaffold
 
     def count_items(query, find_options = {}, count_includes = nil)
       count_includes ||= find_options[:includes] unless find_options[:conditions].blank?
-      options = find_options.reject{|k,v| [:select, :reorder].include? k}
+      options = find_options.reject { |k, _| [:select, :reorder].include? k }
       # NOTE: we must use includes in the count query, because some conditions may reference other tables
       options[:includes] = count_includes
 
@@ -384,7 +381,7 @@ module ActiveScaffold
     # See finder_options for valid options
     def find_page(options = {})
       options.assert_valid_keys :sorting, :per_page, :page, :count_includes, :pagination, :select
-      options[:per_page] ||= 999999999
+      options[:per_page] ||= 999_999_999
       options[:page] ||= 1
 
       find_options = finder_options(options)
@@ -397,7 +394,7 @@ module ActiveScaffold
 
       query = append_to_query(query, find_options)
       # we build the paginator differently for method- and sql-based sorting
-      if options[:sorting] and options[:sorting].sorts_by_method?
+      if options[:sorting] && options[:sorting].sorts_by_method?
         pager = ::Paginator.new(count, options[:per_page]) do |offset, per_page|
           calculate_last_modified(query)
           sorted_collection = sort_collection_by_column(query.to_a, *options[:sorting].first)
@@ -415,9 +412,8 @@ module ActiveScaffold
     end
 
     def calculate_last_modified(query)
-      if conditional_get_support? && query.klass.columns_hash['updated_at']
-        @last_modified = query.maximum(:updated_at)
-      end
+      return unless conditional_get_support? && query.klass.columns_hash['updated_at']
+      @last_modified = query.maximum(:updated_at)
     end
 
     def calculate_query
@@ -428,28 +424,29 @@ module ActiveScaffold
       outer_joins += includes if includes
       primary_key = active_scaffold_config.model.primary_key
       subquery = append_to_query(beginning_of_chain, :conditions => conditions, :joins => joins_for_finder, :outer_joins => outer_joins, :select => active_scaffold_config.columns[primary_key].field)
+      subquery = subquery.unscope(:order) if Rails::VERSION::MAJOR >= 4
       active_scaffold_config.model.where(primary_key => subquery)
     end
 
-    def append_to_query(query, options)
+    def append_to_query(relation, options)
       options.assert_valid_keys :where, :select, :group, :reorder, :limit, :offset, :joins, :outer_joins, :includes, :lock, :readonly, :from, :conditions, :preload, (:references if Rails::VERSION::MAJOR >= 4)
-      query = options.reject{|k,v| v.blank?}.inject(query) do |query, (k, v)|
-        k == :conditions ? apply_conditions(query, *v) : query.send(k, v)
+      relation = options.reject { |_, v| v.blank? }.inject(relation) do |rel, (k, v)|
+        k == :conditions ? apply_conditions(rel, *v) : rel.send(k, v)
       end
       if options[:outer_joins].present?
         if Rails::VERSION::MAJOR >= 4
-          query.distinct_value = true
+          relation.distinct_value = true
         else
-          query = query.uniq
+          relation = relation.uniq
         end
       end
-      query
+      relation
     end
 
     def joins_for_finder
       case joins_for_collection
         when String
-          [ joins_for_collection ]
+          [joins_for_collection]
         when Array
           joins_for_collection
         else
@@ -457,12 +454,12 @@ module ActiveScaffold
       end + active_scaffold_habtm_joins
     end
 
-    def apply_conditions(query, *conditions)
-      conditions.reject(&:blank?).inject(query) do |query, condition|
+    def apply_conditions(relation, *conditions)
+      conditions.reject(&:blank?).inject(relation) do |rel, condition|
         if condition.is_a?(Array) && !condition.first.is_a?(String) # multiple conditions
-          apply_conditions(query, *condition)
+          apply_conditions(rel, *condition)
         else
-          query.where(condition)
+          rel.where(condition)
         end
       end
     end
@@ -470,11 +467,11 @@ module ActiveScaffold
     # TODO: this should reside on the column, not the controller
     def sort_collection_by_column(collection, column, order)
       sorter = column.sort[:method]
-      collection = collection.sort_by { |record|
+      collection = collection.sort_by do |record|
         value = (sorter.is_a? Proc) ? record.instance_eval(&sorter) : record.instance_eval(sorter.to_s)
         value = '' if value.nil?
         value
-      }
+      end
       collection.reverse! if order.downcase == 'desc'
       collection
     end