pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/adobe/urn_generator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    # Generates URN strings for Adobe identifiers.
+    #
+    # Format:
+    #   urn:adobe:tech-note:<number>            e.g. urn:adobe:tech-note:5014
+    #   urn:adobe:publication:<slug>[:v<ver>]   e.g. urn:adobe:publication:adobe-glyph-list
+    #                                             urn:adobe:publication:adobe-japan1:v7
+    class UrnGenerator
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        if identifier.is_a?(Identifiers::TechNote)
+          generate_tech_note
+        elsif identifier.is_a?(Identifiers::Publication)
+          generate_publication
+        else
+          raise ArgumentError,
+                "Unknown Adobe identifier class: #{identifier.class}"
+        end
+      end
+
+      private
+
+      def generate_tech_note
+        "urn:adobe:tech-note:#{identifier.number}"
+      end
+
+      def generate_publication
+        parts = ["urn:adobe:publication", identifier.slug]
+        parts << "v#{identifier.version}" if identifier.version
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/adobe/urn_parser.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Adobe
+    # Parses Adobe URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:adobe:tech-note:<number>
+    #   urn:adobe:publication:<slug>[:v<version>]
+    #
+    # Examples:
+    #   urn:adobe:tech-note:5014                  → Adobe Technical Note #5014
+    #   urn:adobe:publication:adobe-glyph-list    → adobe-glyph-list
+    #   urn:adobe:publication:adobe-japan1:v7     → adobe-japan1-7
+    class UrnParser < Pubid::UrnParser::Base
+      PREFIX = "urn:adobe:".freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        namespace = parts.fetch(0)
+
+        case namespace
+        when "tech-note"
+          parse_tech_note(parts)
+        when "publication"
+          parse_publication(parts)
+        else
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Unknown Adobe URN namespace: #{namespace.inspect} in #{urn.inspect}"
+        end
+      end
+
+      private
+
+      def strip_namespace(urn)
+        unless urn.downcase.start_with?(PREFIX)
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid Adobe URN: #{urn.inspect}"
+        end
+
+        urn[PREFIX.length..]
+      end
+
+      def parse_tech_note(parts)
+        number = parts.fetch(1)
+        flavor_parse("Adobe Technical Note ##{number}")
+      end
+
+      def parse_publication(parts)
+        slug = parts.fetch(1)
+        version_seg = parts[2]
+        if version_seg&.start_with?("v")
+          flavor_parse("#{slug}-#{version_seg.sub(/\Av/, "")}")
+        else
+          flavor_parse(slug)
+        end
+      end
+
+      def split_parts(body)
+        body.split(":")
+      end
+
+      def flavor_parse(text)
+        ::Pubid::Adobe.parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/adobe.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "pubid"
+module Pubid
+  module Adobe
+    extend Pubid::PrefixesSupport
+
+    # Leading identifier prefix tokens that an Adobe document id can start
+    # with. Tech notes appear as both `Adobe Technical Note #<n>` and the
+    # short alias `ATN<n>` in citations; both must route to this flavor.
+    # Named publications start with `Adobe` (e.g. `Adobe Glyph List`,
+    # `Adobe-Japan1-7`).
+    PREFIXES = ["Adobe", "ATN"].freeze
+
+    autoload :Builder,      "#{__dir__}/adobe/builder"
+    autoload :Identifier,   "#{__dir__}/adobe/identifier"
+    autoload :Identifiers,  "#{__dir__}/adobe/identifiers"
+    autoload :Parser,       "#{__dir__}/adobe/parser"
+    autoload :Renderer,     "#{__dir__}/adobe/renderer"
+    autoload :UrnGenerator, "#{__dir__}/adobe/urn_generator"
+    autoload :UrnParser,    "#{__dir__}/adobe/urn_parser"
+
+    # Parse an Adobe identifier string into an identifier object.
+    # @param identifier [String]
+    # @return [Pubid::Adobe::Identifier]
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    # with the Adobe-specific renderer.
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Adobe::Renderer)
+
+    # Auto-discover identifier types from the Identifiers namespace.
+    # @return [Array<Class>]
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c < Pubid::Identifier }
+        .reject { |c| c == Identifier }
+    end
+
+    # Lookup: type key → identifier class
+    # @param code [String, Symbol]
+    # @return [Class, nil]
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: type short letter (e.g. "ATN") → identifier class
+    # @param short [String]
+    # @return [Class<Identifier>]
+    def self.identifier_klass_for_short(short)
+      @by_short ||= identifier_types.to_h { |klass| [klass.type[:short].to_s, klass] }
+      @by_short.fetch(short.to_s)
+    end
+  end
+end
+
+Pubid::Registry.register(:adobe, Pubid::Adobe)

data/lib/pubid/amca/builder.rb

@@ -7,7 +7,7 @@ module Pubid
     class Builder
       attr_reader :identifier_class
 
-      def initialize(identifier_class = Identifiers::Base)
+      def initialize(identifier_class = Identifier)
         @identifier_class = identifier_class
       end
 
@@ -46,7 +46,7 @@ module Pubid
 
       # Class method to build an identifier from parsed data
       # @param parsed [Hash, Array] the parsed identifier data
-      # @return [Identifiers::Base] the constructed identifier object
+      # @return [Identifier] the constructed identifier object
       def self.build(parsed)
         new.build(parsed)
       end
@@ -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/identifier.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
 # Pubid::Amca::Identifier is the AMCA base class (a real Pubid::Identifier
-# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
-# live in identifiers/base.rb. This file just ensures it is loaded.
-require_relative "identifiers/base"
+# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.

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

@@ -3,15 +3,22 @@
 module Pubid
   module Amca
     # Base identifier class for AMCA identifiers. Canonical name
-    # Pubid::Amca::Identifier (Identifiers::Base is a back-compat alias); common
+    # 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,33 +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?
+      # 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("code", v.to_s))
+        self.class.type[:key]&.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?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("year", y.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
-
-      def year_from_kv(model, value)
-        model.year = ::Pubid::Components::Date.new(year: value.to_s)
-      end
-    end
-
-    module Identifiers
-      # Backward-compatible alias: AMCA's base class used to be
-      # Pubid::Amca::Identifiers::Base. It is now Pubid::Amca::Identifier.
-      Base = Pubid::Amca::Identifier
     end
   end
 end

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

@@ -8,17 +8,25 @@ module Pubid
       # - AMCA 99 JW Interp
       # - AMCA 204 – 1
       # - ANSI/AMCA 204 Interp
-      class Interpretation < Base
-        attr_reader :interpretation_code
+      class Interpretation < Identifier
+        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

@@ -8,17 +8,21 @@ module Pubid
       # - AMCA Publication 211-22 (Rev. 01-23)
       # - AMCA Publication 311-16
       # - AMCA Publication 1011-03 (R2010)
-      class Publication < Base
-        attr_reader :revision
+      class Publication < Identifier
+        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

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

data/lib/pubid/amca/identifiers.rb

@@ -3,7 +3,6 @@
 module Pubid
   module Amca
     module Identifiers
-      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :Interpretation, "#{__dir__}/identifiers/interpretation"
       autoload :Publication, "#{__dir__}/identifiers/publication"
       autoload :Standard, "#{__dir__}/identifiers/standard"

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/single_identifier.rb

@@ -4,7 +4,7 @@ module Pubid
   module Amca
     # Base class for single (non-supplement) ACMA identifiers
     # Includes: Standard, Publication
-    class SingleIdentifier < Identifiers::Base
+    class SingleIdentifier < Identifier
     end
   end
 end

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
@@ -8,7 +9,7 @@ module Pubid
     # Pubid::JOINT_PREFIXES.
     PREFIXES = ["AMCA"].freeze
 
-    autoload :Identifier, "#{__dir__}/amca/identifier"
+    autoload :Identifier, "#{__dir__}/amca/identifiers/base"
     autoload :Identifiers, "#{__dir__}/amca/identifiers"
     autoload :Builder, "#{__dir__}/amca/builder"
     autoload :Parser, "#{__dir__}/amca/parser"
@@ -20,14 +21,14 @@ 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
 
     # Per-flavor format registry: inherits global formats, overrides :human
-    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifiers::Base.format_registry.register(:human, renderer: Amca::Renderer)
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Amca::Renderer)
 
     # Auto-discover all identifier types from the Identifiers namespace
     # @return [Array<Class>] identifier classes that define a self.type Hash

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