active_scaffold 3.7.0 → 3.7.1

data/test/helpers/search_column_helpers_test.rb

@@ -9,6 +9,7 @@ class SearchColumnHelpersTest < ActionView::TestCase
   end
 
   def test_choices_for_boolean_search_ui
-    assert_dom_equal "<select name=\"search[adult]\"><option value=\"\">- select -</option>\n<option value=\"true\">True</option>\n<option value=\"false\" selected=\"selected\">False</option></select>", active_scaffold_search_boolean(@column, :object => @record, :name => 'search[adult]', :value => '0')
+    opts = {object: @record, name: 'search[adult]', value: '0'}
+    assert_dom_equal "<select name=\"search[adult]\"><option value=\"\">- select -</option>\n<option value=\"true\">True</option>\n<option value=\"false\" selected=\"selected\">False</option></select>", active_scaffold_search_boolean(@column, opts)
   end
 end

data/test/misc/constraints_test.rb

@@ -17,6 +17,7 @@ module ModelStubs
       @table_name || to_s.split('::').last.underscore.pluralize
     end
     self.store_full_sti_class = false
+    def self.load_schema; end
   end
 
   ##

data/test/misc/finder_test.rb

@@ -78,6 +78,44 @@ class FinderTest < Minitest::Test
     assert_equal ['"people"."adult" = ?', false], ClassWithFinder.condition_for_column(column, '0')
   end
 
+  def test_condition_for_polymorphic_column
+    column = ActiveScaffold::DataStructures::Column.new('addressable', Address)
+    column.search_sql = [{subquery: [Building, 'name']}]
+    condition = ClassWithFinder.condition_for_column(column, 'test search')
+    assert_equal Building.where(['name LIKE ?', '%test search%']).select(:id).to_sql, condition[1].to_sql
+    assert_equal '"addresses"."addressable_id" IN (?) AND "addresses"."addressable_type" = ?', condition[0]
+    assert_equal ['Building'], condition[2..-1]
+  end
+
+  def test_condition_for_polymorphic_column_with_relation
+    column = ActiveScaffold::DataStructures::Column.new('contactable', Contact)
+    column.search_sql = [{subquery: [Person.joins(:buildings), 'first_name', 'last_name']}]
+    condition = ClassWithFinder.condition_for_column(column, 'test search')
+    assert_equal Person.joins(:buildings).where(['first_name LIKE ? OR last_name LIKE ?', '%test search%', '%test search%']).select(:id).to_sql, condition[1].to_sql
+    assert_equal '"contacts"."contactable_id" IN (?) AND "contacts"."contactable_type" = ?', condition[0]
+    assert_equal ['Person'], condition[2..-1]
+  end
+
+  def test_subquery_condition_for_association_with_condition
+    column = ActiveScaffold::DataStructures::Column.new('owner', Building)
+    column.search_sql = [{subquery: [Person, 'first_name', 'last_name'], conditions: ['floor_count > 0']}]
+    column.search_ui = :text
+    condition = ClassWithFinder.condition_for_column(column, 'test search')
+    assert_equal Person.where(['first_name LIKE ? OR last_name LIKE ?', '%test search%', '%test search%']).select(:id).to_sql, condition[1].to_sql
+    assert_equal '"buildings"."owner_id" IN (?) AND floor_count > 0', condition[0]
+    assert_equal [], condition[2..-1]
+  end
+
+  def test_subquery_condition_for_association_with_conditions
+    column = ActiveScaffold::DataStructures::Column.new('owner', Building)
+    column.search_sql = [{subquery: [Person, 'first_name', 'last_name'], conditions: ['floor_count > 0 AND name != ?', '']}]
+    column.search_ui = :text
+    condition = ClassWithFinder.condition_for_column(column, 'test search')
+    assert_equal Person.where(['first_name LIKE ? OR last_name LIKE ?', '%test search%', '%test search%']).select(:id).to_sql, condition[1].to_sql
+    assert_equal '"buildings"."owner_id" IN (?) AND floor_count > 0 AND name != ?', condition[0]
+    assert_equal [''], condition[2..-1]
+  end
+
   private
 
   def relation_class

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_scaffold
 version: !ruby/object:Gem::Version
-  version: 3.7.0
+  version: 3.7.1
 platform: ruby
 authors:
 - Many, see README
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-12 00:00:00.000000000 Z
+date: 2024-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -189,9 +189,6 @@ files:
 - app/views/active_scaffold_overrides/update.html.erb
 - app/views/active_scaffold_overrides/update_column.js.erb
 - app/views/active_scaffold_overrides/update_row.js.erb
-- config/brakeman.ignore
-- config/brakeman.yml
-- config/i18n-tasks.yml
 - config/locales/de.yml
 - config/locales/en.yml
 - config/locales/es.yml
@@ -267,7 +264,6 @@ files:
 - lib/active_scaffold/bridges/record_select/helpers.rb
 - lib/active_scaffold/bridges/semantic_attributes.rb
 - lib/active_scaffold/bridges/semantic_attributes/column.rb
-- lib/active_scaffold/bridges/shared/date_bridge.rb
 - lib/active_scaffold/bridges/tiny_mce.rb
 - lib/active_scaffold/bridges/tiny_mce/helpers.rb
 - lib/active_scaffold/bridges/usa_state_select.rb

data/config/brakeman.ignore

@@ -1,26 +0,0 @@
-{
-  "ignored_warnings": [
-    {
-      "warning_type": "Weak Hash",
-      "warning_code": 90,
-      "fingerprint": "bca53a490b010fea618ad3791c37086988592b4706fc569f244bca2a3a471bef",
-      "check_name": "WeakHash",
-      "message": "Weak hashing algorithm (MD5) used",
-      "file": "lib/active_scaffold/extensions/action_view_rendering.rb",
-      "line": 99,
-      "link": "http://brakemanscanner.org/docs/warning_types/weak_hash/",
-      "code": "Digest::MD5.hexdigest((params[:controller] + options.to_s))",
-      "render_path": null,
-      "location": {
-        "type": "method",
-        "class": "ActiveScaffold::RenderingHelper",
-        "method": "render_embedded"
-      },
-      "user_input": "params",
-      "confidence": "High",
-      "note": "Hash used for uniquely identify different embedded scaffolds with fixed length id"
-    }
-  ],
-  "updated": "2017-10-18 08:35:45 +0200",
-  "brakeman_version": "4.0.1"
-}

data/config/brakeman.yml

@@ -1,3 +0,0 @@
----
-:run_all_checks: true
-:quiet: true

data/config/i18n-tasks.yml

@@ -1,121 +0,0 @@
-# i18n-tasks finds and manages missing and unused translations: https://github.com/glebm/i18n-tasks
-
-# The "main" locale.
-base_locale: en
-## All available locales are inferred from the data by default. Alternatively, specify them explicitly:
-#locales: [en]
-## Reporting locale, default: en. Available: en, ru.
-# internal_locale: en
-
-# Read and write translations.
-data:
-  ## Translations are read from the file system. Supported format: YAML, JSON.
-  ## Provide a custom adapter:
-  # adapter: I18n::Tasks::Data::FileSystem
-
-  # Locale files or `File.find` patterns where translations are read from:
-  read:
-    ## Default:
-    - config/locales/%{locale}.yml
-    ## More files:
-    # - config/locales/**/*.%{locale}.yml
-    ## Another gem (replace %#= with %=):
-    # - "<%#= %x[bundle show vagrant].chomp %>/templates/locales/%{locale}.yml"
-
-  # Locale files to write new keys to, based on a list of key pattern => file rules. Matched from top to bottom:
-  # `i18n-tasks normalize -p` will force move the keys according to these rules
-  write:
-    ## For example, write devise and simple form keys to their respective files:
-    # - ['{devise, simple_form}.*', 'config/locales/\1.%{locale}.yml']
-    ## Catch-all default:
-    # - config/locales/%{locale}.yml
-
-  ## Specify the router (see Readme for details). Valid values: conservative_router, pattern_router, or a custom class.
-  # router: convervative_router
-
-  yaml:
-    write:
-      # do not wrap lines at 80 characters
-      line_width: -1
-
-  ## Pretty-print JSON:
-  # json:
-  #   write:
-  #     indent: '  '
-  #     space: ' '
-  #     object_nl: "\n"
-  #     array_nl: "\n"
-
-# Find translate calls
-search:
-  ## Paths or `File.find` patterns to search in:
-  paths:
-    - app/
-    - lib/
-
-  ## Root directories for relative keys resolution.
-  # relative_roots:
-  #   - app/controllers
-  #   - app/helpers
-  #   - app/mailers
-  #   - app/presenters
-  #   - app/views
-
-  ## Files or `File.fnmatch` patterns to exclude from search. Some files are always excluded regardless of this setting:
-  ##   %w(*.jpg *.png *.gif *.svg *.ico *.eot *.otf *.ttf *.woff *.woff2 *.pdf *.css *.sass *.scss *.less *.yml *.json)
-  exclude:
-    - app/assets/images
-    - lib/generators/templates
-
-  ## Alternatively, the only files or `File.fnmatch patterns` to search in `paths`:
-  ## If specified, this settings takes priority over `exclude`, but `exclude` still applies.
-  # only: ["*.rb", "*.html.slim"]
-
-  ## If `strict` is `false`, guess usages such as t("categories.#{category}.title"). The default is `true`.
-  # strict: true
-
-  ## Multiple scanners can be used. Their results are merged.
-  ## The options specified above are passed down to each scanner. Per-scanner options can be specified as well.
-  ## See this example of a custom scanner: https://github.com/glebm/i18n-tasks/wiki/A-custom-scanner-example
-
-## Google Translate
-# translation:
-#   # Get an API key and set billing info at https://code.google.com/apis/console to use Google Translate
-#   api_key: "AbC-dEf5"
-
-## Do not consider these keys missing:
-ignore_missing:
-  # translations from rails i18n are used
-  - date.formats.default
-  - number.currency.format
-  - number.format
-  - number.human.format
-  - number.percentage.format
-
-## Consider these keys used:
-ignore_unused:
-  - 'active_scaffold.*' # used indirectly by the ActiveScaffold
-
-## Exclude these keys from the `i18n-tasks eq-base' report:
-# ignore_eq_base:
-#   all:
-#     - common.ok
-#   fr,es:
-#     - common.brand
-
-## Ignore these keys completely:
-# ignore:
-#  - kaminari.*
-
-## Sometimes, it isn't possible for i18n-tasks to match the key correctly,
-## e.g. in case of a relative key defined in a helper method.
-## In these cases you can use the built-in PatternMapper to map patterns to keys, e.g.:
-#
-# <%# I18n::Tasks.add_scanner 'I18n::Tasks::Scanners::PatternMapper',
-#       only: %w(*.html.haml *.html.slim),
-#       patterns: [['= title\b', '.page_title']] %>
-#
-# The PatternMapper can also match key literals via a special %{key} interpolation, e.g.:
-#
-# <%# I18n::Tasks.add_scanner 'I18n::Tasks::Scanners::PatternMapper',
-#       patterns: [['\bSpree\.t[( ]\s*%{key}', 'spree.%{key}']] %>

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

@@ -1,221 +0,0 @@
-module ActiveScaffold
-  module Bridges
-    module Shared
-      module DateBridge
-        module SearchColumnHelpers
-          def active_scaffold_search_date_bridge(column, options)
-            current_search = {'from' => nil, 'to' => nil, 'opt' => 'BETWEEN',
-                              'number' => 1, 'unit' => 'DAYS', 'range' => nil}
-            current_search.merge!(options[:value]) unless options[:value].nil?
-            tags = []
-            tags << active_scaffold_search_date_bridge_comparator_tag(column, options, current_search)
-            tags << active_scaffold_search_date_bridge_trend_tag(column, options, current_search)
-            tags << active_scaffold_search_date_bridge_numeric_tag(column, options, current_search)
-            tags << active_scaffold_search_date_bridge_range_tag(column, options, current_search)
-            safe_join tags, '&nbsp;'.html_safe # rubocop:disable Rails/OutputSafety
-          end
-
-          def active_scaffold_search_date_bridge_comparator_options(column)
-            select_options = ActiveScaffold::Finder::DATE_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] }
-            select_options + ActiveScaffold::Finder::NUMERIC_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] }
-          end
-
-          def active_scaffold_search_date_bridge_comparator_tag(column, options, current_search)
-            choices = options_for_select(active_scaffold_search_date_bridge_comparator_options(column), current_search['opt'])
-            select_tag("#{options[:name]}[opt]", choices, :id => "#{options[:id]}_opt", :class => 'as_search_range_option as_search_date_time_option')
-          end
-
-          def active_scaffold_search_date_bridge_numeric_tag(column, options, current_search)
-            numeric_controls = [
-              active_scaffold_search_date_bridge_calendar_control(column, options, current_search, 'from'),
-              content_tag(:span, safe_join([' - ', active_scaffold_search_date_bridge_calendar_control(column, options, current_search, 'to')]),
-                          :id => "#{options[:id]}_between", :class => 'as_search_range_between',
-                          :style => current_search['opt'] == 'BETWEEN' ? nil : 'display: none')
-            ]
-            content_tag('span', safe_join(numeric_controls),
-                        :id => "#{options[:id]}_numeric", :class => 'search-date-numeric',
-                        :style => ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(current_search['opt']) ? nil : 'display: none')
-          end
-
-          def active_scaffold_search_date_bridge_trend_tag(column, options, current_search)
-            active_scaffold_date_bridge_trend_tag(column, options,
-                                                  :number_value => current_search['number'],
-                                                  :unit_value => current_search['unit'],
-                                                  :show => (current_search['opt'] == 'PAST' || current_search['opt'] == 'FUTURE'))
-          end
-
-          def active_scaffold_date_bridge_trend_tag(column, options, trend_options)
-            trend_controls = [
-              text_field_tag("#{options[:name]}[number]", trend_options[:number_value], :class => 'text-input', :size => 10, :autocomplete => 'off'),
-              select_tag("#{options[:name]}[unit]",
-                         options_for_select(active_scaffold_search_date_bridge_trend_units(column), trend_options[:unit_value]),
-                         :class => 'text-input')
-            ]
-            content_tag('span', safe_join(trend_controls, ' '),
-                        :id => "#{options[:id]}_trend", :class => 'search-date-trend',
-                        :style => trend_options[:show] ? nil : 'display: none')
-          end
-
-          def active_scaffold_search_date_bridge_trend_units(column)
-            options = ActiveScaffold::Finder::DATE_UNITS.collect { |unit| [as_(unit.downcase.to_sym), unit] }
-            options = ActiveScaffold::Finder::TIME_UNITS.collect { |unit| [as_(unit.downcase.to_sym), unit] } + options if column_datetime?(column)
-            options
-          end
-
-          def active_scaffold_search_date_bridge_range_tag(column, options, current_search)
-            values = ActiveScaffold::Finder::DATE_RANGES.collect { |range| [as_(range.downcase.to_sym), range] }
-            range_controls = select_tag("#{options[:name]}[range]",
-                                        options_for_select(values, current_search['range']),
-                                        :class => 'text-input', :id => nil)
-            content_tag('span', range_controls,
-                        :id => "#{options[:id]}_range", :class => 'search-date-range',
-                        :style => ('display: none' unless current_search['opt'] == 'RANGE'))
-          end
-
-          def column_datetime?(column)
-            (!column.column.nil? && %i[datetime time].include?(column.column.type))
-          end
-        end
-
-        module HumanConditionHelpers
-          def active_scaffold_human_condition_date_bridge(column, value)
-            case value['opt']
-            when 'RANGE'
-              range_type, range = value['range'].downcase.split('_')
-              format = active_scaffold_human_condition_date_bridge_range_format(range_type, range)
-              from, = controller.class.date_bridge_from_to(column, value)
-              "#{column.active_record_class.human_attribute_name(column.name)} = #{as_(value['range'].downcase).downcase} (#{I18n.l(from, :format => format)})"
-            when 'PAST', 'FUTURE'
-              from, to = controller.class.date_bridge_from_to(column, value)
-              "#{column.active_record_class.human_attribute_name(column.name)} #{as_('BETWEEN'.downcase).downcase} #{I18n.l(from)} - #{I18n.l(to)}"
-            else
-              from, to = controller.class.date_bridge_from_to(column, value)
-              "#{column.active_record_class.human_attribute_name(column.name)} #{as_(value['opt'].downcase).downcase} #{I18n.l(from)} #{value['opt'] == 'BETWEEN' ? '- ' + I18n.l(to) : ''}"
-            end
-          end
-
-          def active_scaffold_human_condition_date_bridge_range_format(range_type, range)
-            case range
-            when 'week'
-              first_day_of_week = I18n.translate 'active_scaffold.date_picker_options.firstDay'
-              if first_day_of_week == 1
-                '%W %Y'
-              else
-                '%U %Y'
-              end
-            when 'month'
-              '%b %Y'
-            when 'year'
-              '%Y'
-            else
-              I18n.translate 'date.formats.default'
-            end
-          end
-        end
-
-        module Finder
-          module ClassMethods
-            def condition_for_date_bridge_type(column, value, like_pattern)
-              operator = ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(value['opt']) && value['opt'] != 'BETWEEN' ? value['opt'] : nil
-              from_value, to_value = date_bridge_from_to(column, value)
-
-              if column.search_sql.is_a? Proc
-                column.search_sql.call(from_value, to_value, operator)
-              elsif operator.nil?
-                ['%<search_sql>s BETWEEN ? AND ?', from_value, to_value] unless from_value.nil? || to_value.nil?
-              else
-                ["%<search_sql>s #{value['opt']} ?", from_value] unless from_value.nil?
-              end
-            end
-
-            def date_bridge_from_to(column, value)
-              conversion = datetime_conversion_for_condition(column)
-              case value['opt']
-              when 'RANGE'
-                values = date_bridge_from_to_for_range(column, value)
-                # Avoid calling to_time, not needed and broken on rails >= 4, because return local time instead of UTC
-                values.collect!(&conversion) if conversion != :to_time
-                values
-              when 'PAST', 'FUTURE'
-                values = date_bridge_from_to_for_trend(column, value)
-                # Avoid calling to_time, not needed and broken on rails >= 4, because return local time instead of UTC
-                values.collect!(&conversion) if conversion != :to_time
-                values
-              else
-                %w[from to].collect { |field| condition_value_for_datetime(column, value[field], conversion) }
-              end
-            end
-
-            def date_bridge_now
-              Time.zone.now
-            end
-
-            def date_bridge_from_to_for_trend(column, value)
-              case value['opt']
-              when 'PAST'
-                trend_number = [value['number'].to_i, 1].max
-                now = date_bridge_now
-                if date_bridge_column_date?(column)
-                  from = now.beginning_of_day.ago(trend_number.send(value['unit'].downcase.singularize.to_sym))
-                  to = now.end_of_day
-                else
-                  from = now.ago(trend_number.send(value['unit'].downcase.singularize.to_sym))
-                  to = now
-                end
-                [from, to]
-              when 'FUTURE'
-                trend_number = [value['number'].to_i, 1].max
-                now = date_bridge_now
-                if date_bridge_column_date?(column)
-                  from = now.beginning_of_day
-                  to = now.end_of_day.in(trend_number.send(value['unit'].downcase.singularize.to_sym))
-                else
-                  from = now
-                  to = now.in(trend_number.send(value['unit'].downcase.singularize.to_sym))
-                end
-                [from, to]
-              end
-            end
-
-            def date_bridge_from_to_for_range(column, value)
-              case value['range']
-              when 'TODAY'
-                [date_bridge_now.beginning_of_day, date_bridge_now.end_of_day]
-              when 'YESTERDAY'
-                [date_bridge_now.ago(1.day).beginning_of_day, date_bridge_now.ago(1.day).end_of_day]
-              when 'TOMORROW'
-                [date_bridge_now.in(1.day).beginning_of_day, date_bridge_now.in(1.day).end_of_day]
-              else
-                range_type, range = value['range'].downcase.split('_')
-                raise ArgumentError unless %w[week month year].include?(range)
-                case range_type
-                when 'this'
-                  return date_bridge_now.send("beginning_of_#{range}".to_sym), date_bridge_now.send("end_of_#{range}")
-                when 'prev'
-                  return date_bridge_now.ago(1.send(range.to_sym)).send("beginning_of_#{range}".to_sym), date_bridge_now.ago(1.send(range.to_sym)).send("end_of_#{range}".to_sym)
-                when 'next'
-                  return date_bridge_now.in(1.send(range.to_sym)).send("beginning_of_#{range}".to_sym), date_bridge_now.in(1.send(range.to_sym)).send("end_of_#{range}".to_sym)
-                else
-                  return nil, nil
-                end
-              end
-            end
-
-            def date_bridge_column_date?(column)
-              if %i[date_picker datetime_picker].include? column.form_ui
-                column.form_ui == :date_picker
-              else
-                (!column.column.nil? && [:date].include?(column.column.type))
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-ActiveScaffold::Finder.const_set('DATE_COMPARATORS', %w[PAST FUTURE RANGE])
-ActiveScaffold::Finder.const_set('DATE_UNITS', %w[DAYS WEEKS MONTHS YEARS])
-ActiveScaffold::Finder.const_set('TIME_UNITS', %w[SECONDS MINUTES HOURS])
-ActiveScaffold::Finder.const_set('DATE_RANGES', %w[TODAY YESTERDAY TOMORROW THIS_WEEK PREV_WEEK NEXT_WEEK THIS_MONTH PREV_MONTH NEXT_MONTH THIS_YEAR PREV_YEAR NEXT_YEAR])