lutaml-model 0.7.1 → 0.7.7

data/lib/lutaml/model/attribute.rb

@@ -1,7 +1,7 @@
 module Lutaml
   module Model
     class Attribute
-      attr_reader :name, :type, :options
+      attr_reader :name, :options
 
       ALLOWED_OPTIONS = %i[
         raw
@@ -17,23 +17,88 @@ module Lutaml
         polymorphic
         polymorphic_class
         initialize_empty
+        validations
       ].freeze
 
+      MODEL_STRINGS = [
+        Lutaml::Model::Type::String,
+        "String",
+        :string,
+      ].freeze
+
+      # Safe methods than can be overriden without any crashing
+      ALLOW_OVERRIDING = %i[
+        display
+        validate
+        hash
+        itself
+        taint
+        untaint
+        trust
+        untrust
+        methods
+        instance_variables
+        tap
+        extend
+        freeze
+        encoding
+        method
+        object_id
+      ].freeze
+
+      def self.cast_type!(type)
+        case type
+        when Symbol then cast_from_symbol!(type)
+        when String then cast_from_string!(type)
+        when Class then type
+        else
+          raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
+        end
+      end
+
+      def self.cast_from_symbol!(type)
+        Type.lookup(type)
+      rescue UnknownTypeError
+        raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
+      end
+
+      def self.cast_from_string!(type)
+        Type.const_get(type)
+      rescue NameError
+        raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
+      end
+
       def initialize(name, type, options = {})
+        validate_name!(
+          name, reserved_methods: Lutaml::Model::Serializable.instance_methods
+        )
+
         @name = name
         @options = options
 
         validate_presence!(type, options[:method_name])
-        process_type!(type) if type
+        @type = type
         process_options!
       end
 
+      def type(register_id = nil)
+        return if unresolved_type.nil?
+
+        register_id ||= Lutaml::Model::Config.default_register
+        register = Lutaml::Model::GlobalRegister.lookup(register_id)
+        register.get_class_without_register(unresolved_type)
+      end
+
+      def unresolved_type
+        @type
+      end
+
       def polymorphic?
         @options[:polymorphic_class]
       end
 
       def derived?
-        type.nil?
+        unresolved_type.nil?
       end
 
       def delegate
@@ -52,45 +117,61 @@ module Lutaml
         @options[:initialize_empty]
       end
 
+      def validations
+        @options[:validations]
+      end
+
       def cast_type!(type)
-        case type
-        when Symbol
-          begin
-            Type.lookup(type)
-          rescue UnknownTypeError
-            raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
-          end
-        when String
-          begin
-            Type.const_get(type)
-          rescue NameError
-            raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
-          end
-        when Class
-          type
-        else
-          raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
-        end
+        self.class.cast_type!(type)
       end
 
-      def cast_value(value)
-        return type.cast(value) unless value.is_a?(Array)
+      def cast_value(value, register)
+        return cast_element(value, register) unless collection_instance?(value)
+
+        build_collection(value.map { |v| cast_element(v, register) })
+      end
+
+      def cast_element(value, register)
+        resolved_type = type(register)
+        return resolved_type.new(value) if value.is_a?(Hash) && !hash_type?
+
+        resolved_type.cast(value)
+      end
 
-        value.map { |v| type.cast(v) }
+      def hash_type?
+        type == Lutaml::Model::Type::Hash
       end
 
       def setter
         :"#{@name}="
       end
 
+      def collection
+        @options[:collection]
+      end
+
       def collection?
-        options[:collection] || false
+        collection || false
       end
 
       def singular?
         !collection?
       end
 
+      def collection_class
+        return Array unless custom_collection?
+
+        collection
+      end
+
+      def collection_instance?(value)
+        value.is_a?(collection_class)
+      end
+
+      def build_collection(*args)
+        collection_class.new(args.flatten)
+      end
+
       def raw?
         @raw
       end
@@ -99,13 +180,13 @@ module Lutaml
         !enum_values.empty?
       end
 
-      def default
-        cast_value(default_value)
+      def default(register = Lutaml::Model::Config.default_register)
+        cast_value(default_value(register), register)
       end
 
-      def default_value
+      def default_value(register)
         if delegate
-          type.attributes[to].default
+          type(register).attributes[to].default(register)
         elsif options[:default].is_a?(Proc)
           options[:default].call
         elsif options.key?(:default)
@@ -115,8 +196,8 @@ module Lutaml
         end
       end
 
-      def default_set?
-        !Utils.uninitialized?(default_value)
+      def default_set?(register)
+        !Utils.uninitialized?(default_value(register))
       end
 
       def pattern
@@ -153,8 +234,8 @@ module Lutaml
         options[:values].include?(value)
       end
 
-      def valid_pattern!(value)
-        return true unless type == Lutaml::Model::Type::String
+      def valid_pattern!(value, resolved_type)
+        return true unless resolved_type == Lutaml::Model::Type::String
         return true unless pattern
 
         unless pattern.match?(value)
@@ -174,32 +255,48 @@ module Lutaml
       #   2. Value count should be between the collection range if defined
       #      e.g if collection: 0..5 is set then the value greater then 5
       #          will raise `Lutaml::Model::CollectionCountOutOfRangeError`
-      def validate_value!(value)
+      def validate_value!(value, register)
         # Use the default value if the value is nil
-        value = default if value.nil?
+        value = default(register) if value.nil?
+        resolved_type = type(register)
 
         valid_value!(value) &&
           valid_collection!(value, self) &&
-          valid_pattern!(value) &&
-          validate_polymorphic!(value)
+          valid_pattern!(value, resolved_type) &&
+          validate_polymorphic!(value, resolved_type) &&
+          execute_validations!(value)
       end
 
-      def validate_polymorphic(value)
-        return value.all? { |v| validate_polymorphic!(v) } if value.is_a?(Array)
-        return true unless polymorphic_enabled?
+      # execute custom validations on the attribute value
+      # i.e presence: true, numericality: true, etc
+      def execute_validations!(value)
+        return true if Utils.blank?(value)
+
+        memoization_container = {}
+        errors = Lutaml::Model::Validator.call(value, validations, memoization_container)
 
-        valid_polymorphic_type?(value)
+        return if errors.empty?
+
+        raise Lutaml::Model::ValidationFailedError.new(errors)
+      end
+
+      def validate_polymorphic(value, resolved_type)
+        return value.all? { |v| validate_polymorphic!(v, resolved_type) } if value.is_a?(Array)
+        return true unless options[:polymorphic]
+
+        valid_polymorphic_type?(value, resolved_type)
       end
 
-      def validate_polymorphic!(value)
-        return true if validate_polymorphic(value)
+      def validate_polymorphic!(value, resolved_type)
+        return true if validate_polymorphic(value, resolved_type)
 
-        raise Lutaml::Model::PolymorphicError.new(value, options)
+        raise Lutaml::Model::PolymorphicError.new(value, options, resolved_type)
       end
 
       def validate_collection_range
         range = @options[:collection]
         return if range == true
+        return if custom_collection?
 
         unless range.is_a?(Range)
           raise ArgumentError, "Invalid collection range: #{range}"
@@ -228,14 +325,14 @@ module Lutaml
       end
 
       def valid_collection!(value, caller)
-        raise Lutaml::Model::CollectionTrueMissingError.new(name, caller) if value.is_a?(Array) && !collection?
+        raise Lutaml::Model::CollectionTrueMissingError.new(name, caller) if collection_instance?(value) && !collection?
 
         return true unless collection?
 
         # Allow any value for unbounded collections
         return true if options[:collection] == true
 
-        unless value.is_a?(Array)
+        unless collection_instance?(value)
           raise Lutaml::Model::CollectionCountOutOfRangeError.new(
             name,
             value,
@@ -246,7 +343,7 @@ module Lutaml
         range = options[:collection]
         return true unless range.is_a?(Range)
 
-        if range.end.nil?
+        if range.is_a?(Range) && range.end.nil?
           if value.size < range.begin
             raise Lutaml::Model::CollectionCountOutOfRangeError.new(
               name,
@@ -254,7 +351,7 @@ module Lutaml
               range,
             )
           end
-        elsif !range.cover?(value.size)
+        elsif range.is_a?(Range) && !range.cover?(value.size)
           raise Lutaml::Model::CollectionCountOutOfRangeError.new(
             name,
             value,
@@ -263,39 +360,86 @@ module Lutaml
         end
       end
 
-      def serialize(value, format, options = {})
-        value ||= [] if collection? && initialize_empty?
+      def serialize(value, format, register, options = {})
+        value ||= build_collection if collection? && initialize_empty?
         return value if value.nil? || Utils.uninitialized?(value)
         return value if derived?
-        return serialize_array(value, format, options) if value.is_a?(Array)
-        return serialize_model(value, format, options) if type <= Serialize
 
-        serialize_value(value, format)
-      end
+        resolved_type = options[:resolved_type] || type(register)
+        serialize_options = options.merge(resolved_type: resolved_type)
+        return serialize_array(value, format, register, serialize_options) if collection_instance?(value)
+        return serialize_model(value, format, register, options) if resolved_type <= Serialize
 
-      def cast(value, format, options = {})
-        value ||= [] if collection? && !value.nil?
-        return value.map { |v| cast(v, format, options) } if value.is_a?(Array)
+        serialize_value(value, format, resolved_type)
+      end
 
-        return value if already_serialized?(type, value)
+      def cast(value, format, register, options = {})
+        resolved_type = options[:resolved_type] || type(register)
+        return build_collection(value.map { |v| cast(v, format, register, options.merge(resolved_type: resolved_type)) }) if collection_instance?(value) || value.is_a?(Array)
 
-        klass = resolve_polymorphic_class(type, value, options)
+        return value if already_serialized?(resolved_type, value)
 
+        klass = resolve_polymorphic_class(resolved_type, value, options)
         if can_serialize?(klass, value, format)
-          klass.apply_mappings(value, format, options)
+          klass.apply_mappings(value, format, options.merge(register: register))
         elsif needs_conversion?(klass, value)
           klass.send(:"from_#{format}", value)
         else
-          klass.cast(value)
+          # No need to use register#get_class,
+          # can_serialize? method already checks if type is Serializable or not.
+          Type.lookup(klass).cast(value)
         end
       end
 
+      def serializable?(register)
+        type(register) <= Serialize
+      end
+
+      def collection_range
+        return unless collection?
+
+        collection.is_a?(Range) ? collection : 0..Float::INFINITY
+      end
+
+      def sequenced_appearance_count(element_order, mapped_name, current_index)
+        elements = element_order[current_index..]
+        element_count = elements.take_while { |element| element == mapped_name }.count
+        return element_count if element_count.between?(*collection_range.minmax)
+
+        raise Lutaml::Model::ElementCountOutOfRangeError.new(
+          mapped_name,
+          element_count,
+          collection_range,
+        )
+      end
+
+      def process_options!
+        validate_options!(@options)
+        @raw = !!@options[:raw]
+        @validations = @options[:validations]
+        set_default_for_collection if collection?
+      end
+
       def deep_dup
-        self.class.new(name, type, Utils.deep_dup(options))
+        self.class.new(name, unresolved_type, Utils.deep_dup(options))
       end
 
       private
 
+      def validate_name!(name, reserved_methods:)
+        return unless reserved_methods.include?(name.to_sym)
+
+        if ALLOW_OVERRIDING.include?(name.to_sym)
+          warn_name_conflict(name)
+        else
+          raise Lutaml::Model::InvalidAttributeNameError.new(name)
+        end
+      end
+
+      def warn_name_conflict(name)
+        Logger.warn("Attribute name `#{name}` conflicts with a built-in method")
+      end
+
       def resolve_polymorphic_class(type, value, options)
         return type unless polymorphic_map_defined?(options, value)
 
@@ -304,47 +448,54 @@ module Lutaml
         Object.const_get(klass_name)
       end
 
-      def polymorphic_map_defined?(options, value)
+      def polymorphic_map_defined?(polymorphic_options, value)
         !value.nil? &&
-          options[:polymorphic] &&
-          !options[:polymorphic].empty? &&
-          value[options[:polymorphic][:attribute]]
+          polymorphic_options[:polymorphic] &&
+          !polymorphic_options[:polymorphic].empty? &&
+          value[polymorphic_options[:polymorphic][:attribute]]
       end
 
       def castable?(value, format)
         value.is_a?(Hash) ||
-          (format == :xml && value.is_a?(Lutaml::Model::XmlAdapter::XmlElement))
-      end
-
-      def castable_serialized_type?(value)
-        type <= Serialize && value.is_a?(type.model)
+          (format == :xml && value.is_a?(Lutaml::Model::Xml::XmlElement))
       end
 
       def can_serialize?(klass, value, format)
         klass <= Serialize && castable?(value, format)
       end
 
+      def custom_collection?
+        return false if singular?
+        return false if collection == true
+        return false if collection.is_a?(Range)
+
+        collection <= Lutaml::Model::Collection
+      end
+
       def needs_conversion?(klass, value)
-        !value.nil? && !value.is_a?(klass)
+        !value.nil? && !value.is_a?(klass) && Utils.initialized?(value)
       end
 
       def already_serialized?(klass, value)
         klass <= Serialize && value.is_a?(klass.model)
       end
 
-      def serialize_array(value, format, options)
-        value.map { |v| serialize(v, format, options) }
+      def serialize_array(value, format, register, options)
+        value.map { |v| serialize(v, format, register, options) }
       end
 
-      def serialize_model(value, format, options)
+      def serialize_model(value, format, register, options)
+        as_options = options.merge(register: register)
         return unless Utils.present?(value)
-        return value.class.as(format, value, options) if value.is_a?(type)
 
-        type.as(format, value, options)
+        resolved_type = as_options.delete(:resolved_type) || type(register)
+        return value.class.as(format, value, as_options) if value.is_a?(resolved_type)
+
+        resolved_type.as(format, value, as_options)
       end
 
-      def serialize_value(value, format)
-        value = type.new(value) unless value.is_a?(Type::Value)
+      def serialize_value(value, format, resolved_type)
+        value = resolved_type.new(value) unless value.is_a?(Type::Value)
         value.send(:"to_#{format}")
       end
 
@@ -354,29 +505,19 @@ module Lutaml
         raise ArgumentError, "method or type must be set for an attribute"
       end
 
-      def process_type!(type)
-        validate_type!(type)
-        @type = cast_type!(type)
-      end
-
-      def process_options!
-        validate_options!(@options)
-        @raw = !!@options[:raw]
-        set_default_for_collection if collection?
-      end
-
       def set_default_for_collection
         validate_collection_range
-        @options[:default] ||= -> { [] } if initialize_empty?
+        @options[:default] ||= -> { build_collection } if initialize_empty?
       end
 
       def validate_options!(options)
         if (invalid_opts = options.keys - ALLOWED_OPTIONS).any?
-          raise StandardError,
-                "Invalid options given for `#{name}` #{invalid_opts}"
+          raise Lutaml::Model::InvalidAttributeOptionsError.new(name, invalid_opts)
         end
 
-        if options.key?(:pattern) && type != Lutaml::Model::Type::String
+        # No need to change user register#get_class, only checks if type is LutaML-Model string.
+        # Using MODEL_STRINGS since pattern is only supported for String type.
+        if options.key?(:pattern) && !MODEL_STRINGS.include?(type)
           raise StandardError,
                 "Invalid option `pattern` given for `#{name}`, " \
                 "`pattern` is only allowed for :string type"
@@ -390,19 +531,20 @@ module Lutaml
       end
 
       def validate_type!(type)
-        return true if type.is_a?(Class)
-        return true if [Symbol, String].include?(type.class) && cast_type!(type)
+        return true if [Symbol, String].include?(type.class) || type.is_a?(Class)
 
         raise ArgumentError,
               "Invalid type: #{type}, must be a Symbol, String or a Class"
       end
 
-      def polymorphic_enabled?
-        options[:polymorphic]&.any?
+      def valid_polymorphic_type?(value, resolved_type)
+        return value.is_a?(type) unless has_polymorphic_list?
+
+        options[:polymorphic].include?(value.class) && value.is_a?(resolved_type)
       end
 
-      def valid_polymorphic_type?(value)
-        value.is_a?(type) && options[:polymorphic].include?(value.class)
+      def has_polymorphic_list?
+        options[:polymorphic]&.is_a?(Array)
       end
     end
   end

data/lib/lutaml/model/choice.rb

@@ -41,8 +41,28 @@ module Lutaml
         raise Lutaml::Model::ChoiceLowerBoundError.new(validated_attributes, @min) if valid.count < @min
       end
 
+      def import_model_attributes(model)
+        return import_model_later(model, :import_model_attributes) if later_importable?(model)
+
+        root_model_error(model)
+        imported_attributes = Utils.deep_dup(model.attributes.values)
+        imported_attributes.each do |attr|
+          attr.options[:choice] = self
+          @model.define_attribute_methods(attr)
+        end
+        @attributes.concat(imported_attributes)
+        attrs_hash = imported_attributes.to_h { |attr| [attr.name, attr] }
+        @model.attributes.merge!(attrs_hash)
+      end
+
       private
 
+      def root_model_error(model)
+        return unless model.root?
+
+        raise Lutaml::Model::ImportModelWithRootError.new(model)
+      end
+
       def valid_attributes(object, validated_attributes)
         @attributes.each do |attribute|
           if attribute.is_a?(Choice)
@@ -58,6 +78,16 @@ module Lutaml
 
         validated_attributes
       end
+
+      def later_importable?(model)
+        model.is_a?(Symbol) || model.is_a?(String)
+      end
+
+      def import_model_later(model, method)
+        @model.importable_choices[self][method] << model.to_sym
+        @model.instance_variable_set(:@choices_imported, false)
+        @model.setup_trace_point
+      end
     end
   end
 end