active_fields 0.2.0 → 1.0.0

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

@@ -1,85 +1,94 @@
 # frozen_string_literal: true
 
 module ActiveFields
-  # Mix-in that adds the active fields functionality to the ActiveRecord model
+  # Model mix-in that adds the active fields functionality to the customizable model
   module CustomizableConcern
     extend ActiveSupport::Concern
 
     included do
-      # active_values association for the owner record.
-      # We skip built-in autosave because it doesn't work if the owner record isn't changed.
-      # Instead, we implement our own autosave callback: `save_changed_active_values`.
       # rubocop:disable Rails/ReflectionClassName
       has_many :active_values,
         class_name: ActiveFields.config.value_class_name,
         as: :customizable,
         inverse_of: :customizable,
-        autosave: false,
+        autosave: true,
         dependent: :destroy
       # rubocop:enable Rails/ReflectionClassName
 
-      # Firstly, we build active_values that hasn't been already created.
-      # Than, we set values for active_values whose values should be changed
-      # according to `active_values_attributes`.
-      before_validation :initialize_active_values
-
-      # Save all changed active_values on the owner record save.
-      after_save :save_changed_active_values
-
-      # We always validate active_values on the owner record change,
-      # as if they are just an ordinary record columns.
-      validates_associated :active_values
-
-      # This virtual attribute is used for setting active_values values.
-      # Keys are active_fields names,
-      # values are values for corresponding active_values of the record.
-      attr_reader :active_values_attributes
+      accepts_nested_attributes_for :active_values, allow_destroy: true
     end
 
     def active_fields
       ActiveFields.config.field_base_class.for(model_name.name)
     end
 
-    # Convert hash keys to strings for easier access by fields names.
-    def active_values_attributes=(value)
-      @active_values_attributes =
-        if value.respond_to?(:to_h)
-          value.to_h.transform_keys(&:to_s)
-        else
-          value
-        end
-    end
+    # Assigns the given attributes to the active_values association.
+    #
+    # Accepts an Array of Hashes (symbol/string keys) 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.
+    # Element with a <tt>:_destroy</tt> key set to a truthy value will mark the
+    # matched active_value for destruction.
+    #
+    # Example:
+    #
+    #   customizable.active_fields_attributes = [
+    #     { name: "integer_array", value: [1, 4, 5, 5, 0] }, # create or update (symbol keys)
+    #     { "name" => "text", "value" => "Lasso" }, # create or update (string keys)
+    #     { name: "date", _destroy: true }, # destroy (symbol keys)
+    #     { "name" => "boolean", "_destroy" => true }, # destroy (string keys)
+    #     permitted_params, # params could be passed, but they must be permitted
+    #   ]
+    def active_fields_attributes=(attributes)
+      attributes = attributes.to_h if attributes.respond_to?(:permitted?)
+
+      unless attributes.is_a?(Array) || attributes.is_a?(Hash)
+        raise ArgumentError, "Array or Hash expected for `active_fields=`, got #{attributes.class.name}"
+      end
 
-    private
+      # Handle `fields_for` params
+      attributes = attributes.values if attributes.is_a?(Hash)
 
-    def initialize_active_values
-      active_fields.each do |active_field|
-        active_value =
-          find_active_value_by_field(active_field) ||
-          active_values.new(active_field: active_field, value: active_field.default_value)
+      active_fields_by_name = active_fields.index_by(&:name)
+      active_values_by_field_id = active_values.index_by(&:active_field_id)
+
+      nested_attributes = attributes.filter_map do |active_value_attributes|
+        # Convert params to Hash
+        active_value_attributes = active_value_attributes.to_h if active_value_attributes.respond_to?(:permitted?)
+        active_value_attributes = active_value_attributes.with_indifferent_access
 
-        next unless active_values_attributes.is_a?(Hash)
-        next unless active_values_attributes.key?(active_field.name)
+        active_field = active_fields_by_name[active_value_attributes[:name]]
+        next if active_field.nil?
 
-        active_value.value = active_values_attributes[active_field.name]
+        active_value = active_values_by_field_id[active_field.id]
+
+        if has_destroy_flag?(active_value_attributes)
+          # Destroy
+          { id: active_value&.id, _destroy: true }
+        elsif active_value
+          # Update
+          { id: active_value.id, value: active_value_attributes[:value] }
+        else
+          # Create
+          { active_field: active_field, value: active_value_attributes[:value] }
+        end
       end
+
+      self.active_values_attributes = nested_attributes
     end
 
-    def save_changed_active_values
-      active_values.each do |active_value|
-        next unless active_value.new_record? || active_value.changed?
+    alias_method :active_fields=, :active_fields_attributes=
 
-        # For new records association id isn't set right, so we force reassignment of the customizable
-        active_value.customizable = self
+    # Build an active_value, if it doesn't exist, with a default value for each available active_field
+    def initialize_active_values
+      existing_field_ids = active_values.map(&:active_field_id)
 
-        # Do not validate active values twice,
-        # because they have already been validated by `validates_associated`.
-        active_value.save!(validate: false)
-      end
-    end
+      active_fields.each do |active_field|
+        next if existing_field_ids.include?(active_field.id)
 
-    def find_active_value_by_field(active_field)
-      active_values.find { |active_value| active_value.active_field_id == active_field.id }
+        active_values.new(active_field: active_field, value: active_field.default_value)
+      end
     end
   end
 end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  # Model mix-in that adds array functionality to the active fields model
+  module FieldArrayConcern
+    extend ActiveSupport::Concern
+
+    included do
+      store_accessor :options, :min_size, :max_size
+
+      validates :min_size, comparison: { greater_than_or_equal_to: 0 }, allow_nil: true
+      validates :max_size, comparison: { greater_than_or_equal_to: ->(r) { r.min_size || 0 } }, allow_nil: true
+
+      %i[min_size max_size].each do |column|
+        define_method(column) do
+          Casters::IntegerCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(Casters::IntegerCaster.new.serialize(other))
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveFields
-  # Mix-in with a base logic for the active fields model
+  # Model mix-in with a base logic for the active fields model
   module FieldConcern
     extend ActiveSupport::Concern
 
@@ -22,36 +22,63 @@ module ActiveFields
       validate :validate_default_value
       validate :validate_customizable_model_allows_type
 
-      after_create :add_field_to_records
       after_initialize :set_defaults
     end
 
-    def value_validator_class
-      @value_validator_class ||= "ActiveFields::Validators::#{model_name.name.demodulize}Validator".constantize
-    end
+    class_methods do
+      def acts_as_active_field(array: false, validator:, caster:)
+        include FieldArrayConcern if array
 
-    def value_validator
-      value_validator_class.new(self)
-    end
+        define_method(:array?) { array }
 
-    def value_caster_class
-      @value_caster_class ||= "ActiveFields::Casters::#{model_name.name.demodulize}Caster".constantize
-    end
+        define_method(:value_validator_class) do
+          @value_validator_class ||= validator[:class_name].constantize
+        end
+
+        define_method(:value_validator) do
+          options =
+            if validator[:options].nil?
+              {}
+            elsif validator[:options].arity == 0
+              instance_exec(&validator[:options])
+            else
+              validator[:options].call(self)
+            end
+          value_validator_class.new(**options)
+        end
+
+        define_method(:value_caster_class) do
+          @value_caster_class ||= caster[:class_name].constantize
+        end
 
-    def value_caster
-      value_caster_class.new
+        define_method(:value_caster) do
+          options =
+            if caster[:options].nil?
+              {}
+            elsif caster[:options].arity == 0
+              instance_exec(&caster[:options])
+            else
+              caster[:options].call(self)
+            end
+          value_caster_class.new(**options)
+        end
+      end
     end
 
     def customizable_model
-      customizable_type.constantize
+      customizable_type.safe_constantize
     end
 
     def default_value=(v)
-      super(value_caster.serialize(v))
+      default_value_meta["const"] = value_caster.serialize(v)
     end
 
     def default_value
-      value_caster.deserialize(super)
+      value_caster.deserialize(default_value_meta["const"])
+    end
+
+    def type_name
+      ActiveFields.config.fields.key(type)
     end
 
     private
@@ -72,19 +99,13 @@ module ActiveFields
     end
 
     def validate_customizable_model_allows_type
-      allowed_types = customizable_model.active_fields_config&.types || []
-      return true if ActiveFields.config.fields.values_at(*allowed_types).include?(type)
+      allowed_types = customizable_model&.active_fields_config&.types || []
+      return true if allowed_types.include?(type_name)
 
       errors.add(:customizable_type, :inclusion)
       false
     end
 
-    def add_field_to_records
-      customizable_model.find_each do |record|
-        ActiveFields.config.value_class.create!(active_field: self, customizable: record, value: default_value)
-      end
-    end
-
     def set_defaults; end
   end
 end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveFields
-  # Mix-in with a base logic for the active fields value model
+  # Model mix-in with a base logic for the active fields value model
   module ValueConcern
     extend ActiveSupport::Concern
 
@@ -14,17 +14,32 @@ module ActiveFields
         inverse_of: :active_values
       # rubocop:enable Rails/ReflectionClassName
 
-      validates :active_field_id, uniqueness: { scope: %i[customizable_id customizable_type] }
+      validates :active_field, uniqueness: { scope: :customizable }
       validate :validate_value
       validate :validate_customizable_allowed
+
+      before_validation :assign_value_from_temp, if: -> { temp_value && active_field }
     end
 
+    delegate :name, to: :active_field, allow_nil: true
+
+    attr_reader :temp_value
+
     def value=(v)
-      super(active_field&.value_caster&.serialize(v))
+      if active_field
+        clear_temp_value
+        value_meta["const"] = active_field.value_caster.serialize(v)
+      else
+        assign_temp_value(v)
+      end
     end
 
     def value
-      active_field&.value_caster&.deserialize(super)
+      return unless active_field
+
+      assign_value_from_temp if temp_value
+
+      active_field.value_caster.deserialize(value_meta["const"])
     end
 
     private
@@ -51,5 +66,18 @@ module ActiveFields
       errors.add(:customizable, :invalid)
       false
     end
+
+    # Wrap the provided value to differentiate between explicitly setting it to nil and not setting it at all
+    def assign_temp_value(v)
+      @temp_value = { "value" => v }
+    end
+
+    def clear_temp_value
+      @temp_value = nil
+    end
+
+    def assign_value_from_temp
+      self.value = temp_value["value"]
+    end
   end
 end

data/db/migrate/20240229230000_create_active_fields_tables.rb

@@ -6,7 +6,7 @@ class CreateActiveFieldsTables < ActiveRecord::Migration[6.0]
       t.string :name, null: false
       t.string :type, null: false
       t.string :customizable_type, null: false
-      t.jsonb :default_value
+      t.jsonb :default_value_meta, null: false, default: {}
       t.jsonb :options, null: false, default: {}
 
       t.timestamps
@@ -20,7 +20,7 @@ class CreateActiveFieldsTables < ActiveRecord::Migration[6.0]
       t.references :active_field,
         null: false,
         foreign_key: { to_table: :active_fields, name: "active_fields_values_active_field_id_fk" }
-      t.jsonb :value
+      t.jsonb :value_meta, null: false, default: {}
 
       t.timestamps
 

data/lib/active_fields/casters/base_caster.rb

@@ -4,12 +4,18 @@ module ActiveFields
   module Casters
     # Typecasts the active_value value
     class BaseCaster
-      # To raw DB value
+      attr_reader :options
+
+      def initialize(**options)
+        @options = options
+      end
+
+      # To raw AR attribute value
       def serialize(value)
         raise NotImplementedError
       end
 
-      # From raw DB value
+      # From raw AR attribute value
       def deserialize(value)
         raise NotImplementedError
       end

data/lib/active_fields/casters/date_caster.rb

@@ -4,19 +4,21 @@ module ActiveFields
   module Casters
     class DateCaster < BaseCaster
       def serialize(value)
-        cast(value)&.iso8601
+        casted_value = caster.serialize(value)
+
+        casted_value.iso8601 if casted_value.is_a?(Date)
       end
 
       def deserialize(value)
-        cast(value)
+        casted_value = caster.deserialize(value)
+
+        casted_value if casted_value.is_a?(Date)
       end
 
       private
 
-      def cast(value)
-        casted_value = ActiveModel::Type::Date.new.cast(value)
-
-        casted_value if casted_value.acts_like?(:date)
+      def caster
+        ActiveRecord::Type::Date.new
       end
     end
   end

data/lib/active_fields/casters/date_time_array_caster.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Casters
+    class DateTimeArrayCaster < DateTimeCaster
+      def serialize(value)
+        return unless value.is_a?(Array)
+
+        value.map { super(_1) }
+      end
+
+      def deserialize(value)
+        return unless value.is_a?(Array)
+
+        value.map { super(_1) }
+      end
+    end
+  end
+end

data/lib/active_fields/casters/date_time_caster.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+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)
+
+        casted_value.iso8601(precision) if casted_value.acts_like?(:time)
+      end
+
+      def deserialize(value)
+        value = value.iso8601 if value.is_a?(Date)
+        casted_value = caster.deserialize(value)
+
+        apply_precision(casted_value).in_time_zone if casted_value.acts_like?(:time)
+      end
+
+      private
+
+      def caster
+        ActiveRecord::Type::DateTime.new
+      end
+
+      # 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
+      end
+
+      def apply_precision(value)
+        number_of_insignificant_digits = 9 - precision
+        round_power = 10**number_of_insignificant_digits
+        rounded_off_nsec = value.nsec % round_power
+
+        value.change(nsec: value.nsec - rounded_off_nsec)
+      end
+    end
+  end
+end

data/lib/active_fields/casters/decimal_caster.rb

@@ -4,7 +4,8 @@ module ActiveFields
   module Casters
     class DecimalCaster < BaseCaster
       def serialize(value)
-        cast(value)
+        # Decimals should be saved as strings to avoid potential precision loss when stored in JSON
+        cast(value)&.to_s
       end
 
       def deserialize(value)
@@ -14,7 +15,14 @@ module ActiveFields
       private
 
       def cast(value)
-        BigDecimal(value, 0, exception: false)
+        casted = BigDecimal(value, 0, exception: false)
+        casted = casted.truncate(precision) if casted && precision
+
+        casted
+      end
+
+      def precision
+        options[:precision]
       end
     end
   end

data/lib/active_fields/casters/enum_array_caster.rb

@@ -2,6 +2,18 @@
 
 module ActiveFields
   module Casters
-    class EnumArrayCaster < TextArrayCaster; end
+    class EnumArrayCaster < EnumCaster
+      def serialize(value)
+        return unless value.is_a?(Array)
+
+        value.map { super(_1) }
+      end
+
+      def deserialize(value)
+        return unless value.is_a?(Array)
+
+        value.map { super(_1) }
+      end
+    end
   end
 end

data/lib/active_fields/casters/enum_caster.rb

@@ -2,6 +2,20 @@
 
 module ActiveFields
   module Casters
-    class EnumCaster < TextCaster; end
+    class EnumCaster < BaseCaster
+      def serialize(value)
+        cast(value)
+      end
+
+      def deserialize(value)
+        cast(value)
+      end
+
+      private
+
+      def cast(value)
+        value&.to_s.presence
+      end
+    end
   end
 end

data/lib/active_fields/casters/integer_caster.rb

@@ -2,7 +2,7 @@
 
 module ActiveFields
   module Casters
-    class IntegerCaster < DecimalCaster
+    class IntegerCaster < BaseCaster
       def serialize(value)
         cast(value)
       end
@@ -14,7 +14,7 @@ module ActiveFields
       private
 
       def cast(value)
-        super&.to_i
+        BigDecimal(value, 0, exception: false)&.to_i
       end
     end
   end

data/lib/active_fields/config.rb

@@ -7,7 +7,8 @@ module ActiveFields
 
     include Singleton
 
-    attr_accessor :field_base_class_name, :value_class_name, :fields
+    attr_accessor :field_base_class_name, :value_class_name
+    attr_reader :fields
 
     def initialize
       @field_base_class_name = DEFAULT_FIELD_BASE_CLASS_NAME
@@ -16,6 +17,8 @@ module ActiveFields
         boolean: "ActiveFields::Field::Boolean",
         date: "ActiveFields::Field::Date",
         date_array: "ActiveFields::Field::DateArray",
+        datetime: "ActiveFields::Field::DateTime",
+        datetime_array: "ActiveFields::Field::DateTimeArray",
         decimal: "ActiveFields::Field::Decimal",
         decimal_array: "ActiveFields::Field::DecimalArray",
         enum: "ActiveFields::Field::Enum",
@@ -46,5 +49,13 @@ module ActiveFields
     def register_field(type_name, class_name)
       @fields[type_name.to_sym] = class_name
     end
+
+    def type_names
+      fields.keys
+    end
+
+    def type_class_names
+      fields.values
+    end
   end
 end

data/lib/active_fields/customizable_config.rb

@@ -9,7 +9,7 @@ module ActiveFields
     end
 
     def types=(value)
-      invalid_types = value - ActiveFields.config.fields.keys
+      invalid_types = value - ActiveFields.config.type_names
       if invalid_types.any?
         raise ArgumentError, "undefined ActiveFields types provided for #{customizable_model}: #{invalid_types}"
       end

data/lib/active_fields/has_active_fields.rb

@@ -8,7 +8,7 @@ module ActiveFields
     class_methods do
       attr_reader :active_fields_config
 
-      def has_active_fields(types: ActiveFields.config.fields.keys)
+      def has_active_fields(types: ActiveFields.config.type_names)
         include CustomizableConcern
 
         @active_fields_config = CustomizableConfig.new(self)

data/lib/active_fields/validators/base_validator.rb

@@ -4,24 +4,28 @@ module ActiveFields
   module Validators
     # Validates the active_value value
     class BaseValidator
-      attr_reader :active_field, :errors
+      attr_reader :options, :errors
 
-      def initialize(active_field)
-        @active_field = active_field
+      def initialize(**options)
+        @options = options
         @errors = Set.new
       end
 
+      # Performs the validation and adds errors to the `errors` list.
+      # Returns `true` if no errors are found, `false` otherwise.
       def validate(value)
         perform_validation(value)
         valid?
       end
 
+      # Returns `true` if no errors are found, `false` otherwise.
       def valid?
         errors.empty?
       end
 
       private
 
+      # Performs the validation. If there are any errors, it should save them in `errors`.
       def perform_validation(value)
         raise NotImplementedError
       end

data/lib/active_fields/validators/boolean_validator.rb

@@ -7,9 +7,9 @@ module ActiveFields
 
       def perform_validation(value)
         if value.nil?
-          errors << :exclusion unless active_field.nullable?
+          errors << :exclusion unless options[:nullable]
         elsif value.is_a?(FalseClass)
-          errors << :required if active_field.required?
+          errors << :required if options[:required]
         elsif value.is_a?(TrueClass)
           nil
         else