active_scaffold 3.7.12 → 4.0.0.rc1

data/lib/active_scaffold/data_structures/columns.rb

@@ -57,6 +57,7 @@ module ActiveScaffold::DataStructures
       klass = column.association.klass
       columns.each do |col|
         next if find_by_name col
+
         @set[col.to_sym] = ActiveScaffold::DataStructures::Column.new(col, klass, column.association)
       end
     end
@@ -77,8 +78,8 @@ module ActiveScaffold::DataStructures
     end
     alias [] find_by_name
 
-    def each
-      @set.each_value { |name| yield name }
+    def each(&block)
+      @set.each_value(&block)
     end
 
     def _inheritable

data/lib/active_scaffold/data_structures/nested_info.rb

@@ -18,7 +18,7 @@ module ActiveScaffold::DataStructures
     end
 
     def to_params
-      {:parent_scaffold => parent_scaffold.controller_path}
+      {parent_scaffold: parent_scaffold.controller_path}
     end
 
     def new_instance?
@@ -87,7 +87,7 @@ module ActiveScaffold::DataStructures
       setup_constrained_fields
     end
 
-    delegate :name, :belongs_to?, :has_one?, :has_many?, :habtm?, :readonly?, :to => :association
+    delegate :name, :belongs_to?, :has_one?, :has_many?, :habtm?, :readonly?, to: :association
 
     # A through association with has_one or has_many as source association
     # create cannot be called in nested through associations, and not-nested through associations, unless:
@@ -108,7 +108,7 @@ module ActiveScaffold::DataStructures
       return false unless association.source_reflection.collection? # create allowed if source is singular, rails creates joint model
 
       # create allowed only if through reflection in record to be created is included in create columns
-      !child_association || !columns.include?(child_association.through_reflection.name)
+      !child_association || columns.exclude?(child_association.through_reflection.name)
     end
 
     def create_through_singular?
@@ -146,13 +146,14 @@ module ActiveScaffold::DataStructures
     def default_sorting(chain)
       return @default_sorting if defined? @default_sorting
       return unless association.scope.is_a?(Proc) && chain.respond_to?(:values) && chain.values[:order]
+
       @default_sorting = chain.values[:order]
       @default_sorting = @default_sorting.map(&:to_sql) if @default_sorting[0].is_a? Arel::Nodes::Node
       @default_sorting = @default_sorting.join(', ')
     end
 
     def to_params
-      super.merge(:association => @association.name, @param_name => parent_id)
+      super.merge(association: @association.name, @param_name => parent_id)
     end
 
     protected
@@ -177,7 +178,7 @@ module ActiveScaffold::DataStructures
     end
 
     def to_params
-      super.merge(:named_scope => @scope)
+      super.merge(named_scope: @scope)
     end
 
     def name

data/lib/active_scaffold/data_structures/proxy_column.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ActiveScaffold::DataStructures
+  class ProxyColumn
+    COPY_VARS = %i[@list_ui @list_ui_options @show_ui @show_ui_options @search_ui @search_ui_options @search_joins].freeze
+    def initialize(column)
+      @column = column
+      # without override_or_delegate, the methods won't use column's values if they are set
+      # with override_or_delegate, if they had no value, they won't return overrided form_ui
+      # the easier way is copying variables to proxy object
+      (column.instance_variables & COPY_VARS).each do |var|
+        instance_variable_set(var, column.instance_variable_get(var))
+      end
+    end
+
+    def self.attr_reader(*names)
+      names.each do |name|
+        define_method name do
+          instance_variable_defined?(:"@#{name}") ? instance_variable_get(:"@#{name}") : @column.send(name)
+        end
+      end
+    end
+
+    def self.attr_accessor(*names)
+      attr_reader(*names)
+      attr_writer(*names)
+    end
+
+    def self.override_or_delegate(*names)
+      location = caller_locations(1, 1).first
+      method_def = names.map do |name|
+        "def #{name}(...)
+            instance_variable_defined?(\"@#{name.to_s.gsub(/\?$/, '')}\") ? super : @column.send(\"#{name}\", ...)
+          end"
+      end
+
+      module_eval method_def.join(';'), location.path, location.lineno
+      names
+    end
+
+    include Column::ProxyableMethods
+
+    def method_missing(name, ...)
+      if respond_to_missing?(name, true)
+        @column.send(name, ...)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_all = false)
+      (!name.match?(/[!=]$/) && @column.respond_to?(name, include_all)) || super
+    end
+
+    def params=(value)
+      @params = Set.new(*value)
+    end
+    attr_reader :params, :options
+
+    override_or_delegate :required?, :label, :description, :placeholder, :sort, :associated_number?,
+                         :show_blank_record?, :number?, :search_sql, :link
+    delegate :==, to: :@column
+
+    def is_a?(klass)
+      super || @column.is_a?(klass)
+    end
+  end
+end

data/lib/active_scaffold/data_structures/set.rb

@@ -43,13 +43,12 @@ module ActiveScaffold::DataStructures
     # returns the item of the given name.
     def find_by_name(name)
       # this works because of `def item.=='
-      item = @set.find { |c| c == name }
-      item
+      @set.find { |c| c == name }
     end
     alias [] find_by_name
 
-    def each
-      @set.each { |i| yield i }
+    def each(&block)
+      @set.each(&block)
     end
 
     # returns the number of items in the set
@@ -61,6 +60,10 @@ module ActiveScaffold::DataStructures
       @set.empty?
     end
 
+    def +(other)
+      self.class.new(@set, *other)
+    end
+
     protected
 
     attr_reader :set

data/lib/active_scaffold/data_structures/sorting.rb

@@ -4,8 +4,7 @@ module ActiveScaffold::DataStructures
     include Enumerable
     include ActiveScaffold::OrmChecks
 
-    attr_accessor :constraint_columns
-    attr_accessor :sorting_by_primary_key # enabled by default for postgres
+    attr_accessor :constraint_columns, :sorting_by_primary_key # sorting_by_primary_key enabled by default for postgres
     attr_reader :model
     alias active_record_class model
 
@@ -19,11 +18,13 @@ module ActiveScaffold::DataStructures
 
     def set_default_sorting
       return unless active_record?
+
       # fallback to setting primary key ordering
       setup_primary_key_order_clause
       model_scope = model.send(:build_default_scope)
       order_clause = model_scope.order_values.join(',') if model_scope
       return unless order_clause
+
       # If an ORDER BY clause is found set default sorting according to it
       set_sorting_from_order_clause(order_clause, model.table_name)
       @default_sorting = true
@@ -41,6 +42,7 @@ module ActiveScaffold::DataStructures
       column = get_column(column_name)
       raise ArgumentError, "Could not find column #{column_name}" if column.nil?
       raise ArgumentError, 'Sorting direction unknown' unless %i[ASC DESC].include? direction.to_sym
+
       @clauses << [column, direction] if column.sortable?
       raise ArgumentError, "Can't mix :method- and :sql-based sorting" if mixed_sorting?
     end
@@ -83,11 +85,12 @@ module ActiveScaffold::DataStructures
     def direction_of(column)
       clause = get_clause(column)
       return if clause.nil?
+
       clause[1]
     end
 
-    SORTING_STAGES = Hash[%w[reset ASC DESC reset].each_cons(2).to_a].freeze
-    DEFAULT_SORTING_STAGES = Hash[%w[ASC DESC ASC].each_cons(2).to_a].freeze
+    SORTING_STAGES = %w[reset ASC DESC reset].each_cons(2).to_h.freeze
+    DEFAULT_SORTING_STAGES = %w[ASC DESC ASC].each_cons(2).to_h.freeze
     def next_sorting_of(column, sorted_by_default)
       stages = sorted_by_default ? DEFAULT_SORTING_STAGES : SORTING_STAGES
       stages[direction_of(column)] || 'ASC'
@@ -103,8 +106,8 @@ module ActiveScaffold::DataStructures
     end
 
     # iterate over the clauses
-    def each
-      @clauses.each { |clause| yield clause }
+    def each(&block)
+      @clauses.each(&block)
     end
 
     def each_column
@@ -128,8 +131,10 @@ module ActiveScaffold::DataStructures
       order = []
       each do |sort_column, sort_direction|
         next if constraint_columns.include? sort_column.name
+
         sql = grouped_columns ? grouped_columns[sort_column.name] : sort_column.sort[:sql]
         next if sql.blank?
+
         sql = sql.to_sql if sql.respond_to?(:to_sql)
 
         parts = Array(sql).map do |column|
@@ -155,6 +160,7 @@ module ActiveScaffold::DataStructures
     def get_column(name_or_column)
       # it's a column
       return name_or_column if name_or_column.is_a? ActiveScaffold::DataStructures::Column
+
       # it's a name
       name_or_column = name_or_column.to_s.split('.').last if name_or_column.to_s.include? '.'
       @columns[name_or_column]
@@ -171,18 +177,20 @@ module ActiveScaffold::DataStructures
     def set_sorting_from_order_clause(order_clause, model_table_name = nil)
       clear
       order_clause.to_s.split(',').each do |criterion|
-        if criterion.present?
-          order_parts = extract_order_parts(criterion)
-          add(order_parts[:column_name], order_parts[:direction]) unless different_table?(model_table_name, order_parts[:table_name]) || get_column(order_parts[:column_name]).nil?
+        next if criterion.blank?
+
+        parts = extract_order_parts(criterion)
+        unless different_table?(model_table_name, parts[:table_name]) || get_column(parts[:column_name]).nil?
+          add(parts[:column_name], parts[:direction])
         end
       end
     end
 
     def extract_order_parts(criterion_parts)
-      column_name_part, direction_part = criterion_parts.strip.split(' ')
+      column_name_part, direction_part = criterion_parts.strip.split(' ') # rubocop:disable Style/RedundantArgument
       column_name_parts = column_name_part.split('.')
-      order = {:direction => extract_direction(direction_part),
-               :column_name => remove_quotes(column_name_parts.last)}
+      order = {direction: extract_direction(direction_part),
+               column_name: remove_quotes(column_name_parts.last)}
       order[:table_name] = remove_quotes(column_name_parts[-2]) if column_name_parts.length >= 2
       order
     end
@@ -213,6 +221,7 @@ module ActiveScaffold::DataStructures
 
     def setup_primary_key_order_clause
       return unless model.column_names.include?(model.primary_key)
+
       set([model.primary_key, 'ASC'])
       @primary_key_order_clause = clause
       @sorting_by_primary_key = postgres? # mandatory for postgres, so enabled by default

data/lib/active_scaffold/engine.rb

@@ -30,29 +30,29 @@ module ActiveScaffold
         require 'active_scaffold/extensions/unsaved_associated'
         require 'active_scaffold/extensions/unsaved_record'
         include ActiveScaffold::ActiveRecordPermissions::ModelUserAccess::Model
-        module ActiveRecord::Associations
-          Association.send :include, ActiveScaffold::Tableless::Association
-          CollectionAssociation.send :include, ActiveScaffold::Tableless::CollectionAssociation
-          SingularAssociation.send :include, ActiveScaffold::Tableless::SingularAssociation
+        ActiveRecord::Associations.module_eval do
+          self::Association.include ActiveScaffold::Tableless::Association
+          self::CollectionAssociation.include ActiveScaffold::Tableless::CollectionAssociation
+          self::SingularAssociation.include ActiveScaffold::Tableless::SingularAssociation
         end
-        module ActiveRecord::ConnectionAdapters
-          AbstractAdapter.send :include, ActiveScaffold::ConnectionAdapters::AbstractAdapter
-          if defined?(PostgreSQLAdapter)
-            PostgreSQLAdapter.send :include, ActiveScaffold::ConnectionAdapters::PostgreSQLAdapter
+
+        ActiveRecord::ConnectionAdapters.module_eval do
+          self::AbstractAdapter.include ActiveScaffold::ConnectionAdapters::AbstractAdapter
+          if const_defined?(:PostgreSQLAdapter)
+            self::PostgreSQLAdapter.include ActiveScaffold::ConnectionAdapters::PostgreSQLAdapter
           end
-          if defined?(SQLServerAdapter)
-            SQLServerAdapter.send :include, ActiveScaffold::ConnectionAdapters::SQLServerAdapter
+          if const_defined?(:SQLServerAdapter)
+            self::SQLServerAdapter.include ActiveScaffold::ConnectionAdapters::SQLServerAdapter
           end
         end
       end
     end
 
     initializer 'active_scaffold.assets' do
-      config.assets.precompile << 'active_scaffold/indicator.gif'
+      config.assets.precompile << 'active_scaffold_manifest.js' if Rails::VERSION::MAJOR < 7
     end
 
     initializer 'active_scaffold.extensions' do
-      require 'active_scaffold/extensions/cow_proxy'
       require 'active_scaffold/extensions/ice_nine'
       require 'active_scaffold/extensions/localize'
       require 'active_scaffold/extensions/paginator_extensions'

data/lib/active_scaffold/extensions/action_controller_rendering.rb

@@ -1,18 +1,18 @@
 # wrap the action rendering for ActiveScaffold controllers
 module ActiveScaffold
-  module ActionController #:nodoc:
+  module ActionController # :nodoc:
     def render(*args, &block)
       if self.class.uses_active_scaffold? && params[:adapter] && @rendering_adapter.nil? && request.xhr?
         @rendering_adapter = true # recursion control
         # if we need an adapter, then we render the actual stuff to a string and insert it into the adapter template
         opts = args.any? ? args.first : {}
 
-        render :partial => params[:adapter][1..-1],
-               :locals => {:payload => render_to_string(opts.merge(:layout => false), &block).html_safe}, # rubocop:disable Rails/OutputSafety
-               :use_full_path => true, :layout => false, :content_type => :html
+        render partial: params[:adapter][1..],
+               locals: {payload: render_to_string(opts.merge(layout: false), &block).html_safe}, # rubocop:disable Rails/OutputSafety
+               use_full_path: true, layout: false, content_type: :html
         @rendering_adapter = nil # recursion control
       else
-        super(*args, &block)
+        super
       end
     end
   end

data/lib/active_scaffold/extensions/action_controller_rescueing.rb

@@ -1,4 +1,4 @@
-module ActionController #:nodoc:
+module ActionController # :nodoc:
   class Base
     # adding to ActionController::Base so it can overrided in ApplicationController
     def deny_access

data/lib/active_scaffold/extensions/action_view_rendering.rb

@@ -2,14 +2,14 @@ module ActiveScaffold
   module LookupContext
     attr_accessor :last_template
 
-    def find_template(name, prefixes = [], partial = false, keys = [], options = {})
-      self.last_template = super(name, prefixes, partial, keys, options)
+    def find_template(name, prefixes = [], partial = false, keys = [], options = {}) # rubocop:disable Metrics, Style
+      self.last_template = super
     end
   end
 end
 
 # wrap the action rendering for ActiveScaffold views
-module ActiveScaffold #:nodoc:
+module ActiveScaffold # :nodoc:
   module RenderingHelper
     #
     # Adds two rendering options.
@@ -19,7 +19,7 @@ module ActiveScaffold #:nodoc:
     # This syntax skips all template overrides and goes directly to the provided ActiveScaffold templates.
     # Useful if you want to wrap an existing template. Just call super!
     #
-    # ==render :active_scaffold => #{controller.to_s}, options = {}+
+    # ==render active_scaffold: #{controller.to_s}, options+
     #
     # Lets you embed an ActiveScaffold by referencing the controller where it's configured.
     #
@@ -45,7 +45,7 @@ module ActiveScaffold #:nodoc:
           @_view_paths ||= lookup_context.view_paths.clone
           @_last_template ||= lookup_context.last_template
         end
-        result = super options_for_render_super(args[1])
+        result = super(options_for_render_super(args[1]))
         @lookup_context = @_lookup_context if @_lookup_context # rails 6
         lookup_context.view_paths = @_view_paths if @_view_paths # rails < 6
         lookup_context.last_template = @_last_template if @_last_template # rails < 6
@@ -74,7 +74,7 @@ module ActiveScaffold #:nodoc:
     end
 
     def view_stack
-      @_view_stack ||= []
+      @view_stack ||= []
     end
 
     private
@@ -91,11 +91,11 @@ module ActiveScaffold #:nodoc:
       options[:template] = parts.pop
       prefix = parts.join('/')
       # if prefix is active_scaffold_overrides we must try to render with this prefix in following paths
-      if prefix != 'active_scaffold_overrides'
-        options[:prefixes] = lookup_context.prefixes.drop((lookup_context.prefixes.find_index(prefix) || -1) + 1)
-      else
+      if prefix == 'active_scaffold_overrides'
         options[:prefixes] = ['active_scaffold_overrides']
         update_view_paths
+      else
+        options[:prefixes] = lookup_context.prefixes.drop((lookup_context.prefixes.find_index(prefix) || -1) + 1)
       end
       options
     end
@@ -145,7 +145,7 @@ module ActiveScaffold #:nodoc:
       eid_info[:conditions] = options[:conditions] if options[:conditions]
       eid_info[:label] = options[:label] if options[:label]
       options[:params] ||= {}
-      options[:params].merge! :eid => eid, :embedded => eid_info
+      options[:params].merge! eid: eid, embedded: eid_info
 
       id = "as_#{eid}-embedded"
       url_options = {controller: remote_controller.to_s, action: 'index', id: nil}.merge(options[:params])
@@ -154,8 +154,8 @@ module ActiveScaffold #:nodoc:
         controller.send(:render_component_into_view, url_options)
       else
         url = url_for(url_options)
-        content_tag(:div, :id => id, :class => 'active-scaffold-component', :data => {:refresh => url}) do
-          content_tag(:div, :class => 'active-scaffold-header') do
+        content_tag(:div, id: id, class: 'active-scaffold-component', data: {refresh: url}) do
+          content_tag(:div, class: 'active-scaffold-header') do
             content_tag(:h2) do
               label = options[:label] || remote_controller_config(remote_controller).list.label
               link_to(label, url, remote: true, class: 'load-embedded', data: {error_msg: as_(:error_500)}) <<
@@ -178,27 +178,25 @@ module ActionView
       include ActiveScaffold::RenderingHelper
     end
 
-    if Gem.loaded_specs['rails'].version.segments.first >= 6
-      RenderingHelper.class_eval do
-        # override the render method to use our @lookup_context instead of the
-        # memoized @_lookup_context
-        def render(options = {}, locals = {}, &block)
-          case options
-          when Hash
-            in_rendering_context(options) do |_|
-              # previously set view paths and lookup context are lost here
-              # if you use view_renderer, so instead create a new renderer
-              # with our context
-              temp_renderer = ActionView::Renderer.new(@lookup_context)
-              if block_given?
-                temp_renderer.render_partial(self, options.merge(partial: options[:layout]), &block)
-              else
-                temp_renderer.render(self, options)
-              end
+    RenderingHelper.class_eval do
+      # override the render method to use our @lookup_context instead of the
+      # memoized @_lookup_context
+      def render(options = {}, locals = {}, &block)
+        case options
+        when Hash
+          in_rendering_context(options) do |_|
+            # previously set view paths and lookup context are lost here
+            # if you use view_renderer, so instead create a new renderer
+            # with our context
+            temp_renderer = ActionView::Renderer.new(@lookup_context)
+            if block_given?
+              temp_renderer.render_partial(self, options.merge(partial: options[:layout]), &block)
+            else
+              temp_renderer.render(self, options)
             end
-          else
-            view_renderer.render_partial(self, partial: options, locals: locals, &block)
           end
+        else
+          view_renderer.render_partial(self, partial: options, locals: locals, &block)
         end
       end
     end

data/lib/active_scaffold/extensions/ice_nine.rb

@@ -2,7 +2,7 @@ module IceNine
   class Freezer
     def self.find(name)
       freezer = name.split('::').reduce(self) do |mod, const|
-        mod.const_lookup(const) or break mod # rubocop:disable Style/AndOr
+        mod.const_lookup(const) or break mod
       end
       freezer if freezer < self # only return a descendant freezer
     end
@@ -13,6 +13,7 @@ module IceNine
       def self.freeze_instance_variables(object, recursion_guard)
         object.instance_variables.each do |ivar_name|
           next if excluded_vars.include? ivar_name
+
           Freezer.guarded_deep_freeze(
             object.instance_variable_get(ivar_name),
             recursion_guard

data/lib/active_scaffold/extensions/localize.rb

@@ -2,8 +2,8 @@ class Object
   def as_(key, options = {})
     if key.present?
       scope = [:active_scaffold, *options.delete(:scope)]
-      options = options.reverse_merge(:scope => scope, :default => key.is_a?(String) ? key : key.to_s.titleize)
-      text = I18n.translate(key.to_s, **options).html_safe # rubocop:disable Rails/OutputSafety
+      options = options.reverse_merge(scope: scope, default: key.is_a?(String) ? key : key.to_s.titleize)
+      text = I18n.t(key.to_s, **options).html_safe
       # text = nil if text.include?('translation missing:')
     end
     text || key

data/lib/active_scaffold/extensions/name_option_for_datetime.rb

@@ -4,7 +4,7 @@ module ActiveScaffold
 
     def datetime_selector(options, html_options)
       options[:prefix] = options[:name].gsub(/\[[^\[]*\]$/, '') if options[:name]
-      super(options, html_options)
+      super
     end
   end
 end

data/lib/active_scaffold/extensions/routing_mapper.rb

@@ -1,12 +1,12 @@
 module ActiveScaffold
   module Routing
     ACTIVE_SCAFFOLD_CORE_ROUTING = {
-      :collection => {:show_search => :get, :render_field => :post, :mark => :post},
-      :member => {:update_column => :post, :render_field => %i[get post], :mark => :post}
+      collection: {show_search: :get, render_field: :post, mark: :post},
+      member: {update_column: :post, render_field: %i[get post], mark: :post}
     }.freeze
     ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING = {
-      :collection => {:edit_associated => :get, :new_existing => :get, :add_existing => :post},
-      :member => {:edit_associated => :get, :destroy_existing => :delete}
+      collection: {edit_associated: :get, new_existing: :get, add_existing: :post},
+      member: {edit_associated: :get, destroy_existing: :delete}
     }.freeze
 
     class Association
@@ -44,6 +44,7 @@ module ActiveScaffold
 
     class Basic < Association
       def initialize(defaults = {})
+        super()
         @defaults = defaults
       end
 

data/lib/active_scaffold/extensions/unsaved_associated.rb

@@ -2,6 +2,7 @@
 class ActiveRecord::Base
   def associated_valid?(path = [])
     return true if path.include?(self) # prevent recursion (if associated and parent are new records)
+
     path << self
     # using [].all? syntax to avoid a short-circuit
     # errors to associated record can be added by update_record_from_params when association fails to set and ActiveRecord::RecordNotSaved is raised
@@ -47,14 +48,14 @@ class ActiveRecord::Base
   # yields every associated object that has been instantiated and is flagged as unsaved.
   # returns false if any yield returns false.
   # returns true otherwise, even when none of the associations have been instantiated. build wrapper methods accordingly.
-  def with_unsaved_associated
+  def with_unsaved_associated(&block)
     associations_for_update.map do |assoc|
       association_proxy = association(assoc.name)
       if association_proxy.target.present?
         records = association_proxy.target
         records = [records] unless records.is_a? Array # convert singular associations into collections for ease of use
         # must use select instead of find_all, which Rails overrides on association proxies for db access
-        records.select { |r| r.unsaved? && !r.readonly? }.map { |r| yield r }.all?
+        records.select { |r| r.unsaved? && !r.readonly? }.map(&block).all?
       else
         true
       end