active_scaffold 3.5.3 → 3.6.0.rc2

data/lib/active_scaffold/config/core.rb

@@ -60,6 +60,11 @@ module ActiveScaffold::Config
       ActiveScaffold::ActiveRecordPermissions
     end
 
+    # access to default column configuration.
+    def self.column
+      ActiveScaffold::DataStructures::Column
+    end
+
     # columns that should be ignored for every model. these should be metadata columns like change dates, versions, etc.
     # values in this array may be symbols or strings.
     def self.ignore_columns
@@ -83,6 +88,16 @@ module ActiveScaffold::Config
     cattr_accessor :highlight_messages, instance_accessor: false
     @@highlight_messages = nil
 
+    # method names or procs to be called after all configure blocks
+    cattr_reader :after_config_callbacks, instance_accessor: false
+    @@after_config_callbacks = [:_configure_sti]
+
+    def self.freeze
+      super
+      security.freeze
+      column.freeze
+    end
+
     # instance-level configuration
     # ----------------------------
 
@@ -149,6 +164,7 @@ module ActiveScaffold::Config
     def initialize(model_id)
       # model_id is the only absolutely required configuration value. it is also not publicly accessible.
       @model_id = model_id
+      setup_user_setting_key
 
       # inherit the actions list directly from the global level
       @actions = self.class.actions.clone
@@ -182,17 +198,20 @@ module ActiveScaffold::Config
       @highlight_messages = self.class.highlight_messages
     end
 
-    # To be called after your finished configuration
-    def _load_action_columns
-      # then, register the column objects
+    # To be called before freezing
+    def _cache_lazy_values
+      action_links.each(&:name_to_cache) if cache_action_link_urls
+      columns.select(&:sortable?).each(&:sort)
+      columns.select(&:searchable?).each(&:search_sql)
       actions.each do |action_name|
         action = send(action_name)
-        action.columns.set_columns(columns) if action.respond_to?(:columns)
+        Array(action.class.columns_collections).each { |method| action.send(method) }
       end
     end
 
     # To be called after your finished configuration
     def _configure_sti
+      return if sti_children.nil?
       column = model.inheritance_column
       if sti_create_links
         columns[column].form_ui ||= :hidden
@@ -205,28 +224,55 @@ module ActiveScaffold::Config
       end
     end
 
+    def _setup_action(action)
+      define_singleton_method action do
+        self[action]
+      end
+    end
+
     # configuration routing.
     # we want to route calls named like an activated action to that action's global or local Config class.
     # ---------------------------
     def method_missing(name, *args)
-      @action_configs ||= {}
-      titled_name = name.to_s.camelcase
-      underscored_name = name.to_s.underscore.to_sym
-      klass = "ActiveScaffold::Config::#{titled_name}".constantize rescue nil
-      if klass
-        if @actions.include? underscored_name
-          return @action_configs[underscored_name] ||= klass.new(self)
-        else
-          raise "#{titled_name} is not enabled. Please enable it or remove any references in your configuration (e.g. config.#{underscored_name}.columns = [...])."
-        end
+      self[name] || super
+    end
+
+    def respond_to_missing?(name, include_all = false)
+      self.class.config_class?(name) && @actions.include?(name.to_sym) || super
+    end
+
+    def [](action_name)
+      klass = self.class.config_class(action_name)
+      return unless klass
+
+      underscored_name = action_name.to_s.underscore.to_sym
+      unless @actions.include? underscored_name
+        raise "#{action_name.to_s.camelcase} is not enabled. Please enable it or remove any references in your configuration (e.g. config.#{underscored_name}.columns = [...])."
       end
-      super
+      @action_configs ||= {}
+      @action_configs[underscored_name] ||= klass.new(self)
+    end
+
+    def []=(action_name, action_config)
+      @action_configs ||= {}
+      @action_configs[action_name] = action_config
     end
+    private :[]=
 
     def self.method_missing(name, *args)
-      klass = "ActiveScaffold::Config::#{name.to_s.camelcase}".constantize rescue nil
-      return klass if @@actions.include?(name.to_s.underscore) && klass
-      super
+      config_class(name) || super
+    end
+
+    def self.config_class(name)
+      "ActiveScaffold::Config::#{name.to_s.camelcase}".constantize if config_class?(name)
+    end
+
+    def self.config_class?(name)
+      ActiveScaffold::Config.const_defined? name.to_s.camelcase
+    end
+
+    def self.respond_to_missing?(name, include_all = false)
+      config_class?(name) && @@actions.include?(name.to_s.underscore) || super
     end
     # some utility methods
     # --------------------
@@ -247,6 +293,17 @@ module ActiveScaffold::Config
       @inherited_view_paths ||= []
     end
 
+    def build_action_columns(action, columns)
+      action_columns =
+        if columns.is_a?(ActiveScaffold::DataStructures::ActionColumns)
+          columns.dup
+        else
+          ActiveScaffold::DataStructures::ActionColumns.new(*columns)
+        end
+      action_columns.action = action.is_a?(Symbol) ? send(action) : action
+      action_columns
+    end
+
     # must be a class method so the layout doesn't depend on a controller that uses active_scaffold
     # note that this is unaffected by per-controller frontend configuration.
     def self.asset_path(filename, frontend = self.frontend)
@@ -264,5 +321,76 @@ module ActiveScaffold::Config
       frontends_dir = Rails.root.join('vendor', 'plugins', ActiveScaffold::Config::Core.plugin_directory, 'frontends')
       Dir.entries(frontends_dir).reject { |e| e.match(/^\./) } # Get rid of files that start with .
     end
+
+    class UserSettings < UserSettings
+      include ActiveScaffold::Configurable
+      user_attr :cache_action_link_urls, :cache_association_options, :conditional_get_support,
+                :timestamped_messages, :highlight_messages
+
+      def method_missing(name, *args)
+        value = @conf.actions.include?(name) ? @conf.send(name) : super
+        value.is_a?(Base) ? action_user_settings(value) : value
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        super # avoid rubocop warning
+      end
+
+      def action_user_settings(action_config)
+        if action_config.user.nil? && action_config.respond_to?(:new_user_settings)
+          action_config.new_user_settings @storage, @params
+        end
+        action_config.user || action_config
+      end
+
+      def columns
+        @columns ||= UserColumns.new(@conf.columns)
+      end
+
+      def action_links
+        @action_links ||= CowProxy.wrap(@conf.action_links)
+      end
+
+      def model
+        @conf.model # for performance, called many times, so we avoid method_missing
+      end
+
+      def actions
+        @conf.actions # for performance, called many times, so we avoid method_missing
+      end
+    end
+
+    class UserColumns
+      include Enumerable
+
+      def initialize(columns)
+        @global_columns = columns
+        @columns = {}
+      end
+
+      def [](name)
+        return nil unless @global_columns[name]
+        @columns[name.to_sym] ||= CowProxy.wrap @global_columns[name]
+      end
+
+      def each
+        return enum_for(:each) unless block_given?
+        @global_columns.each do |col|
+          yield self[col.name]
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        if @global_columns.respond_to?(name, true)
+          @global_columns.send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        @global_columns.respond_to?(name, include_all) || super
+      end
+    end
   end
 end

data/lib/active_scaffold/config/delete.rb

@@ -12,7 +12,18 @@ module ActiveScaffold::Config
 
     # the ActionLink for this action
     cattr_accessor :link, instance_accessor: false
-    @@link = ActiveScaffold::DataStructures::ActionLink.new('destroy', :label => :delete, :type => :member, :confirm => :are_you_sure_to_delete, :method => :delete, :crud_type => :delete, :position => false, :parameters => {:destroy_action => true}, :security_method => :delete_authorized?, :ignore_method => :delete_ignore?)
+    @@link = ActiveScaffold::DataStructures::ActionLink.new(
+      'destroy',
+      :label => :delete,
+      :type => :member,
+      :method => :delete,
+      :crud_type => :delete,
+      :confirm => :are_you_sure_to_delete,
+      :position => false,
+      :parameters => {:destroy_action => true},
+      :security_method => :delete_authorized?,
+      :ignore_method => :delete_ignore?
+    )
 
     # whether we should refresh list after destroy or not
     cattr_accessor :refresh_list, instance_accessor: false
@@ -26,5 +37,7 @@ module ActiveScaffold::Config
 
     # whether we should refresh list after destroy or not
     attr_accessor :refresh_list
+
+    undef_method :new_user_settings
   end
 end

data/lib/active_scaffold/config/field_search.rb

@@ -1,6 +1,7 @@
 module ActiveScaffold::Config
   class FieldSearch < Base
     self.crud_type = :read
+    NO_COLUMNS = [].freeze
 
     def initialize(core_config)
       super
@@ -52,7 +53,8 @@ module ActiveScaffold::Config
     end
 
     def optional_columns
-      @optional_columns ||= []
+      return @optional_columns || NO_COLUMNS if frozen?
+      @optional_columns ||= NO_COLUMNS.dup
     end
 
     # add array of columns as options for group by to get aggregated listings
@@ -68,5 +70,9 @@ module ActiveScaffold::Config
     # human conditions
     # instead of just filtered you may show the user a humanized search condition statment
     attr_accessor :human_conditions
+
+    UserSettings.class_eval do
+      user_attr :optional_columns, :group_options, :grouped_columns, :human_conditions
+    end
   end
 end

data/lib/active_scaffold/config/form.rb

@@ -43,7 +43,7 @@ module ActiveScaffold::Config
 
     columns_accessor :columns do
       columns.exclude :created_on, :created_at, :updated_on, :updated_at, :as_marked
-      columns.exclude(*@core.columns.collect { |c| c.name if c.association.try(:polymorphic?) }.compact)
+      columns.exclude(*@core.columns.collect { |c| c.name if c.association&.polymorphic? }.compact)
     end
 
     # whether the form should be multipart
@@ -51,5 +51,14 @@ module ActiveScaffold::Config
     def multipart?
       @multipart ? true : false
     end
+
+    UserSettings.class_eval do
+      user_attr :persistent, :refresh_list, :show_unauthorized_columns
+
+      attr_writer :multipart
+      def multipart?
+        defined?(@multipart) ? @multipart : @conf.multipart?
+      end
+    end
   end
 end

data/lib/active_scaffold/config/list.rb

@@ -186,8 +186,8 @@ module ActiveScaffold::Config
     def search_partial
       if @always_show_search == true
         auto_search_partial
-      else
-        @always_show_search.to_s if @core.actions.include? @always_show_search
+      elsif @core.actions.include? @always_show_search
+        @always_show_search.to_s
       end
     end
 
@@ -219,10 +219,16 @@ module ActiveScaffold::Config
     # order clause will be used for ETag when calculate_etag is disabled, so query for records can be avoided
     attr_accessor :calculate_etag
 
-    class UserSettings < UserSettings
+    # don't inherit, defined with columns_accessor, class_eval would complain about block too long
+    class UserSettings
+      user_attr :page_links_inner_window, :page_links_outer_window, :refresh_with_header, :empty_field_text,
+                :association_join_text, :messages_above_header, :wrap_tag, :auto_select_columns, :calculate_etag,
+                :no_entries_message, :filtered_message, :show_search_reset, :always_show_create, :always_show_search,
+                :hide_nested_column, :pagination, :auto_pagination
+
       def initialize(conf, storage, params)
         super(conf, storage, params, :list)
-        @sorting = nil
+        @_sorting = nil
       end
 
       attr_writer :label
@@ -232,7 +238,7 @@ module ActiveScaffold::Config
       end
 
       def embedded_label
-        @params[:embedded][:label] if @params[:embedded]
+        @params.dig :embedded, :label
       end
 
       def per_page
@@ -240,6 +246,10 @@ module ActiveScaffold::Config
         self['per_page'] || @conf.per_page
       end
 
+      def per_page=(value)
+        self['per_page'] = value
+      end
+
       def page
         self['page'] = @params['page'] || 1 if @params.key?('page') || @conf.auto_pagination
         self['page'] || 1
@@ -252,41 +262,57 @@ module ActiveScaffold::Config
       attr_reader :nested_default_sorting
 
       def nested_default_sorting=(options)
-        @nested_default_sorting ||= @conf.sorting.clone
+        @nested_default_sorting ||= sorting_dup
         @nested_default_sorting.set_nested_sorting(options[:table_name], options[:default_sorting])
       end
 
       def default_sorting
-        nested_default_sorting.nil? ? @conf.sorting.clone : nested_default_sorting
+        nested_default_sorting.nil? || @sorting.present? ? sorting_dup : nested_default_sorting
       end
 
+      # TODO: programatically set sorting, for per-request configuration, priority @params, then @sort
+
       def user_sorting?
         @params['sort'] && @params['sort_direction'] != 'reset'
       end
 
+      # change list sorting for this request, unless sorting is defined
+      # {column => direction, column => direction}
+      attr_writer :sorting
+
       def sorting
-        if @sorting.nil?
+        if @_sorting.nil?
           # we want to store as little as possible in the session, but we want to return a Sorting data structure. so we recreate it each page load based on session data.
           self['sort'] = [@params['sort'], @params['sort_direction']] if @params['sort'] && @params['sort_direction']
           self['sort'] = nil if @params['sort_direction'] == 'reset'
 
           if self['sort'] && @conf.core.columns[self['sort'][0]]
-            sorting = @conf.sorting.clone
+            sorting = sorting_dup
             sorting.set(*self['sort'])
-            @sorting = sorting
+            @_sorting = sorting
           else
-            @sorting = default_sorting
+            @_sorting = default_sorting
+            @_sorting.set(@sorting) if @sorting
             if @conf.columns.constraint_columns.present?
-              @sorting.constraint_columns = @conf.columns.constraint_columns
+              @_sorting.constraint_columns = @conf.columns.constraint_columns
             end
           end
         end
-        @sorting
+        @_sorting
       end
 
       def count_includes
         @conf.count_includes
       end
+
+      protected
+
+      def sorting_dup
+        sorting = @conf.sorting.dup
+        # access to config instance columns instead of config class columns, in case columns are changed in this request
+        sorting.instance_variable_set :@columns, core.columns
+        sorting
+      end
     end
   end
 end

data/lib/active_scaffold/config/mark.rb

@@ -11,7 +11,7 @@ module ActiveScaffold::Config
     attr_accessor :mark_all_mode
 
     def initialize(core_config)
-      @core = core_config
+      super
       @mark_all_mode = self.class.mark_all_mode
       @core.model.send(:include, ActiveScaffold::MarkedModel) unless @core.model < ActiveScaffold::MarkedModel
       add_mark_column
@@ -24,7 +24,9 @@ module ActiveScaffold::Config
       @core.columns[:as_marked].label = 'M'
       @core.columns[:as_marked].list_ui = :marked
       @core.columns[:as_marked].sort = false
-      @core.list.columns = [:as_marked] + @core.list.columns.names_without_auth_check unless @core.list.columns.include? :as_marked
+      @core.list.columns = [:as_marked] + @core.list.columns.to_a unless @core.list.columns.include? :as_marked
     end
+
+    undef_method :new_user_settings
   end
 end

data/lib/active_scaffold/config/nested.rb

@@ -25,23 +25,20 @@ module ActiveScaffold::Config
     # Add a nested ActionLink
     def add_link(attribute, options = {})
       column = @core.columns[attribute.to_sym]
-      if column && column.association
-        label =
-          if column.association.polymorphic?
-            column.label
-          else
-            column.association.klass.model_name.human(:count => column.association.singular? ? 1 : 2, :default => column.association.klass.name.pluralize)
-          end
-        options.reverse_merge! :security_method => :nested_authorized?, :label => label
-        action_group = options.delete(:action_group) || self.action_group
-        action_link = @core.link_for_association(column, options)
-        @core.action_links.add_to_group(action_link, action_group) unless action_link.nil?
-        action_link
-      elsif column.nil?
-        raise ArgumentError, "unknown column #{attribute}"
-      elsif column.association.nil?
-        raise ArgumentError, "column #{attribute} is not an association"
-      end
+      raise ArgumentError, "unknown column #{attribute}" if column.nil?
+      raise ArgumentError, "column #{attribute} is not an association" if column.association.nil?
+
+      label =
+        if column.association.polymorphic?
+          column.label
+        else
+          column.association.klass.model_name.human(:count => column.association.singular? ? 1 : 2, :default => column.association.klass.name.pluralize)
+        end
+      options.reverse_merge! :security_method => :nested_authorized?, :label => label
+      action_group = options.delete(:action_group) || self.action_group
+      action_link = @core.link_for_association(column, options)
+      @core.action_links.add_to_group(action_link, action_group) unless action_link.nil?
+      action_link
     end
 
     def add_scoped_link(named_scope, options = {})
@@ -51,5 +48,7 @@ module ActiveScaffold::Config
 
     # the label for this Nested action. used for the header.
     attr_writer :label
+
+    undef_method :new_user_settings
   end
 end