active_scaffold 3.2.20 → 3.3.0.rc

data/lib/active_scaffold/data_structures/column.rb

@@ -13,6 +13,8 @@ module ActiveScaffold::DataStructures
       self.clear_link if value
       @inplace_edit = value
     end
+    
+    attr_accessor :inplace_edit_update
 
     # Whether this column set is collapsed by default in contexts where collapsing is supported
     attr_accessor :collapsed
@@ -43,6 +45,12 @@ module ActiveScaffold::DataStructures
       end
     end
 
+    # A placeholder text, to be used inside blank text fields to describe, what should be typed in
+    attr_writer :placeholder
+    def placeholder
+      @placeholder || I18n.t(name, :scope => [:activerecord, :placeholder, active_record_class.to_s.underscore.to_sym], :default => '')
+    end
+
     # this will be /joined/ to the :name for the td's class attribute. useful if you want to style columns on different ActiveScaffolds the same way, but the columns have different names.
     attr_accessor :css_class
 
@@ -66,16 +74,6 @@ module ActiveScaffold::DataStructures
     cattr_accessor :send_form_on_update_column
     attr_accessor :send_form_on_update_column
 
-    # column to be updated in a form when this column changes
-    def update_column=(column_name)
-      ActiveSupport::Deprecation.warn "Use update_columns= instead of update_column="
-      self.update_columns = column_name
-    end
-
-    # send all the form instead of only new value when this column change
-    cattr_accessor :send_form_on_update_column
-    attr_accessor :send_form_on_update_column
-
     # sorting on a column can be configured four ways:
     #   sort = true               default, uses intelligent sorting sql default
     #   sort = false              sometimes sorting doesn't make sense
@@ -174,11 +172,7 @@ module ActiveScaffold::DataStructures
     end
 
     # a collection of columns to load when eager loading is disabled, if it's nil all columns will be loaded
-    attr_accessor :select_associated_columns
-    def select_columns=(value)
-      ActiveSupport::Deprecation.warn "Use select_associated_columns= instead of select_columns="
-      self.select_associated_columns = value
-    end
+    attr_accessor :select_columns
 
     # describes how to search on a column
     #   search = true           default, uses intelligent search sql
@@ -304,6 +298,7 @@ module ActiveScaffold::DataStructures
       @options = {:format => :i18n_number} if self.number?
       @form_ui = :checkbox if @column and @column.type == :boolean
       @form_ui = :textarea if @column and @column.type == :text
+      @form_ui = :number   if @column and self.number?
       @allow_add_existing = true
       @form_ui = self.class.association_form_ui if @association && self.class.association_form_ui
       
@@ -319,7 +314,6 @@ module ActiveScaffold::DataStructures
       
       @weight = estimate_weight
 
-      self.clear_link if self.polymorphic_association?
       self.includes = (association and not polymorphic_association?) ? [association.name] : []
     end
 
@@ -354,6 +348,17 @@ module ActiveScaffold::DataStructures
       end
     end
 
+    # to cache method to get value in list
+    attr_accessor :list_method
+
+    # cache constraints for numeric columns (get in ActiveScaffold::Helpers::FormColumnHelpers::numerical_constraints_for_column)
+    attr_accessor :numerical_constraints
+
+    # the table.field name for this column, if applicable
+    def field
+      @field ||= [@active_record_class.quoted_table_name, field_name].join('.')
+    end
+
     protected
 
     def initialize_sort
@@ -381,11 +386,6 @@ module ActiveScaffold::DataStructures
 
     # the table name from the ActiveRecord class
     attr_reader :table
-
-    # the table.field name for this column, if applicable
-    def field
-      @field ||= [@active_record_class.quoted_table_name, field_name].join('.')
-    end
     
     def estimate_weight
       if singular_association?

data/lib/active_scaffold/data_structures/nested_info.rb

@@ -3,32 +3,21 @@ module ActiveScaffold::DataStructures
     def self.get(model, params)
       nested_info = {}
       begin
-        nested_info[:name] = (params[:association] || params[:named_scope]).to_sym
-        nested_info[:parent_scaffold] = "#{params[:parent_scaffold].to_s.camelize}Controller".constantize
-        nested_info[:parent_model] = nested_info[:parent_scaffold].active_scaffold_config.model
-        nested_info[:parent_id] = if params[:association].nil?
-          params[nested_info[:parent_model].name.foreign_key]
+        unless params[:association].nil?
+          ActiveScaffold::DataStructures::NestedInfoAssociation.new(model, params)
         else
-          params[nested_info[:parent_model].reflect_on_association(params[:association].to_sym).active_record.name.foreign_key]
-        end
-        if nested_info[:parent_id]
-          unless params[:association].nil?
-            ActiveScaffold::DataStructures::NestedInfoAssociation.new(model, nested_info)
-          else
-            ActiveScaffold::DataStructures::NestedInfoScope.new(model, nested_info)
-          end
+          ActiveScaffold::DataStructures::NestedInfoScope.new(model, params)
         end
       rescue ActiveScaffold::ControllerNotFound
         nil
       end
     end
     
-    attr_accessor :association, :child_association, :parent_model, :parent_scaffold, :parent_id, :constrained_fields, :scope
+    attr_accessor :association, :child_association, :parent_model, :parent_scaffold, :parent_id, :param_name, :constrained_fields, :scope
         
-    def initialize(model, nested_info)
-      @parent_model = nested_info[:parent_model]
-      @parent_id = nested_info[:parent_id]
-      @parent_scaffold = nested_info[:parent_scaffold]
+    def initialize(model, params)
+      @parent_scaffold = "#{params[:parent_scaffold].to_s.camelize}Controller".constantize
+      @parent_model = @parent_scaffold.active_scaffold_config.model
     end
     
     def to_params
@@ -41,10 +30,6 @@ module ActiveScaffold::DataStructures
       result
     end
     
-    def parent_scope
-      @parent_scope ||= parent_model.find(parent_id)
-    end
-    
     def habtm?
       false 
     end
@@ -69,6 +54,10 @@ module ActiveScaffold::DataStructures
       has_many? || habtm?
     end
 
+    def readonly_through_association?
+      false
+    end
+
     def through_association?
       false
     end
@@ -83,9 +72,11 @@ module ActiveScaffold::DataStructures
   end
   
   class NestedInfoAssociation < NestedInfo
-    def initialize(model, nested_info)
-      super(model, nested_info)
-      @association = parent_model.reflect_on_association(nested_info[:name])
+    def initialize(model, params)
+      super
+      @association = parent_model.reflect_on_association(params[:association].to_sym)
+      @param_name = @association.active_record.name.foreign_key.to_sym
+      @parent_id = params[@param_name]
       iterate_model_associations(model)
     end
     
@@ -109,6 +100,12 @@ module ActiveScaffold::DataStructures
       association.macro == :has_one
     end
     
+    # A through association with has_one or has_many as source association
+    # create cannot be called in such through association
+    def readonly_through_association?
+      association.options[:through] && association.source_reflection.macro != :belongs_to
+    end
+    
     def through_association?
       association.options[:through]
     end
@@ -132,31 +129,21 @@ module ActiveScaffold::DataStructures
     protected
     
     def iterate_model_associations(model)
-      @constrained_fields = Set.new
+      @constrained_fields = []
       constrained_fields << association.foreign_key.to_sym unless association.belongs_to?
-      model.reflect_on_all_associations.each do |current|
-        if !current.belongs_to? && association != current && association.foreign_key.to_s == current.association_foreign_key.to_s
-          constrained_fields << current.name.to_sym
-          @child_association = current if current.klass == @parent_model
-        end
-        if association.foreign_key.to_s == current.foreign_key.to_s
-          # show columns for has_many and has_one child associationes
-          constrained_fields << current.name.to_sym if current.belongs_to?
-          if association.options[:as] and current.options[:polymorphic]
-            @child_association = current if association.options[:as].to_sym == current.name
-          else
-            @child_association = current if current.klass == @parent_model
-          end
-        end
+      if reverse = association.reverse(model)
+        @child_association = model.reflect_on_association(reverse)
+        constrained_fields << @child_association.name unless @child_association == association
       end
-      @constrained_fields = @constrained_fields.to_a
     end
   end
   
   class NestedInfoScope < NestedInfo
-    def initialize(model, nested_info)
-      super(model, nested_info)
-      @scope = nested_info[:name]
+    def initialize(model, params)
+      super
+      @scope = params[:named_scope].to_sym
+      @param_name = parent_model.name.foreign_key.to_sym
+      @parent_id = params[@param_name]
       @constrained_fields = [] 
     end
     

data/lib/active_scaffold/extensions/action_controller_rescueing.rb

@@ -1,5 +1,6 @@
 module ActionController #:nodoc:
   class Base
+    # adding to ActionController::Base so it can overrided in ApplicationController
     def deny_access
       head :unauthorized
     end

data/lib/active_scaffold/extensions/action_view_rendering.rb

@@ -1,20 +1,11 @@
 module ActionView
   class LookupContext
-    module ViewPaths
-      def find_all_templates(name, partial = false, locals = {})
-        prefixes.collect do |prefix|
-          view_paths.collect do |resolver|
-            if Rails.version < '3.2.0' # FIXME: remove when rails 3.1 support is dropped
-              temp_args = *args_for_lookup(name, [prefix], partial, locals)
-            else
-              temp_args = *args_for_lookup(name, [prefix], partial, locals, {})
-            end
-            temp_args[1] = temp_args[1][0]
-            resolver.find_all(*temp_args)
-          end
-        end.flatten!
-      end
+    attr_accessor :last_template
+    
+    def find_template_with_last_template(name, prefixes = [], partial = false, keys = [], options = {})
+      self.last_template = find_template_without_last_template(name, prefixes, partial, keys, options)
     end
+    alias_method_chain :find_template, :last_template
   end
 end
 
@@ -44,21 +35,7 @@ module ActionView::Helpers #:nodoc:
     # 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]
+      if args.first.is_a? Hash and args.first[:active_scaffold]
         require 'digest/md5'
         options = args.first
 
@@ -87,21 +64,38 @@ module ActionView::Helpers #:nodoc:
             if ActiveScaffold.js_framework == :prototype
               javascript_tag("new Ajax.Updater('#{id}', '#{url}', {method: 'get', evalScripts: true});")
             elsif ActiveScaffold.js_framework == :jquery
-              javascript_tag("jQuery('##{id}').load('#{url}');")
+              javascript_tag("jQuery('##{id}').load('#{url}', function() { $(this).trigger('as:element_updated'); });")
             end
           end
         end
 
+      elsif args.first == :super
+        prefix, template = @virtual_path.split('/')
+        options = args[1] || {}
+        options[:locals] ||= {}
+        options[:locals] = view_stack.last[:locals].merge!(options[:locals]) if view_stack.last && view_stack.last[:locals]
+        options[:template] = template
+        # if prefix is active_scaffold_overrides we must try to render with this prefix in following paths
+        if prefix != 'active_scaffold_overrides'
+          options[:prefixes] = lookup_context.prefixes.drop((lookup_context.prefixes.find_index(prefix) || -1) + 1)
+        else
+          options[:prefixes] = ['active_scaffold_overrides']
+          view_paths = lookup_context.view_paths
+          last_view_path = File.expand_path(File.dirname(File.dirname(lookup_context.last_template.inspect)), Rails.root)
+          lookup_context.view_paths = view_paths.drop(view_paths.find_index {|path| path.to_s == last_view_path} + 1)
+        end
+        result = render_without_active_scaffold options
+        lookup_context.view_paths = view_paths if view_paths
+        result
       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?
+        last_template = lookup_context.last_template
+        if args.first.is_a?(Hash)
+          current_view = {:locals => args.first[:locals]}
+          view_stack << current_view
         end
         result = render_without_active_scaffold(*args, &block)
         view_stack.pop if current_view.present?
+        lookup_context.last_template = last_template
         result
       end
     end

data/lib/active_scaffold/extensions/reverse_associations.rb

@@ -7,19 +7,23 @@ module ActiveRecord
       end
 
       attr_writer :reverse
-      def reverse
-        @reverse ||= inverse_of.try(:name)
+      def reverse(klass = nil)
+        unless defined? @reverse
+          @reverse ||= inverse_of.try(:name)
+        end
+        @reverse || (autodetect_inverse(klass).try(:name) unless klass.nil?)
       end
 
       def inverse_of_with_autodetect
         inverse_of_without_autodetect || autodetect_inverse
       end
       alias_method_chain :inverse_of, :autodetect
-      
+
       protected
 
-        def autodetect_inverse
-          return nil if options[:polymorphic]
+        def autodetect_inverse(klass = nil)
+          return nil if klass.nil? && options[:polymorphic]
+          klass ||= self.klass
           reverse_matches = []
 
           # stage 1 filter: collect associations that point back to this model and use the same foreign_key
@@ -31,7 +35,7 @@ module ActiveRecord
             else
               # skip over has_many :through associations
               next if assoc.options[:through]
-              next unless assoc.options[:polymorphic] or assoc.class_name.constantize == self.active_record
+              next unless assoc.options[:polymorphic] or assoc.class_name == self.active_record.name
 
               case [assoc.macro, self.macro].find_all{|m| m == :has_and_belongs_to_many}.length
                 # if both are a habtm, then match them based on the join table

data/lib/active_scaffold/extensions/routing_mapper.rb

@@ -1,21 +1,22 @@
 module ActionDispatch
   module Routing
     ACTIVE_SCAFFOLD_CORE_ROUTING = {
-        :collection => {:show_search => :get, :render_field => :get, :mark => :post},
-        :member => {:row => :get, :update_column => :post, :render_field => :get, :mark => :post}
+        :collection => {:show_search => :get, :render_field => :post, :mark => :post},
+        :member => {:row => :get, :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, :add_association => :get, :destroy_existing => :delete}
+        :member => {:edit_associated => :get, :destroy_existing => :delete}
     }
     class Mapper
       module Base
         def as_routes(options = {:association => true})
           collection do
-            ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection].each {|name, type| send(type, name)}
+            ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection].each {|name, type| match(name, :via => type)}
           end
           member do
-            ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:member].each {|name, type| send(type, name)}
+            ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:member].each {|name, type| match(name, :via => type)}
+            get 'list', :action => :index
           end
           as_association_routes if options[:association]
         end

data/lib/active_scaffold/extensions/unsaved_associated.rb

@@ -4,7 +4,7 @@ class ActiveRecord::Base
     return true if path.include?(self) # prevent recursion (if associated and parent are new records)
     path << self
     # using [].all? syntax to avoid a short-circuit
-    with_unsaved_associated { |a| [a.valid?, a.associated_valid?(path)].all? {|v| v == true} }
+    with_unsaved_associated { |a| [a.valid?, a.associated_valid?(path)].all? }
   end
 
   def save_associated

data/lib/active_scaffold/finder.rb

@@ -148,7 +148,7 @@ module ActiveScaffold
 
       def condition_value_for_numeric(column, value)
         return value if value.nil?
-        value = i18n_number_to_native_format(value) if [:i18n_number, :currency].include?(column.options[:format])
+        value = i18n_number_to_native_format(value) if [:i18n_number, :currency].include?(column.options[:format]) && column.search_ui != :number
         case (column.search_ui || column.column.type)
         when :integer   then value.to_i rescue value ? 1 : 0
         when :float     then value.to_f
@@ -275,12 +275,14 @@ module ActiveScaffold
       ]
     end
     
-    # returns a single record (the given id) but only if it's allowed for the specified action.
+    # 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, crud_type, klass = beginning_of_chain)
+    def find_if_allowed(id, security_options, klass = beginning_of_chain)
       record = klass.find(id)
-      raise ActiveScaffold::RecordNotAllowed, "#{klass} with id = #{id}" unless record.authorized_for?(:crud_type => crud_type.to_sym)
+      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
     end
     # valid options may include:
@@ -341,7 +343,7 @@ module ActiveScaffold
       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).all
+          append_to_query(klass, find_options)
         end
       end
       pager.page(options[:page])
@@ -351,14 +353,20 @@ module ActiveScaffold
       conditions = all_conditions
       includes = active_scaffold_config.list.count_includes
       includes ||= active_scaffold_includes unless conditions.nil?
-      append_to_query(beginning_of_chain, :conditions => conditions, :includes => includes,
-        :joins => joins_for_collection).calculate(column.calculate, column.name)
+      primary_key = active_scaffold_config.model.primary_key
+      subquery = append_to_query(beginning_of_chain, :conditions => conditions, :joins => joins_for_collection)
+      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
+      beginning_of_chain.where(primary_key => subquery).calculate(column.calculate, column.name)
     end
     
     def append_to_query(query, options)
       options.assert_valid_keys :where, :select, :group, :reorder, :limit, :offset, :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 = apply_conditions(query, *options.delete(:conditions)) if options[:conditions]
+      options.reject{|k, v| v.blank?}.inject(query) do |query, (k, v)|
         query.send((k.to_sym), v) 
       end
     end
@@ -388,7 +396,7 @@ module ActiveScaffold
     def sort_collection_by_column(collection, column, order)
       sorter = column.sort[:method]
       collection = collection.sort_by { |record|
-        value = (sorter.is_a? Proc) ? record.instance_eval(&sorter) : record.instance_eval(sorter)
+        value = (sorter.is_a? Proc) ? record.instance_eval(&sorter) : record.instance_eval(sorter.to_s)
         value = '' if value.nil?
         value
       }