lutaml-model 0.8.10 → 0.8.12

data/lib/lutaml/rdf/mapping_rule.rb

@@ -3,14 +3,31 @@
 module Lutaml
   module Rdf
     class MappingRule
-      attr_reader :predicate_name, :namespace, :to, :lang_tagged
+      attr_reader :predicate_name, :namespace, :to, :lang_tagged, :uri_reference
 
-      def initialize(predicate_name, namespace:, to:, lang_tagged: false)
+      def initialize(predicate_name, namespace:, to:, lang_tagged: false,
+                     uri_reference: false)
         validate!(predicate_name, namespace, to)
+        if lang_tagged && uri_reference
+          raise ArgumentError,
+                "lang_tagged and uri_reference are mutually exclusive"
+        end
+
         @predicate_name = predicate_name.to_s.freeze
         @namespace = namespace
         @to = to
         @lang_tagged = lang_tagged
+        @uri_reference = uri_reference
+      end
+
+      def kind
+        if uri_reference
+          :uri_reference
+        elsif lang_tagged
+          :lang_tagged
+        else
+          :plain
+        end
       end
 
       def uri

data/lib/lutaml/rdf/member_rule.rb

@@ -3,10 +3,27 @@
 module Lutaml
   module Rdf
     class MemberRule
-      attr_reader :attr_name
+      attr_reader :attr_name, :predicate_name, :namespace
+
+      def initialize(attr_name, predicate_name: nil, namespace: nil)
+        if predicate_name && !namespace
+          raise ArgumentError,
+                "namespace is required when predicate_name is provided"
+        end
 
-      def initialize(attr_name)
         @attr_name = attr_name.to_sym
+        @predicate_name = predicate_name
+        @namespace = namespace
+      end
+
+      def linked?
+        !!@predicate_name
+      end
+
+      def linked_predicate_uri
+        return nil unless linked?
+
+        @namespace[@predicate_name]
       end
     end
   end

data/lib/lutaml/rdf/transform.rb

@@ -3,22 +3,35 @@
 module Lutaml
   module Rdf
     class Transform < Lutaml::Model::Transform
-      protected
-
       def resolve_subject_uri(mapping, instance)
         mapping.rdf_subject&.call(instance)
       end
 
-      def resolve_type_uri(mapping)
-        return unless mapping.rdf_type
+      def resolve_single_type_uri(mapping, type_value)
+        mapping.namespace_set.resolve_compact_iri(type_value)
+      end
+
+      def resolve_type_uris(mapping)
+        return [] unless mapping.rdf_type.any?
+
+        mapping.rdf_type.map { |t| resolve_single_type_uri(mapping, t) }
+      end
+
+      def each_member(instance, member_rule, &)
+        collection = Array(instance.public_send(member_rule.attr_name))
+        collection.each(&)
+      end
 
-        mapping.namespace_set.resolve_compact_iri(mapping.rdf_type)
+      def member_mapping_for(member, format)
+        member.class.mappings[format]
       end
 
-      def resolve_type_compact(mapping)
-        mapping.rdf_type
+      def extract_language(value)
+        value.language_tag if value.is_a?(Lutaml::Rdf::LanguageTagged)
       end
 
+      protected
+
       def build_instance(attrs, options)
         child_register = Lutaml::Model::Register.resolve_for_child(
           model_class, lutaml_register
@@ -27,10 +40,6 @@ module Lutaml
         root_and_parent_assignment(instance, options)
         instance
       end
-
-      def extract_language(value)
-        value.language_tag if value.is_a?(Lutaml::Rdf::LanguageTagged)
-      end
     end
   end
 end

data/lib/lutaml/toml/adapter/mapping.rb

@@ -8,10 +8,8 @@ module Lutaml
           super(:toml)
         end
 
-        def deep_dup
-          self.class.new.tap do |new_mapping|
-            new_mapping.mappings = duplicate_mappings
-          end
+        def dup_instance
+          self.class.new
         end
 
         def validate!(key, to, with, render_nil, render_empty)

data/lib/lutaml/turtle/transform.rb

@@ -46,56 +46,101 @@ module Lutaml
       def build_graph(mapping, instance)
         graph = RDF::Graph.new
 
-        has_predicates_or_type = mapping.rdf_type || mapping.rdf_predicates.any?
-
-        if has_predicates_or_type
-          subject_uri = if mapping.rdf_subject
-                          RDF::URI(resolve_subject_uri(mapping, instance))
-                        else
-                          RDF::Node.new
-                        end
-
-          if mapping.rdf_type
-            type_uri = RDF::URI(resolve_type_uri(mapping))
-            graph << RDF::Statement.new(subject_uri, RDF.type, type_uri)
+        has_resource_data =
+          mapping.rdf_type.any? ||
+          mapping.rdf_predicates.any? ||
+          mapping.rdf_members.any?(&:linked?)
+
+        if has_resource_data
+          subject_uri = resolve_subject(mapping, instance)
+          build_resource_triples(graph, mapping, instance, subject_uri)
+        end
+
+        build_member_subgraphs(graph, mapping, instance)
+
+        graph
+      end
+
+      def resolve_subject(mapping, instance)
+        if mapping.rdf_subject
+          RDF::URI(resolve_subject_uri(mapping, instance))
+        else
+          RDF::Node.new
+        end
+      end
+
+      def build_resource_triples(graph, mapping, instance, subject_uri)
+        mapping.rdf_type.each do |type_value|
+          type_uri = RDF::URI(resolve_single_type_uri(mapping, type_value))
+          graph << RDF::Statement.new(subject_uri, RDF.type, type_uri)
+        end
+
+        mapping.rdf_predicates.each do |rule|
+          value = instance.public_send(rule.to)
+          next if value.nil?
+
+          Array(value).each do |v|
+            object = build_rdf_object(v, rule, mapping.namespace_set)
+            graph << RDF::Statement.new(subject_uri, RDF::URI(rule.uri), object)
           end
+        end
+
+        mapping.rdf_members.each do |member_rule|
+          next unless member_rule.linked?
 
-          mapping.rdf_predicates.each do |rule|
-            value = instance.public_send(rule.to)
-            next if value.nil?
+          each_member(instance, member_rule) do |member|
+            member_mapping = member_mapping_for(member, :turtle)
+            next unless member_mapping
 
-            Array(value).each do |v|
-              object = build_rdf_object(v, rule)
-              graph << RDF::Statement.new(subject_uri, RDF::URI(rule.uri),
-                                          object)
-            end
+            member_subject = RDF::URI(resolve_subject_uri(member_mapping,
+                                                          member))
+            graph << RDF::Statement.new(
+              subject_uri,
+              RDF::URI(member_rule.linked_predicate_uri),
+              member_subject,
+            )
           end
         end
+      end
 
+      def build_member_subgraphs(graph, mapping, instance)
         mapping.rdf_members.each do |member_rule|
-          collection = Array(instance.public_send(member_rule.attr_name))
-          collection.each do |member|
-            member_mapping = member.class.mappings[:turtle]
+          each_member(instance, member_rule) do |member|
+            member_mapping = member_mapping_for(member, :turtle)
             next unless member_mapping
 
             graph << build_graph(member_mapping, member)
           end
         end
-
-        graph
       end
 
-      def build_rdf_object(value, rule)
-        if rule.lang_tagged
+      def build_rdf_object(value, rule, namespace_set)
+        case rule.kind
+        when :uri_reference
+          build_uri_reference_object(value, namespace_set)
+        when :lang_tagged
           lang = extract_language(value)
           RDF::Literal.new(value.to_s, language: lang)
         else
-          case value
-          when Integer then RDF::Literal.new(value, datatype: RDF::XSD.integer)
-          when Float then RDF::Literal.new(value, datatype: RDF::XSD.double)
-          when TrueClass, FalseClass then RDF::Literal.new(value, datatype: RDF::XSD.boolean)
-          else RDF::Literal.new(value.to_s)
-          end
+          build_plain_literal(value)
+        end
+      end
+
+      def build_uri_reference_object(value, namespace_set)
+        resolved = if value.to_s.include?(":")
+                     namespace_set.resolve_compact_iri(value.to_s)
+                   else
+                     value.to_s
+                   end
+        RDF::URI.new(resolved)
+      end
+
+      def build_plain_literal(value)
+        case value
+        when Integer then RDF::Literal.new(value, datatype: RDF::XSD.integer)
+        when Float then RDF::Literal.new(value, datatype: RDF::XSD.double)
+        when TrueClass, FalseClass then RDF::Literal.new(value, datatype: RDF::XSD.boolean)
+        else RDF::Literal.new(value.to_s)
         end
       end
 
@@ -103,13 +148,12 @@ module Lutaml
         ns_set = mapping.namespace_set
 
         mapping.rdf_members.each do |member_rule|
-          collection = Array(instance.public_send(member_rule.attr_name))
-          next if collection.empty?
-
-          member_mapping = collection.first.class.mappings[:turtle]
-          next unless member_mapping
+          each_member(instance, member_rule) do |member|
+            member_mapping = member_mapping_for(member, :turtle)
+            next unless member_mapping
 
-          ns_set = ns_set.merge(member_mapping.namespace_set)
+            ns_set = ns_set.merge(member_mapping.namespace_set)
+          end
         end
 
         ns_set.each.with_object({}) do |ns, h|
@@ -119,38 +163,66 @@ module Lutaml
 
       def extract_attributes(graph, mapping)
         attrs = {}
-        type_uri = resolve_type_uri(mapping)
+        type_uris = resolve_type_uris(mapping)
 
-        matching_subjects = find_subjects_by_type(graph, type_uri)
+        matching_subjects = find_subjects_by_types(graph, type_uris)
 
         matching_subjects.each do |subject|
-          mapping.rdf_predicates.each do |rule|
-            stmts = graph.query([subject, RDF::URI(rule.uri), nil])
-            next if stmts.empty?
-
-            values = stmts.map { |s| literal_to_ruby(s.object) }
-            attrs[rule.to] = values.length == 1 ? values.first : values
-          end
+          attrs["id"] = subject.to_s unless subject.node?
+          extract_predicate_attributes(graph, subject, mapping, attrs)
         end
 
         attrs
       end
 
-      def find_subjects_by_type(graph, type_uri)
-        graph.query([nil, RDF.type, RDF::URI(type_uri)]).map(&:subject).uniq
+      def extract_predicate_attributes(graph, subject, mapping, attrs)
+        mapping.rdf_predicates.each do |rule|
+          stmts = graph.query([subject, RDF::URI(rule.uri), nil])
+          next if stmts.empty?
+
+          values = stmts.map do |s|
+            literal_to_ruby(s.object, rule, mapping.namespace_set)
+          end
+          attrs[rule.to] = values.length == 1 ? values.first : values
+        end
+      end
+
+      def find_subjects_by_types(graph, type_uris)
+        type_uris.flat_map do |type_uri|
+          graph.query([nil, RDF.type, RDF::URI(type_uri)]).map(&:subject).uniq
+        end.uniq
       end
 
-      def literal_to_ruby(rdf_object)
+      def literal_to_ruby(rdf_object, rule, namespace_set)
         case rdf_object
+        when RDF::URI
+          uri_to_ruby(rdf_object, rule, namespace_set)
         when RDF::Literal
+          literal_value_to_ruby(rdf_object, rule)
+        else
+          rdf_object.to_s
+        end
+      end
+
+      def uri_to_ruby(rdf_object, rule, namespace_set)
+        uri_str = rdf_object.to_s
+        if rule.kind == :uri_reference
+          namespace_set.compact(uri_str) || uri_str
+        else
+          uri_str
+        end
+      end
+
+      def literal_value_to_ruby(rdf_object, rule)
+        if rule.kind == :lang_tagged && rdf_object.language
+          rdf_object.value
+        else
           case rdf_object.datatype
           when RDF::XSD.integer then rdf_object.value.to_i
           when RDF::XSD.double, RDF::XSD.decimal, RDF::XSD.float then rdf_object.value.to_f
           when RDF::XSD.boolean then rdf_object.value == "true"
           else rdf_object.value
           end
-        else
-          rdf_object.to_s
         end
       end
     end

data/lib/lutaml/xml/schema/xsd.rb

@@ -2,11 +2,12 @@
 
 # NOTE: Do NOT require lutaml/model here. This file is autoloaded via
 # Lutaml::Xml::Schema::Xsd, and requiring lutaml/model creates a circular
-# dependency since lutaml/xml.rb requires lutaml/model. The adapter type
-# is already set by lutaml/xml.rb at the end.
+# dependency since lutaml/xml.rb requires lutaml/model. This file only sets
+# a fallback XML adapter when no adapter has been selected yet.
 
-adapter = RUBY_ENGINE == "opal" ? :oga : :nokogiri
-Lutaml::Model::Config.xml_adapter_type = adapter unless defined?(Lutaml::Model::Config.xml_adapter_type)
+unless defined?(Lutaml::Model::Config.xml_adapter_type)
+  Lutaml::Model::Config.xml_adapter_type = Lutaml::Model::AdapterResolver.detect_xml_adapter
+end
 
 # Require the XsdNamespace class for XSD schema support
 require_relative "xsd_namespace"

data/lib/lutaml/xml/schema.rb

@@ -3,11 +3,14 @@
 module Lutaml
   module Xml
     module Schema
-      autoload :Xsd, "#{__dir__}/schema/xsd"
-      autoload :XsdSchema, "#{__dir__}/schema/xsd_schema"
-      autoload :RelaxngSchema, "#{__dir__}/schema/relaxng_schema"
-      autoload :Builder, "#{__dir__}/schema/builder"
-      autoload :BuiltinTypes, "#{__dir__}/schema/builtin_types"
+      Lutaml::Model::RuntimeCompatibility.autoload_native(
+        self,
+        Xsd: "#{__dir__}/schema/xsd",
+        XsdSchema: "#{__dir__}/schema/xsd_schema",
+        RelaxngSchema: "#{__dir__}/schema/relaxng_schema",
+        Builder: "#{__dir__}/schema/builder",
+        BuiltinTypes: "#{__dir__}/schema/builtin_types",
+      )
     end
   end
 end

data/lib/lutaml/xml/xml_orderable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    # Mixin for XML element/attribute ordering state.
+    #
+    # Included by:
+    #   - Lutaml::Xml::Serialization::InstanceMethods (Serialize instances)
+    #   - Plain model classes via add_format_specific_model_methods
+    #
+    # Enables Lutaml::Model to check ordering capability with is_a? instead
+    # of respond_to?, following proper OOP type-checking.
+    module XmlOrderable
+      attr_accessor :element_order, :attribute_order, :ordered, :mixed
+    end
+  end
+end

data/lib/lutaml/xml.rb

@@ -42,16 +42,13 @@ module Lutaml
     # XML Schema modules
     autoload :Schema, "#{__dir__}/xml/schema"
 
-    # Detect available XML adapter
-    # @return [Symbol, nil] :nokogiri, :ox, :oga, :rexml, or nil
+    # Detect available XML adapter.
+    # Delegates to moxml, which is the authority on XML adapter
+    # availability and platform constraints.
+    #
+    # @return [Symbol] adapter type name
     def self.detect_xml_adapter
-      return :oga if Lutaml::Model::RuntimeCompatibility.opal?
-      return :nokogiri if Lutaml::Model::Utils.safe_load("nokogiri", :Nokogiri)
-      return :ox if Lutaml::Model::Utils.safe_load("ox", :Ox)
-      return :oga if Lutaml::Model::Utils.safe_load("oga", :Oga)
-      return :rexml if Lutaml::Model::Utils.safe_load("rexml", :REXML)
-
-      nil
+      Moxml::Config.runtime_default_adapter
     end
 
     # Get the current XML adapter
@@ -174,8 +171,8 @@ Lutaml::Model::FormatRegistry.register(
   ],
   adapter_options: if Lutaml::Model::RuntimeCompatibility.opal?
                      {
-                       available: %i[oga],
-                       default: :oga,
+                       available: %i[rexml],
+                       default: :rexml,
                      }
                    else
                      {

data/lib/lutaml/yaml/adapter/mapping.rb

@@ -8,10 +8,8 @@ module Lutaml
           super(:yaml)
         end
 
-        def deep_dup
-          self.class.new.tap do |new_mapping|
-            new_mapping.mappings = duplicate_mappings
-          end
+        def dup_instance
+          self.class.new
         end
       end
     end

data/lib/lutaml/yamls/adapter/mapping.rb

@@ -4,7 +4,7 @@ module Lutaml
   module Yamls
     module Adapter
       class Mapping < Lutaml::KeyValue::Mapping
-        attr_reader :yamls_sequence
+        attr_accessor :yamls_sequence
 
         def initialize
           super(:yaml)
@@ -15,9 +15,13 @@ module Lutaml
           @yamls_sequence.instance_eval(&)
         end
 
+        def dup_instance
+          self.class.new
+        end
+
         def deep_dup
-          self.class.new.tap do |new_mapping|
-            new_mapping.mappings = duplicate_mappings
+          super.tap do |new_mapping|
+            new_mapping.yamls_sequence = @yamls_sequence&.dup
           end
         end
       end

data/lutaml-model.gemspec

@@ -36,7 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "canon"
   spec.add_dependency "concurrent-ruby"
   spec.add_dependency "liquid", ">= 4.0", "< 6.0"
-  spec.add_dependency "moxml", ">= 0.1.20"
+  spec.add_dependency "moxml", ">= 0.1.22"
   spec.add_dependency "ostruct"
   spec.add_dependency "rubyzip", "~> 2.3"
   spec.add_dependency "thor"