pubid 2.0.0 → 2.0.2

data/lib/pubid/ietf/identifiers/base.rb

@@ -64,9 +64,25 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:ietf, identifier)
+        parsed = Pubid::Parg::Model.bound(:ietf, strip_prefix(identifier))
         Builder.build(parsed)
       end
+
+      # The external spellings `IETF RFC 8341`, `IETF I-D draft-…`,
+      # `IETF Internet-Draft draft-…`, `Internet-Draft draft-…` and
+      # `I-D draft-…` name the same document as the bare form. The publisher
+      # and the draft label are not part of the identity, so they are dropped
+      # before the baked grammar runs, and `to_s(with_publisher:)` renders
+      # them again. The lookahead keeps the strip off anything that is not
+      # followed by an IETF designation.
+      EXTERNAL_PREFIX = /
+        \A(?:IETF\s+)?(?:(?:I-D|Internet-Draft)\s+(?=draft-))?
+        (?=(?:RFC|BCP|STD|FYI)\s|draft-)
+      /x
+
+      def self.strip_prefix(identifier)
+        identifier.sub(EXTERNAL_PREFIX, "")
+      end
     end
   end
 end

data/lib/pubid/ietf/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Ietf
-    # Parslet grammar for the three IETF families. The top-level alternation is
+    # Grammar for the three IETF families. The top-level alternation is
     # keyed by leading token, and each alternative captures the raw fields the
     # Builder needs:
     #   * RFC        -> { number: }
@@ -12,50 +10,7 @@ module Pubid
     #   * draft      -> { draft_rest: }  (everything after "draft-"; the version
     #                    split is done in the Builder to keep the digit-tail
     #                    heuristic in one place)
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:space) { str(" ") }
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-
-      # "RFC 2119", and the zero-padded, space-less spelling the RFC editor's
-      # rfc-index.xml emits ("RFC0001"). See #subseries for why.
-      rule(:rfc) { str("RFC") >> space.maybe >> digits.as(:number) }
-
-      # "BCP 3" / "STD 66" / "FYI 1".
-      #
-      # The space is optional and leading zeros are allowed because
-      # rfc-index.xml writes the sub-series membership of an RFC in the padded,
-      # space-less form -- <is-also><doc-id>STD0066</doc-id></is-also> -- and
-      # relaton builds the STD/BCP/FYI <-> RFC cross-references from exactly
-      # those elements without normalizing them itself. The Builder strips the
-      # pad, so the printed form stays the canonical "STD 66".
-      rule(:subseries) do
-        (str("BCP") | str("STD") | str("FYI")).as(:series) >>
-          space.maybe >> digits.as(:number)
-      end
-
-      # Internet-Draft slug characters: lowercase, digits and the "-", "+", "_"
-      # separators, plus two historical shapes the published corpus carries --
-      # a dot inside a topic token ("draft-ietf-pilc-2.5g3g-12") and uppercase
-      # letters in protocol/organisation names ("draft-chapin-clnp-ISO8473-00").
-      # 50 of the 166,740 relaton-data-ids identifiers need those two
-      # characters; nothing else outside [a-z0-9-] occurs in the corpus.
-      #
-      # Widening the tail is unambiguous: the top-level alternation is keyed on
-      # the leading token (RFC / BCP|STD|FYI / draft-), so a wider draft tail
-      # cannot make another branch match.
-      #
-      # The whole remainder after "draft-" is captured; the Builder anchors the
-      # optional trailing "-NN" version.
-      rule(:draft_rest) { match['a-zA-Z0-9+_.\-'].repeat(1).as(:draft_rest) }
-      rule(:draft) { str("draft-") >> draft_rest }
-
-      rule(:identifier) { rfc | subseries | draft }
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/ietf/renderer.rb

@@ -8,10 +8,25 @@ module Pubid
     #   "RFC 2119"
     #   "BCP 3" / "STD 66" / "FYI 1"
     #   "draft-giuliano-treedn-02" / "draft-giuliano-treedn"
+    #
+    # The default form carries no publisher, which is how IETF documents are
+    # cited. `with_publisher:` names the two forms relaton#49 asks for:
+    #   true  -> "IETF RFC 2119" / "IETF Internet-Draft draft-giuliano-treedn"
+    #   false -> "RFC 2119"      / "Internet-Draft draft-giuliano-treedn"
+    # A draft slug says nothing about its type, so both explicit forms label
+    # it; the default keeps the bare slug.
     class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **_opts)
+      INTERNET_DRAFT_LABEL = "Internet-Draft"
+
+      def render(context: nil, with_publisher: nil, **_opts)
         require_number!(@id)
-        render_identifier(@id)
+        result = render_identifier(@id)
+        return result if with_publisher.nil?
+
+        if @id.is_a?(Identifiers::InternetDraft)
+          result = "#{INTERNET_DRAFT_LABEL} #{result}"
+        end
+        with_publisher ? "#{Identifier::PUBLISHER} #{result}" : result
       end
 
       private

data/lib/pubid/iho/CLAUDE.md

@@ -0,0 +1,89 @@
+# IHO flavor notes
+
+IHO (International Hydrographic Organization) identifiers: the
+S/P/M/B/C letter series, their parg-driven parse, and the series
+components introduced for relaton/relaton#407.
+
+Read this before you change `lib/pubid/iho/` or `spec/pubid/iho/`. The
+root `CLAUDE.md` keeps the cross-flavor contract that every flavor
+obeys.
+
+## Parsing runs on the parg artifact
+
+There is no `parser.rb` and no Parslet anywhere in this flavor: parse
+goes `Pubid::Parg::Backend.parse(:iho, ...)` over the baked artifact
+`data/parg/iho.json`. The artifact is baked from the flavor grammar
+source `grammars/iho.parg` in the pubid-grammar repository (commit
+840b2b1d "Retire the last live Parslet parsers" ports the original
+13-rule Parslet grammar byte-identically).
+
+**Drift warning:** the artifact on this branch carries the
+relaton/relaton#407 tail rules (year / volume / issue), while the
+checked-in `grammars/iho.parg` in pubid-grammar still has only the
+version tail. Until the updated grammar source lands in pubid-grammar,
+the artifact is ahead of its source and not reproducible from it —
+the same artifact-ahead-of-source state the root notes describe under
+grammar-artifact drift. Do not re-bake from the stale source, and do
+not hand-edit the artifact; land the grammar first.
+
+## Series components (relaton/relaton#407)
+
+The B-7, P-1, P-5, P-6 series are continuously updated publications
+whose trailing component is not an a.b.c edition: P-5/P-6 (and B-7)
+are identified by **year**, P-1 (the International Hydrographic
+Review) by **volume** with an optional **issue**. The grammar tail
+picks exactly one discriminator, so only one of `version` / `year` /
+`volume` is ever present, with `issue` only beside a volume:
+
+- `IHO P-5 2024` — year is a plain `:string` scalar, 19xx/20xx only
+  (`IHO P-5 1850` and the two-segment `IHO B-12 3.0` reject).
+- `IHO P-1 Vol. 30 (2)` — volume/issue scalars; `Issue 2` is an input
+  alias whose canonical print is `(2)`.
+- `IHO S-44 5.0.0` — the dotted `version` stays for the edition-bearing
+  series and legacy `1.0.0` placeholder rows.
+
+All three are ordinary lutaml attributes mapped through the flavor's
+`key_value` block — no converters, no hand-rolled serialization.
+
+**Identity semantics:** the components are identity-bearing in `==` /
+`matches?`; a bare reference (`IHO P-5`) leaves all four nil and
+wildcards the series (`spec/pubid/partial_ref_spec.rb` locks the
+omitted-key set). The volume/issue pair is a scalar **cluster**:
+`exclude(:volume)` nils the issue with it, so a reference that omits
+the issue still matches a hit that carries one — the same
+additive-alias shape the base applies to `:year -> :date`. A lone
+scalar `:year` needs no override; the base nils a declared `:year`
+directly.
+
+**`all_parts_edition_keys` needs no override:** the default
+`%i[date year edition version]` already covers `:year` and `version`,
+and volume/issue only ride part-less ids, which cannot join
+`AllParts` (`validate_member!` demands a `part`). The audit case in
+`spec/pubid/all_parts_edition_keys_audit_spec.rb` covers the
+version-bearing S-series collapse.
+
+**URN conventions:** a year is a bare trailing segment
+(`urn:iho:p:5:2024`); a volume is a `vol.N` part-kind segment with an
+optional `issue.N` after it (`urn:iho:p:1:vol.30.issue.2`). The URN
+parser walks part-kind tokens as a run and hands the rebuilt text
+back through the flavor parse, so a URN round-trip exercises the same
+grammar as a string.
+
+## Fixtures run through the classify pipeline
+
+`spec/fixtures/iho/identifiers/full/identifiers.txt` is the input
+corpus; `rake "validation:classify[iho]"` regenerates `pass/` and
+`fail/` from it (the classifier deletes pass/fail first — never edit
+them by hand, edit `full/` and reclassify). Before the relaton#407
+branch the pass files were hand-curated with **no** `full/` tree, the
+OASIS hazard: a classify run would have wiped 131 entries and rebuilt
+nothing. The classifier's per-flavor class detection has an `iho`
+case, so fail entries land in a named class file.
+
+## relaton-side follow-ups (not this repo)
+
+relaton/relaton#407 items 3-4 stay open on the relaton side:
+`Relaton::Iho::Bibliography#pubid_match?`/`version_key` need the new
+component, relaton-cli's `MachineIndex::REFINABLE_KEYS` needs
+`year`/`volume` beside `version`/`edition`, and the pubid pin bumps
+in step with the relaton-data-iho re-key.

data/lib/pubid/iho/builder.rb

@@ -2,7 +2,7 @@
 
 module Pubid
   module Iho
-    # Build IHO identifier objects from parslet parse output.
+    # Build IHO identifier objects from the parg artifact parse tree.
     class Builder
       def build(parsed)
         hash = parsed.is_a?(Array) ? parsed.reduce({}, :merge) : parsed
@@ -15,6 +15,9 @@ module Pubid
           annex: stringify(hash[:annex]),
           supplement: stringify(hash[:supplement]),
           version: stringify(hash[:version]),
+          year: stringify(hash[:year]),
+          volume: stringify(hash[:volume]),
+          issue: stringify(hash[:issue]),
         }.compact
 
         Pubid::Iho.identifier_klass_for_type_letter(type_letter).new(**attrs)

data/lib/pubid/iho/identifiers/base.rb

@@ -6,7 +6,7 @@ module Pubid
     # every concrete IHO identifier (Identifiers::*) descends from it.
     #
     # IHO identifiers have the form:
-    #   IHO {S|P|M|B|C}-{number}[ Ap. {appendix}][ Part {part}][ Annex {annex}][ Suppl {supplement}][ {version}]
+    #   IHO {S|P|M|B|C}-{number}[ Ap. {appendix}][ Part {part}][ Annex {annex}][ Suppl {supplement}][ {version|year|Vol. N [issue]}]
     #
     # The leading IHO publisher prefix is optional on input but always
     # emitted on output.
@@ -25,7 +25,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(identifier)
+        parsed = Pubid::Parg::Backend.parse(:iho, identifier.strip)
         Builder.build(parsed)
       end
 
@@ -40,6 +40,17 @@ module Pubid
       attribute :annex,      :string
       attribute :supplement, :string
       attribute :version,    :string
+      # Series identity components (relaton#407): the year-identified
+      # series (B-7, P-5, P-6) and the volume/issue-identified ones
+      # (P-1 and the IHR) carry no a.b.c edition — their trailing
+      # component is a year or a "Vol. N [issue]" pair instead. Plain
+      # scalars, like every other IHO attribute; the grammar's tail
+      # picks exactly one discriminator, so only one of
+      # version/year/volume is ever present, with issue only
+      # alongside volume.
+      attribute :year,       :string
+      attribute :volume,     :string
+      attribute :issue,      :string
 
       # Polymorphic type map for lutaml::Model key_value serialization: maps
       # each subclass's polymorphic_name to its class name so `from_hash` can
@@ -65,10 +76,25 @@ module Pubid
         map "annex",      to: :annex
         map "supplement", to: :supplement
         map "version",    to: :version
+        map "year",       to: :year
+        map "volume",     to: :volume
+        map "issue",      to: :issue
       end
 
       # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
       # IHO_TYPE_MAP remains as the key_value polymorphic_map.
+
+      # The volume/issue pair is a scalar cluster: a reference that omits
+      # the issue must still match a hit that carries one ("P-1 Vol. 30"
+      # vs "P-1 Vol. 30 (2)"), so excluding the volume nils the issue
+      # with it — the same additive-alias shape the base applies to
+      # :year -> :date. A lone scalar :year needs no override here: the
+      # base nils a declared :year directly (the additive :year -> :date
+      # alias nils whichever name the flavor declares).
+      def exclude(*args)
+        args << :issue if args.include?(:volume)
+        super
+      end
     end
 
   end

data/lib/pubid/iho/renderer.rb

@@ -9,6 +9,8 @@ module Pubid
     #   "IHO P-1/21 1.0.0"
     #   "IHO S-100 Part 4a 1.0.0"
     #   "IHO S-65 Ap. A 1.0.0"
+    #   "IHO P-5 2024"            (year-identified series)
+    #   "IHO P-1 Vol. 30 (2)"     (volume/issue-identified series)
     #
     # The renderer is registered as the `:human` format in the IHO format
     # registry and invoked via `render(format: :human)`.
@@ -22,7 +24,13 @@ module Pubid
         rendered << " Part #{id.part}" if id.part
         rendered << " Annex #{id.annex}" if id.annex
         rendered << " Suppl #{id.supplement}" if id.supplement
+        # The grammar's tail picks exactly one discriminator: a dotted
+        # version, a year, or a volume (with an optional issue). The
+        # issue prints parenthesized; "Issue N" is an input alias only.
         rendered << " #{id.version}" if id.version
+        rendered << " #{id.year}" if id.year
+        rendered << " Vol. #{id.volume}" if id.volume
+        rendered << " (#{id.issue})" if id.issue
         rendered
       end
     end

data/lib/pubid/iho/urn_generator.rb

@@ -4,8 +4,13 @@ module Pubid
   module Iho
     # Generates URN strings for IHO identifiers.
     #
-    # Format: urn:iho:{type-letter-lowercase}:{number}[:ap.{appendix}][:part.{part}][:annex.{annex}][:suppl.{supplement}][:{version}]
+    # Format: urn:iho:{type-letter-lowercase}:{number}[:ap.{appendix}][:part.{part}][:annex.{annex}][:suppl.{supplement}][:{version|year|vol.N[.issue.N]}]
     # Example: urn:iho:s:44:5.0.0 for "IHO S-44 5.0.0".
+    # The trailing series component follows the flavor's own conventions:
+    # a version or a year is a bare segment ("urn:iho:p:5:2024" for
+    # "IHO P-5 2024"), a volume is a vol.N part-kind segment with an
+    # optional issue.N after it ("urn:iho:p:1:vol.30.issue.2" for
+    # "IHO P-1 Vol. 30 (2)").
     class UrnGenerator
       attr_reader :identifier
 
@@ -21,7 +26,12 @@ module Pubid
         parts << "part.#{identifier.part}"       if identifier.part
         parts << "annex.#{identifier.annex}"     if identifier.annex
         parts << "suppl.#{identifier.supplement}" if identifier.supplement
+        # The grammar's tail picks exactly one discriminator; a volume
+        # may carry an issue beside it.
+        parts << "vol.#{identifier.volume}"      if identifier.volume
+        parts << "issue.#{identifier.issue}"     if identifier.issue
         parts << identifier.version.to_s if identifier.version
+        parts << identifier.year.to_s if identifier.year
         parts.join(":")
       end
     end

data/lib/pubid/iho/urn_parser.rb

@@ -5,22 +5,28 @@ module Pubid
     # Parses IHO URNs back into identifiers.
     #
     # UrnGenerator emits:
-    #   urn:iho:{type-lower}:{number}[:{part-kind}.{part}]:{version}
+    #   urn:iho:{type-lower}:{number}[:{part-kind}.{part}][:{version|year|vol.N[.issue.N]}]
     #
     # type-lower is the lowercase series letter (s, p, m, b, c).
-    # part-kind is the lowercase part label (part, ap, annex, suppl).
-    # version is the dotted version string.
+    # part-kind is the lowercase part label (part, ap, annex, suppl,
+    # vol, issue).
+    # The trailing segment is the dotted version, a bare year, or the
+    # volume/issue pair.
     #
     # Examples:
     # - urn:iho:s:44:5.0.0                → IHO S-44 5.0.0
     # - urn:iho:s:100:part.4a:1.0.0       → IHO S-100 Part 4a 1.0.0
     # - urn:iho:s:65:ap.A:1.0.0           → IHO S-65 Ap. A 1.0.0
+    # - urn:iho:p:5:2024                  → IHO P-5 2024
+    # - urn:iho:p:1:vol.30                → IHO P-1 Vol. 30
+    # - urn:iho:p:1:vol.30.issue.2        → IHO P-1 Vol. 30 (2)
     class UrnParser < Pubid::UrnParser::Base
       PART_LABELS = {
         "part" => "Part",
         "ap" => "Ap.",
         "annex" => "Annex",
         "suppl" => "Suppl",
+        "vol" => "Vol.",
       }.freeze
 
       def parse_urn(urn)
@@ -30,18 +36,22 @@ module Pubid
         type_token = parts.fetch(0).upcase
         number = parts.fetch(1)
         idx = 2
-        part_label = nil
-        if parts[idx] && part_kind?(parts[idx])
+        text = "IHO #{type_token}-#{number}"
+        # Part-kind tokens come in any run (a volume may carry an issue
+        # beside it); "issue.N" prints as the parenthesized issue.
+        while parts[idx] && part_kind?(parts[idx])
           kind, value = parts[idx].split(".", 2)
-          label = PART_LABELS.fetch(kind.downcase) { kind.capitalize }
-          part_label = "#{label} #{value}"
+          if kind.downcase == "issue"
+            text += " (#{value})"
+          else
+            label = PART_LABELS.fetch(kind.downcase) { kind.capitalize }
+            text += " #{label} #{value}"
+          end
           idx += 1
         end
-        version = parts[idx]
+        tail = parts[idx]
 
-        text = "IHO #{type_token}-#{number}"
-        text += " #{part_label}" if part_label
-        text += " #{version}" if version
+        text += " #{tail}" if tail
         flavor_parse(text)
       end
 

data/lib/pubid/iho.rb

@@ -11,7 +11,6 @@ module Pubid
     autoload :Builder,      "#{__dir__}/iho/builder"
     autoload :Identifier, "#{__dir__}/iho/identifiers/base"
     autoload :Identifiers,  "#{__dir__}/iho/identifiers"
-    autoload :Parser,       "#{__dir__}/iho/parser"
     autoload :Renderer,     "#{__dir__}/iho/renderer"
     autoload :UrnGenerator, "#{__dir__}/iho/urn_generator"
     autoload :UrnParser, "#{__dir__}/iho/urn_parser"

data/lib/pubid/isbn/identifier.rb

@@ -64,7 +64,7 @@ module Pubid
 
       # @raise [Pubid::Errors::ParseError] if the string is not a valid ISBN
       def self.build_identifier(identifier)
-        parsed = Pubid::Parg::Backend.parse(:isbn, identifier)
+        parsed = Pubid::Parg::Model.bound(:isbn, identifier)
         Builder.build(parsed)
       rescue ArgumentError => e
         # The Builder validates length and check digit. Surface that as a parse

data/lib/pubid/isbn/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Isbn
-    # Parslet grammar for ISBN identifiers per ISO 2108.
+    # Grammar for ISBN identifiers per ISO 2108.
     #
     # Accepts:
     #   [ISBN[ |:]] {10 or 13 digits with optional hyphens}
@@ -12,34 +10,7 @@ module Pubid
     # ISBN-10 final digit may be "X" (check digit value 10). Hyphens are
     # optional and may appear in any group position; they are preserved
     # for round-trip rendering.
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:space)   { str(" ") }
-      rule(:colon)   { str(":") }
-      rule(:hyphen)  { str("-") }
-      rule(:digit)   { match("[0-9]") }
-      rule(:x_digit) { digit | str("X") }
-
-      rule(:isbn_prefix) do
-        (str("ISBN") >> (space | (space.maybe >> colon >> space.maybe))).maybe
-      end
-
-      rule(:digit_group) { digit.repeat(1) }
-      rule(:x_group)     { x_digit.repeat(1) }
-
-      # Loose "ISBN-ish" token: digits or final X, separated by hyphens.
-      rule(:isbn_body) do
-        (digit_group >> (hyphen >> digit_group).repeat >>
-          (hyphen >> x_digit).maybe).as(:body) |
-          (digit.repeat(9, 12) >> x_digit.maybe).as(:body)
-      end
-
-      rule(:identifier) { isbn_prefix >> isbn_body }
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/iso/builder.rb

@@ -308,7 +308,7 @@ module Pubid
         when :number
           # For TC documents, number is the document number (N number)
           # For regular identifiers, this is handled in :number_with_part
-          if value.is_a?(Parslet::Slice) || value.is_a?(String) ||
+          if value.is_a?(String) ||
               value.is_a?(Integer)
             value.to_s
           else

data/lib/pubid/iso/identifiers/directives.rb

@@ -35,9 +35,12 @@ module Pubid
         end
 
         def to_s(**opts)
-          context = build_rendering_context(nil, format: :human, **opts)
-          Pubid::Renderers::DirectivesRenderer.new(self).render(context:,
-                                                                **opts.slice(:with_edition))
+          context = build_rendering_context(
+            nil, format: :human, **opts.except(:with_publisher)
+          )
+          rendered = Pubid::Renderers::DirectivesRenderer.new(self)
+            .render(context:, **opts.slice(:with_edition))
+          apply_with_publisher(rendered, :human, opts[:with_publisher])
         end
 
         # Directives use a different URN scheme: urn:iso:doc instead of urn:iso:std

data/lib/pubid/iso/identifiers/guide.rb

@@ -91,9 +91,12 @@ module Pubid
         def to_s(**opts)
           return super if opts[:format] && opts[:format] != :human
 
-          context = build_rendering_context(nil, format: :human, **opts)
-          Pubid::Renderers::GuideRenderer.new(self).render(context:,
-                                                           **opts.slice(:with_edition))
+          context = build_rendering_context(
+            nil, format: :human, **opts.except(:with_publisher)
+          )
+          rendered = Pubid::Renderers::GuideRenderer.new(self)
+            .render(context:, **opts.slice(:with_edition))
+          apply_with_publisher(rendered, :human, opts[:with_publisher])
         end
       end
     end

data/lib/pubid/iso/identifiers/international_standard.rb

@@ -54,7 +54,9 @@ module Pubid
             code: :wds,
             stage_code: :wds,
             type_code: :is,
-            abbr: ["WDS"],
+            # ISO launched the "WD Study" WG consultation (stage 20.20/20.60,
+            # relaton-iso#125); its spelled-out form is an accepted input spelling.
+            abbr: ["WDS", "WD Study"],
             name: "Working Draft Study",
             harmonized_stages: %w[20.20 20.60],
           ),

data/lib/pubid/iso/identifiers/international_workshop_agreement.rb

@@ -85,9 +85,12 @@ module Pubid
         end
 
         def to_s(**opts)
-          context = build_rendering_context(nil, format: :human, **opts)
-          Pubid::Renderers::IwaRenderer.new(self).render(context:,
-                                                         **opts.slice(:with_edition))
+          context = build_rendering_context(
+            nil, format: :human, **opts.except(:with_publisher)
+          )
+          rendered = Pubid::Renderers::IwaRenderer.new(self)
+            .render(context:, **opts.slice(:with_edition))
+          apply_with_publisher(rendered, :human, opts[:with_publisher])
         end
       end
     end

data/lib/pubid/iso/normalizer.rb

@@ -71,7 +71,7 @@ module Pubid
           supplement_number = match[3] # "1"
           supplement_year = match[4]   # "1987" or nil
 
-          base_parsed = Pubid::Iso.parser.parse(base_str)
+          base_parsed = Pubid::Parg::Backend.parse(:iso, base_str)
           base = Pubid::Iso.builder.build(base_parsed)
 
           addendum = Identifiers::Addendum.new