lutaml-model 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 223c53c673e167e5bf85d7eec79a95011e37db1e07849a6a005d935bd5586c0f
-  data.tar.gz: 4adc0dc4bc3d30b15c7901b2b997c3e4ff24ff9d92896020d038e443dda99925
+  metadata.gz: c28f7695801483c724c6d8b03e37b1bc269eb82a506b4e363f65078142bed860
+  data.tar.gz: feb57e7df6c86c2cc3cdaa03012045e017c557a2f957b74c639d80feb53a36fc
 SHA512:
-  metadata.gz: 34a4d857e96d2955581a6df37c0aff10466edb1eb57293d6a818c62b998ba2244609ac9963d676ff789c0c2e08593296bd96bf7d8c6bd628ff867718e9f8e31a
-  data.tar.gz: a0e0c005f90ce0d029f119f1d2013da1b2ea7d61e8a8f149c46fce3c6bbfea79237d90cb9b8fc4a5eed7ef40939f2b4a35d121ab2be034b04a897103e78b7c0e
+  metadata.gz: 4a9641bec82c8c12099bc5c332931aa1f52b0dd8594ebc6e43722ace015c838522e7ebc873b834e324167db151b5055bbb495461ee585f6fdcd1c400ddbe7513
+  data.tar.gz: 88090ad9c5dc0be10531d1fc5c053db353fd5a30412279f19868b4786d046ae1f9b9f03237709c1928afd039f2b94809e137a6ad430e3fe2d04e200416cc8949

data/.github/workflows/rake.yml

@@ -12,4 +12,4 @@ jobs:
   rake:
     uses: metanorma/ci/.github/workflows/generic-rake.yml@main
     secrets:
-      pat_token: ${{ secrets.METANORMA_CI_PAT_TOKEN }}
+      pat_token: ${{ secrets.LUTAML_CI_PAT_TOKEN }}

data/.github/workflows/release.yml

@@ -19,5 +19,5 @@ jobs:
     with:
       next_version: ${{ github.event.inputs.next_version }}
     secrets:
-      rubygems-api-key: ${{ secrets.METANORMA_CI_RUBYGEMS_API_KEY }}
-      pat_token: ${{ secrets.METANORMA_CI_PAT_TOKEN }}
+      rubygems-api-key: ${{ secrets.LUTAML_CI_RUBYGEMS_API_KEY }}
+      pat_token: ${{ secrets.LUTAML_CI_PAT_TOKEN }}

data/.rubocop.yml

@@ -5,7 +5,7 @@ inherit_from:
 # ...
 
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.0
   NewCops: enable
   Exclude:
     - 'lib/sts/mapper.rb'

data/Gemfile

@@ -10,3 +10,23 @@ gem "rake", "~> 13.0"
 gem "rspec", "~> 3.0"
 
 gem "rubocop", "~> 1.21"
+
+gem "equivalent-xml"
+
+gem "multi_json"
+
+gem "nokogiri"
+
+gem "oga"
+
+gem "ox"
+
+gem "pry"
+
+gem "rubocop-performance"
+
+gem "rubocop-rails"
+
+gem "tomlib"
+
+gem "toml-rb"

data/lib/lutaml/model/attribute.rb

@@ -15,7 +15,9 @@ module Lutaml
       end
 
       def default
-        options[:default].is_a?(Proc) ? options[:default].call : options[:default]
+        return options[:default].call if options[:default].is_a?(Proc)
+
+        options[:default]
       end
 
       def render_nil?

data/lib/lutaml/model/key_value_mapping.rb

@@ -11,7 +11,13 @@ module Lutaml
       end
 
       def map(name, to:, render_nil: false, with: {}, delegate: nil)
-        @mappings << KeyValueMappingRule.new(name, to: to, render_nil: render_nil, with: with, delegate: delegate)
+        @mappings << KeyValueMappingRule.new(
+          name,
+          to: to,
+          render_nil: render_nil,
+          with: with,
+          delegate: delegate,
+        )
       end
 
       alias map_element map

data/lib/lutaml/model/mapping_rule.rb

@@ -13,6 +13,15 @@ module Lutaml
       end
 
       alias from name
+      alias render_nil? render_nil
+
+      def prefixed_name
+        if prefix
+          "#{prefix}:#{name}"
+        else
+          name
+        end
+      end
 
       def serialize(model, value)
         if custom_methods[:to]

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

@@ -17,8 +17,6 @@ module Lutaml
           options[:pretty] ? JSON.pretty_generate(schema) : schema.to_json
         end
 
-        private
-
         def self.generate_definitions(klass)
           {
             klass.name => {
@@ -30,8 +28,8 @@ module Lutaml
         end
 
         def self.generate_properties(klass)
-          klass.attributes.each_with_object({}) do |(name, attr), properties|
-            properties[name] = generate_property_schema(attr)
+          klass.attributes.transform_values do |attr|
+            generate_property_schema(attr)
           end
         end
 
@@ -40,22 +38,14 @@ module Lutaml
         end
 
         def self.get_json_type(type)
-          case type
-          when Lutaml::Model::Type::String
-            "string"
-          when Lutaml::Model::Type::Integer
-            "integer"
-          when Lutaml::Model::Type::Boolean
-            "boolean"
-          when Lutaml::Model::Type::Float
-            "number"
-          when Lutaml::Model::Type::Array
-            "array"
-          when Lutaml::Model::Type::Hash
-            "object"
-          else
-            "string" # Default to string for unknown types
-          end
+          {
+            Lutaml::Model::Type::String => "string",
+            Lutaml::Model::Type::Integer => "integer",
+            Lutaml::Model::Type::Boolean => "boolean",
+            Lutaml::Model::Type::Float => "number",
+            Lutaml::Model::Type::Array => "array",
+            Lutaml::Model::Type::Hash => "object",
+          }[type] || "string" # Default to string for unknown types
         end
       end
     end

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

@@ -5,7 +5,7 @@ module Lutaml
   module Model
     module Schema
       class RelaxngSchema
-        def self.generate(klass, options = {})
+        def self.generate(klass, _options = {})
           schema = Nokogiri::XML::Builder.new do |xml|
             xml.element(name: klass.name) do
               xml.complexType do
@@ -18,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_relaxng_type(attr.type))
@@ -27,22 +25,14 @@ module Lutaml
         end
 
         def self.get_relaxng_type(type)
-          case type
-          when Lutaml::Model::Type::String
-            "string"
-          when Lutaml::Model::Type::Integer
-            "integer"
-          when Lutaml::Model::Type::Boolean
-            "boolean"
-          when Lutaml::Model::Type::Float
-            "float"
-          when Lutaml::Model::Type::Array
-            "array"
-          when Lutaml::Model::Type::Hash
-            "object"
-          else
-            "string" # Default to string for unknown types
-          end
+          {
+            Lutaml::Model::Type::String => "string",
+            Lutaml::Model::Type::Integer => "integer",
+            Lutaml::Model::Type::Boolean => "boolean",
+            Lutaml::Model::Type::Float => "float",
+            Lutaml::Model::Type::Array => "array",
+            Lutaml::Model::Type::Hash => "object",
+          }[type] || "string" # Default to string for unknown types
         end
       end
     end

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

@@ -22,6 +22,11 @@ module Lutaml
         base.extend(ClassMethods)
       end
 
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/BlockLength
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
       module ClassMethods
         attr_accessor :attributes, :mappings
 
@@ -31,11 +36,11 @@ module Lutaml
           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
 
@@ -47,8 +52,8 @@ module Lutaml
             self.mappings[format].instance_eval(&block)
           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
@@ -64,22 +69,98 @@ 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 = 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 = 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 do |v|
+            #     attr.type <= Serialize ? attr.type.new(v) : v
+            #   end
+            # elsif value.is_a?(Hash) && attr.type <= Serialize
+            #   value = attr.type.new(value)
+            # else
+            #   value = attr.type.cast(value)
+            # end
+
+            if attr.collection?
+              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
+          end
+        end
+
+        def apply_xml_mapping(doc)
+          mappings = mappings_for(:xml).mappings
+
           mappings.each_with_object({}) do |rule, hash|
             attr = attributes[rule.to]
             raise "Attribute '#{rule.to}' not found in #{self}" unless attr
 
-            value = doc[rule.name]
+            value = if rule.name
+                      doc[rule.name.to_s] || doc[rule.name.to_sym]
+                    else
+                      doc["text"]
+                    end
+
+            # if attr.collection?
+            #   value = (value || []).map do |v|
+            #     attr.type <= Serialize ? attr.type.from_hash(v) : v
+            #   end
+            # elsif value.is_a?(Hash) && attr.type <= Serialize
+            #   value = attr.type.cast(value)
+            # elsif value.is_a?(Array)
+            #   value = attr.type.cast(value.first["text"]&.first)
+            # 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|
+                if attr.type <= Serialize
+                  attr.type.apply_xml_mapping(v)
+                else
+                  v["text"]
+                end
+              end
+            elsif attr.type <= Serialize
+              value = attr.type.apply_xml_mapping(value) if value
+            else
+              if value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
+                value = value["text"]
+              end
+
+              value = attr.type.cast(value)
             end
             hash[rule.to] = value
           end
@@ -94,25 +175,50 @@ module Lutaml
         end
       end
 
+      # rubocop:disable Layout/LineLength
       def initialize(attrs = {})
-        return self unless self.class.attributes
+        return unless self.class.attributes
 
         self.class.attributes.each do |name, attr|
-          value = attrs.key?(name) ? attrs[name] : attr.default
+          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.default
+                  end
+
           value = if attr.collection?
-              (value || []).map { |v| Lutaml::Model::Type.cast(v, attr.type) }
-            else
-              Lutaml::Model::Type.cast(value, attr.type)
-            end
-          send("#{name}=", ensure_utf8(value))
+                    (value || []).map do |v|
+                      if v.is_a?(Hash)
+                        attr.type.new(v)
+                      else
+                        Lutaml::Model::Type.cast(
+                          v, attr.type
+                        )
+                      end
+                    end
+                  elsif value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
+                    attr.type.new(value)
+                  else
+                    Lutaml::Model::Type.cast(value, attr.type)
+                  end
+          send(:"#{name}=", ensure_utf8(value))
         end
       end
+      # rubocop:enable Layout/LineLength
 
       # 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 +254,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,11 +318,18 @@ 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
       end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/BlockLength
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
     end
   end
 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