lutaml-model 0.8.38 → 0.8.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad19014fa289dad72ab50f6908d425ed7708b4f7046432ac05426b65087fc713
-  data.tar.gz: 4f2d95722e22e73b3691e6eec7903d3967ec1d9cf9ea2b641b02b77cc59911ef
+  metadata.gz: 597b465123fe390703bdb760a4f6e18e4069b55bea8998633e2a4c0c7f5fcb9c
+  data.tar.gz: e848597e1ad2cef05670d8dc8de6f7480bf028fde627021c5a61f554ad99a2f0
 SHA512:
-  metadata.gz: 575ac30c297c4d8059bccb27b42b1d1e942ffef3352072f1ebdbff55039073cffb228a2e6873c55afd940bc78aaac1830c5375df0b37ac1b4eb498cea3a73fe2
-  data.tar.gz: 4d1c80a2a3fd04e5c461aec33ba2248547ae5f6c877990f457d23160c272a4f67e17ef4ab05ad450265f5c2aa8c5c637deead3c27b20a2ea1978ab4815d6d397
+  metadata.gz: 231f9601a9ce76ae516a6435b2c7185e15c2cc6680d0aefbad27ef328b25f67f0ed2635be8319eff6c3a64338f3bd2f9855ab1daa51058018345eb77cf3aa0d9
+  data.tar.gz: 88af6f65b2fadf91990f6f6f10a03a799007acda351d87a059f00325c85514291fbaccfd99580dd1daac3090bd61f4aa1ec26efffd058438c7e6abdd9a53cea4

data/docs/_guides/custom-methods.adoc

@@ -0,0 +1,71 @@
+= Custom serialization methods
+
+:toc:
+
+Lutaml::Model maps serialization constructs (`map_element`, `map_attribute`, `map_content`, key-value `map`) to *model attributes*. When the wire shape and the model shape disagree, custom methods bridge the gap at the mapping site instead of hand-rolled `to_h`/`from_h` code.
+
+== `with:` — per-rule custom methods
+
+Declare both directions on the rule. The methods live on the model (instance methods); the names are symbols.
+
+[source,ruby]
+----
+class Requirement
+  include Lutaml::Model::Serialize
+
+  attribute :guidance, :string
+  attribute :purpose, :string
+
+  xml do
+    element "requirement"
+    map_element "component", to: :guidance,
+      with: { from: :component_from_guidance, to: :component_to_guidance }
+  end
+
+  def component_from_guidance(model, value, ctx = nil)
+    # `from` receives (model, value[, context]); assign the model attribute
+    model.guidance = value
+  end
+
+  def component_to_guidance(model, parent, doc = nil, ctx = nil)
+    # `to` receives (model, parent[, doc[, context]]); write into parent/doc
+    parent.add_element("component", model.guidance, type: "guidance")
+  end
+end
+----
+
+Notes:
+
+* The `from` method *assigns* the attribute (it receives the whole model); the `to` method *writes* the output document.
+* The optional trailing `context` parameter receives the options hash passed to `Model.from_xml(data, context: {...})` / `model.to_xml(context: {...})` — it is forwarded when the method declares it (lutaml-model#550).
+* Callables work in key-value mappings: `with: { from: ->(value) { ... } }` maps and assigns the return value; an exact-arity-2 callable receives the context as its second argument.
+
+== `transform:` — value-level transforms
+
+`transform:` converts values (not documents). A Hash form (`transform: { from: ->(v) {...}, to: ->(v) {...} }`) wraps the value in both directions without touching assignment; a `ValueTransformer` subclass receives `from(value, format)` / `to(value, format)` and is shared by every rule that references it.
+
+== Type-level serialization
+
+A *type class* (a `Lutaml::Model::Type::Value` subclass) can carry its own format behavior, so reuse lives on the type rather than the parent mapping:
+
+[source,ruby]
+----
+class XmiNsType < Lutaml::Model::Type::String
+  xml do
+    namespace XmiNs # bind the type's own namespace
+  end
+end
+----
+
+`Lutaml::Model::Type::Value.register_format_type_serializer(format, type_class, to:, from:)` registers per-format serialize/deserialize procs for a type class; resolution walks the hierarchy.
+
+== `of_*` and the conversion entry points
+
+`Model.of_<format>(parsed_document, options)` is the documented seam between adapter parsing and mapping application: the adapter (`from_<format>`) parses the wire data into a document object, and `of_<format>` (class method) applies the mappings to build instances. It is public API for tooling that already holds a parsed document — e.g. re-applying mappings to a reparsed tree — and is what `from_<format>` delegates to.
+
+The per-instance counterparts are `to_<format>` (serialize through the mappings) and `as_<format>` (render without register-specific side effects). Prefer the generated `from_*/to_*` methods; reach for `of_*` only when you interpose between parse and mapping.
+
+== Common recipes
+
+* One wire element, several attributes dispatched by an attribute value (`component/@type`): one `with:` pair per attribute whose `from` inspects the dispatch attribute and whose `to` emits only for its type. (Polymorphic *class* dispatch has first-class support via `polymorphic:`.)
+* Key remapping, nesting shifts, delimiter splitting: prefer `transform:`, `child_mappings`, and `root`/`prefix` options before custom methods — the mapping stays declarative and reviewable.

data/docs/_guides/index.adoc

@@ -19,6 +19,7 @@ Task-oriented guides for accomplishing specific goals with Lutaml::Model.
 
 == Key-value serialization
 
+* link:../custom-methods[Custom Serialization Methods] - with:/transform:, type-level serialization, of_* entry points
 * link:../keyvalue-serialization[Key-Value Serialization] - JSON/YAML/TOML/Hash
 * link:../collection-serialization[Collection Serialization] - JSONL and YAML Stream
 

data/lib/lutaml/key_value/transform.rb

@@ -286,7 +286,6 @@ format)
           # only nil (non-existent) skips it (lutaml-model#746).
           return if value.nil?
 
-          warn "PROBE-264 keys=#{options.keys.inspect} ctx=#{options[:context].inspect}"
           return rule.deserialize(instance, value, attributes, model_class,
                                   options[:context])
         end

data/lib/lutaml/model/compiled_rule.rb

@@ -208,6 +208,15 @@ module Lutaml
       # @param args [Array] Arguments (ignored for options)
       # @param block [Proc] Block (ignored for options)
       # @return [Object] The option value or nil
+      # Static per rule (see MappingRule#custom_method_only?). Compiled
+      # rules are frozen, so the answer is recomputed with a single
+      # to_s instead of the historical two.
+      def custom_method_only?
+        name = attribute_name.to_s
+        (name.start_with?("__") && name.end_with?("__")) ||
+          (!custom_methods.empty? && attribute_type.nil?)
+      end
+
       def method_missing(method_name, *args, &block)
         # Check if this is an option key
         if options.key?(method_name)

data/lib/lutaml/model/mapping/mapping_rule.rb

@@ -307,6 +307,18 @@ context = nil)
         end
       end
 
+      # Static per rule: placeholder `__name__` targets and inferred
+      # custom-method targets without an attribute type never change —
+      # the applier asked this per element and paid two to_s strings
+      # each time (240k allocations on the ISO-13849 serialize profile).
+      # Rules may be frozen, so no per-instance memo: one to_s instead
+      # of two is the frozen-safe diet.
+      def custom_method_only?
+        name = attribute_name.to_s
+        (name.start_with?("__") && name.end_with?("__")) ||
+          (has_custom_methods? && attribute_type.nil?)
+      end
+
       def has_custom_method_for_serialization?
         !custom_methods.empty? && custom_methods[:to]
       end

data/lib/lutaml/model/serialize/attribute_definition.rb

@@ -129,6 +129,7 @@ module Lutaml
               end
             end
           elsif attr.unresolved_type == Lutaml::Model::Type::Reference
+            Lutaml::Model::Store.reference_types_in_use!
             define_reference_methods(name, register_id)
           else
             define_regular_attribute_methods(name, attr)
@@ -264,9 +265,12 @@ module Lutaml
           # class_eval'd bodies cannot close over locals; a hidden
           # define_method accessor holds the Attribute handle.
           attr_reader_method = :"__attribute_definition_#{name}"
-          unless method_defined?(attr_reader_method, false)
-            define_method(attr_reader_method) { attr }
-          end
+          reader_defined = if Lutaml::Model.opal?
+                             method_defined?(attr_reader_method)
+                           else
+                             method_defined?(attr_reader_method, false)
+                           end
+          define_method(attr_reader_method) { attr } unless reader_defined
 
           if attr.collection?
             # class_eval interpolates, e.g.:

data/lib/lutaml/model/serialize.rb

@@ -33,6 +33,11 @@ module Lutaml
       # The getter materializes a real Array on first access.
       LAZY_EMPTY_COLLECTION = [].freeze
 
+      # Ivar symbols for lazy collections, memoized per attribute name:
+      # the "@name" interpolation allocated twice per collection read
+      # (491k on the ISO-13849 serialize profile).
+      LAZY_IVAR = {}.compare_by_identity
+
       # Sentinel distinguishing "getter called with no argument" from
       # builder-syntax `g.attr(value)` where value may be nil. Compiled
       # getters default to it instead of a `*args` splat.
@@ -406,11 +411,16 @@ module Lutaml
       # @param attribute_name [Symbol] the collection attribute
       # @return [Object] the stored collection
       def materialize_lazy_collection(attribute_name)
-        current = instance_variable_get(:"@#{attribute_name}")
+        ivar = LAZY_IVAR[attribute_name]
+        unless ivar
+          ivar = :"@#{attribute_name}"
+          LAZY_IVAR[attribute_name] = ivar
+        end
+        current = instance_variable_get(ivar)
         return current unless current.equal?(LAZY_EMPTY_COLLECTION)
         return current if frozen?
 
-        instance_variable_set(:"@#{attribute_name}", [])
+        instance_variable_set(ivar, [])
       end
 
       # Hand back a reference collection the caller can push onto.

data/lib/lutaml/model/store.rb

@@ -33,11 +33,30 @@ module Lutaml
           @instance ||= new
         end
 
+        # lutaml-model#808: Ruby 3.3's GC has a WeakMap-mark hazard under
+        # heavy insert churn (freed slot dereferenced at wmap mark time).
+        # Registration is only ever consumed by `ref:` resolution — when
+        # no Reference-typed attribute exists anywhere, nothing can
+        # resolve, so registration is skipped entirely and the WeakMap
+        # stays quiet. Set the first time an attribute with a Reference
+        # type is defined.
+        # Not memoized `||=` — the setter flips it to true for the
+        # process lifetime and reads must see that.
+        def reference_types_in_use?
+          @reference_types_in_use ? true : false
+        end
+
+        def reference_types_in_use!
+          @reference_types_in_use = true
+        end
+
         def reset!
           @instance = new
         end
 
         def register(object)
+          return unless reference_types_in_use?
+
           instance.register(object)
         end
 

data/lib/lutaml/model/type/string.rb

@@ -19,7 +19,10 @@ module Lutaml
           end
 
           value = value.to_s
-          value = value.gsub(/[\t\n\r]/, " ") unless mode == :preserve
+          # tr, not gsub: the regexp engine is measurable on hot text
+          # paths; :collapse keeps squeeze+strip (two C passes, no
+          # intermediate regexp state).
+          value = value.tr("\t\n\r", " ") unless mode == :preserve
           value = value.squeeze(" ").strip if mode == :collapse
 
           unless options.equal?(EMPTY_OPTIONS)

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.38"
+    VERSION = "0.8.40"
   end
 end

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

@@ -299,13 +299,23 @@ module Lutaml
           # Create element
           xml.create_and_add_element(tag_name, attributes: attributes,
                                                prefix: prefix) do |inner_xml|
-            # Handle raw content (map_all directive)
+            # Handle raw content (map_all directive). lutaml-model#223:
+            # with coexisting mappings the raw remainder is the TAIL —
+            # mapped children render first through the normal paths
+            # below, then the fragment is appended. Standalone map_all
+            # (raw is the whole content) keeps the historical
+            # raw-only rendering by fronting the fragment and skipping
+            # children only when there is nothing mapped.
             has_raw_content = false
             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)
-                has_raw_content = true
+                if element.children.empty?
+                  inner_xml.add_xml_fragment(inner_xml, raw_content.to_s)
+                  has_raw_content = true
+                else
+                  (tail_raw_fragments ||= []) << raw_content.to_s
+                end
               end
             end
 
@@ -343,6 +353,9 @@ module Lutaml
                 end
               end
             end
+            (tail_raw_fragments || []).each do |fragment|
+              inner_xml.add_xml_fragment(inner_xml, fragment)
+            end
           end
         end
 

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

@@ -268,11 +268,20 @@ module Lutaml
           attributes["xmlns"] = "" if needs_xmlns_blank
 
           xml.create_and_add_element(qualified_name, attributes: attributes) do
+            tail_raw = nil
             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)
-                return
+                # lutaml-model#223: with coexisting map_all, the raw
+                # remainder is the tail — mapped children render first.
+                # Standalone map_all (no mapped children) keeps the
+                # historical raw-only rendering.
+                if xml_element.children.empty?
+                  xml.add_xml_fragment(xml, raw_content.to_s)
+                  return
+                end
+
+                tail_raw = raw_content.to_s
               end
             end
 
@@ -306,6 +315,8 @@ module Lutaml
               end
             end
 
+            xml.add_xml_fragment(xml, tail_raw) if tail_raw
+
             if xml_element.text_content
               if xml_element.cdata
                 xml.cdata(xml_element.text_content.to_s)

data/lib/lutaml/xml/adapter_element.rb

@@ -109,6 +109,13 @@ module Lutaml
         children.map(&:to_xml).join
       end
 
+      # The element including its own tags — the building block for
+      # scoped raw capture (#223): an unclaimed child contributes its
+      # whole subtree verbatim.
+      def inner_xml_or_self
+        to_xml
+      end
+
       private
 
       def build_element_xml(builder)

data/lib/lutaml/xml/mapping.rb

@@ -979,9 +979,14 @@ module Lutaml
                                "is allowed with #{TYPES[:all_content]}"
         end
 
-        if !(elements.empty? && content_mapping.nil?) && type == TYPES[:all_content]
-          raise StandardError,
-                "#{TYPES[:all_content]} is not allowed with other mappings"
+        if type == TYPES[:all_content] &&
+            !(elements.empty? && content_mapping.nil?)
+          # lutaml-model#223: map_all may coexist with mapped siblings.
+          # The raw capture receives only the UNCLAIMED content — the
+          # verbatim subtree minus children matched by element rules.
+          # The historical exclusivity raised here; the coexistence
+          # contract is enforced by scoped capture on parse and
+          # remainder-after-mapped emission on serialize.
         end
       end
 

data/lib/lutaml/xml/model_transform.rb

@@ -18,9 +18,13 @@ module Lutaml
       # rules — attribute, derived/valid flags, and #765 group-skip —
       # keyed on the mapping's finalize version so late changes rebuild.
       # The loop body used to re-derive these per parsed instance.
-      # Concurrent::Map has no compare_by_identity; class identity is
-      # the key semantic here.
-      RULE_RECORDS = Concurrent::Map.new # rubocop:disable Lint/HashCompareByIdentity
+      # Concurrent::Map under threaded MRI, plain Hash under Opal
+      # (Concurrent is unavailable there); class identity keys either.
+      RULE_RECORDS = if Lutaml::Model.opal?
+                       {}
+                     else
+                       Concurrent::Map.new # rubocop:disable Lint/HashCompareByIdentity
+                     end
 
       # Namespaced rule name -> [local_name, rule_uri]. Pure string
       # splitting, deterministic per spelling, shared across parses.
@@ -51,14 +55,17 @@ module Lutaml
           # ISO-13849 profile). Memoize one instance per (element, class)
           # for the whole parse; the memo travels in the propagated
           # deserialization options.
-          memo = options[:__lutaml_child_memo] ||= {}
-          memo_key = [data.object_id, model_class.object_id]
-          if (existing = memo[memo_key])
+          # Nested identity maps keyed on the element object itself —
+          # flat object_id pairs could collide after GC id reuse on
+          # long parses (#808 audit).
+          memo = options[:__lutaml_child_memo] ||= {}.compare_by_identity
+          per_class = (memo[data] ||= {}.compare_by_identity)
+          if (existing = per_class[model_class])
             return existing
           end
 
           instance = model_class.allocate_for_deserialization(child_register)
-          memo[memo_key] = instance
+          per_class[model_class] = instance
         else
           instance = model_class.new
           register_accessor_methods_for(instance, child_register)
@@ -341,7 +348,7 @@ module Lutaml
             end
 
           value = if rule.raw_mapping?
-                    doc.root.inner_xml
+                    scoped_raw_inner_xml(doc, xml_mapping)
                   elsif rule.content_mapping?
                     rule.cdata ? doc.cdata : doc.text
                   elsif (group = grouped_plain_rules[rule_to]) &&
@@ -709,6 +716,23 @@ _effective_register)
       # lutaml-model#154: decode HTML entities for mappings that opted in
       # (`html_entities` in the xml block). Values stay untouched
       # otherwise — XML keeps undefined entities literal by design.
+      # lutaml-model#223: with coexisting map_all, the raw capture is
+      # the verbatim subtree MINUS the children claimed by element
+      # rules (they hydrate their own attributes). Standalone map_all
+      # (no element rules) keeps the full inner_xml.
+      def scoped_raw_inner_xml(doc, xml_mapping)
+        claimed = []
+        xml_mapping&.elements&.each do |element_rule|
+          Array(element_rule.name).each { |n| claimed << n.to_s }
+        end
+        return doc.root.inner_xml if claimed.empty?
+
+        doc.root.element_children.reject do |child|
+          claimed.include?(child.unprefixed_name) ||
+            claimed.include?(child.name)
+        end.map(&:inner_xml_or_self).join
+      end
+
       def decode_html_entities_value(value, enabled)
         return value if value.nil? || !value.is_a?(String)
         return value unless enabled
@@ -724,8 +748,11 @@ _effective_register)
 
         mapping = model_class.mappings_for(:xml, register)
         version = mapping&.rule_records_version.to_i
-        per_class = RULE_RECORDS[model_class.object_id] || # rubocop:disable Lint/HashCompareByIdentity
-          (RULE_RECORDS[model_class.object_id] = Concurrent::Map.new) # rubocop:disable Lint/HashCompareByIdentity,Layout/MultilineAssignmentLayout
+        per_class = RULE_RECORDS[model_class.object_id] # rubocop:disable Lint/HashCompareByIdentity
+        unless per_class
+          per_class = Lutaml::Model.opal? ? {} : Concurrent::Map.new
+          RULE_RECORDS[model_class.object_id] = per_class # rubocop:disable Lint/HashCompareByIdentity
+        end
         cached = per_class[register]
         return cached.records if cached && cached.version == version
 

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

@@ -227,13 +227,7 @@ register_id)
         # @param rule [CompiledRule] The rule
         # @return [Boolean] true if custom method only
         def custom_method_only?(rule)
-          # Check if attribute name is a placeholder (e.g., :__content__)
-          return true if rule.attribute_name.to_s.start_with?("__") &&
-            rule.attribute_name.to_s.end_with?("__")
-
-          # Also check if rule has custom methods but attribute_type is nil
-          # This handles cases where we inferred an attribute name for custom methods
-          rule.has_custom_methods? && rule.attribute_type.nil?
+          rule.custom_method_only?
         end
 
         # Extract value for a rule

data/spec/lutaml/model/map_all_spec.rb

@@ -185,28 +185,32 @@ module MapAllSpec
       end
     end
 
-    describe "invalid mapping combinations" do
-      it "raises error when combining map_all with other mappings" do
-        expect do
-          InvalidDocument.json do
+    describe "coexistence with other mappings (#223)" do
+      it "captures only unclaimed content alongside mapped elements" do
+        doc_class = Class.new(Lutaml::Model::Serializable) do
+          attribute :title, :string
+          attribute :rest, :string
+
+          xml do
+            element "eref"
             map_element "title", to: :title
+            map_all to: :rest
           end
-        end.to raise_error(
-          StandardError,
-          "map_all is not allowed with other mappings",
-        )
-      end
+        end
 
-      it "raises error when combining other mappings are used with map_all" do
-        expect do
-          InvalidDocument.yaml do
-            map_element "title", to: :title
-            map_all to: :content
-          end
-        end.to raise_error(
-          StandardError,
-          "map_all is not allowed with other mappings",
-        )
+        source = %(<eref><title>T</title><p>para</p><note>N</note></eref>)
+        parsed = doc_class.from_xml(source)
+        expect(parsed.title).to eq("T")
+        expect(parsed.rest).to eq("<p>para</p><note>N</note>")
+
+        out = doc_class.to_xml(parsed)
+        expect(out).to include("<title>T</title>")
+        expect(out).to include("<p>para</p>")
+        expect(out).to include("<note>N</note>")
+
+        reparsed = doc_class.from_xml(out)
+        expect(reparsed.title).to eq("T")
+        expect(reparsed.rest).to eq("<p>para</p><note>N</note>")
       end
     end
   end

data/spec/lutaml/model/store_spec.rb

@@ -3,6 +3,13 @@
 require "spec_helper"
 
 RSpec.describe Lutaml::Model::Store do
+  before do
+    # Registration only runs when a Reference-typed attribute exists
+    # somewhere (#808); the internal specs opt in explicitly.
+    described_class.reference_types_in_use!
+    described_class.clear 
+  end
+
   let(:model_class) do
     Class.new(Lutaml::Model::Serializable) do
       attribute :id, :string
@@ -10,7 +17,6 @@ RSpec.describe Lutaml::Model::Store do
     end
   end
 
-  before { described_class.clear }
   after { described_class.clear }
 
   describe "#register and #resolve" do

data/spec/lutaml/xml/mapping_spec.rb

@@ -974,7 +974,6 @@ RSpec.describe Lutaml::Xml::Mapping do
       end
 
       context "when mixed content is true and child is content_mapping" do
-        let(:map_all_error) { "map_all is not allowed with other mappings" }
         let(:invalid_element) { "must be defined without namespace" }
         let(:mfenced) do
           <<~XML
@@ -994,7 +993,7 @@ RSpec.describe Lutaml::Xml::Mapping do
           XML
         end
 
-        it "raises error when map_all used in content_mapping without custom methods" do
+        it "allows map_all alongside element mappings (#223)" do
           original_mapping = XmlMappingSpec::MmlMath.mappings[:xml].deep_dup
 
           begin
@@ -1005,7 +1004,7 @@ RSpec.describe Lutaml::Xml::Mapping do
               XmlMappingSpec::MmlMath.xml do
                 map_all to: :all_content
               end
-            end.to raise_error(StandardError, map_all_error)
+            end.not_to raise_error
           ensure
             XmlMappingSpec::MmlMath.instance_variable_set(:@mappings,
                                                           { xml: original_mapping })
@@ -1013,16 +1012,16 @@ RSpec.describe Lutaml::Xml::Mapping do
           end
         end
 
-        it "can be defined after any other mapping" do
+        it "still validates its own arguments when combined (#223)" do
           original_mapping = XmlMappingSpec::MmlMath.mappings[:xml].deep_dup
 
           begin
             expect do
               XmlMappingSpec::MmlMath.xml do
-                map_all to: :all_content
-                namespace XmiNewNamespace
+                map_all to: :all_content, namespace: "http://explicit.ns"
               end
-            end.to raise_error(StandardError, map_all_error)
+            end.to raise_error(Lutaml::Model::IncorrectMappingArgumentsError,
+                               /namespace is not allowed/)
           ensure
             XmlMappingSpec::MmlMath.instance_variable_set(:@mappings,
                                                           { xml: original_mapping })

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.38
+  version: 0.8.40
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-18 00:00:00.000000000 Z
+date: 2026-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -202,6 +202,7 @@ files:
 - docs/_guides/character-encoding.adoc
 - docs/_guides/collection-serialization.adoc
 - docs/_guides/creating-xsd.adoc
+- docs/_guides/custom-methods.adoc
 - docs/_guides/document-validation.adoc
 - docs/_guides/index.adoc
 - docs/_guides/jsonld-serialization.adoc