lutaml-model 0.1.0 → 0.3.0

data/lib/lutaml/model/schema/xsd_schema.rb

@@ -5,14 +5,12 @@ module Lutaml
   module Model
     module Schema
       class XsdSchema
-        def self.generate(klass, options = {})
+        def self.generate(klass, _options = {})
           schema = Nokogiri::XML::Builder.new do |xml|
             xml.schema(xmlns: "http://www.w3.org/2001/XMLSchema") do
               xml.element(name: klass.name) do
                 xml.complexType do
-                  xml.sequence do
-                    generate_elements(klass, xml)
-                  end
+                  xml.sequence { generate_elements(klass, xml) }
                 end
               end
             end
@@ -20,8 +18,6 @@ module Lutaml
           schema.to_xml
         end
 
-        private
-
         def self.generate_elements(klass, xml)
           klass.attributes.each do |name, attr|
             xml.element(name: name, type: get_xsd_type(attr.type))
@@ -29,24 +25,15 @@ module Lutaml
         end
 
         def self.get_xsd_type(type)
-          case type
-          when Lutaml::Model::Type::String
-            "xs:string"
-          when Lutaml::Model::Type::Integer
-            "xs:integer"
-          when Lutaml::Model::Type::Boolean
-            "xs:boolean"
-          when Lutaml::Model::Type::Float
-            "xs:float"
-          when Lutaml::Model::Type::Decimal
-            "xs:decimal"
-          when Lutaml::Model::Type::Array
-            "xs:array"
-          when Lutaml::Model::Type::Hash
-            "xs:object"
-          else
-            "xs:string" # Default to string for unknown types
-          end
+          {
+            Lutaml::Model::Type::String => "xs:string",
+            Lutaml::Model::Type::Integer => "xs:integer",
+            Lutaml::Model::Type::Boolean => "xs:boolean",
+            Lutaml::Model::Type::Float => "xs:float",
+            Lutaml::Model::Type::Decimal => "xs:decimal",
+            Lutaml::Model::Type::Array => "xs:array",
+            Lutaml::Model::Type::Hash => "xs:object",
+          }[type] || "xs:string" # Default to string for unknown types
         end
       end
     end

data/lib/lutaml/model/schema/yaml_schema.rb

@@ -5,7 +5,7 @@ module Lutaml
   module Model
     module Schema
       class YamlSchema
-        def self.generate(klass, options = {})
+        def self.generate(klass, _options = {})
           schema = {
             "type" => "map",
             "mapping" => generate_mapping(klass),
@@ -13,8 +13,6 @@ module Lutaml
           YAML.dump(schema)
         end
 
-        private
-
         def self.generate_mapping(klass)
           klass.attributes.each_with_object({}) do |(name, attr), mapping|
             mapping[name.to_s] = { "type" => get_yaml_type(attr.type) }
@@ -22,24 +20,16 @@ module Lutaml
         end
 
         def self.get_yaml_type(type)
-          case type
-          when Lutaml::Model::Type::String
-            "str"
-          when Lutaml::Model::Type::Integer
-            "int"
-          when Lutaml::Model::Type::Boolean
-            "bool"
-          when Lutaml::Model::Type::Float
-            "float"
-          when Lutaml::Model::Type::Decimal
-            "float" # YAML does not have a separate decimal type, so we use float
-          when Lutaml::Model::Type::Array
-            "seq"
-          when Lutaml::Model::Type::Hash
-            "map"
-          else
-            "str" # Default to string for unknown types
-          end
+          {
+            Lutaml::Model::Type::String => "str",
+            Lutaml::Model::Type::Integer => "int",
+            Lutaml::Model::Type::Boolean => "bool",
+            Lutaml::Model::Type::Float => "float",
+            # YAML does not have a separate decimal type, so we use float
+            Lutaml::Model::Type::Decimal => "float",
+            Lutaml::Model::Type::Array => "seq",
+            Lutaml::Model::Type::Hash => "map",
+          }[type] || "str" # Default to string for unknown types
         end
       end
     end

data/lib/lutaml/model/serialize.rb

@@ -1,14 +1,11 @@
 # lib/lutaml/model/serialize.rb
-require_relative "json_adapter/standard"
-require_relative "json_adapter/multi_json"
 require_relative "yaml_adapter"
 require_relative "xml_adapter"
-require_relative "toml_adapter/toml_rb_adapter"
-require_relative "toml_adapter/tomlib_adapter"
 require_relative "config"
 require_relative "type"
 require_relative "attribute"
 require_relative "mapping_rule"
+require_relative "mapping_hash"
 require_relative "xml_mapping"
 require_relative "key_value_mapping"
 require_relative "json_adapter"
@@ -25,17 +22,23 @@ module Lutaml
       module ClassMethods
         attr_accessor :attributes, :mappings
 
+        def inherited(subclass)
+          super
+
+          subclass.instance_variable_set(:@attributes, @attributes.dup)
+        end
+
         def attribute(name, type, options = {})
           self.attributes ||= {}
           attr = Attribute.new(name, type, options)
           attributes[name] = attr
 
           define_method(name) do
-            instance_variable_get("@#{name}")
+            instance_variable_get(:"@#{name}")
           end
 
-          define_method("#{name}=") do |value|
-            instance_variable_set("@#{name}", value)
+          define_method(:"#{name}=") do |value|
+            instance_variable_set(:"@#{name}", value)
           end
         end
 
@@ -45,13 +48,17 @@ module Lutaml
             klass = format == :xml ? XmlMapping : KeyValueMapping
             self.mappings[format] = klass.new
             self.mappings[format].instance_eval(&block)
+
+            if format == :xml && !self.mappings[format].root_element
+              self.mappings[format].root(to_s)
+            end
           end
 
-          define_method("from_#{format}") do |data|
-            adapter = Lutaml::Model::Config.send("#{format}_adapter")
+          define_method(:"from_#{format}") do |data|
+            adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
             doc = adapter.parse(data)
             mapped_attrs = apply_mappings(doc.to_h, format)
-            apply_content_mapping(doc, mapped_attrs) if format == :xml
+            # apply_content_mapping(doc, mapped_attrs) if format == :xml
             new(mapped_attrs)
           end
         end
@@ -64,55 +71,170 @@ module Lutaml
           klass = format == :xml ? XmlMapping : KeyValueMapping
           klass.new.tap do |mapping|
             attributes&.each do |name, attr|
-              mapping.map_element(name.to_s, to: name, render_nil: attr.render_nil?)
+              mapping.map_element(name.to_s, to: name,
+                                             render_nil: attr.render_nil?)
             end
           end
         end
 
         def apply_mappings(doc, format)
+          return apply_xml_mapping(doc) if format == :xml
+
           mappings = mappings_for(format).mappings
-          mappings.each_with_object({}) do |rule, hash|
-            attr = attributes[rule.to]
+          mappings.each_with_object(Lutaml::Model::MappingHash.new) do |rule, hash|
+            attr = if rule.delegate
+                     attributes[rule.delegate].type.attributes[rule.to]
+                   else
+                     attributes[rule.to]
+                   end
+
             raise "Attribute '#{rule.to}' not found in #{self}" unless attr
 
-            value = doc[rule.name]
+            value = if rule.custom_methods[:from]
+                      new.send(rule.custom_methods[:from], hash, doc)
+                    elsif doc.key?(rule.name) || doc.key?(rule.name.to_sym)
+                      doc[rule.name] || doc[rule.name.to_sym]
+                    else
+                      attr.default
+                    end
+
             if attr.collection?
-              value = (value || []).map { |v| attr.type <= Serialize ? attr.type.new(v) : v }
-            elsif value.is_a?(Hash) && attr.type <= Serialize
-              value = attr.type.new(value)
+              value = (value || []).map do |v|
+                attr.type <= Serialize ? attr.type.apply_mappings(v, format) : v
+              end
+            elsif value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
+              value = attr.type.apply_mappings(value, format)
+            end
+
+            if rule.delegate
+              hash[rule.delegate] ||= {}
+              hash[rule.delegate][rule.to] = value
+            else
+              hash[rule.to] = value
             end
-            hash[rule.to] = value
           end
         end
 
-        def apply_content_mapping(doc, mapped_attrs)
-          content_mapping = mappings_for(:xml).content_mapping
-          return unless content_mapping
+        def apply_xml_mapping(doc, caller_class: nil, mixed_content: false)
+          return unless doc
+
+          mappings = mappings_for(:xml).mappings
+
+          if doc.is_a?(Array)
+            raise "May be `collection: true` is" \
+                  "missing for #{self} in #{caller_class}"
+          end
+
+          mapping_hash = Lutaml::Model::MappingHash.new
+          mapping_hash.item_order = doc.item_order
+          mapping_hash.ordered = mappings_for(:xml).mixed_content? || mixed_content
+
+          mappings.each_with_object(mapping_hash) do |rule, hash|
+            attr = attributes[rule.to]
+            raise "Attribute '#{rule.to}' not found in #{self}" unless attr
+
+            is_content_mapping = rule.name.nil?
+            value = if is_content_mapping
+                      doc["text"]
+                    else
+                      doc[rule.name.to_s] || doc[rule.name.to_sym]
+                    end
+
+            if attr.collection?
+              if value && !value.is_a?(Array)
+                value = [value]
+              end
+
+              value = (value || []).map do |v|
+                if attr.type <= Serialize
+                  attr.type.apply_xml_mapping(v, caller_class: self, mixed_content: rule.mixed_content)
+                elsif v.is_a?(Hash)
+                  v["text"]
+                else
+                  v
+                end
+              end
+            elsif attr.type <= Serialize
+              value = attr.type.apply_xml_mapping(value, caller_class: self, mixed_content: rule.mixed_content)
+            else
+              if value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
+                value = value["text"]
+              end
+
+              value = attr.type.cast(value) unless is_content_mapping
+            end
 
-          content = doc.root.children.select(&:text?).map(&:text)
-          mapped_attrs[content_mapping.to] = content
+            hash[rule.to] = value
+          end
         end
       end
 
+      attr_reader :element_order
+
       def initialize(attrs = {})
-        return self unless self.class.attributes
+        return unless self.class.attributes
+
+        if attrs.is_a?(Lutaml::Model::MappingHash)
+          @ordered = attrs.ordered?
+          @element_order = attrs.item_order
+        end
 
         self.class.attributes.each do |name, attr|
-          value = attrs.key?(name) ? attrs[name] : attr.default
-          value = if attr.collection?
-              (value || []).map { |v| Lutaml::Model::Type.cast(v, attr.type) }
+          value = attr_value(attrs, name, attr)
+
+          send(:"#{name}=", ensure_utf8(value))
+        end
+      end
+
+      def attr_value(attrs, name, attr_rule)
+        value = if attrs.key?(name)
+                  attrs[name]
+                elsif 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
-              Lutaml::Model::Type.cast(value, attr.type)
+              Lutaml::Model::Type.cast(
+                v, attr_rule.type
+              )
             end
-          send("#{name}=", ensure_utf8(value))
+          end
+        elsif value.is_a?(Hash) && attr_rule.type != Lutaml::Model::Type::Hash
+          attr_rule.type.new(value)
+        else
+          Lutaml::Model::Type.cast(value, attr_rule.type)
         end
       end
 
+      def ordered?
+        @ordered
+      end
+
+      def key_exist?(hash, key)
+        hash.key?(key) || hash.key?(key.to_sym) || hash.key?(key.to_s)
+      end
+
+      def key_value(hash, key)
+        hash[key] || hash[key.to_sym] || hash[key.to_s]
+      end
+
       # TODO: Make this work
       # FORMATS.each do |format|
       #   define_method("to_#{format}") do |options = {}|
       #     adapter = Lutaml::Model::Config.send("#{format}_adapter")
-      #     representation = format == :yaml ? self : hash_representation(format, options)
+      #     representation = if format == :yaml
+      #                        self
+      #                      else
+      #                        hash_representation(format, options)
+      #                      end
       #     adapter.new(representation).send("to_#{format}", options)
       #   end
       # end
@@ -148,20 +270,63 @@ module Lutaml
           name = rule.to
           next if except&.include?(name) || (only && !only.include?(name))
 
-          value = send(name)
+          next handle_delegate(self, rule, hash) if rule.delegate
+
+          value = if rule.custom_methods[:to]
+                    send(rule.custom_methods[:to], self, send(name))
+                  else
+                    send(name)
+                  end
+
           next if value.nil? && !rule.render_nil
 
+          attribute = self.class.attributes[name]
+
           hash[rule.from] = case value
-            when Array
-              value.map { |v| v.is_a?(Serialize) ? v.hash_representation(format, options) : v }
-            else
-              value.is_a?(Serialize) ? value.hash_representation(format, options) : value
-            end
+                            when Array
+                              value.map do |v|
+                                if v.is_a?(Serialize)
+                                  v.hash_representation(format, options)
+                                else
+                                  attribute.type.serialize(v)
+                                end
+                              end
+                            else
+                              if value.is_a?(Serialize)
+                                value.hash_representation(format, options)
+                              else
+                                attribute.type.serialize(value)
+                              end
+                            end
         end
       end
 
       private
 
+      def handle_delegate(_obj, rule, hash)
+        name = rule.to
+        value = send(rule.delegate).send(name)
+        return if value.nil? && !rule.render_nil
+
+        attribute = send(rule.delegate).class.attributes[name]
+        hash[rule.from] = case value
+                          when Array
+                            value.map do |v|
+                              if v.is_a?(Serialize)
+                                v.hash_representation(format, options)
+                              else
+                                attribute.type.serialize(v)
+                              end
+                            end
+                          else
+                            if value.is_a?(Serialize)
+                              value.hash_representation(format, options)
+                            else
+                              attribute.type.serialize(value)
+                            end
+                          end
+      end
+
       def ensure_utf8(value)
         case value
         when String
@@ -169,7 +334,9 @@ module Lutaml
         when Array
           value.map { |v| ensure_utf8(v) }
         when Hash
-          value.transform_keys { |k| ensure_utf8(k) }.transform_values { |v| ensure_utf8(v) }
+          value.transform_keys do |k|
+            ensure_utf8(k)
+          end.transform_values { |v| ensure_utf8(v) }
         else
           value
         end

data/lib/lutaml/model/toml_adapter/tomlib_adapter.rb

@@ -7,12 +7,13 @@ module Lutaml
     module TomlAdapter
       class TomlibDocument < Document
         def self.parse(toml)
-          data = Tomlib::Parser.new(toml).parsed
+          data = Tomlib.load(toml)
           new(data)
         end
 
         def to_toml(*args)
-          Tomlib::Generator.new(to_h).toml_str
+          Tomlib.dump(to_h, *args)
+          # Tomlib::Generator.new(to_h).toml_str
         end
       end
     end