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

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

@@ -6,24 +6,64 @@ module Pubid
   module Itu
     module Components
       # ITU Code component
-      # Format: NUMBER[.SUBSERIES][-PART]
-      # Examples: 1234, 1234.5, 1234-1, 1234.5-2
+      # Format: [Imp]NUMBER[SUFFIX][.SUBSERIES][-PART]
+      # Examples: 1234, 1234.5, 1234-1, 1234.5-2, 50bis, 8bis, Imp712, ImpOSI
+      #
+      # The optional "Imp" marker identifies an Implementers' Guide for the
+      # series (e.g. G.Imp712, X.ImpOSI); the NUMBER that follows may be
+      # digits or a short letter string.
+      #
+      # SUFFIX is the edition marker "bis" / "ter" / "quater" attached
+      # directly to the number (e.g. X.50bis, V.8bis).
       #
       # Stays independent of Pubid::Components::Code because ITU uses
       # +subseries+ (dot-separated, flavor-specific) and +parts+
       # (dash-separated).
       class Code < Lutaml::Model::Serializable
+        attribute :imp_marker, :string
         attribute :number, :string
+        attribute :series_suffix, :string
+        # ITU prints the edition word both glued ("X.50bis") and space-
+        # separated ("E.250 bis"). The word itself is stored without the space,
+        # so `series_suffix` stays a clean, whitespace-free value to compare and
+        # index on; the spacing is this rendering-only flag. Named for the
+        # rarer-in-code form so the `false` default stays out of `to_hash`.
+        attribute :series_suffix_spaced, :boolean, default: -> { false }
         attribute :subseries, :string
         attribute :parts, :string, collection: true, default: []
+        # A single trailing letter distinguishing variants of one
+        # Recommendation: "D.200 R" (old D-series tariff recommendations),
+        # "Q.2931 B", "R.38 A", the glued "D.502R" and the lowercase
+        # "I.256.2a". Spaced is the majority spelling, so the glued one is the
+        # flag.
+        attribute :qualifier, :string
+        attribute :qualifier_glued, :boolean, default: -> { false }
 
+        # Segment order mirrors the grammar exactly — a GLUED suffix is
+        # captured inside `standard_code` (the edition word before the
+        # subseries, the qualifier after the parts), while a SPACED one is
+        # captured afterwards by `code_suffixes`. Rendering the edition word
+        # unconditionally first would print "Q.11a bis" back as "Q.11 bisa".
         def to_s
-          result = number.to_s
+          result = "#{imp_marker}#{number}"
+          result += series_suffix.to_s if series_suffix && !series_suffix_spaced
           result += ".#{subseries}" if subseries
           result += parts.map { |p| "-#{p}" }.join if parts&.any?
+          result += qualifier.to_s if qualifier && qualifier_glued
+          result += " #{series_suffix}" if series_suffix && series_suffix_spaced
+          result += " #{qualifier}" if qualifier && !qualifier_glued
           result
         end
 
+        # Space-free rendering for URN and MR use: the print form may separate
+        # the edition word or the qualifier letter with a space ("E.250 bis",
+        # "D.200 R"), which is not admissible inside a URN segment. Removing
+        # the space keeps "D.200" and "D.200 R" on distinct URNs, which
+        # dropping the suffix would not.
+        def compact_s
+          to_s.delete(" ")
+        end
+
         def render(context: nil)
           to_s
         end
@@ -31,9 +71,12 @@ module Pubid
         def ==(other)
           return false unless other.is_a?(Code)
 
-          number == other.number &&
+          imp_marker == other.imp_marker &&
+            number == other.number &&
+            series_suffix == other.series_suffix &&
             subseries == other.subseries &&
-            parts == other.parts
+            parts == other.parts &&
+            qualifier == other.qualifier
         end
       end
     end

data/lib/pubid/itu/components/designation.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Itu
+    module Components
+      # One series+number designation of a combined (joint) recommendation.
+      # A combined recommendation such as "ITU-T G.780/Y.1351" keeps its primary
+      # designation on the base identifier (series "G", code "780") and carries
+      # each *additional* designation ("Y.1351", and any further "/Z.1362" …) as
+      # a Designation in Identifiers::CombinedIdentifier#combined.
+      #
+      # Format: SERIES.CODE  (e.g. "Y.1351", "Y.1362-2")
+      class Designation < Lutaml::Model::Serializable
+        attribute :series, Pubid::Itu::Components::Series
+        attribute :code, Pubid::Itu::Components::Code
+
+        def to_s
+          "#{series}.#{code}"
+        end
+
+        def render(context: nil)
+          to_s
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Designation)
+
+          series == other.series && code == other.code
+        end
+      end
+    end
+  end
+end

data/lib/pubid/itu/components.rb

@@ -6,6 +6,7 @@ module Pubid
       autoload :Sector, "#{__dir__}/components/sector"
       autoload :Series, "#{__dir__}/components/series"
       autoload :Code, "#{__dir__}/components/code"
+      autoload :Designation, "#{__dir__}/components/designation"
     end
   end
 end

data/lib/pubid/itu/identifier.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
 # Pubid::Itu::Identifier is the ITU 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"
+# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.

data/lib/pubid/itu/identifiers/addendum.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    module Identifiers
+      # Addendum identifier (Add.)
+      # Pattern: "ITU-T I.363 (1993) Add. 1 (11/1993)"
+      class Addendum < Supplement
+        def to_s(**opts)
+          annotate_plain_render(render_supplement("Add."), **opts)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/itu/identifiers/amendment.rb

@@ -4,36 +4,14 @@ module Pubid
   module Itu
     module Identifiers
       # Amendment identifier (Amd)
-      # Pattern: "ITU-T G.989 Amd 1", "ITU-T G.780/Y.1351 Amd 1 (2004)"
+      # Pattern: "ITU-T G.989 Amd. 1", "ITU-T G.780/Y.1351 Amd. 1 (2004)"
       class Amendment < Supplement
-        def to_s
-          result = base ? base.to_s : "#{publisher}-#{sector}"
-
-          # Add series if no base
-          if !base && series
-            result += " #{series}"
-          end
-
-          result += " Amd #{number}"
-
-          # Add date if present
-          if date
-            result += if date.month
-                        " (#{date.month}/#{date.year})"
-                      else
-                        " (#{date.year})"
-                      end
-          end
-
-          result
-        end
-
-        def ==(other)
-          return false unless other.is_a?(Amendment)
-
-          base == other.base &&
-            number == other.number &&
-            date == other.date
+        # "Amd." with the period, matching ITU's own rendering and the sibling
+        # supplement types (Cor./Err./Suppl./Add.). The parser accepts both
+        # spellings (see Parser#supplement_type), so the period-less input form
+        # still round-trips through parse — it just normalizes here.
+        def to_s(**opts)
+          annotate_plain_render(render_supplement("Amd."), **opts)
         end
       end
     end

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

@@ -12,8 +12,19 @@ module Pubid
       #   * long with i18n_lang + format: :long: per-language `annex_long` template
       # Languages without an `annex_to` entry (fr/es/ru/zh) use the long
       # template for the short form too.
-      class Annex < Base
-        attribute :base, Base, polymorphic: true
+      class Annex < Identifier
+        attribute :base, Identifier, polymorphic: true
+
+        # Compact serialization: an Annex is just the nested (itself-flat) base
+        # plus its own language; everything else is delegated to `base`.
+        key_value do
+          map "_type", to: :_type
+          map "base", with: { to: :base_to_kv, from: :base_from_kv }
+          map "language", to: :language
+          map "common_text_twin",
+              with: { to: :common_text_twin_to_kv,
+                      from: :common_text_twin_from_kv }
+        end
 
         def to_urn
           # Annex URN: append :annex to the inner identifier's URN.

data/lib/pubid/itu/identifiers/annex_of_recommendation.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    module Identifiers
+      # A labelled annex of a Recommendation — "ITU-T A.23 Annex A (06/2014)",
+      # "ITU-T Z.100 Annex F3 (10/2019)", "ITU-T G.729 Annex C+ (02/2000)".
+      #
+      # The annex is a document in its own right: it is published (and dated)
+      # separately from the Recommendation it annexes, and may itself carry a
+      # corrigendum/errata/amendment ("ITU-T G.729 Annex B (1996) Cor. 3
+      # (03/2001)").
+      #
+      # Distinct from Identifiers::Annex, which models the label-less
+      # "Annex to ITU OB No. 1000" form (a prefix rendering with its own i18n
+      # templates). Keeping them apart keeps each `_type` — already persisted in
+      # relaton index rows — unambiguous.
+      class AnnexOfRecommendation < Identifier
+        attribute :base, Identifier, polymorphic: true
+        # The annex label ("A", "F3", "C+"). Named `number` for symmetry with
+        # Supplement's ordinal; it shadows Identifier#number (code&.number),
+        # which is nil here anyway — the document number is reached via #root.
+        attribute :number, :string
+
+        # Compact serialization: the annex is the nested (itself-flat) base plus
+        # its own label, date and language. sector/series/code are the base's
+        # and are deliberately not re-emitted (the wrapper lesson).
+        key_value do
+          map "_type", to: :_type
+          map "number", to: :number
+          map "year", with: { to: :year_to_kv, from: :year_from_kv }
+          map "month", with: { to: :month_to_kv, from: :month_from_kv }
+          map "base", with: { to: :base_to_kv, from: :base_from_kv }
+          map "language", to: :language
+          map "common_text_twin",
+              with: { to: :common_text_twin_to_kv,
+                      from: :common_text_twin_from_kv }
+        end
+
+        # "<base urn>:annex:<label>[:<date>]" — the annex's own date must be
+        # there, or two editions of one annex share a URN (the base's date
+        # rides inside base_urn, so omitting the annex's would be asymmetric).
+        def to_urn
+          segments = [base&.to_urn || "urn:itu", "annex", number&.downcase]
+          segments << urn_date_segment
+          segments.compact.join(":")
+        end
+
+        def render_base(**opts)
+          result = base ? base.render_base(**opts) : "#{publisher}-#{sector}"
+
+          "#{result} Annex #{number}#{render_date_suffix}"
+        end
+
+        # MR: recurse into the annexed document and append "annex.<label>[.year]"
+        # (the documented supplement-suffix hook), so the slug stays distinct
+        # per annex. Without it the wrapper's own nil sector/series/code would
+        # collapse every annex onto a bare "itu.<year>".
+        def mr_supplement_suffix
+          # "C+" -> "cplus", not "c" — the MR charset excludes "+", and
+          # dropping it would collide with the sibling "Annex C".
+          label = number.to_s.downcase.gsub("+", "plus").gsub(/[^a-z0-9]/, "")
+
+          ["annex", label.empty? ? nil : label, date&.year].compact.join(".")
+        end
+
+        def ==(other)
+          return false unless other.instance_of?(self.class)
+
+          base == other.base &&
+            number == other.number &&
+            date == other.date &&
+            language == other.language &&
+            common_text_twin == other.common_text_twin
+        end
+
+        private
+
+        def urn_date_segment
+          return nil unless date
+
+          date.month ? "#{date.month}/#{date.year}" : date.year.to_s
+        end
+      end
+    end
+  end
+end

data/lib/pubid/itu/identifiers/appendix_of_recommendation.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    module Identifiers
+      # A labelled appendix of a Recommendation — "ITU-T G.101 App. I
+      # (05/2000)", "ITU-T G.722 (1988) App. IV (11/2006)".
+      #
+      # Structurally the twin of AnnexOfRecommendation: an appendix is
+      # published and dated separately from the Recommendation it appends, and
+      # may itself carry an amendment/errata ("ITU-T G.729 App. I (2002)
+      # Amd. 1"). The label is a Roman numeral rather than a series letter.
+      class AppendixOfRecommendation < Identifier
+        attribute :base, Identifier, polymorphic: true
+        # The appendix label ("I", "II", "IV"). Named `number` for symmetry
+        # with Supplement's ordinal and AnnexOfRecommendation's label; it
+        # shadows Identifier#number (code&.number), which is nil here anyway —
+        # the document number is reached via #root.
+        attribute :number, :string
+        # The companion artefact published under the appendix's designation:
+        # "test vectors" or "Software". Its own catalogue record, so it must
+        # stay distinct from the appendix itself.
+        attribute :material, :string
+
+        # Compact serialization: the nested (itself-flat) base plus this
+        # document's own label, date and language. sector/series/code belong to
+        # the base and are deliberately not re-emitted.
+        key_value do
+          map "_type", to: :_type
+          map "number", to: :number
+          map "material", to: :material
+          map "year", with: { to: :year_to_kv, from: :year_from_kv }
+          map "month", with: { to: :month_to_kv, from: :month_from_kv }
+          map "base", with: { to: :base_to_kv, from: :base_from_kv }
+          map "language", to: :language
+          map "common_text_twin",
+              with: { to: :common_text_twin_to_kv,
+                      from: :common_text_twin_from_kv }
+        end
+
+        # "<base urn>:appendix:<label>[:<date>]" — the appendix's own date must
+        # be there, or two editions of one appendix share a URN (the base's
+        # date rides inside base_urn, so omitting this one would be asymmetric).
+        def to_urn
+          segments = [base&.to_urn || "urn:itu", "appendix", number&.downcase]
+          # Without this the test-vector record and the appendix itself would
+          # share a URN.
+          segments << material.downcase.gsub(/[^a-z0-9]/, "") if material
+          segments << urn_date_segment
+          segments.compact.join(":")
+        end
+
+        def render_base(**opts)
+          result = base ? base.render_base(**opts) : "#{publisher}-#{sector}"
+
+          result += " App. #{number}"
+          result += " #{material}" if material
+          result + render_date_suffix
+        end
+
+        # MR: recurse into the appendixed document and append
+        # "app.<label>[.year]" (the documented supplement-suffix hook), so the
+        # slug stays distinct per appendix. Without it the wrapper's own nil
+        # sector/series/code would collapse every appendix onto "itu.<year>".
+        def mr_supplement_suffix
+          label = "#{number}#{material}".downcase.gsub(/[^a-z0-9]/, "")
+
+          ["app", label.empty? ? nil : label, date&.year].compact.join(".")
+        end
+
+        def ==(other)
+          return false unless other.instance_of?(self.class)
+
+          base == other.base &&
+            number == other.number &&
+            material == other.material &&
+            date == other.date &&
+            language == other.language &&
+            common_text_twin == other.common_text_twin
+        end
+
+        private
+
+        def urn_date_segment
+          return nil unless date
+
+          date.month ? "#{date.month}/#{date.year}" : date.year.to_s
+        end
+      end
+    end
+  end
+end