pubid 2.0.4 → 2.0.6

data/lib/pubid/iho/urn_parser.rb

@@ -2,69 +2,240 @@
 
 module Pubid
   module Iho
-    # Parses IHO URNs back into identifiers.
+    # Parses IHO URNs back into identifiers through the documented
+    # positional segment grammar (the same grammar the generator emits;
+    # the segment table lives in the grammar header and the flavor notes):
     #
-    # UrnGenerator emits:
-    #   urn:iho:{type-lower}:{number}[:{tag}.{value}]*[:{version}][:y.{year}]
+    #   urn:iho:<type>:<number>[:ed-<x.y.z>][:sup-<n>][:part-<X>]
+    #     [:annex-<A>][:appendix-<B>][:<sub>][:vol-<n>][:issue-<n>]
+    #     [:year-<yyyy>]
     #
-    # type-lower is the lowercase series letter (s, p, m, b, c).
-    # tag is a lowercase label: part, ap, annex, suppl, vol, issue or y.
-    # version is the dotted a.b.c edition, the only untagged tail.
+    # Segment discipline (mirrors the ISO URN parser's strictness):
+    # - the docnumber occupies every leading bare number segment up to
+    #   the first marker, so a colon number ("158:100") round-trips
+    #   without escaping;
+    # - every other component is a marker-prefixed segment validated
+    #   against its own value pattern — unknown, reordered or junk
+    #   segments raise {Pubid::Errors::UrnParseError}, never
+    #   mis-consume;
+    # - the appendix subnumber is a bare digit atom allowed only
+    #   directly after its appendix segment (a year is always
+    #   marker-tagged, so a bare digit there can only be the subnumber);
+    # - the issue is allowed only beside its volume and validated as
+    #   digits.
     #
-    # The number is not escaped, so it can span segments
-    # ("IHO S-158:100" gives "urn:iho:s:158:100"). Every untagged
-    # segment that is not a version therefore belongs to the number.
+    # Legacy 2.0.x spellings remain decodable but are never emitted:
+    # the bare a.b.c edition segment, the dotted keys part./annex./
+    # suppl./ap./appendix./vol./issue. and the single-letter y. year tag
+    # (the #637 scheme the positional grammar replaces; the legacy
+    # appendix values stored the subnumber inside one string, "D-2",
+    # which decodes into the two components).
     #
     # 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:s:158:100:1.0.0           → IHO S-158:100 1.0.0
-    # - urn:iho:p:5:y.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)
+    # - urn:iho:s:44:ed-5.0.0                  → IHO S-44 5.0.0
+    # - urn:iho:s:100:ed-5.0.0:part-2          → IHO S-100 5.0.0 Part 2
+    # - urn:iho:s:122:ed-1.0.0:appendix-D:2    → IHO S-122 1.0.0 Appendix D-2
+    # - urn:iho:p:5:vol-2024                   → IHO P-5 Vol. 2024
+    # - urn:iho:p:1:vol-30:issue-2             → IHO P-1 Vol. 30 (2)
+    # - urn:iho:s:158:100                      → IHO S-158:100
     class UrnParser < Pubid::UrnParser::Base
-      # Tag => the text that the human-readable form prints for it.
-      TAG_TEXT = {
-        "part" => ->(v) { " Part #{v}" },
-        "ap" => ->(v) { " Ap. #{v}" },
-        "annex" => ->(v) { " Annex #{v}" },
-        "suppl" => ->(v) { " Suppl #{v}" },
-        "vol" => ->(v) { " Vol. #{v}" },
-        "issue" => ->(v) { " (#{v})" },
-        "y" => ->(v) { " #{v}" },
+      TYPE_LETTERS = %w[s p m b c].freeze
+
+      # Marker => attribute, with the value pattern each marker's slot
+      # accepts. The patterns mirror the grammar's own production rules
+      # (upper-case letters are case-preserved; "part" allows the
+      # digits-then-letters compound like "4a" beside a lone letter; the
+      # volume takes any serial locator, yearbook years included).
+      MARKERS = {
+        "ed" => [:edition, /\A\d+\.\d+\.\d+\z/],
+        "sup" => [:supplement, /\A\d+\z/],
+        "part" => [:part, /\A(?:\d+[a-zA-Z]*|[A-Z]|[SPMBC]-\d+)\z/],
+        "annex" => [:annex, /\A[A-Z]\z/],
+        "appendix" => [:appendix, /\A(?:[A-Z]|\d+)\z/],
+        "vol" => [:volume, /\A\d+\z/],
+        "issue" => [:issue, /\A\d+\z/],
+        "year" => [:year, /\A(?:19|20)\d{2}\z/],
+      }.freeze
+
+      MARKER_RE = /\A(#{MARKERS.keys.join('|')})-(.+)\z/
+
+      # The positional markers: their attribute depends on the node they
+      # follow (the component-edition duality).
+      POSITIONAL_MARKERS = %i[edition year].freeze
+
+      # Legacy dotted keys (deprecated; decodable, never emitted).
+      # "ap" is the pre-positional appendix tag; "suppl" the pre-positional
+      # supplement tag; "y" the pre-positional year tag — under the
+      # serial-locator unification a year IS a volume, so the y. value
+      # decodes into the volume.
+      LEGACY_KEYS = {
+        "part" => :part,
+        "annex" => :annex,
+        "suppl" => :supplement,
+        "ap" => :appendix,
+        "appendix" => :appendix,
+        "vol" => :volume,
+        "issue" => :issue,
+        "y" => :volume,
       }.freeze
 
-      VERSION_SEGMENT = /\A\d+\.\d+\.\d+\z/
+      LEGACY_RE = /\A([a-z]+)\.(.+)\z/
+
+      # A bare a.b.c segment is the legacy edition encoding.
+      LEGACY_EDITION_RE = /\A\d+\.\d+\.\d+\z/
+      SUBNUMBER_RE = /\A\d+\z/
+      # The docnumber's own charset: digits with : / - suffix runs.
+      NUMBER_RE = /\A\d+(?:[:\/-]\d+)*\z/
 
       def parse_urn(urn)
-        type_token, first, *rest = split_parts(strip_namespace(urn))
-        number = [first, *rest.take_while { |s| untagged_number?(s) }]
-        tail = rest.drop(number.size - 1).map { |s| segment_text(s, urn) }
-        flavor_parse("IHO #{type_token.upcase}-#{number.join(':')}#{tail.join}")
+        segments = split_parts(strip_namespace(urn))
+        type_token = read_type!(segments, urn)
+        attrs = { number: consume_number!(segments, urn) }
+        # Positional context: the component the upcoming ed-/year- would
+        # attach to, and the owner of the edition just consumed (a year
+        # belongs to a component only when it follows that component's
+        # own edition).
+        ctx = { component: nil, edition_owner: nil }
+        consume_segments!(attrs, segments, ctx, urn)
+        Builder.build({ type: type_token.upcase, **attrs })
       end
 
       private
 
-      def untagged_number?(segment)
-        !tagged?(segment) && !segment.match?(VERSION_SEGMENT)
+      def read_type!(segments, urn)
+        type_token = segments.shift.to_s.downcase
+        return type_token if TYPE_LETTERS.include?(type_token)
+
+        raise Pubid::Errors::UrnParseError,
+              "Unknown IHO series #{type_token.inspect} in #{urn.inspect}"
+      end
+
+      def consume_segments!(attrs, segments, ctx, urn)
+        until segments.empty?
+          consume_segment!(attrs, segments, ctx, urn)
+        end
+      end
+
+      # The number occupies every leading bare number segment; the first
+      # segment that is not number-shaped ends it (and the segment loop
+      # below decides whether it is a legal marker).
+      def consume_number!(segments, urn)
+        number = []
+        while segments.first&.match?(NUMBER_RE)
+          number << segments.shift
+        end
+        if number.empty?
+          raise Pubid::Errors::UrnParseError,
+                "Missing docnumber in #{urn.inspect}"
+        end
+
+        number.join(":")
+      end
+
+      def consume_segment!(attrs, segments, ctx, urn)
+        segment = segments.shift
+        case segment
+        when MARKER_RE then consume_marker!(segment, attrs, segments, ctx, urn)
+        when LEGACY_RE then consume_legacy!(segment, attrs, urn)
+        when LEGACY_EDITION_RE then store!(attrs, :edition, segment, urn)
+        else raise_unexpected!(segment, urn)
+        end
+      end
+
+      def raise_unexpected!(segment, urn)
+        raise Pubid::Errors::UrnParseError,
+              "Unexpected segment #{segment.inspect} in #{urn.inspect}"
+      end
+
+      # A marker segment: validate the value against the marker's own
+      # pattern, store it, and claim the bare atom that follows an
+      # appendix (its subnumber — the only bare atom allowed after a
+      # marker). The ed- and year- markers are POSITIONAL: the edition
+      # attaches to the component it follows (the base when no component
+      # precedes it), and a year belongs to a component only when it
+      # follows that component's own edition — the separately-published
+      # mode; otherwise it is the base with-year qualifier.
+      def consume_marker!(segment, attrs, segments, ctx, urn)
+        marker, value = MARKER_RE.match(segment).captures
+        key, pattern = MARKERS.fetch(marker)
+        raise_invalid!(marker, value, urn) unless value.match?(pattern)
+
+        if POSITIONAL_MARKERS.include?(key)
+          return consume_positional!(attrs, key, value, ctx, urn)
+        end
+
+        store!(attrs, key, value, urn)
+        ctx[:component] = key
+        ctx[:edition_owner] = nil
+        consume_subnumber!(attrs, key, segments, ctx, urn)
+      end
+
+      def raise_invalid!(marker, value, urn)
+        raise Pubid::Errors::UrnParseError,
+              "Invalid #{marker} value #{value.inspect} in #{urn.inspect}"
+      end
+
+      # ed- and year- are POSITIONAL markers (see the marker docs): the
+      # edition attaches to the component it follows, the year to the
+      # edition owner.
+      def consume_positional!(attrs, key, value, ctx, urn)
+        if key == :edition
+          return store_component_scoped!(attrs, :edition, value, ctx, urn)
+        end
+
+        store_year!(attrs, value, ctx, urn)
+      end
+
+      def store_component_scoped!(attrs, stem, value, ctx, urn)
+        owner = ctx[:component]
+        store!(attrs, owner ? :"#{owner}_#{stem}" : stem, value, urn)
+        ctx[:edition_owner] = owner
       end
 
-      def tagged?(segment)
-        segment.match?(/\A[a-z]+\./i)
+      def store_year!(attrs, value, ctx, urn)
+        owner = ctx[:edition_owner]
+        attrs_key = owner && owner != :base ? :"#{owner}_year" : :year
+        ctx[:edition_owner] = nil
+        store!(attrs, attrs_key, value, urn)
       end
 
-      def segment_text(segment, urn)
-        return " #{segment}" if segment.match?(VERSION_SEGMENT)
+      def consume_subnumber!(attrs, key, segments, ctx, urn)
+        return unless key == :appendix && segments.first&.match?(SUBNUMBER_RE)
+
+        store!(attrs, :appendix_subnumber, segments.shift, urn)
+      end
 
-        tag, value = segment.split(".", 2)
-        render = TAG_TEXT[tag.downcase] if tagged?(segment)
-        unless render
+      # Legacy dotted-key decode. The legacy appendix value stored the
+      # subnumber inside one string ("appendix.D-2"); it decodes into the
+      # two components.
+      def consume_legacy!(segment, attrs, urn)
+        match = LEGACY_RE.match(segment)
+        key = LEGACY_KEYS.fetch(match[1]) do
           raise Pubid::Errors::UrnParseError,
                 "Unexpected segment #{segment.inspect} in #{urn.inspect}"
         end
 
-        render.call(value)
+        store_legacy!(attrs, key, match[2], urn)
+      end
+
+      def store_legacy!(attrs, key, value, urn)
+        sub = /\A([A-Z])-(\d+)\z/.match(value) if key == :appendix
+        return store!(attrs, key, value, urn) unless sub
+
+        store!(attrs, :appendix, sub[1], urn)
+        store!(attrs, :appendix_subnumber, sub[2], urn)
+      end
+
+      def store!(attrs, key, value, urn)
+        raise_if_duplicate(key, attrs, urn)
+        attrs[key] = value
+      end
+
+      def raise_if_duplicate(key, attrs, urn)
+        return unless attrs[key]
+
+        raise Pubid::Errors::UrnParseError,
+              "Duplicate #{key} segment in #{urn.inspect}"
       end
     end
   end

data/lib/pubid/iso/CLAUDE.md

@@ -46,6 +46,38 @@
   different attributes — the first pass stripped `edition.number.value` too,
   and two corrigendum examples caught it.
 
+- **URN item paths and document versions are cut, not parsed (issue #645).**
+  Glossarist-rendered corpora cite parent documents with URNs like
+  `urn:iso:std:iso:10303:-2:ed-1:v1:en:tech:ACTIVITY_MIM` and a duplicated
+  `:tech:X:tech:X:X` extraction tail. Neither tail is document identity, so
+  `UrnParser` drops both: the bare document-version token (`v1` right after
+  `ed-N` — the base identifier has no version attribute, and before this fix
+  the supplement loop consumed it as a type-less supplement number, which
+  wrapped the document as that phantom supplement and collapsed
+  "ISO 10303-2" to "ISO 1"), and the item path, cut at the first
+  supplement-loop token that can be nothing else (`item_path_segment?`).
+  Two invariants to keep when editing this loop:
+  **the cut's allow-list must mirror exactly what the loop consumes** —
+  `stage-`, a bare typed-stage abbr, the `ABBR.N` form, a supplement type,
+  digits, a `\Av\d` version, or a language field (`LANGUAGE_FIELD_RE`,
+  2-3-letter ISO 639 codes, comma-separated). A token allowed through that
+  no branch consumes spins the loop forever: the language branch used to be
+  the loose catch-all that guaranteed progress, and gating it on
+  `LANGUAGE_FIELD_RE` (so item-path segments stop overwriting the base
+  language as a bogus "(ACTIVITY_MIM)" suffix) removed that guarantee —
+  `FDAM.3` in `urn:iso:std:iso:17301:-1:FDAM.3:amd:2022:v1.3` exposed it.
+  That is also why the loop gained an explicit `ABBR.N` arm: the base stage
+  block deliberately skips a supplement-family stage when its own supplement
+  follows, and the loop had to consume the token instead. It is consumed
+  **and dropped** — the supplement layer has no stage-iteration slot, and
+  the old catch-all carried it as a bogus base language visible only in the
+  generated URN (`…:fdam.3:amd:1:2022:v1` → now `…:amd:1:2022:v1`; the
+  locked `to_s` "ISO 17301-1/AMD 1:2022" is unchanged). Net effect:
+  `parse(render(parse(urn)))` round-trips for both item-path forms — the
+  face renders `(EN)` (a form the grammar accepts) instead of the
+  unparseable `(ACTIVITY_MIM)` — and identifiers without an item path
+  render byte-identically. No grammar or renderer change was needed.
+
 - **Typed model bindings (Phase D): the builder consumes the grammar's bound
   map, not a parse tree.** `Identifier.parse` and `Normalizer` parse through
   `Pubid::Parg::Model.bound(:iso, …)`; `UrnParser#build_identifier` constructs

data/lib/pubid/iso/urn_parser.rb

@@ -55,6 +55,12 @@ module Pubid
         "data" => :data,
       }.freeze
 
+      # An ISO 639 language field: 2-3 letter codes, comma-separated
+      # ("en", "fr", "en,fr"). Item-path segments ("tech", "ACTIVITY_MIM")
+      # do not match it and are cut as the URN's item path instead
+      # (issue #645).
+      LANGUAGE_FIELD_RE = /\A[a-zA-Z]{2,3}(?:,[a-zA-Z]{2,3})*\z/
+
       # Parse ISO URN string
       # @param urn [String] URN string to parse
       # @return [Identifier] parsed identifier
@@ -126,12 +132,21 @@ module Pubid
           edition = parts.shift.sub("ed-", "").to_i
         end
 
+        # RFC 5141-bis document version token ("v1" in "…:ed-1:v1:en"). The
+        # base identifier has no version attribute -- the edition is the
+        # version axis -- so the token is dropped here, before the
+        # supplement loop mistakes it for a type-less supplement number,
+        # which wrapped the document as that phantom supplement and
+        # collapsed "ISO 10303-2" to "ISO 1" (issue #645).
+        parts.shift if parts.first&.match?(/\Av\d/)
+
         # Parse language if present (2-letter codes like "en" or comma-separated)
         languages = nil
         if parts.first && !parts.first.match(/^\d+$/) &&
             !parts.first.match?(/^(amd|cor|sup|add|v\d+|stage-|ed-)/i) &&
             !TYPED_STAGE_REVERSE_MAP.key?(parts.first.upcase) &&
-            !parts.first.match?(/^[A-Z]+\.\d+$/i)
+            !parts.first.match?(/^[A-Z]+\.\d+$/i) &&
+            parts.first.match?(LANGUAGE_FIELD_RE)
           languages = parse_languages(parts.shift)
         end
 
@@ -181,6 +196,17 @@ module Pubid
         # Check for supplements (amd, cor, sup, add)
         supplements = []
         while parts.any?
+          # Item path (issue #645): trailing URN segments naming a resource
+          # inside the document ("...:en:tech:ACTIVITY_MIM", and the
+          # Glossarist-era duplicated ":tech:X:tech:X:X" extraction
+          # tails). They are not document identity: the first token that
+          # cannot be a stage, supplement field, version or language
+          # starts the path, and it and everything after it are dropped so
+          # the duplication cannot derail the fields parsed before it.
+          if item_path_segment?(parts.first)
+            break
+          end
+
           supp_type = nil
           supp_number = nil
           supp_version = nil
@@ -194,6 +220,16 @@ module Pubid
           elsif TYPED_STAGE_REVERSE_MAP.key?(parts.first&.upcase)
             supp_stage_abbr = parts.shift.upcase
             supp_stage = TYPED_STAGE_REVERSE_MAP[supp_stage_abbr]
+          elsif parts.first&.match?(/\A[A-Za-z]+\.\d+\z/) &&
+              TYPED_STAGE_REVERSE_MAP.key?(parts.first.upcase.split(".").first)
+            # "FDAM.3" -- a supplement-family stage abbreviation with an
+            # iteration, meant for the supplement that follows
+            # ("...:FDAM.3:amd:..."). The supplement layer has no
+            # stage-iteration slot, so the token is consumed here and
+            # dropped: the previous catch-all language branch carried it
+            # as a bogus base language, surfacing only in the generated
+            # URN (issue #645).
+            parts.shift
           end
 
           # Check for supplement type (amd, cor, sup, add)
@@ -218,8 +254,8 @@ module Pubid
           # the NUMBER. The RFC 5141 additive extension ("amd:1:2007:v2")
           # keeps the number in its own slot, so a v-token after a number
           # is the true <supplversion>.
-          if parts.first&.start_with?("v")
-            version_str = parts.shift.sub("v", "")
+          if parts.first&.match?(/\Av\d/)
+            version_str = parts.shift.delete_prefix("v")
             value = version_str.split(".").first.to_i
             if supp_number.nil?
               supp_number = value
@@ -236,8 +272,8 @@ module Pubid
           # A v-token after the year ("amd:1:2007:v1") would otherwise be
           # left for the next loop iteration, wrapping a type-less
           # supplement around the real one and losing the base.
-          if parts.first&.start_with?("v")
-            version_str = parts.shift.sub("v", "")
+          if parts.first&.match?(/\Av\d/)
+            version_str = parts.shift.delete_prefix("v")
             value = version_str.split(".").first.to_i
             if supp_number.nil?
               supp_number = value
@@ -248,7 +284,9 @@ module Pubid
 
           # Check for language after supplement
           supp_languages = nil
-          if parts.first && !parts.first.match(/^\d+$/) && !parts.first.match?(/^(amd|cor|sup|add|v\d+|stage-)/i)
+          if parts.first && !parts.first.match(/^\d+$/) &&
+              !parts.first.match?(/^(amd|cor|sup|add|v\d+|stage-)/i) &&
+              parts.first.match?(LANGUAGE_FIELD_RE)
             supp_languages = parse_languages(parts.shift)
           end
 
@@ -270,6 +308,25 @@ module Pubid
 
       private
 
+      # True when the token can only be an item-path segment (issue #645):
+      # it is not a stage, supplement type, number/year, version or
+      # language field, so it -- and everything after it -- names a
+      # resource inside the document rather than a component of the
+      # identifier. The allow-list mirrors exactly what the supplement
+      # loop can consume, so every token it lets through makes progress.
+      def item_path_segment?(token)
+        return false if token.nil?
+        return false if token.match?(/\A\d+\z/)
+        return false if token.match?(/\Av\d/)
+        return false if token.start_with?("stage-")
+        return false if TYPED_STAGE_REVERSE_MAP.key?(token.upcase)
+        return false if token.match?(/\A[A-Za-z]+\.\d+\z/) &&
+                        TYPED_STAGE_REVERSE_MAP.key?(token.upcase.split(".").first)
+        return false if SUPPLEMENT_TYPE_MAP.key?(token.downcase)
+
+        !token.match?(LANGUAGE_FIELD_RE)
+      end
+
       # Helper to find IS-type TypedStage by harmonized stage code
       # Used when URN doesn't specify a type code (defaults to IS)
       # Prefers the most specific (non-published) stage

data/lib/pubid/jis/CLAUDE.md

@@ -11,10 +11,15 @@
   jis_identifier`. The WES branch is `"WES" space number parts …` with the same
   tail as JIS (year, `R`, language, 規格群, supplements, SYMBOL) and binds a
   `wes` capture, which the builder keys on. `JIS WES 7700` and `WES X 7700`
-  are rejected: the JIS prefix and a series letter belong only to JIS. The
-  source of record is pubid/pubid-grammar; the artifact was rebaked here with
-  parsanol **1.3.114** — the PATH `parsanol` shim may be a newer version, so
-  bake with the 1.3.114 gem's `exe/parsanol` and check `compiler_version`.
+  are rejected: the JIS prefix and a series letter belong only to JIS.
+- **The artifact is vendored, not baked here.** `data/parg/jis.json` is a
+  verbatim copy of pubid/pubid-grammar `artifacts/jis.json` (main `31fb965`,
+  parsanol **1.3.121**). Change the grammar there and copy the artifact back;
+  `spec/pubid/jis/parg_reaffirmed_spec.rb` pins its `source_hash`, so a local
+  rebake fails that spec.
+- **`reaffirmed` binds the whole run of R's** (`":1997R"` → `"R"`, `":1997RR"`
+  → `"RR"`; same for `amd_reaffirmed`/`corr_reaffirmed`). The builder reads
+  each only for truth (`true if data[:reaffirmed]`), so `RR` renders as `R`.
 - **`series` is nil** for WES (JIS keeps its `""`-coerced String), so the hash
   carries no `series` key. `number` is the bare number (`"7700"`), the index
   key.

data/lib/pubid/parg/backend.rb

@@ -24,7 +24,7 @@ module Pubid
         end
 
         to_builder_hash(Artifact.for(flavor).parse(entry, input), merge: merge_top_sequence)
-      rescue Parsanol::ParseFailed => e
+      rescue *ENGINE_ERRORS => e
         raise Pubid::Errors::ParseError.new(e.message, nil,
                                             input: input,
                                             flavor: registered_name(flavor))

data/lib/pubid/parg/model.rb

@@ -27,7 +27,7 @@ module Pubid
           source = all_parts ? input.sub(ALL_PARTS_PATTERN, "") : input
           hash = Artifact.for(flavor).parse_and_bind(entry, source)
           all_parts ? Backend.mark_all_parts(hash) : hash
-        rescue Parsanol::ParseFailed => e
+        rescue *ENGINE_ERRORS => e
           parse_error(e, input, flavor)
         end
 
@@ -38,12 +38,17 @@ module Pubid
           register(flavor, model_class, entry)
           model, all_parts = materialize(flavor, model_class, input)
           all_parts ? model.to_all_parts : model
-        rescue Parsanol::ParseFailed => e
+        rescue *ENGINE_ERRORS => e
           parse_error(e, input, flavor)
         end
 
         private
 
+        # The uniform error contract (CLAUDE.md "One error namespace"):
+        # every grammar/binding failure surfaces as Pubid::Errors::ParseError
+        # so `rescue Pubid::Errors::Error` stays exhaustive. Binding failures
+        # raise Parsanol::PARG::BindError (< PARG::Error, NOT ParseFailed) —
+        # left unrescued it escaped Pubid.parse raw (issue #646).
         def parse_error(error, input, flavor)
           raise Pubid::Errors::ParseError.new(
             error.message,

data/lib/pubid/parg.rb

@@ -1,9 +1,22 @@
 # frozen_string_literal: true
 
+require "parsanol"
+
 module Pubid
   module Parg
     autoload :Artifact, "pubid/parg/artifact"
     autoload :Backend, "pubid/parg/backend"
     autoload :Model, "pubid/parg/model"
+
+    # The engine errors a PG artifact can raise while parsing or binding an
+    # input. Every one of them must surface as Pubid::Errors::ParseError —
+    # the uniform error contract (CLAUDE.md "One error namespace") makes
+    # `rescue Pubid::Errors::Error` exhaustive, and a raw Parsanol class
+    # escaping Pubid.parse bypasses every such guard (issue #646: the JIS
+    # year forms raised Parsanol::PARG::BindError raw, which is NOT a
+    # Parsanol::ParseFailed). PARG::Error carries BindError
+    # (< ArtifactError < Error) and the PARG Parse/Compile/Artifact errors;
+    # Parsanol::ParseFailed is the ruby reference engine's parse failure.
+    ENGINE_ERRORS = [Parsanol::ParseFailed, Parsanol::PARG::Error].freeze
   end
 end

data/lib/pubid/tgpp/CLAUDE.md

@@ -41,3 +41,5 @@ keeps `#matches?(other, ignore:)`.
   paths and the strict comparison treats that `[]` and a nil alike — the
   same asymmetry the `initialize_empty` note above is about, seen from the
   matching side. relaton had two committed specs breaking on this.
+
+- **The flavor key is `:"3gpp"`, not the derived `:tgpp` (pubid#644)**: `PrefixesSupport#prefix_flavor_key` derives the key from the Ruby constant's name (`Pubid::Tgpp` → `:tgpp`), but the external key is "3gpp" — the registry registration, the `pubid:3gpp:*` `_type` namespace and the `urn:3gpp:` URN namespace all spell it with the digit. The derived mismatch made `Pubid.prefix_flavors` attribute the "3GPP" prefix to a key **nothing is registered under**, so the router's routing table resolved `Registry.get(:tgpp)` to `nil`, `candidates_by_prefix`'s `compact` silently dropped the owner, and `Pubid.parse("3GPP TS 38.101")` — which `Pubid::Tgpp.parse` handles fine (the prefixed spelling is a normalizing parse; canonical render drops the publisher, `with_publisher: true` puts it back) — lost its prefix-owner fallback and raised. The fix is a one-line `prefix_flavor_key` override in `lib/pubid/tgpp.rb` returning `:"3gpp"`; `Pubid.prefix_flavors["3GPP"]` now reads `[:\"3gpp\"]` and `Registry.canonical_name(Pubid::Tgpp)` answers the real key. The registry-driven tripwire `spec/pubid/parse_routing_spec.rb` ("resolves every prefix table entry to a registered flavor module") is the guard that turns any future key/registry mismatch of this shape red at the table level.

data/lib/pubid/tgpp.rb

@@ -16,6 +16,17 @@ module Pubid
     # excluded. The parser still accepts an optional leading "3GPP ".
     PREFIXES = ["3GPP"].freeze
 
+    # The external flavor key is "3gpp" (the registry key, the `pubid:3gpp:*`
+    # `_type` namespace and the `urn:3gpp:` URN namespace), but the default
+    # derivation spells it from the Ruby constant as :tgpp. That mismatch made
+    # {Pubid.prefix_flavors} attribute "3GPP" to a key nothing is registered
+    # under, so {Pubid}'s routing table resolved the prefix to no module and
+    # the "3GPP TS …" printed form lost its prefix-owner status (pubid#644).
+    # Return the real external key, matching the registry registration below.
+    def self.prefix_flavor_key
+      :"3gpp"
+    end
+
     autoload :Builder, "#{__dir__}/tgpp/builder"
     autoload :Identifier, "#{__dir__}/tgpp/identifier"
     autoload :Identifiers, "#{__dir__}/tgpp/identifiers"

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.4"
+  VERSION = "2.0.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.0.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-02 00:00:00.000000000 Z
+date: 2026-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -71,6 +71,7 @@ files:
 - data/parg/asme.json
 - data/parg/astm.json
 - data/parg/bipm.json
+- data/parg/bipm.parg
 - data/parg/bsi.json
 - data/parg/calconnect.json
 - data/parg/ccsds.json
@@ -93,6 +94,7 @@ files:
 - data/parg/ieee.json
 - data/parg/ietf.json
 - data/parg/iho.json
+- data/parg/iho.parg
 - data/parg/ire.json
 - data/parg/ire.parg
 - data/parg/isbn.json
@@ -109,6 +111,7 @@ files:
 - data/parg/oiml.json
 - data/parg/omg.json
 - data/parg/parg.json
+- data/parg/parg.parg
 - data/parg/plateau.json
 - data/parg/sae.json
 - data/parg/tables/bipm_groups.yaml