pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

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

@@ -4,7 +4,6 @@ module Pubid
   module Iso
     module Identifiers
       class Corrigendum < SupplementIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -59,7 +58,7 @@ module Pubid
           ),
           ::Pubid::Components::TypedStage.new(
             code: :dcor,
-            abbr: ["DCor", "DCOR"],
+            abbr: ["DCor", "DCOR", "DIS Cor"],
             short_abbr: "DCOR",
             long_abbr: "DCor",
             type_code: :cor,
@@ -69,7 +68,7 @@ module Pubid
           ),
           ::Pubid::Components::TypedStage.new(
             code: :fdcor,
-            abbr: ["FDCor", "FDCOR", "FCOR"],
+            abbr: ["FDCor", "FDCOR", "FCOR", "FDIS Cor"],
             short_abbr: "FDCOR",
             long_abbr: "FDCor",
             type_code: :cor,
@@ -100,7 +99,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :cor, title: "Corrigendum", short: "COR" }
+          { key: :cor,
+            web: :corrigendum, title: "Corrigendum", short: "COR" }
         end
       end
     end

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

@@ -5,7 +5,6 @@ module Pubid
     module Identifiers
       # Data Identifier
       class Data < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(

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

@@ -4,9 +4,14 @@ module Pubid
   module Iso
     module Identifiers
       class Directives < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
         attribute :subgroup, ::Pubid::Components::Code
 
+        # Merges with Identifier's block (base attributes); only adds the
+        # Directives-specific subgroup so it survives to_hash/from_hash.
+        key_value do
+          map "subgroup", to: :subgroup
+        end
+
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
             code: :pubguide,
@@ -22,7 +27,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :dir, title: "Directives", short: "DIR" }
+          { key: :dir,
+            web: :directives, title: "Directives", short: "DIR" }
         end
 
         def to_s(**opts)

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

@@ -4,9 +4,35 @@ module Pubid
   module Iso
     module Identifiers
       class DirectivesSupplement < SupplementIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
         attribute :supplement_publisher, ::Pubid::Components::Publisher
 
+        # supplement_publisher (e.g. "IEC" in "ISO/IEC DIR 1 IEC SUP") is needed
+        # by to_s/to_urn; serialize its body under "publisher" (the supplement's
+        # own publisher; the base's publisher lives in the nested base). This
+        # overrides the inherited publisher map, whose delegated value is nil or
+        # the omitted ISO default here.
+        key_value do
+          map "publisher",
+              with: { to: :supplement_publisher_to_kv, from: :supplement_publisher_from_kv }
+        end
+
+        def supplement_publisher_to_kv(model, doc)
+          body = model.supplement_publisher&.body
+          return if body.nil? || body.to_s.empty?
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new("publisher", body.to_s),
+          )
+        end
+
+        def supplement_publisher_from_kv(model, value)
+          model.supplement_publisher = ::Pubid::Components::Publisher.new(body: value.to_s)
+        end
+
+        # copublishers here is the base's (delegated), redundant with the nested
+        # base; don't duplicate it at the supplement level.
+        def copublishers_to_kv(_model, _doc); end
+
         # Delegate base identifier attributes for easier access
         def copublishers
           base_identifier&.copublishers
@@ -28,7 +54,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :"dir-sup", title: "Directives Supplement", short: "SUP" }
+          { key: :"dir-sup",
+            web: :directives_supplement, title: "Directives Supplement", short: "SUP" }
         end
 
         # def render_directives_supplement_identifier(identifier)
@@ -47,10 +74,10 @@ format: nil, stage_format_long: nil, with_date: nil)
             [
               base_identifier.to_s(lang: lang, lang_single: lang_single,
                                    with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date),
-              " #{supplement_publisher.body}",
+              " #{supplement_publisher.render}",
               " SUP", # Always render as "SUP" even though typed_stage.abbreviation is "DIR SUP"
-              (date ? ":#{date.year}" : ""),
-              (edition ? " Edition #{edition.number.value}" : ""),
+              (date ? ":#{date.render}" : ""),
+              (edition ? " Edition #{edition.value}" : ""),
             ].join
           else
             # Simplified rendering for bundled identifiers (just the supplement part)
@@ -63,13 +90,13 @@ format: nil, stage_format_long: nil, with_date: nil)
 format: nil, stage_format_long: nil, with_date: nil)
           date_str = if date
                        month_part = date.month ? "-#{date.month}" : ""
-                       ":#{date.year}#{month_part}"
+                       ":#{date.render}#{month_part}"
                      else
                        ""
                      end
 
           [
-            supplement_publisher.body,
+            supplement_publisher.render,
             " SUP",
             date_str,
           ].join
@@ -78,13 +105,15 @@ format: nil, stage_format_long: nil, with_date: nil)
         # DirectivesSupplement use urn:iso:doc scheme (not urn:iso:std)
         # Format: urn:iso:doc:{base_urn_parts}:jtc:X:sup[:{year}][:{edition}]
         def to_urn
+          urn_ctx = Rendering::RenderingContext.urn
+
           # If this is a standalone supplement (no base_identifier), build URN directly
           unless base_identifier
             parts = ["urn", "iso", "doc"]
-            parts << supplement_publisher.body.downcase if supplement_publisher
+            parts << supplement_publisher.render(context: urn_ctx) if supplement_publisher
             parts << "sup"
-            parts << date.year.to_s if date
-            parts << "ed-#{edition.number}" if edition&.number
+            parts << date.render(context: urn_ctx) if date
+            parts << edition.render(context: urn_ctx) if edition&.number
             return parts.join(":")
           end
 
@@ -94,7 +123,7 @@ format: nil, stage_format_long: nil, with_date: nil)
           # Handle JTC pattern specially
           if supplement_publisher&.body&.match?(/^JTC\s+(\d+)$/i)
             # Extract JTC number: "JTC 1" -> ["jtc", "1"]
-            jtc_parts = supplement_publisher.body.downcase.split
+            jtc_parts = supplement_publisher.render(context: urn_ctx).split
             # Insert JTC parts before "sup"
             parts = base_urn.split(":")
             parts.concat(jtc_parts) # Add "jtc" and "1"
@@ -102,14 +131,14 @@ format: nil, stage_format_long: nil, with_date: nil)
           else
             # Normal supplement
             parts = [base_urn, "sup"]
-            parts << supplement_publisher.body.downcase if supplement_publisher
+            parts << supplement_publisher.render(context: urn_ctx) if supplement_publisher
           end
 
           # Year (if present)
-          parts << date.year.to_s if date
+          parts << date.render(context: urn_ctx) if date
 
           # Edition (if present)
-          parts << "ed-#{edition.number}" if edition&.number
+          parts << edition.render(context: urn_ctx) if edition&.number
 
           parts.join(":")
         end

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

@@ -4,7 +4,6 @@ module Pubid
   module Iso
     module Identifiers
       class Extract < SupplementIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -18,7 +17,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :ext, title: "Extract", short: "Ext" }
+          { key: :ext,
+            web: :extract, title: "Extract", short: "Ext" }
         end
 
         # def self.get_renderer_class

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

@@ -4,7 +4,6 @@ module Pubid
   module Iso
     module Identifiers
       class Guide < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(

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

@@ -8,7 +8,6 @@ module Pubid
         include IdentifierMetadata
 
         # Note: type attribute uses shared Components::Type from Pubid namespace
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -142,7 +141,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :is, title: "International Standard", short: nil }
+          { key: :is,
+            web: :international_standard, title: "International Standard", short: nil }
         end
 
         # Define machine-readable metadata
@@ -164,5 +164,5 @@ module Pubid
   end
 end
 
-# NOTE: Identifiers are now registered in the ISO Scheme class
-# The global registry has been removed in favor of per-flavor Schemes
+# NOTE: Identifiers are now registered in the ISO flavor module
+# The global registry has been removed in favor of self-describing types

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

@@ -5,7 +5,6 @@ module Pubid
     module Identifiers
       # International Standardized Profile Identifier
       class InternationalStandardizedProfile < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -52,7 +51,7 @@ module Pubid
             code: :disp,
             stage_code: :disp,
             type_code: :isp,
-            abbr: ["DISP"],
+            abbr: ["DISP", "DIS ISP"],
             name: "Draft International Standardized Profile",
             harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
           ),
@@ -61,7 +60,7 @@ module Pubid
             code: :fdisp,
             stage_code: :fdis,
             type_code: :isp,
-            abbr: ["FDISP"],
+            abbr: ["FDISP", "FDIS ISP"],
             name: "Final Draft International Standardized Profile",
             harmonized_stages: %w[50.00 50.20 50.60 50.92],
           ),
@@ -85,7 +84,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :isp, title: "International Standardized Profile",
+          { key: :isp,
+            web: :international_standardized_profile, title: "International Standardized Profile",
             short: "ISP" }
         end
       end

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

@@ -4,12 +4,17 @@ module Pubid
   module Iso
     module Identifiers
       class InternationalWorkshopAgreement < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
+
+        # IWA identifiers have no publisher prefix (rendered "IWA 1", not
+        # "ISO IWA 1"), so there is no implied publisher to default on load.
+        def self.default_publisher
+          nil
+        end
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
-            code: :npiwa,
-            stage_code: :np,
+            code: :pwiiwa,
+            stage_code: :pwi,
             type_code: :iwa,
             abbr: ["PWI IWA"],
             name: "Proposed Work Item for International Workshop Agreement",
@@ -75,7 +80,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :iwa, title: "International Workshop Agreement", short: "IWA" }
+          { key: :iwa,
+            web: :international_workshop_agreement, title: "International Workshop Agreement", short: "IWA" }
         end
 
         def to_s(**opts)

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

@@ -5,7 +5,6 @@ module Pubid
     module Identifiers
       # Publicly Available Specification", Identifier
       class Pas < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -85,7 +84,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :pas, title: "Publicly Available Specification", short: "PAS" }
+          { key: :pas,
+            web: :publicly_available_specification, title: "Publicly Available Specification", short: "PAS" }
         end
       end
     end

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

@@ -4,7 +4,6 @@ module Pubid
   module Iso
     module Identifiers
       class Recommendation < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -32,7 +31,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :rec, title: "Recommendation", short: "R" }
+          { key: :rec,
+            web: :recommendation, title: "Recommendation", short: "R" }
         end
 
         # Override URN type code - Recommendation uses 'r' in URN (RFC 5141)

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

@@ -4,9 +4,16 @@ module Pubid
   module Iso
     module Identifiers
       class Supplement < SupplementIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwisuppl,
+            stage_code: :pwi,
+            type_code: :suppl,
+            abbr: ["PWI Suppl"],
+            name: "Proposed Work Item for Supplement",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
           ::Pubid::Components::TypedStage.new(
             code: :npsuppl,
             stage_code: :np,
@@ -43,7 +50,7 @@ module Pubid
             code: :dsuppl,
             stage_code: :dsuppl,
             type_code: :suppl,
-            abbr: ["DSuppl"],
+            abbr: ["DSuppl", "DIS Suppl"],
             name: "Draft Supplement",
             harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
           ),
@@ -79,7 +86,8 @@ module Pubid
         end
 
         def self.type
-          { key: :suppl, title: "Supplement", short: "suppl" }
+          { key: :suppl,
+            web: :supplement, title: "Supplement", short: "suppl" }
         end
       end
     end

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

@@ -5,7 +5,7 @@ module Pubid
     module Identifiers
       # Technical Committee Document
       # Format: TC 184/SC 4/WG 3 N 123, JTC 1 N 456, TC 184 N 100
-      class TcDocument < Base
+      class TcDocument < Identifier
         # TC type (TC, JTC, PC, IT, etc.)
         attribute :tc_type, ::Pubid::Components::Code
         # TC number
@@ -33,8 +33,36 @@ module Pubid
         # TC documents don't use typed stages like other identifiers
         TYPED_STAGES = [].freeze
 
+        # Serialize the committee structure (all plain-string Codes) on top of
+        # the inherited ISO mapping; TC documents have no stage.
+        key_value do
+          map "tc_type", with: { to: :tc_type_to_kv, from: :tc_type_from_kv }
+          map "tc_number", with: { to: :tc_number_to_kv, from: :tc_number_from_kv }
+          map "sc_type", with: { to: :sc_type_to_kv, from: :sc_type_from_kv }
+          map "sc_number", with: { to: :sc_number_to_kv, from: :sc_number_from_kv }
+          map "wg_type", with: { to: :wg_type_to_kv, from: :wg_type_from_kv }
+          map "wg_number", with: { to: :wg_number_to_kv, from: :wg_number_from_kv }
+        end
+
+        # TC documents have no stage; suppress the inherited stage emission.
+        def stage_to_kv(_model, _doc); end
+
+        def tc_type_to_kv(m, doc) = emit_code(doc, "tc_type", m.tc_type)
+        def tc_type_from_kv(m, v) = m.tc_type = build_code(v)
+        def tc_number_to_kv(m, doc) = emit_code(doc, "tc_number", m.tc_number)
+        def tc_number_from_kv(m, v) = m.tc_number = build_code(v)
+        def sc_type_to_kv(m, doc) = emit_code(doc, "sc_type", m.sc_type)
+        def sc_type_from_kv(m, v) = m.sc_type = build_code(v)
+        def sc_number_to_kv(m, doc) = emit_code(doc, "sc_number", m.sc_number)
+        def sc_number_from_kv(m, v) = m.sc_number = build_code(v)
+        def wg_type_to_kv(m, doc) = emit_code(doc, "wg_type", m.wg_type)
+        def wg_type_from_kv(m, v) = m.wg_type = build_code(v)
+        def wg_number_to_kv(m, doc) = emit_code(doc, "wg_number", m.wg_number)
+        def wg_number_from_kv(m, v) = m.wg_number = build_code(v)
+
         def self.type
-          { key: :tc, title: "Technical Committee Document", short: "TC" }
+          { key: :tc,
+            web: :tc_document, title: "Technical Committee Document", short: "TC" }
         end
 
         def self.typed_stages
@@ -45,26 +73,26 @@ module Pubid
           result = publisher.to_s if publisher
 
           # Add TC type and number
-          result += "/#{tc_type.value} " if tc_type&.value
-          result += tc_number.value.to_s if tc_number&.value
+          result += "/#{tc_type.render} " if tc_type&.value
+          result += tc_number.render.to_s if tc_number&.value
 
           # Add SC type and number
           if sc_type&.value && sc_number&.value
-            result += "/#{sc_type.value} "
-            result += sc_number.value.to_s
+            result += "/#{sc_type.render} "
+            result += sc_number.render.to_s
           end
 
           # Add WG type and number
           if wg_type&.value && wg_number&.value
-            result += "/#{wg_type.value} "
-            result += wg_number.value.to_s
+            result += "/#{wg_type.render} "
+            result += wg_number.render.to_s
           end
 
           # Add document number
-          result += " N #{number.value}" if number&.value
+          result += " N #{number.render}" if number&.value
 
           # Add year if present
-          result += ":#{date.year}" if date&.year
+          result += ":#{date.render}" if date&.year
 
           result
         end
@@ -72,20 +100,21 @@ module Pubid
         # Generate URN for TC document
         # Format: urn:iso:doc:iso:tc:184:sc-4:wg-3:123
         def to_urn
+          urn_ctx = Rendering::RenderingContext.urn
           parts = ["urn:iso:doc"]
-          parts << publisher.to_s.downcase if publisher
+          parts << publisher.render(context: urn_ctx) if publisher
 
           # Add TC
-          parts << "tc:#{tc_number.value}" if tc_number&.value
+          parts << "tc:#{tc_number.render(context: urn_ctx)}" if tc_number&.value
 
           # Add SC
-          parts << "sc-#{sc_number.value}" if sc_number&.value
+          parts << "sc-#{sc_number.render(context: urn_ctx)}" if sc_number&.value
 
           # Add WG
-          parts << "wg-#{wg_number.value}" if wg_number&.value
+          parts << "wg-#{wg_number.render(context: urn_ctx)}" if wg_number&.value
 
           # Add document number
-          parts << number.value if number&.value
+          parts << number.render(context: urn_ctx) if number&.value
 
           parts.join(":")
         end

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

@@ -4,7 +4,6 @@ module Pubid
   module Iso
     module Identifiers
       class TechnicalReport < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -64,7 +63,7 @@ module Pubid
             code: :dtr,
             stage_code: :draft,
             type_code: :tr,
-            abbr: ["DTR"],
+            abbr: ["DTR", "DIS TR"],
             name: "Draft Technical Report",
             harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
           ),
@@ -72,7 +71,7 @@ module Pubid
             code: :fdtr,
             stage_code: :final_draft,
             type_code: :tr,
-            abbr: ["FDTR"],
+            abbr: ["FDTR", "FDIS TR"],
             name: "Final Draft Technical Report",
             harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
           ),
@@ -95,7 +94,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :tr, title: "Technical Report", short: "TR" }
+          { key: :tr,
+            web: :technical_report, title: "Technical Report", short: "TR" }
         end
       end
     end

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

@@ -4,7 +4,6 @@ module Pubid
   module Iso
     module Identifiers
       class TechnicalSpecification < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
             code: :pwits,
@@ -94,7 +93,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :ts, title: "Technical Specification", short: "TS" }
+          { key: :ts,
+            web: :technical_specification, title: "Technical Specification", short: "TS" }
         end
       end
     end

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

@@ -4,7 +4,6 @@ module Pubid
   module Iso
     module Identifiers
       class TechnologyTrendsAssessments < SingleIdentifier
-        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -87,7 +86,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :tta, title: "Technology Trends Assessments", short: "TTA" }
+          { key: :tta,
+            web: :technology_trends_assessments, title: "Technology Trends Assessments", short: "TTA" }
         end
       end
     end

data/lib/pubid/iso/identifiers.rb

@@ -5,7 +5,6 @@ module Pubid
     module Identifiers
       autoload :Addendum, "#{__dir__}/identifiers/addendum"
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
-      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :Data, "#{__dir__}/identifiers/data"
       autoload :Directives, "#{__dir__}/identifiers/directives"

data/lib/pubid/iso/normalizer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    # Applies pre-parse normalizations to ISO identifier strings, then dispatches
+    # to the parser/builder. Handles Cyrillic (Russian) translations, legacy
+    # update_codes regex rewrites, and the DAD/FDAM pattern that the PEG
+    # parser cannot recognize because it treats "/" as a copublisher separator.
+    class Normalizer
+      DAD_PATTERN = /^(.+?)\/(F?DAD)\s+(\d+)(?::(\d{4}))?$/.freeze
+
+      class << self
+        # Apply all normalizations to an identifier string and return the
+        # parsed identifier object.
+        # @param identifier [String]
+        # @return [Pubid::Iso::Identifier]
+        def apply(identifier)
+          if (match = identifier.match(DAD_PATTERN))
+            parse_dad_pattern(match)
+          else
+            normalized = Core::UpdateCodes.apply(identifier, :iso)
+            normalized = normalize_cyrillic(normalized)
+            parse_with_builder(normalized)
+          end
+        end
+
+        private
+
+        def parse_with_builder(string)
+          parsed = Pubid::Iso.parser.parse(string)
+          Pubid::Iso.builder.build(parsed)
+        end
+
+        # Normalize Cyrillic (Russian) ISO identifiers to Latin equivalents.
+        # ИСО = ISO, МЭК = IEC, Руководство/Руководства = Guide,
+        # ОПМС = FDIS, ПМС = DIS, ТО = TR, ТС = TS.
+        # @return [String]
+        def normalize_cyrillic(identifier)
+          return identifier unless identifier.match?(/[а-яА-Я]/)
+
+          normalized = identifier.dup
+          # Remove inline comments (Russian style comments with #)
+          normalized = normalized.gsub(/\s*#\s*.*$/, "")
+          # Translate Russian abbreviations (order matters: longer first)
+          normalized = normalized.gsub("Руководства", "GUIDE")
+          normalized = normalized.gsub("Руководство", "GUIDE")
+          normalized = normalized.gsub("ИСО/МЭК", "ISO/IEC")
+          normalized = normalized.gsub("ИСО/ОПМС", "ISO/FDIS")
+          normalized = normalized.gsub("ИСО/ПМС", "ISO/DIS")
+          normalized = normalized.gsub("ИСО/ТО", "ISO/TR")
+          normalized = normalized.gsub("ИСО/ТС", "ISO/TS")
+          normalized = normalized.gsub("ИСО", "ISO")
+          normalized = normalized.gsub("МЭК", "IEC")
+          # Standalone Cyrillic stage abbreviations (after publisher replacements)
+          normalized = normalized.gsub("ТО", "TR")
+          normalized = normalized.gsub("ТС", "TS")
+          normalized = normalized.gsub("ОПМС", "FDIS")
+          normalized = normalized.gsub("ПМС", "DIS")
+          normalized.strip
+        end
+
+        # Parse the DAD/FDAM pattern manually. The parser fails because it
+        # treats "/" as a copublisher separator.
+        # Pattern: "ISO 2631/DAD 1" or "ISO 2553/DAD 1:1987"
+        def parse_dad_pattern(match)
+          base_str = match[1]          # "ISO 2631" or "ISO 2553"
+          stage_abbr = match[2]        # "DAD" or "FDAD"
+          supplement_number = match[3] # "1"
+          supplement_year = match[4]   # "1987" or nil
+
+          base_parsed = Pubid::Iso.parser.parse(base_str)
+          base_identifier = Pubid::Iso.builder.build(base_parsed)
+
+          addendum = Identifiers::Addendum.new
+          addendum.base_identifier = base_identifier
+          addendum.number = Iso::Components::Code.new(value: supplement_number)
+          addendum.date = Pubid::Components::Date.new(year: supplement_year) if supplement_year
+
+          typed_stage = Pubid::Iso.locate_stage(stage_abbr)
+          addendum.typed_stage = typed_stage
+          addendum.stage = typed_stage.to_stage
+          addendum.type = typed_stage.to_type
+
+          addendum
+        end
+      end
+    end
+  end
+end