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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d61c7856e3a399a750ea5d73de7d370f32970f68a8dd66cda45a4ea4acc3f9d
-  data.tar.gz: de8c106c766b93318efde9b250d30b1eb4229d73124bb04741c3503a330c0b50
+  metadata.gz: 18402e85b2e19640920f3e216f62f704c6770a840f654d92f96d799b03fbda71
+  data.tar.gz: e9b1735e843fe5eb20574749d2581c19192799f86fe3f31a8e72b3d0a00ab047
 SHA512:
-  metadata.gz: e8a6e510b3344464c39a245057f0c9dd8819245e8f0dd8d391d814949ba22b678c1942586cb801d831c1c37bc4cadc30549d035ffcb0b148128628861678dfa1
-  data.tar.gz: af562497969b162c2c4d5a99591eb03c5cc86d3588d487c5ef84407eb6726e53edab78c0e09f090cc1c39386e5113c4b4032ab725f85ed7d881b752d6f358bf0
+  metadata.gz: 1cbcaa48b3fb036aca2a62aabe9cdfc4733ad030dc833aa31b5be2dbba433ef6459f87dc22c0b811e707687ce18ee966a2882f928a44d2d0df89e159df5ea837
+  data.tar.gz: 0ea8984849aa9f56a400948fb5ab7b29f5de122f70ab036d35fe344655abe70fbe9e34d9cdc04b80673593190b1479d8ac47b31bd21e056ad9b64fa6743e18e6

data/README.adoc

@@ -147,18 +147,35 @@ id.to_json
 
 === Import from Hash
 
+`Pubid.from_hash` is the hash counterpart of `Pubid.parse`. It builds the
+correct identifier class from a hash that `#to_hash` emits. You do not name
+the flavor: the `_type` key (`pubid:<flavor>:<type>`) identifies the class.
+
 [source,ruby]
 ----
-require 'pubid/iso'
+require 'pubid'
 
 hash = {
-  flavor: "iso",
-  publisher: "ISO",
-  number: "9001",
-  year: "2015"
+  "_type" => "pubid:iso:international-standard",
+  "number" => "9001",
+  "year" => "2015"
 }
-id = Pubid::Serializable.from_h(hash)
-id.to_s # => "ISO 9001:2015"
+id = Pubid.from_hash(hash)
+id.class # => Pubid::Iso::Identifiers::InternationalStandard
+id.to_s  # => "ISO 9001:2015"
+----
+
+For a row of a relaton-data `index-v2.yaml` file, give the identifier hash in
+the `:id` key of the row: `Pubid.from_hash(row[:id])`.
+
+A hash that is not an identifier hash raises `Pubid::Errors::InvalidInputError`
+(an `ArgumentError`). This occurs when the input is not a Hash, has no `_type`,
+or has a `_type` that no flavor defines.
+
+[source,ruby]
+----
+Pubid.from_hash({ "number" => "9001" })
+# => Pubid::Errors::InvalidInputError: identifier hash has no _type key: ...
 ----
 
 === Import from JSON
@@ -181,11 +198,15 @@ All identifiers support full round-trip conversion preserving all attributes:
 require 'pubid/iso'
 
 original = Pubid::Iso.parse("ISO 9001:2015/Amd 1:2020/Cor 1:2021")
-hash = original.to_h
-restored = Pubid::Serializable.from_h(hash)
+hash = original.to_hash
+# => {"_type" => "pubid:iso:corrigendum", "number" => "1", "year" => "2021",
+#     "base" => {"_type" => "pubid:iso:amendment", "number" => "1", "year" => "2020",
+#       "base" => {"_type" => "pubid:iso:international-standard",
+#                  "number" => "9001", "year" => "2015"}}}
+restored = Pubid.from_hash(hash)
 
 restored.to_s # => "ISO 9001:2015/Amd 1:2020/Cor 1:2021"
-restored.to_urn # => "urn:iso:std:iso:9001:amd:2020:cor:2021:v1"
+restored.to_urn # => "urn:iso:std:iso:9001:amd:2020:v1:cor:2021:v1"
 ----
 
 == Utility Methods
@@ -1756,7 +1777,8 @@ require 'pubid'
 
 # update_codes.yaml: "NBS HB: NIST HB"
 id = Pubid::Nist.parse("NBS HB 105-1")
-id.to_s  # => "NIST HB 105-1" (NBS→NIST correction applied)
+id.to_s  # => "NBS HB 105-1" (NBS identity preserved - documents published
+         # by NBS, i.e. before/equal 1988, keep their NBS identifiers forever)
 
 # update_codes.yaml: "FIPS.140-2: FIPS 140-2" (normalizes dotted format)
 id = Pubid::Nist.parse("FIPS.140-2")

data/conformance/pending.yaml

@@ -0,0 +1,4 @@
+# Cases this implementation explicitly cannot handle yet.
+# Rules: entries need reason + ref; a pending case that passes raises
+# the pending-satisfied alarm and MUST be unmarked (TODO.correct-test-suite/04).
+---

data/lib/pubid/adobe/identifier.rb

@@ -16,12 +16,10 @@ module Pubid
       # Parse an Adobe identifier string into an identifier object.
       # @param identifier [String]
       # @return [Pubid::Adobe::Identifier]
-      # @raise [Parslet::ParseFailed] If parsing fails
+      # @raise [Pubid::Errors::ParseError] If parsing fails
       def self.parse(identifier)
         parsed = Parser.parse(identifier)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse Adobe identifier '#{identifier}': #{e.message}"
       end
 
       attribute :publisher, :string, default: "Adobe"

data/lib/pubid/adobe/parser.rb

@@ -21,7 +21,7 @@ module Pubid
     #   ATN5014                        (short alias)
     #   5014                           (bare number; data-repo context)
     #   adobe-glyph-list               (bare slug)
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
 
       root :identifier
@@ -119,7 +119,15 @@ module Pubid
       # @param string [String]
       # @return [Hash]
       def self.parse(string)
-        raise ArgumentError, ::Pubid::INPUT_TOO_LONG_MESSAGE if string.length > ::Pubid::MAX_INPUT_LENGTH
+        unless string.is_a?(String)
+          raise ::Pubid::Errors::InvalidInputError,
+                ::Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if string.length > ::Pubid::MAX_INPUT_LENGTH
+          raise ::Pubid::Errors::InvalidInputError,
+                ::Pubid::INPUT_TOO_LONG_MESSAGE
+        end
 
         new.parse(string.strip)
       end

data/lib/pubid/adobe.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Adobe
     extend Pubid::PrefixesSupport

data/lib/pubid/amca/builder.rb

@@ -78,7 +78,7 @@ module Pubid
         if parsed[:code_with_year]
           code_year_data = parsed[:code_with_year]
           if code_year_data && code_year_data[:code]
-            attributes[:code] =
+            attributes[:number] =
               extract_value(code_year_data[:code])
           end
           if code_year_data && code_year_data[:year]
@@ -86,7 +86,7 @@ module Pubid
               extract_value(code_year_data[:year])
           end
         elsif parsed[:code]
-          attributes[:code] = extract_value(parsed[:code])
+          attributes[:number] = extract_value(parsed[:code])
         end
 
         # Extract year if not already extracted from code_with_year

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

@@ -6,12 +6,19 @@ module Pubid
     # Pubid::Amca::Identifier; common
     # functionality for all AMCA identifier types.
     class Identifier < ::Pubid::Identifier
-      # @raise [Parslet::ParseFailed] If parsing fails
+      # @raise [Pubid::Errors::ParseError] If parsing fails
       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 Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         parsed = Parser.parse(identifier)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse ACMA identifier '#{identifier}': #{e.message}"
       end
 
       # Stored as a plain string (always "AMCA") so it round-trips through
@@ -19,22 +26,40 @@ module Pubid
       # serialize a String against the Components::Publisher attribute and raise.
       attribute :publisher, :string, default: -> { "AMCA" }
       attribute :copublisher, :string
-      attribute :code, Components::Code
-      attribute :year, Components::Date
+      # The document number used to live in AMCA's own `code` attribute, leaving
+      # the `number` inherited from ::Pubid::Identifier nil — so relaton-index,
+      # which sorts and bsearches on `id.root.number.to_s`, keyed every AMCA row
+      # on "". `code` is gone; each LEAF now declares `attribute :number,
+      # :string` (see standard.rb / publication.rb / interpretation.rb).
+      #
+      # It is declared on the leaves, never here: this class is inherited by all
+      # three of them, and redefining the parent's Components::Code-typed
+      # `number` on an inherited-from class resolves nondeterministically under
+      # multi-flavor load. Do not reintroduce `code`, and do not move `number`
+      # up here.
+      #
+      # A bare 2-digit edition year ("21", "02"). Declared :string, not
+      # Components::Date: the builder assigns a String and lutaml does not cast
+      # it, so a Date declaration left the PARSE path holding a String while
+      # from_hash produced a Components::Date — making
+      # `parse(x) == from_hash(parse(x).to_hash)` false for every AMCA id and
+      # breaking #matches?, which is built on ==. to_hash and to_s agreed, so
+      # the relaton index gate never caught it.
+      attribute :year, :string
       attribute :suffix, :string
       attribute :reaffirmed, :string
 
       # Explicit key_value mapping: only these keys serialize (the inherited
       # Pubid::Identifier attributes — including :type, which subclasses expose
       # as a class-metadata Hash via `self.type` — are intentionally dropped).
-      # code/year are flattened to their scalar value and rebuilt on load, since
-      # the Builder may store them as either a String or a component.
+      # Every mapped attribute is a plain scalar, so no custom converters are
+      # needed; the canonical to_hash already drops empty and default values.
       key_value do
         map "_type", to: :_type
         map "publisher", to: :publisher
         map "copublisher", to: :copublisher
-        map "code", with: { to: :code_to_kv, from: :code_from_kv }
-        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "number", to: :number
+        map "year", to: :year
         map "suffix", to: :suffix
         map "reaffirmed", to: :reaffirmed
       end
@@ -43,28 +68,25 @@ module Pubid
         UrnGenerator.new(self).generate
       end
 
-      def code_to_kv(model, doc)
-        v = model.code.is_a?(::Pubid::Components::Code) ? model.code.value : model.code
-        return if v.nil? || v.to_s.empty?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("code", v.to_s))
-      end
-
-      def code_from_kv(model, value)
-        model.code = ::Pubid::Components::Code.new(value: value.to_s)
-      end
-
-      def year_to_kv(model, doc)
-        y = model.year.is_a?(::Pubid::Components::Date) ? model.year.year : model.year
-        return if y.nil? || y.to_s.empty?
+      # AMCA models its document type as class metadata (`self.type`), not as a
+      # `typed_stage`, so the base `mr_type` hook found nothing. Without it an
+      # interpretation and the standard it interprets share a slug — and
+      # `to_slug` is an output FILENAME. Before the index columns landed the
+      # whole flavor collapsed onto two slugs ("amca" and "").
+      def mr_type
+        return nil unless self.class.respond_to?(:type)
 
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("year", y.to_s))
+        self.class.type[:key]&.to_s
       end
 
-      def year_from_kv(model, value)
-        model.year = ::Pubid::Components::Date.new(year: value.to_s)
+      # AMCA keeps the edition in its own `year` string, not in the inherited
+      # `date`, so the base `mr_year` hook read nil and two editions of one
+      # standard — "ANSI/AMCA 300-14" and "ANSI/AMCA Standard 300-24" —
+      # produced the same slug. Same shape as the BIPM year recorded in
+      # CLAUDE.md.
+      def mr_year
+        year&.to_s
       end
     end
-
   end
 end

data/lib/pubid/amca/identifiers/interpretation.rb

@@ -9,16 +9,24 @@ module Pubid
       # - AMCA 204 – 1
       # - ANSI/AMCA 204 Interp
       class Interpretation < Identifier
-        attr_reader :interpretation_code
+        attribute :number, :string
 
-        def initialize(code:, year: nil, copublisher: nil, suffix: nil,
-reaffirmed: nil, interpretation_code: nil)
-          @code = Components::Code.new(value: code.to_s)
-          @year = Components::Date.new(year: year.to_s) if year
-          @copublisher = copublisher
-          @suffix = suffix
-          @reaffirmed = reaffirmed
-          @interpretation_code = interpretation_code
+        # See Publication: the hand-written keyword initializer bypassed lutaml,
+        # costing this class its `_type`, its `publisher` default and the
+        # serialization of `interpretation_code`.
+        attribute :interpretation_code, :string
+
+        key_value do
+          map "interpretation_code", to: :interpretation_code
+        end
+
+        # The interpretation letter is what distinguishes one interpretation of
+        # a standard from another ("AMCA 99 JW Interp" vs "AMCA 99 KB Interp" —
+        # different documents, and #== agrees). It is in `==` and in `to_s`, so
+        # it must reach the slug too, or three interpretations of standard 99
+        # share one filename.
+        def mr_number_with_part
+          mr_join(super, interpretation_code&.to_s&.downcase)
         end
 
         def self.type

data/lib/pubid/amca/identifiers/publication.rb

@@ -9,16 +9,20 @@ module Pubid
       # - AMCA Publication 311-16
       # - AMCA Publication 1011-03 (R2010)
       class Publication < Identifier
-        attr_reader :revision
+        attribute :number, :string
 
-        def initialize(code:, year:, copublisher: nil, suffix: nil,
-reaffirmed: nil, revision: nil)
-          @code = Components::Code.new(value: code.to_s)
-          @year = Components::Date.new(year: year.to_s) if year
-          @copublisher = copublisher
-          @suffix = suffix
-          @reaffirmed = reaffirmed
-          @revision = revision
+        # Was a hand-written keyword initializer assigning ivars directly,
+        # which bypassed lutaml entirely. Three things broke as a result: no
+        # `_type` was emitted (so Identifier.from_hash could not route back to
+        # this class), the `publisher` default never materialised, and
+        # `revision` was a plain attr_reader that to_hash dropped. Removing it
+        # — and making `revision` a real attribute — is the AIEE/IRE/NESC
+        # migration applied here; the builder already calls `new(**attributes)`
+        # exactly as it does for Standard, which never had this problem.
+        attribute :revision, :string
+
+        key_value do
+          map "revision", to: :revision
         end
 
         def self.type

data/lib/pubid/amca/identifiers/standard.rb

@@ -9,6 +9,8 @@ module Pubid
       # - ANSI/AMCA Standard 99-25
       # - AMCA Standard 803-02 (R2008)
       class Standard < Identifier
+        attribute :number, :string
+
         def self.type
           { key: :standard, title: "Standard", short: nil }
         end

data/lib/pubid/amca/parser.rb

@@ -4,7 +4,7 @@ module Pubid
   module Amca
     # Parser class for ACMA identifiers
     # Single Responsibility: Parsing ACMA identifier syntax
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:space?) { space.maybe }

data/lib/pubid/amca/renderer.rb

@@ -35,14 +35,14 @@ module Pubid
         if t.is_a?(Hash) && t[:title]
           parts << t[:title].to_s
         end
-        parts << id.code.to_s
+        parts << id.number.to_s
         parts << "-#{id.year}" if id.year
 
         result = parts.compact.join(" ")
 
         if id.copublisher&.include?("/") && id.year
           type_title = t.is_a?(Hash) ? t[:title].to_s : ""
-          result = "#{id.copublisher} #{type_title} #{id.code}-#{id.year}"
+          result = "#{id.copublisher} #{type_title} #{id.number}-#{id.year}"
         end
 
         result += " (#{id.reaffirmed})" if id.reaffirmed
@@ -54,7 +54,7 @@ module Pubid
         parts = []
         parts << id.copublisher if id.copublisher
         parts << "Publication"
-        parts << id.code.to_s
+        parts << id.number.to_s
         parts << "-#{id.year}" if id.year
         parts << " (Rev. #{id.revision})" if id.revision
         parts << " (#{id.reaffirmed})" if id.reaffirmed && !id.revision
@@ -65,7 +65,7 @@ module Pubid
       def render_interpretation(id)
         parts = []
         parts << id.copublisher if id.copublisher
-        parts << id.code.to_s
+        parts << id.number.to_s
 
         if id.interpretation_code
           parts << "– #{id.interpretation_code}"

data/lib/pubid/amca/urn_generator.rb

@@ -4,9 +4,9 @@ module Pubid
   module Amca
     class UrnGenerator < Pubid::UrnGenerator::Base
       def urn_number
-        return nil unless identifier.code
+        return nil unless identifier.number
 
-        identifier.code.to_s
+        identifier.number.to_s
       end
 
       def urn_year

data/lib/pubid/amca.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Amca
     extend Pubid::PrefixesSupport
@@ -20,7 +21,7 @@ module Pubid
     # Parse an ACMA identifier string into an identifier object
     # @param identifier [String] The ACMA identifier string to parse
     # @return [Pubid::Amca::Identifier] The appropriate identifier object
-    # @raise [Parslet::ParseFailed] If parsing fails
+    # @raise [Pubid::Errors::ParseError] If parsing fails
     def self.parse(identifier)
       Identifier.parse(identifier)
     end

data/lib/pubid/ansi/builder.rb

@@ -36,8 +36,8 @@ module Pubid
           main_number = main_and_parts[0]
           part_number = main_and_parts[1]
           {
-            number: Components::Code.new(value: main_number),
-            part: part_number ? Components::Code.new(value: part_number) : nil,
+            number: main_number,
+            part: part_number,
           }.compact
         when :date
           Components::Date.new(year: value.to_s)

data/lib/pubid/ansi/identifier.rb

@@ -4,7 +4,25 @@ module Pubid
   module Ansi
     # Base ANSI identifier class
     class Identifier < ::Pubid::Identifier
+      # `number`/`part`/`subpart` are declared here rather than inherited as a
+      # Components::Code: ANSI stores a bare string in every one of them.
+      # Declaring on this class is safe because its body lives in this one file
+      # and is never reopened, so every subclass body opens after it has run
+      # (lutaml deep-dups the parent attribute table at class-definition time).
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
+
       def self.parse(string)
+        unless string.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         parsed = Pubid::Ansi::Parser.new.parse(string)
         Pubid::Ansi::Builder.new.build(parsed)
       end

data/lib/pubid/ansi/parser.rb

@@ -4,7 +4,7 @@ module Pubid
   module Ansi
     # Parser for ANSI (American National Standards Institute) identifiers
     # Examples: ANSI X3.4-1986, ANSI C63.4-2014, ANSI/ISO 9899:1990
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 

data/lib/pubid/ansi/renderer.rb

@@ -37,8 +37,8 @@ module Pubid
 
       def number_portion(id, context)
         [
-          id.number.render(context:),
-          (id.part ? "-#{id.part.render(context:)}" : ""),
+          id.number,
+          (id.part ? "-#{id.part}" : ""),
           (id.date ? ":#{id.date.render(context:)}" : ""),
         ].join
       end

data/lib/pubid/ansi.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Ansi
     extend Pubid::PrefixesSupport
@@ -21,12 +22,11 @@ module Pubid
     # Parse an ANSI identifier string
     # @param identifier [String] the identifier string to parse
     # @return [Identifier] the parsed identifier
+    # Delegate to the class method rather than repeating the parser/builder
+    # sequence, so the input guards live in one place and the two entry points
+    # cannot drift apart.
     def self.parse(identifier)
-      parser = Parser.new
-      builder = Builder.new
-
-      parsed = parser.parse(identifier)
-      builder.build(parsed)
+      Identifier.parse(identifier)
     end
 
     # Per-flavor format registry: inherits global formats, overrides :human

data/lib/pubid/api/builder.rb

@@ -30,15 +30,29 @@ module Pubid
         # identifier attribute (the concrete class is pinned by `_type`). Drop it
         # so the raw Parslet::Slice never lands in the inherited :type attribute.
         when :type then nil
-        when :number then Components::Code.new(value: value.to_s)
         when :reaffirmation
           value.is_a?(Hash) ? (value[:year] || value).to_s : value.to_s
-        when :part, :chapter, :section, :subsection, :year
+        # Every remaining key is a bare scalar. `:chapter` is a PARSE-TREE key
+        # and keeps its name in the grammar; the ATTRIBUTE it feeds is `number`
+        # (see handle_key below), which this branch retyped from
+        # Components::Code to :string — so it now casts like the rest.
+        when :number, :chapter, :part, :section, :subsection, :year
           value.to_s
         else
           super
         end
       end
+
+      # Route the MPMS chapter into the `number` attribute. The shared
+      # assign_attributes loop uses the parse-tree key as the setter name and
+      # silently skips a key that is not an attribute, so without this the
+      # chapter would simply vanish once `attribute :chapter` was removed.
+      def handle_key(identifier, key, value)
+        return super unless key.to_sym == :chapter
+
+        identifier.number = value
+        true
+      end
     end
   end
 end

data/lib/pubid/api/identifier.rb

@@ -7,14 +7,35 @@ module Pubid
     # `is_a?(Pubid::Api::Identifier)` natively and gets the shared polymorphic
     # `from_hash` (no facade needed).
     class Identifier < ::Pubid::Identifier
+      # `number`/`part`/`subpart` are declared here rather than inherited as a
+      # Components::Code: API stores a bare string in every one of them.
+      # Declaring on this class is safe because its body lives in this one file
+      # and is never reopened, so every subclass body opens after it has run
+      # (lutaml deep-dups the parent attribute table at class-definition time).
+      # `code` keeps its Components::Code type on SingleIdentifier - it is not
+      # one of the three attributes the shared base declares.
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
+
       def self.parse(input)
-        # Filter out comments
-        return nil if input.start_with?("#")
+        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
 
+        # There used to be a `return nil if input.start_with?("#")` here, to
+        # skip the comment lines of a fixture file. A comment is not an
+        # identifier, so it must be rejected like any other unparseable string:
+        # this was the one public parse in the gem that could return nil, which
+        # a caller reading `id.to_s` sees as a NoMethodError far from the cause.
+        # Both API fixture loaders already drop `#` lines themselves.
         tree = Parser.new.parse(input)
         Builder.new.build(tree)
-      rescue Parslet::ParseFailed => e
-        raise e
       end
     end
   end

data/lib/pubid/api/identifiers/mpms.rb

@@ -4,20 +4,22 @@ module Pubid
   module Api
     module Identifiers
       class Mpms < Base
-        attribute :chapter, :string
+        # The MPMS chapter IS the document number — "API MPMS CH 12.2" is
+        # chapter 12, section 2 — so it lives in the `number` inherited from
+        # ::Pubid::Identifier, which every other API type already sets. It used
+        # to sit in a separate `chapter` :string, leaving `number` nil, so all
+        # 30 MPMS ids keyed "" for relaton-index.
+        #
+        # `section`/`subsection` stay as sibling part columns, which is what
+        # gives the bucket semantics a part-less reference needs: every section
+        # of chapter 12 shares the key "12". `CH` is a literal marker in the
+        # renderer and was never part of the value.
         attribute :section, :string
         attribute :subsection, :string
 
         def type_string
           "MPMS"
         end
-
-        private
-
-        def code_portion
-          # Override - MPMS doesn't use code_portion
-          nil
-        end
       end
     end
   end

data/lib/pubid/api/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Api
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:dash) { str("-") }