active_scaffold 3.4.43 → 3.5.0

data/lib/active_scaffold/data_structures/columns.rb

@@ -24,7 +24,7 @@ module ActiveScaffold::DataStructures
       @_inheritable = []
       @set = []
 
-      add *args
+      add(*args)
     end
 
     # the way to add columns to the set. this is primarily useful for virtual columns.
@@ -38,7 +38,25 @@ module ActiveScaffold::DataStructures
       # then add columns to @set (unless they already exist)
       args.each { |a| @set << ActiveScaffold::DataStructures::Column.new(a.to_sym, @active_record_class) unless find_by_name(a) }
     end
-    alias_method :<<, :add
+    alias << add
+
+    # add columns from association (belongs_to or has_one)
+    # these columns will use label translation from association model
+    # they will be excluded, so won't be included in action columns
+    # association columns will work for read actions only, not in form actions (create, update, subform)
+    def add_association_columns(association, *columns)
+      column = self[association]
+      raise ArgumentError, "unknown column #{association}" if column.nil?
+      raise ArgumentError, "column #{association} is not an association" if column.association.nil?
+      raise ArugmentError, "column #{association} is not singular association" unless column.association.singular?
+      raise ArugmentError, "column #{association} is polymorphic association" if column.association.polymorphic?
+
+      klass = column.association.klass
+      columns.each do |col|
+        next if find_by_name col
+        @set << ActiveScaffold::DataStructures::Column.new(col, klass, column.association)
+      end
+    end
 
     def exclude(*args)
       # only remove columns from _inheritable. we never want to completely forget about a column.
@@ -56,7 +74,7 @@ module ActiveScaffold::DataStructures
       column = @set.find { |c| c == name }
       column
     end
-    alias_method :[], :find_by_name
+    alias [] find_by_name
 
     def each
       @set.each { |i| yield i }

data/lib/active_scaffold/data_structures/nested_info.rb

@@ -63,7 +63,7 @@ module ActiveScaffold::DataStructures
       false
     end
 
-    def sorted?
+    def sorted?(*)
       false
     end
   end
@@ -71,27 +71,15 @@ module ActiveScaffold::DataStructures
   class NestedInfoAssociation < NestedInfo
     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
+      column = parent_scaffold.active_scaffold_config.columns[params[:association].to_sym]
+      @param_name = column.model.name.foreign_key.to_sym
       @parent_id = params[@param_name]
-      iterate_model_associations(model)
+      @association = column.try(:association)
+      @child_association = association.reverse_association(model) if association
+      setup_constrained_fields
     end
 
-    delegate :name, :to => :association
-
-    def has_many?
-      association.macro == :has_many
-    end
-
-    def habtm?
-      association.macro == :has_and_belongs_to_many
-    end
-
-    delegate :belongs_to?, :to => :association
-
-    def has_one?
-      association.macro == :has_one
-    end
+    delegate :name, :belongs_to?, :has_one?, :has_many?, :habtm?, :readonly?, :to => :association
 
     # A through association with has_one or has_many as source association
     # create cannot be called in nested through associations, and not-nested through associations
@@ -101,28 +89,25 @@ module ActiveScaffold::DataStructures
     def readonly_through_association?(columns)
       return false unless through_association?
       return true if association.through_reflection.options[:through]
-      association.source_reflection.macro != :belongs_to && (
+      !association.source_reflection.belongs_to? && (
         !child_association || !columns.include?(child_association.through_reflection.name)
       )
     end
 
     def through_association?
-      association.options[:through]
+      association.through?
     end
 
-    def readonly?
-      association.options[:readonly]
+    def sorted?(chain)
+      default_sorting(chain).present?
     end
 
-    def sorted?
-      association.options.key? :order
-    end
-
-    def default_sorting
-      if association.options[:order] # TODO: remove when rails 3 compatibility is removed
-        association.options[:order]
-      elsif association.respond_to?(:scope) # rails 4
-        association.klass.class_eval(&association.scope).values[:order] if association.scope.is_a? Proc
+    def default_sorting(chain)
+      return @default_sorting if defined? @default_sorting
+      if association.scope.is_a?(Proc) && chain.respond_to?(:values) && chain.values[:order]
+        @default_sorting = chain.values[:order]
+        @default_sorting = @default_sorting.map(&:to_sql) if @default_sorting[0].is_a? Arel::Nodes::Node
+        @default_sorting = @default_sorting.join(', ')
       end
     end
 
@@ -132,12 +117,12 @@ module ActiveScaffold::DataStructures
 
     protected
 
-    def iterate_model_associations(model)
+    def setup_constrained_fields
       @constrained_fields = []
-      constrained_fields << Array(association.foreign_key).map(&:to_sym) unless association.belongs_to?
-      return if (reverse = association.reverse(model)).nil?
-      @child_association = model.reflect_on_association(reverse)
-      constrained_fields << @child_association.name unless @child_association == association
+      @constrained_fields << Array(association.foreign_key).map(&:to_sym) unless association.belongs_to?
+      if child_association && child_association != association
+        @constrained_fields << child_association.name
+      end
     end
   end
 

data/lib/active_scaffold/data_structures/set.rb

@@ -9,7 +9,7 @@ module ActiveScaffold::DataStructures
 
     def set_values(*args)
       @set = []
-      add *args
+      add(*args)
     end
 
     # the way to add items to the set.
@@ -20,7 +20,7 @@ module ActiveScaffold::DataStructures
         @set << arg unless @set.include? arg # avoid duplicates
       end
     end
-    alias_method :<<, :add
+    alias << add
 
     # the way to remove items from the set.
     def exclude(*args)
@@ -29,7 +29,7 @@ module ActiveScaffold::DataStructures
       # check respond_to? :to_sym, ActionColumns doesn't respond to to_sym
       @set.reject! { |c| c.respond_to?(:to_sym) && args.include?(c.to_sym) } # reject all items specified
     end
-    alias_method :remove, :exclude
+    alias remove exclude
 
     # returns an array of items with the provided names
     def find_by_names(*names)
@@ -42,7 +42,7 @@ module ActiveScaffold::DataStructures
       item = @set.find { |c| c == name }
       item
     end
-    alias_method :[], :find_by_name
+    alias [] find_by_name
 
     def each
       @set.each { |i| yield i }

data/lib/active_scaffold/data_structures/sorting.rb

@@ -2,19 +2,24 @@ module ActiveScaffold::DataStructures
   # encapsulates the column sorting configuration for the List view
   class Sorting
     include Enumerable
+    include ActiveScaffold::OrmChecks
 
     attr_accessor :constraint_columns
     attr_accessor :sorting_by_primary_key # enabled by default for postgres
+    attr_reader :model
+    alias active_record_class model
 
-    def initialize(columns)
+    def initialize(columns, model)
       @columns = columns
       @clauses = []
       @constraint_columns = []
+      @model = model
     end
 
-    def set_default_sorting(model)
+    def set_default_sorting
+      return unless active_record?
       # fallback to setting primary key ordering
-      setup_primary_key_order_clause(model)
+      setup_primary_key_order_clause
       model_scope = model.send(:build_default_scope)
       order_clause = model_scope.order_values.join(',') if model_scope
       return unless order_clause
@@ -34,7 +39,7 @@ module ActiveScaffold::DataStructures
       direction = direction.to_s.upcase
       column = get_column(column_name)
       raise ArgumentError, "Could not find column #{column_name}" if column.nil?
-      raise ArgumentError, 'Sorting direction unknown' unless [:ASC, :DESC].include? direction.to_sym
+      raise ArgumentError, 'Sorting direction unknown' unless %i[ASC DESC].include? direction.to_sym
       @clauses << [column, direction.untaint] if column.sortable?
       raise ArgumentError, "Can't mix :method- and :sql-based sorting" if mixed_sorting?
     end
@@ -77,8 +82,8 @@ module ActiveScaffold::DataStructures
       clause[1]
     end
 
-    SORTING_STAGES = Hash[%w(reset ASC DESC reset).each_cons(2).to_a].freeze
-    DEFAULT_SORTING_STAGES = Hash[%w(ASC DESC ASC).each_cons(2).to_a].freeze
+    SORTING_STAGES = Hash[%w[reset ASC DESC reset].each_cons(2).to_a].freeze
+    DEFAULT_SORTING_STAGES = Hash[%w[ASC DESC ASC].each_cons(2).to_a].freeze
     def next_sorting_of(column, sorted_by_default)
       stages = sorted_by_default ? DEFAULT_SORTING_STAGES : SORTING_STAGES
       stages[direction_of(column)] || 'ASC'
@@ -103,21 +108,30 @@ module ActiveScaffold::DataStructures
       @clauses.first
     end
 
+    def size
+      @clauses.size
+    end
+
     # builds an order-by clause
-    def clause
+    def clause(grouped_columns_calculations = nil)
       return nil if sorts_by_method? || default_sorting?
 
       # unless the sorting is by method, create the sql string
       order = []
       each do |sort_column, sort_direction|
         next if constraint_columns.include? sort_column.name
-        sql = sort_column.sort[:sql]
-        next if sql.nil? || sql.empty?
+        sql = grouped_columns_calculations.try(:dig, sort_column.name) || sort_column.sort[:sql]
+        next if sql.blank?
+        sql = sql.to_sql if sql.respond_to?(:to_sql)
 
-        order << Array(sql).map { |column| "#{column} #{sort_direction}" }.join(', ')
+        parts = Array(sql).map do |column|
+          mongoid? ? [column, sort_direction] : "#{column} #{sort_direction}"
+        end
+        order << parts
       end
 
       order << @primary_key_order_clause if @sorting_by_primary_key
+      order.flatten!(1)
       order unless order.empty?
     end
 
@@ -149,7 +163,7 @@ module ActiveScaffold::DataStructures
     def set_sorting_from_order_clause(order_clause, model_table_name = nil)
       clear
       order_clause.to_s.split(',').each do |criterion|
-        unless criterion.blank?
+        if criterion.present?
           order_parts = extract_order_parts(criterion)
           add(order_parts[:column_name], order_parts[:direction]) unless different_table?(model_table_name, order_parts[:table_name]) || get_column(order_parts[:column_name]).nil?
         end
@@ -178,22 +192,22 @@ module ActiveScaffold::DataStructures
     end
 
     def extract_direction(direction_part)
-      if direction_part.to_s.upcase == 'DESC'
+      if direction_part.to_s.casecmp('DESC').zero?
         'DESC'
       else
         'ASC'
       end
     end
 
-    def postgres?(model)
+    def postgres?
       model.connection.try(:adapter_name) == 'PostgreSQL'
     end
 
-    def setup_primary_key_order_clause(model)
+    def setup_primary_key_order_clause
       return unless model.column_names.include?(model.primary_key)
       set([model.primary_key, 'ASC'])
       @primary_key_order_clause = clause
-      @sorting_by_primary_key = postgres?(model) # mandatory for postgres, so enabled by default
+      @sorting_by_primary_key = postgres? # mandatory for postgres, so enabled by default
     end
   end
 end

data/lib/active_scaffold/engine.rb

@@ -34,6 +34,8 @@ module ActiveScaffold
       end
     end
 
-    config.assets.precompile << 'active_scaffold/indicator.gif' if Rails::VERSION::MAJOR >= 4
+    initializer 'active_scaffold.assets' do
+      config.assets.precompile << 'active_scaffold/indicator.gif'
+    end
   end
 end

data/lib/active_scaffold/extensions/action_controller_rendering.rb

@@ -1,7 +1,7 @@
 # wrap the action rendering for ActiveScaffold controllers
-module ActionController #:nodoc:
-  class Base
-    def render_with_active_scaffold(*args, &block)
+module ActiveScaffold
+  module ActionController #:nodoc:
+    def render(*args, &block)
       if self.class.uses_active_scaffold? && params[:adapter] && @rendering_adapter.nil? && request.xhr?
         @rendering_adapter = true # recursion control
         # if we need an adapter, then we render the actual stuff to a string and insert it into the adapter template
@@ -11,9 +11,14 @@ module ActionController #:nodoc:
                :use_full_path => true, :layout => false, :content_type => :html
         @rendering_adapter = nil # recursion control
       else
-        render_without_active_scaffold(*args, &block)
+        super(*args, &block)
       end
     end
-    alias_method_chain :render, :active_scaffold
+  end
+end
+
+module ActionController
+  class Base
+    prepend ActiveScaffold::ActionController
   end
 end

data/lib/active_scaffold/extensions/action_view_rendering.rb

@@ -1,16 +1,15 @@
-module ActionView
-  class LookupContext
+module ActiveScaffold
+  module LookupContext
     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)
+    def find_template(name, prefixes = [], partial = false, keys = [], options = {})
+      self.last_template = super(name, prefixes, partial, keys, options)
     end
-    alias_method_chain :find_template, :last_template
   end
 end
 
 # wrap the action rendering for ActiveScaffold views
-module ActionView::Helpers #:nodoc:
+module ActiveScaffold #:nodoc:
   module RenderingHelper
     #
     # Adds two rendering options.
@@ -34,52 +33,11 @@ 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)
+    # options[:xhr] force to load embedded scaffold with AJAX even when render_component gem is installed.
+    #
+    def render(*args, &block)
       if args.first.is_a?(Hash) && 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)
-        eid_info = session["as:#{eid}"] ||= {}
-        if constraints
-          eid_info['constraints'] = constraints
-        else
-          eid_info.delete 'constraints'
-        end
-        if conditions
-          eid_info['conditions'] = conditions
-        else
-          eid_info.delete 'conditions'
-        end
-        if options[:label]
-          eid_info['list'] = {'label' => options[:label]}
-        else
-          eid_info.delete 'list'
-        end
-        session.delete "as:#{eid}" if eid_info.empty?
-        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, true)
-          controller.send(:render_component_into_view, url_options)
-        else
-          url = url_for(url_options)
-          content_tag(:div, :id => id, :class => 'active-scaffold-component', :data => {:refresh => url}) do
-            # parse the ActiveRecord model name from the controller path, which
-            # might be a namespaced controller (e.g., 'admin/admins')
-            model = remote_controller.to_s.sub(/.*\//, '').singularize
-            content_tag(:div, :class => 'active-scaffold-header') do
-              content_tag :h2, link_to(args.first[:label] || active_scaffold_config_for(model).list.label, url, :remote => true, :class => 'load-embedded')
-            end
-          end
-        end
-
+        render_embedded args.first
       elsif args.first == :super
         @_view_paths ||= lookup_context.view_paths.clone
         @_last_template ||= lookup_context.last_template
@@ -102,30 +60,78 @@ module ActionView::Helpers #:nodoc:
           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
+        result = super options
         lookup_context.view_paths = @_view_paths if @_view_paths
         lookup_context.last_template = @_last_template if @_last_template
         result
       else
         @_view_paths ||= lookup_context.view_paths.clone
         last_template = lookup_context.last_template
-        if args[0].is_a?(Hash)
-          current_view = {:locals => args[0][:locals], :object => args[0][:object]}
-        else # call is render 'partial', locals_hash
-          current_view = {:locals => args[1]}
-        end
+        current_view = if args[0].is_a?(Hash)
+                         {:locals => args[0][:locals], :object => args[0][:object]}
+                       else # call is render 'partial', locals_hash
+                         {:locals => args[1]}
+                       end
         view_stack << current_view if current_view
         lookup_context.view_paths = @_view_paths # reset view_paths in case a view render :super, and then render :partial
-        result = render_without_active_scaffold(*args, &block)
+        result = super
         view_stack.pop if current_view.present?
         lookup_context.last_template = last_template
         result
       end
     end
-    alias_method_chain :render, :active_scaffold
 
     def view_stack
       @_view_stack ||= []
     end
+
+    private
+
+    def render_embedded(options)
+      require 'digest/md5'
+
+      remote_controller = options[:active_scaffold]
+      # It is important that the EID hash remains short as to not contribute
+      # to a large session size and thus a possible cookie overflow exception
+      # when using rails CookieStore or EncryptedCookieStore. For example,
+      # when rendering many embedded scaffolds with constraints or conditions
+      # on a single page.
+      eid = Digest::MD5.hexdigest(params[:controller] + options.to_s)
+      eid_info = {loading: true}
+      eid_info[:constraints] = options[:constraints] if options[:constraints]
+      eid_info[:conditions] = options[:conditions] if options[:conditions]
+      eid_info[:label] = options[:label] if options[:label]
+      options[:params] ||= {}
+      options[:params].merge! :eid => eid, :embedded => eid_info
+
+      id = "as_#{eid}-embedded"
+      url_options = {controller: remote_controller.to_s, action: 'index', id: nil}.merge(options[:params])
+
+      if controller.respond_to?(:render_component_into_view, true) && !options[:xhr]
+        controller.send(:render_component_into_view, url_options)
+      else
+        url = url_for(url_options)
+        content_tag(:div, :id => id, :class => 'active-scaffold-component', :data => {:refresh => url}) do
+          # parse the ActiveRecord model name from the controller path, which
+          # might be a namespaced controller (e.g., 'admin/admins')
+          model = remote_controller.to_s.sub(/.*\//, '').singularize
+          content_tag(:div, :class => 'active-scaffold-header') do
+            content_tag :h2, link_to(options[:label] || active_scaffold_config_for(model).list.label, url, :remote => true, :class => 'load-embedded')
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActionView
+  LookupContext.class_eval do
+    prepend ActiveScaffold::LookupContext
+  end
+
+  module Helpers
+    Base.class_eval do
+      include ActiveScaffold::RenderingHelper
+    end
   end
 end