lutaml-model 0.8.9 → 0.8.11

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

@@ -41,7 +41,7 @@ module Lutaml
             resolved_element_order&.each do |child|
               if child.is_a?(Element)
                 array << child
-              elsif child.respond_to?(:child_elements)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.child_elements(array)
               end
             end
@@ -54,7 +54,7 @@ module Lutaml
             resolved_element_order&.any? do |child|
               if child.is_a?(Element)
                 reference_matches?(element_name, child.ref || child.name)
-              elsif child.respond_to?(:find_elements_used)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.find_elements_used(element_name)
               end
             end || false

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

@@ -105,7 +105,7 @@ except: DIRECT_CHILD_ELEMENTS_EXCEPTION)
             resolved_element_order&.each do |child|
               if child.is_a?(Element)
                 array << child
-              elsif child.respond_to?(:child_elements)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.child_elements(array)
               end
             end
@@ -118,7 +118,7 @@ except: DIRECT_CHILD_ELEMENTS_EXCEPTION)
             resolved_element_order&.any? do |child|
               if child.is_a?(Element)
                 reference_matches?(element_name, child.ref || child.name)
-              elsif child.respond_to?(:find_elements_used)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.find_elements_used(element_name)
               end
             end || false
@@ -139,9 +139,9 @@ except: DIRECT_CHILD_ELEMENTS_EXCEPTION)
           # Get elements from the primary content model (sequence, choice, or all).
           # @return [Array<Element>] Elements exposed by the active content model
           def elements
-            return sequence.element if sequence.respond_to?(:element)
-            return choice.element if choice.respond_to?(:element)
-            return all.element if all.respond_to?(:element)
+            return sequence.element if sequence
+            return choice.element if choice
+            return all.element if all
 
             []
           end

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

@@ -28,8 +28,8 @@ module Lutaml
               parts = []
               parts << header
               parts << context_details if @error.context && !@error.context.to_h.empty?
-              parts << suggestions_section if @error.respond_to?(:suggestions) && @error.suggestions.any?
-              parts << troubleshooting_section if @error.respond_to?(:troubleshooting_tips) && @error.troubleshooting_tips.any?
+              parts << suggestions_section if @error.is_a?(EnhancedError) && @error.suggestions.any?
+              parts << troubleshooting_section if @error.is_a?(EnhancedError) && @error.troubleshooting_tips.any?
               parts.compact.join("\n\n")
             end
 
@@ -39,7 +39,7 @@ module Lutaml
             #
             # @return [String] Error header
             def header
-              severity = @error.respond_to?(:severity) ? @error.severity.to_s.upcase : "ERROR"
+              severity = @error.is_a?(EnhancedError) ? @error.severity.to_s.upcase : "ERROR"
               "#{severity}: #{@error.message}"
             end
 

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

@@ -44,7 +44,7 @@ module Lutaml
             group.resolved_element_order&.each do |child|
               if child.is_a?(Element)
                 array << child
-              elsif child.respond_to?(:child_elements)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.child_elements(array)
               end
             end
@@ -57,7 +57,7 @@ module Lutaml
             resolved_element_order&.any? do |child|
               if child.is_a?(Element)
                 reference_matches?(element_name, child.ref || child.name)
-              elsif child.respond_to?(:find_elements_used)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.find_elements_used(element_name)
               end
             end || false

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

@@ -41,7 +41,7 @@ module Lutaml
             resolved_element_order&.each do |child|
               if child.is_a?(Element)
                 array << child
-              elsif child.respond_to?(:child_elements)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.child_elements(array)
               end
             end
@@ -54,7 +54,7 @@ module Lutaml
             resolved_element_order&.any? do |child|
               if child.is_a?(Element)
                 reference_matches?(element_name, child.ref || child.name)
-              elsif child.respond_to?(:find_elements_used)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.find_elements_used(element_name)
               end
             end || false

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

@@ -82,7 +82,7 @@ module Lutaml
             attr_type = attr.type(register)
 
             # Validate Type::Value xsd_type
-            if attr_type.respond_to?(:xsd_type)
+            if attr_type.is_a?(Class) && attr_type < Lutaml::Model::Type::Value
               type_name = attr_type.xsd_type
               classification = classify_xsd_type(type_name, klass, register)
 
@@ -413,7 +413,7 @@ _mapping_rule = nil)
           return attr.options[:xsd_type] if attr.options[:xsd_type]
 
           # 2. Check if type has xsd_type method (Type-level)
-          if attr_type.respond_to?(:xsd_type)
+          if attr_type.is_a?(Class) && attr_type < Lutaml::Model::Type::Value
             # Special handling for Reference type
             if attr_type == Lutaml::Model::Type::Reference
               target_xsd_type = get_target_xsd_type(attr, register)
@@ -466,7 +466,7 @@ _mapping_rule = nil)
 
           # Get namespace info from Model class (Serializable)
           def get_model_namespace_info(klass)
-            mapping = klass.respond_to?(:mappings_for) ? klass.mappings_for(:xml) : nil
+            mapping = klass.is_a?(Class) && klass.include?(Lutaml::Model::Serialize) ? klass.mappings_for(:xml) : nil
             return {} unless mapping
 
             {
@@ -487,8 +487,8 @@ _mapping_rule = nil)
 
             # XmlNamespace class
             {
-              uri: ns.respond_to?(:uri) ? ns.uri : nil,
-              prefix: ns.respond_to?(:prefix_default) ? ns.prefix_default : nil,
+              uri: ns.is_a?(Class) && ns < Lutaml::Xml::Namespace ? ns.uri : nil,
+              prefix: ns.is_a?(Class) && ns < Lutaml::Xml::Namespace ? ns.prefix_default : nil,
               class: ns,
             }
           end

data/lib/lutaml/xml/serialization/format_conversion.rb

@@ -97,7 +97,7 @@ module Lutaml
           raise Lutaml::Model::NoRootMappingError.new(self) unless valid
 
           options[:encoding] = doc.encoding
-          if doc.respond_to?(:doctype) && doc.doctype
+          if doc.is_a?(Lutaml::Xml::Document) && doc.doctype
             options[:doctype] = doc.doctype
           end
         end
@@ -214,7 +214,7 @@ module Lutaml
         def process_xml_mapping_class_inheritance(mapping_class, &block)
           # Start with a copy of the parent class's XML mapping (if any).
           parent_class = superclass_with_xml_mapping(self)
-          parent_xml_mapping = if parent_class.respond_to?(:mappings)
+          parent_xml_mapping = if parent_class.is_a?(Class) && parent_class.include?(Lutaml::Model::Serialize)
                                  parent_class.mappings[:xml]
                                end
           @xml_mapping = if parent_xml_mapping
@@ -224,7 +224,8 @@ module Lutaml
                          end
 
           # Get the parent mapping instance (DSL already evaluated via xml_mapping_instance)
-          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/transformation/element_builder.rb

@@ -91,7 +91,7 @@ parent_element_form_default)
             if attr_type.is_a?(Class) && attr_type.include?(Lutaml::Model::Serialize)
               attr_mapping = attr_type.mappings_for(:xml)
               attr_ns = attr_mapping&.namespace_class
-              attr_ns_param = attr_mapping&.send(:namespace_param)
+              attr_ns_param = attr_mapping&.namespace_param
               # Use child's explicit namespace if it differs from parent's
               # If child has no namespace declaration (nil) or explicit blank (:blank),
               # do NOT inherit parent's namespace - return nil
@@ -165,7 +165,9 @@ is_polymorphic_subtype)
             if polymorphic_config.is_a?(Hash)
               poly_attr = polymorphic_config[:attribute]
               poly_class_map = polymorphic_config[:class_map]
-              poly_value = value.send(poly_attr) if poly_attr && value.respond_to?(poly_attr)
+              poly_value = if poly_attr && value.is_a?(Lutaml::Model::Serialize) && value.class.attributes.key?(poly_attr)
+                             value.public_send(poly_attr)
+                           end
               if poly_value && poly_class_map && (klass_name = poly_class_map[poly_value.to_s])
                 Object.const_get(klass_name)
               else

data/lib/lutaml/xml/transformation/rule_applier.rb

@@ -241,8 +241,8 @@ register_id)
         def apply_custom_method(parent, rule, model_class, model_instance)
           wrapper = ::Lutaml::Xml::CustomMethodWrapper.new(parent)
           mapper_instance = model_class.new
-          mapper_instance.send(rule.custom_methods[:to], model_instance,
-                               parent, wrapper)
+          mapper_instance.public_send(rule.custom_methods[:to], model_instance,
+                                      parent, wrapper)
         end
 
         # Apply element value handling collections

data/lib/lutaml/xml/transformation/value_serializer.rb

@@ -54,7 +54,7 @@ module Lutaml
           end
 
           # Use type's serialization if available
-          if rule.attribute_type.respond_to?(:serialize)
+          if rule.attribute_type.is_a?(Class) && rule.attribute_type < Lutaml::Model::Type::Value
             rule.attribute_type.serialize(value)
           else
             value.to_s
@@ -101,7 +101,7 @@ module Lutaml
         # @param attribute_type [Class, nil] The attribute type
         # @return [Boolean] true if custom Value type
         def custom_value_type?(attribute_type)
-          attribute_type.respond_to?(:new) &&
+          attribute_type.is_a?(Class) &&
             attribute_type < Lutaml::Model::Type::Value
         end
 
@@ -112,14 +112,12 @@ module Lutaml
         # @return [String, nil] Serialized value or nil
         def serialize_custom_value(value, attribute_type)
           # Skip wrapping if value is already the correct type
-          if value.is_a?(attribute_type) && value.respond_to?(:to_xml)
+          if value.is_a?(attribute_type)
             return value.to_xml
           end
 
           wrapped_value = attribute_type.new(value)
-          if wrapped_value.respond_to?(:to_xml)
-            wrapped_value.to_xml
-          end
+          wrapped_value.to_xml
         end
 
         # Find attribute definition from model class

data/lib/lutaml/xml/transformation.rb

@@ -139,9 +139,9 @@ module Lutaml
       # @param model_instance [Object] The model instance
       def handle_schema_location(root, model_instance)
         # Case 1: SchemaLocation object (programmatic creation)
-        if model_instance.respond_to?(:schema_location) && model_instance.schema_location
+        if model_instance.is_a?(Lutaml::Model::Serialize) && model_instance.schema_location
           schema_loc = model_instance.schema_location
-          if schema_loc.respond_to?(:to_xml_attributes)
+          if schema_loc.is_a?(Lutaml::Xml::SchemaLocation)
             schema_attrs = schema_loc.to_xml_attributes
             schema_attrs.each do |attr_name, attr_value|
               attr = ::Lutaml::Xml::DataModel::XmlAttribute.new(attr_name,
@@ -150,7 +150,7 @@ module Lutaml
             end
           end
         # Case 2: @raw_schema_location string (from parsing/round-trip)
-        elsif model_instance.respond_to?(:raw_schema_location) && model_instance.raw_schema_location
+        elsif model_instance.is_a?(Lutaml::Model::Serialize) && model_instance.raw_schema_location
           raw_schema_loc = model_instance.raw_schema_location
           if raw_schema_loc && !raw_schema_loc.empty?
             add_raw_schema_location(root, raw_schema_loc)
@@ -292,7 +292,7 @@ module Lutaml
       # @param model_instance [Object] The model instance
       # @param options [Hash] Options
       def apply_standard_rules(root, model_instance, options)
-        attr_order = model_instance.respond_to?(:attribute_order) &&
+        attr_order = model_instance.is_a?(Lutaml::Model::Serialize) &&
           model_instance.attribute_order
 
         rules = if attr_order

data/lib/lutaml/xml/type/configurable.rb

@@ -104,9 +104,7 @@ module Lutaml
           # @return [String, nil] parent's xsd_type if set
           def inherited_xsd_type
             return nil if superclass == Lutaml::Model::Type::Value
-            return nil unless superclass.respond_to?(:xsd_type)
 
-            # Get parent's @xsd_type directly (not default_xsd_type)
             parent_xsd = superclass.instance_variable_get(:@xsd_type)
             parent_xsd || superclass.inherited_xsd_type
           end
@@ -116,7 +114,6 @@ module Lutaml
           # @return [Class, Symbol, nil] parent's namespace class if set
           def inherited_namespace
             return nil if superclass == Lutaml::Model::Type::Value
-            return nil unless superclass.respond_to?(:xml_mapping)
 
             parent_mapping = superclass.xml_mapping
             parent_mapping&.namespace_class || superclass.inherited_namespace
@@ -136,7 +133,6 @@ module Lutaml
           # @return [Lutaml::Xml::Type::ValueXmlMapping] the new XML mapping
           def inherit_xml_mapping_from_parent
             return create_xml_mapping if superclass == Lutaml::Model::Type::Value
-            return create_xml_mapping unless superclass.respond_to?(:xml_mapping)
 
             parent_mapping = superclass.xml_mapping
             return create_xml_mapping unless parent_mapping

data/lib/lutaml/xml/xml_element.rb

@@ -157,7 +157,7 @@ module Lutaml
       def name
         return @name unless namespace_prefix
 
-        @prefixed_name ||= "#{namespace_prefix}:#{@name}" # rubocop:disable Naming/MemoizedInstanceVariableName
+        @prefixed_name ||= -"#{namespace_prefix}:#{@name}" # rubocop:disable Naming/MemoizedInstanceVariableName
       end
 
       def namespaced_name
@@ -174,15 +174,18 @@ module Lutaml
           # 3. Fall back to namespaces[nil] if exists
           # 4. Return unprefixed name
           ns = namespaces
-          if namespace_prefix && ns[namespace_prefix]
-            "#{ns[namespace_prefix].uri}:#{@name}"
-          elsif @default_namespace
-            "#{@default_namespace}:#{@name}"
-          elsif ns[nil]
-            "#{ns[nil].uri}:#{@name}"
-          else
-            @name
-          end
+          raw = if namespace_prefix && ns[namespace_prefix]
+                  "#{ns[namespace_prefix].uri}:#{@name}"
+                elsif @default_namespace
+                  "#{@default_namespace}:#{@name}"
+                elsif ns[nil]
+                  "#{ns[nil].uri}:#{@name}"
+                else
+                  @name
+                end
+          # Deduplicate the string to reduce GC pressure from repeated
+          # namespace URIs across thousands of elements.
+          -raw
         end
       end
 
@@ -236,7 +239,8 @@ module Lutaml
 
         @namespace_uri = begin
           ns = namespace
-          ns&.uri
+          uri = ns&.uri
+          uri ? -uri : nil
         end
       end
 
@@ -296,9 +300,13 @@ module Lutaml
 
       def text
         return @text if children.empty?
-        return text_children.map(&:text) if content_bearing_children_count > 1
+        return @computed_text if defined?(@computed_text)
 
-        text_children.map(&:text).join
+        @computed_text = if content_bearing_children_count > 1
+                           text_children.map(&:text)
+                         else
+                           text_children.map(&:text).join
+                         end
       end
 
       def cdata

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.16"
+  spec.add_dependency "moxml", ">= 0.1.20"
   spec.add_dependency "ostruct"
   spec.add_dependency "rubyzip", "~> 2.3"
   spec.add_dependency "thor"

data/spec/lutaml/jsonld/transform_spec.rb

@@ -208,4 +208,243 @@ RSpec.describe Lutaml::JsonLd::Transform do
       expect(restored.tags).to eq(["en", "fr"])
     end
   end
+
+  describe "multiple types" do
+    before do
+      stub_const("DctermsTestNs", Class.new(Lutaml::Rdf::Namespace) do
+        uri "http://purl.org/dc/terms/"
+        prefix "dcterms"
+      end)
+
+      stub_const("MultiTypeJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        rdf do
+          namespace TestSkosNs, DctermsTestNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject
+
+          type ["skos:Concept", "dcterms:Agent"]
+
+          predicate :name, namespace: TestExNs, to: :name
+        end
+      end)
+    end
+
+    it "generates @type as array for multiple types" do
+      instance = MultiTypeJsonLdModel.new(name: "multi")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["@type"]).to eq(["skos:Concept", "dcterms:Agent"])
+    end
+
+    it "generates @type as string for single type" do
+      instance = JsonLdTestModel.new(name: "single")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["@type"]).to eq("skos:Concept")
+    end
+  end
+
+  describe "URI reference predicates" do
+    before do
+      stub_const("UriRefJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :related, :string, collection: true
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject
+
+          type "skos:Concept"
+
+          predicate :name, namespace: TestExNs, to: :name
+          predicate :related, namespace: TestSkosNs, to: :related,
+                              uri_reference: true
+        end
+      end)
+    end
+
+    it "generates @type @id in context for uri_reference predicates" do
+      instance = UriRefJsonLdModel.new(name: "test", related: ["skos:other"])
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["@context"]["related"]).to eq({
+                                                    "@id" => "http://www.w3.org/2004/02/skos/core#related",
+                                                    "@type" => "@id",
+                                                  })
+    end
+
+    it "serializes URI reference as @id object" do
+      instance = UriRefJsonLdModel.new(name: "test", related: ["skos:other"])
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["related"]).to eq([{ "@id" => "skos:other" }])
+    end
+
+    it "serializes single URI reference value as @id object" do
+      stub_const("SingleUriRefModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :link, :string
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject
+
+          type "skos:Concept"
+
+          predicate :name, namespace: TestExNs, to: :name
+          predicate :related, namespace: TestSkosNs, to: :link,
+                              uri_reference: true
+        end
+      end)
+
+      instance = SingleUriRefModel.new(name: "test", link: "skos:something")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["related"]).to eq({ "@id" => "skos:something" })
+    end
+  end
+
+  describe "member linking predicates" do
+    before do
+      stub_const("JsonLdChildModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :cid, :string
+        attribute :label, :string
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/item/#{m.cid}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Concept"
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :label
+        end
+      end)
+
+      stub_const("JsonLdParentModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :children, JsonLdChildModel, collection: true
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/group/#{m.name}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Collection"
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :name
+
+          members :children,
+                  predicate_name: :member,
+                  namespace: TestSkosNs
+        end
+      end)
+    end
+
+    it "includes linking term in @context with @type @id" do
+      parent = JsonLdParentModel.new(
+        name: "grp1",
+        children: [JsonLdChildModel.new(cid: "a", label: "Alpha")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      expect(parsed["@context"]["member"]).to eq({
+                                                   "@id" => "http://www.w3.org/2004/02/skos/core#member",
+                                                   "@type" => "@id",
+                                                 })
+    end
+
+    it "generates @id references for linked members in @graph" do
+      parent = JsonLdParentModel.new(
+        name: "grp1",
+        children: [
+          JsonLdChildModel.new(cid: "a", label: "Alpha"),
+          JsonLdChildModel.new(cid: "b", label: "Beta"),
+        ],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      parent_resource = parsed["@graph"].find { |r| r["@type"] }
+      expect(parent_resource["member"]).to eq([
+                                                { "@id" => "http://example.org/item/a" },
+                                                { "@id" => "http://example.org/item/b" },
+                                              ])
+    end
+
+    it "includes member resources in @graph" do
+      parent = JsonLdParentModel.new(
+        name: "grp1",
+        children: [JsonLdChildModel.new(cid: "a", label: "Alpha")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      member = parsed["@graph"].find { |r| r["prefLabel"] == "Alpha" }
+      expect(member).not_to be_nil
+      expect(member["@id"]).to eq("http://example.org/item/a")
+    end
+
+    it "merges child namespaces into @context" do
+      parent = JsonLdParentModel.new(
+        name: "grp1",
+        children: [JsonLdChildModel.new(cid: "a", label: "Alpha")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      expect(parsed["@context"]["skos"]).to eq("http://www.w3.org/2004/02/skos/core#")
+      expect(parsed["@context"]["ex"]).to eq("http://example.org/")
+    end
+
+    it "omits linking key when members have no linking predicate" do
+      stub_const("UnlinkedChild", Class.new(Lutaml::Model::Serializable) do
+        attribute :label, :string
+
+        rdf do
+          namespace TestSkosNs
+
+          subject { |m| "http://example.org/#{m.label}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :label
+        end
+      end)
+
+      stub_const("UnlinkedParent", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :items, UnlinkedChild, collection: true
+
+        rdf do
+          namespace TestSkosNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :name
+
+          members :items
+        end
+      end)
+
+      parent = UnlinkedParent.new(
+        name: "grp",
+        items: [UnlinkedChild.new(label: "a")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      expect(parsed["@context"]).not_to have_key("member")
+    end
+  end
+
+  describe "empty type array" do
+    before do
+      stub_const("NoTypeJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        rdf do
+          namespace TestExNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject
+
+          predicate :name, namespace: TestExNs, to: :name
+        end
+      end)
+    end
+
+    it "omits @type when no types declared" do
+      instance = NoTypeJsonLdModel.new(name: "test")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed).not_to have_key("@type")
+    end
+  end
 end

data/spec/lutaml/model/cached_type_resolver_spec.rb

@@ -129,14 +129,14 @@ RSpec.describe Lutaml::Model::CachedTypeResolver do
       expect(result2).to eq(result1)
     end
 
-    it "passes through Class objects without caching" do
+    it "caches Class objects with substitution applied" do
       klass = Class.new
       result = resolver.resolve(klass, context)
       expect(result).to eq(klass)
 
-      # Should not be cached
+      # Should be cached
       stats = resolver.cache_stats
-      expect(stats[:size]).to eq(0)
+      expect(stats[:size]).to eq(1)
     end
 
     it "raises UnknownTypeError for unknown types" do