active_scaffold 3.5.5 → 3.6.0.pre

data/lib/active_scaffold/config/delete.rb

@@ -26,5 +26,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

@@ -219,10 +219,15 @@ 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
+    UserSettings.class_eval do # defined with columns_accessor
+      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
+
       def initialize(conf, storage, params)
         super(conf, storage, params, :list)
-        @sorting = nil
+        @_sorting = nil
       end
 
       attr_writer :label
@@ -232,7 +237,7 @@ module ActiveScaffold::Config
       end
 
       def embedded_label
-        @params[:embedded][:label] if @params[:embedded]
+        @params.dig :embedded, :label
       end
 
       def per_page
@@ -240,6 +245,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,36 +261,43 @@ module ActiveScaffold::Config
       attr_reader :nested_default_sorting
 
       def nested_default_sorting=(options)
-        @nested_default_sorting ||= @conf.sorting.clone
+        @nested_default_sorting ||= @conf.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? ? @conf.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 = @conf.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

data/lib/active_scaffold/config/mark.rb

@@ -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

data/lib/active_scaffold/config/search.rb

@@ -64,5 +64,14 @@ module ActiveScaffold::Config
     def live?
       @live
     end
+
+    UserSettings.class_eval do
+      attr_writer :live
+      def live?
+        defined?(@live) ? @live : @conf.live?
+      end
+
+      user_attr :text_search, :split_terms
+    end
   end
 end

data/lib/active_scaffold/config/show.rb

@@ -25,5 +25,9 @@ module ActiveScaffold::Config
     attr_writer :label
 
     columns_accessor :columns
+
+    UserSettings.class_eval do
+      user_attr :inline_links
+    end
   end
 end

data/lib/active_scaffold/config/update.rb

@@ -32,5 +32,9 @@ module ActiveScaffold::Config
     def hide_nested_column
       @hide_nested_column.nil? ? true : @hide_nested_column
     end
+
+    UserSettings.class_eval do
+      user_attr :nested_links, :hide_nested_column
+    end
   end
 end

data/lib/active_scaffold/configurable.rb

@@ -13,14 +13,19 @@ module ActiveScaffold
       ret
     end
 
-    # this method will surely need tweaking. for example, i'm not sure if it should call super before or after it tries to eval with the binding.
     def method_missing(name, *args)
-      super
-    rescue NoMethodError, NameError
-      if @configuration_binding.nil?
-        raise
-      else
+      if @configuration_binding&.respond_to?(name, true)
         @configuration_binding.send(name, *args)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_all = false)
+      if @configuration_binding
+        @configuration_binding.respond_to?(name, include_all)
+      else
+        super
       end
     end
   end

data/lib/active_scaffold/constraints.rb

@@ -143,7 +143,7 @@ module ActiveScaffold
       config = record.is_a?(active_scaffold_config.model) ? active_scaffold_config : active_scaffold_config_for(record.class)
       constraints.each do |k, v|
         column = config.columns[k]
-        if column && column.association
+        if column&.association
           if column.association.collection?
             record.send(k.to_s).send(:<<, column.association.klass.find(v))
           elsif column.association.polymorphic?

data/lib/active_scaffold/core.rb

@@ -4,12 +4,43 @@ module ActiveScaffold
       base.extend(ClassMethods)
     end
 
+    def setup_user_settings
+      config = self.class.active_scaffold_config
+      config.new_user_settings(user_settings_storage, params)
+      unless ActiveScaffold.threadsafe
+        config.actions.each do |action_name|
+          conf_instance = config.send(action_name) rescue next # rubocop:disable Style/RescueModifier
+          config.user.action_user_settings(conf_instance)
+        end
+      end
+    end
+
     def active_scaffold_config
-      self.class.active_scaffold_config
+      setup_user_settings unless self.class.active_scaffold_config.user
+      if ActiveScaffold.threadsafe
+        self.class.active_scaffold_config.user
+      else
+        self.class.active_scaffold_config
+      end
+    end
+
+    def active_scaffold_session_storage_key(id = nil)
+      id ||= params[:eid] || "#{params[:controller]}#{"_#{nested_parent_id}" if nested?}"
+      "as:#{id}"
     end
 
-    def active_scaffold_config_for(klass)
-      self.class.active_scaffold_config_for(klass)
+    def active_scaffold_session_storage(id = nil)
+      session_index = active_scaffold_session_storage_key(id)
+      session[session_index] ||= {}
+      session[session_index]
+    end
+
+    def user_settings_storage
+      if self.class.active_scaffold_config.store_user_settings
+        active_scaffold_session_storage
+      else
+        {}
+      end
     end
 
     module ClassMethods
@@ -30,7 +61,6 @@ module ActiveScaffold
         active_scaffold_config.sti_children = nil # reset sti_children if set in parent block
         active_scaffold_config.configure(&block) if block_given?
         active_scaffold_config._configure_sti unless active_scaffold_config.sti_children.nil?
-        active_scaffold_config._load_action_columns
 
         # defines the attribute read methods on the model, so record.send() doesn't find protected/private methods instead
         # define_attribute_methods is safe to call multiple times since rails 4.0.4
@@ -46,6 +76,7 @@ module ActiveScaffold
           active_scaffold_config.actions.each do |mod|
             include "ActiveScaffold::Actions::#{mod.to_s.camelize}".constantize
             mod_conf = active_scaffold_config.send(mod)
+            active_scaffold_config._setup_action(mod) if ActiveScaffold.threadsafe
             next unless mod_conf.respond_to?(:link) && (link = mod_conf.link)
 
             # sneak the action links from the actions into the main set
@@ -59,10 +90,14 @@ module ActiveScaffold
           end
         end
         _add_sti_create_links if active_scaffold_config.add_sti_create_links?
+        if ActiveScaffold.threadsafe
+          active_scaffold_config._cache_lazy_values
+          active_scaffold_config.deep_freeze!
+        end
       end
 
       module Prefixes
-        define_method Rails.version < '4.2' ? 'parent_prefixes' : 'local_prefixes' do
+        define_method 'local_prefixes' do
           @local_prefixes ||= begin
             prefixes = super()
             unless superclass.uses_active_scaffold? || prefixes.include?('active_scaffold_overrides')
@@ -167,17 +202,14 @@ module ActiveScaffold
       end
 
       def active_scaffold_config_for(klass)
-        controller = active_scaffold_controller_for(klass)
+        active_scaffold_controller_for(klass).active_scaffold_config
       rescue ActiveScaffold::ControllerNotFound
-        config = ActiveScaffold::Config::Core.new(klass)
-        config._load_action_columns
-        config
-      else
-        controller.active_scaffold_config
+        ActiveScaffold::Config::Core.new(klass)
       end
 
       def active_scaffold_controller_for(klass)
         return self if uses_active_scaffold? && klass == active_scaffold_config.model
+        # noinspection RubyArgCount
         ActiveScaffold::Core.active_scaffold_controller_for(klass, to_s.deconstantize + '::')
       end
 
@@ -216,9 +248,9 @@ module ActiveScaffold
     end
 
     def self.column_type_cast(value, column)
-      if defined?(ActiveRecord) && ActiveRecord::ConnectionAdapters::Column === column
+      if defined?(ActiveRecord) && column.is_a?(ActiveRecord::ConnectionAdapters::Column)
         active_record_column_type_cast(value, column)
-      elsif defined?(Mongoid) && Mongoid::Fields::Standard === column
+      elsif defined?(Mongoid) && column.is_a?(Mongoid::Fields::Standard)
         mongoid_column_type_cast(value, column)
       else
         value
@@ -230,9 +262,7 @@ module ActiveScaffold
     end
 
     def self.active_record_column_type_cast(value, column)
-      if Rails.version < '4.2'
-        column.type_cast value
-      elsif Rails.version < '5.0'
+      if Rails.version < '5.0'
         column.type_cast_from_user value
       elsif column.type.respond_to? :cast # jruby-jdbc and rails 5
         column.type.cast value

data/lib/active_scaffold/data_structures/action_columns.rb

@@ -52,82 +52,77 @@ module ActiveScaffold::DataStructures
       false
     end
 
-    def names
-      if @columns
-        collect_visible(:flatten => true, &:name)
-      else
-        names_without_auth_check
-      end
+    def to_a
+      Array(@set)
     end
 
-    def names_without_auth_check
-      Array(@set)
+    def skip_column?(column_name, options)
+      # skip if this matches a constrained column
+      return true if constraint_columns.include?(column_name.to_sym)
+      # skip this field if it's not authorized
+      unless options[:for].authorized_for?(action: options[:action], crud_type: options[:crud_type] || action&.crud_type || :read, column: column_name)
+        unauthorized_columns << column_name.to_sym
+        return true
+      end
+      false
     end
 
-    # Redefine the each method to yield actual Column objects.
-    # It will skip constrained and unauthorized columns.
-    #
-    # Options:
-    #  * :flatten - whether to recursively iterate on nested sets. default is false.
-    #  * :for - the record (or class) being iterated over. used for column-level security. default is the class.
-    def each(options = {}, &proc)
-      options[:for] ||= @columns.active_record_class unless @columns.nil?
+    def each_column(options = {}, &proc)
+      columns = action.core.columns
       self.unauthorized_columns = []
-      @set.each do |item|
-        unless item.is_a?(ActiveScaffold::DataStructures::ActionColumns) || @columns.nil?
-          item = (@columns[item] || ActiveScaffold::DataStructures::Column.new(item.to_sym, @columns.active_record_class))
-          next if skip_column?(item, options)
-        end
+      options[:for] ||= columns.active_record_class
+
+      each do |item|
         if item.is_a? ActiveScaffold::DataStructures::ActionColumns
           if options[:flatten]
-            item.each(options, &proc)
+            item.each_column(options, &proc)
           elsif !options[:skip_groups]
             yield item
           end
         else
-          yield item
+          next if skip_column?(item, options)
+          yield columns[item] || ActiveScaffold::DataStructures::Column.new(item.to_sym, columns.active_record_class)
         end
       end
     end
 
-    def collect_visible(options = {}, &proc)
+    def visible_columns(options = {})
       columns = []
-      options[:for] ||= @columns.active_record_class
-      self.unauthorized_columns = []
-      @set.each do |item|
-        unless item.is_a?(ActiveScaffold::DataStructures::ActionColumns) || @columns.nil?
-          item = (@columns[item] || ActiveScaffold::DataStructures::Column.new(item.to_sym, @columns.active_record_class))
-          next if skip_column?(item, options)
-        end
-        if item.is_a?(ActiveScaffold::DataStructures::ActionColumns) && options.key?(:flatten) && options[:flatten]
-          columns += item.collect_visible(options, &proc)
-        else
-          columns << (block_given? ? yield(item) : item)
-        end
+      each_column(options) do |column|
+        columns << column
       end
       columns
     end
 
-    def skip_column?(column, options)
-      # skip if this matches a constrained column
-      return true if constraint_columns.include?(column.name.to_sym)
-      # skip this field if it's not authorized
-      unless options[:for].authorized_for?(:action => options[:action], :crud_type => options[:crud_type] || action.try(:crud_type) || :read, :column => column.name)
-        unauthorized_columns << column.name.to_sym
-        return true
-      end
-      false
+    def visible_columns_names(options = {})
+      visible_columns(options.reverse_merge(flatten: true)).map(&:name)
     end
 
-    # registers a set of column objects (recursively, for all nested ActionColumns)
-    def set_columns(columns)
-      @columns = columns
-      # iterate over @set instead of self to avoid dealing with security queries
-      @set.each do |item|
-        item.set_columns(columns) if item.respond_to? :set_columns
+    def each(options = nil, &proc)
+      if options
+        ActiveSupport::Deprecation.warn 'use each_column'
+        each_column(options, &proc)
+      else
+        super(&proc)
       end
     end
 
+    def collect_visible(options = {}, &proc)
+      ActiveSupport::Deprecation.warn "use visible_columns#{"(#{options.inspect})" if options.present?}#{'.map(&proc)' if proc}"
+      columns = visible_columns(options)
+      proc ? columns.map(&proc) : columns
+    end
+
+    def names
+      ActiveSupport::Deprecation.warn 'use visible_columns.map(&:name)'
+      visible_columns(flatten: true).map(&:name)
+    end
+
+    def names_without_auth_check
+      ActiveSupport::Deprecation.warn 'use to_a'
+      to_a
+    end
+
     def action_name
       @action.class.name.demodulize.underscore
     end
@@ -137,23 +132,19 @@ module ActiveScaffold::DataStructures
     end
 
     def constraint_columns=(columns)
-      Thread.current[:constraint_columns] ||= {}
-      Thread.current[:constraint_columns][columns_key] = columns
+      ActiveScaffold::Registry.constraint_columns[columns_key] = columns
     end
 
     def constraint_columns
-      constraints = Thread.current[:constraint_columns]
-      (constraints[columns_key] if constraints) || []
+      ActiveScaffold::Registry.constraint_columns[columns_key]
     end
 
     def unauthorized_columns=(columns)
-      Thread.current[:unauthorized_columns] ||= {}
-      Thread.current[:unauthorized_columns][columns_key] = columns
+      ActiveScaffold::Registry.unauthorized_columns[columns_key] = columns
     end
 
     def unauthorized_columns
-      Thread.current[:unauthorized_columns] ||= {}
-      Thread.current[:unauthorized_columns][columns_key] ||= []
+      ActiveScaffold::Registry.unauthorized_columns[columns_key]
     end
 
     def length