pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/itu/urn_generator.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        if identifier.is_a?(Identifiers::Supplement)
+          generate_supplement_urn
+        else
+          generate_base_urn
+        end
+      end
+
+      protected
+
+      def generate_base_urn
+        parts = ["urn", "itu"]
+
+        if identifier.sector
+          sector = identifier.sector.to_s
+          parts << sector.to_s.downcase
+        else
+          parts << "itu"
+        end
+
+        # An ITU-R Report numbers independently of the Recommendation series,
+        # so "BT.2020-1" alone is ambiguous — the type has to reach the URN as
+        # well as `to_s` and the MR slug, or the two documents share an
+        # identifier on that surface.
+        parts << "report" if identifier.is_a?(Identifiers::Report)
+
+        if identifier.series
+          series = identifier.series.to_s
+          if identifier.code
+            # A series-code document joins with a dash, not a dot; rendering it
+            # "EMC.5" would be ambiguous with a hypothetical "ITU-T EMC.5" and
+            # would not parse back.
+            join = identifier.series_dash ? "-" : "."
+            parts << "#{series}#{join}#{identifier.code.compact_s}"
+          else
+            parts << series
+          end
+        elsif identifier.code
+          code = identifier.code.compact_s
+          parts << code
+        end
+
+        # Identity-bearing markers that are not part of sector/series/code.
+        # Without them "ITU-T H.350 attachment", "ITU-T Q.120-Q.139" and
+        # "ITU-T E-100 series Suppl. 2" would each share a URN with the
+        # document they are distinct from — the same collision Code#compact_s
+        # exists to prevent for the code suffixes.
+        parts << "series" if identifier.series_word
+        parts << "attachment" if identifier.attachment
+        parts << "to-#{identifier.range_end}" if identifier.range_end
+
+        if identifier.date
+          date = identifier.date
+          if date&.year && date.month
+            parts << "#{date.month}/#{date.year}"
+          elsif date&.year
+            parts << date.year.to_s
+          end
+        end
+
+        if identifier.language
+          parts << identifier.language.to_s.downcase
+        end
+
+        parts.join(":")
+      end
+
+      def generate_supplement_urn
+        parts = ["urn", "itu"]
+
+        base = maybe(:base)
+        if base
+          # An annex or appendix base holds its identity in its OWN base (its
+          # sector/series/code are nil), so generate_base_urn would emit
+          # "urn:itu:itu" for it — go through its own to_urn instead.
+          nested_wrapper = base.is_a?(Identifiers::AnnexOfRecommendation) ||
+            base.is_a?(Identifiers::AppendixOfRecommendation)
+          base_urn = if nested_wrapper
+                       base.to_urn
+                     else
+                       self.class.new(base).generate_base_urn
+                     end
+
+          base_part = base_urn.sub(/^urn:itu:/, "")
+          base_parts = base_part.split(":")
+
+          parts.concat(base_parts)
+        else
+          if identifier.sector
+            sector = identifier.sector.to_s
+            parts << sector.to_s.downcase
+          end
+          if identifier.series
+            series = identifier.series.to_s
+            if identifier.code
+              code = identifier.code.compact_s
+              parts << "#{series}.#{code}"
+            else
+              parts << series
+            end
+          end
+          # A base-less supplement's whole identity is sector + series, so the
+          # series-group word belongs in the URN too — without it
+          # "ITU-T E-100 series Suppl. 2" and "ITU-T E-100 Suppl. 2" collide.
+          parts << "series" if identifier.series_word
+        end
+
+        supplement_notation = maybe(:supplement_notation)
+        if supplement_notation
+          parts << supplement_notation.to_s.downcase
+        end
+
+        if identifier.number
+          parts << identifier.number.to_s
+        end
+
+        if identifier.date
+          date = identifier.date
+          if date&.year && date.month
+            parts << "#{date.month}/#{date.year}"
+          elsif date&.year
+            parts << date.year.to_s
+          end
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/itu/urn_parser.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    # Parses ITU URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:itu:{sector}:{code}` where sector is the
+    # lowercase ITU sector letter (t for ITU-T, r for ITU-R, d for ITU-D)
+    # and code is the document code (e.g., "BO.1073-1").
+    #
+    # Examples:
+    # - urn:itu:t:BO.1073-1 → ITU-T BO.1073-1
+    # - urn:itu:r:BO.500    → ITU-R BO.500
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        sector, code = parts
+
+        # UrnGenerator emits a "report" segment between the sector and the code
+        # for an ITU-R Report, which numbers independently of the
+        # Recommendation series (urn:itu:r:report:BT.2020-1).
+        if parts[1] == "report"
+          return flavor_parse("Report ITU-#{sector.upcase} #{parts[2]}")
+        end
+
+        flavor_parse("ITU-#{sector.upcase} #{code}")
+      end
+    end
+  end
+end

data/lib/pubid/itu.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Itu
+    extend Pubid::PrefixesSupport
+
+    # Sole ITU publisher token (see the parser's `itu_prefix` rule).
+    #
+    # The leading "Report" of an ITU-R Report's canonical form
+    # ("Report ITU-R BT.2020-1") is deliberately NOT listed: prefix routing
+    # claims every reference beginning with the token, and "Report" is a
+    # generic English word that other SDOs' references start with — the
+    # mixin's documented exclusion for ambiguous tokens. Report references
+    # route by their "ITU" token in the infix spelling
+    # ("ITU-R Report BT.2020-1"), and `Pubid::Itu.parse` accepts both.
+    PREFIXES = ["ITU"].freeze
+
+    autoload :Builder, "#{__dir__}/itu/builder"
+    autoload :Components, "#{__dir__}/itu/components"
+    autoload :Identifier, "#{__dir__}/itu/identifiers/base"
+    autoload :Identifiers, "#{__dir__}/itu/identifiers"
+    autoload :Parser, "#{__dir__}/itu/parser"
+    autoload :UrnGenerator, "#{__dir__}/itu/urn_generator"
+    autoload :UrnParser, "#{__dir__}/itu/urn_parser"
+    autoload :Model, "#{__dir__}/itu/model"
+
+    # I18N is a YAML-loaded constant (not a class), so autoload cannot be used.
+    # It is loaded eagerly when the ITU module is first referenced.
+    require "#{__dir__}/itu/i18n"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c < Pubid::Identifier }
+        # Exclude the flavor base itself by identity (Identifier is now an
+        # alias for Pubid::Itu::Identifier, so name-based matching misses it).
+        .reject { |c| c == Identifier }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+# Register ITU flavor with the registry
+Pubid::Registry.register(:itu, Pubid::Itu)

data/lib/pubid/jcgm/builder.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    class Builder < Pubid::Builder::Base
+      def locate_identifier_klass(parsed_hash)
+        if parsed_hash[:base]
+          type_with_stage = parsed_hash[:type_with_stage]
+          return Jcgm.locate_type(:amendment) unless type_with_stage
+
+          return Jcgm.locate_type(locate_typed_stage(type_with_stage).type_code)
+        end
+
+        if parsed_hash[:gum_number]
+          return Jcgm.locate_type(:gum_guide)
+        end
+
+        # Standard guide (no type_with_stage, no gum_number).
+        # Don't use locate_stage("") — Guide and GumGuide both have
+        # abbr: [""], so the result depends on constant iteration order.
+        return Jcgm.locate_type(:guide) unless parsed_hash[:type_with_stage]
+
+        typed_stage = locate_typed_stage(parsed_hash[:type_with_stage])
+        Jcgm.locate_type(typed_stage.type_code)
+      end
+
+      def build(parsed_hash)
+        klass = locate_identifier_klass(parsed_hash)
+
+        # GUM guides store their part number in the shared `number` attribute
+        # ("JCGM GUM-6" -> number "6"); the parser tags it :gum_number only to
+        # pick this class. Fold it back onto :number before assigning.
+        if parsed_hash[:gum_number] && klass == Identifiers::GumGuide
+          parsed_hash = parsed_hash.merge(number: parsed_hash[:gum_number])
+          parsed_hash.delete(:gum_number)
+        end
+
+        identifier = klass.new
+        assign_attributes(identifier, parsed_hash)
+
+        # Bare guides/gum-guides carry no parsed stage; derive the (single,
+        # published) typed_stage from the concrete class so parse and from_hash
+        # agree. Avoids the ambiguous locate_stage("") lookup (Guide and
+        # GumGuide both register abbr: [""]).
+        if identifier.class.attributes.key?(:typed_stage) && identifier.typed_stage.nil?
+          identifier.typed_stage = identifier.class.published_typed_stage ||
+            raise(ArgumentError, "No published typed_stage for #{identifier.class}")
+        end
+
+        identifier
+      end
+
+      private
+
+      def default_identifier_class
+        Identifiers::Guide
+      end
+
+      def locate_typed_stage(typed_stage_string)
+        typed_stage_string = "" if typed_stage_string.nil?
+        Jcgm.locate_stage(typed_stage_string) ||
+          raise(ArgumentError, "Unknown type abbreviation: '#{typed_stage_string}'")
+      end
+
+      def cast(type, value)
+        case type
+        when :base
+          build(value)
+        when :publisher
+          Jcgm::Components::Publisher.new(publisher: value.to_s)
+        when :number
+          value.to_s
+        when :date
+          date_str = value.to_s
+          if date_str.include?("-")
+            parts = date_str.split("-")
+            Pubid::Components::Date.new(
+              year: parts[0],
+              month: parts[1],
+              day: parts[2],
+            )
+          else
+            Pubid::Components::Date.new(year: date_str)
+          end
+        when :type_with_stage
+          typed_stage = locate_typed_stage(value.to_s)
+          {
+            stage: typed_stage.to_stage,
+            type: typed_stage.to_type,
+            typed_stage: typed_stage,
+          }
+        when :languages
+          original_value = value.to_s
+          langs = original_value.include?("/") ? original_value.split("/") : [original_value]
+          langs.map do |lang|
+            lang = lang.strip
+            original_lang = lang
+            lang = LANG_CHAR_MAP[lang] if lang.length == 1
+            Pubid::Components::Language.new(code: lang,
+                                            original_code: original_lang)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/components/publisher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Jcgm
+    module Components
+      class Publisher < Lutaml::Model::Serializable
+        attribute :publisher, :string
+
+        def to_s
+          publisher
+        end
+
+        # Alias for consistency
+        alias_method :body, :publisher
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/components.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Components
+      autoload :Publisher, "#{__dir__}/components/publisher"
+    end
+  end
+end

data/lib/pubid/jcgm/identifier.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    class Identifier < ::Pubid::Identifier
+      # `number`/`part`/`subpart` are declared here rather than inherited as a
+      # Components::Code: JCGM stores a bare string in `number` and uses neither
+      # of the other two. Declaring on this class is safe because its body lives
+      # in this one file and is never reopened, so every subclass body opens
+      # after it has run (lutaml deep-dups the parent attribute table at
+      # class-definition time).
+      attribute :number, :string
+      attribute :part, :string
+      attribute :subpart, :string
+
+      def self.parse(string)
+        Pubid::Jcgm.parse(string)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Identifiers
+      class Amendment < SupplementIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubamd,
+            stage_code: :published,
+            type_code: :amendment,
+            abbr: ["Amd"],
+            name: "Amendment",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :amendment, title: "Amendment", short: "Amd" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Identifiers
+      # A JCGM corrigendum. Two surface forms are supported:
+      #
+      #   "JCGM 200:2008 Corrigendum"      — base guide + trailing " Corrigendum"
+      #                                       word, no iteration number
+      #   "JCGM 101:2008/Cor 1:2009"       — base guide + slash-separated
+      #                                       numbered corrigendum with date
+      #
+      # The first form is the JCGM-native convention. The second mirrors the
+      # ISO/IEC supplement syntax and is needed to round-trip identifiers like
+      # "JCGM 101:2008/Cor 1:2009" (corrigendum to GUM Supplement 1).
+      class Corrigendum < SupplementIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubcorr,
+            stage_code: :published,
+            type_code: :corrigendum,
+            abbr: %w[Corrigendum Cor],
+            name: "Corrigendum",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :corrigendum, title: "Corrigendum", short: "Corr" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/identifiers/guide.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Identifiers
+      class Guide < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: [""],
+            type_code: :guide,
+            stage_code: :published,
+          ),
+        ].freeze
+
+        def self.type
+          { key: :guide, title: "Guide" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/identifiers/gum_guide.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Identifiers
+      # A GUM guide, e.g. "JCGM GUM-6:2020". The GUM-series part number ("6")
+      # lives in the inherited `number` attribute (serialized as `number: "6"`);
+      # `_type: pubid:jcgm:gum-guide` disambiguates it from a plain guide.
+      class GumGuide < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubgumguide,
+            stage_code: :published,
+            type_code: :gum_guide,
+            abbr: [""],
+            name: "GUM Guide",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :gum_guide, title: "GUM Guide", short: "GUM" }
+        end
+
+        private
+
+        def language_portion
+          return "" unless languages&.any?
+
+          codes = languages.map do |lang|
+            lang.original_code || lang.code
+          end
+
+          "(#{codes.join('/')})"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/identifiers/meeting.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Identifiers
+      # A JCGM committee/meeting record, e.g. "JCGM 17th Meeting (2012)".
+      #
+      # `number` (Components::Code) holds the meeting ordinal as a clean integer
+      # value ("17"); `date` (Components::Date, year-only) holds the year.
+      class Meeting < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubmeeting,
+            stage_code: :published,
+            type_code: :jcgm_meeting,
+            abbr: ["Meeting"],
+            name: "Meeting",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :jcgm_meeting, title: "Meeting" }
+        end
+
+        # Ordinal suffix as printed by the JCGM/BIPM data generator: a naive
+        # last-digit rule (1->st, 2->nd, 3->rd, else th) with NO 11/12/13 teens
+        # exception. The real records print "11st", "12nd", "13rd", so applying
+        # the standard-English teens exception would break round-trip.
+        def self.ordinal(number)
+          n = number.to_i
+          suffix = case n % 10
+                   when 1 then "st"
+                   when 2 then "nd"
+                   when 3 then "rd"
+                   else "th"
+                   end
+          "#{n}#{suffix}"
+        end
+
+        def ordinal
+          self.class.ordinal(number)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/identifiers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Identifiers
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :Guide, "#{__dir__}/identifiers/guide"
+      autoload :GumGuide, "#{__dir__}/identifiers/gum_guide"
+      autoload :Meeting, "#{__dir__}/identifiers/meeting"
+    end
+  end
+end