pubid 1.15.18 → 2.0.0.pre.alpha.1

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

data/lib/pubid/itu/scheme.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require_relative "model"
+
+module Pubid
+  module Itu
+    class Scheme < Pubid::Scheme
+      # Attribute mappings define how parsed data maps to model attributes
+      ATTRIBUTE_MAPPINGS = {
+        sector: :sector,
+        series: :series,
+        number: :number,
+        subseries: :subseries,
+        part: :part,
+        supplement: :supplement,
+        amendment: :amendment,
+        annex: :annex,
+        corrigendum: :corrigendum,
+        addendum: :addendum,
+        appendix: :appendix,
+        date: :date,
+        month: :month,
+        year: :year,
+        second_number: :second_number,
+        range_series: :range_series,
+        range_number: :range_number,
+        sg_number: :sg_number,
+      }.freeze
+
+      # Model class to use for rendering
+      def self.model_class
+        Model
+      end
+
+      # Convert parsed data to model attributes
+      def self.transform(parsed)
+        attributes = {}
+
+        # Extract sector
+        attributes[:sector] = parsed[:sector].to_s if parsed[:sector]
+
+        # Determine content based on sector
+        content = parsed[:t_content] || parsed[:r_content] || {}
+
+        # Extract series and study group
+        if content[:series].is_a?(Hash) && content[:series][:sg_number]
+          # Study groups (questions)
+          attributes[:series] = "SG#{content[:series][:sg_number]}"
+        elsif content[:series]
+          attributes[:series] = content[:series].to_s
+        end
+
+        # Extract numbering components
+        if content[:numbering]
+          numbering = content[:numbering]
+
+          # Handle numbering as array (e.g., number + subseries)
+          if numbering.is_a?(Array)
+            numbering.each do |part|
+              if part.is_a?(Hash)
+                if part[:number]
+                  attributes[:number] = part[:number].to_s
+                elsif part[:subseries]
+                  # Collect subseries parts
+                  if attributes[:subseries]
+                    attributes[:subseries] =
+                      "#{attributes[:subseries]}.#{part[:subseries]}"
+                  else
+                    attributes[:subseries] = part[:subseries].to_s
+                  end
+                elsif part[:part]
+                  attributes[:part] = part[:part].to_s
+                end
+              end
+            end
+          elsif numbering.is_a?(Hash)
+            # Handle numbering as hash
+            attributes[:number] = numbering[:number].to_s if numbering[:number]
+            if numbering[:subseries]
+              attributes[:subseries] =
+                numbering[:subseries].to_s
+            end
+            attributes[:part] = numbering[:part].to_s if numbering[:part]
+          end
+        end
+
+        # Extract supplement/amendment/etc.
+        if content[:supplement]
+          attributes[:supplement] =
+            content[:supplement].to_s
+        end
+        attributes[:amendment] = content[:amendment].to_s if content[:amendment]
+        attributes[:annex] = content[:annex].to_s if content[:annex]
+        if content[:corrigendum]
+          attributes[:corrigendum] =
+            content[:corrigendum].to_s
+        end
+        attributes[:addendum] = content[:addendum].to_s if content[:addendum]
+
+        # Handle appendix (convert Roman numerals to Arabic)
+        if content[:appendix]
+          appendix = content[:appendix].to_s
+          attributes[:appendix] = roman_to_arabic(appendix) || appendix
+        end
+
+        # Extract date
+        if content[:date]
+          date = content[:date]
+          if date[:month] && date[:year]
+            attributes[:month] = date[:month].to_s
+            attributes[:year] = date[:year].to_s
+          elsif date[:year]
+            attributes[:year] = date[:year].to_s
+          end
+        end
+
+        # Extract second number (for combined standards like G.780/Y.1351)
+        if content[:second_number]
+          second = content[:second_number]
+          second_attrs = {}
+          second_attrs[:series] = second[:series].to_s if second[:series]
+          if second[:numbering]
+            numbering = second[:numbering]
+            if numbering[:number]
+              second_attrs[:number] =
+                numbering[:number].to_s
+            end
+            if numbering[:subseries]
+              second_attrs[:subseries] = numbering[:subseries].to_s
+            end
+            second_attrs[:part] = numbering[:part].to_s if numbering[:part]
+          end
+          attributes[:second_number] = second_attrs unless second_attrs.empty?
+        end
+
+        # Extract range (for Q.400-Q.490 style)
+        if content[:range_series] && content[:range_number]
+          attributes[:range] = {
+            series: content[:range_series].to_s,
+            number: content[:range_number].to_s,
+          }
+        end
+
+        attributes
+      end
+
+      # Convert Roman numerals to Arabic numbers
+      def self.roman_to_arabic(roman)
+        return roman unless roman.match?(/^[IVXLCDM]+$/i)
+
+        roman_map = {
+          "I" => 1, "V" => 5, "X" => 10, "L" => 50,
+          "C" => 100, "D" => 500, "M" => 1000
+        }
+
+        roman = roman.upcase
+        result = 0
+        prev_value = 0
+
+        roman.reverse.each_char do |char|
+          value = roman_map[char]
+          if value < prev_value
+            result -= value
+          else
+            result += value
+          end
+          prev_value = value
+        end
+
+        result.to_s
+      end
+    end
+  end
+end