wallaby-active_record 0.2.7 → 0.3.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55cc61191c3d68eabf0bb98b4977d10c7d5063736e95cba4b4cb446bf1ecebb7
-  data.tar.gz: 8d03e8a115f52bd386e87bd6ba2a8a95fdec39743a1a040396f8f1b06ac1c0fe
+  metadata.gz: 90fb0c2b0c23402987290d4b290b953de709949ffffcbfc1255e8ef7c5efd653
+  data.tar.gz: 67d1cbd6394ed22ff8db981b043d10c719992175630e8e0bcc38d5eec4e42acd
 SHA512:
-  metadata.gz: '0685f26c6acf1c511be09cfe68258bce7ca3cd01263047205fcdbfc2e81da7ca1239af3f0725510401d02f6a2c2629003e79a41760a8e672acaa710cd566d8db'
-  data.tar.gz: fa1497666790dba1d421f1194ce3e3ffc4851e3425a7a2da5701af9f5d4573d1df9bbf3a9ee656aa3490f81ed363af4a6758121d6c3cbd761f3d52707f84f6bb
+  metadata.gz: 678e44a61fe8bd550d24924c95fe4b52a51a8e5667f93e46efadb337613e14a99d7befef28d85f2de8d988b6fcf11dc91577640de4246edebb8fba778a639772
+  data.tar.gz: 610ef0709fd1c48f770fa2414ba7d64b51b8bc3410b12453a8d3c9a6c1c10fbb62ddb65cd0cd5768415eb8bb2554def31c71a7ad1c11a41490e3cf408466efd1

data/README.md

@@ -7,8 +7,19 @@
 [![Test Coverage](https://api.codeclimate.com/v1/badges/9ba0a610043a2e1a9e74/test_coverage)](https://codeclimate.com/github/wallaby-rails/wallaby-active_record/test_coverage)
 [![Inch CI](https://inch-ci.org/github/wallaby-rails/wallaby-active_record.svg?branch=master)](https://inch-ci.org/github/wallaby-rails/wallaby-active_record)
 
-Wallaby::ActiveRecord is the ActiveRecord adapter that implements the [Wallaby::Core](https://github.com/wallaby-rails/wallaby-core)
-interfaces to handle ActiveRecord model/instance(s) in all the CRUD/authorization/pagination operations.
+`Wallaby::ActiveRecord` adapter is designed to seamlessly integrate ActiveRecord models and instances with the [Wallaby::Core](https://github.com/wallaby-rails/wallaby-core)
+interfaces, enabling smooth handling of CRUD operations, authorization, and pagination.
+
+Key features of `Wallaby::ActiveRecord` include:
+
+- Offer built-in compatibility with popular authorization frameworks like CanCanCan and Pundit, allowing you to easily manage access control for your ActiveRecord models.
+- Fully support all Rails associations (`belongs_to`, `has_one`, `has_many`, `has_and_belongs_to_many`).
+- All PostgreSQL types supported by Rails are fully supported to ensure smooth handling of data with different types.
+- Facilitate the normalization of data during form submissions, specifically for `binary`, `point` and `range` types.
+- Provide the flexibility to define custom filters for the `index` action, enabling you to create tailored queries based on your specific requirements.
+- Allow sorting for single or multiple columns and provide `nulls` sorting option, enhancing the control and precision of result ordering.
+- Support STI (Single Table Inheritance)
+- Offer advance search capabilities using a convenient colon syntax, empowering users to perform precise searches with ease.
 
 ## Install
 

data/lib/adapters/wallaby/active_record/model_decorator/fields_builder/sti_builder.rb

@@ -29,7 +29,7 @@ module Wallaby
           # @param klass [Class]
           # @return [Array<Class>]
           def sti_list(klass)
-            (klass.descendants << klass).sort_by(&:name)
+            (klass.descendants << klass).sort_by(&:name).uniq
           end
 
           # Find out which parent is the one that can give us the STI list.

data/lib/adapters/wallaby/active_record/model_decorator/fields_builder.rb

@@ -12,28 +12,31 @@ module Wallaby
 
         # @return [Hash<String, Hash>] a hash for general fields
         def general_fields
-          @model_class.columns.each_with_object({}) do |column, fields|
-            metadata = {
-              type: to_type(column).freeze,
-              label: @model_class.human_attribute_name(column.name)
-            }
-            sti_builder.update(metadata, column)
-            fields[column.name] = metadata
-          end
+          @general_fields ||=
+            @model_class.columns.each_with_object({}) do |column, fields|
+              metadata = {
+                type: to_type(column).freeze,
+                label: @model_class.human_attribute_name(column.name)
+              }
+              sti_builder.update(metadata, column)
+              fields[column.name] = metadata
+            end
         end
 
         # @return [Hash<String, Hash>] a hash for association fields
         #   (e.g. belongs_to / has_one / has_many / has_and_belongs_to_many)
         def association_fields
-          @model_class.reflections.each_with_object({}) do |(name, ref), fields|
-            metadata = {
-              type: ref.macro.to_s,
-              label: @model_class.human_attribute_name(name)
-            }
-            association_builder.update(metadata, ref)
-            polymorphic_builder.update(metadata, ref)
-            fields[name] = metadata
-          end
+          @association_fields ||=
+            @model_class.reflections.each_with_object({}) do |(name, reflection), fields|
+              metadata = {
+                type: reflection.macro.to_s, # association type
+                label: @model_class.human_attribute_name(name)
+              }
+              association_builder.update(metadata, reflection)
+              polymorphic_builder.update(metadata, reflection)
+              update_general_fields_with(metadata)
+              fields[name] = metadata
+            end
         end
 
         protected
@@ -61,6 +64,21 @@ module Wallaby
         def polymorphic_builder
           @polymorphic_builder ||= PolymorphicBuilder.new
         end
+
+        # @param metadata [Hash] association metadata
+        def update_general_fields_with(metadata)
+          metadata[:foreign_key].try do |key|
+            general_fields[key].try do |general_metadata|
+              general_metadata[:is_foreign_key] = general_metadata[:hidden] = true
+            end
+          end
+
+          metadata[:polymorphic_type].try do |key|
+            general_fields[key].try do |general_metadata|
+              general_metadata[:is_polymorphic_type] = general_metadata[:hidden] = true
+            end
+          end
+        end
       end
     end
   end

data/lib/adapters/wallaby/active_record/model_decorator/title_field_finder.rb

@@ -5,7 +5,7 @@ module Wallaby
     class ModelDecorator
       # Try to find the field that can be used as title
       class TitleFieldFinder
-        TITLE_FIELD_TYPES = %w(string).freeze
+        TITLE_FIELD_TYPES = %w[string].freeze
 
         # @param model_class [Class]
         # @param fields [Hash] fields metadata

data/lib/adapters/wallaby/active_record/model_decorator.rb

@@ -5,16 +5,16 @@ module Wallaby
     # Modal decorator for {Wallaby::ActiveRecord}
     class ModelDecorator < ::Wallaby::ModelDecorator
       # Data types to exclude for {#index_field_names}
-      INDEX_EXCLUSIVE_DATA_TYPES = %w(
+      INDEX_EXCLUSIVE_DATA_TYPES = %w[
         binary citext hstore json jsonb tsvector xml
         blob mediumblob longblob text mediumtext longtext
-      ).freeze
+      ].freeze
 
       # Classes to exclude for {#show_field_names}
-      SHOW_EXCLUSIVE_CLASS_NAMES = %w(ActiveStorage::Attachment ActiveStorage::Blob).freeze
+      SHOW_EXCLUSIVE_CLASS_NAMES = %w[ActiveStorage::Attachment ActiveStorage::Blob].freeze
 
       # Fields to exclude for {#form_field_names}
-      FORM_EXCLUSIVE_DATA_TYPES = %w(created_at updated_at).freeze
+      FORM_EXCLUSIVE_DATA_TYPES = %w[created_at updated_at].freeze
 
       # Original metadata information of the primative and association fields
       # pulling out from the ActiveRecord model.
@@ -45,46 +45,49 @@ module Wallaby
         @fields ||= ::ActiveSupport::HashWithIndifferentAccess.new.tap do |hash|
           next hash.default = {} unless @model_class.table_exists?
 
-          hash.merge! general_fields
-          hash.merge! association_fields
-          hash.except!(*foreign_keys_from_associations)
+          hash.merge!(association_fields)
+          hash.merge!(general_fields)
+        rescue ::ActiveRecord::NoDatabaseError
+          hash.default = {}
         end.freeze
-      rescue ::ActiveRecord::NoDatabaseError
-        Hash.new({}).with_indifferent_access
       end
 
       # A copy of {#fields} for index page
       # @return [ActiveSupport::HashWithIndifferentAccess] metadata
       def index_fields
-        @index_fields ||= Utils.clone fields
+        @index_fields ||= Utils.clone(fields)
       end
 
       # A copy of {#fields} for show page
       # @return [ActiveSupport::HashWithIndifferentAccess] metadata
       def show_fields
-        @show_fields ||= Utils.clone fields
+        @show_fields ||= Utils.clone(fields)
       end
 
       # A copy of {#fields} for form (new/edit) page
       # @return [ActiveSupport::HashWithIndifferentAccess] metadata
       def form_fields
-        @form_fields ||= Utils.clone fields
+        @form_fields ||= Utils.clone(fields)
       end
 
       # @return [Array<String>] a list of field names for index page (note: only primitive SQL types are included).
       def index_field_names
         @index_field_names ||=
-          index_fields.reject do |_field_name, metadata|
-            metadata[:is_association] \
-              || INDEX_EXCLUSIVE_DATA_TYPES.include?(metadata[:type])
-          end.keys
+          reposition(
+            index_fields.reject do |_field_name, metadata|
+              metadata[:hidden] || # e.g. foreign keys, polymorphic columns
+                metadata[:is_association] || # associations
+                INDEX_EXCLUSIVE_DATA_TYPES.include?(metadata[:type]) # not the types for index page
+            end.keys
+          )
       end
 
       # @return [Array<String>] a list of field names for show page (note: **ActiveStorage** fields are excluded).
       def show_field_names
         @show_field_names ||=
           show_fields.reject do |_field_name, metadata|
-            SHOW_EXCLUSIVE_CLASS_NAMES.include? metadata[:class].try(:name)
+            metadata[:hidden] || # e.g. foreign keys, polymorphic columns
+              SHOW_EXCLUSIVE_CLASS_NAMES.include?(metadata[:class].try(:name)) # not the types for show page
           end.keys
       end
 
@@ -93,9 +96,11 @@ module Wallaby
       def form_field_names
         @form_field_names ||=
           form_fields.reject do |field_name, metadata|
-            field_name == primary_key \
-              || FORM_EXCLUSIVE_DATA_TYPES.include?(field_name) \
-              || metadata[:has_scope] || metadata[:is_through]
+            field_name == primary_key || # primary key
+              metadata[:has_scope] || # not a regular association
+              metadata[:is_through] || # not direct association
+              metadata[:hidden] || # e.g. foreign keys, polymorphic columns
+              FORM_EXCLUSIVE_DATA_TYPES.include?(field_name) # not the types for form page
           end.keys
       end
 
@@ -106,7 +111,17 @@ module Wallaby
 
       # @return [String] primary key for the resource
       def primary_key
-        @primary_key ||= @model_class.primary_key
+        @primary_key ||=
+          @model_class.primary_key || Wallaby::Logger.warn(<<~WARNING)
+            No primary key is found and all resource pages (show/edit) will fail to build.
+
+            If the resource pages are needed, try:
+
+            - Set `self.primary_key=` in the model #{@model_class}
+            - Set `self.primary_key=` in the decorator
+
+            Otherwise, configure to disable access to new/show/edit/destroy
+          WARNING
       end
 
       # To guess the title for resource.
@@ -117,20 +132,21 @@ module Wallaby
       # @param resource [Object]
       # @return [String] the title of given resource
       def guess_title(resource)
-        resource.try title_field_finder.find
+        title_field_finder.find.try do |title_method|
+          resource.try(title_method)
+        end
       end
 
       protected
 
       # @return [Wallaby::ActiveRecord::ModelDecorator::FieldsBuilder]
       def field_builder
-        @field_builder ||= FieldsBuilder.new @model_class
+        @field_builder ||= FieldsBuilder.new(@model_class)
       end
 
       # @return [Wallaby::ActiveRecord::ModelDecorator::TitleFieldFinder]
       def title_field_finder
-        @title_field_finder ||=
-          TitleFieldFinder.new @model_class, general_fields
+        @title_field_finder ||= TitleFieldFinder.new(@model_class, general_fields)
       end
 
       # @!method general_fields
@@ -141,17 +157,6 @@ module Wallaby
       #   (see Wallaby::ActiveRecord::ModelDecorator::FieldsBuilder#association_fields)
       #   @see Wallaby::ActiveRecord::ModelDecorator::FieldsBuilder#association_fields
       delegate :general_fields, :association_fields, to: :field_builder
-
-      # Find out all the foreign keys for association fields
-      # @param fields [Hash] metadata of fields
-      # @return [Array<String>] a list of foreign keys
-      def foreign_keys_from_associations(fields = association_fields)
-        fields.each_with_object([]) do |(_field_name, metadata), keys|
-          keys << metadata[:foreign_key] if metadata[:foreign_key]
-          keys << metadata[:polymorphic_type] if metadata[:polymorphic_type]
-          keys
-        end
-      end
     end
   end
 end

data/lib/adapters/wallaby/active_record/model_finder.rb

@@ -12,7 +12,7 @@ module Wallaby
       # @return [Array<Class>]
       def all
         ::ActiveRecord::Base.descendants.reject do |model_class|
-          defined?(::ApplicationRecord) && model_class == ::ApplicationRecord ||
+          application_record?(model_class) ||
             model_class.abstract_class? ||
             anonymous?(model_class) ||
             model_class.name.index('HABTM') ||
@@ -22,6 +22,10 @@ module Wallaby
 
       protected
 
+      def application_record?(model_class)
+        defined?(::ApplicationRecord) && model_class == ::ApplicationRecord
+      end
+
       # @param model_class [Class]
       # @see Wallaby::ModuleUtils.anonymous_class?
       def anonymous?(model_class)

data/lib/adapters/wallaby/active_record/model_pagination_provider.rb

@@ -15,12 +15,12 @@ module Wallaby
 
       # @return [Integer] total count for the collection
       def total
-        @collection.unscope(:offset, :limit).count
+        @collection.unscope(:offset, :limit).count # rubocop:disable CodeReuse/ActiveRecord
       end
 
       # @return [Integer] page size from parameters or Wallaby configuration
       def page_size
-        (@params[:per] || Wallaby.configuration.pagination.page_size).to_i
+        @params[:per].to_i
       end
 
       # @return [Integer] page number from parameters starting from 1

data/lib/adapters/wallaby/active_record/model_service_provider/normalizer.rb

@@ -14,11 +14,12 @@ module Wallaby
         def normalize(params)
           params.each do |field_name, values|
             metadata =
-              @model_decorator.metadata_of(field_name).presence || @model_decorator.form_metadata_of(field_name)
+              @model_decorator.metadata_of(field_name).presence ||
+              @model_decorator.form_metadata_of(field_name)
             type = metadata[:type].try(:[], /range|point|binary/)
             next unless type
 
-            public_send "normalize_#{type}_values", params, field_name, values
+            try "normalize_#{type}_values", params, field_name, values
           end
           params
         end
@@ -29,7 +30,7 @@ module Wallaby
         # @param values [Array]
         def normalize_range_values(params, field_name, values)
           normalized = Array(values).map(&:presence).compact
-          params[field_name] = (normalized.present? && values.length == 2) && (values.first...values.last) || nil
+          params[field_name] = ((normalized.present? && values.length == 2) && (values.first...values.last)) || nil
         end
 
         # Turn values into points
@@ -38,7 +39,7 @@ module Wallaby
         # @param values [Array]
         def normalize_point_values(params, field_name, values)
           normalized = Array(values).map(&:presence).compact
-          params[field_name] = normalized.present? && values.map(&:to_f) || nil
+          params[field_name] = (normalized.present? && values.map(&:to_f)) || nil
         end
 
         # Turn values into binary
@@ -46,7 +47,7 @@ module Wallaby
         # @param field_name [String]
         # @param values [Object]
         def normalize_binary_values(params, field_name, values)
-          params[field_name] = values.is_a?(::ActionDispatch::Http::UploadedFile) && values.read || nil
+          params[field_name] = (values.is_a?(::ActionDispatch::Http::UploadedFile) && values.read) || nil
         end
       end
     end

data/lib/adapters/wallaby/active_record/model_service_provider/permitter.rb

@@ -3,7 +3,7 @@
 module Wallaby
   class ActiveRecord
     class ModelServiceProvider
-      # Whitelist the params for mass-assignment
+      # Allowlist the params for mass-assignment
       class Permitter
         # @param model_decorator [Wallaby::ModelDecorator]
         def initialize(model_decorator)
@@ -14,11 +14,11 @@ module Wallaby
         def simple_field_names
           field_names =
             non_range_fields.keys +
-            belongs_to_fields.map do |_, metadata|
+            belongs_to_fields.flat_map do |_, metadata|
               [metadata[:foreign_key], metadata[:polymorphic_type]]
-            end.flatten.compact
+            end.compact
           fields = [@model_decorator.primary_key, 'created_at', 'updated_at']
-          field_names.reject { |field_name| fields.include? field_name }
+          field_names.reject { |field_name| fields.include?(field_name) }.uniq
         end
 
         # @return [Array<String>] a list of field names of range and association
@@ -55,7 +55,7 @@ module Wallaby
         #   - has_many
         #   - has_and_belongs_to_many
         def many_association_fields
-          association_fields.select { |_, metadata| /many/ =~ metadata[:type] }
+          association_fields.select { |_, metadata| metadata[:type].include?('many') }
         end
 
         # @return [Array<String>] a list of belongs_to association field names

data/lib/adapters/wallaby/active_record/model_service_provider/querier/transformer.rb

@@ -93,8 +93,10 @@ module Wallaby
               if right.include? nil
                 exps.push left: lefted, op: SIMPLE_OPERATORS[oped], right: right.delete(nil), join: join
               end
+
               exps.push left: lefted, op: operator, right: right, join: join
             end
+
             exps
           end
 

data/lib/adapters/wallaby/active_record/model_service_provider/querier/wrapper.rb

@@ -9,6 +9,7 @@ module Wallaby
         # with non-{Wallaby::ActiveRecord::ModelServiceProvider::Querier::Transformer} result
         class Wrapper
           attr_reader :list
+
           delegate :push, to: :list
           delegate :each, to: :list
           delegate :last, to: :list

data/lib/adapters/wallaby/active_record/model_service_provider/querier.rb

@@ -5,7 +5,7 @@ module Wallaby
     class ModelServiceProvider
       # Query builder
       class Querier
-        TEXT_FIELDS = %w(string text citext longtext tinytext mediumtext).freeze
+        TEXT_FIELDS = %w[string text citext longtext tinytext mediumtext].freeze
 
         # @param model_decorator [Wallaby::ModelDecorator]
         def initialize(model_decorator)
@@ -19,11 +19,26 @@ module Wallaby
         # @param params [ActionController::Parameters]
         # @return [ActiveRecord::Relation]
         def search(params)
-          filter_name, keywords, field_queries = extract params
-          scope = filtered_by filter_name
-          query = text_search keywords
-          query = field_search field_queries, query
-          scope.where query
+          filter_name, keywords, field_queries = extract(params)
+          scope = filtered_by(filter_name)
+          scope = preload_associations_for(scope)
+          arel_query = text_search(keywords)
+          arel_query = field_search(field_queries, arel_query)
+          scope.where(arel_query) # rubocop:disable CodeReuse/ActiveRecord
+        end
+
+        # Extract the sorting from parameters `sort`,
+        # and combine with metadata option `:nulls`
+        # to execute order for the given scope.
+        # @param sort_string [String]
+        # @param scope [ActiveRecord::Relation]
+        # @return [ActiveRecord::Relation]
+        def sort(sort_string, scope)
+          return scope if sort_string.blank?
+
+          sort_hash = normalize_sort(Sorting::HashBuilder.build(sort_string))
+          sorting = Sorting::HashBuilder.to_str(sort_hash)
+          scope.order(Arel.sql(sorting)) # rubocop:disable CodeReuse/ActiveRecord
         end
 
         protected
@@ -53,11 +68,13 @@ module Wallaby
           valid_filter_name =
             FilterUtils.filter_name_by(filter_name, @model_decorator.filters)
           scope = find_scope(valid_filter_name)
-          if scope.blank? then unscoped
-          elsif scope.is_a?(Proc) then @model_class.instance_exec(&scope)
+          return unscoped if scope.blank?
+
+          if scope.is_a?(Proc) then @model_class.instance_exec(&scope)
           elsif @model_class.respond_to?(scope)
-            @model_class.public_send(scope)
-          else unscoped
+            @model_class.try(scope)
+          else
+            unscoped
           end
         end
 
@@ -72,15 +89,28 @@ module Wallaby
 
         # @return [ActiveRecord::Relation] Unscoped query
         def unscoped
-          @model_class.where nil
+          @model_class.where nil # rubocop:disable CodeReuse/ActiveRecord
+        end
+
+        # Preload association for the scope
+        # @param scope [ActiveRecord::Relation]
+        # @return [ActiveRecord::Relation]
+        def preload_associations_for(scope)
+          index_associations = index_field_names.select do |field_name|
+            @model_decorator.fields.dig(field_name, :is_association)
+          end
+
+          return scope if index_associations.blank?
+
+          scope.preload(*index_associations) # rubocop:disable CodeReuse/ActiveRecord
         end
 
-        # Search text for the text columns (see {}) in `index_field_names`
+        # Search text for the text columns (see {}) in {#index_field_names}
         # @param keywords [String] keywords
-        # @param query [ActiveRecord::Relation, nil]
-        # @return [ActiveRecord::Relation, nil]
-        def text_search(keywords, query = nil)
-          return query unless keywords_check? keywords
+        # @param arel_query [Arel::Nodes::Node, nil]
+        # @return [Arel::Nodes::Node, nil]
+        def text_search(keywords, arel_query = nil)
+          return arel_query unless keywords_check?(keywords)
 
           text_fields.each do |field_name|
             sub_query = nil
@@ -88,34 +118,31 @@ module Wallaby
               exp = table[field_name].matches(Escaper.execute(keyword))
               sub_query = sub_query.try(:and, exp) || exp
             end
-            query = query.try(:or, sub_query) || sub_query
+            arel_query = arel_query.try(:or, sub_query) || sub_query
           end
-          query
+          arel_query
         end
 
         # Perform SQL query for the colon query (e.g. data:<2000-01-01)
         # @param field_queries [Array]
-        # @param query [ActiveRecord::Relation]
-        # @return [ActiveRecord::Relation]
-        def field_search(field_queries, query)
-          return query unless field_check? field_queries
+        # @param arel_query [Arel::Nodes::Node]
+        # @return [Arel::Nodes::Node]
+        def field_search(field_queries, arel_query)
+          return arel_query unless field_check?(field_queries)
 
           field_queries.each do |exps|
-            sub_queries = build_sub_queries_with exps
-            query = query.try(:and, sub_queries) || sub_queries
+            sub_queries = build_sub_queries_with(exps)
+            arel_query = arel_query.try(:and, sub_queries) || sub_queries
           end
-          query
+          arel_query
         end
 
-        # @return [Array<String>] a list of text fields from `index_field_names`
+        # @return [Array<String>] a list of text fields from {#index_field_names}
         def text_fields
-          @text_fields ||= begin
-            index_field_names = @model_decorator.index_field_names.map(&:to_s)
-            @model_decorator.fields.select do |field_name, metadata|
-              index_field_names.include?(field_name) &&
-                TEXT_FIELDS.include?(metadata[:type].to_s)
-            end.keys
-          end
+          @text_fields ||= @model_decorator.fields.select do |field_name, metadata|
+            index_field_names.include?(field_name) &&
+              TEXT_FIELDS.include?(metadata[:type].to_s)
+          end.keys
         end
 
         # @param keywords [Array<String>] a list of keywords
@@ -153,6 +180,30 @@ module Wallaby
           end
           query
         end
+
+        def normalize_sort(hash)
+          sanitized =
+            hash.reject do |name, _sort|
+              @model_decorator.fields[name].blank? || # not a column or association?
+                @model_decorator.index_fields[name][:sort_disabled] || # sort disabled?
+                @model_decorator.index_field_names.exclude?(name) # not included?
+            end
+          sanitized.each_with_object({}) do |(field_name, value), normalized|
+            column_name = "#{@model_class.table_name}.#{field_name}"
+            normalized[column_name] =
+              case nulls_order = @model_decorator.index_fields.dig(field_name, :nulls)
+              when :first, :last, 'first', 'last'
+                "#{value} nulls #{nulls_order}"
+              else
+                value
+              end.upcase
+          end
+        end
+
+        # @return [Array<String>]
+        def index_field_names
+          @index_field_names ||= @model_decorator.index_field_names.map(&:to_s)
+        end
       end
     end
   end

data/lib/adapters/wallaby/active_record/model_service_provider/validator.rb

@@ -30,7 +30,7 @@ module Wallaby
         # @return [false] otherwise
         def valid_range_type?(values, metadata)
           !metadata \
-            || !%w(daterange tsrange tstzrange).include?(metadata[:type]) \
+            || %w[daterange tsrange tstzrange].exclude?(metadata[:type]) \
             || !values.try(:any?, &:blank?)
         end
       end

data/lib/adapters/wallaby/active_record/model_service_provider.rb

@@ -7,9 +7,9 @@ module Wallaby
       # @param params [ActionController::Parameters]
       # @param action [String, Symbol]
       # @param authorizer
-      # @return [ActionController::Parameters] whitelisted parameters
+      # @return [ActionController::Parameters] allowlisted parameters
       def permit(params, action, authorizer)
-        authorized_fields = authorizer.permit_params action, @model_class
+        authorized_fields = authorizer.permit_params(action, @model_class)
         params.require(param_key).permit(authorized_fields || permitted_fields)
       end
 
@@ -18,19 +18,18 @@ module Wallaby
       # @param authorizer [Ability] for now
       # @return [ActiveRecord::Relation] relation
       def collection(params, authorizer)
-        query = querier.search params
-        query = query.order params[:sort] if params[:sort].present?
-        authorizer.accessible_for :index, query
+        query = querier.search(params)
+        query = querier.sort(params[:sort], query)
+        authorizer.accessible_for(:index, query)
       end
 
       # @param query [ActiveRecord::Relation]
       # @param params [ActionController::Parameters]
       # @return [ActiveRecord::Relation] paginated query
       def paginate(query, params)
-        per = (params[:per] || Wallaby.configuration.pagination.page_size).to_i
+        per = (params[:per] || Wallaby.controller_configuration.try(:page_size)).to_i
         page = [params[:page].to_i, 1].max # starting from page 1
-        query = query.offset((page - 1) * per).limit(per)
-        query
+        query.offset((page - 1) * per).limit(per) # rubocop:disable CodeReuse/ActiveRecord
       end
 
       # @note No mass assignment happens here!
@@ -45,7 +44,7 @@ module Wallaby
       # @return [Object] persisted resource object
       # @raise [Wallaby::ResourceNotFound] when record is not found
       def find(id, _params, _authorizer)
-        @model_class.find id
+        @model_class.find(id)
       rescue ::ActiveRecord::RecordNotFound
         raise ResourceNotFound, id
       end
@@ -55,7 +54,7 @@ module Wallaby
       # @param params [ActionController::Parameters]
       # @param authorizer [Wallaby::ModelAuthorizer]
       def create(resource, params, authorizer)
-        save __callee__, resource, params, authorizer
+        save(__callee__, resource, params, authorizer)
       end
 
       # Assign resource with new values and store it in database as an update.
@@ -63,7 +62,7 @@ module Wallaby
       # @param params [ActionController::Parameters]
       # @param authorizer [Wallaby::ModelAuthorizer]
       def update(resource, params, authorizer)
-        save __callee__, resource, params, authorizer
+        save(__callee__, resource, params, authorizer)
       end
 
       # Remove a record from database
@@ -82,19 +81,19 @@ module Wallaby
       # @return resource itself
       # @raise [ActiveRecord::StatementInvalid, ActiveModel::UnknownAttributeError, ActiveRecord::UnknownAttributeError]
       def save(action, resource, params, authorizer)
-        resource.assign_attributes normalize params
-        ensure_attributes_for authorizer, action, resource
-        resource.save if valid? resource
+        resource.assign_attributes(normalize(params))
+        ensure_attributes_for(authorizer, action, resource)
+        resource.save if valid?(resource)
         resource
       rescue ::ActiveRecord::ActiveRecordError, ActiveModel::ForbiddenAttributesError, unknown_attribute_error => e
-        resource.errors.add :base, e.message
+        resource.errors.add(:base, e.message)
         resource
       end
 
       # Normalize params
       # @param params [ActionController::Parameters]
       def normalize(params)
-        normalizer.normalize params
+        normalizer.normalize(params)
       end
 
       # See if a resource is valid
@@ -102,7 +101,7 @@ module Wallaby
       # @return [true] if valid
       # @return [false] otherwise
       def valid?(resource)
-        validator.valid? resource
+        validator.valid?(resource)
       end
 
       # To make sure that the record can be updated with the values that are
@@ -113,8 +112,8 @@ module Wallaby
       def ensure_attributes_for(authorizer, action, resource)
         return if authorizer.blank?
 
-        restricted_conditions = authorizer.attributes_for action, resource
-        resource.assign_attributes restricted_conditions
+        restricted_conditions = authorizer.attributes_for(action, resource)
+        resource.assign_attributes(restricted_conditions)
       end
 
       # @return [String] param key
@@ -122,7 +121,7 @@ module Wallaby
         @model_class.model_name.param_key
       end
 
-      # @return [Array] the list of attributes to whitelist for mass assignment
+      # @return [Array] the list of attributes to allowlist for mass assignment
       def permitted_fields
         @permitted_fields ||=
           permitter.simple_field_names << permitter.compound_hashed_fields
@@ -130,22 +129,22 @@ module Wallaby
 
       # @return [Wallaby::ActiveRecord::ModelServiceProvider::Permitter]
       def permitter
-        @permitter ||= Permitter.new @model_decorator
+        @permitter ||= Permitter.new(@model_decorator)
       end
 
       # @return [Wallaby::ActiveRecord::ModelServiceProvider::Querier]
       def querier
-        @querier ||= Querier.new @model_decorator
+        @querier ||= Querier.new(@model_decorator)
       end
 
       # @return [Wallaby::ActiveRecord::ModelServiceProvider::Normalizer]
       def normalizer
-        @normalizer ||= Normalizer.new @model_decorator
+        @normalizer ||= Normalizer.new(@model_decorator)
       end
 
       # @return [Wallaby::ActiveRecord::ModelServiceProvider::Validator]
       def validator
-        @validator ||= Validator.new @model_decorator
+        @validator ||= Validator.new(@model_decorator)
       end
 
       # @return [Class] ActiveModel::UnknownAttributeError if Rails 4

data/lib/wallaby/active_record/version.rb

@@ -2,6 +2,6 @@
 
 module Wallaby
   module ActiveRecordGem
-    VERSION = '0.2.7' # :nodoc:
+    VERSION = '0.3.0.beta1' # :nodoc:
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wallaby-active_record
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.3.0.beta1
 platform: ruby
 authors:
 - Tian Chen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-02 00:00:00.000000000 Z
+date: 2023-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -28,16 +28,16 @@ dependencies:
   name: wallaby-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.3
+        version: 0.3.0.beta1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.3
+        version: 0.3.0.beta1
 - !ruby/object:Gem::Dependency
   name: cancancan
   requirement: !ruby/object:Gem::Requirement
@@ -132,6 +132,7 @@ metadata:
   homepage_uri: https://github.com/wallaby-rails/wallaby-active_record
   source_code_uri: https://github.com/wallaby-rails/wallaby-active_record
   changelog_uri: https://github.com/wallaby-rails/wallaby-active_record/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -143,11 +144,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Wallaby's ActiveRecord ORM adapter