active_scaffold 3.5.4 → 3.6.0

data/lib/active_scaffold/helpers/show_column_helpers.rb

@@ -14,12 +14,10 @@ module ActiveScaffold
         # second, check if the dev has specified a valid list_ui for this column
         elsif column.show_ui && (method = override_show_column_ui(column.show_ui))
           send(method, value_record, column)
+        elsif column.column && (method = override_show_column_ui(column.column.type))
+          send(method, value_record, column)
         else
-          if column.column && (method = override_show_column_ui(column.column.type))
-            send(method, value_record, column)
-          else
-            get_column_value(record, column)
-          end
+          get_column_value(record, column)
         end
       end
 

data/lib/active_scaffold/helpers/view_helpers.rb

@@ -17,17 +17,10 @@ module ActiveScaffold
       ## Delegates
       ##
 
-      # access to the configuration variable
-      def active_scaffold_config
-        controller.class.active_scaffold_config
-      end
-
-      def active_scaffold_config_for(*args)
-        controller.class.active_scaffold_config_for(*args)
-      end
-
-      def active_scaffold_controller_for(*args)
-        controller.class.active_scaffold_controller_for(*args)
+      def active_scaffold_controller_for(klass)
+        ActiveScaffold::Registry.cache :as_controller, klass do
+          controller.class.active_scaffold_controller_for(klass)
+        end
       end
 
       ##
@@ -44,8 +37,11 @@ module ActiveScaffold
       # This is the template finder logic, keep it updated with however we find stuff in rails
       # currently this very similar to the logic in ActionBase::Base.render for options file
       def template_exists?(template_name, partial = false)
-        restore_view_paths, lookup_context.view_paths = lookup_context.view_paths, @_view_paths if @_view_paths
-        lookup_context.exists?(template_name, '', partial).tap do
+        if @_view_paths
+          restore_view_paths = lookup_context.view_paths
+          lookup_context.view_paths = @_view_paths
+        end
+        (@_lookup_context || lookup_context).exists?(template_name, '', partial).tap do
           lookup_context.view_paths = restore_view_paths if @_view_paths
         end
       end
@@ -62,17 +58,22 @@ module ActiveScaffold
 
       # a general-use loading indicator (the "stuff is happening, please wait" feedback)
       def loading_indicator_tag(options)
-        image_tag 'active_scaffold/indicator.gif', :style => 'visibility:hidden;', :id => loading_indicator_id(options), :alt => 'loading indicator', :class => 'loading-indicator'
+        # it's call many times and we can cache same result
+        @_loading_indicator_path ||= image_path('active_scaffold/indicator.gif')
+        # it's call many times in long lists, image_tag is a bit slower
+        tag :img, src: @_loading_indicator_path, style: 'visibility:hidden;', id: loading_indicator_id(options), alt: 'loading indicator', class: 'loading-indicator'
       end
 
       # Creates a javascript-based link that toggles the visibility of some element on the page.
-      # By default, it toggles the visibility of the sibling after the one it's nested in. You may pass custom javascript logic in options[:of] to change that, though. For example, you could say :of => '$("my_div_id")'.
+      # By default, it toggles the visibility of the sibling after the one it's nested in.
+      # You may pass custom javascript logic in options[:of] to change that, though. For example, you could say :of => '$("my_div_id")'.
       # You may also flag whether the other element is visible by default or not, and the initial text will adjust accordingly.
       def link_to_visibility_toggle(id, options = {})
-        options[:default_visible] = true if options[:default_visible].nil?
         options[:hide_label] ||= as_(:hide)
         options[:show_label] ||= as_(:show_block)
-        link_to options[:default_visible] ? options[:hide_label] : options[:show_label], '#', :data => {:show => options[:show_label], :hide => options[:hide_label], :toggable => id}, :style => 'display: none;', :class => 'as-js-button visibility-toggle'
+        label = options[:default_visible].nil? || options[:default_visible] ? options[:hide_label] : options[:show_label]
+        data = {:show => options[:show_label], :hide => options[:hide_label], :toggable => id}
+        link_to label, '#', :data => data, :style => 'display: none;', :class => 'as-js-button visibility-toggle'
       end
 
       def list_row_class_method(record)
@@ -86,6 +87,10 @@ module ActiveScaffold
         class_override_helper ? send(class_override_helper, record) : ''
       end
 
+      def list_row_attributes(tr_class, tr_id, data_refresh)
+        {class: "record #{tr_class}", id: tr_id, data: {refresh: data_refresh}}
+      end
+
       def column_attributes(column, record)
         method = override_helper column, 'column_attributes'
         return send(method, record) if method
@@ -93,15 +98,14 @@ module ActiveScaffold
       end
 
       def column_class(column, column_value, record)
-        @_column_classes ||= {}
-        @_column_classes[column.name] ||= begin
+        classes = ActiveScaffold::Registry.cache :column_classes, column.cache_key do
           classes = "#{column.name}-column "
           classes << 'sorted ' if active_scaffold_config.actions.include?(:list) && active_scaffold_config.list.user.sorting.sorts_on?(column)
           classes << 'numeric ' if column.number?
-          classes << column.css_class unless column.css_class.nil? || column.css_class.is_a?(Proc)
+          classes << column.css_class << ' ' unless column.css_class.nil? || column.css_class.is_a?(Proc)
           classes
         end
-        classes = "#{@_column_classes[column.name]} "
+        classes = classes.dup
         classes << 'empty ' if column_empty? column_value
         classes << 'in_place_editor_field ' if inplace_edit?(record, column) || column.list_ui == :marked
         if column.css_class.is_a?(Proc)
@@ -124,18 +128,23 @@ module ActiveScaffold
         classes
       end
 
+      def as_main_div_data
+        params[:eid] ? {eid: id_from_controller(params[:eid])} : {}
+      end
+
       def column_empty?(column_value)
+        @_empty_values ||= ['&nbsp;', empty_field_text].compact
         empty = column_value.nil?
         # column_value != false would force boolean to be cast to integer
         # when comparing to column_value of IPAddr class (PostgreSQL inet column type)
-        # rubocop:disable Style/YodaCondition
-        empty ||= false != column_value && column_value.blank?
-        empty ||= ['&nbsp;', empty_field_text].include? column_value if column_value.is_a? String
+        empty ||= false != column_value && column_value.blank? # rubocop:disable Style/YodaCondition
+        empty ||= @_empty_values.include? column_value
         empty
       end
 
       def empty_field_text
-        active_scaffold_config.list.empty_field_text if active_scaffold_config.actions.include?(:list)
+        return @_empty_field_text if defined? @_empty_field_text
+        @_empty_field_text = (active_scaffold_config.list.empty_field_text if active_scaffold_config.actions.include?(:list))
       end
 
       def as_slider(options)
@@ -156,11 +165,7 @@ module ActiveScaffold
       end
 
       def override_helper(column, suffix)
-        hash = @_override_helpers ||= {}
-        hash = hash[suffix] ||= {}
-        hash = hash[column.active_record_class.name] ||= {}
-        return hash[column.name] if hash.include? column.name
-        hash[column.name] = begin
+        ActiveScaffold::Registry.cache suffix, column.cache_key do
           method_with_class = override_helper_name(column, suffix, true)
           if respond_to?(method_with_class)
             method_with_class
@@ -173,7 +178,7 @@ module ActiveScaffold
 
       def history_state
         if active_scaffold_config.store_user_settings
-          state = {page: @page.try(:number)}
+          state = {page: @page&.number}
           state[:search] = search_params if respond_to?(:search_params) && search_params.present?
           if active_scaffold_config.list.user.user_sorting?
             column, state[:sort_direction] = active_scaffold_config.list.user.sorting.first
@@ -189,12 +194,12 @@ module ActiveScaffold
 
       def display_message(message)
         message = safe_join message, tag(:br) if message.is_a?(Array)
-        if (highlights = active_scaffold_config.highlight_messages)
+        if (highlights = active_scaffold_config.user.highlight_messages)
           message = highlights.inject(message) do |msg, (phrases, highlighter)|
             highlight(msg, phrases, highlighter || {})
           end
         end
-        if (format = active_scaffold_config.timestamped_messages)
+        if (format = active_scaffold_config.user.timestamped_messages)
           format = :short if format == true
           messages = [content_tag(:div, l(Time.current, :format => format), :class => 'timestamp')]
           messages << content_tag(:div, message, :class => 'message-content')
@@ -211,9 +216,7 @@ module ActiveScaffold
           object = instance_variable_get("@#{object}") unless object.respond_to?(:to_model)
           object = convert_to_model(object)
 
-          if object.class.respond_to?(:model_name)
-            options[:object_name] ||= object.class.model_name.human.downcase
-          end
+          options[:object_name] ||= object.class.model_name.human.downcase if object.class.respond_to?(:model_name)
 
           object
         end

data/lib/active_scaffold/marked_model.rb

@@ -24,11 +24,11 @@ module ActiveScaffold
 
     module ClassMethods
       def marked_records
-        Thread.current[:marked_records] ||= {}
+        ActiveScaffold::Registry.marked_records ||= {}
       end
 
       def marked_records=(marked)
-        Thread.current[:marked_records] = marked
+        ActiveScaffold::Registry.marked_records = marked
       end
 
       def marked_record_ids

data/lib/active_scaffold/orm_checks.rb

@@ -43,7 +43,7 @@ module ActiveScaffold
         elsif mongoid? klass
           klass.fields
         else
-          []
+          {}
         end
       end
 
@@ -69,13 +69,9 @@ module ActiveScaffold
 
       def type_for_attribute(klass, column_name)
         if active_record? klass
-          if klass.respond_to? :type_for_attribute
-            klass.type_for_attribute column_name.to_s
-          else # Rails.version < 4.2
-            klass.column_types[column_name.to_s]
-          end
+          klass.type_for_attribute column_name.to_s
         elsif mongoid? klass
-          klass.fields[column_name.to_s].type
+          klass.fields[column_name.to_s]&.type
         end
       end
 

data/lib/active_scaffold/paginator.rb

@@ -19,16 +19,15 @@ class Paginator
   #     (and the number of items to show per page, for
   #     convenience, if the arity is 2)
   def initialize(count, per_page, &select)
-    @count, @per_page = count, per_page
-    unless select
-      raise MissingSelectError, 'Must provide block to select data for each page'
-    end
+    @count = count
+    @per_page = per_page
+    raise MissingSelectError, 'Must provide block to select data for each page' unless select
     @select = select
   end
 
   # Total number of pages
   def number_of_pages
-    (@count / @per_page).to_i + (@count % @per_page > 0 ? 1 : 0)
+    (@count / @per_page).to_i + ((@count % @per_page).positive? ? 1 : 0)
   end
 
   # First page object
@@ -57,7 +56,7 @@ class Paginator
 
   # Retrieve page object by number
   def page(number)
-    number = (n = number.to_i) > 0 ? n : 1
+    number = [1, number.to_i].max
     Page.new(self, number) do
       offset = (number - 1) * @per_page
       args = [offset]
@@ -80,7 +79,8 @@ class Paginator
     attr_reader :number, :pager
 
     def initialize(pager, number, &select) #:nodoc:
-      @pager, @number = pager, number
+      @pager = pager
+      @number = number
       @offset = (number - 1) * pager.per_page
       @select = select
     end

data/lib/active_scaffold/registry.rb

@@ -0,0 +1,33 @@
+module ActiveScaffold
+  class Registry
+    extend ActiveSupport::PerThreadRegistry
+    attr_accessor :current_user_proc, :current_ability_proc, :marked_records
+
+    def user_settings
+      @user_settings ||= {}
+    end
+
+    def constraint_columns
+      @constraint_columns ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    def unauthorized_columns
+      @unauthorized_columns ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    def cache(kind, key = nil, &block)
+      unless key
+        key = kind
+        kind = :cache
+      end
+      @cache ||= {}
+      cache = @cache[kind] ||= {}
+      return cache[key] if cache.include? key
+      cache[key] ||= yield
+    end
+
+    def self.instance
+      RequestStore.store[@per_thread_registry_key] ||= new
+    end
+  end
+end

data/lib/active_scaffold/responds_to_parent.rb

@@ -9,11 +9,12 @@ module ActiveScaffold
       return unless performed?
 
       # Either pull out a redirect or the request body
-      script = if response.headers['Location']
-                 "document.location.href = '#{self.class.helpers.escape_javascript response.headers.delete('Location').to_s}'"
-               else
-                 response.body || ''
-                end
+      script =
+        if response.headers['Location']
+          "document.location.href = '#{self.class.helpers.escape_javascript response.headers.delete('Location').to_s}'"
+        else
+          response.body || ''
+        end
       response.status = 200 if (300...400).cover? response.status
 
       # Eval in parent scope and replace document location of this frame
@@ -34,12 +35,8 @@ module ActiveScaffold
         instance_variable_set(:@_response_body, nil)
       end
 
-      # We're returning HTML instead of JS now
-      if Rails.version < '4.1'
-        render text: script, content_type: 'text/html' # remove when rails 4.0 is not supported
-      else
-        render html: script.html_safe, content_type: 'text/html' # rubocop:disable Rails/OutputSafety
-      end
+      # We're returning HTML instead of JS now, content_type needed if not inside respond_to block
+      render html: script.html_safe, content_type: 'text/html' # rubocop:disable Rails/OutputSafety
     end
     alias respond_to_parent responds_to_parent
   end

data/lib/active_scaffold/tableless.rb

@@ -1,10 +1,8 @@
-class ActiveScaffold::Tableless < ActiveRecord::Base
+class ActiveScaffold::Tableless < ActiveRecord::Base # rubocop:disable Rails/ApplicationRecord
   class AssociationScope < ActiveRecord::Associations::AssociationScope
-    if defined?(ActiveRecord::Associations::AssociationScope::INSTANCE) # rails >= 4.1
-      INSTANCE = respond_to?(:create) ? create : new # create for rails >= 4.2
-      def self.scope(association, connection)
-        INSTANCE.scope association, connection
-      end
+    INSTANCE = create
+    def self.scope(association, connection)
+      INSTANCE.scope association, connection
     end
 
     if Rails.version < '5.0.0'
@@ -19,11 +17,9 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
         end
       end
 
-      if Rails.version >= '4.1'
-        def add_constraints(scope, owner, assoc_klass, refl, tracker)
-          tracker.instance_variable_set(:@assoc_klass, assoc_klass)
-          super
-        end
+      def add_constraints(scope, owner, assoc_klass, refl, tracker)
+        tracker.instance_variable_set(:@assoc_klass, assoc_klass)
+        super
       end
     end
   end
@@ -38,6 +34,12 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
     def columns(table_name)
       klass.columns
     end
+
+    if Rails.version >= '6.0.0'
+      def data_sources
+        klass ? [klass.table_name] : []
+      end
+    end
   end
 
   class Column < ActiveRecord::ConnectionAdapters::Column
@@ -46,7 +48,7 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
         metadata = ActiveRecord::Base.connection.send :fetch_type_metadata, sql_type
         super(name, default, metadata, null)
       end
-    elsif Rails.version >= '4.2.0'
+    else
       def initialize(name, default, sql_type = nil, null = true)
         cast_type = ActiveRecord::Base.connection.send :lookup_cast_type, sql_type
         super(name, default, cast_type, sql_type, null)
@@ -55,16 +57,18 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
   end
 
   module Tableless
-    def association_scope
-      @association_scope ||= overrided_association_scope if klass < ActiveScaffold::Tableless
-      super
-    end
+    if Rails.version < '5.2.0'
+      def skip_statement_cache?
+        klass < ActiveScaffold::Tableless ? true : super
+      end
 
-    def overrided_association_scope
-      if AssociationScope.respond_to?(:scope) # rails >= 4.1
-        AssociationScope.scope(self, klass.connection)
-      else # rails < 4.1
-        AssociationScope.new(self).scope
+      def association_scope
+        @association_scope ||= AssociationScope.scope(self, klass.connection) if klass < ActiveScaffold::Tableless
+        super
+      end
+    else
+      def skip_statement_cache?(scope)
+        klass < ActiveScaffold::Tableless ? true : super
       end
     end
 
@@ -84,19 +88,19 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
   end
 
   module TablelessCollectionAssociation
-    def get_records
+    def get_records # rubocop:disable Naming/AccessorMethodName
       klass < ActiveScaffold::Tableless ? scope.to_a : super
     end
   end
 
   module CollectionAssociation
     def self.included(base)
-      base.prepend TablelessCollectionAssociation if Rails.version >= '4.2'
+      base.prepend TablelessCollectionAssociation
     end
   end
 
   module TablelessSingularAssociation
-    def get_records
+    def get_records # rubocop:disable Naming/AccessorMethodName
       klass < ActiveScaffold::Tableless ? scope.limit(1).to_a : super
     end
   end
@@ -110,20 +114,13 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
   module RelationExtension
     attr_reader :conditions
 
-    if Rails.version >= '5.0'
-      def initialize(klass, table, predicate_builder, values = {})
-        super
-        @conditions ||= []
-      end
-    else
-      def initialize(klass, table)
-        super
-        @conditions ||= []
-      end
+    def initialize(klass, *)
+      super
+      @conditions ||= []
     end
 
     def initialize_copy(other)
-      @conditions = @conditions.try(:dup) || []
+      @conditions = @conditions&.dup || []
       super
     end
 
@@ -135,9 +132,9 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
       self
     end
 
-    def merge(r)
+    def merge(rel)
       super.tap do |merged|
-        merged.conditions.concat r.conditions unless r.nil? || r.is_a?(Array)
+        merged.conditions.concat rel.conditions unless rel.nil? || rel.is_a?(Array)
       end
     end
 
@@ -158,50 +155,72 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
     def execute_simple_calculation(operation, column_name, distinct)
       @klass.execute_simple_calculation(self, operation, column_name, distinct)
     end
+
+    def implicit_order_column
+      @klass.implicit_order_column
+    end
+
+    def exists?
+      limit(1).to_a.present?
+    end
   end
 
-  class Relation < ActiveRecord::Relation
+  class Relation < ::ActiveRecord::Relation
     include RelationExtension
   end
   class << self
     private
 
     def relation
-      args = [self, arel_table]
-      args << predicate_builder if Rails.version >= '5.0.0'
+      args = [self]
+      if Rails.version < '5.2.0'
+        args << arel_table
+        args << predicate_builder if Rails.version >= '5.0.0'
+      end
       ActiveScaffold::Tableless::Relation.new(*args)
     end
+
+    if Rails.version >= '5.2'
+      def cached_find_by_statement(key, &block)
+        StatementCache.new(key, self, &block)
+      end
+    end
   end
 
   class StatementCache
-    def initialize(key)
+    def initialize(key, model = nil)
       @key = key
+      @model = model
     end
 
-    def execute(values, model, connection)
-      model.where(@key => values)
+    if Rails.version < '5.2' # 5.0 and 5.1
+      def execute(values, model, connection)
+        model.where(@key => values)
+      end
+    else
+      def execute(values, connection)
+        @model.where(@key => values)
+      end
     end
   end
 
-  unless Rails.version < '4.2'
-    def self.columns_hash
-      if self < ActiveScaffold::Tableless
-        @columns_hash ||= Hash[columns.map { |c| [c.name, c] }]
-      else
-        super
-      end
-    end
-    if Rails.version >= '5.0'
-      def self.initialize_find_by_cache
-        @find_by_statement_cache = {
-          true => Hash.new { |h, k| h[k] = StatementCache.new(k) },
-          false => Hash.new { |h, k| h[k] = StatementCache.new(k) }
-        }
-      end
+  def self.columns_hash
+    if self < ActiveScaffold::Tableless
+      @columns_hash ||= Hash[columns.map { |c| [c.name, c] }]
     else
-      def self.initialize_find_by_cache
-        self.find_by_statement_cache = Hash.new { |h, k| h[k] = StatementCache.new(k) }
-      end
+      super
+    end
+  end
+  if Rails.version < '5.0' # 4.2.x
+    def self.initialize_find_by_cache
+      self.find_by_statement_cache = Hash.new { |h, k| h[k] = StatementCache.new(k) } # rubocop:disable Rails/DynamicFindBy
+    end
+  elsif Rails.version < '5.2' # 5.0 and 5.1
+    def self.initialize_find_by_cache
+      @find_by_statement_cache = {
+        true => Hash.new { |h, k| h[k] = StatementCache.new(k) },
+        false => Hash.new { |h, k| h[k] = StatementCache.new(k) }
+      }
     end
   end
 
@@ -236,11 +255,10 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
   end
 
   def self.execute_simple_calculation(relation, operation, column_name, distinct)
-    if operation == 'count' && [relation.klass.primary_key, :all].include?(column_name)
-      find_all(relation).size
-    else
+    unless operation == 'count' && [relation.klass.primary_key, :all].include?(column_name)
       raise "self.execute_simple_calculation must be implemented in a Tableless model to support #{operation} #{column_name}#{' distinct' if distinct} columns"
     end
+    find_all(relation).size
   end
 
   def destroy
@@ -250,10 +268,8 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
   def _create_record #:nodoc:
     run_callbacks(:create) {}
   end
-  alias create_record _create_record # for rails4 < 4.0.6, < 4.1.2
 
   def _update_record(*) #:nodoc:
     run_callbacks(:update) {}
   end
-  alias update_record _update_record # for rails4 < 4.0.6, < 4.1.2
 end