lutaml-model 0.8.9 → 0.8.11

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/adapter/adapter_helpers.rb

@@ -90,7 +90,7 @@ module Lutaml
         # @param node [Moxml::Node] The XML node
         # @return [String] The namespaced name (e.g., "uri:name" or "name")
         def namespaced_name_of(node)
-          return name_of(node) unless node.respond_to?(:namespace)
+          return name_of(node) unless node.is_a?(Lutaml::Xml::XmlElement)
 
           [node&.namespace&.uri, node.name].compact.join(":")
         end

data/lib/lutaml/xml/adapter/base_adapter.rb

@@ -126,7 +126,7 @@ module Lutaml
         # @param options [Hash] serialization options
         # @return [Boolean] true if element has ordered content
         def ordered?(element, options = {})
-          return false unless element.respond_to?(:element_order)
+          return false unless element.is_a?(Lutaml::Model::Serialize)
 
           mapper_class = options[:mapper_class]
           xml_mapping = mapper_class&.mappings_for(:xml)
@@ -156,7 +156,7 @@ module Lutaml
           klass = mapper_class || element.class
           return klass.attributes[rule.to] unless rule.delegate
 
-          delegated_obj = element.send(rule.delegate)
+          delegated_obj = element.public_send(rule.delegate)
           return nil if delegated_obj.nil?
 
           delegated_obj.class.attributes[rule.to]
@@ -168,12 +168,12 @@ module Lutaml
         # @param rule [MappingRule] the mapping rule
         # @return [Object, nil] the attribute value or nil if delegate is nil
         def attribute_value_for(element, rule)
-          return element.send(rule.to) unless rule.delegate
+          return element.public_send(rule.to) unless rule.delegate
 
-          delegate_obj = element.send(rule.delegate)
+          delegate_obj = element.public_send(rule.delegate)
           return nil if delegate_obj.nil?
 
-          delegate_obj.send(rule.to)
+          delegate_obj.public_send(rule.to)
         end
 
         # Process content mapping for an element
@@ -186,7 +186,7 @@ module Lutaml
           return unless content_rule
 
           if content_rule.custom_methods[:to]
-            mapper_class.new.send(
+            mapper_class.new.public_send(
               content_rule.custom_methods[:to],
               element,
               xml.parent,
@@ -225,15 +225,11 @@ module Lutaml
         private
 
         def attribute_values(element, &)
-          if element.respond_to?(:attributes_each_value)
-            element.attributes_each_value(&)
-          else
-            element.attributes.each_value(&)
-          end
+          element.attributes.each_value(&)
         end
 
         def schema_location_attribute?(attr)
-          attr_name = if attr.respond_to?(:unprefixed_name)
+          attr_name = if attr.is_a?(Lutaml::Xml::XmlAttribute)
                         attr.unprefixed_name
                       else
                         attr.name
@@ -242,7 +238,7 @@ module Lutaml
         end
 
         def attribute_namespace_prefix(attr)
-          if attr.respond_to?(:namespace_prefix)
+          if attr.is_a?(Lutaml::Xml::XmlAttribute)
             attr.namespace_prefix
           else
             attr.namespace&.prefix
@@ -250,7 +246,7 @@ module Lutaml
         end
 
         def attribute_hash_name(attr)
-          if attr.respond_to?(:namespaced_name)
+          if attr.is_a?(Lutaml::Xml::XmlAttribute)
             attr.namespaced_name
           else
             self.class.namespaced_attr_name(attr)

data/lib/lutaml/xml/adapter/namespace_uri_collector.rb

@@ -29,7 +29,7 @@ module Lutaml
 
           visited.add(model.object_id)
 
-          if model.respond_to?(:original_namespace_uri) && model.original_namespace_uri
+          if model.is_a?(::Lutaml::Model::Serialize) && model.class.attributes.key?(:original_namespace_uri) && model.original_namespace_uri
             original_uri = model.original_namespace_uri
             if original_uri && !original_uri.empty?
               ns_class = model.class.mappings_for(:xml)&.namespace_class
@@ -47,12 +47,12 @@ module Lutaml
             next unless attr_def
 
             child_type = attr_def.type(Lutaml::Model::Config.default_register)
-            next unless child_type.respond_to?(:<) && child_type < ::Lutaml::Model::Serializable
+            next unless child_type.is_a?(Class) && child_type < ::Lutaml::Model::Serializable
 
             child_mapping = child_type.mappings_for(:xml)
             next unless child_mapping
 
-            child_instance = model.public_send(elem_rule.to) if model.respond_to?(elem_rule.to)
+            child_instance = model.public_send(elem_rule.to) if model.class.attributes.key?(elem_rule.to)
 
             if child_instance.is_a?(Array) || child_instance.is_a?(::Lutaml::Model::Collection)
               instances = child_instance.is_a?(::Lutaml::Model::Collection) ? child_instance.collection : child_instance

data/lib/lutaml/xml/adapter/plan_based_builder.rb

@@ -158,8 +158,8 @@ module Lutaml
                                                prefix: prefix) do |inner_xml|
             # Call attribute custom methods now that element is created
             attribute_custom_methods.each do |attribute_rule|
-              mapper_class.new.send(attribute_rule.custom_methods[:to],
-                                    element, inner_xml.parent, inner_xml)
+              mapper_class.new.public_send(attribute_rule.custom_methods[:to],
+                                           element, inner_xml.parent, inner_xml)
             end
 
             if ordered?(element, options.merge(mapper_class: mapper_class))
@@ -292,7 +292,7 @@ module Lutaml
           end
 
           # Check if element was created from nil value with render_nil option
-          if element.respond_to?(:xsi_nil) && element.xsi_nil
+          if element.is_a?(Lutaml::Xml::DataModel::XmlElement) && element.xsi_nil
             attributes["xsi:nil"] = true
           end
 
@@ -301,7 +301,7 @@ module Lutaml
                                                prefix: prefix) do |inner_xml|
             # Handle raw content (map_all directive)
             has_raw_content = false
-            if element.respond_to?(:raw_content)
+            if element.is_a?(Lutaml::Xml::DataModel::XmlElement)
               raw_content = element.raw_content
               if raw_content && !raw_content.to_s.empty?
                 inner_xml.add_xml_fragment(inner_xml, raw_content.to_s)
@@ -361,8 +361,8 @@ module Lutaml
 
             # Handle custom methods
             if element_rule.custom_methods[:to]
-              mapper_class.new.send(element_rule.custom_methods[:to], element,
-                                    xml.parent, xml)
+              mapper_class.new.public_send(element_rule.custom_methods[:to], element,
+                                           xml.parent, xml)
               next
             end
 
@@ -432,8 +432,8 @@ module Lutaml
 
             # Handle custom methods
             if element_rule.custom_methods[:to]
-              mapper_class.new.send(element_rule.custom_methods[:to], element,
-                                    xml.parent, xml)
+              mapper_class.new.public_send(element_rule.custom_methods[:to], element,
+                                           xml.parent, xml)
               next
             end
 
@@ -468,7 +468,7 @@ module Lutaml
                 attribute_def = mapper_class.attributes[element_rule.to]
                 next unless attribute_def
 
-                value = element.send(element_rule.to)
+                value = element.public_send(element_rule.to)
                 next unless element_rule.render?(value, element)
 
                 # For type-only models, children plans may not be available
@@ -500,7 +500,7 @@ module Lutaml
               attribute_def = mapper_class.attributes[element_rule.to]
               next unless attribute_def
 
-              value = element.send(element_rule.to)
+              value = element.public_send(element_rule.to)
               next unless element_rule.render?(value, element)
 
               child_plan = plan.child_plan(element_rule.to)
@@ -805,10 +805,10 @@ module Lutaml
           value = nil
 
           if element_rule.delegate
-            delegate_obj = element.send(element_rule.delegate)
-            if delegate_obj.respond_to?(element_rule.to)
+            delegate_obj = element.public_send(element_rule.delegate)
+            if delegate_obj.is_a?(Lutaml::Model::Serialize) && delegate_obj.class.attributes.key?(element_rule.to)
               attribute_def = delegate_obj.class.attributes[element_rule.to]
-              value = delegate_obj.send(element_rule.to)
+              value = delegate_obj.public_send(element_rule.to)
             end
           else
             attribute_def = attribute_definition_for(element, element_rule,
@@ -828,7 +828,7 @@ module Lutaml
         # @param content [Array] accumulated content strings
         def process_ordered_content(element, xml_mapping, xml, curr_index,
 content)
-          text = element.send(xml_mapping.content_mapping.to)
+          text = element.public_send(xml_mapping.content_mapping.to)
           text = text[curr_index] if text.is_a?(Array)
 
           if element.mixed?

data/lib/lutaml/xml/adapter/xml_serializer.rb

@@ -83,7 +83,7 @@ module Lutaml
         def build_xml_element_with_plan(builder, xml_element, plan,
     options = {})
           # Add processing instructions before the root element
-          if xml_element.respond_to?(:processing_instructions)
+          if xml_element.is_a?(Lutaml::Xml::DataModel::XmlElement)
             xml_element.processing_instructions.each do |pi|
               builder.add_processing_instruction(pi.target, pi.content)
             end
@@ -230,7 +230,7 @@ module Lutaml
             attributes[attr_node.qualified_name] = xml_attr.value.to_s
           end
 
-          if xml_element.respond_to?(:xsi_nil) && xml_element.xsi_nil
+          if xml_element.is_a?(Lutaml::Xml::DataModel::XmlElement) && xml_element.xsi_nil
             attributes["xsi:nil"] = "true"
           end
 
@@ -240,7 +240,7 @@ module Lutaml
           attributes["xmlns"] = "" if needs_xmlns_blank
 
           xml.create_and_add_element(qualified_name, attributes: attributes) do
-            if xml_element.respond_to?(:raw_content)
+            if xml_element.is_a?(Lutaml::Xml::DataModel::XmlElement)
               raw_content = xml_element.raw_content
               if raw_content && !raw_content.to_s.empty?
                 xml.add_xml_fragment(xml, raw_content.to_s)

data/lib/lutaml/xml/configurable.rb

@@ -119,7 +119,8 @@ module Lutaml
         # @return [void]
         def inherit_mapping_from(mapping_class)
           # Get the parent mapping instance that has DSL already evaluated
-          parent_mapping = if mapping_class.respond_to?(:xml_mapping_instance) &&
+          parent_mapping = if mapping_class.is_a?(Class) &&
+              (mapping_class < Lutaml::Xml::Mapping || mapping_class.include?(Lutaml::Model::Serialize)) &&
               mapping_class.xml_mapping_instance
                              mapping_class.xml_mapping_instance
                            else

data/lib/lutaml/xml/data_model.rb

@@ -133,7 +133,7 @@ module Lutaml
         def qualified_name(prefix = nil)
           if prefix
             "#{prefix}:#{name}"
-          elsif namespace_class.respond_to?(:prefix_default)
+          elsif namespace_class.is_a?(Class) && namespace_class < Lutaml::Xml::Namespace
             ns_prefix = namespace_class.prefix_default
             ns_prefix ? "#{ns_prefix}:#{name}" : name
           else
@@ -202,7 +202,7 @@ module Lutaml
         def qualified_name(prefix = nil)
           if prefix
             "#{prefix}:#{name}"
-          elsif namespace_class.respond_to?(:prefix_default)
+          elsif namespace_class.is_a?(Class) && namespace_class < Lutaml::Xml::Namespace
             ns_prefix = namespace_class.prefix_default
             ns_prefix ? "#{ns_prefix}:#{name}" : name
           else

data/lib/lutaml/xml/decisions/decision_context.rb

@@ -129,7 +129,7 @@ module Lutaml
           return nil unless @element
 
           if @element.is_a?(Lutaml::Xml::XmlElement)
-            @element.namespace_prefix if @element.respond_to?(:namespace_prefix)
+            @element.namespace_prefix
           else
             # For DataModel::XmlElement, check xml_namespace_prefix first
             prefix = @element.xml_namespace_prefix
@@ -137,7 +137,7 @@ module Lutaml
 
             # Fall back to original XmlElement wrapper if available
             original = @element.original_xml_element
-            if original.respond_to?(:namespace_prefix)
+            if original.is_a?(Lutaml::Xml::XmlElement)
               return original.namespace_prefix
             end
 
@@ -213,7 +213,7 @@ module Lutaml
 
         # Returns all URIs for the current namespace (canonical + aliases).
         def namespace_all_uris
-          if @namespace_class.respond_to?(:all_uris)
+          if @namespace_class.is_a?(Class) && @namespace_class < Lutaml::Xml::Namespace
             @namespace_class.all_uris
           else
             [@namespace_uri]

data/lib/lutaml/xml/decisions/rules/element_form_default_unqualified_rule.rb

@@ -51,7 +51,7 @@ module Lutaml
 
             # Only apply if no explicit form option on the element
             # ElementFormOptionRule (Priority -0.5) handles explicit form options
-            return false if context.element.respond_to?(:form) && !context.element.form.nil?
+            return false if context.element.is_a?(Lutaml::Xml::DataModel::XmlElement) && !context.element.form.nil?
 
             true
           end

data/lib/lutaml/xml/decisions/rules/element_form_option_rule.rb

@@ -30,7 +30,7 @@ module Lutaml
           def applies?(context)
             return false unless context.element
             # Check if element responds to :form before accessing it
-            return false unless context.element.respond_to?(:form)
+            return false unless context.element.is_a?(Lutaml::Xml::DataModel::XmlElement)
 
             # Check if element has form attribute
             form = context.element.form

data/lib/lutaml/xml/decisions/rules/used_prefix_rule.rb

@@ -44,7 +44,7 @@ module Lutaml
             # Skip if namespace does NOT have element_form_default :qualified
             # Namespaces without explicit :qualified should use default format
             # (e.g., dcterms namespace uses default format, not prefix)
-            return false unless ns_class.respond_to?(:element_form_default_set?) &&
+            return false unless ns_class.is_a?(Class) && ns_class < Lutaml::Xml::Namespace &&
               ns_class.element_form_default_set? &&
               ns_class.element_form_default == :qualified
 

data/lib/lutaml/xml/declaration_plan.rb

@@ -441,7 +441,7 @@ module Lutaml
         ns_classes = []
         collect_ns_classes_recursive(@root_node, ns_classes)
         ns_classes.uniq.select do |ns_class|
-          ns_class.respond_to?(:schema_location) && ns_class.schema_location
+          ns_class.is_a?(Class) && ns_class < Lutaml::Xml::Namespace && ns_class.schema_location
         end
       end
 
@@ -452,7 +452,7 @@ module Lutaml
       # @return [void]
       def collect_ns_classes_recursive(element_node, ns_classes)
         # Add namespace from element's own namespace_class
-        if element_node.respond_to?(:qualified_name) && @namespace_classes
+        if element_node.is_a?(Lutaml::Xml::DeclarationPlan::ElementNode) && @namespace_classes
           # Try to find namespace class from namespace_classes by matching URI
           # The ElementNode itself doesn't store ns_class, but we can check if
           # any of our namespace_classes match the element's context