lutaml-model 0.5.3 → 0.6.0

data/lib/lutaml/model/schema.rb

@@ -2,6 +2,7 @@ require_relative "schema/json_schema"
 require_relative "schema/xsd_schema"
 require_relative "schema/relaxng_schema"
 require_relative "schema/yaml_schema"
+require_relative "schema/xml_compiler"
 
 module Lutaml
   module Model
@@ -21,6 +22,10 @@ module Lutaml
       def self.to_yaml(klass, options = {})
         YamlSchema.generate(klass, options)
       end
+
+      def self.from_xml(xml, options = {})
+        XmlCompiler.to_models(xml, options)
+      end
     end
   end
 end

data/lib/lutaml/model/schema_location.rb

@@ -11,6 +11,13 @@ module Lutaml
       def to_xml_attribute
         "#{@namespace} #{@location}".strip
       end
+
+      def eql?(other)
+        other.class == self.class &&
+          namespace == other.namespace &&
+          location == other.location
+      end
+      alias == eql?
     end
 
     class SchemaLocation

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
@@ -269,8 +310,17 @@ module Lutaml
 
             value = instance.send(name)
 
+            if rule.raw_mapping?
+              adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
+              return adapter.parse(value, options)
+            end
+
             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
@@ -424,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)
@@ -440,43 +491,45 @@ 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["__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["__schema_location"][:schema_location],
-              prefix: doc["__schema_location"][:prefix],
-              namespace: doc["__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)
 
             attr = attribute_for_rule(rule)
 
-            namespaced_names = rule.namespaced_names(options[:default_namespace])
-
             value = if rule.raw_mapping?
-                      doc.node.inner_xml
+                      doc.root.inner_xml
                     elsif rule.content_mapping?
-                      doc[rule.content_key]
-                    elsif key = (namespaced_names & doc.keys).first
-                      doc[key]
-                    else
+                      rule.cdata ? doc.cdata : doc.text
+                    elsif val = value_for_rule(doc, rule, options, instance)
+                      val
+                    elsif instance.using_default?(rule.to) || rule.render_default
                       defaults_used << rule.to
                       attr&.default || rule.to_value_for(instance)
                     end
+
             value = normalize_xml_value(value, rule, attr, options)
             rule.deserialize(instance, value, attributes, self)
           end
@@ -488,6 +541,46 @@ module Lutaml
           instance
         end
 
+        def value_for_rule(doc, rule, options, instance)
+          rule_names = rule.namespaced_names(options[:default_namespace])
+
+          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 = {})
           mappings = options[:mappings] || mappings_for(format).mappings
           mappings.each do |rule|
@@ -500,6 +593,9 @@ module Lutaml
             value = names.collect do |rule_name|
               if rule.root_mapping?
                 doc
+              elsif rule.raw_mapping?
+                adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
+                adapter.new(doc).public_send(:"to_#{format}")
               elsif doc.key?(rule_name.to_s)
                 doc[rule_name.to_s]
               elsif doc.key?(rule_name.to_sym)
@@ -530,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)
@@ -583,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
@@ -703,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/toml_adapter/toml_rb_adapter.rb

@@ -6,8 +6,7 @@ module Lutaml
     module TomlAdapter
       class TomlRbAdapter < TomlDocument
         def self.parse(toml, _options = {})
-          data = TomlRB.parse(toml)
-          new(data)
+          TomlRB.parse(toml)
         end
 
         def to_toml(*)

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/hash.rb

@@ -19,18 +19,18 @@ module Lutaml
 
           hash = hash.to_h if hash.is_a?(Lutaml::Model::MappingHash)
 
-          hash = hash.except("text")
-
-          hash.transform_values do |value|
-            if value.is_a?(::Hash)
-              # Only process if value is a Hash
-              nested = normalize_hash(value)
-              # Only include non-text nodes in nested hashes if it's a hash
-              nested.is_a?(::Hash) ? nested.except("text") : nested
-            else
-              value
-            end
+          normalized_hash = hash.transform_values do |value|
+            normalize_value(value)
           end
+
+          normalized_hash["elements"] || normalized_hash
+        end
+
+        def self.normalize_value(value)
+          return value unless value.is_a?(::Hash)
+
+          nested = normalize_hash(value)
+          nested.is_a?(::Hash) ? nested.except("text") : nested
         end
 
         def self.serialize(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.3"
+    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)