pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

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

data/lib/pubid/iso/parser.rb

@@ -9,10 +9,19 @@ module Pubid
 
       DASH_CHARS = ["-", "‑", "‐"].freeze
 
+      # Supplement identifier type keys (kept as a hard-coded list to match
+      # the previous identifier split; only the base identifier registry
+      # is auto-discovered from the Identifiers namespace).
+      SUPPLEMENT_TYPE_KEYS = %i[amd cor suppl ext add].freeze
+
       # We need to sort by length to match longest first because that's how Parslet works
-      TYPED_STAGES = Pubid::Iso::Scheme.typed_stages
+      TYPED_STAGES = Pubid::Iso.identifier_types
+        .reject { |k| SUPPLEMENT_TYPE_KEYS.include?(k.type[:key]) }
+        .flat_map { |k| k.const_defined?(:TYPED_STAGES) ? k.const_get(:TYPED_STAGES) : [] }
         .map(&:abbr).flatten.sort_by(&:length).reverse
-      TYPED_STAGES_SUPPLEMENTS = Pubid::Iso::Scheme.supplement_typed_stages
+      TYPED_STAGES_SUPPLEMENTS = Pubid::Iso.identifier_types
+        .select { |k| SUPPLEMENT_TYPE_KEYS.include?(k.type[:key]) }
+        .flat_map { |k| k.const_defined?(:TYPED_STAGES) ? k.const_get(:TYPED_STAGES) : [] }
         .map(&:abbr).flatten.sort_by(&:length).reverse
 
       root :identifier
@@ -45,7 +54,9 @@ module Pubid
       #             ISO/JTC 1 N 456
       #             ISO/TC 184/SC 4 N 789 (TC and SC only, no WG)
       rule(:tc_document) do
-        prefix_sole_publisher >> str("/") >> tc_type >> space >> tc_number.as(:tc_number) >>
+        # Accept either "ISO/TC 184…" or the lenient space form "ISO TC 184…"
+        # (the latter was valid in pubid 1.x via an optional slash).
+        prefix_sole_publisher >> (str("/") | space) >> tc_type >> space >> tc_number.as(:tc_number) >>
           tc_subcommittee_part.maybe >>
           space >> str("N") >> space? >> digits.as(:number) >>
           (str(":") >> year_digits.as(:year)).maybe
@@ -64,7 +75,9 @@ module Pubid
       end
 
       rule(:sc_type) do
-        str("SC").as(:sc_type)
+        # "SC" plus the "SC/QC" quality-committee variant
+        # (e.g. ISO/TC 184/SC/QC 4 N 246). Longest first for Parslet.
+        (str("SC/QC") | str("SC")).as(:sc_type)
       end
 
       rule(:wg_type) do
@@ -325,7 +338,9 @@ module Pubid
       rule(:supplement_identifier_no_third) do
         identifier_copublishers_no_third.as(:base_identifier) >>
           str("/") >> supplement_type_with_stage >>
-          ((space? >> second_part) | (str(".") >> digits.as(:number)) | (space? >> date))
+          # The trailing number/date is optional: some draft supplements have no
+          # number yet, e.g. "ISO/IEC 9579/WD Amd".
+          ((space? >> second_part) | (str(".") >> digits.as(:number)) | (space? >> date)).maybe
       end
 
       rule(:supplement_identifier) do
@@ -378,9 +393,14 @@ module Pubid
 
       DIRECTIVES_TYPED_STAGES = Identifiers::Directives::TYPED_STAGES.map(&:abbr).flatten.sort_by(&:length).reverse
       rule(:directives_identifier_no_third) do
-        prefix_with_copublishers >> space >>
+        prefix_with_copublishers >> space? >>
           (directives_publisher_subgroup >> space).maybe >>
           array_to_str(DIRECTIVES_TYPED_STAGES).as(:type_with_stage) >>
+          # The subgroup may also follow the type, e.g. "ISO/IEC DIR JTC 1"
+          # (canonical form is "ISO/IEC JTC 1 DIR"). Guard against a trailing
+          # supplement, where "JTC 1" is the supplement publisher instead
+          # (e.g. "ISO/IEC DIR JTC 1 SUP").
+          (space >> directives_publisher_subgroup >> (space >> str("SUP")).absent?).maybe >>
           (
             (space >> directives_number_with_part).maybe >>
             (str(":") >> date).maybe

data/lib/pubid/iso/single_identifier.rb

@@ -11,7 +11,8 @@ module Pubid
 
       def build_rendering_context(_renderer, format:, with_edition: false,
                                   lang: :en, lang_single: false,
-                                  stage_format_long: nil, with_date: nil)
+                                  stage_format_long: nil, with_date: nil,
+                                  annotated: false)
         if format == :mr_string
           nil
         elsif lang_single || stage_format_long || !with_date.nil?
@@ -19,17 +20,19 @@ module Pubid
             with_language_code: lang_single ? :single : :none,
             stage_format_long: stage_format_long || false,
             with_date: with_date.nil? || with_date,
+            annotated: annotated,
           )
         else
-          detect_rendering_context
+          detect_rendering_context(annotated: annotated)
         end
       end
 
-      def detect_rendering_context
+      def detect_rendering_context(annotated: false)
         Rendering::RenderingContext.new(
           with_language_code: detect_language_code_format,
           stage_format_long: detect_stage_format_long,
           with_date: true,
+          annotated: annotated,
         )
       end
 

data/lib/pubid/iso/supplement_identifier.rb

@@ -7,14 +7,27 @@ module Pubid
                 polymorphic: true
 
       key_value do
-        map "base_identifier", to: :base_identifier, polymorphic: {
+        # Serialized key is "base" (matches JIS); the attribute/method stays
+        # `base_identifier`, which relaton-index's get_id_number depends on.
+        map "base", to: :base_identifier, polymorphic: {
           attribute: "_type",
           class_map: Identifier::ISO_TYPE_MAP,
         }
       end
 
+      # A supplement carries the publisher/copublishers of the document it
+      # supplements. Delegate to the root rather than the immediate base so a
+      # nested supplement (e.g. ".../Amd 1/Cor 1") reads identity from the
+      # underlying standard in one hop, regardless of chain depth. This keeps a
+      # parsed supplement and a from_hash-deserialized one in agreement (== and
+      # index matching compare both). Guard on base_identifier: `root` returns
+      # self when there is no base, which would otherwise recurse forever.
       def publisher
-        base_identifier&.publisher
+        root.publisher if base_identifier
+      end
+
+      def copublishers
+        root.copublishers if base_identifier
       end
 
       def to_s(**opts)