active_fields 0.1.0 → 1.0.0

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

@@ -1,21 +1,26 @@
 # frozen_string_literal: true
 
-require_relative "../field"
-
 module ActiveFields
-  class Field
-    class Boolean < ActiveFields::Field
-      store_accessor :options, :required, :nullable
+  module Field
+    class Boolean < ActiveFields.config.field_base_class
+      acts_as_active_field(
+        validator: {
+          class_name: "ActiveFields::Validators::BooleanValidator",
+          options: -> { { required: required?, nullable: nullable? } },
+        },
+        caster: {
+          class_name: "ActiveFields::Casters::BooleanCaster",
+        },
+      )
 
-      # attribute :required, :boolean, default: false
-      # attribute :nullable, :boolean, default: false
+      store_accessor :options, :required, :nullable
 
       validates :required, exclusion: [nil]
       validates :nullable, exclusion: [nil]
 
       %i[required nullable].each do |column|
         define_method(column) do
-          ActiveFields::Casters::BooleanCaster.new.deserialize(super())
+          Casters::BooleanCaster.new.deserialize(super())
         end
 
         define_method(:"#{column}?") do
@@ -23,7 +28,7 @@ module ActiveFields
         end
 
         define_method(:"#{column}=") do |other|
-          super(ActiveFields::Casters::BooleanCaster.new.serialize(other))
+          super(Casters::BooleanCaster.new.serialize(other))
         end
       end
 

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

@@ -1,22 +1,26 @@
 # frozen_string_literal: true
 
-require_relative "../field"
-
 module ActiveFields
-  class Field
-    class Date < ActiveFields::Field
-      store_accessor :options, :required, :min, :max
+  module Field
+    class Date < ActiveFields.config.field_base_class
+      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
 
       %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
@@ -24,17 +28,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 max].each do |column|
         define_method(column) do
-          ActiveFields::Casters::DateCaster.new.deserialize(super())
+          Casters::DateCaster.new.deserialize(super())
         end
 
         define_method(:"#{column}=") do |other|
-          super(ActiveFields::Casters::DateCaster.new.serialize(other))
+          super(Casters::DateCaster.new.serialize(other))
         end
       end
 

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Field
+    class DateArray < ActiveFields.config.field_base_class
+      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
+
+      validates :max, comparison: { greater_than_or_equal_to: :min }, allow_nil: true, if: :min
+
+      %i[min max].each do |column|
+        define_method(column) do
+          Casters::DateCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(Casters::DateCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      def set_defaults; end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Field
+    class Decimal < ActiveFields.config.field_base_class
+      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 } },
+        },
+      )
+
+      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
+          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::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::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/decimal_array.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Field
+    class DecimalArray < ActiveFields.config.field_base_class
+      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
+
+      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[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::DecimalCaster.new(precision: precision).deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |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/{lib/active_fields/models → app/models/active_fields}/field/enum.rb

@@ -1,21 +1,26 @@
 # frozen_string_literal: true
 
-require_relative "../field"
-
 module ActiveFields
-  class Field
-    class Enum < ActiveFields::Field
-      store_accessor :options, :required, :allowed_values
+  module Field
+    class Enum < ActiveFields.config.field_base_class
+      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
 
       %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
@@ -23,17 +28,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[allowed_values].each do |column|
         define_method(column) do
-          ActiveFields::Casters::TextArrayCaster.new.deserialize(super())
+          Casters::TextArrayCaster.new.deserialize(super())
         end
 
         define_method(:"#{column}=") do |other|
-          super(ActiveFields::Casters::TextArrayCaster.new.serialize(other))
+          super(Casters::TextArrayCaster.new.serialize(other))
         end
       end
 
@@ -42,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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Field
+    class EnumArray < ActiveFields.config.field_base_class
+      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",
+        },
+      )
+
+      store_accessor :options, :allowed_values
+
+      validate :validate_allowed_values
+
+      %i[allowed_values].each do |column|
+        define_method(column) do
+          Casters::TextArrayCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(Casters::TextArrayCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      def validate_allowed_values
+        if allowed_values.nil?
+          errors.add(:allowed_values, :blank)
+          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
+        end
+
+        true
+      end
+
+      def set_defaults
+        self.allowed_values ||= []
+      end
+    end
+  end
+end

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

@@ -1,22 +1,26 @@
 # frozen_string_literal: true
 
-require_relative "../field"
-
 module ActiveFields
-  class Field
-    class Integer < ActiveFields::Field
-      store_accessor :options, :required, :min, :max
+  module Field
+    class Integer < ActiveFields.config.field_base_class
+      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
 
       %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
@@ -24,17 +28,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 max].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/integer_array.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Field
+    class IntegerArray < ActiveFields.config.field_base_class
+      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",
+        },
+      )
+
+      store_accessor :options, :min, :max
+
+      validates :max, comparison: { greater_than_or_equal_to: :min }, allow_nil: true, if: :min
+
+      %i[min max].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