pubid 1.15.19 → 2.0.0.pre.alpha.2

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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require_relative "../../components/date"
+require_relative "../components/sector"
+require_relative "../components/series"
+require_relative "../components/code"
+require_relative "../i18n"
+
+module Pubid
+  module Itu
+    module Identifiers
+      # Base class for all ITU identifiers
+      class Base < Pubid::Identifier
+        # Long-form ↔ ITU single-letter language code map. The parser produces
+        # single-letter codes (E/F/S/R/A/C); API callers (e.g. metanorma-itu)
+        # pass long-form (en/fr/es/ru/ar/zh). Storage is normalized to the
+        # single-letter form. Languages with no canonical letter (e.g. "de")
+        # pass through unchanged and produce no trailing suffix.
+        LANGUAGES = {
+          "fr" => "F", "es" => "S", "ru" => "R",
+          "ar" => "A", "zh" => "C", "en" => "E",
+          "F" => "F", "S" => "S", "R" => "R",
+          "A" => "A", "C" => "C", "E" => "E"
+        }.freeze
+
+        attribute :sector, Pubid::Itu::Components::Sector
+        attribute :series, Pubid::Itu::Components::Series
+        attribute :code, Pubid::Itu::Components::Code
+        attribute :date, Pubid::Components::Date
+        attribute :language, :string
+
+        def initialize(**kwargs)
+          if kwargs[:language]
+            kwargs = kwargs.merge(language: normalize_language(kwargs[:language]))
+          end
+
+          super
+
+          validate_ob_no_sector!
+        end
+
+        # Generate URN for this identifier
+        #
+        # @return [String] URN representation
+
+        # Override base_hash to handle ITU-specific attributes
+        def base_hash
+          hash = super
+          # ITU Series has a 'series' attribute, not 'number'
+          if hash[:series].is_a?(Hash) && series
+            hash[:series] = series.series
+          end
+          # Add sector (ITU-specific, has a 'sector' attribute)
+          hash[:sector] = sector.sector if sector
+          hash
+        end
+
+        def publisher
+          "ITU"
+        end
+
+        # Render identifier as a string.
+        #
+        # @param i18n_lang [Symbol, String] language for identifier text
+        #   translation (e.g. :fr renders "Annex to" as "Annexe au"). Distinct
+        #   from the identifier's `language` attribute, which is the document's
+        #   own language and produces the trailing suffix like "-F".
+        # @param language [Symbol, String] deprecated alias for i18n_lang.
+        # @param format [Symbol] :long for title-style rendering of supported
+        #   identifiers, otherwise the default short form.
+        def to_s(**opts)
+          opts = self.class.normalize_to_s_opts(opts)
+          render_base(**opts) + render_language_suffix
+        end
+
+        def render_base(**_opts)
+          result = "#{publisher}-#{sector}"
+
+          # Add series and code
+          result += if series
+                      " #{series}.#{code}"
+                    else
+                      " #{code}"
+                    end
+
+          # Add date if present
+          if date
+            result += if date.month
+                        " (#{date.month}/#{date.year})"
+                      else
+                        " (#{date.year})"
+                      end
+          end
+
+          result
+        end
+
+        def render_language_suffix
+          return "" unless language
+          # Only render canonical single-letter ITU language codes
+          # (e.g. "F", "S"). Languages with no mapping (e.g. "de") get
+          # no suffix — matches v1 PR #38 render_language behavior.
+          return "" unless LANGUAGES.value?(language)
+
+          "-#{language}"
+        end
+
+        # Translate `language:` opt to `i18n_lang:` opt. v1 PR #38 introduced
+        # `i18n_lang:` to disambiguate "rendering language" from the document
+        # language attribute; `language:` remains a deprecated alias.
+        def self.normalize_to_s_opts(opts)
+          opts = opts.dup
+          if opts.key?(:language) && !opts.key?(:i18n_lang)
+            opts[:i18n_lang] = opts.delete(:language)
+          else
+            opts.delete(:language)
+          end
+          opts
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Base)
+
+          sector == other.sector &&
+            series == other.series &&
+            code == other.code &&
+            date == other.date &&
+            language == other.language
+        end
+
+        private
+
+        def normalize_language(value)
+          str = value.to_s
+          LANGUAGES[str] || str
+        end
+
+        # OB (Operational Bulletin) is a cross-bureau ITU publication and
+        # must not have a sector. Direct construction with both raises;
+        # the parser silently drops sector for legacy strings like
+        # "ITU-T OB.X" (handled in Builder).
+        def validate_ob_no_sector!
+          return unless series&.series == "OB"
+          return if sector.nil?
+          return if sector.is_a?(Components::Sector) && (sector.sector.nil? || sector.sector.to_s.empty?)
+
+          raise ArgumentError,
+                "OB (Operational Bulletin) is a cross-bureau ITU publication; " \
+                "sector must not be set"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Itu
+    module Identifiers
+      # Combined identifier for dual-series recommendations
+      # Format: ITU-T G.780/Y.1351
+      # Example: ITU-T G.780/Y.1351 (2004)
+      class CombinedIdentifier < Base
+        attribute :combined_series, Pubid::Itu::Components::Series
+        attribute :combined_code, Pubid::Itu::Components::Code
+
+        def to_s
+          result = "#{publisher}-#{sector}"
+
+          # Add primary series and code
+          result += if series
+                      " #{series}.#{code}"
+                    else
+                      " #{code}"
+                    end
+
+          # Add combined series and code
+          if combined_series && combined_code
+            result += "/#{combined_series}.#{combined_code}"
+          end
+
+          # Add date if present
+          if date
+            result += if date.month
+                        " (#{date.month}/#{date.year})"
+                      else
+                        " (#{date.year})"
+                      end
+          end
+
+          # Add language
+          result += "-#{language}" if language
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "supplement"
+
+module Pubid
+  module Itu
+    module Identifiers
+      # Corrigendum identifier (Cor.)
+      # Pattern: "ITU-T Z.100 (1999) Cor. 1 (10/2001)"
+      # Can be corrigendum of annex: "ITU-T G.729 Annex E (1998) Cor. 1 (02/2000)"
+      class Corrigendum < Supplement
+        def to_s
+          result = base ? base.to_s : "#{publisher}-#{sector}"
+
+          # Add series if no base
+          if !base && series
+            result += " #{series}"
+          end
+
+          result += " Cor. #{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?(Corrigendum)
+
+          base == other.base &&
+            number == other.number &&
+            date == other.date
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Itu
+    module Identifiers
+      # ITU Recommendation
+      # Format: ITU-{SECTOR} {SERIES}.{NUMBER}[-PART]
+      # Example: ITU-R V.1234-1
+      class Recommendation < Base
+        # Type-specific rendering handled by Base
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Itu
+    module Identifiers
+      # ITU Special Publication — currently models the Operational Bulletin (OB).
+      # OB is a cross-bureau publication (no sector) rendered as
+      # "ITU OB No. {number}" with optional date.
+      #
+      # Pattern: "ITU OB No. 1283 (01/2024)"
+      class SpecialPublication < Base
+        def render_base(**_opts)
+          number = code&.number
+          result = "#{publisher} #{series} No. #{number}"
+
+          if date
+            result += if date.month
+                        " (#{date.month.to_s.rjust(2, '0')}/#{date.year})"
+                      else
+                        " (#{date.year})"
+                      end
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pubid
+  module Itu
+    module Identifiers
+      # Supplement identifier (Suppl.)
+      # Pattern: "ITU-T H Suppl. 1", "ITU-T E.156 Suppl. 2"
+      class Supplement < Base
+        attribute :base, Base, polymorphic: true
+        attribute :number, :string
+
+        def to_s
+          result = base ? base.to_s : "#{publisher}-#{sector}"
+
+          # Add series if no base
+          if !base && series
+            result += " #{series}"
+          end
+
+          result += " Suppl. #{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?(Supplement)
+
+          base == other.base &&
+            number == other.number &&
+            date == other.date
+        end
+      end
+    end
+  end
+end

data/lib/pubid/itu/identifiers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    module Identifiers
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Annex, "#{__dir__}/identifiers/annex"
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :CombinedIdentifier, "#{__dir__}/identifiers/combined_identifier"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :Recommendation, "#{__dir__}/identifiers/recommendation"
+      autoload :SpecialPublication, "#{__dir__}/identifiers/special_publication"
+      autoload :Supplement, "#{__dir__}/identifiers/supplement"
+    end
+  end
+end

data/lib/pubid/itu/model.rb

@@ -0,0 +1,111 @@
+require "lutaml/model"
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    class Model < Lutaml::Model::Serializable
+      attribute :sector, :string
+      attribute :series, :string
+      attribute :number, :string
+      attribute :subseries, :string
+      attribute :part, :string
+      attribute :supplement, :string
+      attribute :amendment, :string
+      attribute :annex, :string
+      attribute :corrigendum, :string
+      attribute :addendum, :string
+      attribute :appendix, :string
+      attribute :month, :string
+      attribute :year, :string
+      attribute :second_number, :string
+      attribute :range, :string
+      attribute :sg_number, :string
+
+      def to_s
+        parts = []
+
+        # Add publisher and sector
+        parts << "ITU-#{sector}" if sector
+
+        # Add series (handle special cases)
+        if series == "OB"
+          # Operational Bulletin
+          parts << "#{series} No. #{number}"
+        elsif series&.start_with?("SG")
+          # Study Group Question
+          parts << "#{series}.#{number}"
+          parts[-1] << "-#{part}" if part
+        elsif series == "R" && !number
+          # Resolution without number
+          parts << "R.#{number}"
+          parts[-1] << "-#{part}" if part
+        elsif series
+          # Regular series
+          series_str = series.to_s
+          if number
+            series_str << ".#{number}"
+            series_str << ".#{subseries}" if subseries
+            series_str << "-#{part}" if part
+          end
+          parts << series_str
+
+          # Add second number for combined standards
+          if second_number.is_a?(Hash)
+            second_str = "/#{second_number[:series]}.#{second_number[:number]}"
+            second_str << ".#{second_number[:subseries]}" if second_number[:subseries]
+            second_str << "-#{second_number[:part]}" if second_number[:part]
+            parts[-1] << second_str
+          end
+
+          # Add range notation
+          if range.is_a?(Hash)
+            parts[-1] << "-#{range[:series]}.#{range[:number]}"
+          end
+        elsif number && !series
+          # Handbook or similar (just number)
+          parts << number
+          parts[-1] << "-#{part}" if part
+        end
+
+        # Add supplement
+        if supplement
+          parts << "Suppl. #{supplement}"
+        end
+
+        # Add annex
+        if annex
+          parts << "Annex #{annex}"
+        end
+
+        # Add date
+        if month && year
+          parts << "(#{month.rjust(2, '0')}/#{year})"
+        elsif year
+          parts << "(#{year})"
+        end
+
+        # Add amendment
+        if amendment
+          parts << "Amd #{amendment}"
+        end
+
+        # Add corrigendum
+        if corrigendum
+          parts << "Cor. #{corrigendum}"
+        end
+
+        # Add addendum
+        if addendum
+          parts << "Add. #{addendum}"
+        end
+
+        # Add appendix
+        if appendix
+          parts << "App. #{appendix}"
+        end
+
+        parts.join(" ")
+      end
+    end
+  end
+end

data/lib/pubid/itu/parser.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Itu
+    class Parser < Parslet::Parser
+      # Basic elements
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+      rule(:letter) { match["A-Z"] }
+      rule(:space) { str(" ") }
+      rule(:dash) { str("-") }
+      rule(:dot) { str(".") }
+
+      # ITU prefix
+      rule(:itu_prefix) { str("ITU") >> (dash | space) }
+
+      # Sector (R, T, or D)
+      rule(:sector) do
+        (str("R") | str("T") | str("D")).as(:sector)
+      end
+
+      # Series (BO, V, X, etc.)
+      rule(:series) do
+        (
+          # Study groups: SG1, SG12
+          (str("SG") >> digits) |
+          # Regular series: BO, V, X, etc.
+          letter.repeat(1, 3)
+        ).as(:series)
+      end
+
+      # Number
+      rule(:number) do
+        digits.as(:number)
+      end
+
+      rule(:subseries) do
+        dot >> digits.as(:subseries)
+      end
+
+      # Parts
+      rule(:part) do
+        dash >> digits.as(:part)
+      end
+
+      rule(:parts) { part.repeat(0).as(:parts) }
+
+      # Code = number + subseries + parts
+      rule(:code) do
+        number >> subseries.maybe >> parts
+      end
+
+      # Date
+      rule(:date_part) do
+        space >> str("(") >>
+          (digits.as(:month) >> str("/")).maybe >>
+          digit.repeat(4, 4).as(:year) >>
+          str(")")
+      end
+
+      # Language
+      rule(:language) do
+        dash >> match["EFASCR"].as(:language)
+      end
+
+      # Combined identifier (Y.1351 part after slash)
+      rule(:combined_suffix) do
+        str("/") >>
+          series.as(:combined_series) >>
+          dot >>
+          digits.as(:combined_number) >>
+          subseries.maybe >>
+          parts
+      end
+
+      # Supplement types
+      rule(:supplement_type) do
+        (
+          str("Suppl.") | str("Suppl") |
+          str("Amd.") | str("Amd") |
+          str("Cor.") | str("Cor")
+        ).as(:supplement_type)
+      end
+
+      # Supplement number
+      rule(:supplement_number) do
+        space >> digits.as(:supplement_number)
+      end
+
+      # Supplement date (separate from base date)
+      rule(:supplement_date) do
+        space >> str("(") >>
+          (digits.as(:supplement_month) >> str("/")).maybe >>
+          digit.repeat(4, 4).as(:supplement_year) >>
+          str(")")
+      end
+
+      # Base identifier for supplements
+      rule(:base_with_series) do
+        itu_prefix >>
+          sector >>
+          space >>
+          series >> dot >>
+          code >>
+          combined_suffix.maybe >>
+          date_part.maybe
+      end
+
+      rule(:base_without_series) do
+        itu_prefix >>
+          sector >>
+          space >>
+          code >>
+          date_part.maybe
+      end
+
+      rule(:base_identifier) do
+        base_with_series | base_without_series
+      end
+
+      # Supplement with base identifier (has recommendation number)
+      rule(:supplement_with_base) do
+        base_identifier.as(:base) >>
+          space >>
+          supplement_type >>
+          supplement_number >>
+          supplement_date.maybe >>
+          language.maybe
+      end
+
+      # Supplement without base (series-only, like "ITU-T H Suppl. 1")
+      rule(:supplement_series_only) do
+        itu_prefix >>
+          sector >>
+          space >>
+          series >>
+          space >>
+          supplement_type >>
+          supplement_number >>
+          supplement_date.maybe >>
+          language.maybe
+      end
+
+      # Complete supplement identifier (try with base first, then series-only)
+      rule(:supplement_identifier) do
+        supplement_with_base | supplement_series_only
+      end
+
+      # With series: ITU-R BO.600-1
+      rule(:with_series) do
+        itu_prefix >>
+          sector >>
+          space >>
+          series >> dot >>
+          code >>
+          combined_suffix.maybe >>
+          date_part.maybe >>
+          language.maybe
+      end
+
+      # Without series: ITU-R 20-200
+      rule(:without_series) do
+        itu_prefix >>
+          sector >>
+          space >>
+          code >>
+          date_part.maybe >>
+          language.maybe
+      end
+
+      # OB (Operational Bulletin) — Special Publication.
+      # OB is a cross-bureau ITU publication; sector, when present in legacy
+      # strings like "ITU-T OB.1096", is silently dropped by the builder.
+      rule(:ob_series) { str("OB").as(:series) }
+
+      rule(:ob_dot_body) { dot >> number }
+      rule(:ob_no_body) { space >> str("No.") >> space >> number }
+
+      rule(:ob_with_sector) do
+        itu_prefix >>
+          (sector >> space).maybe >>
+          ob_series >>
+          (ob_dot_body | ob_no_body) >>
+          date_part.maybe >>
+          language.maybe
+      end
+
+      # Legacy long form: "ITU-T Operational Bulletin No. 1096".
+      # The :_op_bull marker tells the builder to set series=OB.
+      rule(:ob_long_form) do
+        itu_prefix >>
+          (sector >> space).maybe >>
+          str("Operational Bulletin").as(:_op_bull) >>
+          space >> str("No.") >> space >>
+          number >>
+          date_part.maybe >>
+          language.maybe
+      end
+
+      rule(:special_publication) { ob_with_sector | ob_long_form }
+
+      # "Annex to ..." — the document IS the annex of a Special Publication
+      # (no annex number). The :annex_to wrapping signals to the builder.
+      rule(:annex_to_identifier) do
+        str("Annex to") >> space >> special_publication.as(:annex_to)
+      end
+
+      rule(:identifier) do
+        annex_to_identifier |
+          special_publication |
+          supplement_identifier |
+          with_series |
+          without_series
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end