active_scaffold 3.5.4 → 3.6.0

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

@@ -1,5 +1,7 @@
 module ActiveScaffold
-  # Exposes a +configure+ method that accepts a block and runs all contents of the block in two contexts, as opposed to the normal one. First, everything gets evaluated as part of the object including Configurable. Then, as a failover, missing methods and variables are evaluated in the original binding of the block.
+  # Exposes a +configure+ method that accepts a block and runs all contents of the block in two contexts,
+  # as opposed to the normal one. First, everything gets evaluated as part of the object including Configurable.
+  # Then, as a failover, missing methods and variables are evaluated in the original binding of the block.
   #
   # Note that this only works with "barewords". Constants, instance variables, and class variables are not currently supported in both contexts.
   #
@@ -13,14 +15,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 defined? @configuration_binding
+        @configuration_binding&.respond_to?(name, include_all)
+      else
+        super
       end
     end
   end

data/lib/active_scaffold/constraints.rb

@@ -61,15 +61,7 @@ module ActiveScaffold
 
           # association column constraint
           elsif column.association
-            if column.association.habtm?
-              active_scaffold_habtm_joins.concat column.includes
-            elsif !column.association.polymorphic?
-              if column.association.belongs_to?
-                active_scaffold_preload.concat column.includes
-              else
-                active_scaffold_references.concat column.includes
-              end
-            end
+            join_from_association_constraint(column)
             hash_conditions.deep_merge!(condition_from_association_constraint(column.association, v))
 
           # regular column constraints
@@ -78,7 +70,7 @@ module ActiveScaffold
             conditions << [column.search_sql.collect { |search_sql| "#{search_sql} = ?" }.join(' OR '), *([v] * column.search_sql.size)]
           end
         # unknown-to-activescaffold-but-real-database-column constraint
-        elsif active_scaffold_config.model.columns_hash[k.to_s] && params[column.name] != v
+        elsif active_scaffold_config._columns_hash[k.to_s] && params[column.name] != v
           hash_conditions.deep_merge!(k => v)
         else
           raise ActiveScaffold::MalformedConstraint, constraint_error(active_scaffold_config.model, k), caller
@@ -87,6 +79,18 @@ module ActiveScaffold
       conditions.reject(&:blank?)
     end
 
+    def join_from_association_constraint(column)
+      if column.association.habtm?
+        active_scaffold_habtm_joins.concat column.includes
+      elsif !column.association.polymorphic?
+        if column.association.belongs_to?
+          active_scaffold_preload.concat column.includes
+        else
+          active_scaffold_references.concat column.includes
+        end
+      end
+    end
+
     # We do NOT want to use .search_sql. If anything, search_sql will refer
     # to a human-searchable value on the associated record.
     def condition_from_association_constraint(association, value)
@@ -96,17 +100,15 @@ module ActiveScaffold
       #
       # please see the relevant tests for concrete examples.
 
-      field = if association.belongs_to?
-                association.foreign_key
-              else
-                association.klass.primary_key
+      field =
+        if association.belongs_to?
+          association.foreign_key
+        else
+          association.klass.primary_key
         end
 
       table = association.belongs_to? ? active_scaffold_config.model.table_name : association.table_name
-
-      if association.primary_key
-        value = association.klass.find(value).send(association.primary_key)
-      end
+      value = association.klass.find(value).send(association.primary_key) if association.primary_key
 
       if association.polymorphic?
         unless value.is_a?(Array) && value.size == 2
@@ -143,7 +145,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?
@@ -151,7 +153,7 @@ module ActiveScaffold
               raise ActiveScaffold::MalformedConstraint, polymorphic_constraint_error(column.association), caller
             end
             record.send("#{k}=", v[0].constantize.find(v[1]))
-          else # regular singular association
+          elsif !column.association.source_reflection&.options&.include?(:through) # regular singular association, or one-level through association
             record.send("#{k}=", column.association.klass.find(v))
 
             # setting the belongs_to side of a has_one isn't safe. if the has_one was already

data/lib/active_scaffold/core.rb

@@ -4,12 +4,44 @@ module ActiveScaffold
       base.extend(ClassMethods)
     end
 
+    def setup_user_settings
+      config = self.class.active_scaffold_config
+      config.new_user_settings(user_settings_storage, params)
+      return if 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
+
     def active_scaffold_config
-      self.class.active_scaffold_config
+      @active_scaffold_config ||= begin
+        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
+    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
@@ -29,8 +61,13 @@ module ActiveScaffold
         active_scaffold_superclasses_blocks.each { |superblock| active_scaffold_config.configure(&superblock) }
         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
+        active_scaffold_config.class.after_config_callbacks.each do |callback|
+          if callback.is_a?(Proc)
+            callback.call
+          elsif active_scaffold_config.respond_to?(callback)
+            active_scaffold_config.send(callback)
+          end
+        end
 
         # 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 +83,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 +97,13 @@ module ActiveScaffold
           end
         end
         _add_sti_create_links if active_scaffold_config.add_sti_create_links?
+        return unless ActiveScaffold.threadsafe
+        active_scaffold_config._cache_lazy_values
+        active_scaffold_config.deep_freeze!
       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')
@@ -87,7 +128,8 @@ module ActiveScaffold
         end
       end
 
-      # Create the automatic column links. Note that this has to happen when configuration is *done*, because otherwise the Nested module could be disabled. Actually, it could still be disabled later, couldn't it?
+      # Create the automatic column links. Note that this has to happen when configuration is *done*,
+      # because otherwise the Nested module could be disabled. Actually, it could still be disabled later, couldn't it?
       def links_for_associations
         return unless active_scaffold_config.actions.include?(:list) && active_scaffold_config.actions.include?(:nested)
         active_scaffold_config.columns.each do |column|
@@ -122,10 +164,13 @@ module ActiveScaffold
         else
           actions = controller.active_scaffold_config.actions unless controller == :polymorph
           actions ||= %i[create update show]
-          column.actions_for_association_links.delete :new unless actions.include? :create
-          column.actions_for_association_links.delete :edit unless actions.include? :update
-          column.actions_for_association_links.delete :show unless actions.include? :show
-          ActiveScaffold::DataStructures::ActionLink.new(nil, options.merge(:html_options => {:class => column.name}))
+          controller_actions = column.actions_for_association_links
+          controller_actions = controller_actions.dup if controller_actions.frozen?
+          controller_actions.delete :new unless actions.include? :create
+          controller_actions.delete :edit unless actions.include? :update
+          controller_actions.delete :show unless actions.include? :show
+          options.merge!(html_options: {class: column.name}, controller_actions: Set.new(controller_actions))
+          ActiveScaffold::DataStructures::ActionLink.new(nil, options)
         end
       end
 
@@ -167,17 +212,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
 
@@ -198,12 +240,9 @@ module ActiveScaffold
             controller = "#{namespace}#{controller_name.camelize}Controller".constantize
           rescue NameError => error
             # Only rescue NameError associated with the controller constant not existing - not other compile errors
-            if error.message["uninitialized constant #{controller}"]
-              error_message << "#{namespace}#{controller_name.camelize}Controller"
-              next
-            else
-              raise
-            end
+            raise unless error.message["uninitialized constant #{controller}"]
+            error_message << "#{namespace}#{controller_name.camelize}Controller"
+            next
           end
           raise ActiveScaffold::ControllerNotFound, "#{controller} missing ActiveScaffold", caller unless controller.uses_active_scaffold?
           unless controller.active_scaffold_config.model.to_s == klass.to_s
@@ -216,9 +255,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
@@ -226,13 +265,13 @@ module ActiveScaffold
     end
 
     def self.mongoid_column_type_cast(value, column)
+      return Time.zone.at(value.to_i) if value =~ /\A\d+\z/ && [Time, DateTime].include?(column.type)
       column.type.evolve value
     end
 
     def self.active_record_column_type_cast(value, column)
-      if Rails.version < '4.2'
-        column.type_cast value
-      elsif Rails.version < '5.0'
+      return Time.zone.at(value.to_i) if value =~ /\A\d+\z/ && %i[time datetime].include?(column.type)
+      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 = options[:core_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