active_scaffold 3.0.26 → 3.1.3

data/lib/active_scaffold/extensions/action_view_rendering.rb

@@ -1,111 +1,108 @@
 module ActionView
   class LookupContext
     module ViewPaths
-      def find_all_templates(name, prefix = nil, partial = false)
-        templates = []
-        @view_paths.each do |resolver|
-          template = resolver.find_all(*args_for_lookup(name, prefix, partial)).first
-          templates << template unless template.nil?
-        end
-        templates
+      def find_all_templates(name, partial = false, locals = {})
+        prefixes.collect do |prefix|
+          view_paths.collect do |resolver|
+            temp_args = *args_for_lookup(name, [prefix], partial, locals)
+            temp_args[1] = temp_args[1][0]
+            resolver.find_all(*temp_args)
+          end
+        end.flatten!
       end
     end
   end
 end
 
 # wrap the action rendering for ActiveScaffold views
-module ActionView::Rendering #:nodoc:
-  # Adds two rendering options.
-  #
-  # ==render :super
-  #
-  # This syntax skips all template overrides and goes directly to the provided ActiveScaffold templates.
-  # Useful if you want to wrap an existing template. Just call super!
-  #
-  # ==render :active_scaffold => #{controller.to_s}, options = {}+
-  #
-  # Lets you embed an ActiveScaffold by referencing the controller where it's configured.
-  #
-  # You may specify options[:constraints] for the embedded scaffold. These constraints have three effects:
-  #   * the scaffold's only displays records matching the constraint
-  #   * all new records created will be assigned the constrained values
-  #   * constrained columns will be hidden (they're pretty boring at this point)
-  #
-  # You may also specify options[:conditions] for the embedded scaffold. These only do 1/3 of what
-  # constraints do (they only limit search results). Any format accepted by ActiveRecord::Base.find is valid.
-  #
-  # Defining options[:label] lets you completely customize the list title for the embedded scaffold.
-  #
-  def render_with_active_scaffold(*args, &block)
-    if args.first == :super
-      last_view = @view_stack.last
-      options = args[1] || {}
-      options[:locals] ||= {}
-      options[:locals].reverse_merge!(last_view[:locals] || {})
-      if last_view[:templates].nil?
-        last_view[:templates] = lookup_context.find_all_templates(last_view[:view], controller_path, !last_view[:is_template])
-        last_view[:templates].shift
-      end
-      options[:template] = last_view[:templates].shift
-      @view_stack << last_view
-      result = render_without_active_scaffold options
-      @view_stack.pop
-      result
-    elsif args.first.is_a?(Hash) and args.first[:active_scaffold]
-      require 'digest/md5'
-      options = args.first
+module ActionView::Helpers #:nodoc:
+  module RenderingHelper
+    #
+    # Adds two rendering options.
+    #
+    # ==render :super
+    #
+    # This syntax skips all template overrides and goes directly to the provided ActiveScaffold templates.
+    # Useful if you want to wrap an existing template. Just call super!
+    #
+    # ==render :active_scaffold => #{controller.to_s}, options = {}+
+    #
+    # Lets you embed an ActiveScaffold by referencing the controller where it's configured.
+    #
+    # You may specify options[:constraints] for the embedded scaffold. These constraints have three effects:
+    #   * the scaffold's only displays records matching the constraint
+    #   * all new records created will be assigned the constrained values
+    #   * constrained columns will be hidden (they're pretty boring at this point)
+    #
+    # You may also specify options[:conditions] for the embedded scaffold. These only do 1/3 of what
+    # constraints do (they only limit search results). Any format accepted by ActiveRecord::Base.find is valid.
+    #
+    # Defining options[:label] lets you completely customize the list title for the embedded scaffold.
+    #
+    def render_with_active_scaffold(*args, &block)
+      if args.first == :super
+        last_view = view_stack.last || {:view => instance_variable_get(:@virtual_path).split('/').last}
+        options = args[1] || {}
+        options[:locals] ||= {}
+        options[:locals].reverse_merge!(last_view[:locals] || {})
+        if last_view[:templates].nil?
+          last_view[:templates] = lookup_context.find_all_templates(last_view[:view], last_view[:partial], options[:locals].keys)
+          last_view[:templates].shift
+        end
+        options[:template] = last_view[:templates].shift
+        view_stack << last_view
+        result = render_without_active_scaffold options
+        view_stack.pop
+        result
+      elsif args.first.is_a? Hash and args.first[:active_scaffold]
+        require 'digest/md5'
+        options = args.first
 
-      remote_controller = options[:active_scaffold]
-      constraints = options[:constraints]
-      conditions = options[:conditions]
-      eid = Digest::MD5.hexdigest(params[:controller] + remote_controller.to_s + constraints.to_s + conditions.to_s)
-      session["as:#{eid}"] = {:constraints => constraints, :conditions => conditions, :list => {:label => args.first[:label]}}
-      options[:params] ||= {}
-      options[:params].merge! :eid => eid, :embedded => true
-      
-      id = "as_#{eid}-content"
-      url_options = {:controller => remote_controller.to_s, :action => 'index'}.merge(options[:params])
-      
-      if controller.respond_to?(:render_component_into_view)
-        controller.send(:render_component_into_view, url_options)
-      else
-        content_tag(:div, :id => id, :class => 'active-scaffold-component') do
-          url = url_for(url_options)
-          content_tag(:div, :class => 'active-scaffold-header') do
-            content_tag :h2, link_to(active_scaffold_config_for(remote_controller).list.label, url, :remote => true, :id => id)
-          end <<
-          if ActiveScaffold.js_framework == :prototype
-            javascript_tag("new Ajax.Updater('#{id}', '#{url}', {method: 'get', evalScripts: true});")
-          elsif ActiveScaffold.js_framework == :jquery
-            javascript_tag("$('##{id}').load('#{url}');")
+        remote_controller = options[:active_scaffold]
+        constraints = options[:constraints]
+        conditions = options[:conditions]
+        eid = Digest::MD5.hexdigest(params[:controller] + remote_controller.to_s + constraints.to_s + conditions.to_s)
+        session["as:#{eid}"] = {:constraints => constraints, :conditions => conditions, :list => {:label => args.first[:label]}}
+        options[:params] ||= {}
+        options[:params].merge! :eid => eid, :embedded => true
+
+        id = "as_#{eid}-embedded"
+        url_options = {:controller => remote_controller.to_s, :action => 'index'}.merge(options[:params])
+
+        if controller.respond_to?(:render_component_into_view)
+          controller.send(:render_component_into_view, url_options)
+        else
+          content_tag(:div, :id => id, :class => 'active-scaffold-component') do
+            url = url_for(url_options)
+            content_tag(:div, :class => 'active-scaffold-header') do
+              content_tag :h2, link_to(args.first[:label] || active_scaffold_config_for(remote_controller.to_s.singularize).list.label, url, :remote => true)
+            end <<
+            if ActiveScaffold.js_framework == :prototype
+              javascript_tag("new Ajax.Updater('#{id}', '#{url}', {method: 'get', evalScripts: true});")
+            elsif ActiveScaffold.js_framework == :jquery
+              javascript_tag("$('##{id}').load('#{url}');")
+            end
           end
         end
-      end
-      
-    else
-      options = args.first
-      if options.is_a?(Hash)
-        current_view = {:view => options[:partial], :is_template => false} if options[:partial]
-        current_view = {:view => options[:template], :is_template => !!options[:template]} if current_view.nil? && options[:template]
-        current_view[:locals] = options[:locals] if !current_view.nil? && options[:locals]
-        if current_view.present?
-          @view_stack ||= []
-          @view_stack << current_view
+
+      else
+        options = args.first
+        if options.is_a?(Hash)
+          current_view = {:view => options[:partial], :partial => true} if options[:partial]
+          current_view = {:view => options[:template], :partial => false} if current_view.nil? && options[:template]
+          current_view[:locals] = options[:locals] if !current_view.nil? && options[:locals]
+          view_stack << current_view if current_view.present?
         end
+        result = render_without_active_scaffold(*args, &block)
+        view_stack.pop if current_view.present?
+        result
       end
-      result = render_without_active_scaffold(*args, &block)
-      @view_stack.pop if current_view.present?
-      result
     end
-  end
-  alias_method_chain :render, :active_scaffold
-  
-
-  def partial_pieces(partial_path)
-    if partial_path.include?('/')
-      return File.dirname(partial_path), File.basename(partial_path)
-    else
-      return controller.class.controller_path, partial_path
+    alias_method_chain :render, :active_scaffold
+    
+    def view_stack
+      @_view_stack ||= []
     end
+
   end
 end

data/lib/active_scaffold/extensions/action_view_rendering.rb~

@@ -1,6 +1,5 @@
 module ActionView
   class LookupContext
-    attr_accessor :uses_active_scaffold
     module ViewPaths
       def find_all_templates(name, partial = false, locals = {})
         prefixes.collect do |prefix|
@@ -12,17 +11,6 @@ module ActionView
         end.flatten!
       end
     end
-    
-    # Overload formats= to expand ["*/*"] values and automatically
-    # add :html as fallback to :js.
-    def formats=(values)
-      debugger
-      if values == [:js] && uses_active_scaffold
-        _set_detail(:formats, values) if values != @details[:formats]
-      else
-        super(values)
-      end
-    end
   end
 end
 
@@ -61,7 +49,7 @@ module ActionView::Helpers #:nodoc:
           last_view[:templates] = lookup_context.find_all_templates(last_view[:view], last_view[:partial], options[:locals].keys)
           last_view[:templates].shift
         end
-        options[:template] = last_view[:templates].shift
+        options[:file] = last_view[:templates].shift
         view_stack << last_view
         result = render_without_active_scaffold options
         view_stack.pop

data/lib/active_scaffold/extensions/active_association_reflection.rb

@@ -1,13 +1,22 @@
 # Bugfix: building an sti model from an association fails
 # https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/6306-collection-associations-build-method-not-supported-for-sti
+# https://github.com/rails/rails/issues/815
+# https://github.com/rails/rails/pull/1686
 ActiveRecord::Reflection::AssociationReflection.class_eval do
-  def build_association(*opts)
-    col = klass.inheritance_column.to_sym
-    if !col.nil? && opts.first.is_a?(Hash) && (opts.first.symbolize_keys[col])
-      sti_model = opts.first.delete(col)
-      sti_model.to_s.camelize.constantize.new(*opts)
+  def klass_with_sti(*opts)
+    sti_col = klass.inheritance_column
+    if (h = opts.first).is_a? Hash and (passed_type = ( h[sti_col] || h[sti_col.to_sym] )) and (new_klass = active_record.send(:compute_type, passed_type)) < klass
+      new_klass
     else
-      klass.new(*opts)
+      klass
     end
   end
-end
+  def build_association(*opts, &block)
+    self.original_build_association_called = true
+    klass_with_sti(*opts).new(*opts, &block)
+  end
+  def create_association(*opts, &block)
+    self.original_build_association_called = true
+    klass_with_sti(*opts).create(*opts, &block)
+  end
+end

data/lib/active_scaffold/extensions/cache_association.rb

@@ -0,0 +1,16 @@
+module ActiveRecord
+  class Relation
+    def target=(records)
+      @loaded = true
+      @records = records
+      @records
+    end
+  end
+end
+module ActiveRecord
+  module Associations
+    class CollectionProxy
+      delegate :target=, :to => :@association
+    end
+  end
+end

data/lib/active_scaffold/extensions/reverse_associations.rb

@@ -1,26 +1,28 @@
 module ActiveRecord
   module Reflection
     class AssociationReflection #:nodoc:
-      def reverse_for?(klass)
-        reverse_matches_for(klass).empty? ? false : true
+      def inverse_for?(klass)
+        inverse_class = inverse_of.try(:active_record)
+        inverse_class.present? && (inverse_class == klass || klass < inverse_class)
       end
 
       attr_writer :reverse
       def reverse
-        if @reverse.nil? and not self.options[:polymorphic]
-          reverse_matches = reverse_matches_for(self.class_name.constantize) rescue nil
-          # grab first association, or make a wild guess
-          @reverse = reverse_matches.blank? ? false : reverse_matches.first.name
-        end
-        @reverse
+        @reverse ||= inverse_of.try(:name)
       end
 
+      def inverse_of_with_autodetect
+        inverse_of_without_autodetect || autodetect_inverse
+      end
+      alias_method_chain :inverse_of, :autodetect
+      
       protected
 
-        def reverse_matches_for(klass)
+        def autodetect_inverse
+          return nil if options[:polymorphic]
           reverse_matches = []
 
-          # stage 1 filter: collect associations that point back to this model and use the same primary_key_name
+          # 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|
             if self.options[:through]
               # only iterate has_many :through associations
@@ -40,9 +42,9 @@ module ActiveRecord
                 when 1
                 next
 
-                # otherwise, match them based on the primary_key_name
+                # otherwise, match them based on the foreign_key
                 when 0
-                next unless assoc.primary_key_name.to_sym == self.primary_key_name.to_sym
+                next unless assoc.foreign_key.to_sym == self.foreign_key.to_sym
               end
             end
 
@@ -54,7 +56,7 @@ module ActiveRecord
             self.active_record.to_s.underscore.include? assoc.name.to_s.pluralize.singularize
           end if reverse_matches.length > 1
 
-          reverse_matches
+          reverse_matches.first
         end
 
     end

data/lib/active_scaffold/extensions/unsaved_associated.rb

@@ -48,7 +48,7 @@ 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 |association|
-      association_proxy = instance_variable_get("@#{association.name}")
+      association_proxy = send(association.name)
       if association_proxy
         records = association_proxy
         records = [records] unless records.is_a? Array # convert singular associations into collections for ease of use

data/lib/active_scaffold/finder.rb

@@ -34,12 +34,13 @@ module ActiveScaffold
       # TODO: this should reside on the column, not the controller
       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)
+        end
         return unless column and column.search_sql and not value.blank?
-        search_ui = column.search_ui || column.column.type
+        search_ui = column.search_ui || column.column.try(:type)
         begin
-          if self.respond_to?("condition_for_#{column.name}_column")
-            self.send("condition_for_#{column.name}_column", column, value, like_pattern)
-          elsif self.respond_to?("condition_for_#{search_ui}_type")
+          if search_ui && self.respond_to?("condition_for_#{search_ui}_type")
             self.send("condition_for_#{search_ui}_type", column, value, like_pattern)
           else
             unless column.search_sql.instance_of? Proc
@@ -95,7 +96,7 @@ module ActiveScaffold
         elsif value[:from].blank?
           nil
         elsif ActiveScaffold::Finder::StringComparators.values.include?(value[:opt])
-          ["#{column.search_sql} #{ActiveScaffold::Finder.like_operator} ?", value[:opt].sub('?', value[:from])]
+          ["#{column.search_sql} LIKE ?", value[:opt].sub('?', value[:from])]
         elsif value[:opt] == 'BETWEEN'
           ["#{column.search_sql} BETWEEN ? AND ?", value[:from], value[:to]]
         elsif ActiveScaffold::Finder::NumericComparators.include?(value[:opt])
@@ -245,51 +246,67 @@ module ActiveScaffold
       return record
     end
 
-    # returns a Paginator::Page (not from ActiveRecord::Paginator) for the given parameters
-    # options may include:
+    # returns a hash with options to find records
+    # 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.
     # * :per_page
     # * :page
-    # TODO: this should reside on the model, not the controller
-    def find_page(options = {})
-      options.assert_valid_keys :sorting, :per_page, :page, :count_includes, :pagination
+    def finder_options(options = {})
+      options.assert_valid_keys :sorting, :per_page, :page, :count_includes, :pagination, :select
 
       search_conditions = all_conditions
       full_includes = (active_scaffold_includes.blank? ? nil : active_scaffold_includes)
-      options[:per_page] ||= 999999999
-      options[:page] ||= 1
-      options[:count_includes] ||= full_includes unless search_conditions.nil?
 
-      klass = beginning_of_chain
-      
       # create a general-use options array that's compatible with Rails finders
       finder_options = { :order => options[:sorting].try(:clause),
                          :where => search_conditions,
                          :joins => joins_for_finder,
-                         :includes => options[:count_includes]}
+                         :includes => full_includes}
                          
       finder_options.merge! custom_finder_options
+      finder_options
+    end
+
+    # Returns a hash with options to count records, rejecting select and order options
+    # See finder_options for valid options
+    def count_options(find_options = {}, count_includes = nil)
+      count_includes ||= find_options[:includes] unless find_options[:where].nil?
+      options = find_options.reject{|k,v| [:select, :order].include? k}
+      options[:includes] = count_includes
+      options
+    end
+
+    # returns a Paginator::Page (not from ActiveRecord::Paginator) for the given parameters
+    # See finder_options for valid options
+    # TODO: this should reside on the model, not the controller
+    def find_page(options = {})
+      options[:per_page] ||= 999999999
+      options[:page] ||= 1
 
+      find_options = finder_options(options)
+      klass = beginning_of_chain
+      
       # NOTE: we must use :include in the count query, because some conditions may reference other tables
-      count_query = append_to_query(klass, finder_options.reject{|k, v| [:select, :order].include?(k)})
-      count = count_query.count unless options[:pagination] == :infinite
+      if options[:pagination] && options[:pagination] != :infinite
+        count_query = append_to_query(klass, count_options(find_options, options[:count_includes]))
+        count = count_query.count unless options[:pagination] == :infinite
+      end
   
       # Converts count to an integer if ActiveRecord returned an OrderedHash
-      # that happens when finder_options contains a :group key
+      # that happens when find_options contains a :group key
       count = count.length if count.is_a? ActiveSupport::OrderedHash
-      finder_options.merge! :includes => full_includes
 
       # 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, finder_options).all, *options[:sorting].first)
+          sorted_collection = sort_collection_by_column(append_to_query(klass, find_options).all, *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|
-          finder_options.merge!(:offset => offset, :limit => per_page) if options[:pagination]
-          append_to_query(klass, finder_options).all
+          find_options.merge!(:offset => offset, :limit => per_page) if options[:pagination]
+          append_to_query(klass, find_options).all
         end
       end
       pager.page(options[:page])