pubid 1.15.21 → 2.0.0.alpha.10

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/sector.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Itu
+    module Components
+      # ITU Sector component
+      # Values: R (Radio), T (Telecommunications), D (Development)
+      class Sector < Lutaml::Model::Serializable
+        attribute :sector, :string # R, T, or D
+
+        VALID_SECTORS = %w[R T D].freeze
+
+        # Accept either a positional Hash (lutaml-model's call style:
+        # `Sector.new({lutaml_register: :default})` then attribute assignment)
+        # or a literal `sector:` kwarg (`Sector.new(sector: "R")`). Both call
+        # paths funnel through the same validate-then-set flow so the attribute
+        # stays lutaml-tracked and round-trips through to_hash/from_hash.
+        def initialize(attrs = {}, options = {})
+          super
+          sector_val = attrs[:sector] || attrs["sector"]
+          return if sector_val.nil?
+
+          normalized = sector_val.to_s.upcase
+          unless VALID_SECTORS.include?(normalized)
+            raise ArgumentError,
+                  "Invalid sector: #{sector_val}. Must be R, T, or D"
+          end
+
+          self.sector = normalized
+        end
+
+        def to_s
+          sector
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Sector)
+
+          sector == other.sector
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Itu
+    module Components
+      # ITU Series component
+      # Examples: BO, V, X, A, etc.
+      class Series < Lutaml::Model::Serializable
+        attribute :series, :string # e.g., BO, V, X, R, SG1, OB
+
+        def to_s
+          series
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Series)
+
+          series == other.series
+        end
+      end
+    end
+  end
+end

data/lib/pubid/itu/components.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    module Components
+      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/i18n.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Pubid
+  module Itu
+    I18N = YAML.load_file(File.expand_path("i18n.yaml", __dir__)).freeze
+  end
+end

data/lib/pubid/itu/i18n.yaml

@@ -0,0 +1,30 @@
+# Translations for ITU identifier rendering.
+#
+# Ported from v1 monorepo gems/pubid-itu/i18n.yaml — only the sections
+# required by the "Annex to ITU OB" feature are populated here. The
+# `type`/`publisher` sections used by the v1 recommendation renderer are
+# intentionally omitted on v2: the v2 rendering pipeline does not yet wire
+# them up (a separate effort).
+
+# Translation of the "Annex to" prefix used when an annex has no number
+# (i.e. the document IS the annex of a Special Publication, not a sub-annex).
+# For Arabic the value is positioned as a postfix instead of a prefix.
+# Languages with an annex_long entry below (fr/es/ru/zh) intentionally have
+# no entry here — they use the long-form template for short rendering too,
+# so French short matches French long etc. This avoids mixing the English
+# "OB" abbreviation with localized text; ITU itself uses the localized
+# abbreviation (e.g. "BE" in French/Spanish).
+# German is not an official ITU language so no long template exists.
+annex_to:
+  ar: "ملحق"
+  de: Anhang zum
+
+# Long-form (title-style) templates for "Annex to ..." identifiers.
+# Used both for to_s(format: :long) and for short rendering when no
+# annex_to entry exists for the language.
+annex_long:
+  fr: "Annexe au BE de l'UIT %{number}"
+  es: "Anexo al BE de la UIT N.º %{number}"
+  ar: "ملحق ابلنشرة التشغيلية رقم %{number}"
+  ru: "Приложение к ОБ МСЭ %{number}"
+  zh: "国际电联操作公报附件 第 %{number} 期"

data/lib/pubid/itu/identifier.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Pubid::Itu::Identifier is the ITU base class (a real Pubid::Identifier
+# 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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+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)"
+      class Amendment < Supplement
+        # "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
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    module Identifiers
+      # "Annex to ..." identifier — the document IS the annex of a Special
+      # Publication (e.g. an annex to ITU OB), not a sub-annex with a number.
+      #
+      # Three rendering forms (per v1 PR #38):
+      #   * default (no i18n_lang): English structural, "Annex to ITU OB No. 1000"
+      #   * short with i18n_lang: structural translation using `annex_to`
+      #   * 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 < 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.
+          base_urn = base&.to_urn
+          return "urn:itu:annex" unless base_urn
+
+          "#{base_urn}:annex"
+        end
+
+        def render_base(**opts)
+          lang = opts[:i18n_lang]&.to_s
+          long_template = lang && Pubid::Itu::I18N["annex_long"]&.fetch(lang,
+                                                                        nil)
+
+          if opts[:format] == :long && long_template
+            return long_template % { number: base_number }
+          end
+
+          annex_translation = lang && Pubid::Itu::I18N["annex_to"]&.fetch(lang,
+                                                                          nil)
+
+          if annex_translation
+            base_str = base_render(**opts)
+            return "#{base_str} #{annex_translation}" if lang == "ar"
+
+            return "#{annex_translation} #{base_str}"
+          end
+
+          if long_template
+            return long_template % { number: base_number }
+          end
+
+          "Annex to #{base_render(**opts)}"
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Annex)
+
+          base == other.base && language == other.language
+        end
+
+        private
+
+        def base_render(**opts)
+          base&.render_base(**opts) || ""
+        end
+
+        def base_number
+          return code&.number if code
+
+          base&.code&.number
+        end
+      end
+    end
+  end
+end

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