lutaml-model 0.5.4 → 0.6.0

data/lib/lutaml/model/sequence.rb

@@ -0,0 +1,71 @@
+module Lutaml
+  module Model
+    class Sequence
+      attr_reader :attributes,
+                  :model
+
+      def initialize(model)
+        @attributes = []
+        @model = model
+      end
+
+      def attribute(name, type, options = {})
+        options[:sequence] = self
+        @model.attribute(name, type, options)
+      end
+
+      def sequence(&block)
+        instance_eval(&block)
+      end
+
+      def map_element(
+        name,
+        to: nil,
+        render_nil: false,
+        render_default: false,
+        with: {},
+        delegate: nil,
+        cdata: false,
+        namespace: nil,
+        prefix: nil,
+        transform: {}
+      )
+        @attributes << @model.map_element(
+          name,
+          to: to,
+          render_nil: render_nil,
+          render_default: render_default,
+          with: with,
+          delegate: delegate,
+          cdata: cdata,
+          namespace: namespace,
+          prefix: prefix,
+          transform: transform,
+        )
+      end
+
+      def map_attribute(*)
+        raise Lutaml::Model::UnknownSequenceMappingError.new("map_attribute")
+      end
+
+      def map_content(*)
+        raise Lutaml::Model::UnknownSequenceMappingError.new("map_content")
+      end
+
+      def map_all(*)
+        raise Lutaml::Model::UnknownSequenceMappingError.new("map_all")
+      end
+
+      def validate_content!(element_order)
+        defined_order = @attributes.map { |rule| rule.name.to_s }
+        start_index = element_order.index(defined_order.first)
+
+        defined_order.each.with_index(start_index) do |element, i|
+          unless element_order[i] == element
+            raise Lutaml::Model::IncorrectSequenceError.new(element, element_order[i])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/serialize.rb

@@ -12,12 +12,16 @@ require_relative "comparable_model"
 require_relative "schema_location"
 require_relative "validation"
 require_relative "error"
+require_relative "choice"
+require_relative "sequence"
+require_relative "liquefiable"
 
 module Lutaml
   module Model
     module Serialize
       include ComparableModel
       include Validation
+      include Lutaml::Model::Liquefiable
 
       def self.included(base)
         base.extend(ClassMethods)
@@ -25,7 +29,9 @@ module Lutaml
       end
 
       module ClassMethods
-        attr_accessor :attributes, :mappings
+        include Lutaml::Model::Liquefiable::ClassMethods
+
+        attr_accessor :attributes, :mappings, :choice_attributes
 
         def inherited(subclass)
           super
@@ -40,6 +46,7 @@ module Lutaml
         def initialize_attrs(source_class)
           @mappings = Utils.deep_dup(source_class.instance_variable_get(:@mappings)) || {}
           @attributes = Utils.deep_dup(source_class.instance_variable_get(:@attributes)) || {}
+          @choice_attributes = Utils.deep_dup(source_class.instance_variable_get(:@choice_attributes)) || []
           instance_variable_set(:@model, self)
         end
 
@@ -81,6 +88,12 @@ module Lutaml
           value
         end
 
+        def choice(min: 1, max: 1, &block)
+          @choice_attributes << Choice.new(self, min, max).tap do |c|
+            c.instance_eval(&block)
+          end
+        end
+
         # Define an attribute for the model
         def attribute(name, type, options = {})
           attr = Attribute.new(name, type, options)
@@ -103,6 +116,33 @@ module Lutaml
               instance_variable_set(:"@#{name}", attr.cast_value(value))
             end
           end
+
+          register_drop_method(name)
+
+          attr
+        end
+
+        def root?
+          mappings_for(:xml).root?
+        end
+
+        def import_model_attributes(model)
+          raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+
+          @attributes.merge!(model.attributes)
+        end
+
+        def import_model_mappings(model)
+          raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+
+          @mappings.merge!(model.mappings)
+        end
+
+        def import_model(model)
+          raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+
+          import_model_attributes(model)
+          import_model_mappings(model)
         end
 
         def add_enum_methods_to_model(klass, enum_name, values, collection: false)
@@ -140,7 +180,7 @@ module Lutaml
                             enum_vals.delete(value)
                             enum_vals
                           else
-                            []
+                            instance_variable_get(:"@#{enum_name}") - [value]
                           end
 
               instance_variable_set(:"@#{enum_name}", enum_vals)
@@ -190,7 +230,7 @@ module Lutaml
             mappings[format] ||= klass.new
             mappings[format].instance_eval(&block)
 
-            if format == :xml && !mappings[format].root_element
+            if format == :xml && !mappings[format].root_element && !mappings[format].no_root?
               mappings[format].root(model.to_s)
             end
           end
@@ -208,9 +248,10 @@ module Lutaml
             end
 
             if format == :xml
-              doc_hash = doc.parse_element(doc.root, self, :xml)
+              raise Lutaml::Model::NoRootMappingError.new(self) unless root?
+
               options[:encoding] = doc.encoding
-              apply_mappings(doc_hash, format, options)
+              apply_mappings(doc, format, options)
             else
               apply_mappings(doc.to_h, format)
             end
@@ -276,6 +317,10 @@ module Lutaml
 
             attribute = attributes[name]
 
+            if export_method = rule.transform[:export] || attribute.transform_export_method
+              value = export_method.call(value)
+            end
+
             next hash.merge!(generate_hash_from_child_mappings(attribute, value, format, rule.root_mappings)) if rule.root_mapping?
 
             value = if rule.child_mappings
@@ -429,6 +474,7 @@ module Lutaml
           return instance if Utils.blank?(doc)
 
           options[:mappings] = mappings_for(format).mappings
+
           return apply_xml_mapping(doc, instance, options) if format == :xml
 
           apply_hash_mapping(doc, instance, format, options)
@@ -445,25 +491,28 @@ module Lutaml
           end
           mappings = options[:mappings] || mappings_for(:xml).mappings
 
-          if doc.is_a?(Array)
-            raise Lutaml::Model::CollectionTrueMissingError(self, option[:caller_class])
-          end
+          raise Lutaml::Model::CollectionTrueMissingError(self, option[:caller_class]) if doc.is_a?(Array)
 
-          if instance.respond_to?(:ordered=) && doc.is_a?(Lutaml::Model::MappingHash)
-            instance.element_order = doc.item_order
+          if instance.respond_to?(:ordered=)
+            instance.element_order = doc.root.order
             instance.ordered = mappings_for(:xml).ordered? || options[:ordered]
             instance.mixed = mappings_for(:xml).mixed_content? || options[:mixed_content]
           end
 
-          if doc["attributes"]&.key?("__schema_location")
+          schema_location = doc.attributes.values.find do |a|
+            a.unprefixed_name == "schemaLocation"
+          end
+
+          if !schema_location.nil?
             instance.schema_location = Lutaml::Model::SchemaLocation.new(
-              schema_location: doc["attributes"]["__schema_location"][:schema_location],
-              prefix: doc["attributes"]["__schema_location"][:prefix],
-              namespace: doc["attributes"]["__schema_location"][:namespace],
+              schema_location: schema_location.value,
+              prefix: schema_location.namespace_prefix,
+              namespace: schema_location.namespace,
             )
           end
 
           defaults_used = []
+          validate_sequence!(instance.element_order)
 
           mappings.each do |rule|
             raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
@@ -471,12 +520,12 @@ module Lutaml
             attr = attribute_for_rule(rule)
 
             value = if rule.raw_mapping?
-                      doc.node.inner_xml
+                      doc.root.inner_xml
                     elsif rule.content_mapping?
-                      doc[rule.content_key]
-                    elsif val = value_for_rule(doc, rule, options)
+                      rule.cdata ? doc.cdata : doc.text
+                    elsif val = value_for_rule(doc, rule, options, instance)
                       val
-                    else
+                    elsif instance.using_default?(rule.to) || rule.render_default
                       defaults_used << rule.to
                       attr&.default || rule.to_value_for(instance)
                     end
@@ -492,13 +541,44 @@ module Lutaml
           instance
         end
 
-        def value_for_rule(doc, rule, options)
+        def value_for_rule(doc, rule, options, instance)
           rule_names = rule.namespaced_names(options[:default_namespace])
-          hash = rule.attribute? ? doc["attributes"] : doc["elements"]
-          return unless hash
 
-          value_key = rule_names.find { |name| hash.key_exist?(name) }
-          hash.fetch(value_key) if value_key
+          if rule.attribute?
+            doc.root.find_attribute_value(rule_names)
+          else
+            attr = attribute_for_rule(rule)
+
+            children = doc.children.select do |child|
+              rule_names.include?(child.namespaced_name)
+            end
+
+            if rule.using_custom_methods? || attr.type == Lutaml::Model::Type::Hash
+              return children.first
+            end
+
+            if Utils.present?(children)
+              instance.value_set_for(attr.name)
+            end
+
+            if rule.cdata
+              values = children.map do |child|
+                child.cdata_children&.map(&:text)
+              end.flatten
+              return children.count > 1 ? values : values.first
+            end
+
+            values = children.map do |child|
+              if !rule.using_custom_methods? && attr.type <= Serialize
+                attr.type.apply_xml_mapping(child, attr.type.new, options.except(:mappings))
+              elsif attr.raw?
+                inner_xml_of(child)
+              else
+                child&.children&.first&.text
+              end
+            end
+            attr&.collection? ? values : values.first
+          end
         end
 
         def apply_hash_mapping(doc, instance, format, options = {})
@@ -546,18 +626,6 @@ module Lutaml
         def normalize_xml_value(value, rule, attr, options = {})
           value = [value].compact if attr&.collection? && !value.is_a?(Array)
 
-          value = if value.is_a?(Array)
-                    value.map do |v|
-                      text_hash?(attr, v) ? v.text : v
-                    end
-                  elsif attr&.raw? && value
-                    value.node.children.map(&:to_xml).join
-                  elsif text_hash?(attr, value)
-                    value.text
-                  else
-                    value
-                  end
-
           return value unless cast_value?(attr, rule)
 
           options.merge(caller_class: self, mixed_content: rule.mixed_content)
@@ -599,6 +667,26 @@ module Lutaml
             value
           end
         end
+
+        def validate_sequence!(element_order)
+          mapping_sequence = mappings_for(:xml).element_sequence
+          current_order = element_order.filter_map(&:element_tag)
+
+          mapping_sequence.each do |mapping|
+            mapping.validate_content!(current_order)
+          end
+        end
+
+        private
+
+        def inner_xml_of(node)
+          case node
+          when XmlAdapter::XmlElement
+            node.inner_xml
+          else
+            node.children.map(&:to_xml).join
+          end
+        end
       end
 
       attr_accessor :element_order, :schema_location, :encoding
@@ -719,6 +807,8 @@ module Lutaml
       Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
         define_method(:"to_#{format}") do |options = {}|
           adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
+          raise Lutaml::Model::NoRootMappingError.new(self.class) unless self.class.root?
+
           representation = if format == :xml
                              self
                            else

data/lib/lutaml/model/type/decimal.rb

@@ -27,10 +27,6 @@ module Lutaml
           value.to_s("F") # Use fixed-point notation to match test expectations
         end
 
-        def self.from_xml(value)
-          cast(value.text)
-        end
-
         def self.check_dependencies!(value)
           unless defined?(BigDecimal)
             raise TypeNotEnabledError.new("Decimal", value)

data/lib/lutaml/model/type/time.rb

@@ -25,9 +25,9 @@ module Lutaml
         end
 
         # # xs:time format (HH:MM:SS.mmm±HH:MM)
-        # def to_xml
-        #   value&.strftime("%H:%M:%S%:z")
-        # end
+        def to_xml
+          value&.iso8601
+        end
 
         # # ISO8601 time format
         # def to_json

data/lib/lutaml/model/utils.rb

@@ -85,26 +85,30 @@ module Lutaml
           end
         end
 
-        def deep_dup(hash)
-          return hash if hash.nil?
-
-          new_hash = {}
-
-          hash.each do |key, value|
-            new_hash[key] = if value.is_a?(Hash)
-                              deep_dup(value)
-                            elsif value.respond_to?(:deep_dup)
-                              value.deep_dup
-                            else
-                              value.dup
-                            end
-          end
+        def deep_dup(object)
+          return object if object.nil?
 
-          new_hash
+          case object
+          when Hash then deep_dup_hash(object)
+          when Array then deep_dup_array(object)
+          else deep_dup_object(object)
+          end
         end
 
         private
 
+        def deep_dup_hash(hash)
+          hash.transform_values { |value| deep_dup(value) }
+        end
+
+        def deep_dup_array(array)
+          array.map { |value| deep_dup(value) }
+        end
+
+        def deep_dup_object(object)
+          object.respond_to?(:deep_dup) ? object.deep_dup : object.dup
+        end
+
         def camelize_part(part)
           part.gsub(/(?:_|-|^)([a-z\d])/i) { $1.upcase }
         end

data/lib/lutaml/model/validation.rb

@@ -17,13 +17,24 @@ module Lutaml
             errors << e
           end
         end
-        errors
+
+        validate_helper(errors)
       end
 
       def validate!
         errors = validate
         raise Lutaml::Model::ValidationError.new(errors) if errors.any?
       end
+
+      def validate_helper(errors)
+        self.class.choice_attributes.each do |attribute|
+          attribute.validate_content!(self)
+        end
+        errors
+      rescue Lutaml::Model::ChoiceUpperBoundError,
+             Lutaml::Model::ChoiceLowerBoundError => e
+        errors << e
+      end
     end
   end
 end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.5.4"
+    VERSION = "0.6.0"
   end
 end

data/lib/lutaml/model/xml_adapter/builder/oga.rb

@@ -6,19 +6,15 @@ module Lutaml
       module Builder
         class Oga
           def self.build(options = {}, &block)
-            if block_given?
-              XmlAdapter::Builder::Oga.new(options, &block)
-            else
-              XmlAdapter::Builder::Oga.new(options)
-            end
+            new(options, &block)
           end
 
-          attr_reader :document, :current_node, :options
+          attr_reader :document, :current_node, :encoding
 
           def initialize(options = {})
             @document = XmlAdapter::Oga::Document.new
             @current_node = @document
-            @options = options
+            @encoding = options[:encoding]
             yield(self) if block_given?
           end
 
@@ -112,9 +108,14 @@ module Lutaml
           end
 
           def add_text(element, text, cdata: false)
+            text = text&.encode(encoding) if encoding && text.is_a?(String)
             return add_cdata(element, text) if cdata
 
             oga_text = ::Oga::XML::Text.new(text: text.to_s)
+            append_text_node(element, oga_text)
+          end
+
+          def append_text_node(element, oga_text)
             if element.is_a?(XmlAdapter::Oga::Document)
               children = element.children
               children.empty? ? children << oga_text : children.last.children << oga_text
@@ -166,6 +167,8 @@ module Lutaml
 
           def element_attributes(oga_element, attributes)
             oga_element.attributes = attributes.map do |name, value|
+              value = value.uri unless value.is_a?(String)
+
               ::Oga::XML::Attribute.new(
                 name: name,
                 value: value,

data/lib/lutaml/model/xml_adapter/builder/ox.rb

@@ -6,17 +6,18 @@ module Lutaml
           def self.build(options = {})
             if block_given?
               ::Ox::Builder.new(options) do |xml|
-                yield(new(xml))
+                yield(new(xml, options))
               end
             else
-              new(::Ox::Builder.new(options))
+              new(::Ox::Builder.new(options), options)
             end
           end
 
-          attr_reader :xml
+          attr_reader :xml, :encoding
 
-          def initialize(xml)
+          def initialize(xml, options = {})
             @xml = xml
+            @encoding = options[:encoding]
             @current_namespace = nil
           end
 
@@ -27,7 +28,7 @@ module Lutaml
 
             if block_given?
               xml.element(name, attributes) do |element|
-                yield(self.class.new(element))
+                yield(self.class.new(element, { encoding: encoding }))
               end
             else
               xml.element(name, attributes)
@@ -44,17 +45,11 @@ module Lutaml
 
           def create_and_add_element(element_name, prefix: nil, attributes: {})
             element_name = element_name.first if element_name.is_a?(Array)
-            prefixed_name = if prefix
-                              "#{prefix}:#{element_name}"
-                            elsif @current_namespace && !element_name.start_with?("#{@current_namespace}:")
-                              "#{@current_namespace}:#{element_name}"
-                            else
-                              element_name
-                            end
+            prefixed_name = set_prefixed_name(element_name, prefix)
 
             if block_given?
               xml.element(prefixed_name, attributes) do |element|
-                yield(self.class.new(element))
+                yield(self.class.new(element, { encoding: encoding }))
               end
             else
               xml.element(prefixed_name, attributes)
@@ -63,6 +58,16 @@ module Lutaml
             @current_namespace = nil
           end
 
+          def set_prefixed_name(element_name, prefix)
+            if prefix
+              "#{prefix}:#{element_name}"
+            elsif @current_namespace && !element_name.start_with?("#{@current_namespace}:")
+              "#{@current_namespace}:#{element_name}"
+            else
+              element_name
+            end
+          end
+
           def <<(text)
             xml.text(text)
           end
@@ -72,6 +77,8 @@ module Lutaml
           end
 
           def add_text(element, text, cdata: false)
+            text = text&.encode(encoding) if encoding && text.is_a?(String)
+
             return element.cdata(text) if cdata
 
             element.text(text)

data/lib/lutaml/model/xml_adapter/element.rb

@@ -0,0 +1,32 @@
+module Lutaml
+  module Model
+    module XmlAdapter
+      class Element
+        attr_reader :type, :name
+
+        def initialize(type, name)
+          @type = type
+          @name = name
+        end
+
+        def text?
+          @type == "Text" && @name != "#cdata-section"
+        end
+
+        def element_tag
+          @name unless text?
+        end
+
+        def eql?(other)
+          return false unless other.is_a?(self.class)
+
+          instance_variables.all? do |var|
+            instance_variable_get(var) == other.instance_variable_get(var)
+          end
+        end
+
+        alias == eql?
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml_adapter/nokogiri_adapter.rb

@@ -7,9 +7,9 @@ module Lutaml
     module XmlAdapter
       class NokogiriAdapter < XmlDocument
         def self.parse(xml, options = {})
-          parsed = Nokogiri::XML(xml, nil, options[:encoding])
-          root = NokogiriElement.new(parsed.root)
-          new(root, parsed.encoding)
+          parsed = Nokogiri::XML(xml, nil, encoding(xml, options))
+          @root = NokogiriElement.new(parsed.root)
+          new(@root, parsed.encoding)
         end
 
         def to_xml(options = {})
@@ -71,11 +71,11 @@ module Lutaml
             index_hash = {}
             content = []
 
-            element.element_order.each do |name|
-              index_hash[name] ||= -1
-              curr_index = index_hash[name] += 1
+            element.element_order.each do |object|
+              index_hash[object.name] ||= -1
+              curr_index = index_hash[object.name] += 1
 
-              element_rule = xml_mapping.find_by_name(name)
+              element_rule = xml_mapping.find_by_name(object.name)
               next if element_rule.nil?
 
               attribute_def = attribute_definition_for(element, element_rule,
@@ -83,7 +83,7 @@ module Lutaml
               value = attribute_value_for(element, element_rule)
 
               if element_rule == xml_mapping.content_mapping
-                next if element_rule.cdata && name == "text"
+                next if element_rule.cdata && object.text?
 
                 text = xml_mapping.content_mapping.serialize(element)
                 text = text[curr_index] if text.is_a?(Array)