eluvia-base 3.37.1

data/lib/eluvia/active_model/attributes.rb

@@ -0,0 +1,417 @@
+module Eluvia
+  module ActiveModel
+    module Attributes
+      extend ::ActiveSupport::Concern
+      include ::ActiveModel::Model
+
+      SIMPLE_TYPES = %i[any string uuid date datetime integer float boolean].freeze
+      COMPLEX_TYPES = %i[has_one has_many].freeze
+
+      def initialize(params = {})
+        super(params)
+        if params
+          self.class.attrs(type: SIMPLE_TYPES).each do |attr_spec|
+            attr_name = attr_spec[:attr_name]
+            underlying_attr_name = attr_spec[:underlying_attr_name] || attr_name
+
+            # Get value from input params
+            key = nil
+            if params.key?(attr_name)
+              key = attr_name
+            elsif params.key?(attr_name.to_s)
+              key = attr_name.to_s
+            end
+
+            # Clean, transform and assign value only if key defined in params
+            if key
+              value = params[key]
+              self.send(:"#{attr_name}=", self.class.clean_value(value, attr_name))
+              self.send(:"#{underlying_attr_name}=", self.class.clean_and_transform_value(value, attr_name)) if underlying_attr_name != attr_name
+            end
+          end
+        end
+      end
+
+      def new_record?
+        if self.respond_to?(:id)
+          self.id.blank?
+        else
+          true
+        end
+      end
+
+      def write_attribute(attr_name, value)
+        if self.class.has_attr?(attr_name)
+          instance_variable_set("@#{attr_name}", value)
+        else
+          super(attr_name, value)
+        end
+      end
+
+      def read_attribute(attr_name)
+        if self.class.has_attr?(attr_name)
+          instance_variable_get("@#{attr_name}")
+        else
+          super(attr_name)
+        end
+      end
+
+      class_methods do
+
+        # *********************************************************************
+        # Clean and transform value methods
+        # *********************************************************************
+
+        # Clean value of a specific type or attribute.
+        def clean_value(value, attr_name)
+          return nil if value.nil?
+          attr_spec = self.find_attr(attr_name)
+          raise Eluvia::Errors::StandardError.new("Cannot clean value of unknow attribute `#{attr_name}`.") unless attr_spec
+          self.send(:"clean_#{attr_spec[:type]}_value", value)
+        end
+
+        def clean_and_transform_value(value, attr_name)
+          return nil if value.nil?
+          attr_spec = self.find_attr(attr_name)
+          raise Eluvia::Errors::StandardError.new("Cannot transform value of unknow attribute `#{attr_name}`.") unless attr_spec
+          value_cleaned = self.send(:"clean_#{attr_spec[:type]}_value", value)
+          if attr_spec[:transform] && attr_spec[:transform].respond_to?(:call)
+            attr_spec[:transform].call(value_cleaned)
+          else
+            value_cleaned
+          end
+        end
+
+        # Clean value of type `any`.
+        def clean_any_value(value)
+          value
+        end
+
+        # Clean value of type `string`.
+        def clean_string_value(value)
+          value.nil? ? nil : value.to_s
+        end
+
+        # Clean value of type `uuid`.
+        def clean_uuid_value(value)
+          value.nil? ? nil : value.to_s
+        end
+
+        # Clean value of type `date`.
+        def clean_date_value(value)
+          if value.is_a?(::String)
+            return ::Date.parse(value) rescue nil
+          elsif value.is_a?(::Date)
+            return value
+          elsif value.is_a?(::Time)
+            return value.to_date
+          elsif value.is_a?(::DateTime)
+            return value.to_date
+          end
+          nil
+        end
+
+        # Clean value of type `datetime`.
+        def clean_datetime_value(value)
+          if value.is_a?(::String)
+            return ::DateTime.parse(value) rescue nil
+          elsif value.is_a?(::Date)
+            return value.to_datetime
+          elsif value.is_a?(::Time)
+            return value.to_datetime
+          elsif value.is_a?(::DateTime)
+            return value
+          end
+          nil
+        end
+
+        # Clean value of type `integer`.
+        def clean_integer_value(value)
+          value.nil? ? nil : value.to_i
+        end
+
+        # Clean value of type `float`.
+        def clean_float_value(value)
+          value.nil? ? nil : value.to_f
+        end
+
+        # Clean value of type `boolean`.
+        def clean_boolean_value(value)
+          ::ActiveModel::Type::Boolean.new.cast(value)
+        end
+
+        # *********************************************************************
+        # Attribute store methods
+        # *********************************************************************
+
+        def _attrs
+          @attrs ||= {}
+        end
+
+        def attrs(type: nil)
+          result = _attrs.values
+          return result unless type
+          if type.is_a?(::Array)
+            result.select { |a| type.include?(a[:type]) }
+          else
+            result.select { |a| a[:type] == type }
+          end
+        end
+
+        def attr_names(type: nil)
+          attrs(type: type).map { |a| a[:attr_name] }
+        end
+
+        def has_attr?(attr_name, type: nil)
+          find_attr(attr_name, type: type).present?
+        end
+
+        def find_attr(attr_name, type: nil)
+          result = _attrs.fetch(attr_name.to_sym, nil)
+          return nil unless result
+          return result unless type
+          if type.is_a?(::Array)
+            return nil unless type.include?(result[:type])
+          else
+            return nil unless result[:type] == type
+          end
+          result
+        end
+
+        def simple_attrs
+          attrs(type: SIMPLE_TYPES)
+        end
+
+        def simple_attr_names
+          attr_names(type: SIMPLE_TYPES)
+        end
+
+        def has_simple_attr?(attr_name)
+          has_attr?(attr_name, type: SIMPLE_TYPES)
+        end
+
+        def find_simple_attr(attr_name)
+          find_attr(attr_name, type: SIMPLE_TYPES)
+        end
+
+        def complex_attrs
+          attrs(type: COMPLEX_TYPES)
+        end
+
+        def complex_attr_names
+          attr_names(type: COMPLEX_TYPES)
+        end
+
+        def has_complex_attr?(attr_name)
+          has_attr?(attr_name, type: COMPLEX_TYPES)
+        end
+
+        def find_complex_attr(attr_name)
+          find_attr(attr_name, type: COMPLEX_TYPES)
+        end
+
+        # *********************************************************************
+        # Polymorphic type declaration
+        # *********************************************************************
+
+        # Declares which `type` values this class handles during polymorphic mapping.
+        # Works together with the `default:` option on `has_one_attr` / `has_many_attr`.
+        #
+        # @param types [Array<Symbol, String>] one or more type values this class owns
+        #
+        # @example
+        #   class FieldDescriptor
+        #     include Eluvia::ActiveModel::Attributes
+        #     intended_for_types :field
+        #   end
+        def intended_for_types(*types)
+          return @_intended_for_types || [] if types.empty?
+          @_intended_for_types = types.map(&:to_s)
+        end
+
+        # *********************************************************************
+        # Mapping methods
+        # *********************************************************************
+
+        def slice(data)
+          data.slice(*self.simple_attr_names)
+        end
+
+        def _resolve_class_name(item_value, class_name, default_class_name = nil)
+          return class_name unless class_name.is_a?(::Array)
+
+          type_value = item_value.is_a?(::Hash) ? (item_value[:type] || item_value['type']).to_s : nil
+
+          class_name.each do |candidate|
+            klass = candidate.constantize
+            return candidate if klass.intended_for_types.include?(type_value)
+          end
+
+          default_class_name || raise(Eluvia::Errors::StandardError.new("No class in #{class_name.inspect} handles type '#{type_value}' and no default was specified."))
+        end
+
+        def _map_value(value, class_name)
+          if class_name == 'String'
+            clean_string_value(value)
+          elsif class_name == 'Uuid'
+            clean_uuid_value(value)
+          elsif class_name == 'Date'
+            clean_date_value(value)
+          elsif class_name == 'DateTime'
+            clean_datetime_value(value)
+          elsif class_name == 'Integer'
+            clean_integer_value(value)
+          elsif class_name == 'Float'
+            clean_float_value(value)
+          elsif class_name == 'Boolean'
+            clean_boolean_value(value)
+          else
+            class_name.constantize.map(value)
+          end
+        end
+
+        def map(data)
+          return nil if data.blank?
+          return nil unless data.is_a?(::Hash)
+          data = data.with_indifferent_access
+          object = self.new(self.slice(data))
+          self.attrs(type: :has_one).each do |attr_spec|
+            attr_name = attr_spec[:attr_name]
+            class_name = attr_spec[:class_name]
+            polymorphic_default = attr_spec[:polymorphic_default]
+            item_value = data[attr_name]
+            next if item_value.nil?
+            resolved = _resolve_class_name(item_value, class_name, polymorphic_default)
+            object.send(:"#{attr_name}=", resolved.constantize.map(item_value))
+          end
+          self.attrs(type: :has_many).each do |attr_spec|
+            attr_name = attr_spec[:attr_name]
+            class_name = attr_spec[:class_name]
+            underlying_type = attr_spec[:underlying_type]
+            polymorphic_default = attr_spec[:polymorphic_default]
+            if underlying_type == :hash
+              combined_value = {}
+              if data[attr_name].is_a?(::Hash)
+                data[attr_name].each do |item_key, item_value|
+                  combined_value[item_key] = _map_value(item_value, _resolve_class_name(item_value, class_name, polymorphic_default))
+                end
+              end
+            else
+              combined_value = []
+              if data[attr_name].is_a?(::Array)
+                data[attr_name].each do |item_value|
+                  combined_value << _map_value(item_value, _resolve_class_name(item_value, class_name, polymorphic_default))
+                end
+              end
+            end
+            object.send(:"#{attr_name}=", combined_value)
+          end
+          object
+        end
+
+        # *********************************************************************
+        # Attribute definition methods
+        # *********************************************************************
+
+        def simple_attr(attr_name, type, transform: nil, underlying_attr_name: nil, default: nil)
+          attr_name = attr_name.to_sym
+          type = type.to_sym
+          type = :any unless SIMPLE_TYPES.include?(type)
+          underlying_attr_name = underlying_attr_name.to_sym if underlying_attr_name
+
+          # Define attribute accessors
+          attr_accessor attr_name
+
+          attr_accessor underlying_attr_name if underlying_attr_name && underlying_attr_name != attr_name
+
+          # Register metadata
+          _attrs[attr_name] = {
+            attr_name: attr_name,
+            type: type,
+            transform: transform,
+            underlying_attr_name: underlying_attr_name,
+            default: default
+          }
+        end
+
+        def any_attr(attr_name, **args)
+          simple_attr(attr_name, :any, **args)
+        end
+
+        def string_attr(attr_name, **args)
+          simple_attr(attr_name, :string, **args)
+        end
+
+        def uuid_attr(attr_name, **args)
+          simple_attr(attr_name, :uuid, **args)
+        end
+
+        def date_attr(attr_name, **args)
+          simple_attr(attr_name, :date, **args)
+        end
+
+        def datetime_attr(attr_name, **args)
+          simple_attr(attr_name, :datetime, **args)
+        end
+
+        def integer_attr(attr_name, **args)
+          simple_attr(attr_name, :integer, **args)
+        end
+
+        def float_attr(attr_name, **args)
+          simple_attr(attr_name, :float, **args)
+        end
+
+        def boolean_attr(attr_name, **args)
+          simple_attr(attr_name, :boolean, **args)
+        end
+
+        # Add a new "has one" attribute
+        #
+        # @param attr_name [Symbol] attribute name
+        # @param class_name [String, Array<String>] name of the class (or ordered list of candidate
+        #   class names) of the related object. When an Array, class resolution calls
+        #   `handles_type?(type_value)` on each candidate; the first match wins.
+        # @param default [String, nil] class name to use when no candidate matches. Required when
+        #   class_name is an Array; raises an error on no-match if omitted.
+        def has_one_attr(attr_name, class_name, default: nil)
+          attr_name = attr_name.to_sym
+
+          attr_accessor attr_name
+
+          _attrs[attr_name] = {
+            attr_name: attr_name,
+            type: :has_one,
+            class_name: class_name,
+            polymorphic_default: default
+          }
+        end
+
+        # Add a new "has many" attribute
+        #
+        # @param attr_name [Symbol] attribute name
+        # @param class_name [String, Array<String>] name of the class (or ordered list of candidate
+        #   class names) of the related objects. When an Array, class resolution calls
+        #   `handles_type?(type_value)` on each candidate; the first match wins.
+        # @param underlying_type [Symbol] :array or :hash
+        # @param default [String, nil] class name to use when no candidate matches. Required when
+        #   class_name is an Array; raises an error on no-match if omitted.
+        def has_many_attr(attr_name, class_name, underlying_type: :array, default: nil)
+          attr_name = attr_name.to_sym
+
+          attr_accessor attr_name
+
+          _attrs[attr_name] = {
+            attr_name: attr_name,
+            type: :has_many,
+            class_name: class_name,
+            underlying_type: underlying_type,
+            polymorphic_default: default
+          }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/eluvia/active_model/enum_array_attribute.rb

@@ -0,0 +1,60 @@
+module Eluvia
+  module ActiveModel
+    module EnumArrayAttribute
+      extend ::ActiveSupport::Concern
+      include Eluvia::ActiveModel::ArrayAttribute
+      include Eluvia::ActiveModel::EnumAttribute
+
+      class_methods do
+
+        # *********************************************************************
+        # Attribute definition methods for enum array
+        # *********************************************************************
+
+        def enum_array_column(new_column, choices, options = {})
+          enum_array_attr(new_column, choices, **options)
+        end
+
+        # Add a new "enum array" attribute to this model
+        def enum_array_attr(attr_name, choices, **options)
+          attr_name = attr_name.to_sym
+
+          # Define it using array and enum
+          array_attr(attr_name, **options) # -> this will define the setter and getter for array
+          enum_attr(attr_name, choices) # -> this will define available_xxx_values and other static functions
+
+          # *******************************************************************
+          # Dynamically defined instance methods for enum array
+          # *******************************************************************
+
+          # Get choices objects
+          define_method(:"#{attr_name}_objs") do
+            values = self.send(attr_name)
+            return nil if values.blank?
+            result = []
+            values.each do |value|
+              obj = self.class.find_enum_attr(attr_name)&.fetch(value.to_s, nil)
+              result << obj if obj
+            end
+            if result.empty?
+              nil
+            else
+              result
+            end
+          end
+
+          # Get labels
+          define_method(:"#{attr_name}_labels") do
+            self.send(:"#{attr_name}_objs")&.map { |obj| obj[:label] }
+          end
+
+          # Get colors
+          define_method(:"#{attr_name}_colors") do
+            self.send(:"#{attr_name}_objs")&.map { |obj| obj[:color] }
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/eluvia/active_model/enum_attribute.rb

@@ -0,0 +1,174 @@
+module Eluvia
+  module ActiveModel
+    module EnumAttribute
+      extend ::ActiveSupport::Concern
+      include Eluvia::ActiveModel::Attributes
+
+      class_methods do
+
+        # *********************************************************************
+        # Attribute store methods
+        # *********************************************************************
+
+        def _enum_attrs
+          @enum_attrs ||= {}
+        end
+
+        def enum_attrs
+          _enum_attrs.values
+        end
+
+        def enum_attr_names
+          enum_attrs.map { |a| a[:attr_name] }
+        end
+
+        def has_enum_attr?(attr_name)
+          _enum_attrs.key?(attr_name.to_sym)
+        end
+
+        def find_enum_attr(attr_name)
+          _enum_attrs.fetch(attr_name.to_sym, nil)
+        end
+
+        # *********************************************************************
+        # Attribute definition methods
+        # *********************************************************************
+
+        # Backward compatibility
+        def enum_column(attr_name, choices, options = {})
+          enum_attr(attr_name, choices, **options)
+        end
+
+        # Adds new "enum" attribute to this model
+        #
+        # @param attr_name [Symbol] Attribute name
+        # @param choices [Array<Hash, Object>] Array of choice definitions or values
+        # @param default [Object] Default value
+        # @param declare [Boolean] Whether to declare the underlying attribute as string
+        def enum_attr(attr_name, choices, default: nil, declare: false)
+          attr_name = attr_name.to_sym
+
+          # Declare underlying attribute
+          if declare
+            string_attr attr_name
+          end
+
+          # Input check
+          raise Eluvia::Errors::StandardError.new('Please specify enum choices as an array.') unless choices.is_a?(::Array)
+
+          # Prepare and fill out the internal structure
+          _enum_attrs[attr_name] = {}
+          choices.each do |choice|
+
+            # Value check
+            if choice.is_a?(::Hash)
+              # OK
+            else
+              choice = { value: choice }
+            end
+            raise Eluvia::Errors::StandardError.new('Enum definition cannot be empty.') if choice[:value].nil? || choice[:value].to_s.empty?
+
+            # Identify underlying type
+            if choice[:value].is_a?(::Integer)
+              choice[:underlying_type] = :integer
+            elsif choice[:value].is_a?(::TrueClass) || choice[:value].is_a?(::FalseClass)
+              choice[:underlying_type] = :boolean
+            else
+              choice[:underlying_type] = :string
+            end
+
+            # Retype value to string
+            choice[:value] = choice[:value].to_s
+
+            # Label
+            unless choice[:label]
+              choice[:label] = I18n.t("#{i18n_scope}.attributes.#{model_name.i18n_key}.#{attr_name}_values.#{"#{choice[:underlying_type]}_" if choice[:underlying_type] != :string}#{choice[:value]}", default: choice[:value])
+            end
+
+            # Color
+            unless choice[:color]
+              choice[:color] = I18n.t("#{i18n_scope}.attributes.#{model_name.i18n_key}.#{attr_name}_colors.#{"#{choice[:underlying_type]}_" if choice[:underlying_type] != :string}#{choice[:value]}", default: 'inherit')
+            end
+
+            # Store
+            _enum_attrs[attr_name][choice[:value]] = choice
+          end
+
+          # *******************************************************************
+          # Dynamically defined instance methods
+          # *******************************************************************
+
+          # Define new attribute for choice object
+          obj_attr_name = :"#{attr_name}_obj"
+          any_attr(obj_attr_name)
+
+          # Get a choice object
+          define_method(obj_attr_name) do
+            value = self.send(attr_name)
+            self.class.find_enum_attr(attr_name)&.fetch(value.to_s, nil)
+          end
+
+          # Define new attribute for label
+          label_attr_name = :"#{attr_name}_label"
+          string_attr(label_attr_name)
+
+          # Get label
+          define_method(label_attr_name) do
+            value = self.send(attr_name)
+            self.class.find_enum_attr(attr_name)&.fetch(value.to_s, nil)&.fetch(:label, nil)
+          end
+
+          # Define new attribute for color
+          color_attr_name = :"#{attr_name}_color"
+          string_attr(color_attr_name)
+
+          # Get color
+          define_method(color_attr_name) do
+            value = self.send(attr_name)
+            self.class.find_enum_attr(attr_name)&.fetch(value.to_s, nil)&.fetch(:color, nil)
+          end
+
+          # *******************************************************************
+          # Dynamically defined class methods
+          # *******************************************************************
+
+          # Get all choice objects
+          define_singleton_method(:"available_#{attr_name.to_s.pluralize}") do
+            find_enum_attr(attr_name)&.values
+          end
+
+          # Get all values
+          define_singleton_method(:"available_#{attr_name}_values") do
+            find_enum_attr(attr_name)&.values&.map { |item| item[:value].to_sym }
+          end
+
+          # Get label - static method
+          define_singleton_method(:"#{attr_name}_label") do |value|
+            find_enum_attr(attr_name)&.fetch(value.to_s, nil)&.fetch(:label, nil)
+          end
+
+          # Get color - static method
+          define_singleton_method(:"#{attr_name}_color") do |value|
+            find_enum_attr(attr_name)&.fetch(value.to_s, nil)&.fetch(:color, nil)
+          end
+
+          # *******************************************************************
+          # Other hooks
+          # *******************************************************************
+
+          # Default value
+          if default
+            before_validation do
+              if self.send(attr_name).nil?
+                self.send("#{attr_name}=", default.to_s)
+              end
+            end
+          end
+
+        end
+
+      end
+
+    end
+  end
+end