pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.11

data/lib/pubid/oiml.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Oiml
     extend Pubid::PrefixesSupport
@@ -19,8 +20,13 @@ module Pubid
     autoload :UrnParser, "#{__dir__}/oiml/urn_parser"
 
     def self.parse(identifier)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
       if identifier.length > Pubid::MAX_INPUT_LENGTH
-        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
       parser = Parser.new

data/lib/pubid/omg/builder.rb

@@ -12,6 +12,7 @@ module Pubid
         Identifiers::Specification.new(
           acronym: data[:acronym].to_s,
           version: data[:version]&.to_s,
+          part: data[:part]&.to_s,
         )
       end
     end

data/lib/pubid/omg/identifier.rb

@@ -13,6 +13,19 @@ module Pubid
       # rendering.
       attribute :version, :string
 
+      # The document part: the volume or format segment after the version,
+      # e.g. "Superstructure", "Infrastructure", "PDF".
+      #
+      # This retypes the `part` that ::Pubid::Identifier declares as a
+      # Components::Code, because an OMG part is a name and not a numbered
+      # part. Reusing the inherited name is what gives relaton `remove_part!`
+      # as `exclude(:part)`, and what lets Renderers::Annotator wrap the value
+      # from its own TOKENS table. The declaration sits once, on the class
+      # every OMG identifier inherits from, whose body lives in this one file
+      # and is never reopened — the placement the number-retype tranches
+      # require.
+      attribute :part, :string
+
       OMG_TYPE_MAP = {
         "pubid:omg:specification" => "Pubid::Omg::Identifiers::Specification",
       }.freeze
@@ -21,6 +34,7 @@ module Pubid
         map "_type", to: :_type, polymorphic_map: OMG_TYPE_MAP
         map "acronym", to: :acronym
         map "version", to: :version
+        map "part", to: :part
       end
 
       PUBLISHER = "OMG"
@@ -30,14 +44,17 @@ module Pubid
       end
 
       def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
         if identifier.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         parsed = Parser.parse(identifier)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse OMG identifier '#{identifier}': #{e.message}"
       end
     end
   end

data/lib/pubid/omg/parser.rb

@@ -7,27 +7,80 @@ module Pubid
     # Parslet grammar for OMG specification identifiers.
     #
     # Accepts:
-    #   OMG {ACRONYM}[ {VERSION}]
+    #   OMG {ACRONYM}[ {VERSION}][ {PART}]
     #
-    # ACRONYM is uppercase letters/digits, at least 1 char.
-    # VERSION is digits/dots/spaces/beta+space+digit, e.g. "1.0", "2.5.1",
-    # "5 beta 3".
-    class Parser < Parslet::Parser
+    # ACRONYM is the URL segment of https://www.omg.org/spec/<ACRONYM>/, e.g.
+    # "UML", "DDS-XTypes", "EDMC-FIBO/BE", "VSIPL++", "smartant".
+    # VERSION is digits/dots, optionally followed by a beta label, e.g. "1.0",
+    # "2.5.1", "5 beta 3", "2.5 beta".
+    # PART is the volume or format segment, e.g. "Superstructure", "PDF". A
+    # space or a slash separates it.
+    class Parser < ::Pubid::Parser::Grammar
       rule(:space) { str(" ") }
 
-      # Acronym: starts with uppercase, may contain uppercase + lowercase +
-      # digits (covers "SysML", "AMI4CCM", "UML", "CORBA", "BMM", ...).
-      rule(:acronym) { (match("[A-Z]") >> match("[A-Za-z0-9]").repeat).as(:acronym) }
+      # Acronym: the URL segment OMG gives the specification, kept verbatim,
+      # because a consumer builds the URL from it. It starts with a letter,
+      # which may be lower case ("smartant"). Letters, digits and "+" follow
+      # ("SysML", "AMI4CCM", "VSIPL++"). A hyphen or a slash joins further
+      # segments ("DDS-PSM-Cxx", "EDMC-FIBO/BE"). Each segment is non-empty,
+      # so a hyphen or a slash never ends the acronym.
+      #
+      # The slash in "EDMC-FIBO/BE" belongs to the acronym: OMG serves the
+      # document at /spec/EDMC-FIBO/BE/. A slash after the version separates
+      # the document part instead (see the identifier rule).
+      rule(:acronym_char) { match("[A-Za-z0-9+]") }
+
+      rule(:acronym) do
+        (match("[A-Za-z]") >> acronym_char.repeat >>
+          (match("[-/]") >> acronym_char.repeat(1)).repeat).as(:acronym)
+      end
+
+      # Version: digits with optional dots, optionally followed by " beta" and
+      # an optional beta number. OMG writes the label both ways: the document
+      # at /spec/UML/2.5/Beta1 gives its own version as "2.5 beta", and DDS 1.4
+      # supersedes /spec/DDS/1.4/Beta2.
+      #
+      # The beta number must stay optional here. The document part below would
+      # otherwise swallow a bare "beta" and report the version as "2.5" — a
+      # silent wrong answer, not a parse failure.
+      #
+      # Both halves of the beta label end at a word boundary. Parslet never
+      # backtracks into a `.maybe` that already succeeded, so an unanchored
+      # literal makes the version eat the front of a document part and then
+      # reject the whole identifier: "OMG DDS 1.4 beta2" and
+      # "OMG DDS 1.4 betawave" would raise instead of reading the part.
+      rule(:word_boundary) { match("[A-Za-z0-9]").absent? }
+
+      rule(:beta) do
+        str(" beta") >> word_boundary >>
+          (space >> match("[0-9]").repeat(1) >> word_boundary).maybe
+      end
 
-      # Version: digits with optional dots, optionally followed by " beta N".
       rule(:version) do
         (match("[0-9]").repeat(1) >>
           (str(".") >> match("[0-9]").repeat(1)).repeat >>
-          (str(" beta ") >> match("[0-9]").repeat(1)).maybe).as(:version)
+          beta.maybe).as(:version)
       end
 
+      # After the version, OMG separates the document part with either a
+      # space or a slash. The renderer prints a space, so the two spellings of
+      # one document stay equal.
+      rule(:part_separator) { space | str("/") }
+
+      # Document part: the volume or format segment OMG puts after the
+      # version. UML 2.1.1 is two documents, Superstructure and
+      # Infrastructure, and the URL carries the same segment
+      # (/spec/UML/2.1.1/Superstructure). A format name (/spec/DDS/1.4/PDF)
+      # occupies the same position.
+      rule(:part) { match("[A-Za-z0-9]").repeat(1).as(:part) }
+
+      # Only a space separates a part that follows the acronym directly. The
+      # acronym rule takes a slash there, so a slash separator is legal only
+      # after a version.
       rule(:identifier) do
-        str("OMG") >> space >> acronym >> (space >> version).maybe
+        str("OMG") >> space >> acronym >>
+          ((space >> version >> (part_separator >> part).maybe) |
+            (space >> part)).maybe
       end
 
       rule(:root) { identifier }

data/lib/pubid/omg/renderer.rb

@@ -7,13 +7,25 @@ module Pubid
     # Produces:
     #   "OMG AMI4CCM 1.0"
     #   "OMG UML 2.5.1"
+    #   "OMG UML 2.1.1 Superstructure"
     #   "OMG CORBA"
+    #
+    # The document part always prints behind a space. OMG writes it behind
+    # either a space or a slash, and the parser takes both, so normalizing
+    # here is what keeps the two spellings of one document equal.
     class Renderer < ::Pubid::Renderers::Base
       def render(**_opts)
         result = "OMG #{@id.acronym}"
-        result += " #{@id.version}" if @id.version && !@id.version.empty?
+        result += " #{@id.version}" if present?(@id.version)
+        result += " #{@id.part}" if present?(@id.part)
         result
       end
+
+      private
+
+      def present?(value)
+        value && !value.empty?
+      end
     end
   end
 end

data/lib/pubid/omg.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   # OMG (Object Management Group) specification flavor.
   #
   # Covers formal OMG specifications identified by an acronym (UML, SysML,
-  # CORBA, AMI4CCM, ...) with optional version (`1.0`, `2.5.1`,
+  # CORBA, DDS-XTypes, EDMC-FIBO/BE, ...) with optional version (`1.0`, `2.5.1`,
   # `5 beta 3`).
   module Omg
     extend Pubid::PrefixesSupport

data/lib/pubid/parser/grammar.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "parslet"
+require_relative "../errors"
+
+module Pubid
+  module Parser
+    # The superclass of every flavor grammar.
+    #
+    # Its only job is to keep parslet out of pubid's public contract. Every
+    # grammar failure originates in `Parslet::Atoms::Base#parse`, which
+    # `Parslet::Parser` does not override, so one override here covers all 46
+    # grammars, both public entry points of every flavor, and the cross-flavor
+    # delegation routes (`Pubid::Iso.parse("ITU-T G.711")` runs ITU's grammar)
+    # — without touching the 131 `parse` methods.
+    #
+    # The name is `Grammar`, not `Base`, because {Pubid::Parsers::Base} already
+    # exists and means something unrelated (the MR-string parser).
+    #
+    # Known limit: a rule atom parsed directly, `Parser.new.<rule>.parse(str)`,
+    # bypasses this and raises a bare `Parslet::ParseFailed`. Nothing in the
+    # gem does that.
+    class Grammar < ::Parslet::Parser
+      # @param io [String, IO]
+      # @param options [Hash] passed through to parslet
+      # @raise [Pubid::Errors::ParseError]
+      def parse(io, options = {})
+        super
+      rescue ::Pubid::Errors::ParseError
+        # A nested grammar already wrapped it. Keep the inner flavor and input.
+        raise
+      rescue ::Parslet::ParseFailed => e
+        raise wrap_parse_failure(e, io)
+      end
+
+      private
+
+      # @param error [Parslet::ParseFailed]
+      # @param io [String, IO] what was handed to {#parse}
+      # @return [Pubid::Errors::ParseError]
+      def wrap_parse_failure(error, io)
+        ::Pubid::Errors::ParseError.new(
+          error.message,
+          error.parse_failure_cause,
+          input: io.is_a?(String) ? io : nil,
+          flavor: pubid_flavor_name,
+        )
+      end
+
+      # "Pubid::Iso::Parser" -> "iso"; "Pubid::Ieee::Aiee::Parser" -> "ieee".
+      #
+      # Resolved through {Pubid::Registry} rather than taken from the module
+      # name, because the two disagree: `Pubid::Tgpp` registers as `"3gpp"`,
+      # and `Pubid::CenCenelec` registers twice (`"cen_cenelec"` first, then
+      # the `"cen"` alias). Reporting the registered name is what lets a caller
+      # feed `error.flavor` straight back to `Pubid::Registry.get`.
+      # @return [String, nil]
+      def pubid_flavor_name
+        parts = self.class.name.to_s.split("::")
+        return nil unless parts[0] == "Pubid" && parts.length > 1
+
+        registered_flavor_name(parts[1]) || parts[1].downcase
+      end
+
+      # @param module_name [String] e.g. "Tgpp"
+      # @return [String, nil] the registered name, nil if not registered
+      def registered_flavor_name(module_name)
+        ::Pubid::Registry.canonical_name(::Pubid.const_get(module_name))
+      rescue ::NameError
+        nil
+      end
+    end
+  end
+end

data/lib/pubid/parser.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Parser
+    autoload :Grammar, "pubid/parser/grammar"
     autoload :CommonParseMethods, "pubid/parser/common_parse_methods"
     autoload :CommonParseRules, "pubid/parser/common_parse_rules"
   end

data/lib/pubid/parsers/mr_string.rb

@@ -101,6 +101,25 @@ module Pubid
         raise ArgumentError, "Unknown flavor: #{flavor}" unless flavor_module
 
         identifier_string = convert_to_human_readable(mr_string)
+
+        # Refuse to hand the flavor a string this parser did not change.
+        #
+        # `detect_flavor` falls back to `:iso` for any publisher it does not
+        # know, and `Pubid::Iso.parse` sends an MR-shaped string straight back
+        # here — so a string that survives conversion unchanged recurses
+        # forever. `ECMA-426 ed1` is the standing example: "ECMA" is absent
+        # from FLAVOR_MAP, the string matches the MR shape heuristic
+        # (`/\A[A-Z]{2,}[.-]/`), and conversion is a fixed point.
+        # `Pubid::Iso.parse("ECMA-426 ed1")` raised SystemStackError.
+        #
+        # A fixed point means "this was never an MR string", which is a parse
+        # failure — the class the cross-flavor contract requires, and the one
+        # `Pubid.parse` treats as "try the next flavor".
+        if identifier_string == mr_string && flavor_module == Pubid::Iso
+          raise Parslet::ParseFailed,
+                "#{mr_string.inspect} is not an MR string"
+        end
+
         flavor_module.parse(identifier_string)
       end
 

data/lib/pubid/plateau/parser.rb

@@ -2,7 +2,7 @@
 
 module Pubid
   module Plateau
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:space) { str(" ") }
       rule(:dash) { str("-") }
       rule(:hash) { str("#") }

data/lib/pubid/plateau.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 require "parslet"
 
 module Pubid
@@ -19,6 +20,15 @@ module Pubid
     autoload :UrnParser, "#{__dir__}/plateau/urn_parser"
 
     def self.parse(input)
+      unless input.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if input.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       # Apply legacy update_codes normalization first
       normalized = Core::UpdateCodes.apply(input, :plateau)
       parser = Parser.new

data/lib/pubid/prefixes_support.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   # Mixin providing the uniform, static +prefixes+ class method that every
   # registered flavor exposes. relaton uses this to build a global prefix

data/lib/pubid/renderers/annotator.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    # Adds semantic <span class="..."> markers to an already-rendered
+    # identifier string.
+    #
+    # In pubid 1.x annotation was applied in ONE place — `prerender_params`
+    # wrapped every value in the param hash — so all 40-odd flavors got it for
+    # free. pubid 2 replaced that hash with typed components and per-flavor
+    # renderers, and the annotation went with it: `Renderers::Base#annotate`
+    # exists, but only the HumanReadable family calls it. All 39 flavor
+    # renderers receive `context.annotated` and ignore it, so
+    # `to_s(annotated: true)` returned plain text for every flavor but ISO.
+    #
+    # Re-annotating inside 39 renderers would mean 39 chances to drift. This
+    # class recovers the markup from the OUTSIDE instead: it asks the
+    # identifier for its own component values and wraps each one where it
+    # appears in the rendered string. That is one implementation, and a flavor
+    # added tomorrow is covered without touching its renderer.
+    #
+    # It is a fallback, not a replacement. `Identifier#render` uses it only
+    # when the renderer produced no span of its own, so ISO's exact,
+    # render-time placement still wins.
+    #
+    # Deliberate limits:
+    #
+    # * A token that does not appear verbatim in the output is skipped. A
+    #   renderer may transform a value (abbreviate it, change its case), and a
+    #   missing span is a far better outcome than a wrong one or a crash.
+    # * Matching walks left to right behind a cursor, so a later token can
+    #   never match text an earlier one already claimed — that is what stops
+    #   the part "1" of `ISO 1234-1` from matching inside "1234".
+    class Annotator
+      # Semantic class for each token, in the order tokens appear in a printed
+      # identifier. Order matters: it is the sequence the cursor walks.
+      TOKENS = [
+        [:publisher, "publisher"],
+        [:copublishers, "publisher"],
+        %i[typed_stage typed_stage_css],
+        [:type, "doctype"],
+        [:stage, "stage"],
+        [:number, "docnumber"],
+        [:part, "part"],
+        [:subpart, "part"],
+        [:stage_iteration, "iteration"],
+        [:year, "year"],
+        [:edition, "edition"],
+        [:languages, "language"],
+      ].freeze
+
+      # Characters that may not sit directly against a match, so a token never
+      # binds to the middle of a longer run of the same character class.
+      WORD_CHAR = /[A-Za-z0-9]/
+
+      # How deep to follow nested identifiers. A wrapper around a wrapper is
+      # real (BSI adopts a CEN prestandard that adopts an ISO standard); four
+      # levels is past anything the corpus holds, and the cap is here so a
+      # cyclic `base` cannot hang a rendering call.
+      MAX_NESTING = 4
+
+      def initialize(identifier, context = nil)
+        @id = identifier
+        @context = context
+      end
+
+      # @param rendered [String] the plain rendering of {@id}
+      # @return [String] the same string with semantic spans inserted
+      def annotate(rendered)
+        return rendered unless rendered.is_a?(String) && !rendered.empty?
+
+        cursor = 0
+        result = +""
+
+        ordered_tokens(rendered).each do |text, css_class|
+          index = find_token(rendered, text, cursor)
+          next if index.nil?
+
+          result << rendered[cursor...index]
+          result << %(<span class="#{css_class}">#{text}</span>)
+          cursor = index + text.length
+        end
+
+        result << rendered[cursor..]
+        result
+      end
+
+      private
+
+      # Tokens sorted by where they actually appear, not by the order
+      # {TOKENS} lists them.
+      #
+      # Flavors disagree about layout: ISO prints the number before the type
+      # ("ISO/IEC TR 2131"), CCSDS prints it after ("CCSDS 121.0-B-2"). Walking
+      # in declaration order pushed the cursor past the number for CCSDS, so
+      # "121" was never annotated. Sorting by first occurrence makes the walk
+      # follow the printed identifier instead of a fixed idea of one.
+      def ordered_tokens(rendered)
+        tokens = []
+        each_token { |text, css_class| tokens << [text, css_class] }
+
+        decorated = tokens.each_with_index.map do |token, i|
+          position = find_token(rendered, token.first, 0) || rendered.length
+          [position, i, token]
+        end
+
+        decorated.sort_by { |position, i, _| [position, i] }.map(&:last)
+      end
+
+      # Yields [text, css_class] for every annotatable token this identifier
+      # actually carries, then every one its nested identifiers carry.
+      def each_token(&)
+        emit_tokens(@id, 0, &)
+      end
+
+      # A wrapper — an adoption, a supplement, a bundle — carries no number of
+      # its own and prints the document it wraps, so the annotatable tokens in
+      # its string belong to `base`. Reading only the wrapper's own attributes
+      # is why every CSA container and CIE's supplement rendered plain while
+      # accepting the flag.
+      #
+      # Order does not matter here: `ordered_tokens` sorts by first occurrence,
+      # so a nested token lands where it actually appears in the string.
+      def emit_tokens(id, depth, &)
+        return if depth > MAX_NESTING
+
+        tokens_for(id).each do |attr_name, css_class|
+          Array(token_values(id, attr_name)).each do |value|
+            text = token_text(value)
+            next if text.nil? || text.empty?
+
+            yield text, resolve_class(css_class, value)
+          end
+        end
+
+        nested_identifiers(id).each { |nested| emit_tokens(nested, depth + 1, &) }
+      end
+
+      # {TOKENS} unless the identifier names more of its own — see
+      # `Pubid::Identifier#annotation_tokens`.
+      def tokens_for(id)
+        id.respond_to?(:annotation_tokens) ? id.annotation_tokens : TOKENS
+      end
+
+      # The identifiers this one wraps, under any of the four names the gem
+      # uses: `base` (the uniform parent accessor), the `ids` / `identifiers`
+      # collections that bundles and consolidated identifiers hold instead, and
+      # CSA `Bundled`'s `bundled_with` — which holds the amendments a
+      # consolidation prints, and whose values it composes into the string from
+      # their components rather than from their own `to_s`.
+      def nested_identifiers(id)
+        %i[base ids identifiers bundled_with].flat_map do |name|
+          next [] unless id.respond_to?(name)
+
+          begin
+            Array(id.public_send(name))
+          rescue StandardError
+            []
+          end
+        end.grep(::Pubid::Identifier)
+      end
+
+      def token_values(id, attr_name)
+        return nil unless id.respond_to?(attr_name)
+
+        id.public_send(attr_name)
+      rescue StandardError
+        # A derived reader may assume state a partial identifier lacks. A
+        # missing span is not worth an exception on a rendering path.
+        nil
+      end
+
+      # The printed form of one component. Components render themselves through
+      # the context; a bare scalar is already its own text.
+      def token_text(value)
+        return nil if value.nil?
+
+        text = if value.respond_to?(:render)
+                 value.render(context: @context)
+               else
+                 value
+               end
+        text.to_s.strip
+      rescue StandardError
+        nil
+      end
+
+      def resolve_class(css_class, value)
+        return css_class unless css_class == :typed_stage_css
+
+        TypedStageClass.for(value)
+      end
+
+      # First occurrence of +text+ at or after +cursor+ that is not embedded in
+      # a longer word — so "1" matches the part in "ISO 1234-1", never the "1"
+      # inside "1234".
+      def find_token(rendered, text, cursor)
+        at = cursor
+        while (index = rendered.index(text, at))
+          return index if standalone?(rendered, index, text.length)
+
+          at = index + 1
+        end
+        nil
+      end
+
+      def standalone?(rendered, index, length)
+        before = index.zero? ? nil : rendered[index - 1]
+        after = rendered[index + length]
+
+        !WORD_CHAR.match?(before.to_s) && !WORD_CHAR.match?(after.to_s)
+      end
+
+      # The typed-stage class depends on the stage's type code, the same
+      # mapping `Renderers::Base#typed_stage_css` applies. Kept here rather
+      # than reached for through a private method on another object.
+      module TypedStageClass
+        MAP = {
+          "amd" => "amendment",
+          "cor" => "corrigendum",
+          "add" => "addendum",
+        }.freeze
+
+        def self.for(typed_stage)
+          code = typed_stage.respond_to?(:type_code) ? typed_stage.type_code.to_s : ""
+          return "stage" if code.empty? || code == "is"
+
+          MAP[code] || "doctype"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/renderers/base.rb

@@ -41,6 +41,19 @@ module Pubid
         %(#{lead}<span class="#{css_class}">#{core}</span>#{trail})
       end
 
+      # Render a value that may be a component or a bare scalar.
+      #
+      # `number`, `part` and `subpart` are `Components::Code` on
+      # ::Pubid::Identifier but a plain `:string` in a growing number of
+      # flavors, so a shared renderer cannot assume the format-aware
+      # `#render(context:)` seam is there. This keeps both shapes working while
+      # the flavors convert one tranche at a time.
+      def render_component(value, context)
+        return nil if value.nil?
+
+        value.respond_to?(:render) ? value.render(context: context) : value.to_s
+      end
+
       # Choose between "stage" and a type/supplement class for a typed stage.
       def typed_stage_css(typed_stage)
         code = typed_stage&.type_code.to_s

data/lib/pubid/renderers/directives_renderer.rb

@@ -50,15 +50,15 @@ module Pubid
         ann = context.annotated
         parts = []
         if @id.number
-          parts << annotate(@id.number.render(context:), "docnumber",
+          parts << annotate(render_component(@id.number, context), "docnumber",
                             annotated: ann)
         end
         if @id.part
-          parts << " #{annotate(@id.part.render(context:), 'part', 
+          parts << " #{annotate(render_component(@id.part, context), 'part', 
                                 annotated: ann)}"
         end
         if @id.subpart
-          parts << "-#{annotate(@id.subpart.render(context:), 'part', 
+          parts << "-#{annotate(render_component(@id.subpart, context), 'part', 
                                 annotated: ann)}"
         end
         if @id.stage_iteration

data/lib/pubid/renderers/human_readable.rb

@@ -41,15 +41,15 @@ module Pubid
         ann = context.annotated
         parts = []
         if @id.number
-          parts << annotate(@id.number.render(context:), "docnumber",
+          parts << annotate(render_component(@id.number, context), "docnumber",
                             annotated: ann)
         end
         if @id.part
-          parts << "-#{annotate(@id.part.render(context:), 'part', 
+          parts << "-#{annotate(render_component(@id.part, context), 'part', 
                                 annotated: ann)}"
         end
         if @id.subpart
-          parts << "-#{annotate(@id.subpart.render(context:), 'part', 
+          parts << "-#{annotate(render_component(@id.subpart, context), 'part', 
                                 annotated: ann)}"
         end
         if @id.stage_iteration