lutaml-model 0.3.30 → 0.5.0

data/lib/lutaml/model/serialize.rb

@@ -21,6 +21,7 @@ module Lutaml
 
       def self.included(base)
         base.extend(ClassMethods)
+        base.initialize_attrs(base)
       end
 
       module ClassMethods
@@ -28,14 +29,18 @@ module Lutaml
 
         def inherited(subclass)
           super
+          subclass.initialize_attrs(self)
+        end
 
-          @mappings ||= {}
-          @attributes ||= {}
+        def included(base)
+          base.extend(ClassMethods)
+          base.initialize_attrs(self)
+        end
 
-          subclass.instance_variable_set(:@attributes,
-                                         Utils.deep_dup(@attributes))
-          subclass.instance_variable_set(:@mappings, Utils.deep_dup(@mappings))
-          subclass.instance_variable_set(:@model, subclass)
+        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)) || {}
+          instance_variable_set(:@model, self)
         end
 
         def model(klass = nil)
@@ -81,16 +86,104 @@ module Lutaml
           attr = Attribute.new(name, type, options)
           attributes[name] = attr
 
-          define_method(name) do
-            instance_variable_get(:"@#{name}")
+          if attr.enum?
+            add_enum_methods_to_model(
+              model,
+              name,
+              options[:values],
+              collection: options[:collection],
+            )
+          else
+            define_method(name) do
+              instance_variable_get(:"@#{name}")
+            end
+
+            define_method(:"#{name}=") do |value|
+              value_set_for(name)
+              instance_variable_set(:"@#{name}", attr.cast_value(value))
+            end
           end
+        end
+
+        def add_enum_methods_to_model(klass, enum_name, values, collection: false)
+          add_enum_getter_if_not_defined(klass, enum_name, collection)
+          add_enum_setter_if_not_defined(klass, enum_name, values, collection)
 
-          define_method(:"#{name}=") do |value|
-            value_set_for(name)
-            instance_variable_set(:"@#{name}", attr.cast_value(value))
+          return unless values.all?(::String)
+
+          values.each do |value|
+            Utils.add_method_if_not_defined(klass, "#{value}?") do
+              curr_value = public_send(:"#{enum_name}")
+
+              if collection
+                curr_value.include?(value)
+              else
+                curr_value == value
+              end
+            end
+
+            Utils.add_method_if_not_defined(klass, value.to_s) do
+              public_send(:"#{value}?")
+            end
+
+            Utils.add_method_if_not_defined(klass, "#{value}=") do |val|
+              value_set_for(enum_name)
+              enum_vals = public_send(:"#{enum_name}")
+
+              enum_vals = if !!val
+                            if collection
+                              enum_vals << value
+                            else
+                              [value]
+                            end
+                          elsif collection
+                            enum_vals.delete(value)
+                            enum_vals
+                          else
+                            []
+                          end
+
+              instance_variable_set(:"@#{enum_name}", enum_vals)
+            end
+
+            Utils.add_method_if_not_defined(klass, "#{value}!") do
+              public_send(:"#{value}=", true)
+            end
           end
         end
 
+        def add_enum_getter_if_not_defined(klass, enum_name, collection)
+          Utils.add_method_if_not_defined(klass, enum_name) do
+            i = instance_variable_get(:"@#{enum_name}") || []
+
+            if !collection && i.is_a?(Array)
+              i.first
+            else
+              i.uniq
+            end
+          end
+        end
+
+        def add_enum_setter_if_not_defined(klass, enum_name, _values, collection)
+          Utils.add_method_if_not_defined(klass, "#{enum_name}=") do |value|
+            value = [value] unless value.is_a?(Array)
+
+            value_set_for(enum_name)
+
+            if collection
+              curr_value = public_send(:"#{enum_name}")
+
+              instance_variable_set(:"@#{enum_name}", curr_value + value)
+            else
+              instance_variable_set(:"@#{enum_name}", value)
+            end
+          end
+        end
+
+        def enums
+          attributes.select { |_, attr| attr.enum? }
+        end
+
         Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
           define_method(format) do |&block|
             klass = format == :xml ? XmlMapping : KeyValueMapping
@@ -135,7 +228,7 @@ module Lutaml
             end
           end
 
-          define_method(:"as_#{format}") do |instance|
+          define_method(:"as_#{format}") do |instance, options = {}|
             if instance.is_a?(Array)
               return instance.map { |item| public_send(:"as_#{format}", item) }
             end
@@ -147,7 +240,7 @@ module Lutaml
 
             return instance if format == :xml
 
-            hash_representation(instance, format)
+            hash_representation(instance, format, options)
           end
         end
 
@@ -166,7 +259,7 @@ module Lutaml
           mappings.each_with_object({}) do |rule, hash|
             name = rule.to
             next if except&.include?(name) || (only && !only.include?(name))
-            next if !rule.render_default? && instance.using_default?(rule.to)
+            next if !rule.custom_methods[:to] && (!rule.render_default? && instance.using_default?(rule.to))
 
             next handle_delegate(instance, rule, hash, format) if rule.delegate
 
@@ -176,15 +269,18 @@ module Lutaml
 
             value = instance.send(name)
 
-            next if value.nil? && !rule.render_nil
-
             attribute = attributes[name]
 
-            hash[rule.from] = if rule.child_mappings
-                                generate_hash_from_child_mappings(value, rule.child_mappings)
-                              else
-                                attribute.serialize(value, format, options)
-                              end
+            value = if rule.child_mappings
+                      generate_hash_from_child_mappings(value, rule.child_mappings)
+                    else
+                      attribute.serialize(value, format, options)
+                    end
+
+            next if Utils.blank?(value) && !rule.render_nil
+
+            rule_from_name = rule.multiple_mappings? ? rule.from.first.to_s : rule.from.to_s
+            hash[rule_from_name] = value
           end
         end
 
@@ -194,39 +290,14 @@ module Lutaml
           return if value.nil? && !rule.render_nil
 
           attribute = instance.send(rule.delegate).class.attributes[name]
-          hash[rule.from] = attribute.serialize(value, format)
+          rule_from_name = rule.multiple_mappings? ? rule.from.first.to_s : rule.from.to_s
+          hash[rule_from_name] = attribute.serialize(value, format)
         end
 
         def mappings_for(format)
           mappings[format] || default_mappings(format)
         end
 
-        def attr_value(attrs, name, attr_rule)
-          value = if attrs.key?(name.to_sym)
-                    attrs[name.to_sym]
-                  elsif attrs.key?(name.to_s)
-                    attrs[name.to_s]
-                  else
-                    attr_rule.default
-                  end
-
-          if attr_rule.collection? || value.is_a?(Array)
-            (value || []).map do |v|
-              if v.is_a?(Hash)
-                attr_rule.type.new(v)
-              else
-                # TODO: This code is problematic because Type.cast does not know
-                # about all the types.
-                Lutaml::Model::Type.cast(v, attr_rule.type)
-              end
-            end
-          else
-            # TODO: This code is problematic because Type.cast does not know
-            # about all the types.
-            Lutaml::Model::Type.cast(value, attr_rule.type)
-          end
-        end
-
         def default_mappings(format)
           klass = format == :xml ? XmlMapping : KeyValueMapping
 
@@ -325,8 +396,7 @@ module Lutaml
           mappings = mappings_for(:xml).mappings
 
           if doc.is_a?(Array)
-            raise "May be `collection: true` is" \
-                  "missing for #{self} in #{options[:caller_class]}"
+            raise "May be `collection: true` is missing for #{self} in #{options[:caller_class]}"
           end
 
           if instance.respond_to?(:ordered=) && doc.is_a?(Lutaml::Model::MappingHash)
@@ -350,17 +420,18 @@ module Lutaml
 
             attr = attribute_for_rule(rule)
 
+            namespaced_names = rule.namespaced_names(options[:default_namespace])
+
             value = if rule.raw_mapping?
                       doc.node.inner_xml
                     elsif rule.content_mapping?
                       doc[rule.content_key]
-                    elsif doc.key_exist?(rule.namespaced_name(options[:default_namespace]))
-                      doc.fetch(rule.namespaced_name(options[:default_namespace]))
+                    elsif key = (namespaced_names & doc.keys).first
+                      doc[key]
                     else
                       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
@@ -379,13 +450,19 @@ module Lutaml
 
             attr = attribute_for_rule(rule)
 
-            value = if doc.key?(rule.name) || doc.key?(rule.name.to_sym)
-                      doc[rule.name] || doc[rule.name.to_sym]
-                    else
-                      attr.default
-                    end
+            names = rule.multiple_mappings? ? rule.name : [rule.name]
 
-            if rule.custom_methods[:from]
+            value = names.collect do |rule_name|
+              if doc.key?(rule_name.to_s)
+                doc[rule_name.to_s]
+              elsif doc.key?(rule_name.to_sym)
+                doc[rule_name.to_sym]
+              else
+                attr&.default
+              end
+            end.compact.first
+
+            if rule.using_custom_methods?
               if Utils.present?(value)
                 value = new.send(rule.custom_methods[:from], instance, value)
               end
@@ -479,7 +556,7 @@ module Lutaml
 
         self.class.attributes.each do |name, attr|
           value = if attrs.key?(name) || attrs.key?(name.to_s)
-                    self.class.attr_value(attrs, name, attr)
+                    attr_value(attrs, name, attr)
                   else
                     using_default_for(name)
                     attr.default
@@ -490,7 +567,35 @@ module Lutaml
             value = []
           end
 
-          instance_variable_set(:"@#{name}", self.class.ensure_utf8(value))
+          default = using_default?(name)
+          public_send(:"#{name}=", self.class.ensure_utf8(value))
+          using_default_for(name) if default
+        end
+      end
+
+      def attr_value(attrs, name, attr_rule)
+        value = if attrs.key?(name.to_sym)
+                  attrs[name.to_sym]
+                elsif attrs.key?(name.to_s)
+                  attrs[name.to_s]
+                else
+                  attr_rule.default
+                end
+
+        if attr_rule.collection? || value.is_a?(Array)
+          (value || []).map do |v|
+            if v.is_a?(Hash)
+              attr_rule.type.new(v)
+            else
+              # TODO: This code is problematic because Type.cast does not know
+              # about all the types.
+              Lutaml::Model::Type.cast(v, attr_rule.type)
+            end
+          end
+        else
+          # TODO: This code is problematic because Type.cast does not know
+          # about all the types.
+          Lutaml::Model::Type.cast(value, attr_rule.type)
         end
       end
 
@@ -539,6 +644,14 @@ module Lutaml
         hash[key.to_sym] || hash[key.to_s]
       end
 
+      def pretty_print_instance_variables
+        (instance_variables - %i[@using_default]).sort
+      end
+
+      def to_yaml_hash
+        self.class.as_yaml(self)
+      end
+
       Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
         define_method(:"to_#{format}") do |options = {}|
           adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")

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

@@ -36,6 +36,11 @@ module Lutaml
             raise TypeNotEnabledError.new("Decimal", value)
           end
         end
+
+        # Override to avoid serializing ruby object in YAML
+        def to_yaml
+          value&.to_s("F")
+        end
       end
     end
   end

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

@@ -34,10 +34,10 @@ module Lutaml
         #   value&.iso8601
         # end
 
-        # # YAML timestamp format (native)
-        # def to_yaml
-        #   value
-        # end
+        # YAML timestamp format (native)
+        def to_yaml
+          value&.iso8601
+        end
 
         # # TOML time format (HH:MM:SS.mmm)
         # def to_toml

data/lib/lutaml/model/utils.rb

@@ -39,7 +39,7 @@ module Lutaml
         end
 
         def blank?(value)
-          value.respond_to?(:empty?) ? value.empty? : !value
+          value.respond_to?(:empty?) ? value.empty? : value.nil?
         end
 
         def add_method_if_not_defined(klass, method_name, &block)

data/lib/lutaml/model/validation.rb

@@ -4,9 +4,13 @@ module Lutaml
       def validate
         errors = []
         self.class.attributes.each do |name, attr|
-          value = instance_variable_get(:"@#{name}")
+          value = public_send(:"#{name}")
           begin
-            attr.validate_value!(value)
+            if value.respond_to?(:validate!)
+              value.validate!
+            else
+              attr.validate_value!(value)
+            end
           rescue Lutaml::Model::InvalidValueError,
                  Lutaml::Model::CollectionCountOutOfRangeError,
                  PatternNotMatchedError => e

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.30"
+    VERSION = "0.5.0"
   end
 end

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

@@ -39,6 +39,7 @@ module Lutaml
           )
             add_namespace_prefix(prefix)
 
+            element_name = element_name.first if element_name.is_a?(Array)
             element_name = "#{element_name}_" if respond_to?(element_name)
 
             if block_given?

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      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
+          end
+
+          attr_reader :document, :current_node, :options
+
+          def initialize(options = {})
+            @document = XmlAdapter::Oga::Document.new
+            @current_node = @document
+            @options = options
+            yield(self) if block_given?
+          end
+
+          def create_element(name, attributes = {}, &block)
+            if @current_namespace && !name.start_with?("#{@current_namespace}:")
+              name = "#{@current_namespace}:#{name}"
+            end
+
+            if block_given?
+              element(name, attributes, &block)
+            else
+              element(name, attributes)
+            end
+          end
+
+          def element(name, attributes = {})
+            oga_element = ::Oga::XML::Element.new(name: name)
+            if block_given?
+              element_attributes(oga_element, attributes)
+              @current_node.children << oga_element
+              # Save previous node to reset the pointer for the rest of the iteration
+              previous_node = @current_node
+              # Set current node to new element as pointer for the block
+              @current_node = oga_element
+              yield(self)
+              # Reset the pointer for the rest of the iterations
+              @current_node = previous_node
+            end
+            oga_element
+          end
+
+          def add_element(oga_element, child)
+            if child.is_a?(String)
+              current_element = oga_element.is_a?(XmlAdapter::Oga::Document) ? current_node : oga_element
+              add_xml_fragment(current_element, child)
+            elsif oga_element.is_a?(XmlAdapter::Oga::Document)
+              oga_element.children.last.children << child
+            else
+              oga_element.children << child
+            end
+          end
+
+          def add_attribute(element, name, value)
+            attribute = ::Oga::XML::Attribute.new(
+              name: name,
+              value: value.to_s,
+            )
+            if element.is_a?(XmlAdapter::Oga::Document)
+              element.children.last.attributes << attribute
+            else
+              element.attributes << attribute
+            end
+          end
+
+          def create_and_add_element(
+            element_name,
+            prefix: (prefix_unset = true
+                     nil),
+            attributes: {},
+            &block
+          )
+            @current_namespace = nil if prefix.nil? && !prefix_unset
+            prefixed_name = if prefix
+                              "#{prefix}:#{element_name}"
+                            elsif @current_namespace && !element_name.start_with?("#{@current_namespace}:")
+                              "#{@current_namespace}:#{element_name}"
+                            else
+                              element_name
+                            end
+
+            if block_given?
+              element(prefixed_name, attributes, &block)
+            else
+              element(prefixed_name, attributes)
+            end
+          end
+
+          def <<(text)
+            @current_node.text(text)
+          end
+
+          def add_xml_fragment(element, content)
+            fragment = "<fragment>#{content}</fragment>"
+            parsed_fragment = ::Oga.parse_xml(fragment)
+            parsed_children = parsed_fragment.children.first.children
+            if element.is_a?(XmlAdapter::Oga::Document)
+              element.children.last.children += parsed_children
+            else
+              element.children += parsed_children
+            end
+          end
+
+          def add_text(element, text, cdata: false)
+            return add_cdata(element, text) if cdata
+
+            oga_text = ::Oga::XML::Text.new(text: text.to_s)
+            if element.is_a?(XmlAdapter::Oga::Document)
+              children = element.children
+              children.empty? ? children << oga_text : children.last.children << oga_text
+            else
+              element.children << oga_text
+            end
+          end
+
+          def add_cdata(element, value)
+            oga_cdata = ::Oga::XML::CData.new(text: value.to_s)
+            if element.is_a?(XmlAdapter::Oga::Document)
+              element.children.last.children << oga_cdata
+            else
+              element.children << oga_cdata
+            end
+          end
+
+          def add_namespace_prefix(prefix)
+            @current_namespace = prefix
+            self
+          end
+
+          def parent
+            @document
+          end
+
+          def text(value = nil)
+            return @current_node.inner_text if value.nil?
+
+            str = value.is_a?(Array) ? value.join : value
+            @current_node.children << ::Oga::XML::Text.new(text: str)
+          end
+
+          def method_missing(method_name, *args)
+            if block_given?
+              @current_node.public_send(method_name, *args) do
+                yield(self)
+              end
+            else
+              @current_node.public_send(method_name, *args)
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            @current_node.respond_to?(method_name) || super
+          end
+
+          private
+
+          def element_attributes(oga_element, attributes)
+            oga_element.attributes = attributes.map do |name, value|
+              ::Oga::XML::Attribute.new(
+                name: name,
+                value: value,
+                element: oga_element,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -43,6 +43,7 @@ module Lutaml
           end
 
           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}:")

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      module Oga
+        class Document < ::Oga::XML::Document
+          def initialize(options = {})
+            super
+          end
+
+          def text(value = nil)
+            children << ::Oga::XML::Text.new(text: value)
+            self
+          end
+        end
+      end
+    end
+  end
+end