pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

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

@@ -1,154 +1,150 @@
 # 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
+    # Base class for all ITU identifiers. Canonical name Pubid::Itu::Identifier
+    # (Identifiers::Base is a back-compat alias).
+    class Identifier < ::Pubid::Identifier
+      # Parse an ITU identifier string into an identifier object.
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse ITU identifier '#{identifier}': #{e.message}"
+      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
+      # 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
 
-        def publisher
-          "ITU"
-        end
+        super
 
-        # 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
+        validate_ob_no_sector!
+      end
 
-        def render_base(**_opts)
-          result = "#{publisher}-#{sector}"
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+
+      # Stored as a plain string (always "ITU") so it round-trips through
+      # to_hash/from_hash. Was a `def publisher` method, which made lutaml
+      # serialize a String against the Components::Publisher attribute.
+      attribute :publisher, :string, default: -> { "ITU" }
+
+      # 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
 
-          # Add series and code
-          result += if series
-                      " #{series}.#{code}"
-                    else
-                      " #{code}"
-                    end
+      def render_base(**_opts)
+        result = "#{publisher}-#{sector}"
 
-          # Add date if present
-          if date
-            result += if date.month
-                        " (#{date.month}/#{date.year})"
-                      else
-                        " (#{date.year})"
-                      end
-          end
+        # Add series and code
+        result += if series
+                    " #{series}.#{code}"
+                  else
+                    " #{code}"
+                  end
 
-          result
+        # Add date if present
+        if date
+          result += if date.month
+                      " (#{date.month}/#{date.year})"
+                    else
+                      " (#{date.year})"
+                    end
         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)
+        result
+      end
 
-          "-#{language}"
-        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
+      # 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)
+      def ==(other)
+        return false unless other.is_a?(Pubid::Itu::Identifier)
 
-          sector == other.sector &&
-            series == other.series &&
-            code == other.code &&
-            date == other.date &&
-            language == other.language
-        end
+        sector == other.sector &&
+          series == other.series &&
+          code == other.code &&
+          date == other.date &&
+          language == other.language
+      end
 
-        private
+      private
 
-        def normalize_language(value)
-          str = value.to_s
-          LANGUAGES[str] || str
-        end
+      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
+      # 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
+
+    module Identifiers
+      # Backward-compatible alias: ITU's base class used to be
+      # Pubid::Itu::Identifiers::Base. It is now Pubid::Itu::Identifier.
+      Base = Pubid::Itu::Identifier
+    end
   end
 end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Itu
     module Identifiers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "supplement"
-
 module Pubid
   module Itu
     module Identifiers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Itu
     module Identifiers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Itu
     module Identifiers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Itu
     module Identifiers

data/lib/pubid/itu/urn_parser.rb

@@ -0,0 +1,23 @@
+# 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
+        flavor_parse("ITU-#{sector.upcase} #{code}")
+      end
+    end
+  end
+end

data/lib/pubid/itu.rb

@@ -5,16 +5,59 @@ require "lutaml/model"
 module Pubid
   module Itu
     autoload :Builder, "#{__dir__}/itu/builder"
+    autoload :Components, "#{__dir__}/itu/components"
     autoload :Identifier, "#{__dir__}/itu/identifier"
     autoload :Identifiers, "#{__dir__}/itu/identifiers"
     autoload :Parser, "#{__dir__}/itu/parser"
-    autoload :Scheme, "#{__dir__}/itu/scheme"
     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 (Identifiers::Base is now an
+        # alias for Pubid::Itu::Identifier, so name-based matching misses it).
+        .reject { |c| c == Identifiers::Base }
+    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
 

data/lib/pubid/jcgm/builder.rb

@@ -3,21 +3,22 @@
 module Pubid
   module Jcgm
     class Builder < Pubid::Builder::Base
-      def initialize(scheme)
-        @scheme = scheme
-      end
-
       def locate_identifier_klass(parsed_hash)
         if parsed_hash[:base_identifier]
-          return @scheme.locate_identifier_klass_by_type_code(:amendment)
+          return Jcgm.locate_type(:amendment)
         end
 
         if parsed_hash[:gum_number]
-          return @scheme.locate_identifier_klass_by_type_code(:gum_guide)
+          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])
-        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+        Jcgm.locate_type(typed_stage.type_code)
       end
 
       def build(parsed_hash)
@@ -25,7 +26,8 @@ module Pubid
         assign_attributes(identifier, parsed_hash)
 
         if identifier.class.attributes.key?(:typed_stage) && identifier.typed_stage.nil?
-          default_typed_stage = @scheme.locate_typed_stage_by_abbr("")
+          default_typed_stage = Jcgm.locate_stage("") ||
+            raise(ArgumentError, "Unknown type abbreviation: ''")
           identifier.typed_stage = default_typed_stage
           identifier.stage = default_typed_stage.to_stage if identifier.class.attributes.key?(:stage)
           identifier.type = default_typed_stage.to_type if identifier.class.attributes.key?(:type)
@@ -40,6 +42,12 @@ module Pubid
         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_identifier

data/lib/pubid/jcgm/identifier.rb

@@ -6,49 +6,6 @@ module Pubid
       def self.parse(string)
         Pubid::Jcgm.parse(string)
       end
-
-      # Factory mirroring pubid 1.x's `Pubid::Jcgm::Identifier.create` API.
-      # Dispatches `:guide` (default) → Guide, `:gum_guide` → GumGuide.
-      TYPE_KEY_TO_KLASS = {
-        guide:     "Guide",
-        gum_guide: "GumGuide",
-      }.freeze
-
-      def self.create(type: nil, **opts)
-        klass = resolve_create_class(type)
-        attrs = coerce_create_attrs(opts)
-        ts = klass.const_defined?(:TYPED_STAGES) &&
-             klass.const_get(:TYPED_STAGES).find do |t|
-               t.stage_code&.to_sym == :published
-             end
-        attrs[:typed_stage] = ts if ts
-        klass.new(**attrs)
-      end
-
-      def self.resolve_create_class(type)
-        return Identifiers::Guide if type.nil?
-
-        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
-        raise ArgumentError, "Unknown JCGM type: #{type.inspect}" unless klass_name
-
-        Identifiers.const_get(klass_name)
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = {
-          publisher: Pubid::Jcgm::Components::Publisher.new(
-            publisher: (opts[:publisher] || "JCGM").to_s,
-          ),
-        }
-        if (v = opts[:number])
-          attrs[:number] = Pubid::Components::Code.new(value: v.to_s)
-        end
-        if (v = opts[:year])
-          attrs[:date] = Pubid::Components::Date.new(year: v.to_s)
-        end
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
     end
   end
 end

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

@@ -20,15 +20,6 @@ module Pubid
         def self.type
           { key: :amendment, title: "Amendment", short: "Amd" }
         end
-
-        def to_s(lang: :en, lang_single: false, with_edition: false,
-format: nil, stage_format_long: nil, with_date: nil)
-          result = base_identifier.to_s if base_identifier
-          result += "/Amd"
-          result += " #{iteration.value}" if iteration
-          result += ":#{date}" if date
-          result
-        end
       end
     end
   end

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

@@ -22,18 +22,6 @@ module Pubid
           { key: :gum_guide, title: "GUM Guide", short: "GUM" }
         end
 
-        def to_s(lang: :en, lang_single: false, with_edition: false,
-format: nil, stage_format_long: nil, with_date: nil)
-          parts = []
-          parts << publisher.publisher if publisher
-          parts << "GUM-#{gum_number.value}" if gum_number
-
-          result = parts.join(" ")
-          result += ":#{date}" if date
-          result += language_portion if languages&.any?
-          result
-        end
-
         private
 
         def language_portion

data/lib/pubid/jcgm/renderer.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    # Human-readable renderer for JCGM identifiers.
+    #
+    # Produces strings like:
+    #   "JCGM 100:2008"
+    #   "JCGM 100:2008/Amd 1:2023"
+    #   "JCGM GUM-6:2020"
+    #
+    # The renderer is registered as the `:human` format in the JCGM format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::Amendment
+          render_amendment(id, context)
+        when Identifiers::GumGuide
+          render_gum_guide(id, context)
+        else
+          render_single(id)
+        end
+      end
+
+      private
+
+      def render_single(id)
+        parts = [id.publisher_portion]
+        parts << id.number_portion unless id.number_portion.empty?
+        result = parts.join(" ")
+        result += id.language_portion if id.languages&.any?
+        result
+      end
+
+      def render_amendment(id, context)
+        result = id.base_identifier.to_s if id.base_identifier
+        result += "/Amd"
+        result += " #{id.iteration.render(context:)}" if id.iteration
+        result += ":#{id.date}" if id.date
+        result
+      end
+
+      def render_gum_guide(id, context)
+        parts = []
+        parts << id.publisher.publisher if id.publisher
+        parts << "GUM-#{id.gum_number.render(context:)}" if id.gum_number
+
+        result = parts.join(" ")
+        result += ":#{id.date}" if id.date
+        result += gum_language_portion(id) if id.languages&.any?
+        result
+      end
+
+      def gum_language_portion(id)
+        return "" unless id.languages&.any?
+
+        codes = id.languages.map do |lang|
+          lang.original_code || lang.code
+        end
+
+        "(#{codes.join('/')})"
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/single_identifier.rb

@@ -35,14 +35,6 @@ module Pubid
           ")",
         ].join
       end
-
-      def to_s
-        parts = [publisher_portion]
-        parts << number_portion unless number_portion.empty?
-        result = parts.join(" ")
-        result += language_portion
-        result
-      end
     end
   end
 end

data/lib/pubid/jcgm/urn_generator.rb

@@ -37,9 +37,8 @@ module Pubid
           parts << "-#{sp}"
         end
 
-        if identifier.date
-          year = identifier.date.year
-          parts << year.to_s
+        if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
+          parts << identifier.date.render(context: URN_CONTEXT)
         elsif maybe(:year)
           parts << maybe(:year).to_s
         end
@@ -95,9 +94,8 @@ module Pubid
             parts << iter
           end
 
-          if identifier.date
-            year = identifier.date.year
-            parts << year.to_s
+          if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
+            parts << identifier.date.render(context: URN_CONTEXT)
           end
         else
           parts << "unknown"