active_fields 0.2.0 → 1.0.0

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

@@ -3,11 +3,17 @@
 module ActiveFields
   module Field
     class Date < ActiveFields.config.field_base_class
-      store_accessor :options, :required, :min, :max
+      acts_as_active_field(
+        validator: {
+          class_name: "ActiveFields::Validators::DateValidator",
+          options: -> { { required: required?, min: min, max: max } },
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::DateCaster",
+        },
+      )
 
-      # attribute :required, :boolean, default: false
-      # attribute :min, :date
-      # attribute :max, :date
+      store_accessor :options, :required, :min, :max
 
       validates :required, exclusion: [nil]
       validates :max, comparison: { greater_than_or_equal_to: :min }, allow_nil: true, if: :min

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

@@ -3,27 +3,21 @@
 module ActiveFields
   module Field
     class DateArray < ActiveFields.config.field_base_class
-      store_accessor :options, :min_size, :max_size, :min, :max
+      acts_as_active_field(
+        array: true,
+        validator: {
+          class_name: "ActiveFields::Validators::DateArrayValidator",
+          options: -> { { min: min, max: max, min_size: min_size, max_size: max_size } },
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::DateArrayCaster",
+        },
+      )
+
+      store_accessor :options, :min, :max
 
-      # attribute :min_size, :integer
-      # attribute :max_size, :integer
-      # attribute :min, :date
-      # attribute :max, :date
-
-      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
       validates :max, comparison: { greater_than_or_equal_to: :min }, allow_nil: true, if: :min
 
-      %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
-
       %i[min max].each do |column|
         define_method(column) do
           Casters::DateCaster.new.deserialize(super())

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Field
+    class DateTime < ActiveFields.config.field_base_class
+      acts_as_active_field(
+        validator: {
+          class_name: "ActiveFields::Validators::DateTimeValidator",
+          options: -> { { required: required?, min: min, max: max } },
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::DateTimeCaster",
+          options: -> { { precision: precision } },
+        },
+      )
+
+      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, less_than_or_equal_to: Casters::DateTimeCaster::MAX_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.
+      # This callback reassigns the internal values of the attributes to ensure accuracy.
+      before_save :reapply_precision
+
+      %i[required].each do |column|
+        define_method(column) do
+          Casters::BooleanCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}?") do
+          !!public_send(column)
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(Casters::BooleanCaster.new.serialize(other))
+        end
+      end
+
+      %i[min max].each do |column|
+        define_method(column) do
+          Casters::DateTimeCaster.new(precision: precision).deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(Casters::DateTimeCaster.new(precision: precision).serialize(other))
+        end
+      end
+
+      %i[precision].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
+        self.required ||= false
+      end
+
+      def reapply_precision
+        self.min = min
+        self.max = max
+        self.default_value = default_value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Field
+    class DateTimeArray < ActiveFields.config.field_base_class
+      acts_as_active_field(
+        array: true,
+        validator: {
+          class_name: "ActiveFields::Validators::DateTimeArrayValidator",
+          options: -> { { min: min, max: max, min_size: min_size, max_size: max_size } },
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::DateTimeArrayCaster",
+          options: -> { { precision: precision } },
+        },
+      )
+
+      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 },
+        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.
+      # This callback reassigns the internal values of the attributes to ensure accuracy.
+      before_save :reapply_precision
+
+      %i[precision].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
+
+      %i[min max].each do |column|
+        define_method(column) do
+          Casters::DateTimeCaster.new(precision: precision).deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(Casters::DateTimeCaster.new(precision: precision).serialize(other))
+        end
+      end
+
+      private
+
+      def set_defaults; end
+
+      def reapply_precision
+        self.min = min
+        self.max = max
+        self.default_value = default_value
+      end
+    end
+  end
+end

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

@@ -3,14 +3,27 @@
 module ActiveFields
   module Field
     class Decimal < ActiveFields.config.field_base_class
-      store_accessor :options, :required, :min, :max
+      acts_as_active_field(
+        validator: {
+          class_name: "ActiveFields::Validators::DecimalValidator",
+          options: -> { { required: required?, min: min, max: max } },
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::DecimalCaster",
+          options: -> { { precision: precision } },
+        },
+      )
 
-      # attribute :required, :boolean, default: false
-      # attribute :min, :decimal
-      # attribute :max, :decimal
+      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
+
+      # 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.
+      # This callback reassigns the internal values of the attributes to ensure accuracy.
+      before_save :reapply_precision
 
       %i[required].each do |column|
         define_method(column) do
@@ -28,11 +41,21 @@ module ActiveFields
 
       %i[min max].each do |column|
         define_method(column) do
-          Casters::DecimalCaster.new.deserialize(super())
+          Casters::DecimalCaster.new(precision: precision).deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(Casters::DecimalCaster.new(precision: precision).serialize(other))
+        end
+      end
+
+      %i[precision].each do |column|
+        define_method(column) do
+          Casters::IntegerCaster.new.deserialize(super())
         end
 
         define_method(:"#{column}=") do |other|
-          super(Casters::DecimalCaster.new.serialize(other))
+          super(Casters::IntegerCaster.new.serialize(other))
         end
       end
 
@@ -41,6 +64,12 @@ module ActiveFields
       def set_defaults
         self.required ||= false
       end
+
+      def reapply_precision
+        self.min = min
+        self.max = max
+        self.default_value = default_value
+      end
     end
   end
 end

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

@@ -3,18 +3,29 @@
 module ActiveFields
   module Field
     class DecimalArray < ActiveFields.config.field_base_class
-      store_accessor :options, :min_size, :max_size, :min, :max
+      acts_as_active_field(
+        array: true,
+        validator: {
+          class_name: "ActiveFields::Validators::DecimalArrayValidator",
+          options: -> { { min: min, max: max, min_size: min_size, max_size: max_size } },
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::DecimalArrayCaster",
+          options: -> { { precision: precision } },
+        },
+      )
+
+      store_accessor :options, :min, :max, :precision
 
-      # attribute :min_size, :integer
-      # attribute :max_size, :integer
-      # attribute :min, :decimal
-      # attribute :max, :decimal
-
-      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
       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
+
+      # 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.
+      # This callback reassigns the internal values of the attributes to ensure accuracy.
+      before_save :reapply_precision
 
-      %i[min_size max_size].each do |column|
+      %i[precision].each do |column|
         define_method(column) do
           Casters::IntegerCaster.new.deserialize(super())
         end
@@ -26,17 +37,23 @@ module ActiveFields
 
       %i[min max].each do |column|
         define_method(column) do
-          Casters::DecimalCaster.new.deserialize(super())
+          Casters::DecimalCaster.new(precision: precision).deserialize(super())
         end
 
         define_method(:"#{column}=") do |other|
-          super(Casters::DecimalCaster.new.serialize(other))
+          super(Casters::DecimalCaster.new(precision: precision).serialize(other))
         end
       end
 
       private
 
       def set_defaults; end
+
+      def reapply_precision
+        self.min = min
+        self.max = max
+        self.default_value = default_value
+      end
     end
   end
 end

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

@@ -3,10 +3,17 @@
 module ActiveFields
   module Field
     class Enum < ActiveFields.config.field_base_class
-      store_accessor :options, :required, :allowed_values
+      acts_as_active_field(
+        validator: {
+          class_name: "ActiveFields::Validators::EnumValidator",
+          options: -> { { required: required?, allowed_values: allowed_values } },
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::EnumCaster",
+        },
+      )
 
-      # attribute :required, :boolean, default: false
-      # attribute :allowed_values, :string, array: true, default: []
+      store_accessor :options, :required, :allowed_values
 
       validates :required, exclusion: [nil]
       validate :validate_allowed_values
@@ -40,15 +47,27 @@ module ActiveFields
       def validate_allowed_values
         if allowed_values.nil?
           errors.add(:allowed_values, :blank)
-        elsif allowed_values.is_a?(Array)
-          if allowed_values.empty?
-            errors.add(:allowed_values, :blank)
-          elsif allowed_values.any? { !_1.is_a?(String) }
+          return false
+        end
+
+        unless allowed_values.is_a?(Array)
+          errors.add(:allowed_values, :invalid)
+          return false
+        end
+
+        if allowed_values.empty?
+          errors.add(:allowed_values, :blank)
+          return false
+        end
+
+        allowed_values.each do |value_element|
+          if value_element.blank?
             errors.add(:allowed_values, :invalid)
+            return false
           end
-        else
-          errors.add(:allowed_values, :invalid)
         end
+
+        true
       end
 
       def set_defaults

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

@@ -3,26 +3,21 @@
 module ActiveFields
   module Field
     class EnumArray < ActiveFields.config.field_base_class
-      store_accessor :options, :min_size, :max_size, :allowed_values
+      acts_as_active_field(
+        array: true,
+        validator: {
+          class_name: "ActiveFields::Validators::EnumArrayValidator",
+          options: -> { { allowed_values: allowed_values, min_size: min_size, max_size: max_size } },
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::EnumArrayCaster",
+        },
+      )
 
-      # attribute :min_size, :integer
-      # attribute :max_size, :integer
-      # attribute :allowed_values, :string, array: true, default: []
+      store_accessor :options, :allowed_values
 
-      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
       validate :validate_allowed_values
 
-      %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
-
       %i[allowed_values].each do |column|
         define_method(column) do
           Casters::TextArrayCaster.new.deserialize(super())
@@ -38,15 +33,27 @@ module ActiveFields
       def validate_allowed_values
         if allowed_values.nil?
           errors.add(:allowed_values, :blank)
-        elsif allowed_values.is_a?(Array)
-          if allowed_values.empty?
-            errors.add(:allowed_values, :blank)
-          elsif allowed_values.any? { !_1.is_a?(String) }
+          return false
+        end
+
+        unless allowed_values.is_a?(Array)
+          errors.add(:allowed_values, :invalid)
+          return false
+        end
+
+        if allowed_values.empty?
+          errors.add(:allowed_values, :blank)
+          return false
+        end
+
+        allowed_values.each do |value_element|
+          if value_element.blank?
             errors.add(:allowed_values, :invalid)
+            return false
           end
-        else
-          errors.add(:allowed_values, :invalid)
         end
+
+        true
       end
 
       def set_defaults

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

@@ -3,11 +3,17 @@
 module ActiveFields
   module Field
     class Integer < ActiveFields.config.field_base_class
-      store_accessor :options, :required, :min, :max
+      acts_as_active_field(
+        validator: {
+          class_name: "ActiveFields::Validators::IntegerValidator",
+          options: -> { { required: required?, min: min, max: max } },
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::IntegerCaster",
+        },
+      )
 
-      # attribute :required, :boolean, default: false
-      # attribute :min, :integer
-      # attribute :max, :integer
+      store_accessor :options, :required, :min, :max
 
       validates :required, exclusion: [nil]
       validates :max, comparison: { greater_than_or_equal_to: :min }, allow_nil: true, if: :min

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

@@ -3,18 +3,22 @@
 module ActiveFields
   module Field
     class IntegerArray < ActiveFields.config.field_base_class
-      store_accessor :options, :min_size, :max_size, :min, :max
+      acts_as_active_field(
+        array: true,
+        validator: {
+          class_name: "ActiveFields::Validators::IntegerArrayValidator",
+          options: -> { { min: min, max: max, min_size: min_size, max_size: max_size } },
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::IntegerArrayCaster",
+        },
+      )
 
-      # attribute :min_size, :integer
-      # attribute :max_size, :integer
-      # attribute :min, :integer
-      # attribute :max, :integer
+      store_accessor :options, :min, :max
 
-      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
       validates :max, comparison: { greater_than_or_equal_to: :min }, allow_nil: true, if: :min
 
-      %i[min_size max_size min max].each do |column|
+      %i[min max].each do |column|
         define_method(column) do
           Casters::IntegerCaster.new.deserialize(super())
         end

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

@@ -3,11 +3,17 @@
 module ActiveFields
   module Field
     class Text < ActiveFields.config.field_base_class
-      store_accessor :options, :required, :min_length, :max_length
+      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

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

@@ -3,19 +3,25 @@
 module ActiveFields
   module Field
     class TextArray < ActiveFields.config.field_base_class
-      store_accessor :options, :min_size, :max_size, :min_length, :max_length
+      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",
+        },
+      )
 
-      # attribute :min_size, :integer
-      # attribute :max_size, :integer
-      # attribute :min_length, :integer
-      # attribute :max_length, :integer
+      store_accessor :options, :min_length, :max_length
 
-      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
       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_size max_size min_length max_length].each do |column|
+      %i[min_length max_length].each do |column|
         define_method(column) do
           Casters::IntegerCaster.new.deserialize(super())
         end