active_fields 0.1.0

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../field"
+
+module ActiveFields
+  class Field
+    class Boolean < ActiveFields::Field
+      store_accessor :options, :required, :nullable
+
+      # attribute :required, :boolean, default: false
+      # attribute :nullable, :boolean, default: false
+
+      validates :required, exclusion: [nil]
+      validates :nullable, exclusion: [nil]
+
+      %i[required nullable].each do |column|
+        define_method(column) do
+          ActiveFields::Casters::BooleanCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}?") do
+          !!public_send(column)
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::BooleanCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      def set_defaults
+        self.required ||= false
+        self.nullable ||= false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../field"
+
+module ActiveFields
+  class Field
+    class Date < ActiveFields::Field
+      store_accessor :options, :required, :min, :max
+
+      # attribute :required, :boolean, default: false
+      # attribute :min, :date
+      # attribute :max, :date
+
+      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())
+        end
+
+        define_method(:"#{column}?") do
+          !!public_send(column)
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::BooleanCaster.new.serialize(other))
+        end
+      end
+
+      %i[min max].each do |column|
+        define_method(column) do
+          ActiveFields::Casters::DateCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::DateCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      def set_defaults
+        self.required ||= false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../field"
+
+module ActiveFields
+  class Field
+    class DateArray < ActiveFields::Field
+      store_accessor :options, :min_size, :max_size, :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
+          ActiveFields::Casters::IntegerCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::IntegerCaster.new.serialize(other))
+        end
+      end
+
+      %i[min max].each do |column|
+        define_method(column) do
+          ActiveFields::Casters::DateCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::DateCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      def set_defaults; end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../field"
+
+module ActiveFields
+  class Field
+    class Decimal < ActiveFields::Field
+      store_accessor :options, :required, :min, :max
+
+      # attribute :required, :boolean, default: false
+      # attribute :min, :decimal
+      # attribute :max, :decimal
+
+      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())
+        end
+
+        define_method(:"#{column}?") do
+          !!public_send(column)
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::BooleanCaster.new.serialize(other))
+        end
+      end
+
+      %i[min max].each do |column|
+        define_method(column) do
+          ActiveFields::Casters::DecimalCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::DecimalCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      def set_defaults
+        self.required ||= false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../field"
+
+module ActiveFields
+  class Field
+    class DecimalArray < ActiveFields::Field
+      store_accessor :options, :min_size, :max_size, :min, :max
+
+      # 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
+
+      %i[min_size max_size].each do |column|
+        define_method(column) do
+          ActiveFields::Casters::IntegerCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::IntegerCaster.new.serialize(other))
+        end
+      end
+
+      %i[min max].each do |column|
+        define_method(column) do
+          ActiveFields::Casters::DecimalCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::DecimalCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      def set_defaults; end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../field"
+
+module ActiveFields
+  class Field
+    class Enum < ActiveFields::Field
+      store_accessor :options, :required, :allowed_values
+
+      # attribute :required, :boolean, default: false
+      # attribute :allowed_values, :string, array: true, default: []
+
+      validates :required, exclusion: [nil]
+      validate :validate_allowed_values
+
+      %i[required].each do |column|
+        define_method(column) do
+          ActiveFields::Casters::BooleanCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}?") do
+          !!public_send(column)
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::BooleanCaster.new.serialize(other))
+        end
+      end
+
+      %i[allowed_values].each do |column|
+        define_method(column) do
+          ActiveFields::Casters::TextArrayCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::TextArrayCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      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) }
+            errors.add(:allowed_values, :invalid)
+          end
+        else
+          errors.add(:allowed_values, :invalid)
+        end
+      end
+
+      def set_defaults
+        self.required ||= false
+        self.allowed_values ||= []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "../field"
+
+module ActiveFields
+  class Field
+    class EnumArray < ActiveFields::Field
+      store_accessor :options, :min_size, :max_size, :allowed_values
+
+      # attribute :min_size, :integer
+      # attribute :max_size, :integer
+      # attribute :allowed_values, :string, array: true, default: []
+
+      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
+          ActiveFields::Casters::IntegerCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::IntegerCaster.new.serialize(other))
+        end
+      end
+
+      %i[allowed_values].each do |column|
+        define_method(column) do
+          ActiveFields::Casters::TextArrayCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::TextArrayCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      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) }
+            errors.add(:allowed_values, :invalid)
+          end
+        else
+          errors.add(:allowed_values, :invalid)
+        end
+      end
+
+      def set_defaults
+        self.allowed_values ||= []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../field"
+
+module ActiveFields
+  class Field
+    class Integer < ActiveFields::Field
+      store_accessor :options, :required, :min, :max
+
+      # attribute :required, :boolean, default: false
+      # attribute :min, :integer
+      # attribute :max, :integer
+
+      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())
+        end
+
+        define_method(:"#{column}?") do
+          !!public_send(column)
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::BooleanCaster.new.serialize(other))
+        end
+      end
+
+      %i[min max].each do |column|
+        define_method(column) do
+          ActiveFields::Casters::IntegerCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::IntegerCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      def set_defaults
+        self.required ||= false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../field"
+
+module ActiveFields
+  class Field
+    class IntegerArray < ActiveFields::Field
+      store_accessor :options, :min_size, :max_size, :min, :max
+
+      # attribute :min_size, :integer
+      # attribute :max_size, :integer
+      # attribute :min, :integer
+      # attribute :max, :integer
+
+      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|
+        define_method(column) do
+          ActiveFields::Casters::IntegerCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::IntegerCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      def set_defaults; end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../field"
+
+module ActiveFields
+  class Field
+    class Text < ActiveFields::Field
+      store_accessor :options, :required, :min_length, :max_length
+
+      # attribute :required, :boolean, default: false
+      # attribute :min_length, :integer
+      # attribute :max_length, :integer
+
+      validates :required, exclusion: [nil]
+      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[required].each do |column|
+        define_method(column) do
+          ActiveFields::Casters::BooleanCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}?") do
+          !!public_send(column)
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::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())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::IntegerCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      def set_defaults
+        self.required ||= false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../field"
+
+module ActiveFields
+  class Field
+    class TextArray < ActiveFields::Field
+      store_accessor :options, :min_size, :max_size, :min_length, :max_length
+
+      # attribute :min_size, :integer
+      # attribute :max_size, :integer
+      # attribute :min_length, :integer
+      # attribute :max_length, :integer
+
+      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|
+        define_method(column) do
+          ActiveFields::Casters::IntegerCaster.new.deserialize(super())
+        end
+
+        define_method(:"#{column}=") do |other|
+          super(ActiveFields::Casters::IntegerCaster.new.serialize(other))
+        end
+      end
+
+      private
+
+      def set_defaults; end
+    end
+  end
+end

data/lib/active_fields/models/field.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: active_fields
+#
+#  id                :bigint           not null, primary key
+#  customizable_type :string           not null
+#  default_value     :jsonb
+#  name              :string           not null
+#  options           :jsonb            default({}), not null
+#  type              :string           not null
+#  created_at        :datetime         not null
+#  updated_at        :datetime         not null
+#
+# Indexes
+#
+#  index_active_fields_on_customizable_type           (customizable_type)
+#  index_active_fields_on_name_and_customizable_type  (name,customizable_type) UNIQUE
+#
+module ActiveFields
+  class Field < ::ActiveRecord::Base
+    self.table_name = "active_fields"
+
+    include ActiveFields::FieldConcern
+  end
+end

data/lib/active_fields/models/value.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: active_fields_values
+#
+#  id                :bigint           not null, primary key
+#  customizable_type :string           not null
+#  value             :jsonb
+#  created_at        :datetime         not null
+#  updated_at        :datetime         not null
+#  customizable_id   :bigint           not null
+#  active_field_id   :bigint           not null
+#
+# Indexes
+#
+#  index_active_fields_values_on_customizable_and_field  (customizable_type,customizable_id,active_field_id) UNIQUE
+#  index_active_fields_values_on_active_field_id                (active_field_id)
+#
+# Foreign Keys
+#
+#  active_fields_values_active_field_id_fk  (active_field_id => active_fields.id)
+#
+module ActiveFields
+  class Value < ::ActiveRecord::Base
+    self.table_name = "active_fields_values"
+
+    include ActiveFields::ValueConcern
+  end
+end

data/lib/active_fields/validators/base_validator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Validators
+    # Validates the active_value value
+    class BaseValidator
+      attr_reader :active_field, :errors
+
+      def initialize(active_field)
+        @active_field = active_field
+        @errors = Set.new
+      end
+
+      def validate(value)
+        perform_validation(value)
+        valid?
+      end
+
+      def valid?
+        errors.empty?
+      end
+
+      private
+
+      def perform_validation(value)
+        raise NotImplementedError
+      end
+
+      def validate_size(value, min:, max:)
+        if min && value.size < min
+          errors << [:size_too_short, count: min]
+        end
+
+        if max && value.size > max
+          errors << [:size_too_long, count: max]
+        end
+      end
+
+      def validate_length(value, min:, max:)
+        if min && value.length < min
+          errors << [:too_short, count: min]
+        end
+
+        if max && value.length > max
+          errors << [:too_long, count: max]
+        end
+      end
+
+      def validate_minmax(value, min:, max:)
+        # maybe acts_like?(:date) || acts_like?(:time)
+        if min && value < min
+          formatted =
+            if min.respond_to?(:strftime) && defined?(I18n) && I18n.respond_to?(:l)
+              I18n.l(min)
+            else
+              min
+            end
+          errors << [:greater_than_or_equal_to, count: formatted]
+        end
+
+        if max && value > max
+          formatted =
+            if max.respond_to?(:strftime) && defined?(I18n) && I18n.respond_to?(:l)
+              I18n.l(max)
+            else
+              max
+            end
+          errors << [:less_than_or_equal_to, count: formatted]
+        end
+      end
+    end
+  end
+end

data/lib/active_fields/validators/boolean_validator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base_validator"
+
+module ActiveFields
+  module Validators
+    class BooleanValidator < BaseValidator
+      private
+
+      def perform_validation(value)
+        if value.nil?
+          errors << :exclusion unless active_field.nullable?
+        elsif value.is_a?(FalseClass)
+          errors << :required if active_field.required?
+        elsif value.is_a?(TrueClass)
+          nil
+        else
+          errors << :invalid
+        end
+      end
+    end
+  end
+end