pubid 2.0.0.pre.alpha.3 → 2.0.0.pre.alpha.4

data/lib/pubid/nist/preprocessor.rb

@@ -53,6 +53,7 @@ module Pubid
       # Extracted so rubocop can scope length/ABC metrics narrowly.
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       def run_stages
+        normalize_spurious_u_suffix!
         normalize_publisher_and_series!
         normalize_lcirc_supplement_contexts!
         normalize_revision_spacing!
@@ -84,6 +85,17 @@ module Pubid
 
       private
 
+      # Strip the spurious "U" a bad v2 data migration prefixed onto real
+      # letter/revision suffixes (e.g. "800-38a" → "800-38Ua",
+      # "73-197r" → "73-197Ur"). NIST's authoritative records
+      # (allrecords.xml, DOIs) carry no such "U"; it exists only in the
+      # migrated corpus. Removing it here lets the remainder parse through
+      # the normal letter-suffix / revision path — "U<letter>" is never a
+      # real NIST suffix, so this only ever undoes the corruption.
+      def normalize_spurious_u_suffix!
+        @cleaned = @cleaned.gsub(/(\d)U([a-z])/, '\1\2')
+      end
+
       # Lowercase publishers, publisher+series concatenations, lowercase
       # series codes, and the lone "LC" → "LCIRC" expansion.
       def normalize_publisher_and_series!

data/lib/pubid/nist.rb

@@ -53,6 +53,10 @@ module Pubid
     # @param identifier [String] the identifier string to parse
     # @return [Identifiers::Base] the parsed identifier
     def self.parse(identifier)
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       # Use the Parser class's preprocessing method
       # Note: We call the class method directly to ensure preprocessing is applied
       parsed = Parser.class_parse_with_preprocessing(identifier)

data/lib/pubid/oiml/builder.rb

@@ -77,14 +77,21 @@ module Pubid
       end
 
       def build_supplement(parsed_hash)
-        # Determine supplement type
+        marker = parsed_hash[:trailing_marker].to_s if parsed_hash[:trailing_marker]
+
+        # Determine supplement type. The trailing word ("Amendment"/"Errata")
+        # selects the class; the concrete class then carries the word via
+        # #supplement_type, so only the `trailing` flag needs storing.
         supplement_class = if parsed_hash[:annex_letter] || parsed_hash[:annex_marker]
                              Identifiers::Annex
+                           elsif marker == "Errata"
+                             Identifiers::Errata
                            else
                              Identifiers::Amendment
                            end
 
         supplement = supplement_class.new
+        supplement.trailing = true if marker
 
         # Recursively parse base identifier
         if parsed_hash[:base_identifier]
@@ -103,6 +110,13 @@ module Pubid
         supplement.language = extract_language(parsed_hash[:language]) if parsed_hash[:language]
         supplement.letter = parsed_hash[:annex_letter].to_s if parsed_hash[:annex_letter]
 
+        # Annex with no year of its own but a dated base ("R 60:2017 Annexes"):
+        # the year belongs to the base and must render glued to it.
+        if supplement.is_a?(Identifiers::Annex) && !year_value &&
+            supplement.base_identifier&.date
+          supplement.year_on_base = true
+        end
+
         # Track if supplement itself was parsed with Edition format
         if parsed_hash[:edition_format]
           supplement.parsed_format = "long"
@@ -119,8 +133,8 @@ module Pubid
 
         identifier = identifier_class.new
 
-        # Handle code (number-part-subpart) specially
-        if parsed_hash[:number] || parsed_hash[:part] || parsed_hash[:subpart]
+        # Handle code (number-part-subpart-suffix) specially
+        if parsed_hash[:number] || parsed_hash[:part] || parsed_hash[:subpart] || parsed_hash[:code_suffix]
           code_attrs = {}
           if parsed_hash[:number]
             code_attrs[:number] =
@@ -131,6 +145,10 @@ module Pubid
             code_attrs[:subpart] =
               parsed_hash[:subpart].to_s
           end
+          if parsed_hash[:code_suffix]
+            code_attrs[:suffix] = parsed_hash[:code_suffix].to_s
+            code_attrs[:space_suffix] = true if parsed_hash.key?(:space_suffix)
+          end
           identifier.code = Components::Code.new(**code_attrs)
         end
 

data/lib/pubid/oiml/components/code.rb

@@ -13,11 +13,18 @@ module Pubid
         attribute :number, :string
         attribute :part, :string
         attribute :subpart, :string
+        # Free-form trailing suffix glued to the code, e.g. "sup", "A",
+        # "erratum", "GUM 1", "ISO3930". Preserved verbatim for round-trip.
+        attribute :suffix, :string
+        # When true the suffix is space-separated ("D 1 Brochure") rather than
+        # the default dash ("R 60-sup").
+        attribute :space_suffix, :boolean, default: false
 
         def to_s
           result = number.to_s
           result += "-#{part}" if part
           result += "-#{subpart}" if subpart
+          result += "#{space_suffix ? ' ' : '-'}#{suffix}" if suffix
           result
         end
 

data/lib/pubid/oiml/identifier.rb

@@ -3,6 +3,50 @@
 module Pubid
   module Oiml
     class Identifier < Pubid::Identifier
+      # Maps each concrete identifier's polymorphic_name => class name, so
+      # key_value (de)serialization can re-instantiate the correct subclass
+      # from the `_type` discriminator. Kept in sync with the Identifiers
+      # namespace by a spec assertion (see spec/pubid/oiml/to_hash_spec.rb).
+      OIML_TYPE_MAP = {
+        "pubid:oiml:recommendation" => "Pubid::Oiml::Identifiers::Recommendation",
+        "pubid:oiml:basic-publication" => "Pubid::Oiml::Identifiers::BasicPublication",
+        "pubid:oiml:document" => "Pubid::Oiml::Identifiers::Document",
+        "pubid:oiml:guide" => "Pubid::Oiml::Identifiers::Guide",
+        "pubid:oiml:vocabulary" => "Pubid::Oiml::Identifiers::Vocabulary",
+        "pubid:oiml:expert-report" => "Pubid::Oiml::Identifiers::ExpertReport",
+        "pubid:oiml:seminar-report" => "Pubid::Oiml::Identifiers::SeminarReport",
+        "pubid:oiml:amendment" => "Pubid::Oiml::Identifiers::Amendment",
+        "pubid:oiml:errata" => "Pubid::Oiml::Identifiers::Errata",
+        "pubid:oiml:annex" => "Pubid::Oiml::Identifiers::Annex",
+      }.freeze
+
+      # The base Pubid::Identifier no longer auto-maps attributes, so OIML must
+      # declare its own key_value mapping. SingleIdentifier and
+      # SupplementIdentifier (siblings) add their disjoint attribute deltas on
+      # top of this shared block. `type` is deliberately NOT mapped: OIML's
+      # `type` is a String-returning method (e.g. "R"), incompatible with the
+      # inherited Components::Type attribute — and the `_type` discriminator
+      # already pins the concrete subclass (and thus the type letter).
+      key_value do
+        map "_type", to: :_type, polymorphic_map: OIML_TYPE_MAP
+        map "language", to: :language
+        map "parsed_format", to: :parsed_format
+      end
+
+      # lutaml's polymorphic_map only validates `_type` on deserialization; it
+      # does not re-instantiate the concrete subclass. Route by `_type` so
+      # `Pubid::Oiml::Identifier.from_hash(h)` returns the right class (and its
+      # nested base_identifier), mirroring Pubid::Iso::Identifier.from_hash.
+      def self.from_hash(data, options = {})
+        type = data["_type"] || data[:_type]
+        klass_name = OIML_TYPE_MAP[type]
+        if klass_name
+          klass = Object.const_get(klass_name)
+          return klass.from_hash(data, options) unless klass == self
+        end
+        super
+      end
+
       def to_urn
         UrnGenerator.new(self).generate
       end

data/lib/pubid/oiml/identifiers/annex.rb

@@ -4,7 +4,16 @@ module Pubid
   module Oiml
     module Identifiers
       class Annex < SupplementIdentifier
-        attribute :letter, :string # For "Annex A", "Annex B", etc.
+        attribute :letter, :string # For "Annex A", "Annex B", "Annex B-C"
+        # True when the publication year is glued to the base ("OIML R 60:2017
+        # Annexes") rather than the marker ("OIML R 60 Annexes:2017"); drives
+        # exact round-trip in the renderer.
+        attribute :year_on_base, :boolean, default: false
+
+        key_value do
+          map "letter", to: :letter
+          map "year_on_base", to: :year_on_base
+        end
 
         def supplement_type
           letter ? "Annex #{letter}" : "Annexes"

data/lib/pubid/oiml/identifiers/errata.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      # Errata supplement, used by the trailing-word shorthand
+      # "OIML R 126:2015 Errata" (the publication year lives on the base).
+      class Errata < SupplementIdentifier
+        def supplement_type
+          "Errata"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers.rb

@@ -5,9 +5,9 @@ module Pubid
     module Identifiers
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
       autoload :Annex, "#{__dir__}/identifiers/annex"
-      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :BasicPublication, "#{__dir__}/identifiers/basic_publication"
       autoload :Document, "#{__dir__}/identifiers/document"
+      autoload :Errata, "#{__dir__}/identifiers/errata"
       autoload :ExpertReport, "#{__dir__}/identifiers/expert_report"
       autoload :Guide, "#{__dir__}/identifiers/guide"
       autoload :Recommendation, "#{__dir__}/identifiers/recommendation"

data/lib/pubid/oiml/parser.rb

@@ -18,7 +18,8 @@ module Pubid
 
       # Main identifier pattern - check supplements first
       rule(:identifier) do
-        amendment_identifier | amendment_short | annex_letter_identifier | annex_identifier | base_identifier
+        amendment_identifier | amendment_short | annex_letter_identifier |
+          annex_identifier | trailing_supplement_identifier | base_identifier
       end
 
       # Publisher - always "OIML"
@@ -30,14 +31,33 @@ module Pubid
       # Number with optional part and subpart
       rule(:number_only) { digits.as(:number) }
 
-      rule(:part_number) { dash >> digits.as(:part) }
+      # Part number, optionally a slashed multi-part continuation captured
+      # verbatim, e.g. "1/-2" in "OIML R 46-1/-2:2012".
+      rule(:part_number) do
+        dash >> (digits >> (slash >> dash >> digits).repeat).as(:part)
+      end
 
       rule(:subpart_number) { dash >> digits.as(:subpart) }
 
+      # Free-form named/lettered code suffix glued after the numeric part:
+      #   -GUM 1, -special, -sup, -erratum, -A, -ISO3930, -Amend, -Amended_2012
+      # plus the space-separated "Brochure" label. "GUM <n>" is tried first so
+      # its trailing number isn't lost to the bare-word alternative. The
+      # trailing `(_?digits)*` captures joint codes ("ISO3930") and the
+      # "Amended_2012" amendment label (the hand-off treats these as part
+      # suffixes, preserved verbatim for round-trip).
+      rule(:named_suffix) do
+        (dash >> (
+          (str("GUM") >> space >> digits) |
+          (match("[A-Za-z]").repeat(1) >> (str("_").maybe >> digits).repeat)
+        ).as(:code_suffix)) |
+          (space >> str("Brochure").as(:code_suffix) >> str("").as(:space_suffix))
+      end
+
       rule(:full_number) do
-        (number_only >> part_number >> subpart_number) |
-          (number_only >> part_number) |
-          number_only
+        (number_only >> part_number >> subpart_number >> named_suffix.maybe) |
+          (number_only >> part_number >> named_suffix.maybe) |
+          (number_only >> named_suffix.maybe)
       end
 
       # Edition number - ordinal numbers
@@ -82,8 +102,18 @@ module Pubid
       end
 
       # Language codes
+      #
+      # relaton-data-oiml encodes the publication language with its own code
+      # set (lib/oiml_fetcher.rb DOCID_LANG_CODE): single uppercase letters
+      # E F D R S C A U X, plus two-letter PO/PT/PE/SR. The two-letter OIML
+      # codes must be tried before the single-letter rule so e.g. "PE" isn't
+      # left with a dangling "E".
       rule(:lang_single) do
-        match("[EFRX]") # Single letter: E, F, R, X
+        match("[EFRXDSCAU]")
+      end
+
+      rule(:lang_multi_oiml) do
+        str("PO") | str("PT") | str("PE") | str("SR")
       end
 
       rule(:lang_multi) do
@@ -93,8 +123,9 @@ module Pubid
       rule(:language_code) do
         (
           (lang_single >> slash >> lang_single) | # E/F
-          lang_single |                          # E, F
-          lang_multi                             # en, fr
+          lang_multi_oiml |                        # PO, PT, PE, SR
+          lang_single |                            # E, F, D, R, S, C, A, U, X
+          lang_multi                               # en, fr
         ).as(:language)
       end
 
@@ -131,21 +162,37 @@ module Pubid
           language_portion.maybe.as(:language)
       end
 
-      # Annex identifier - "BASE Annexes Edition YYYY" or "BASE Annexes:YYYY"
+      # Trailing supplement word - "BASE Amendment" / "BASE Errata" where the
+      # publication year stays on the base (e.g. "OIML R 138:2009 Amendment").
+      # amendment_short is tried first; it only matches when a year follows the
+      # word, so the no-year trailing form falls through to here.
+      rule(:trailing_supplement_identifier) do
+        base_without_language.as(:base_identifier) >>
+          space >> (str("Amendment") | str("Errata")).as(:trailing_marker) >>
+          language_portion.maybe.as(:language)
+      end
+
+      # Annex identifier - "BASE Annexes Edition YYYY" / "BASE Annexes:YYYY" /
+      # "BASE:YYYY Annexes" (year on the base, no annex year).
       rule(:annex_identifier) do
         base_without_language.as(:base_identifier) >>
           space >> str("Annexes").as(:annex_marker) >>
           (
             (space >> edition_text >> space >> year_digits.as(:year)).as(:edition_format) |
             (colon >> year_digits.as(:year))
-          ) >>
+          ).maybe >>
           language_portion.maybe.as(:language)
       end
 
-      # Annex with letter - "BASE Annex A Edition YYYY"
+      # Annex letter or letter range, e.g. "A" or "B-C".
+      rule(:annex_letter_value) do
+        (match("[A-Z]") >> (dash >> match("[A-Z]")).maybe).as(:annex_letter)
+      end
+
+      # Annex with letter - "BASE Annex A Edition YYYY" / "BASE:YYYY Annex B-C"
       rule(:annex_letter_identifier) do
         base_without_language.as(:base_identifier) >>
-          space >> str("Annex") >> space >> match("[A-Z]").as(:annex_letter) >>
+          space >> str("Annex") >> space >> annex_letter_value >>
           ((space >> edition_text >> space >> year_digits.as(:year)) | (colon >> year_digits.as(:year))).maybe >>
           language_portion.maybe.as(:language)
       end

data/lib/pubid/oiml/renderer.rb

@@ -24,8 +24,6 @@ module Pubid
           render_supplement(id)
         when SingleIdentifier
           render_single(id)
-        when Identifiers::Base
-          render_base_identifier(id)
         else
           id.to_s
         end
@@ -38,6 +36,12 @@ module Pubid
           (id.parsed_format == "long" ? :long : :short)
       end
 
+      # Strip a trailing language group "(...)" from a rendered base string so
+      # the supplement can re-attach its own language at the end.
+      def strip_language(str)
+        str.sub(/\s*\([^)]+\)\s*$/, "").strip
+      end
+
       def render_single(id)
         format = effective_format(id)
 
@@ -80,6 +84,16 @@ module Pubid
       def render_supplement(id)
         format = effective_format(id)
 
+        # Trailing-word shorthand: "BASE Amendment" / "BASE Errata" with the
+        # publication year kept on the base identifier. The word comes from the
+        # concrete supplement class.
+        if id.trailing
+          base_str = strip_language(id.base_identifier.to_s)
+          result = "#{base_str} #{id.supplement_type}"
+          result += " (#{id.language})" if id.language
+          return result
+        end
+
         base_format = if format && format != :short
                         format
                       elsif id.base_identifier.class.attributes.key?(:parsed_format) && id.base_identifier.parsed_format == "long"
@@ -93,7 +107,7 @@ module Pubid
                    else
                      id.base_identifier.to_s
                    end
-        base_str = base_str.sub(/\s*\([^)]+\)\s*$/, "").strip
+        base_str = strip_language(base_str)
 
         result = "#{id.supplement_type} (#{id.year}) to #{base_str}"
         result += " (#{id.language})" if id.language
@@ -104,6 +118,16 @@ module Pubid
       def render_annex(id)
         format = effective_format(id)
 
+        # "BASE:YYYY Annex(es)" — the year is glued to the base, the marker
+        # carries none. Keep the base date instead of stripping it.
+        if id.year_on_base
+          base_str = strip_language(id.base_identifier.to_s)
+          marker = id.letter ? "Annex #{id.letter}" : "Annexes"
+          result = "#{base_str} #{marker}"
+          result += " (#{id.language})" if id.language
+          return result
+        end
+
         base_format = if id.base_identifier.class.attributes.key?(:parsed_format) && id.base_identifier.parsed_format == "long"
                         :long
                       else
@@ -142,20 +166,6 @@ module Pubid
         result += " (#{id.language})" if id.language
         result
       end
-
-      def render_base_identifier(id)
-        result = "#{id.publisher} #{id.type} #{id.code}"
-        result += ":#{id.date.render(context: @context)}" if id.date
-
-        if id.stage || id.iteration
-          result += " "
-          result += id.iteration.to_s if id.iteration
-          result += id.stage.to_s if id.stage
-        end
-
-        result += "(#{id.language})" if id.language
-        result
-      end
     end
   end
 end

data/lib/pubid/oiml/single_identifier.rb

@@ -15,6 +15,64 @@ module Pubid
         "short"
       } # Track parsed format
 
+      # Serialization delta on top of Oiml::Identifier's shared block. The
+      # `code` (number/part/subpart/suffix) and `date` (year) components are
+      # flattened to top-level keys rather than nested hashes, mirroring ISO
+      # (lib/pubid/iso/identifier.rb). `type` is intentionally omitted
+      # (recomputed from the class on load).
+      key_value do
+        map "publisher", to: :publisher
+        map "number", with: { to: :number_to_kv, from: :number_from_kv }
+        map "part", with: { to: :part_to_kv, from: :part_from_kv }
+        map "subpart", with: { to: :subpart_to_kv, from: :subpart_from_kv }
+        map "suffix", with: { to: :suffix_to_kv, from: :suffix_from_kv }
+        map "space_suffix",
+            with: { to: :space_suffix_to_kv, from: :space_suffix_from_kv }
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "edition", to: :edition
+        map "stage", to: :stage
+        map "iteration", to: :iteration
+      end
+
+      # --- code components flattened to top-level keys ---
+      def number_to_kv(model, doc) = emit_kv(doc, "number", model.code&.number)
+      def number_from_kv(model, value) = code_for(model).number = value.to_s
+      def part_to_kv(model, doc) = emit_kv(doc, "part", model.code&.part)
+      def part_from_kv(model, value) = code_for(model).part = value.to_s
+      def subpart_to_kv(model, doc) = emit_kv(doc, "subpart", model.code&.subpart)
+      def subpart_from_kv(model, value) = code_for(model).subpart = value.to_s
+      def suffix_to_kv(model, doc) = emit_kv(doc, "suffix", model.code&.suffix)
+      def suffix_from_kv(model, value) = code_for(model).suffix = value.to_s
+
+      def space_suffix_to_kv(model, doc)
+        return unless model.code&.space_suffix
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("space_suffix", true),
+        )
+      end
+
+      def space_suffix_from_kv(model, value)
+        code_for(model).space_suffix = value
+      end
+
+      # --- date flattened to a top-level year ---
+      def year_to_kv(model, doc) = emit_kv(doc, "year", model.date&.year)
+
+      def year_from_kv(model, value)
+        (model.date ||= Pubid::Components::Date.new).year = value.to_s
+      end
+
+      def emit_kv(doc, key, value)
+        return if value.nil? || value.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, value.to_s))
+      end
+
+      def code_for(model)
+        model.code ||= Components::Code.new
+      end
+
       attr_reader :requested_format
 
       # Type is determined by the subclass

data/lib/pubid/oiml/supplement_identifier.rb

@@ -5,13 +5,42 @@ module Pubid
     class SupplementIdentifier < Identifier
       # Base class for OIML supplements (amendments, annexes)
       # These wrap a base identifier like ISO amendments
-      attribute :base_identifier, Oiml::Identifier
+      attribute :base_identifier, Oiml::Identifier, polymorphic: true
       attribute :year, :string
       attribute :language, :string
+      # True for the trailing-word shorthand ("OIML R 138:2009 Amendment"),
+      # where the supplement word is appended after a dated base instead of the
+      # "Amendment (YYYY) to BASE" prose form. The word itself comes from the
+      # concrete class (#supplement_type), so only this flag is stored.
+      attribute :trailing, :boolean, default: false
       attribute :parsed_format, :string, default: -> {
         "short"
       } # Track supplement's parsed format
 
+      # Serialization delta on top of Oiml::Identifier's shared block. The
+      # nested base_identifier is (de)serialized recursively through the
+      # polymorphic router so its own `_type` selects the right subclass.
+      key_value do
+        map "base_identifier",
+            with: { to: :base_identifier_to_kv, from: :base_identifier_from_kv }
+        map "year", to: :year
+        map "trailing", to: :trailing
+      end
+
+      def base_identifier_to_kv(model, doc)
+        base = model.base_identifier
+        return unless base
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("base_identifier",
+                                                   base.to_hash),
+        )
+      end
+
+      def base_identifier_from_kv(model, value)
+        model.base_identifier = ::Pubid::Oiml::Identifier.from_hash(value) if value
+      end
+
       attr_reader :requested_format
 
       def to_s(format: nil, **opts)

data/lib/pubid/plateau/identifier.rb

@@ -1,23 +1,6 @@
 # frozen_string_literal: true
 
-module Pubid
-  module Plateau
-    # Plateau factory entry point. `.parse` lives on `Pubid::Plateau`
-    # itself for historical reasons; this module hosts `.create` for API
-    # consistency with the other pubid flavors.
-    #
-    # NOTE: intentionally does NOT `extend Pubid::IdentifierFacade`. PLATEAU's
-    # `to_hash` currently raises (publisher stored as a String, not a Publisher
-    # component), so enabling the facade's identity check would route PLATEAU
-    # ids through a consumer's `to_hash` (e.g. relaton-index#save) and crash.
-    # Re-enable once PLATEAU serialization round-trips cleanly. See
-    # identifier_facade.rb.
-    module Identifier
-      # Delegate to the flavor module so callers can use
-      # `Pubid::Plateau::Identifier.parse` consistently with other flavors.
-      def self.parse(identifier)
-        Pubid::Plateau.parse(identifier)
-      end
-    end
-  end
-end
+# Pubid::Plateau::Identifier is the PLATEAU 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"

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

@@ -2,50 +2,59 @@
 
 module Pubid
   module Plateau
-    module Identifiers
-      # Base class for all PLATEAU identifiers
-      class Base < Pubid::Identifier
-        # Generate URN for this identifier
-        #
-        # @return [String] URN representation
-        attribute :number, :integer
-        attribute :annex, :integer, default: -> {}
-
-        def publisher
-          "PLATEAU"
-        end
+    # Base class for all PLATEAU identifiers. Canonical name
+    # Pubid::Plateau::Identifier (Identifiers::Base is a back-compat alias).
+    class Identifier < ::Pubid::Identifier
+      # Delegate to the flavor module so callers can use
+      # `Pubid::Plateau::Identifier.parse` consistently with other flavors.
+      def self.parse(identifier)
+        Pubid::Plateau.parse(identifier)
+      end
 
-        # Subclasses must implement type_string
-        def type_string
-          raise NotImplementedError, "Subclasses must implement type_string"
-        end
+      attribute :number, :integer
+      attribute :annex, :integer, default: -> {}
 
-        def formatted_number
-          "#%02d" % number
-        end
+      # Stored as a plain string (always "PLATEAU") so it round-trips through
+      # to_hash/from_hash. Was a `def publisher` method, which made lutaml
+      # serialize a String against the Components::Publisher attribute.
+      attribute :publisher, :string, default: -> { "PLATEAU" }
 
-        def formatted_annex
-          annex ? "-#{annex}" : ""
-        end
+      # Subclasses must implement type_string
+      def type_string
+        raise NotImplementedError, "Subclasses must implement type_string"
+      end
+
+      def formatted_number
+        "#%02d" % number
+      end
+
+      def formatted_annex
+        annex ? "-#{annex}" : ""
+      end
 
-        def ==(other)
-          return false unless other.class == self.class
+      def ==(other)
+        return false unless other.class == self.class
 
-          number == other.number &&
-            annex == other.annex
-        end
+        number == other.number &&
+          annex == other.annex
+      end
 
-        # Include type_string and annex in serialization for round-trip compatibility
-        def base_hash
-          hash = super
-          if self.class.attributes.key?(:type_string) && type_string
-            hash[:type] =
-              type_string
-          end
-          hash[:annex] = annex if annex
-          hash
+      # Include type_string and annex in serialization for round-trip compatibility
+      def base_hash
+        hash = super
+        if self.class.attributes.key?(:type_string) && type_string
+          hash[:type] =
+            type_string
         end
+        hash[:annex] = annex if annex
+        hash
       end
     end
+
+    module Identifiers
+      # Backward-compatible alias: PLATEAU's base class used to be
+      # Pubid::Plateau::Identifiers::Base. It is now Pubid::Plateau::Identifier.
+      Base = Pubid::Plateau::Identifier
+    end
   end
 end

data/lib/pubid/plateau/identifiers/handbook.rb

@@ -13,10 +13,6 @@ module Pubid
           "Handbook"
         end
 
-        def to_s
-          render(format: :human)
-        end
-
         def formatted_edition
           "第#{edition}版"
         end