pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/iso/parser.rb

@@ -3,25 +3,16 @@ require "parslet"
 
 module Pubid
   module Iso
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 
       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.identifier_types
-        .reject { |k| SUPPLEMENT_TYPE_KEYS.include?(k.type[:key]) }
-        .flat_map { |k| k.const_defined?(:TYPED_STAGES) ? k.const_get(:TYPED_STAGES) : [] }
+      TYPED_STAGES = Pubid::Iso::Scheme.typed_stages
         .map(&:abbr).flatten.sort_by(&:length).reverse
-      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) : [] }
+      TYPED_STAGES_SUPPLEMENTS = Pubid::Iso::Scheme.supplement_typed_stages
         .map(&:abbr).flatten.sort_by(&:length).reverse
 
       root :identifier
@@ -54,9 +45,7 @@ module Pubid
       #             ISO/JTC 1 N 456
       #             ISO/TC 184/SC 4 N 789 (TC and SC only, no WG)
       rule(:tc_document) do
-        # 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) >>
+        prefix_sole_publisher >> str("/") >> 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
@@ -75,9 +64,7 @@ module Pubid
       end
 
       rule(:sc_type) do
-        # "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)
+        str("SC").as(:sc_type)
       end
 
       rule(:wg_type) do
@@ -99,7 +86,7 @@ module Pubid
       rule(:iso_r_supplement_identifier) do
         (
           str("ISO/R").as(:iso_r_prefix) >> space >> iso_r_second_part
-        ).as(:base) >>
+        ).as(:base_identifier) >>
           iso_r_supplement_separator >>
           supplement_type_with_stage >>
           space? >> second_part >> third_part
@@ -148,16 +135,12 @@ module Pubid
       end
 
       rule(:date) do
-        # :2005-02 or :-- (undated reference — ISO/IEC undated-reference form,
-        # e.g. ISO 16634:--, also accepted as the em-dash variant ISO 16634:—)
+        # :2005-02
         (str(":") | dash) >>
-          (
-            (str("--") | str("—")).as(:undated_marker) |
-              (year_digits >>
-                (dash >> month_digits).maybe >>
-                (dash >> day_digits).maybe
-              ).as(:date)
-          ).maybe
+          (year_digits >>
+            (dash >> month_digits).maybe >>
+            (dash >> day_digits).maybe
+          ).as(:date).maybe
       end
 
       rule(:part_and_subpart) do
@@ -274,14 +257,14 @@ module Pubid
       end
 
       # For joint identifiers, we do not treat it as a supplementary identifier
-      # (hence not a base)
+      # (hence not a base_identifier)
       # ISO only supports IDF in joint identifiers
       # ISO 5537|IDF 26
       # ISO 17678|IDF 202:2010
       # ISO/TS 4985:2023 | IDF/RM 255
       # ISO 4214:2022 | IDF 254:2022
       rule(:joint_identifier) do
-        identifier_copublishers_no_third.as(:base) >>
+        identifier_copublishers_no_third.as(:base_identifier) >>
           space? >> str("|") >> space? >>
           scope { idf_identifier }.as(:joint_identifier)
       end
@@ -340,11 +323,9 @@ module Pubid
       # ISO 8601-1:2019/Amd 2:2024
       # ISO/IEC 10646-1:1993/pDCOR.2 (legacy dot-prefixed format)
       rule(:supplement_identifier_no_third) do
-        identifier_copublishers_no_third.as(:base) >>
+        identifier_copublishers_no_third.as(:base_identifier) >>
           str("/") >> supplement_type_with_stage >>
-          # 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
+          ((space? >> second_part) | (str(".") >> digits.as(:number)) | (space? >> date))
       end
 
       rule(:supplement_identifier) do
@@ -355,14 +336,14 @@ module Pubid
       # ISO/IEC 19794-7:2014/Amd 1:2015/CD Cor 1
       # ISO/IEC 10646-1:1993/pDCOR.2 (legacy dot-prefixed format)
       rule(:supplement_supplement_identifier) do
-        supplement_identifier_no_third.as(:base) >>
+        supplement_identifier_no_third.as(:base_identifier) >>
           str("/") >> supplement_type_with_stage >>
           ((space? >> second_part >> third_part) | (str(".") >> digits.as(:number) >> third_part))
       end
 
       # ISO 12345:2020/Amd 1:2021/Cor 1:2022/Amd 2:2023 (three-level supplement)
       rule(:supplement_supplement_supplement_identifier) do
-        supplement_supplement_identifier.as(:base) >>
+        supplement_supplement_identifier.as(:base_identifier) >>
           str("/") >> supplement_type_with_stage >>
           ((space? >> second_part >> third_part) | (str(".") >> digits.as(:number) >> third_part))
       end
@@ -397,14 +378,9 @@ 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
@@ -412,7 +388,7 @@ module Pubid
       end
 
       rule(:directives_supplement_identifier) do
-        directives_identifier_no_third.as(:base) >> space? >> directives_supplement_part
+        directives_identifier_no_third.as(:base_identifier) >> space? >> directives_supplement_part
       end
 
       DIRECTIVES_SUPPLEMENTS_TYPED_STAGES = Identifiers::DirectivesSupplement::TYPED_STAGES.map(&:abbr).flatten.sort_by(&:length).reverse

data/lib/pubid/iso/scheme.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    # ISO Scheme with memoized parser/builder and hash-based indexing
+    class Scheme < Pubid::Scheme
+      class << self
+        # Singleton instance for memoization
+        # @return [Pubid::Iso::Scheme] the singleton scheme instance
+        def instance
+          @instance ||= new
+        end
+
+        # Delegate class methods to singleton instance for backward compatibility
+        # @param identifier [String] the identifier string to parse
+        # @return [Identifier] the parsed identifier
+        def parse(identifier)
+          instance.parse(identifier)
+        end
+
+        # @param abbr [String, Symbol] the abbreviation to find
+        # @return [TypedStage] the matching typed stage
+        def locate_typed_stage_by_abbr(abbr)
+          instance.locate_typed_stage_by_abbr(abbr)
+        end
+
+        # @param type_code [String, Symbol] the type code to find
+        # @return [Class] the matching identifier class
+        def locate_identifier_klass_by_type_code(type_code)
+          instance.locate_identifier_klass_by_type_code(type_code)
+        end
+
+        # @param stage_code [String, Symbol] the stage code to find
+        # @return [TypedStage] the matching typed stage
+        def locate_typed_stage_by_stage_code(stage_code)
+          instance.locate_typed_stage_by_stage_code(stage_code)
+        end
+
+        # @param harmonized_code [String] the harmonized stage code to find
+        # @return [TypedStage, nil] the matching typed stage
+        def locate_typed_stage_by_harmonized_code(harmonized_code)
+          instance.locate_typed_stage_by_harmonized_code(harmonized_code)
+        end
+
+        # Keep existing class methods for backward compatibility
+        # @return [Array<Class>] all base identifier classes
+        def identifiers
+          [
+            Identifiers::InternationalStandard,
+            Identifiers::TechnicalReport,
+            Identifiers::TechnicalSpecification,
+            Identifiers::Guide,
+            Identifiers::Pas,
+            Identifiers::Data,
+            Identifiers::TechnologyTrendsAssessments,
+            Identifiers::InternationalWorkshopAgreement,
+            Identifiers::InternationalStandardizedProfile,
+            Identifiers::Recommendation,
+            Identifiers::Directives,
+            Identifiers::Amendment,
+            Identifiers::Corrigendum,
+            Identifiers::Supplement,
+            Identifiers::Extract,
+            Identifiers::DirectivesSupplement,
+            Identifiers::Addendum,
+            Identifiers::TcDocument,
+          ]
+        end
+
+        def typed_stages
+          identifiers.flat_map { |klass| klass::TYPED_STAGES }.compact
+        end
+
+        def supplement_typed_stages
+          supplement_identifiers = [
+            Identifiers::Amendment,
+            Identifiers::Corrigendum,
+            Identifiers::Supplement,
+            Identifiers::Extract,
+            Identifiers::Addendum,
+          ]
+          supplement_identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+      end
+
+      # Initialize the scheme with identifiers
+      def initialize
+        super(
+          identifiers: self.class.identifiers,
+          supplement_identifiers: [
+            Identifiers::Amendment,
+            Identifiers::Corrigendum,
+            Identifiers::Supplement,
+            Identifiers::Extract,
+            Identifiers::Addendum,
+          ],
+        )
+      end
+
+      # Parse an ISO identifier string using memoized parser/builder
+      # @param identifier [String] the identifier string to parse
+      # @return [Identifier] the parsed identifier
+      def parse(identifier)
+        # Handle DAD/FDAD patterns that parser can't recognize
+        if match = identifier.match(/^(.+?)\/(F?DAD)\s+(\d+)(?::(\d{4}))?$/)
+          parse_dad_pattern(match)
+        else
+          # Apply legacy update_codes normalization first, before any other preprocessing
+          normalized = Core::UpdateCodes.apply(identifier, :iso)
+          # Normalize Cyrillic (Russian) identifiers to Latin equivalents
+          normalized = normalize_cyrillic(normalized)
+          parsed = parser.parse(normalized)
+          builder.build(parsed)
+        end
+      end
+
+      private
+
+      # Memoized parser instance
+      # @return [Pubid::Iso::Parser] parser instance
+      def parser
+        @parser ||= ::Pubid::Iso::Parser.new
+      end
+
+      # Memoized builder instance
+      # @return [Pubid::Iso::Builder] builder instance
+      def builder
+        @builder ||= ::Pubid::Iso::Builder.new(self)
+      end
+
+      # Normalize Cyrillic (Russian) ISO identifiers to Latin equivalents
+      # ИСО = ISO, МЭК = IEC, Руководство/Руководства = Guide,
+      # ОПМС = FDIS, ПМС = DIS, ТО = TR, ТС = TS
+      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 DAD/FDAM pattern manually
+      # Pattern: "ISO 2631/DAD 1" or "ISO 2553/DAD 1:1987"
+      # The parser fails because it treats "/" as copublisher separator
+      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
+
+        # Parse the base identifier normally (without supplement)
+        base_parsed = parser.parse(base_str)
+        base_identifier = builder.build(base_parsed)
+
+        # Construct the Addendum supplement manually
+        addendum = Identifiers::Addendum.new
+        addendum.base_identifier = base_identifier
+        addendum.number = Iso::Components::Code.new(number: supplement_number)
+        addendum.date = Pubid::Components::Date.new(year: supplement_year) if supplement_year
+
+        # Set typed_stage from register (uses TYPED_STAGES in Addendum class)
+        typed_stage = locate_typed_stage_by_abbr(stage_abbr)
+        addendum.typed_stage = typed_stage
+        addendum.stage = typed_stage.to_stage
+        addendum.type = typed_stage.to_type
+
+        addendum
+      end
+    end
+  end
+end

data/lib/pubid/iso/single_identifier.rb

@@ -3,12 +3,15 @@
 module Pubid
   module Iso
     class SingleIdentifier < Identifier
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
       private
 
       def build_rendering_context(_renderer, format:, with_edition: false,
                                   lang: :en, lang_single: false,
-                                  stage_format_long: nil, with_date: nil,
-                                  annotated: false)
+                                  stage_format_long: nil, with_date: nil)
         if format == :mr_string
           nil
         elsif lang_single || stage_format_long || !with_date.nil?
@@ -16,19 +19,17 @@ 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(annotated: annotated)
+          detect_rendering_context
         end
       end
 
-      def detect_rendering_context(annotated: false)
+      def detect_rendering_context
         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

@@ -3,31 +3,18 @@
 module Pubid
   module Iso
     class SupplementIdentifier < SingleIdentifier
-      attribute :base, Identifier,
+      attribute :base_identifier, Identifier,
                 polymorphic: true
 
       key_value do
-        # Serialized key is "base" (matches JIS); the attribute/method stays
-        # `base`, which relaton-index's get_id_number depends on.
-        map "base", to: :base, polymorphic: {
+        map "base_identifier", 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: `root` returns
-      # self when there is no base, which would otherwise recurse forever.
       def publisher
-        root.publisher if base
-      end
-
-      def copublishers
-        root.copublishers if base
+        base_identifier&.publisher
       end
 
       def to_s(**opts)
@@ -35,19 +22,6 @@ module Pubid
         Pubid::Renderers::SupplementRenderer.new(self).render(context:,
                                                               **opts.slice(:with_edition))
       end
-
-      # MR supplement suffix: `/{type}.{number}.{year}` (e.g. "/amd.1.2020").
-      # The MrString renderer recurses into `base` and appends this so the
-      # full supplement chain round-trips losslessly (issue #142).
-      def mr_supplement_suffix
-        segments = []
-        segments << mr_type if mr_type
-        segments << number&.to_s if number
-        segments << date&.year&.to_s if date&.year
-        return nil if segments.empty?
-
-        segments.join(".")
-      end
     end
   end
 end