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

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

@@ -35,11 +35,11 @@ module Pubid
 
         # Delegate base identifier attributes for easier access
         def copublishers
-          base_identifier&.copublishers
+          base&.copublishers
         end
 
         def publisher
-          base_identifier&.publisher
+          base&.publisher
         end
 
         TYPED_STAGES = [
@@ -61,19 +61,19 @@ module Pubid
         # def render_directives_supplement_identifier(identifier)
         #   raise "Not a directives supplement identifier" unless identifier.is_a?(Identifiers::DirectivesSupplement)
 
-        #   render(identifier.base_identifier) +
+        #   render(identifier.base) +
         #     " #{identifier.publisher.body}" +
         #     " #{identifier.stage.abbr}" +
         #     (identifier.date ? ":#{identifier.date.year}" : "")
         # end
 
         def to_s(lang: :en, lang_single: false, with_edition: false,
-format: nil, stage_format_long: nil, with_date: nil)
-          if base_identifier
+format: nil, stage_format_long: nil, with_date: nil, **opts)
+          if base
             # Full rendering with base identifier
             [
-              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),
+              base.to_s(lang: lang, lang_single: lang_single,
+                                   with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts),
               " #{supplement_publisher.render}",
               " SUP", # Always render as "SUP" even though typed_stage.abbreviation is "DIR SUP"
               (date ? ":#{date.render}" : ""),
@@ -81,13 +81,13 @@ format: nil, stage_format_long: nil, with_date: nil)
             ].join
           else
             # Simplified rendering for bundled identifiers (just the supplement part)
-            to_supplement_s(lang: lang, lang_single: lang_single)
+            to_supplement_s(lang: lang, lang_single: lang_single, **opts)
           end
         end
 
         # Render just the supplement part (for use in bundled identifiers)
         def to_supplement_s(lang: :en, lang_single: false, with_edition: false,
-format: nil, stage_format_long: nil, with_date: nil)
+format: nil, stage_format_long: nil, with_date: nil, **_opts)
           date_str = if date
                        month_part = date.month ? "-#{date.month}" : ""
                        ":#{date.render}#{month_part}"
@@ -107,8 +107,8 @@ format: nil, stage_format_long: nil, with_date: nil)
         def to_urn
           urn_ctx = Rendering::RenderingContext.urn
 
-          # If this is a standalone supplement (no base_identifier), build URN directly
-          unless base_identifier
+          # If this is a standalone supplement (no base), build URN directly
+          unless base
             parts = ["urn", "iso", "doc"]
             parts << supplement_publisher.render(context: urn_ctx) if supplement_publisher
             parts << "sup"
@@ -118,7 +118,7 @@ format: nil, stage_format_long: nil, with_date: nil)
           end
 
           # Start with base identifier's URN parts (it will use urn:iso:doc scheme)
-          base_urn = base_identifier.to_urn
+          base_urn = base.to_urn
 
           # Handle JTC pattern specially
           if supplement_publisher&.body&.match?(/^JTC\s+(\d+)$/i)

data/lib/pubid/iso/normalizer.rb

@@ -69,10 +69,10 @@ module Pubid
           supplement_year = match[4]   # "1987" or nil
 
           base_parsed = Pubid::Iso.parser.parse(base_str)
-          base_identifier = Pubid::Iso.builder.build(base_parsed)
+          base = Pubid::Iso.builder.build(base_parsed)
 
           addendum = Identifiers::Addendum.new
-          addendum.base_identifier = base_identifier
+          addendum.base = base
           addendum.number = Iso::Components::Code.new(value: supplement_number)
           addendum.date = Pubid::Components::Date.new(year: supplement_year) if supplement_year
 

data/lib/pubid/iso/parser.rb

@@ -3,7 +3,7 @@ require "parslet"
 
 module Pubid
   module Iso
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 
@@ -99,7 +99,7 @@ module Pubid
       rule(:iso_r_supplement_identifier) do
         (
           str("ISO/R").as(:iso_r_prefix) >> space >> iso_r_second_part
-        ).as(:base_identifier) >>
+        ).as(:base) >>
           iso_r_supplement_separator >>
           supplement_type_with_stage >>
           space? >> second_part >> third_part
@@ -148,12 +148,16 @@ module Pubid
       end
 
       rule(:date) do
-        # :2005-02
+        # :2005-02 or :-- (undated reference — ISO/IEC undated-reference form,
+        # e.g. ISO 16634:--, also accepted as the em-dash variant ISO 16634:—)
         (str(":") | dash) >>
-          (year_digits >>
-            (dash >> month_digits).maybe >>
-            (dash >> day_digits).maybe
-          ).as(:date).maybe
+          (
+            (str("--") | str("—")).as(:undated_marker) |
+              (year_digits >>
+                (dash >> month_digits).maybe >>
+                (dash >> day_digits).maybe
+              ).as(:date)
+          ).maybe
       end
 
       rule(:part_and_subpart) do
@@ -270,14 +274,14 @@ module Pubid
       end
 
       # For joint identifiers, we do not treat it as a supplementary identifier
-      # (hence not a base_identifier)
+      # (hence not a base)
       # 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) >>
+        identifier_copublishers_no_third.as(:base) >>
           space? >> str("|") >> space? >>
           scope { idf_identifier }.as(:joint_identifier)
       end
@@ -336,7 +340,7 @@ 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) >>
+        identifier_copublishers_no_third.as(:base) >>
           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".
@@ -351,14 +355,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_identifier) >>
+        supplement_identifier_no_third.as(:base) >>
           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_identifier) >>
+        supplement_supplement_identifier.as(:base) >>
           str("/") >> supplement_type_with_stage >>
           ((space? >> second_part >> third_part) | (str(".") >> digits.as(:number) >> third_part))
       end
@@ -408,7 +412,7 @@ module Pubid
       end
 
       rule(:directives_supplement_identifier) do
-        directives_identifier_no_third.as(:base_identifier) >> space? >> directives_supplement_part
+        directives_identifier_no_third.as(:base) >> space? >> directives_supplement_part
       end
 
       DIRECTIVES_SUPPLEMENTS_TYPED_STAGES = Identifiers::DirectivesSupplement::TYPED_STAGES.map(&:abbr).flatten.sort_by(&:length).reverse

data/lib/pubid/iso/supplement_identifier.rb

@@ -3,13 +3,13 @@
 module Pubid
   module Iso
     class SupplementIdentifier < SingleIdentifier
-      attribute :base_identifier, Identifier,
+      attribute :base, Identifier,
                 polymorphic: true
 
       key_value do
         # 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: {
+        # `base`, which relaton-index's get_id_number depends on.
+        map "base", to: :base, polymorphic: {
           attribute: "_type",
           class_map: Identifier::ISO_TYPE_MAP,
         }
@@ -20,14 +20,14 @@ module Pubid
       # 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
+      # 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_identifier
+        root.publisher if base
       end
 
       def copublishers
-        root.copublishers if base_identifier
+        root.copublishers if base
       end
 
       def to_s(**opts)
@@ -35,6 +35,19 @@ 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

data/lib/pubid/iso/urn_generator.rb

@@ -84,7 +84,7 @@ module Pubid
 
         while current.is_a?(SupplementIdentifier)
           supplement_chain.unshift(current)
-          current = current.base_identifier
+          current = current.base
         end
 
         base_id = current
@@ -258,6 +258,9 @@ module Pubid
 
       def year_component
         return nil unless identifier.date&.present?
+        # Undated references (e.g. ISO 16634:--) drop the year slot in the URN,
+        # matching the date-less identifier's URN form (per issue #138).
+        return nil if identifier.date&.undated?
         return nil if identifier.is_a?(Pubid::Iso::SingleIdentifier)
 
         identifier.date.render(context: URN_CONTEXT)

data/lib/pubid/iso/urn_parser.rb

@@ -425,7 +425,7 @@ typed_stage
 
           # Wrap current identifier with supplement
           base_hash = {
-            base_identifier: base_hash,
+            base: base_hash,
             **supp_hash,
           }
         end

data/lib/pubid/iso.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 require "lutaml/model"
 
 module Pubid
@@ -31,8 +32,13 @@ module Pubid
     # @param format [Symbol] :auto, :human, :mr_string, or :urn
     # @return [Identifier] the parsed identifier
     def self.parse(identifier, format: :auto)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
       if identifier.length > Pubid::MAX_INPUT_LENGTH
-        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
       format = Pubid::FormatDetector.detect(identifier) if format == :auto

data/lib/pubid/itu/builder.rb

@@ -13,15 +13,59 @@ module Pubid
           return build_annex(data[:annex_to])
         end
 
+        # Common-text twin ("| ISO/IEC ..." suffix) — extract before building
+        # the base ITU identifier, then attach to whichever class the base
+        # resolves to.
+        twin = parse_common_text_twin(data.delete(:common_text_twin))
+
+        # Labelled annex of a Recommendation — "ITU-T A.23 Annex A (06/2014)".
+        # The annexed document is the :base subtree; :year/:month at this level
+        # are the annex's own date, not the base's.
+        if data[:annex_number]
+          annex = build_annex_of_recommendation(data)
+          annex.common_text_twin = twin if twin
+          return annex
+        end
+
+        # Labelled appendix of a Recommendation — "ITU-T G.101 App. I
+        # (05/2000)". Same shape as the annex above.
+        if data[:appendix_number]
+          appendix = build_appendix_of_recommendation(data)
+          appendix.common_text_twin = twin if twin
+          return appendix
+        end
+
         # Operational Bulletin (Special Publication) — series == "OB" or
         # legacy long form ("Operational Bulletin No. ...").
-        if data[:series].to_s == "OB" || data[:_op_bull]
-          return build_special_publication(data)
+        # The series_dash guard keeps a series-code "ITU-T OB-1" out of this
+        # branch, which would drop the dash and render it "ITU OB No. 1".
+        # Belt-and-braces: `series_code_body` already refuses "OB" + dash, so
+        # nothing reaches here with both set — the guard documents that coupling
+        # so removing the parser's `absent?` fails loudly rather than silently
+        # rerouting.
+        if (data[:series].to_s == "OB" && data[:series_dash].nil?) ||
+            data[:_op_bull]
+          sp = build_special_publication(data)
+          sp.common_text_twin = twin if twin && sp
+          return sp
         end
 
         # Check if this is a supplement identifier
         if data[:supplement_type]
-          return build_supplement(data)
+          supp = build_supplement(data)
+          supp.common_text_twin = twin if twin && supp
+          return supp
+        end
+
+        # Handbook — "ITU-R 42.HDB"
+        if data[:handbook_marker]
+          return build_handbook(data)
+        end
+
+        # Question — numeric ("ITU-R 234-1/7:") or letter-series
+        # ("ITU-R P.3/BL/7"). Both carry a :study_group marker.
+        if data[:study_group]
+          return build_question(data)
         end
 
         # Build basic recommendation or combined identifier
@@ -30,44 +74,77 @@ module Pubid
         code = build_code(data) if data[:number]
         date = build_date(data) if data[:year]
 
-        # Check if this is a combined identifier (has combined_series and combined_number)
-        if data[:combined_series] || data[:combined_number]
-          if data[:combined_series]
-            combined_series = Components::Series.new(
-              series: data[:combined_series][:series].to_s,
-            )
-          end
-
-          if data[:combined_number]
-            combined_code = Components::Code.new(
-              number: data[:combined_number].to_s,
-              subseries: data[:combined_subseries]&.to_s,
-              parts: extract_parts(data[:combined_parts]),
-            )
-          end
-
+        # Combined (joint) recommendation — one or more additional
+        # "/SERIES.CODE" designations after the primary (e.g. "G.780/Y.1351",
+        # "G.780/Y.1351/Z.1362"). The primary stays on the base series/code.
+        if data[:combined]
           return Identifiers::CombinedIdentifier.new(
             sector: sector,
             series: series,
             code: code,
-            combined_series: combined_series,
-            combined_code: combined_code,
+            combined: build_designations(data[:combined]),
             date: date,
+            version: data[:version]&.to_s,
+            # with_series offers these slots on either side of
+            # combined_suffixes, so a joint id can carry them too; not
+            # forwarding them let "ITU-T H.350/X.1 attachment" compare equal to
+            # the un-attached document.
+            series_word: !data[:series_word].nil?,
+            series_dash: !data[:series_dash].nil?,
+            attachment: !data[:attachment].nil?,
+            range_end: data[:range_end]&.to_s,
             language: data[:language]&.to_s,
+            common_text_twin: twin,
           )
         end
 
-        Identifiers::Recommendation.new(
+        # A Report ("Report ITU-R BT.2020-1") is shaped exactly like a
+        # Recommendation — only the leading word, captured as :report_marker,
+        # tells the two apart, and it has to, because the two series number
+        # independently and the same series/number is two real documents.
+        klass = data[:report_marker] ? Identifiers::Report : Identifiers::Recommendation
+
+        klass.new(
           sector: sector,
           series: series,
           code: code,
           date: date,
+          version: data[:version]&.to_s,
+          series_word: !data[:series_word].nil?,
+          series_dash: !data[:series_dash].nil?,
+          attachment: !data[:attachment].nil?,
+          range_end: data[:range_end]&.to_s,
           language: data[:language]&.to_s,
+          common_text_twin: twin,
         )
       end
 
+      # Parse the common-text twin string ("| ISO/IEC 13818-1:2022") into
+      # the appropriate flavor's identifier object. Returns nil if the twin
+      # is empty or unparseable.
+      def parse_common_text_twin(twin_raw)
+        return nil if twin_raw.nil?
+
+        twin_str = twin_raw.to_s.strip
+        # Strip a leading pipe if the parser captured it
+        twin_str = twin_str.sub(/\A\s*\|\s*/, "")
+        return nil if twin_str.empty?
+
+        case twin_str
+        when /\AISO\/IEC\b/, /\AISO\b/
+          Pubid::Iso.parse(twin_str)
+        when /\AIEC\b/
+          Pubid::Iec.parse(twin_str)
+        end
+      rescue StandardError
+        # If the twin doesn't parse as a known flavor, leave it as nil
+        # rather than blowing up the whole parse — the ITU half is still
+        # usable on its own.
+        nil
+      end
+
       # Build Special Publication (OB). Sector is silently dropped — OB is a
-      # cross-bureau publication and `Identifiers::Base` rejects sector+OB
+      # cross-bureau publication and `Identifier` rejects sector+OB
       # in its constructor.
       def build_special_publication(data)
         Identifiers::SpecialPublication.new(
@@ -88,6 +165,59 @@ module Pubid
         )
       end
 
+      # Build a labelled annex of a Recommendation. sector/series/code are
+      # deliberately NOT copied from the base: they are not serialized on the
+      # wrapper, so copies would make a from_hash-rebuilt annex differ from the
+      # parsed one.
+      def build_annex_of_recommendation(data)
+        Identifiers::AnnexOfRecommendation.new(
+          base: build(data[:base]),
+          number: data[:annex_number].to_s,
+          date: data[:year] ? build_date(data) : nil,
+          language: data[:language]&.to_s,
+        )
+      end
+
+      # Build a labelled appendix of a Recommendation. Like the annex above,
+      # sector/series/code are deliberately NOT copied from the base — they are
+      # not serialized on the wrapper, so copies would make a from_hash-rebuilt
+      # appendix differ from the parsed one.
+      def build_appendix_of_recommendation(data)
+        Identifiers::AppendixOfRecommendation.new(
+          base: build(data[:base]),
+          number: data[:appendix_number].to_s,
+          material: data[:appendix_material]&.to_s,
+          date: data[:year] ? build_date(data) : nil,
+          language: data[:language]&.to_s,
+        )
+      end
+
+      # Build Handbook ("ITU-R 42.HDB").
+      def build_handbook(data)
+        Identifiers::Handbook.new(
+          sector: Components::Sector.new(sector: data[:sector].to_s),
+          code: build_code(data),
+          date: data[:year] ? build_date(data) : nil,
+        )
+      end
+
+      # Build Question (numeric or letter-series).
+      def build_question(data)
+        series = if data[:series]
+                   Components::Series.new(series: data[:series].to_s)
+                 end
+
+        Identifiers::Question.new(
+          sector: Components::Sector.new(sector: data[:sector].to_s),
+          series: series,
+          code: build_code(data),
+          study_group: data[:study_group].to_s,
+          has_bl: !data[:has_bl].nil?,
+          bracketed: !data[:bracketed].nil?,
+          has_colon: !data[:question_colon].nil?,
+        )
+      end
+
       def build_supplement(data)
         # Build the base identifier first
         base = build(data[:base]) if data[:base]
@@ -97,10 +227,22 @@ module Pubid
         klass = case supplement_type
                 when "Amd"
                   Identifiers::Amendment
+                when "Add"
+                  Identifiers::Addendum
                 when "Cor"
                   Identifiers::Corrigendum
+                when "Err"
+                  Identifiers::Errata
                 when "Suppl"
                   Identifiers::Supplement
+                else
+                  # Previously fell through to a nil class and died with
+                  # "undefined method 'new' for nil" one frame later. Any token
+                  # added to Parser#supplement_type without a class here should
+                  # say so.
+                  raise ArgumentError,
+                        "Unknown ITU supplement type: " \
+                        "#{data[:supplement_type].inspect}"
                 end
 
         # Build supplement date (separate from base date)
@@ -111,25 +253,84 @@ module Pubid
                             )
                           end
 
-        # Build supplement with extracted components
-        klass.new(
-          sector: base&.sector || Components::Sector.new(sector: data[:sector].to_s),
-          series: base&.series || (data[:series] ? Components::Series.new(series: data[:series].to_s) : nil),
-          code: base&.code,
+        # Sector/series are copied from the base when it has them; the fallback
+        # to this level's own tokens is guarded because an annex base keeps
+        # sector/series/code on *its* base, leaving all three nil here while the
+        # supplement level carries no sector token of its own.
+        # An annex base keeps sector/series/code on *its* base, so reach through
+        # it via #root; otherwise a supplement of an annex would carry none of
+        # them and its MR string would collapse to a bare "itu.<date>".
+        base_identity = base&.sector ? base : base&.root
+        sector = base_identity&.sector ||
+          (Components::Sector.new(sector: data[:sector].to_s) if data[:sector])
+        series = base_identity&.series ||
+          (Components::Series.new(series: data[:series].to_s) if data[:series])
+
+        attrs = {
+          sector: sector,
+          series: series,
+          code: base_identity&.code,
           base: base,
           number: data[:supplement_number].to_s,
+          # The marker is the captured space, so its ABSENCE is the flag.
+          number_glued: data[:supplement_space].nil?,
+          slash_joined: !data[:supplement_slash].nil?,
           date: supplement_date,
           language: data[:language]&.to_s,
-        )
+        }
+        # The "series" word rides on the supplement for the base-less,
+        # series-only form; with a base it is the base's, and renders from
+        # there. It is copied up anyway (like sector/series/code above) so the
+        # supplement's own MR slug stays distinct — `render_supplement` and the
+        # base-nil-guarded key_value/== only consult it when base is nil, so
+        # the copy is render- and serialization-neutral.
+        attrs[:series_word] = if base
+                                !!base_identity&.series_word
+                              else
+                                !data[:series_word].nil?
+                              end
+        attrs[:technical] = true if data[:technical] &&
+          klass == Identifiers::Corrigendum
+
+        klass.new(**attrs)
       end
 
       private
 
+      # Build the additional designations of a combined recommendation from the
+      # repeated parse subtrees (each `{ designation: { series:, number:, … } }`).
+      def build_designations(combined_data)
+        Array(combined_data).map do |element|
+          d = element[:designation] || element
+          Components::Designation.new(
+            series: Components::Series.new(series: d[:series].to_s),
+            code: Components::Code.new(
+              number: d[:number].to_s,
+              series_suffix: d[:series_suffix]&.to_s,
+              series_suffix_spaced: !d[:series_suffix_spaced].nil?,
+              subseries: d[:subseries]&.to_s,
+              parts: extract_parts(d[:parts]),
+              qualifier: d[:qualifier]&.to_s,
+              qualifier_glued: !d[:qualifier].nil? && d[:qualifier_spaced].nil?,
+            ),
+          )
+        end
+      end
+
       def build_code(data)
         Components::Code.new(
+          imp_marker: data[:imp_marker]&.to_s,
           number: data[:number].to_s,
+          series_suffix: data[:series_suffix]&.to_s,
+          # The marker is the captured separating space, so its presence is
+          # the flag for the edition word and its ABSENCE is the flag for the
+          # qualifier letter (whose majority spelling is spaced).
+          series_suffix_spaced: !data[:series_suffix_spaced].nil?,
           subseries: data[:subseries]&.to_s,
           parts: extract_parts(data[:parts]),
+          qualifier: data[:qualifier]&.to_s,
+          qualifier_glued: !data[:qualifier].nil? &&
+            data[:qualifier_spaced].nil?,
         )
       end