active_scaffold 3.5.5 → 3.6.0.pre

data/lib/active_scaffold/bridges/paperclip/list_ui.rb

@@ -6,7 +6,7 @@ module ActiveScaffold
         return nil unless paperclip.file?
         content =
           if paperclip.styles.include?(ActiveScaffold::Bridges::Paperclip::PaperclipBridgeHelpers.thumbnail_style)
-            image_tag(paperclip.url(ActiveScaffold::Bridges::Paperclip::PaperclipBridgeHelpers.thumbnail_style), :border => 0)
+            image_tag(paperclip.url(ActiveScaffold::Bridges::Paperclip::PaperclipBridgeHelpers.thumbnail_style), :border => 0, :alt => nil)
           else
             paperclip.original_filename
           end

data/lib/active_scaffold/bridges/paperclip/paperclip_bridge.rb

@@ -9,7 +9,7 @@ module ActiveScaffold
           update.multipart = true
           create.multipart = true
 
-          model.attachment_definitions.keys.each do |field|
+          model.attachment_definitions.each_key do |field|
             configure_paperclip_field(field.to_sym)
             # define the "delete" helper for use with active scaffold, unless it's already defined
             ActiveScaffold::Bridges::Paperclip::PaperclipBridgeHelpers.generate_delete_helper(model, field)

data/lib/active_scaffold/bridges/paperclip/paperclip_bridge_helpers.rb

@@ -6,7 +6,7 @@ module ActiveScaffold
         self.thumbnail_style = :thumbnail
 
         def self.generate_delete_helper(klass, field)
-          klass.class_eval <<-EOF, __FILE__, __LINE__ + 1 unless klass.method_defined?(:"delete_#{field}=")
+          klass.class_eval <<-END, __FILE__, __LINE__ + 1 unless klass.method_defined?(:"delete_#{field}=")
             attr_reader :delete_#{field}
 
             def delete_#{field}=(value)
@@ -16,7 +16,7 @@ module ActiveScaffold
               # passing nil to the file column causes the file to be deleted. Don't delete if we just uploaded a file!
               self.#{field} = nil unless self.#{field}.dirty?
             end
-          EOF
+          END
         end
       end
     end

data/lib/active_scaffold/bridges/record_select/helpers.rb

@@ -1,21 +1,21 @@
+require 'active_support/concern'
+
 class ActiveScaffold::Bridges::RecordSelect
   module Helpers
-    def self.included(base)
-      base.class_eval do
-        include FormColumnHelpers
-        include SearchColumnHelpers
-      end
+    extend ActiveSupport::Concern
+    included do
+      include FormColumnHelpers
+      include SearchColumnHelpers
     end
 
     module FormColumnHelpers
       # requires RecordSelect plugin to be installed and configured.
       def active_scaffold_input_record_select(column, options)
         record = options.delete(:object)
-        if column.association.try(:singular?)
-          multiple = false
-          multiple = column.options[:html_options][:multiple] if column.options[:html_options] && column.options[:html_options][:multiple]
+        if column.association&.singular?
+          multiple = column.options.dig(:html_options, :multiple)
           active_scaffold_record_select(record, column, options, record.send(column.name), multiple)
-        elsif column.association.try(:collection?)
+        elsif column.association&.collection?
           active_scaffold_record_select(record, column, options, record.send(column.name), true)
         else
           active_scaffold_record_select_autocomplete(record, column, options)

data/lib/active_scaffold/bridges/shared/date_bridge.rb

@@ -66,7 +66,7 @@ module ActiveScaffold
                                         :class => 'text-input', :id => nil)
             content_tag('span', range_controls.html_safe,
                         :id => "#{options[:id]}_range", :class => 'search-date-range',
-                        :style => (current_search['opt'] == 'RANGE') ? nil : 'display: none')
+                        :style => ('display: none' unless current_search['opt'] == 'RANGE'))
           end
 
           def column_datetime?(column)
@@ -120,9 +120,9 @@ module ActiveScaffold
                 column.search_sql.call(from_value, to_value, operator)
               else
                 if operator.nil?
-                  ['%{search_sql} BETWEEN ? AND ?', from_value.to_s(:db), to_value.to_s(:db)] unless from_value.nil? || to_value.nil?
+                  ['%<search_sql>s BETWEEN ? AND ?', from_value.to_s(:db), to_value.to_s(:db)] unless from_value.nil? || to_value.nil?
                 else
-                  ["%{search_sql} #{value['opt']} ?", from_value.to_s(:db)] unless from_value.nil?
+                  ["%<search_sql>s #{value['opt']} ?", from_value.to_s(:db)] unless from_value.nil?
                 end
               end
             end

data/lib/active_scaffold/bridges/usa_state_select/usa_state_select_helper.rb

@@ -23,7 +23,7 @@ module ActiveScaffold::Bridges
                           options_for_select([])
                         end
 
-        state_options += if priority_states && priority_states.include?(selected)
+        state_options += if priority_states&.include?(selected)
                            options_for_select(USASTATES - priority_states, :selected => selected)
                          else
                            options_for_select(USASTATES, :selected => selected)

data/lib/active_scaffold/config/base.rb

@@ -2,6 +2,7 @@ module ActiveScaffold::Config
   class Base
     include ActiveScaffold::Configurable
     extend ActiveScaffold::Configurable
+    NO_FORMATS = [].freeze
 
     def initialize(core_config)
       @core = core_config
@@ -37,8 +38,22 @@ module ActiveScaffold::Config
       @label.nil? ? model : as_(@label, :model => model)
     end
 
+    def model_id
+      (core || self).model_id
+    end
+
+    def user_settings_key
+      :"#{model_id}_#{self.class.name.underscore}"
+    end
+
     # the user property gets set to the instantiation of the local UserSettings class during the automatic instantiation of this class.
-    attr_accessor :user
+    def user
+      ActiveScaffold::Registry.user_settings[user_settings_key]
+    end
+
+    def new_user_settings(storage, params)
+      ActiveScaffold::Registry.user_settings[user_settings_key] = self.class::UserSettings.new(self, storage, params)
+    end
 
     # define a default action_group for this action
     # e.g. 'members.crud'
@@ -47,10 +62,39 @@ module ActiveScaffold::Config
     # action_group this action should belong to
     attr_accessor :action_group
 
+    def formats
+      return @formats || NO_FORMATS if frozen?
+      @formats ||= NO_FORMATS.dup
+    end
+    attr_writer :formats
+
     class UserSettings
+      # define setter and getter for names
+      # values will be saved for current request only
+      # getter will return value set with setter, or value from conf
+      def self.user_attr(*names)
+        attr_writer(*names)
+        names.each do |name|
+          define_method(name) do
+            instance_variable_defined?("@#{name}") ? instance_variable_get("@#{name}") : @conf.send(name)
+          end
+        end
+      end
+
+      # define setter and getter for names
+      # values will be saved in session if store_user_settings is enabled,
+      # in other case for current request only
+      # getter will return value set with setter, or value from conf
+      def self.session_attr(*names)
+        names.each do |name|
+          define_method(name) { |value| self[name] = value }
+          define_method(name) { key?(name) ? self[name] : @conf.send(name) }
+        end
+      end
+
       def initialize(conf, storage, params, action = :base)
         # the session hash relevant to this action
-        @session = storage
+        @storage = storage
         # all the request params
         @params = params
         # the configuration object for this action
@@ -58,51 +102,75 @@ module ActiveScaffold::Config
         @action = action.to_s
       end
 
+      def user
+        self
+      end
+
+      def core
+        @conf.core.user
+      end
+
       def [](key)
-        @session[@action][key] if @action && @session[@action]
+        @storage[@action][key.to_s] if @action && @storage[@action]
       end
 
       def []=(key, value)
-        @session[@action] ||= {}
+        @storage[@action] ||= {}
         if value
-          @session[@action][key] = value
+          @storage[@action][key.to_s] = value
         else
-          @session[@action].delete key
-          @session.delete @action if @session[@action].empty?
+          @storage[@action].delete key.to_s
+          @storage.delete @action if @storage[@action].empty?
         end
       end
-    end
 
-    def formats
-      @formats ||= []
+      def key?(key)
+        @storage[@action].key? key.to_s if @action && @storage[@action]
+      end
+
+      def method_missing(name, *args)
+        @conf.respond_to?(name, true) ? @conf.send(name, *args) : super
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        @conf.respond_to?(name, include_all) || super
+      end
     end
-    attr_writer :formats
 
     private
 
     def build_action_columns(val)
-      columns =
-        if val.is_a?(ActiveScaffold::DataStructures::ActionColumns)
-          val.dup
-        else
-          ActiveScaffold::DataStructures::ActionColumns.new(*val)
-        end
-      columns.action = self
-      columns.set_columns(@core.columns)
-      columns
+      @core.build_action_columns self, val
     end
 
+    class_attribute :columns_collections
+
     def self.columns_accessor(*names, &block)
       options = names.extract_options!
+      self.columns_collections = ((columns_collections || []) + names).uniq
       names.each do |name|
         var = "@#{name}"
         define_method "#{name}=" do |val|
           if instance_variable_defined?(var)
             instance_variable_get(var).set_values(*val)
+            instance_variable_get(var)
           else
             instance_variable_set(var, build_action_columns(val))
           end
-          instance_variable_get(var)
+        end
+
+        if self::UserSettings == ActiveScaffold::Config::Base::UserSettings
+          const_set 'UserSettings', Class.new(ActiveScaffold::Config::Base::UserSettings)
+        end
+
+        self::UserSettings.class_eval do
+          define_method "#{name}=" do |val|
+            instance_variable_set var, ::CowProxy.wrap(build_action_columns(val))
+          end
+          define_method name do
+            instance_variable_get(var) ||
+              instance_variable_set(var, ::CowProxy.wrap(@conf.send(name)))
+          end
         end
 
         return if method_defined? name

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,12 @@ module ActiveScaffold::Config
     cattr_accessor :highlight_messages, instance_accessor: false
     @@highlight_messages = nil
 
+    def self.freeze
+      super
+      security.freeze
+      column.freeze
+    end
+
     # instance-level configuration
     # ----------------------------
 
@@ -182,12 +193,17 @@ 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
+      # ensure member and collection groups are cached, if no custom link has been added
+      action_links.member
+      action_links.collection
+      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
 
@@ -205,28 +221,57 @@ 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?(action_name.to_s.underscore.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
+      if @actions.include? underscored_name
+        @action_configs ||= {}
+        @action_configs[underscored_name] ||= klass.new(self)
+      else
+        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
     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
+      klass = config_class(name) if @@actions.include?(name.to_s.underscore)
+      klass || 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 +292,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 +320,58 @@ 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
+    end
+
+    class UserColumns
+      def initialize(columns)
+        @global_columns = columns
+        @columns = {}
+      end
+
+      def [](name)
+        @columns[name.to_sym] ||= CowProxy.wrap @global_columns[name]
+      end
+
+      def method_missing(name, *args)
+        if @global_columns.respond_to?(name, true)
+          @global_columns.send(name, *args)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        @global_columns.respond_to?(name, include_all) || super
+      end
+    end
   end
 end