active_fields 1.0.0 → 2.0.0

data/app/models/active_fields/field/boolean.rb

@@ -11,6 +11,9 @@ module ActiveFields
         caster: {
           class_name: "ActiveFields::Casters::BooleanCaster",
         },
+        finder: {
+          class_name: "ActiveFields::Finders::BooleanFinder",
+        },
       )
 
       store_accessor :options, :required, :nullable

data/app/models/active_fields/field/date.rb

@@ -11,6 +11,9 @@ module ActiveFields
         caster: {
           class_name: "ActiveFields::Casters::DateCaster",
         },
+        finder: {
+          class_name: "ActiveFields::Finders::DateFinder",
+        },
       )
 
       store_accessor :options, :required, :min, :max

data/app/models/active_fields/field/date_array.rb

@@ -12,6 +12,9 @@ module ActiveFields
         caster: {
           class_name: "ActiveFields::Casters::DateArrayCaster",
         },
+        finder: {
+          class_name: "ActiveFields::Finders::DateArrayFinder",
+        },
       )
 
       store_accessor :options, :min, :max

data/app/models/active_fields/field/date_time.rb

@@ -12,6 +12,9 @@ module ActiveFields
           class_name: "ActiveFields::Casters::DateTimeCaster",
           options: -> { { precision: precision } },
         },
+        finder: {
+          class_name: "ActiveFields::Finders::DateTimeFinder",
+        },
       )
 
       store_accessor :options, :required, :min, :max, :precision
@@ -19,7 +22,7 @@ module ActiveFields
       validates :required, exclusion: [nil]
       validates :max, comparison: { greater_than_or_equal_to: :min }, allow_nil: true, if: :min
       validates :precision,
-        comparison: { greater_than_or_equal_to: 0, less_than_or_equal_to: Casters::DateTimeCaster::MAX_PRECISION },
+        comparison: { greater_than_or_equal_to: 0, less_than_or_equal_to: ActiveFields::MAX_DATETIME_PRECISION },
         allow_nil: true
 
       # If precision is set after attributes that depend on it, deserialization will work correctly,

data/app/models/active_fields/field/date_time_array.rb

@@ -13,13 +13,16 @@ module ActiveFields
           class_name: "ActiveFields::Casters::DateTimeArrayCaster",
           options: -> { { precision: precision } },
         },
+        finder: {
+          class_name: "ActiveFields::Finders::DateTimeArrayFinder",
+        },
       )
 
       store_accessor :options, :min, :max, :precision
 
       validates :max, comparison: { greater_than_or_equal_to: :min }, allow_nil: true, if: :min
       validates :precision,
-        comparison: { greater_than_or_equal_to: 0, less_than_or_equal_to: Casters::DateTimeCaster::MAX_PRECISION },
+        comparison: { greater_than_or_equal_to: 0, less_than_or_equal_to: ActiveFields::MAX_DATETIME_PRECISION },
         allow_nil: true
 
       # If precision is set after attributes that depend on it, deserialization will work correctly,

data/app/models/active_fields/field/decimal.rb

@@ -12,13 +12,18 @@ module ActiveFields
           class_name: "ActiveFields::Casters::DecimalCaster",
           options: -> { { precision: precision } },
         },
+        finder: {
+          class_name: "ActiveFields::Finders::DecimalFinder",
+        },
       )
 
       store_accessor :options, :required, :min, :max, :precision
 
       validates :required, exclusion: [nil]
       validates :max, comparison: { greater_than_or_equal_to: :min }, allow_nil: true, if: :min
-      validates :precision, comparison: { greater_than_or_equal_to: 0 }, allow_nil: true
+      validates :precision,
+        comparison: { greater_than_or_equal_to: 0, less_than_or_equal_to: ActiveFields::MAX_DECIMAL_PRECISION },
+        allow_nil: true
 
       # If precision is set after attributes that depend on it, deserialization will work correctly,
       # but an incorrect internal value may be saved in the DB.

data/app/models/active_fields/field/decimal_array.rb

@@ -13,12 +13,17 @@ module ActiveFields
           class_name: "ActiveFields::Casters::DecimalArrayCaster",
           options: -> { { precision: precision } },
         },
+        finder: {
+          class_name: "ActiveFields::Finders::DecimalArrayFinder",
+        },
       )
 
       store_accessor :options, :min, :max, :precision
 
       validates :max, comparison: { greater_than_or_equal_to: :min }, allow_nil: true, if: :min
-      validates :precision, comparison: { greater_than_or_equal_to: 0 }, allow_nil: true
+      validates :precision,
+        comparison: { greater_than_or_equal_to: 0, less_than_or_equal_to: ActiveFields::MAX_DECIMAL_PRECISION },
+        allow_nil: true
 
       # If precision is set after attributes that depend on it, deserialization will work correctly,
       # but an incorrect internal value may be saved in the DB.

data/app/models/active_fields/field/enum.rb

@@ -11,6 +11,9 @@ module ActiveFields
         caster: {
           class_name: "ActiveFields::Casters::EnumCaster",
         },
+        finder: {
+          class_name: "ActiveFields::Finders::EnumFinder",
+        },
       )
 
       store_accessor :options, :required, :allowed_values

data/app/models/active_fields/field/enum_array.rb

@@ -12,6 +12,9 @@ module ActiveFields
         caster: {
           class_name: "ActiveFields::Casters::EnumArrayCaster",
         },
+        finder: {
+          class_name: "ActiveFields::Finders::EnumArrayFinder",
+        },
       )
 
       store_accessor :options, :allowed_values

data/app/models/active_fields/field/integer.rb

@@ -11,6 +11,9 @@ module ActiveFields
         caster: {
           class_name: "ActiveFields::Casters::IntegerCaster",
         },
+        finder: {
+          class_name: "ActiveFields::Finders::IntegerFinder",
+        },
       )
 
       store_accessor :options, :required, :min, :max

data/app/models/active_fields/field/integer_array.rb

@@ -12,6 +12,9 @@ module ActiveFields
         caster: {
           class_name: "ActiveFields::Casters::IntegerArrayCaster",
         },
+        finder: {
+          class_name: "ActiveFields::Finders::IntegerArrayFinder",
+        },
       )
 
       store_accessor :options, :min, :max

data/app/models/active_fields/field/text.rb

@@ -11,6 +11,9 @@ module ActiveFields
         caster: {
           class_name: "ActiveFields::Casters::TextCaster",
         },
+        finder: {
+          class_name: "ActiveFields::Finders::TextFinder",
+        },
       )
 
       store_accessor :options, :required, :min_length, :max_length

data/app/models/active_fields/field/text_array.rb

@@ -14,6 +14,9 @@ module ActiveFields
         caster: {
           class_name: "ActiveFields::Casters::TextArrayCaster",
         },
+        finder: {
+          class_name: "ActiveFields::Finders::TextArrayFinder",
+        },
       )
 
       store_accessor :options, :min_length, :max_length

data/app/models/active_fields/field.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Field; end
+end

data/app/models/concerns/active_fields/customizable_concern.rb

@@ -15,16 +15,95 @@ module ActiveFields
         dependent: :destroy
       # rubocop:enable Rails/ReflectionClassName
 
+      # Searches customizables by active_values.
+      #
+      # Accepts an Array of Hashes (symbol/string keys),
+      # a Hash of Hashes generated from HTTP/HTML parameters
+      # or permitted params.
+      # Each element should contain:
+      # - <tt>:n</tt> or <tt>:name</tt> key matching the active_field record name;
+      # - <tt>:op</tt> or <tt>:operator</tt> key specifying search operation or operator;
+      # - <tt>:v</tt> or <tt>:value</tt> key specifying search value.
+      #
+      # Example:
+      #
+      #   # Array of hashes
+      #   CustomizableModel.where_active_fields(
+      #     [
+      #       { name: "integer_array", operator: "any_gteq", value: 5 }, # symbol keys
+      #       { "name" => "text", operator: "=", "value" => "Lasso" }, # string keys
+      #       { n: "boolean", op: "!=", v: false }, # compact form (string or symbol keys)
+      #     ],
+      #   )
+      #
+      #   # Hash of hashes generated from HTTP/HTML parameters
+      #   CustomizableModel.where_active_fields(
+      #     {
+      #       "0" => { name: "integer_array", operator: "any_gteq", value: 5 },
+      #       "1" => { "name" => "text", operator: "=", "value" => "Lasso" },
+      #       "2" => { n: "boolean", op: "!=", v: false },
+      #     },
+      #   )
+      #
+      #   # Params (must be permitted)
+      #   CustomizableModel.where_active_fields(permitted_params)
+      scope :where_active_fields, ->(filters) do
+        filters = filters.to_h if filters.respond_to?(:permitted?)
+
+        unless filters.is_a?(Array) || filters.is_a?(Hash)
+          raise ArgumentError, "Hash or Array expected for `where_active_fields`, got #{filters.class.name}"
+        end
+
+        # Handle `fields_for` params
+        filters = filters.values if filters.is_a?(Hash)
+
+        active_fields_by_name = active_fields.index_by(&:name)
+
+        filters.inject(self) do |scope, filter|
+          filter = filter.to_h if filter.respond_to?(:permitted?)
+          filter = filter.with_indifferent_access
+
+          active_field = active_fields_by_name[filter[:n] || filter[:name]]
+          next scope if active_field.nil?
+          next scope if active_field.value_finder.nil?
+
+          active_values = active_field.value_finder.search(
+            op: filter[:op] || filter[:operator],
+            value: filter[:v] || filter[:value],
+          )
+          next scope if active_values.nil?
+
+          scope.where(id: active_values.select(:customizable_id))
+        end
+      end
+
       accepts_nested_attributes_for :active_values, allow_destroy: true
     end
 
-    def active_fields
-      ActiveFields.config.field_base_class.for(model_name.name)
+    class_methods do
+      # Collection of active fields registered for this customizable
+      def active_fields
+        ActiveFields.config.field_base_class.for(name)
+      end
+
+      # Returns active fields type names allowed for this customizable model.
+      def allowed_active_fields_type_names
+        ActiveFields.registry.field_type_names_for(name).to_a
+      end
+
+      # Returns active fields class names allowed for this customizable model.
+      def allowed_active_fields_class_names
+        ActiveFields.config.fields.values_at(*allowed_active_fields_type_names)
+      end
     end
 
+    delegate :active_fields, to: :class
+
     # Assigns the given attributes to the active_values association.
     #
-    # Accepts an Array of Hashes (symbol/string keys) or permitted params.
+    # Accepts an Array of Hashes (symbol/string keys),
+    # a Hash of Hashes generated from HTTP/HTML parameters
+    # or permitted params.
     # Each element should contain a <tt>:name</tt> key matching an existing active_field record.
     # Element with a <tt>:value</tt> key will create an active_value if it doesn't exist
     # or update an existing active_value, with the provided value.
@@ -40,6 +119,13 @@ module ActiveFields
     #     { "name" => "boolean", "_destroy" => true }, # destroy (string keys)
     #     permitted_params, # params could be passed, but they must be permitted
     #   ]
+    #
+    #   customizable.active_fields_attributes = {
+    #     "0" => { name: "integer_array", value: [1, 4, 5, 5, 0] }, # create or update (symbol keys)
+    #     "1" => { "name" => "text", "value" => "Lasso" }, # create or update (string keys)
+    #     "2" => { name: "date", _destroy: true }, # destroy (symbol keys)
+    #     "3" => { "name" => "boolean", "_destroy" => true }, # destroy (string keys)
+    #   }
     def active_fields_attributes=(attributes)
       attributes = attributes.to_h if attributes.respond_to?(:permitted?)
 
@@ -80,7 +166,8 @@ module ActiveFields
 
     alias_method :active_fields=, :active_fields_attributes=
 
-    # Build an active_value, if it doesn't exist, with a default value for each available active_field
+    # Build an active_value, if it doesn't exist, with a default value for each available active_field.
+    # Returns active_values collection.
     def initialize_active_values
       existing_field_ids = active_values.map(&:active_field_id)
 
@@ -89,6 +176,8 @@ module ActiveFields
 
         active_values.new(active_field: active_field, value: active_field.default_value)
       end
+
+      active_values
     end
   end
 end

data/app/models/concerns/active_fields/field_concern.rb

@@ -26,7 +26,7 @@ module ActiveFields
     end
 
     class_methods do
-      def acts_as_active_field(array: false, validator:, caster:)
+      def acts_as_active_field(array: false, validator:, caster:, finder: {})
         include FieldArrayConcern if array
 
         define_method(:array?) { array }
@@ -62,6 +62,14 @@ module ActiveFields
             end
           value_caster_class.new(**options)
         end
+
+        define_method(:value_finder_class) do
+          @value_finder_class ||= finder[:class_name]&.constantize
+        end
+
+        define_method(:value_finder) do
+          value_finder_class&.new(active_field: self)
+        end
       end
     end
 
@@ -81,6 +89,21 @@ module ActiveFields
       ActiveFields.config.fields.key(type)
     end
 
+    # Returns customizable types that allow this field type.
+    #
+    # Notes:
+    # - The customizable model must be loaded to appear in this list.
+    #   Relationships between customizable models and field types are established in the `has_active_fields` method,
+    #   which is typically called within the customizable model.
+    #   If eager loading is enabled, there should be no issues.
+    #   However, if eager loading is disabled (common in development),
+    #   the list will remain incomplete until all customizable models are loaded.
+    # - Code reloading may behave incorrectly at times.
+    #   Restart your application if you make changes to the allowed types list in `has_active_fields`.
+    def available_customizable_types
+      ActiveFields.registry.customizable_types_for(type_name).to_a
+    end
+
     private
 
     def validate_default_value
@@ -99,8 +122,8 @@ module ActiveFields
     end
 
     def validate_customizable_model_allows_type
-      allowed_types = customizable_model&.active_fields_config&.types || []
-      return true if allowed_types.include?(type_name)
+      allowed_type_names = ActiveFields.registry.field_type_names_for(customizable_type).to_a
+      return true if allowed_type_names.include?(type_name)
 
       errors.add(:customizable_type, :inclusion)
       false

data/db/migrate/20240229230000_create_active_fields_tables.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class CreateActiveFieldsTables < ActiveRecord::Migration[6.0]
+class CreateActiveFieldsTables < ActiveRecord::Migration[7.1]
   def change
     create_table :active_fields do |t|
       t.string :name, null: false

data/lib/active_fields/casters/date_time_caster.rb

@@ -3,8 +3,6 @@
 module ActiveFields
   module Casters
     class DateTimeCaster < BaseCaster
-      MAX_PRECISION = RUBY_VERSION >= "3.2" ? 9 : 6 # AR max precision is 6 for old Rubies
-
       def serialize(value)
         value = value.iso8601 if value.is_a?(Date)
         casted_value = caster.serialize(value)
@@ -28,7 +26,7 @@ module ActiveFields
       # Use maximum precision by default to prevent the caster from truncating useful time information
       # before precision is applied later
       def precision
-        [options[:precision], MAX_PRECISION].compact.min
+        [options[:precision], ActiveFields::MAX_DATETIME_PRECISION].compact.min
       end
 
       def apply_precision(value)

data/lib/active_fields/casters/decimal_caster.rb

@@ -15,14 +15,11 @@ module ActiveFields
       private
 
       def cast(value)
-        casted = BigDecimal(value, 0, exception: false)
-        casted = casted.truncate(precision) if casted && precision
-
-        casted
+        BigDecimal(value, 0, exception: false)&.truncate(precision)
       end
 
       def precision
-        options[:precision]
+        [options[:precision], ActiveFields::MAX_DECIMAL_PRECISION].compact.min
       end
     end
   end

data/lib/active_fields/constants.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  # Ruby supports up to 9 fractional seconds, but PostgreSQL, like most databases, supports only 6.
+  # Since we use PostgreSQL, we standardize on 6.
+  MAX_DATETIME_PRECISION = 6
+
+  # Ruby's BigDecimal class allows extremely high precision,
+  # but PostgreSQL supports a maximum of 16383 digits after the decimal point.
+  # Since we use PostgreSQL, we limit decimal precision to 16383.
+  MAX_DECIMAL_PRECISION = 2**14 - 1
+
+  OPS = {
+    eq: :"=",
+    not_eq: :"!=",
+    gt: :">",
+    gteq: :">=",
+    lt: :"<",
+    lteq: :"<=",
+
+    start_with: :"^",
+    end_with: :"$",
+    contain: :"~",
+    not_start_with: :"!^",
+    not_end_with: :"!$",
+    not_contain: :"!~",
+    istart_with: :"^*",
+    iend_with: :"$*",
+    icontain: :"~*",
+    not_istart_with: :"!^*",
+    not_iend_with: :"!$*",
+    not_icontain: :"!~*",
+
+    include: :"|=",
+    not_include: :"!|=",
+    any_gt: :"|>",
+    any_gteq: :"|>=",
+    any_lt: :"|<",
+    any_lteq: :"|<=",
+    all_gt: :"&>",
+    all_gteq: :"&>=",
+    all_lt: :"&<",
+    all_lteq: :"&<=",
+
+    size_eq: :"#=",
+    size_not_eq: :"#!=",
+    size_gt: :"#>",
+    size_gteq: :"#>=",
+    size_lt: :"#<",
+    size_lteq: :"#<=",
+
+    any_start_with: :"|^",
+    all_start_with: :"&^",
+  }.freeze
+end

data/lib/active_fields/engine.rb

@@ -4,6 +4,13 @@ module ActiveFields
   class Engine < ::Rails::Engine
     isolate_namespace ActiveFields
 
+    config.eager_load_namespaces << ActiveFields
+
+    # Disable models reloading to avoid STI issues.
+    # Reloading can prevent subclasses from recognizing the base class.
+    config.autoload_once_paths << "#{root}/app/models"
+    config.autoload_once_paths << "#{root}/app/models/concerns"
+
     initializer "active_fields.active_record" do
       ActiveSupport.on_load(:active_record) do
         include HasActiveFields

data/lib/active_fields/finders/array_finder.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class ArrayFinder < BaseFinder
+      private
+
+      # This method defines a JSONPath query for searching within a `jsonb` field.
+      # It must be implemented in a subclass and include a `$value` parameter,
+      # which will be replaced with the provided value during search operations.
+      # Refer to descendant implementations for examples.
+      # For more details, see the PostgreSQL documentation: https://www.postgresql.org/docs/current/functions-json.html
+      def jsonpath(operator) = raise NotImplementedError
+
+      # Arel query node that searches for records where any element matches the JSONPath
+      def value_match_any(operator, value)
+        jsonb_path_exists(
+          value_field_jsonb,
+          jsonpath(operator),
+          { value: value },
+        )
+      end
+
+      # Arel query node that searches for records where all elements match the JSONPath
+      def value_match_all(operator, value)
+        jsonb_array_length(value_field_jsonb).gt(0)
+          .and(
+            jsonb_array_length(value_field_jsonb).eq(
+              jsonb_array_length(
+                jsonb_path_query_array(
+                  value_field_jsonb,
+                  jsonpath(operator),
+                  { value: value },
+                ),
+              ),
+            ),
+          )
+      end
+
+      # Arel query node that searches for records where the array size is equal to the provided value
+      def value_size_eq(value)
+        value = cast_int(value)
+        jsonb_array_length(value_field_jsonb).eq(value)
+      end
+
+      # Arel query node that searches for records where the array size is not equal to the provided value
+      def value_size_not_eq(value)
+        value = cast_int(value)
+        jsonb_array_length(value_field_jsonb).not_eq(value)
+      end
+
+      # Arel query node that searches for records where the array size is greater than the provided value
+      def value_size_gt(value)
+        value = cast_int(value)
+        jsonb_array_length(value_field_jsonb).gt(value)
+      end
+
+      # Arel query node that searches for records where the array size is greater than or equal to the provided value
+      def value_size_gteq(value)
+        value = cast_int(value)
+        jsonb_array_length(value_field_jsonb).gteq(value)
+      end
+
+      # Arel query node that searches for records where the array size is less than the provided value
+      def value_size_lt(value)
+        value = cast_int(value)
+        jsonb_array_length(value_field_jsonb).lt(value)
+      end
+
+      # Arel query node that searches for records where the array size is less than or equal to the provided value
+      def value_size_lteq(value)
+        value = cast_int(value)
+        jsonb_array_length(value_field_jsonb).lteq(value)
+      end
+
+      # Casts given value to integer, useful for querying by array size
+      def cast_int(value)
+        Casters::IntegerCaster.new.deserialize(value)
+      end
+
+      # Arel node for `active_fields.value_meta->const`
+      def value_field_jsonb
+        Arel::Nodes::InfixOperation.new(
+          "->",
+          Arel::Table.new(cte_name)[:value_meta],
+          Arel::Nodes.build_quoted("const"),
+        )
+      end
+
+      # Arel node for `jsonb_path_exists` PostgreSQL function
+      def jsonb_path_exists(target, jsonpath, vars = nil)
+        Arel::Nodes::NamedFunction.new(
+          "jsonb_path_exists",
+          [target, *[jsonpath, vars&.to_json].compact.map { Arel::Nodes.build_quoted(_1) }],
+        )
+      end
+
+      # Arel node for `jsonb_path_query_array` PostgreSQL function
+      def jsonb_path_query_array(target, jsonpath, vars = nil)
+        Arel::Nodes::NamedFunction.new(
+          "jsonb_path_query_array",
+          [target, *[jsonpath, vars&.to_json].compact.map { Arel::Nodes.build_quoted(_1) }],
+        )
+      end
+
+      # Arel node for `jsonb_array_length` PostgreSQL function
+      def jsonb_array_length(target)
+        Arel::Nodes::NamedFunction.new("jsonb_array_length", [target])
+      end
+    end
+  end
+end

data/lib/active_fields/finders/base_finder.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class BaseFinder
+      class << self
+        # Define search operation
+        def operation(name, operator:, &block)
+          name = name.to_sym
+          operator = operator.to_sym
+
+          __operations__[name] = {
+            operator: operator.to_sym,
+            block: block,
+          }
+          __operators__[operator] = name
+        end
+
+        # Returns operator for provided search operation name
+        def operator_for(operation_name)
+          __operations__.dig(operation_name.to_sym, :operator)
+        end
+
+        # Returns search operation name for provided operator
+        def operation_for(operator)
+          __operators__[operator.to_sym]
+        end
+
+        # Returns all defined search operations names
+        def operations
+          __operations__.keys
+        end
+
+        # Storage for defined operations. Private.
+        def __operations__
+          @__operations__ ||= {}
+        end
+
+        # Index for finding operation by operator. Private.
+        def __operators__
+          @__operators__ ||= {}
+        end
+      end
+
+      attr_reader :active_field
+
+      def initialize(active_field:)
+        @active_field = active_field
+      end
+
+      # Perform query operation
+      # @param op [String, Symbol] Operation name or operator
+      # @param value [Any] The value to search for
+      def search(op:, value:)
+        op = op.to_sym
+        operation = self.class.__operations__.key?(op) ? op : self.class.__operators__[op]
+        return if operation.nil?
+
+        instance_exec(value, &self.class.__operations__[operation][:block])
+      end
+
+      private
+
+      # Name of the CTE, that is used in queries. It is the original values table name.
+      def cte_name = ActiveFields.config.value_class.table_name
+
+      # Base scope for querying
+      def scope
+        ActiveFields.config.value_class.with(cte_name => active_field.active_values)
+      end
+    end
+  end
+end