active_scaffold 3.3.3 → 3.4.0

data/lib/active_scaffold/extensions/localize.rb

@@ -1,7 +1,7 @@
 class Object
   def as_(key, options = {})
     unless key.blank?
-      text = I18n.translate "#{key}", {:scope => [:active_scaffold, *options.delete(:scope)], :default => key.is_a?(String) ? key : key.to_s.titleize}.merge(options)
+      text = I18n.translate("#{key}", {:scope => [:active_scaffold, *options.delete(:scope)], :default => key.is_a?(String) ? key : key.to_s.titleize}.merge(options)).html_safe
       # text = nil if text.include?('translation missing:')
     end
     text ||= key 

data/lib/active_scaffold/extensions/name_option_for_datetime.rb

@@ -1,12 +1,17 @@
-module ActionView
-  module Helpers
-    class InstanceTag
-      private
-      def datetime_selector_with_name(options, html_options)
-        options.merge!(:prefix => options[:name].gsub(/\[[^\[]*\]$/,'')) if options[:name]
-        datetime_selector_without_name(options, html_options)        
+module ActiveScaffold
+  module DateSelectExtension
+    def datetime_selector_with_name(options, html_options)
+      options.merge!(:prefix => options[:name].gsub(/\[[^\[]*\]$/,'')) if options[:name]
+      datetime_selector_without_name(options, html_options)
+    end
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :datetime_selector, :name
+        private :datetime_selector_without_name, :datetime_selector_with_name, :datetime_selector
       end
-      alias_method_chain :datetime_selector, :name
     end
   end
 end
+(defined?(ActionView::Helpers::Tags::DateSelect) ? ActionView::Helpers::Tags::DateSelect : ActionView::Helpers::InstanceTag).class_eval do
+  include ActiveScaffold::DateSelectExtension
+end

data/lib/active_scaffold/extensions/paginator_extensions.rb

@@ -4,7 +4,7 @@ class Paginator
 
   # Total number of pages
   def number_of_pages_with_infinite
-    number_of_pages_without_infinite unless infinite?
+    number_of_pages_without_infinite if @count
   end
   alias_method_chain :number_of_pages, :infinite
   
@@ -12,6 +12,10 @@ class Paginator
   def infinite?
     @count.nil?
   end
+
+  def count
+    @count || first.items.size
+  end
   
   class Page
     # Checks to see if there's a page after this one

data/lib/active_scaffold/extensions/reverse_associations.rb

@@ -28,6 +28,7 @@ module ActiveRecord
 
           # stage 1 filter: collect associations that point back to this model and use the same foreign_key
           klass.reflect_on_all_associations.each do |assoc|
+            next if assoc == self
             if self.options[:through]
               # only iterate has_many :through associations
               next unless assoc.options[:through]

data/lib/active_scaffold/extensions/routing_mapper.rb

@@ -2,7 +2,7 @@ module ActionDispatch
   module Routing
     ACTIVE_SCAFFOLD_CORE_ROUTING = {
         :collection => {:show_search => :get, :render_field => :post, :mark => :post},
-        :member => {:row => :get, :update_column => :post, :render_field => [:get, :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},

data/lib/active_scaffold/extensions/unsaved_record.rb

@@ -1,5 +1,5 @@
 # a simple (manual) unsaved? flag and method. at least it automatically reverts after a save!
-class ActiveRecord::Base
+module ActiveScaffold::UnsavedRecord
   # acts like a dirty? flag, manually thrown during update_record_from_params.
   def unsaved=(val)
     @unsaved = (val) ? true : false
@@ -11,10 +11,8 @@ class ActiveRecord::Base
   end
 
   # automatically unsets the unsaved flag
-  def save_with_unsaved_flag(*args)
-    result = save_without_unsaved_flag(*args)
-    self.unsaved = false
-    return result
+  def save(*)
+    super.tap { self.unsaved = false }
   end
-  alias_method_chain :save, :unsaved_flag
 end
+ActiveRecord::Base.class_eval { include ActiveScaffold::UnsavedRecord }

data/lib/active_scaffold/finder.rb

@@ -76,7 +76,7 @@ module ActiveScaffold
           conditions += values*column.search_sql.size if values.present?
           conditions
         rescue Exception => e
-          logger.error Time.now.to_s + "#{e.inspect} -- on the ActiveScaffold column :#{column.name}, search_ui = #{search_ui} in #{self.name}"
+          logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column :#{column.name}, search_ui = #{search_ui} in #{self.name}"
           raise e
         end
       end
@@ -270,9 +270,19 @@ module ActiveScaffold
       @active_scaffold_conditions ||= []
     end
 
-    attr_writer :active_scaffold_includes
+    attr_writer :active_scaffold_preload
+    def active_scaffold_preload
+      @active_scaffold_preload ||= []
+    end
+
+    def active_scaffold_includes=(value)
+      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 = value
+    end
+
     def active_scaffold_includes
-      @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
     end
 
     attr_writer :active_scaffold_habtm_joins
@@ -284,9 +294,28 @@ module ActiveScaffold
     def active_scaffold_outer_joins
       @active_scaffold_outer_joins ||= []
     end
+    
+    attr_writer :active_scaffold_references
+    def active_scaffold_references
+      @active_scaffold_references ||= []
+    end
+
+    # Override this method on your controller to define conditions to be used when querying a recordset (e.g. for List). The return of this method should be any format compatible with the :conditions clause of ActiveRecord::Base's find.
+    def conditions_for_collection
+    end
+  
+    # Override this method on your controller to define joins to be used when querying a recordset (e.g. for List).  The return of this method should be any format compatible with the :joins clause of ActiveRecord::Base's find.
+    def joins_for_collection
+    end
+  
+    # Override this method on your controller to provide custom finder options to the find() call. The return of this method should be a hash.
+    def custom_finder_options
+      {}
+    end
 
     def all_conditions
       [
+        id_condition,                                 # for list with id (e.g. /users/:id/index)
         active_scaffold_conditions,                   # from the search modules
         conditions_for_collection,                    # from the dev
         conditions_from_params,                       # from the parameters (e.g. /users/list?first_name=Fred)
@@ -294,11 +323,14 @@ module ActiveScaffold
         active_scaffold_session_storage[:conditions] # embedding conditions (weaker constraints)
       ].reject(&:blank?)
     end
+
+    def id_condition
+      {:id => params[:id]} if params[:id]
+    end
     
     # returns a single record (the given id) but only if it's allowed for the specified security options.
     # security options can be a hash for authorized_for? method or a value to check as a :crud_type
     # accomplishes this by checking model.#{action}_authorized?
-    # TODO: this should reside on the model, not the controller
     def find_if_allowed(id, security_options, klass = beginning_of_chain)
       record = klass.find(id)
       security_options = {:crud_type => security_options.to_sym} unless security_options.is_a? Hash
@@ -311,32 +343,40 @@ module ActiveScaffold
     # * :page
     def finder_options(options = {})
       search_conditions = all_conditions
-      full_includes = (active_scaffold_includes.blank? ? nil : active_scaffold_includes)
+      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]}
+      if Rails::VERSION::MAJOR >= 4
+        if options[:sorting].try(:sorts_by_sql?)
+          options[:sorting].each do |col, _|
+            finder_options[:outer_joins] << col.includes if col.includes.present?
+          end
+        end
+        finder_options.merge!(:references => active_scaffold_references)
+      end
     
       finder_options.merge! custom_finder_options
       finder_options
     end
 
-    def count_items(find_options = {}, count_includes = nil)
+    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}
+      # NOTE: we must use includes in the count query, because some conditions may reference other tables
       options[:includes] = count_includes
       
-      # NOTE: we must use :include in the count query, because some conditions may reference other tables
-      count_query = append_to_query(beginning_of_chain, options)
-      count = count_query.count(:distinct => true)
+      count = append_to_query(query, options).count
   
       # Converts count to an integer if ActiveRecord returned an OrderedHash
       # that happens when find_options contains a :group key
-      count = count.length if count.is_a? ActiveSupport::OrderedHash
+      count = count.length if count.is_a?(Hash) || count.is_a?(ActiveSupport::OrderedHash) # TODO remove OrderedHash check when ruby 1.8 or rails3 support is removed
       count
     end
 
@@ -348,50 +388,62 @@ module ActiveScaffold
       options[:page] ||= 1
 
       find_options = finder_options(options)
+      query = beginning_of_chain.where(nil) # where(nil) is needed because we need a relation
       
       # NOTE: we must use :include in the count query, because some conditions may reference other tables
       if options[:pagination] && options[:pagination] != :infinite
-        count = count_items(find_options, options[:count_includes])
+        count = count_items(query, find_options, options[:count_includes])
       end
 
-      klass = beginning_of_chain
-      klass = klass.where(nil).uniq if find_options[:outer_joins].present? # HACK: call where(nil) because calling uniq on associations (nested scaffolds) send SQL to DB
+      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?
         pager = ::Paginator.new(count, options[:per_page]) do |offset, per_page|
-          sorted_collection = sort_collection_by_column(append_to_query(klass, find_options).all, *options[:sorting].first)
+          calculate_last_modified(query)
+          sorted_collection = sort_collection_by_column(query.to_a, *options[:sorting].first)
           sorted_collection = sorted_collection.slice(offset, per_page) if options[:pagination]
           sorted_collection
         end
       else
         pager = ::Paginator.new(count, options[:per_page]) do |offset, per_page|
-          find_options.merge!(:offset => offset, :limit => per_page) if options[:pagination]
-          append_to_query(klass, find_options)
+          query = append_to_query(query, :offset => offset, :limit => per_page) if options[:pagination]
+          calculate_last_modified(query)
+          query
         end
       end
       pager.page(options[:page])
     end
 
+    def calculate_last_modified(query)
+      if conditional_get_support? && query.klass.columns_hash['updated_at']
+        @last_modified = query.maximum(:updated_at)
+      end
+    end
+
     def calculate_query
       conditions = all_conditions
       includes = active_scaffold_config.list.count_includes
-      includes ||= active_scaffold_includes unless conditions.blank?
+      includes ||= active_scaffold_references unless conditions.blank?
+      outer_joins = active_scaffold_outer_joins
+      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 => active_scaffold_outer_joins)
-      subquery = subquery.select(active_scaffold_config.columns[primary_key].field)
-      if includes
-        includes_relation = beginning_of_chain.includes(includes)
-        subquery = subquery.send(:apply_join_dependency, subquery, includes_relation.send(:construct_join_dependency_for_association_find))
-      end
+      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)
       active_scaffold_config.model.where(primary_key => subquery)
     end
     
     def append_to_query(query, options)
-      options.assert_valid_keys :where, :select, :group, :reorder, :limit, :offset, :joins, :outer_joins, :includes, :lock, :readonly, :from, :conditions
-      query = apply_conditions(query, *options[:conditions]) if options[:conditions]
-      options.reject{|k, v| k == :conditions || v.blank?}.inject(query) do |query, (k, v)|
-        query.send((k.to_sym), v) 
+      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)
+      end
+      if options[:outer_joins].present?
+        if Rails::VERSION::MAJOR >= 4
+          query.distinct_value = true 
+        else
+          query = query.uniq
+        end
       end
+      query
     end
 
     def joins_for_finder

data/lib/active_scaffold/helpers/association_helpers.rb

@@ -1,7 +1,7 @@
 module ActiveScaffold
   module Helpers
     module AssociationHelpers
-      # Cache the optins for select
+      # Cache the options for select
       def cache_association_options(association, conditions, klass, cache = true)
         if active_scaffold_config.cache_association_options && cache
           @_associations_cache ||= Hash.new { |h,k| h[k] = {} }
@@ -13,9 +13,11 @@ module ActiveScaffold
       end
 
       # Provides a way to honor the :conditions on an association while searching the association's klass
-      def association_options_find(association, conditions = nil, klass = nil)
+      def association_options_find(association, conditions = nil, klass = nil, record = nil)
+        ActiveSupport::Deprecation.warn "Relying on @record is deprecated, call with record.", caller if record.nil? # TODO Remove when relying on @record is removed
+        record ||= @record # TODO Remove when relying on @record is removed
         if klass.nil? && association.options[:polymorphic]
-          class_name = @record.send(association.foreign_type)
+          class_name = record.send(association.foreign_type)
           if class_name.present?
             klass = class_name.constantize
           else
@@ -27,45 +29,73 @@ module ActiveScaffold
           klass ||= association.klass
         end
 
-        conditions = options_for_association_conditions(association) if conditions.nil?
+        if conditions.nil?
+          if method(:options_for_association_conditions).arity.abs == 2
+            conditions = options_for_association_conditions(association, record)
+          else
+            ActiveSupport::Deprecation.warn "Relying on @record is deprecated, include record in your options_for_association_conditions overrided method.", caller if record.nil? # TODO Remove when relying on @record is removed
+            conditions = options_for_association_conditions(association)
+          end
+        end
         cache_association_options(association, conditions, klass, cache) do
+          klass = association_klass_scoped(association, klass, record)
           relation = klass.where(conditions).where(association.options[:conditions])
           relation = relation.includes(association.options[:include]) if association.options[:include]
+          column = column_for_association(association, record)
+          if column && column.try(:sort) && column.sort[:sql]
+            if column.includes
+              include_assoc = column.includes.find { |assoc| assoc.is_a?(Hash) && assoc.include?(association.name) }
+              relation = relation.includes(include_assoc[association.name]) if include_assoc
+            end
+            relation = relation.order(column.sort[:sql])
+          end
           relation = yield(relation) if block_given?
           relation.to_a
         end
       end
 
+      def column_for_association(association, record)
+        active_scaffold_config_for(record.class).columns[association.name] rescue nil
+      end
+
+      def association_klass_scoped(association, klass, record)
+        klass
+      end
+
       # Sorts the options for select
-      def sorted_association_options_find(association, conditions = nil)
-        association_options_find(association, conditions).sort_by(&:to_label)
+      def sorted_association_options_find(association, conditions = nil, record = nil)
+        options = association_options_find(association, conditions, nil, record)
+        column = column_for_association(association, record)
+        unless column && column.try(:sort) && column.sort[:sql]
+          method = column.options[:label_method] if column
+          options = options.sort_by(&(method || :to_label).to_sym)
+        end
+        options
       end
 
       def association_options_count(association, conditions = nil)
         association.klass.where(conditions).where(association.options[:conditions]).count
       end
 
-      # returns options for the given association as a collection of [id, label] pairs intended for the +options_for_select+ helper.
-      def options_for_association(association, include_all = false)
-        ActiveSupport::Deprecation.warn "options_for_association should not be used, use association_options_find directly"
-        available_records = association_options_find(association, include_all ? nil : options_for_association_conditions(association))
-        available_records ||= []
-        available_records.sort{|a,b| a.to_label <=> b.to_label}.collect { |model| [ model.to_label, model.id ] }
-      end
-
-      def options_for_association_count(association)
-        association_options_count(association, options_for_association_conditions(association))
+      def options_for_association_count(association, record)
+        if method(:options_for_association_conditions).arity.abs == 2
+          conditions = options_for_association_conditions(association, record)
+        else
+          ActiveSupport::Deprecation.warn "Relying on @record is deprecated, include record in your options_for_association_conditions overrided method.", caller if record.nil? # TODO Remove when relying on @record is removed
+          conditions = options_for_association_conditions(association)
+        end
+        association_options_count(association, conditions)
       end
 
       # A useful override for customizing the records present in an association dropdown.
       # Should work in both the subform and form_ui=>:select modes.
       # Check association.name to specialize the conditions per-column.
-      def options_for_association_conditions(association)
+      def options_for_association_conditions(association, record = nil)
         return nil if association.options[:through]
         case association.macro
           when :has_one, :has_many
             # Find only orphaned objects
-            "#{association.foreign_key} IS NULL"
+            {association.foreign_key => nil}
           when :belongs_to, :has_and_belongs_to_many
             # Find all
             nil

data/lib/active_scaffold/helpers/controller_helpers.rb

@@ -22,7 +22,7 @@ module ActiveScaffold
         # :sort, :sort_direction, and :page are arguments that stored in the session. they need not propagate.
         # and wow. no we don't want to propagate :record.
         # :commit is a special rails variable for form buttons
-        blacklist = [:adapter, :position, :sort, :sort_direction, :page, :record, :commit, :_method, :authenticity_token, :iframe, :associated_id, :dont_close]
+        blacklist = [:adapter, :position, :sort, :sort_direction, :page, :auto_pagination, :record, :commit, :_method, :authenticity_token, :iframe, :associated_id, :dont_close]
         unless @params_for
           @params_for = {}
           params.except(*blacklist).each {|key, value| @params_for[key.to_sym] = value.duplicable? ? value.clone : value}
@@ -65,10 +65,10 @@ module ActiveScaffold
 
       def render_parent_options
         if nested_singular_association?
-          {:controller => nested.parent_scaffold.controller_path, :action => :row, :id => nested.parent_id}
+          {:controller => nested.parent_scaffold.controller_path, :action => :index, :id => nested.parent_id}
         elsif params[:parent_sti]
           options = params_for(:controller => params[:parent_sti], :action => render_parent_action, :parent_sti => nil)
-          options.merge(:id => @record.id) if render_parent_action == :row
+          options.merge(:action => :index, :id => @record.to_param) if render_parent_action == :row
         end
       end
 
@@ -86,15 +86,24 @@ module ActiveScaffold
         @parent_action
       end
       
-      def build_associated(column, record)
-        if column.singular_association?
-          if column.association.options[:through]
-            record.send(:"build_#{column.association.through_reflection.name}").send(:"build_#{column.name}")
-          else
-            record.send(:"build_#{column.name}")
+      # build an associated record for association 
+      def build_associated(association, parent_record)
+        if association.options[:through]
+          # build full chain, only check create_associated on initial parent_record
+          parent_record = build_associated(association.through_reflection, parent_record)
+          build_associated(association.source_reflection, parent_record).tap do |record|
+            save_record_to_association(record, association.source_reflection.reverse, parent_record) # set inverse
           end
+        elsif association.collection?
+          parent_record.send(association.name).build
+        elsif association.belongs_to? || parent_record.new_record? || parent_record.send(association.name).nil?
+          # avoid use build_association in has_one when record is saved and had associated record
+          # because associated record would be changed in DB
+          parent_record.send("build_#{association.name}")
         else
-          record.send(column.name).build
+          association.klass.new.tap do |record|
+            save_record_to_association(record, association.reverse, parent_record) # set inverse
+          end
         end
       end
     end