active_fields 0.1.0 → 1.0.0

data/{lib/active_fields/models → app/models/active_fields}/field/text.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
-require_relative "../field"
-
 module ActiveFields
-  class Field
-    class Text < ActiveFields::Field
-      store_accessor :options, :required, :min_length, :max_length
+  module Field
+    class Text < ActiveFields.config.field_base_class
+      acts_as_active_field(
+        validator: {
+          class_name: "ActiveFields::Validators::TextValidator",
+          options: -> { { required: required?, min_length: min_length, max_length: max_length } },
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::TextCaster",
+        },
+      )
 
-      # attribute :required, :boolean, default: false
-      # attribute :min_length, :integer
-      # attribute :max_length, :integer
+      store_accessor :options, :required, :min_length, :max_length
 
       validates :required, exclusion: [nil]
       validates :min_length, comparison: { greater_than_or_equal_to: 0 }, allow_nil: true
@@ -17,7 +21,7 @@ module ActiveFields
 
       %i[required].each do |column|
         define_method(column) do
-          ActiveFields::Casters::BooleanCaster.new.deserialize(super())
+          Casters::BooleanCaster.new.deserialize(super())
         end
 
         define_method(:"#{column}?") do
@@ -25,17 +29,17 @@ module ActiveFields
         end
 
         define_method(:"#{column}=") do |other|
-          super(ActiveFields::Casters::BooleanCaster.new.serialize(other))
+          super(Casters::BooleanCaster.new.serialize(other))
         end
       end
 
       %i[min_length max_length].each do |column|
         define_method(column) do
-          ActiveFields::Casters::IntegerCaster.new.deserialize(super())
+          Casters::IntegerCaster.new.deserialize(super())
         end
 
         define_method(:"#{column}=") do |other|
-          super(ActiveFields::Casters::IntegerCaster.new.serialize(other))
+          super(Casters::IntegerCaster.new.serialize(other))
         end
       end
 

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Field
+    class TextArray < ActiveFields.config.field_base_class
+      acts_as_active_field(
+        array: true,
+        validator: {
+          class_name: "ActiveFields::Validators::TextArrayValidator",
+          options: -> do
+            { min_length: min_length, max_length: max_length, min_size: min_size, max_size: max_size }
+          end,
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::TextArrayCaster",
+        },
+      )
+
+      store_accessor :options, :min_length, :max_length
+
+      validates :min_length, comparison: { greater_than_or_equal_to: 0 }, allow_nil: true
+      validates :max_length, comparison: { greater_than_or_equal_to: ->(r) { r.min_length || 0 } }, allow_nil: true
+
+      %i[min_length max_length].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
+
+      private
+
+      def set_defaults; end
+    end
+  end
+end

data/app/models/active_fields/value.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  # If value base class has been changed, we should prevent this model from being loaded.
+  # Since we cannot remove it entirely, we will not add any functionality to it.
+  if ActiveFields.config.value_class_changed?
+    class Value; end
+  else
+    class Value < ApplicationRecord
+      self.table_name = "active_fields_values"
+
+      include ValueConcern
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  # Model mix-in that adds the active fields functionality to the customizable model
+  module CustomizableConcern
+    extend ActiveSupport::Concern
+
+    included do
+      # rubocop:disable Rails/ReflectionClassName
+      has_many :active_values,
+        class_name: ActiveFields.config.value_class_name,
+        as: :customizable,
+        inverse_of: :customizable,
+        autosave: true,
+        dependent: :destroy
+      # rubocop:enable Rails/ReflectionClassName
+
+      accepts_nested_attributes_for :active_values, allow_destroy: true
+    end
+
+    def active_fields
+      ActiveFields.config.field_base_class.for(model_name.name)
+    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
+
+      # Handle `fields_for` params
+      attributes = attributes.values if attributes.is_a?(Hash)
+
+      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
+
+        active_field = active_fields_by_name[active_value_attributes[:name]]
+        next if active_field.nil?
+
+        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
+
+    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
+    def initialize_active_values
+      existing_field_ids = active_values.map(&:active_field_id)
+
+      active_fields.each do |active_field|
+        next if existing_field_ids.include?(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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  # Model mix-in with a base logic for the active fields model
+  module FieldConcern
+    extend ActiveSupport::Concern
+
+    included do
+      # rubocop:disable Rails/ReflectionClassName
+      has_many :active_values,
+        class_name: ActiveFields.config.value_class_name,
+        foreign_key: :active_field_id,
+        inverse_of: :active_field,
+        dependent: :destroy
+      # rubocop:enable Rails/ReflectionClassName
+
+      scope :for, ->(customizable_type) { where(customizable_type: customizable_type) }
+
+      validates :type, presence: true
+      validates :name, presence: true, uniqueness: { scope: :customizable_type }
+      validates :name, format: { with: /\A[a-z0-9_]+\z/ }, allow_blank: true
+      validate :validate_default_value
+      validate :validate_customizable_model_allows_type
+
+      after_initialize :set_defaults
+    end
+
+    class_methods do
+      def acts_as_active_field(array: false, validator:, caster:)
+        include FieldArrayConcern if array
+
+        define_method(:array?) { array }
+
+        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
+
+        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.safe_constantize
+    end
+
+    def default_value=(v)
+      default_value_meta["const"] = value_caster.serialize(v)
+    end
+
+    def default_value
+      value_caster.deserialize(default_value_meta["const"])
+    end
+
+    def type_name
+      ActiveFields.config.fields.key(type)
+    end
+
+    private
+
+    def validate_default_value
+      validator = value_validator
+      return if validator.validate(default_value)
+
+      validator.errors.each do |error|
+        if error.is_a?(Array) && error.size == 2 && error.first.is_a?(Symbol) && error.last.is_a?(Hash)
+          errors.add(:default_value, error.first, **error.last)
+        elsif error.is_a?(Symbol)
+          errors.add(:default_value, *error)
+        else
+          raise ArgumentError
+        end
+      end
+    end
+
+    def validate_customizable_model_allows_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 set_defaults; end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  # Model mix-in with a base logic for the active fields value model
+  module ValueConcern
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :customizable, polymorphic: true, optional: false, inverse_of: :active_values
+      # rubocop:disable Rails/ReflectionClassName
+      belongs_to :active_field,
+        class_name: ActiveFields.config.field_base_class_name,
+        optional: false,
+        inverse_of: :active_values
+      # rubocop:enable Rails/ReflectionClassName
+
+      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)
+      if active_field
+        clear_temp_value
+        value_meta["const"] = active_field.value_caster.serialize(v)
+      else
+        assign_temp_value(v)
+      end
+    end
+
+    def value
+      return unless active_field
+
+      assign_value_from_temp if temp_value
+
+      active_field.value_caster.deserialize(value_meta["const"])
+    end
+
+    private
+
+    def validate_value
+      return if (validator = active_field&.value_validator).nil?
+      return if validator.validate(value)
+
+      validator.errors.each do |error|
+        if error.is_a?(Array) && error.size == 2 && error.first.is_a?(Symbol) && error.last.is_a?(Hash)
+          errors.add(:value, error.first, **error.last)
+        elsif error.is_a?(Symbol)
+          errors.add(:value, *error)
+        else
+          raise ArgumentError
+        end
+      end
+    end
+
+    def validate_customizable_allowed
+      return true if active_field.nil?
+      return true if customizable_type == active_field.customizable_type
+
+      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/config/routes.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+ActiveFields::Engine.routes.draw do
+end

data/{lib/generators/active_fields/install/templates/create_active_fields_tables.rb.tt → db/migrate/20240229230000_create_active_fields_tables.rb}

@@ -1,15 +1,17 @@
-class CreateActiveFieldsTables < ActiveRecord::Migration<%= migration_version %>
+# frozen_string_literal: true
+
+class CreateActiveFieldsTables < ActiveRecord::Migration[6.0]
   def change
     create_table :active_fields do |t|
       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
 
-      t.index [:name, :customizable_type], unique: true
+      t.index %i[name customizable_type], unique: true
       t.index :customizable_type
     end
 
@@ -17,12 +19,12 @@ class CreateActiveFieldsTables < ActiveRecord::Migration<%= migration_version %>
       t.references :customizable, polymorphic: true, null: false, index: false
       t.references :active_field,
         null: false,
-        foreign_key: { to_table: :active_fields, name: :active_fields_values_active_field_id_fk }
-      t.jsonb :value
+        foreign_key: { to_table: :active_fields, name: "active_fields_values_active_field_id_fk" }
+      t.jsonb :value_meta, null: false, default: {}
 
       t.timestamps
 
-      t.index [:customizable_type, :customizable_id, :active_field_id],
+      t.index %i[customizable_type customizable_id active_field_id],
         unique: true,
         name: "index_active_fields_values_on_customizable_and_field"
     end

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/boolean_caster.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base_caster"
-
 module ActiveFields
   module Casters
     class BooleanCaster < BaseCaster

data/lib/active_fields/casters/date_array_caster.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "date_caster"
-
 module ActiveFields
   module Casters
     class DateArrayCaster < DateCaster

data/lib/active_fields/casters/date_caster.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-require_relative "base_caster"
-
 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_array_caster.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "decimal_caster"
-
 module ActiveFields
   module Casters
     class DecimalArrayCaster < DecimalCaster

data/lib/active_fields/casters/decimal_caster.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "base_caster"
-
 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)
@@ -16,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

@@ -1,9 +1,19 @@
 # frozen_string_literal: true
 
-require_relative "text_array_caster"
-
 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