pubid 2.0.0.pre.alpha.3 → 2.0.0.pre.alpha.4

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

@@ -2,79 +2,73 @@
 
 module Pubid
   module Iho
-    module Identifiers
-      # Base class for all IHO identifiers.
-      #
-      # IHO identifiers have the form:
-      #   IHO {S|P|M|B|C}-{number}[ Ap. {appendix}][ Part {part}][ Annex {annex}][ Suppl {supplement}][ {version}]
-      #
-      # The leading IHO publisher prefix is optional on input but always
-      # emitted on output.
-      class Base < Pubid::Identifier
-        # Identity for the Pubid::Iho::Identifier facade (see its comment).
-        include Pubid::Iho::Identifier
-
-        # `number` overrides the generic Components::Code attribute with a plain
-        # string (same pattern as `part` below); it holds the IHO document
-        # number (e.g. "100", "1/21"). Kept as the generic `number` so the
-        # relaton index sorts/binary-searches on it natively via `id.number`.
-        attribute :number,     :string
-        attribute :publisher,  :string, default: "IHO"
-        attribute :appendix,   :string
-        attribute :part,       :string
-        attribute :annex,      :string
-        attribute :supplement, :string
-        attribute :version,    :string
+    # Base class for all IHO identifiers. Canonical name Pubid::Iho::Identifier;
+    # every concrete IHO identifier (Identifiers::*) descends from it, and
+    # Identifiers::Base — aliased at the foot of this file — points back to it.
+    #
+    # IHO identifiers have the form:
+    #   IHO {S|P|M|B|C}-{number}[ Ap. {appendix}][ Part {part}][ Annex {annex}][ Suppl {supplement}][ {version}]
+    #
+    # The leading IHO publisher prefix is optional on input but always
+    # emitted on output.
+    class Identifier < ::Pubid::Identifier
+      # Parse an IHO identifier string into an identifier object
+      # @param identifier [String] The IHO identifier string to parse
+      # @return [Pubid::Iho::Identifier] The appropriate identifier object
+      # @raise [Parslet::ParseFailed] If parsing fails
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse IHO identifier '#{identifier}': #{e.message}"
+      end
 
-        # Polymorphic type map for lutaml::Model key_value serialization: maps
-        # each subclass's polymorphic_name to its class name so `from_hash` can
-        # re-instantiate the concrete type from `_type`.
-        IHO_TYPE_MAP = {
-          "pubid:iho:standard"        => "Pubid::Iho::Identifiers::Standard",
-          "pubid:iho:publication"     => "Pubid::Iho::Identifiers::Publication",
-          "pubid:iho:miscellaneous"   => "Pubid::Iho::Identifiers::Miscellaneous",
-          "pubid:iho:bibliographic"   => "Pubid::Iho::Identifiers::Bibliographic",
-          "pubid:iho:circular-letter" => "Pubid::Iho::Identifiers::CircularLetter",
-        }.freeze
+      # `number` overrides the generic Components::Code attribute with a plain
+      # string (same pattern as `part` below); it holds the IHO document
+      # number (e.g. "100", "1/21"). Kept as the generic `number` so the
+      # relaton index sorts/binary-searches on it natively via `id.number`.
+      attribute :number,     :string
+      attribute :publisher,  :string, default: "IHO"
+      attribute :appendix,   :string
+      attribute :part,       :string
+      attribute :annex,      :string
+      attribute :supplement, :string
+      attribute :version,    :string
 
-        # The base Pubid::Identifier no longer auto-maps attributes, so each
-        # flavor's top class must declare its own key_value mapping. IHO
-        # attributes are plain strings, so they map directly. `publisher` is
-        # intentionally omitted: it is always the "IHO" default and is restored
-        # on load.
-        key_value do
-          map "_type",      to: :_type, polymorphic_map: IHO_TYPE_MAP
-          map "number",     to: :number
-          map "appendix",   to: :appendix
-          map "part",       to: :part
-          map "annex",      to: :annex
-          map "supplement", to: :supplement
-          map "version",    to: :version
-        end
+      # Polymorphic type map for lutaml::Model key_value serialization: maps
+      # each subclass's polymorphic_name to its class name so `from_hash` can
+      # re-instantiate the concrete type from `_type`.
+      IHO_TYPE_MAP = {
+        "pubid:iho:standard" => "Pubid::Iho::Identifiers::Standard",
+        "pubid:iho:publication" => "Pubid::Iho::Identifiers::Publication",
+        "pubid:iho:miscellaneous" => "Pubid::Iho::Identifiers::Miscellaneous",
+        "pubid:iho:bibliographic" => "Pubid::Iho::Identifiers::Bibliographic",
+        "pubid:iho:circular-letter" => "Pubid::Iho::Identifiers::CircularLetter",
+      }.freeze
 
-        # Re-instantiate the concrete subclass from `_type`. lutaml's
-        # polymorphic_map only validates `_type` on key_value deserialization;
-        # without this routing `from_hash` returns a bare Base (no #type, which
-        # breaks #to_s). Mirrors Pubid::Iso::Identifier.from_hash.
-        def self.from_hash(data, options = {})
-          klass_name = IHO_TYPE_MAP[data["_type"] || data[:_type]]
-          if klass_name
-            klass = Object.const_get(klass_name)
-            return klass.from_hash(data, options) unless klass == self
-          end
-          super
-        end
+      # The base Pubid::Identifier no longer auto-maps attributes, so each
+      # flavor's top class must declare its own key_value mapping. IHO
+      # attributes are plain strings, so they map directly. `publisher` is
+      # intentionally omitted: it is always the "IHO" default and is restored
+      # on load.
+      key_value do
+        map "_type",      to: :_type, polymorphic_map: IHO_TYPE_MAP
+        map "number",     to: :number
+        map "appendix",   to: :appendix
+        map "part",       to: :part
+        map "annex",      to: :annex
+        map "supplement", to: :supplement
+        map "version",    to: :version
+      end
 
-        def self.parse(string)
-          Iho::Identifier.parse(string)
-        end
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
+      # IHO_TYPE_MAP remains as the key_value polymorphic_map.
+    end
 
-        # Render the identifier as a string in canonical IHO form.
-        # @return [String]
-        def to_s
-          render(format: :human)
-        end
-      end
+    module Identifiers
+      # Backward-compatible alias: IHO's base class used to be
+      # Pubid::Iho::Identifiers::Base. It is now Pubid::Iho::Identifier.
+      Base = Pubid::Iho::Identifier
     end
   end
 end

data/lib/pubid/iho.rb

@@ -27,7 +27,9 @@ module Pubid
       @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 }
-        .reject { |c| c.name&.split("::")&.last == "Base" }
+        # Exclude the flavor base itself by identity (Identifiers::Base is now an
+        # alias for Pubid::Iho::Identifier, so name-based matching misses it).
+        .reject { |c| c == Identifiers::Base }
     end
 
     # Build typed stage index from identifier types

data/lib/pubid/iso/identifier.rb

@@ -85,6 +85,14 @@ module Pubid
         "pubid:iso:bundled-identifier" => "Pubid::Iso::BundledIdentifier",
       }.freeze
 
+      # BundledIdentifier lives outside Pubid::Iso::Identifiers but carries a
+      # polymorphic `_type`, so the shared polymorphic_type_map needs it
+      # explicitly (see Pubid::Identifier#additional_identifier_classes).
+      def self.additional_identifier_classes
+        [Pubid::Iso::BundledIdentifier]
+      end
+      private_class_method :additional_identifier_classes
+
       # Build type map from Pubid::Iso.identifier_types for validation
       def self.build_type_map
         Pubid::Iso.identifier_types.to_h do |klass|
@@ -259,6 +267,10 @@ module Pubid
       end
 
       def self.parse(string, format: :auto)
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         format = Pubid::FormatDetector.detect(string) if format == :auto
 
         case format
@@ -277,20 +289,9 @@ module Pubid
         end
       end
 
-      # lutaml's polymorphic key_value mapping reads `_type` only to validate;
-      # it does not re-instantiate the concrete subclass on deserialization. So
-      # `Identifier.from_hash(corrigendum_hash)` would return a bare Identifier
-      # and drop `base_identifier`. Route by `_type` to the right subclass and
-      # let its (inherited) from_hash do the real work, mirroring JIS.
-      def self.from_hash(data, options = {})
-        type = data["_type"] || data[:_type]
-        klass_name = ISO_TYPE_MAP[type]
-        if klass_name
-          klass = Object.const_get(klass_name)
-          return klass.from_hash(data, options) unless klass == self
-        end
-        super
-      end
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier, which
+      # routes `_type` through polymorphic_type_map (ISO_TYPE_MAP's dynamic
+      # equivalent). ISO_TYPE_MAP remains as the key_value polymorphic_map.
     end
   end
 end

data/lib/pubid/iso/single_identifier.rb

@@ -3,10 +3,6 @@
 module Pubid
   module Iso
     class SingleIdentifier < Identifier
-      def to_s(**opts)
-        render(format: :human, **opts)
-      end
-
       private
 
       def build_rendering_context(_renderer, format:, with_edition: false,

data/lib/pubid/iso.rb

@@ -25,6 +25,10 @@ module Pubid
     # @param format [Symbol] :auto, :human, :mr_string, or :urn
     # @return [Identifier] the parsed identifier
     def self.parse(identifier, format: :auto)
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       format = Pubid::FormatDetector.detect(identifier) if format == :auto
 
       case format

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

@@ -15,13 +15,7 @@ module Pubid
       class Code < Lutaml::Model::Serializable
         attribute :number, :string
         attribute :subseries, :string
-        attribute :parts, :string, collection: true
-
-        def initialize(number:, subseries: nil, parts: nil)
-          @number = number
-          @subseries = subseries
-          @parts = parts || []
-        end
+        attribute :parts, :string, collection: true, default: []
 
         def to_s
           result = number.to_s

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

@@ -12,12 +12,23 @@ module Pubid
 
         VALID_SECTORS = %w[R T D].freeze
 
-        def initialize(sector:)
-          unless VALID_SECTORS.include?(sector.to_s.upcase)
-            raise ArgumentError, "Invalid sector: #{sector}. Must be R, T, or D"
+        # 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
 
-          @sector = sector.to_s.upcase
+          self.sector = normalized
         end
 
         def to_s

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

@@ -10,10 +10,6 @@ module Pubid
       class Series < Lutaml::Model::Serializable
         attribute :series, :string # e.g., BO, V, X, R, SG1, OB
 
-        def initialize(series:)
-          @series = series
-        end
-
         def to_s
           series
         end

data/lib/pubid/itu/identifier.rb

@@ -1,20 +1,6 @@
 # frozen_string_literal: true
 
-module Pubid
-  module Itu
-    # NOTE: intentionally does NOT `extend Pubid::IdentifierFacade`. ITU's
-    # `to_hash` currently raises (publisher stored as a String, not a Publisher
-    # component), so enabling the facade's identity check would route ITU ids
-    # through a consumer's `to_hash` (e.g. relaton-index#save) and crash.
-    # Re-enable once ITU serialization round-trips cleanly. See
-    # identifier_facade.rb.
-    module Identifier
-      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
-    end
-  end
-end
+# Pubid::Itu::Identifier is the ITU base class (a real Pubid::Identifier
+# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
+# live in identifiers/base.rb. This file just ensures it is loaded.
+require_relative "identifiers/base"

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

@@ -2,147 +2,149 @@
 
 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
+
+      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
+        "-#{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.rb

@@ -27,7 +27,9 @@ module Pubid
       @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 }
-        .reject { |c| c.name&.split("::")&.last == "Base" }
+        # 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

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

@@ -20,10 +20,6 @@ module Pubid
         def self.type
           { key: :amendment, title: "Amendment", short: "Amd" }
         end
-
-        def to_s(**opts)
-          render(format: :human, **opts)
-        end
       end
     end
   end

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

@@ -22,10 +22,6 @@ module Pubid
           { key: :gum_guide, title: "GUM Guide", short: "GUM" }
         end
 
-        def to_s(**opts)
-          render(format: :human, **opts)
-        end
-
         private
 
         def language_portion

data/lib/pubid/jcgm/single_identifier.rb

@@ -35,10 +35,6 @@ module Pubid
           ")",
         ].join
       end
-
-      def to_s
-        render(format: :human)
-      end
     end
   end
 end