lutaml-model 0.8.16 → 0.8.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b419ac1cce55a5e56ca59dd217042047801d2420751f89ce0b875558e517f44
-  data.tar.gz: ed7c6b7dcd749c35d7fa434d2adf4b9e036c7329afd80c2420ef75f57f65895f
+  metadata.gz: 8296b9832eb080f64ba1344b7fa929b179fedc1c4265d9743d6636cd408720f6
+  data.tar.gz: 533255e9702cd82fc93cacc78bf88fb90dba17b8543b5ecf22bb223eaacfa9a1
 SHA512:
-  metadata.gz: c923ed6933f06ca678d4b76c19b46553f1196e0b30c0f202113a792619c91c0e6b3e3885963f4b910d101722d0cee22df8bf71c0c593fc7de4f0832d9062d87d
-  data.tar.gz: cfc1cc06ebeb1affa7875ecc522d8625147f70ed81aa6ae2feb2b4debd92f652ce2cf565f9984e52170e65559a75f23139c85762df5018545b60187cb5974744
+  metadata.gz: 936d9c1ff8eefb9f2b861d3c29c4d032462f9f6f5624bb2d669ebfc77d49ade62ce2859f171052f3b473a00d0a83a88955ee1c4cbd47f5bbddfe2a625e62d1f8
+  data.tar.gz: 79f9f3b4cea4bff89c06df360e6a316507f62af37f2a277cd10dc54b38f72c374cadba6b4b995234e4c67f82dbaa71ecf751d3ec8ed280bf5fe0e64dca42534f

data/.github/workflows/release.yml

@@ -23,9 +23,6 @@ jobs:
     uses: metanorma/ci/.github/workflows/rubygems-release.yml@main
     with:
       next_version: ${{ github.event.inputs.next_version }}
-      post_install: |
-        git status
-        cat .bundle/config
     secrets:
       rubygems-api-key: ${{ secrets.LUTAML_CI_RUBYGEMS_API_KEY }}
       pat_token: ${{ secrets.LUTAML_CI_PAT_TOKEN }}

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-06-05 08:01:07 UTC using RuboCop version 1.87.0.
+# on 2026-06-08 11:45:37 UTC using RuboCop version 1.87.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -11,13 +11,66 @@ Gemspec/RequiredRubyVersion:
   Exclude:
     - 'lutaml-model.gemspec'
 
-# Offense count: 3052
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: EnforcedStyle, IndentationWidth.
+# SupportedStyles: with_first_argument, with_fixed_indentation
+Layout/ArgumentAlignment:
+  Exclude:
+    - 'lib/lutaml/rdf/linked_data_transform.rb'
+
+# Offense count: 2
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: EnforcedStyleAlignWith.
+# SupportedStylesAlignWith: either, start_of_block, start_of_line
+Layout/BlockAlignment:
+  Exclude:
+    - 'spec/lutaml/model/choice_restrict_spec.rb'
+
+# Offense count: 2
+# This cop supports safe autocorrection (--autocorrect).
+Layout/BlockEndNewline:
+  Exclude:
+    - 'spec/lutaml/model/choice_restrict_spec.rb'
+
+# Offense count: 2
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: EnforcedStyle, IndentationWidth.
+# SupportedStyles: special_inside_parentheses, consistent, align_brackets
+Layout/FirstArrayElementIndentation:
+  Exclude:
+    - 'spec/lutaml/model/choice_restrict_spec.rb'
+
+# Offense count: 4
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: Width, EnforcedStyleAlignWith, AllowedPatterns.
+# SupportedStylesAlignWith: start_of_line, relative_to_receiver
+Layout/IndentationWidth:
+  Exclude:
+    - 'spec/lutaml/model/choice_restrict_spec.rb'
+
+# Offense count: 3071
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
 Layout/LineLength:
   Enabled: false
 
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: symmetrical, new_line, same_line
+Layout/MultilineArrayBraceLayout:
+  Exclude:
+    - 'spec/lutaml/model/choice_restrict_spec.rb'
+
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AllowInHeredoc.
+Layout/TrailingWhitespace:
+  Exclude:
+    - 'lib/lutaml/rdf/linked_data_transform.rb'
+
 # Offense count: 21
 # Configuration parameters: AllowedMethods.
 # AllowedMethods: enums
@@ -232,7 +285,7 @@ RSpec/BeforeAfterAll:
 RSpec/ContextWording:
   Enabled: false
 
-# Offense count: 101
+# Offense count: 102
 # Configuration parameters: IgnoredMetadata.
 RSpec/DescribeClass:
   Enabled: false
@@ -243,7 +296,7 @@ RSpec/DescribeMethod:
     - 'spec/lutaml/xml/schema/xsd/schema_helper_methods_spec.rb'
     - 'spec/lutaml/xml/serializable_namespace_spec.rb'
 
-# Offense count: 1328
+# Offense count: 1343
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 68
@@ -318,7 +371,7 @@ RSpec/MultipleDescribes:
     - 'spec/lutaml/xml/namespace_resolution_strategy_spec.rb'
     - 'spec/lutaml/xml/xml_space_type_spec.rb'
 
-# Offense count: 1560
+# Offense count: 1576
 RSpec/MultipleExpectations:
   Max: 21
 
@@ -366,7 +419,7 @@ RSpec/RepeatedExampleGroupDescription:
   Exclude:
     - 'spec/lutaml/model/mixed_content_spec.rb'
 
-# Offense count: 40
+# Offense count: 39
 # Configuration parameters: CustomTransform, IgnoreMethods, IgnoreMetadata, InflectorPath, EnforcedInflector.
 # SupportedInflectors: default, active_support
 RSpec/SpecFilePathFormat:
@@ -392,6 +445,17 @@ Security/MarshalLoad:
   Exclude:
     - 'scripts-xmi-profile/profile_xmi.rb'
 
+# Offense count: 3
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: EnforcedStyle, ProceduralMethods, FunctionalMethods, AllowedMethods, AllowedPatterns, AllowBracesOnProceduralOneLiners, BracesRequiredMethods.
+# SupportedStyles: line_count_based, semantic, braces_for_chaining, always_braces
+# ProceduralMethods: benchmark, bm, bmbm, create, each_with_object, measure, new, realtime, tap, with_object
+# FunctionalMethods: let, let!, subject, watch
+# AllowedMethods: lambda, proc, it
+Style/BlockDelimiters:
+  Exclude:
+    - 'spec/lutaml/model/choice_restrict_spec.rb'
+
 # Offense count: 2
 # This cop supports unsafe autocorrection (--autocorrect-all).
 # Configuration parameters: AllowedMethods, AllowedPatterns.
@@ -484,11 +548,3 @@ Style/StringConcatenation:
     - 'lib/lutaml/model/schema/xml_compiler/complex_type.rb'
     - 'lib/lutaml/model/schema/xml_compiler/simple_type.rb'
     - 'lib/lutaml/model/schema/xml_compiler/xml_namespace_class.rb'
-
-# Offense count: 3
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyleForMultiline.
-# SupportedStylesForMultiline: comma, consistent_comma, diff_comma, no_comma
-Style/TrailingCommaInArguments:
-  Exclude:
-    - 'spec/lutaml/model/raw_element_spec.rb'

data/docs/_guides/xml/namespace-semantics.adoc

@@ -13,6 +13,8 @@ parent: XML namespaces
 Lutaml::Model implements W3C XML Namespace specification with a focus on
 **attribute-based namespace resolution**. Each XML element's namespace is
 determined by its attribute's type and parent context, following clear and
+
+NOTE: This document covers the *core namespace resolution principles*. For the `form:` override option, the full qualification precedence ladder, and `form:` behavior on nested `Serializable` children, see the companion guide: link:../xml-namespace-qualification[XML Namespace Qualification and Prefix Control].
 consistent rules.
 
 This document explains the core namespace principles that govern how namespaces

data/docs/_guides/xml-namespace-qualification.adoc

@@ -509,6 +509,148 @@ Parent.new(child: Child.new(value: "test")).to_xml(prefix: true)
 
 All three elements (`parent`, `child`, `value`) use the prefix because all are qualified via `element_form_default: :qualified`.
 
+=== Form Override on Serializable Children
+
+The `form:` option works on attributes of any type — including attributes whose value type is another `Serializable` model, not only simple types like `:string`. This matters when the parent's namespace declares `element_form_default :unqualified` (the W3C default) and you need a specific nested model element to be qualified anyway.
+
+.Worked example: form: :qualified on a Serializable child
+[example]
+====
+[source,ruby]
+----
+NS = Class.new(Lutaml::Model::XmlNamespace) do
+  uri "https://example.com/ns"
+  prefix_default "ex"
+  element_form_default :unqualified  # W3C default for local elements
+end
+
+class Child < Lutaml::Model::Serializable
+  attribute :label, :string
+  xml do
+    element "child"
+    namespace NS
+    map_element "label", to: :label
+  end
+end
+
+class Parent < Lutaml::Model::Serializable
+  attribute :child, Child
+  xml do
+    element "item"
+    namespace NS
+    map_element "child", to: :child, form: :qualified  # Force prefix
+  end
+end
+
+Parent.new(child: Child.new(label: "x")).to_xml
+----
+
+*Output*:
+[source,xml]
+----
+<item xmlns="https://example.com/ns" xmlns:ex="https://example.com/ns">
+  <ex:child>
+    <label>x</label>
+  </ex:child>
+</item>
+----
+
+The `ex:` prefix on `<child>` is forced by `form: :qualified`, overriding the parent's `:unqualified` schema default. The inner `<label>` remains unprefixed because the `Child` model's own mapping rule for `label` has no `form:` override — see the next section.
+====
+
+=== Form Scope: Per-Rule, Not Transitive
+
+`form:` is a per-mapping-rule override. It does **not** propagate transitively to grandchildren. Each level of the model tree applies its own rule against its own parent's `element_form_default`.
+
+.Worked example: form on parent does not cascade to grandchild
+[example]
+====
+[source,ruby]
+----
+NS = Class.new(Lutaml::Model::XmlNamespace) do
+  uri "https://example.com/ns"
+  prefix_default "ex"
+  element_form_default :unqualified
+end
+
+class Grandchild < Lutaml::Model::Serializable
+  attribute :value, :string
+  xml do
+    element "grandchild"
+    namespace NS
+    map_element "value", to: :value
+  end
+end
+
+class Child < Lutaml::Model::Serializable
+  attribute :inner, Grandchild
+  xml do
+    element "child"
+    namespace NS
+    map_element "grandchild", to: :inner  # NO form: override
+  end
+end
+
+class Parent < Lutaml::Model::Serializable
+  attribute :child, Child
+  xml do
+    element "item"
+    namespace NS
+    map_element "child", to: :child, form: :qualified  # Parent's rule only
+  end
+end
+
+Parent.new(child: Child.new(inner: Grandchild.new(value: "x"))).to_xml
+----
+
+*Output*:
+[source,xml]
+----
+<item xmlns="https://example.com/ns" xmlns:ex="https://example.com/ns">
+  <ex:child>
+    <grandchild>
+      <value>x</value>
+    </grandchild>
+  </ex:child>
+</item>
+----
+
+* `<ex:child>` is qualified because the *Parent* rule has `form: :qualified`.
+* `<grandchild>` is unprefixed because the *Child* rule has no `form:` and the Child's namespace is `:unqualified`.
+* The Parent's `form: :qualified` does **not** cascade.
+====
+
+To qualify every level, either set `form: :qualified` on each mapping rule that needs it, or set `element_form_default :qualified` on the namespace so inheritance handles it.
+
+== Qualification Precedence
+
+When serializing an element, the namespace is resolved by checking the following sources in priority order. The first match wins.
+
+[cols="1,4", options="header"]
+|===
+|Priority |Source
+
+|1 (highest)
+|Type-level namespace: the attribute's value type (a `Type::Value` subclass) declares `xml_namespace`. Wins over everything else.
+
+|2
+|Rule-level namespace: the mapping rule has an explicit `namespace:` option. *However*, if the parent's `element_form_default` is `:unqualified` AND the rule's namespace matches the parent's, the namespace is overridden to blank — W3C unqualified semantics for local elements.
+
+|3
+|`form: :unqualified` on the rule: force the element into no namespace.
+
+|4
+|Parent's `element_form_default :qualified` inheritance: the child inherits the parent's namespace — but only if the child model itself declares a namespace (W3C: `elementFormDefault` applies to locally-declared elements only).
+
+|5
+|`form: :qualified` on the rule: inherit the parent's namespace.
+
+|6 (lowest)
+|No namespace.
+|===
+
+This ladder is implemented in `Lutaml::Xml::Transformation::ElementBuilder#determine_element_namespace`. The `ElementFormOptionRule` decision rule reads the propagated `form` value during the planning phase and forces prefix (`:qualified`) or default (`:unqualified`) format accordingly.
+
 == Type Namespaces
 
 Value types can define their own namespaces:

data/docs/_tutorials/xml-element-attribute-namespace-guide.adoc

@@ -9,6 +9,8 @@ This guide explains how XML namespaces work, particularly the distinction betwee
 - **Qualified**: Element/attribute needs a namespace declared in the XML
 - **Unqualified**: Element/attribute does not need a namespace declared (uses parent's namespace)
 
+> **Authoritative reference:** For the `element_form_default` / `form:` system, the full qualification precedence ladder, and `form:` behavior on nested `Serializable` children, see [docs/_guides/xml-namespace-qualification.adoc](../_guides/xml-namespace-qualification.adoc). This tutorial is a conceptual introduction.
+
 ## Default Namespace Inheritance
 
 **Critical Rule:** Default namespace inheritance ONLY applies to elements, NOT attributes.

data/docs/_tutorials/xml-schema-primer-style-guide.adoc

@@ -441,6 +441,8 @@ end
 
 NOTE: The `<comment>` element uses `xmlns=""` to explicitly declare blank namespace (form: :unqualified override).
 
+TIP: The `form:` option also works on attributes whose value type is a nested `Serializable` model, not just simple types like `:string`. It is a per-rule override and does not propagate transitively to grandchildren. For the full qualification precedence ladder and worked nested-model examples, see link:../_guides/xml-namespace-qualification/#form-override-on-serializable-children[XML Namespace Qualification and Prefix Control].
+
 == Section 3: Type Namespaces
 
 === General

data/docs/namespace-management.adoc

@@ -6,6 +6,8 @@
 
 This guide provides comprehensive information about XML namespace management in Lutaml::Model, including the `namespace_scope` directive, W3C compliance, and best practices for multi-namespace documents.
 
+NOTE: This guide focuses on namespace *declaration* and *scope*. For the `element_form_default` / `form:` qualification system — including the precedence ladder and `form:` behavior on nested `Serializable` children — see the companion guide: link:./_guides/xml-namespace-qualification[XML Namespace Qualification and Prefix Control].
+
 == Understanding XML Namespaces
 
 XML namespaces provide a method to avoid element name conflicts by qualifying names used in XML documents through a URI reference.

data/docs/xml-schema-qualification.md

@@ -13,6 +13,12 @@ declared in the XML, "unqualified" means the ELEMENT/ATTRIBUTE does not need a
 namespace declared in the XML (i.e. we look to its parent's namespace to find
 its namespace).
 
+> **Authoritative reference:** For the full qualification precedence ladder,
+> `form:` behavior on nested `Serializable` children, per-rule vs transitive
+> scope, and worked examples, see
+> [docs/_guides/xml-namespace-qualification.adoc](./_guides/xml-namespace-qualification.adoc).
+> This document is a conceptual overview; the guide is the canonical reference.
+
 When there is no XML Schema present:
 * element "acts like" unqualified (because of default namespace inheritance, does not need prefix)
 * attribute "acts like" qualified (because of no default namespace inheritance, requires prefix)

data/lib/lutaml/jsonld.rb

@@ -5,9 +5,6 @@ require_relative "rdf"
 
 module Lutaml
   module JsonLd
-    autoload :Context, "#{__dir__}/jsonld/context"
-    autoload :TermDefinition, "#{__dir__}/jsonld/term_definition"
-    autoload :Transform, "#{__dir__}/jsonld/transform"
     autoload :Adapter, "#{__dir__}/jsonld/adapter"
   end
 end
@@ -16,7 +13,7 @@ Lutaml::Model::FormatRegistry.register(
   :jsonld,
   mapping_class: Lutaml::Rdf::Mapping,
   adapter_class: Lutaml::JsonLd::Adapter,
-  transformer: Lutaml::JsonLd::Transform,
+  transformer: Lutaml::Rdf::LinkedDataTransform,
   key_value: false,
   rdf: true,
   error_types: ["JSON::ParserError"],

data/lib/lutaml/model/choice.rb

@@ -36,6 +36,36 @@ module Lutaml
         @attributes << @model.attribute(name, type, options)
       end
 
+      # Restrict options on a predefined or imported attribute within this choice
+      #
+      # @param name [Symbol] The attribute name to restrict
+      # @param options [Hash] New options to merge
+      # @return [Symbol] The attribute name
+      def restrict(name, options = {})
+        @model.restrict(name, options)
+        attr = @model.attributes[name]
+        unless @attributes.include?(attr)
+          attr.options[:choice] = self
+          @attributes << attr
+        end
+        invalidate_cache!
+        name
+      end
+
+      # Remove an attribute from this choice block
+      #
+      # @param name [Symbol] The attribute name to remove
+      # @return [Boolean] true if the attribute was removed
+      def remove_attribute(name)
+        attr = @attributes.find { |a| !a.is_a?(Choice) && a.name == name }
+        return nil unless attr
+
+        @attributes.delete(attr)
+        attr.options.delete(:choice)
+        invalidate_cache!
+        attr
+      end
+
       def choice(min: 1, max: 1, &block)
         @attributes << Choice.new(@model, min, max, format: @format).tap do |c|
           c.instance_eval(&block)
@@ -163,6 +193,10 @@ register = nil)
 
       private
 
+      def invalidate_cache!
+        @flat_attributes = nil
+      end
+
       def raise_errors(choices_hash)
         flat_attr_names = flat_attributes.map { |attr| attr.name.to_s }
         choices_hash.each do |choice_attr, count|

data/lib/lutaml/model/compiled_rule.rb

@@ -98,6 +98,13 @@ module Lutaml
         !custom_methods.empty?
       end
 
+      # Check if form is explicitly set
+      #
+      # @return [Boolean] true if form option was provided
+      def form_set?
+        !form.nil?
+      end
+
       # Check if a name matches this rule (including alias names for multiple mappings)
       #
       # @param name [String, Symbol] The name to check

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.16"
+    VERSION = "0.8.17"
   end
 end

data/lib/lutaml/model.rb

@@ -11,6 +11,7 @@ module Lutaml
   autoload :Yamls, "#{__dir__}/yamls"
   autoload :Xml, "#{__dir__}/xml"
   autoload :JsonLd, "#{__dir__}/jsonld"
+  autoload :YamlLd, "#{__dir__}/yamlld"
   autoload :Turtle, "#{__dir__}/turtle"
 
   module Model

data/lib/lutaml/{jsonld → rdf}/context.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Lutaml
-  module JsonLd
+  module Rdf
     class Context
       attr_reader :prefixes, :terms
 

data/lib/lutaml/{jsonld/transform.rb → rdf/linked_data_transform.rb}

@@ -1,34 +1,31 @@
 # frozen_string_literal: true
 
-require "json"
-
 module Lutaml
-  module JsonLd
-    class Transform < Lutaml::Rdf::Transform
-      def model_to_data(instance, _format, options = {})
-        mapping = extract_mapping(options)
+  module Rdf
+    class LinkedDataTransform < Lutaml::Rdf::Transform
+      def model_to_data(instance, format, options = {})
+        mapping = extract_mapping(format, options)
         return {} unless mapping
 
         if mapping.rdf_members.any?
-          build_graph_document(mapping, instance)
+          build_graph_document(mapping, instance, format)
         else
-          build_resource_object(mapping, instance)
+          build_resource_object(mapping, instance, format)
         end
       end
 
-      def data_to_model(data, _format, options = {})
-        mapping = extract_mapping(options)
+      def data_to_model(data, format, options = {})
+        mapping = extract_mapping(format, options)
         return model_class.new unless mapping
 
-        hash = data.is_a?(String) ? JSON.parse(data) : data
+        hash = data.is_a?(Hash) ? data : {}
 
         if hash.key?("@graph") && hash["@graph"].is_a?(Array) && !hash["@graph"].empty?
-          graph_data = hash["@graph"]
-          first = graph_data.first
+          first = hash["@graph"].first
           hash = first.is_a?(Hash) ? first : {}
         end
 
-        hash = strip_jsonld_keywords(hash)
+        hash = strip_linked_data_keywords(hash)
 
         attrs = {}
         mapping.rdf_predicates.each do |rule|
@@ -53,29 +50,29 @@ module Lutaml
 
       private
 
-      def extract_mapping(options)
-        options[:mappings] || mappings_for(:jsonld, lutaml_register)
+      def extract_mapping(format, options)
+        options[:mappings] || mappings_for(format, lutaml_register)
       end
 
-      def build_graph_document(mapping, instance)
-        context = build_merged_context_recursive(mapping, instance)
-        graph = collect_resources(mapping, instance)
+      def build_graph_document(mapping, instance, format)
+        context = build_merged_context_recursive(mapping, instance, format)
+        graph = collect_resources(mapping, instance, format)
 
         { "@context" => context, "@graph" => graph }
       end
 
-      def collect_resources(mapping, instance)
+      def collect_resources(mapping, instance, format)
         graph = []
 
-        resource = build_resource_data(mapping, instance)
+        resource = build_resource_data(mapping, instance, format)
         graph << resource unless resource.empty?
 
         mapping.rdf_members.each do |member_rule|
           each_member(instance, member_rule) do |member|
-            member_mapping = member_mapping_for(member, :jsonld)
+            member_mapping = member_mapping_for(member, format)
             next unless member_mapping
 
-            child_resources = collect_resources(member_mapping, member)
+            child_resources = collect_resources(member_mapping, member, format)
             graph.concat(child_resources)
           end
         end
@@ -83,17 +80,18 @@ module Lutaml
         graph
       end
 
-      def build_merged_context_recursive(mapping, instance)
+      def build_merged_context_recursive(mapping, instance, format)
         context_hash = build_context_from_mapping(mapping).to_hash
 
         mapping.rdf_members.each do |member_rule|
           each_member(instance, member_rule) do |member|
-            member_mapping = member_mapping_for(member, :jsonld)
+            member_mapping = member_mapping_for(member, format)
             next unless member_mapping
 
             context_hash.merge!(build_context_from_mapping(member_mapping).to_hash)
 
-            child_ctx = build_merged_context_recursive(member_mapping, member)
+            child_ctx = build_merged_context_recursive(member_mapping, member,
+                                                       format)
             context_hash.merge!(child_ctx)
           end
         end
@@ -134,13 +132,13 @@ module Lutaml
         end
       end
 
-      def build_resource_object(mapping, instance)
+      def build_resource_object(mapping, instance, format)
         context = build_context_from_mapping(mapping).to_hash
-        data = build_resource_data(mapping, instance)
+        data = build_resource_data(mapping, instance, format)
         { "@context" => context }.merge(data)
       end
 
-      def build_resource_data(mapping, instance)
+      def build_resource_data(mapping, instance, format)
         result = {}
 
         if mapping.rdf_type.any?
@@ -166,10 +164,10 @@ module Lutaml
         mapping.rdf_members.each do |member_rule|
           next unless member_rule.linked?
 
-          member_refs = collect_member_references(instance, member_rule)
+          member_refs = collect_member_references(instance, member_rule, format)
           next if member_refs.empty?
 
-          key = jsonld_member_key(member_rule)
+          key = member_key(member_rule)
           result[key] = member_refs
         end
 
@@ -178,10 +176,10 @@ module Lutaml
         result
       end
 
-      def collect_member_references(instance, member_rule)
+      def collect_member_references(instance, member_rule, format)
         refs = []
         each_member(instance, member_rule) do |member|
-          member_mapping = member_mapping_for(member, :jsonld)
+          member_mapping = member_mapping_for(member, format)
           next unless member_mapping
 
           refs << { "@id" => resolve_subject_uri(member_mapping, member) }
@@ -189,7 +187,7 @@ module Lutaml
         refs
       end
 
-      def jsonld_member_key(member_rule)
+      def member_key(member_rule)
         if member_rule.predicate_name
           member_rule.predicate_name.to_s
         elsif member_rule.link.is_a?(String)
@@ -241,7 +239,7 @@ module Lutaml
         end
       end
 
-      def strip_jsonld_keywords(data)
+      def strip_linked_data_keywords(data)
         return data unless data.is_a?(Hash)
 
         data.reject { |key, _| key.start_with?("@") }

data/lib/lutaml/{jsonld → rdf}/term_definition.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Lutaml
-  module JsonLd
+  module Rdf
     class TermDefinition
       attr_reader :name, :id, :type, :container, :language, :reverse
 

data/lib/lutaml/rdf.rb

@@ -15,5 +15,8 @@ module Lutaml
     autoload :MemberRule, "#{__dir__}/rdf/member_rule"
     autoload :Namespaces, "#{__dir__}/rdf/namespaces"
     autoload :Transform, "#{__dir__}/rdf/transform"
+    autoload :Context, "#{__dir__}/rdf/context"
+    autoload :TermDefinition, "#{__dir__}/rdf/term_definition"
+    autoload :LinkedDataTransform, "#{__dir__}/rdf/linked_data_transform"
   end
 end