pubid 2.0.0.pre.alpha.7 → 2.0.0.pre.alpha.9

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

@@ -2,8 +2,7 @@
 
 module Pubid
   module Sae
-    # Base SAE Identifier. Canonical name Pubid::Sae::Identifier (Identifiers::Base
-    # is a back-compat alias). SAE has a single identifier class that IS the
+    # Base SAE Identifier. Canonical name Pubid::Sae::Identifier. SAE has a single identifier class that IS the
     # document type, so this class is both the base and the only concrete type.
     # Handles all SAE document types (AMS, AIR, ARP, AS, MA).
     class Identifier < ::Pubid::Identifier
@@ -26,12 +25,16 @@ module Pubid
       def year
         date&.year
       end
-    end
 
-    module Identifiers
-      # Backward-compatible alias: SAE's base class used to be
-      # Pubid::Sae::Identifiers::Base. It is now Pubid::Sae::Identifier.
-      Base = Pubid::Sae::Identifier
+      # SAE encodes the document class (AS, ARP, AMS, AIR, J, …) in `type.abbr`,
+      # not in `typed_stage.type_code`, so the generic mr_type returns nil.
+      # Losslessness requires the type letter to appear in MR — without it,
+      # `SAE J300` and `SAE AS300` would collide on `SAE.300.<year>`.
+      # Lowercased to match the all-lowercase MR convention (issue #142).
+      def mr_type
+        type&.abbr&.to_s&.downcase
+      end
     end
+
   end
 end

data/lib/pubid/sae/identifiers.rb

@@ -3,7 +3,6 @@
 module Pubid
   module Sae
     module Identifiers
-      autoload :Base, "#{__dir__}/identifiers/base"
     end
   end
 end

data/lib/pubid/sae.rb

@@ -10,7 +10,7 @@ module Pubid
 
     autoload :Builder, "#{__dir__}/sae/builder"
     autoload :Components, "#{__dir__}/sae/components"
-    autoload :Identifier, "#{__dir__}/sae/identifier"
+    autoload :Identifier, "#{__dir__}/sae/identifiers/base"
     autoload :Identifiers, "#{__dir__}/sae/identifiers"
     autoload :Parser, "#{__dir__}/sae/parser"
     autoload :Renderer, "#{__dir__}/sae/renderer"
@@ -62,5 +62,5 @@ end
 Pubid::Registry.register(:sae, Pubid::Sae)
 
 # Per-flavor format registry: inherits global formats, overrides :human
-Pubid::Sae::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::Sae::Identifiers::Base.format_registry.register(:human, renderer: Pubid::Sae::Renderer)
+Pubid::Sae::Identifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Sae::Identifier.format_registry.register(:human, renderer: Pubid::Sae::Renderer)

data/lib/pubid/tgpp/builder.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        identifier_class(data[:type]).new(
+          number: data[:number].to_s,
+          suffix: data[:suffix]&.to_s,
+          parts: extract_part_strings(data[:parts]),
+          release: data[:release]&.to_s,
+          version: data[:version].to_s,
+        )
+      end
+
+      private
+
+      def identifier_class(type)
+        if type.to_s == "TR"
+          Identifiers::TechnicalReport
+        else
+          Identifiers::TechnicalSpecification
+        end
+      end
+
+      # parts_data is an array of `{ part: "1" }` hashes (or a single hash for a
+      # one-level part); return the part numbers as strings.
+      def extract_part_strings(parts_data)
+        case parts_data
+        when Array then parts_data.filter_map { |h| h[:part]&.to_s }
+        when Hash then [parts_data[:part]&.to_s].compact
+        else []
+        end
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/identifier.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    # Base class for every 3GPP identifier AND the flavor's parse entry point —
+    # mirrors Pubid::Jis::Identifier. Concrete identifiers under
+    # Pubid::Tgpp::Identifiers descend from this class, so a parsed 3GPP id is
+    # an instance of Pubid::Tgpp::Identifier.
+    class Identifier < ::Pubid::Identifier
+      # The dotted core (e.g. "23.207") kept as a string to preserve leading
+      # zeros. `number` overrides the base Components::Code attribute.
+      attribute :number, :string
+      # Optional letter suffix directly after the number: "U", "dcs", "ext"…
+      attribute :suffix, :string
+      # 1–2 hyphen parts (e.g. "26.171-1", "29.198-04-1"); strings preserve any
+      # zero-padding.
+      attribute :parts, :string, collection: true
+      # Raw release token, stored verbatim: "REL-4", "Ph1", "UMTS",
+      # "Release 2000".
+      attribute :release, :string
+      # Three-part version string, e.g. "2.0.0".
+      attribute :version, :string
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization.
+      # Keys are the `pubid:3gpp:…` names produced by polymorphic_name (below).
+      TGPP_TYPE_MAP = {
+        "pubid:3gpp:technical-report" =>
+          "Pubid::Tgpp::Identifiers::TechnicalReport",
+        "pubid:3gpp:technical-specification" =>
+          "Pubid::Tgpp::Identifiers::TechnicalSpecification",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: TGPP_TYPE_MAP
+        map "number", to: :number
+        map "suffix", to: :suffix
+        map "parts", to: :parts
+        map "release", to: :release
+        map "version", to: :version
+      end
+
+      # Publisher token. A plain constant (not a `publisher` method) so it does
+      # not shadow the inherited lutaml `publisher` attribute.
+      PUBLISHER = "3GPP"
+
+      # The auto-derived polymorphic name would be "pubid:tgpp:…" (from the
+      # module constant). Force the "3gpp" segment so the `_type` tag matches
+      # the relaton flavor name and TGPP_TYPE_MAP.
+      def self.polymorphic_name
+        super&.sub(/\Apubid:tgpp:/, "pubid:3gpp:")
+      end
+
+      # Rendering flag: whether to prefix the string with "3GPP ". Transient
+      # (not serialized). #to_s sets it, renders, then resets it to false in an
+      # ensure block, so a subsequent bare #render defaults to no publisher and
+      # the flag never leaks past the to_s call that set it.
+      attr_reader :with_publisher
+
+      # The rendered document code, e.g. "29.198-04-1" (number+suffix+parts).
+      def code
+        result = "#{number}#{suffix}"
+        result += parts.map { |p| "-#{p}" }.join if parts&.any?
+        result
+      end
+
+      # Basic string representation. Delegates to the :human renderer. Default
+      # omits the "3GPP " publisher token (matches the relaton index id);
+      # `to_s(with_publisher: true)` emits the printed "3GPP TS …" form.
+      def to_s(with_publisher: false, **opts)
+        @with_publisher = with_publisher
+        render(format: :human, **opts)
+      ensure
+        @with_publisher = false
+      end
+
+      # Parse a 3GPP identifier string into an identifier object
+      # @param identifier [String] The 3GPP identifier string to parse
+      # @return [Identifier] The appropriate identifier object
+      def self.parse(identifier)
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse 3GPP identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/identifiers/technical_report.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    module Identifiers
+      # Technical Report identifier type.
+      # Format: [3GPP ]TR NN.NNN[suffix][-part…]:<release>/<version>
+      # Example: TR 00.01U:UMTS/3.0.0
+      class TechnicalReport < Pubid::Tgpp::Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :tr,
+            stage_code: :published,
+            type_code: :tr,
+            abbr: ["TR"],
+            name: "Technical Report",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :tr,
+            web: :technical_report, title: "Technical Report", short: "TR" }
+        end
+
+        def type_prefix
+          "TR"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/identifiers/technical_specification.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    module Identifiers
+      # Technical Specification identifier type.
+      # Format: [3GPP ]TS NN.NNN[suffix][-part…]:<release>/<version>
+      # Example: TS 23.207:REL-4/2.0.0
+      class TechnicalSpecification < Pubid::Tgpp::Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :ts,
+            stage_code: :published,
+            type_code: :ts,
+            abbr: ["TS"],
+            name: "Technical Specification",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :ts,
+            web: :technical_specification,
+            title: "Technical Specification", short: "TS" }
+        end
+
+        def type_prefix
+          "TS"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/identifiers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    module Identifiers
+      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+      autoload :TechnicalSpecification,
+               "#{__dir__}/identifiers/technical_specification"
+    end
+  end
+end

data/lib/pubid/tgpp/parser.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Tgpp
+    # Parslet grammar for 3GPP identifiers.
+    #
+    # Form: `[3GPP ]<TR|TS> <NN.NNN>[suffix][-part…]:<release>/<version>`
+    #   TS 23.207:REL-4/2.0.0
+    #   3GPP TR 00.01U:UMTS/3.0.0
+    #   TS 29.198-04-1:REL-5/5.0.0
+    #   TS 02.68:Release 2000/9.0.0
+    class Parser < Parslet::Parser
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+      rule(:space) { str(" ") }
+
+      # Optional leading publisher token.
+      rule(:publisher_prefix) { str("3GPP") >> space }
+
+      # Document type.
+      rule(:type) { (str("TR") | str("TS")).as(:type) }
+
+      # Dotted number core, kept as a string (preserves leading zeros).
+      rule(:number_core) { (digits >> str(".") >> digits).as(:number) }
+
+      # Letter suffix directly after the number ("U"/"dcs"/"ext"…). Generic so
+      # future controlled-vocabulary values keep round-tripping.
+      rule(:suffix) { match["A-Za-z"].repeat(1).as(:suffix) }
+
+      # Hyphen parts.
+      rule(:part) { str("-") >> digits.as(:part) }
+      rule(:parts) { part.repeat(0).as(:parts) }
+
+      # Release token, stored verbatim: everything up to the version separator.
+      # Excludes ":" (as well as "/") so the ":"-delimited URN scheme can always
+      # encode it — every real release ("REL-4", "Ph1", "UMTS", "Release 2000")
+      # is colon-free.
+      rule(:release) { match["^/:"].repeat(1).as(:release) }
+
+      # Three-part version, kept as a string.
+      rule(:version) do
+        (digits >> str(".") >> digits >> str(".") >> digits).as(:version)
+      end
+
+      rule(:identifier) do
+        publisher_prefix.maybe >>
+          type >> space >>
+          number_core >> suffix.maybe >> parts >>
+          (str(":") >> release).maybe >>
+          str("/") >> version
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/renderer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    # Human-readable renderer for 3GPP identifiers.
+    #
+    # Produces strings like:
+    #   "TS 23.207:REL-4/2.0.0"                (default, no publisher)
+    #   "3GPP TS 23.207:REL-4/2.0.0"           (with_publisher: true)
+    #   "TS 29.198-04-1:REL-5/5.0.0"           (parts)
+    #   "TR 00.01U:UMTS/3.0.0"                 (suffix)
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "3GPP"
+
+      def render(context: nil, **_opts)
+        id = @id
+        head = []
+        head << PUBLISHER if with_publisher?(id)
+        head << id.type_prefix
+        result = "#{head.join(' ')} #{id.code}"
+        # A handful of legacy records omit the release segment entirely
+        # (e.g. "TS 29.215/2.0.0").
+        result += ":#{id.release}" if id.release
+        "#{result}/#{id.version}"
+      end
+
+      private
+
+      # Default is no publisher token (the relaton index id form); the caller
+      # opts in via `to_s(with_publisher: true)`.
+      def with_publisher?(id)
+        id.with_publisher == true
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/urn_generator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    # Emits `urn:3gpp:<type>:<code>:<release>:<version>`, e.g.
+    # `urn:3gpp:ts:23.207:REL-4:2.0.0`. `<code>` is number+suffix+parts.
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        [
+          "urn",
+          "3gpp",
+          identifier.type_prefix.downcase,
+          identifier.code,
+          identifier.release,
+          identifier.version,
+        ].join(":")
+      end
+    end
+  end
+end

data/lib/pubid/tgpp/urn_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Tgpp
+    # Parses 3GPP URNs back into identifiers.
+    #
+    # UrnGenerator emits `urn:3gpp:<type>:<code>:<release>:<version>`; the code,
+    # release and version chunks never contain ":", so a plain split recovers
+    # them. Example: urn:3gpp:ts:23.207:REL-4:2.0.0 → TS 23.207:REL-4/2.0.0
+    class UrnParser < Pubid::UrnParser::Base
+      # The module is Tgpp but the URN namespace is "3gpp".
+      def flavor_name
+        "3gpp"
+      end
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        type, code, release, version = split_parts(body)
+        # The rare no-release form (e.g. TS 29.215/2.0.0) serialises with an
+        # empty release chunk ("urn:3gpp:ts:29.215::2.0.0"); rebuild it without
+        # the release colon.
+        head = "#{type.upcase} #{code}"
+        head += ":#{release}" unless release.nil? || release.empty?
+        flavor_parse("#{head}/#{version}")
+      end
+    end
+  end
+end

data/lib/pubid/tgpp.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Pubid
+  # 3GPP (3rd Generation Partnership Project) flavor.
+  #
+  # The Ruby constant is `Pubid::Tgpp` because a constant may not begin with a
+  # digit, but the external contract stays "3gpp": the registry key is "3gpp",
+  # the polymorphic `_type` is `pubid:3gpp:…`, and URNs use the `urn:3gpp:`
+  # namespace. Only the on-disk file names (lib/pubid/tgpp/…) follow the module.
+  module Tgpp
+    extend Pubid::PrefixesSupport
+
+    # Sole routing token. 3GPP references are printed as "3GPP TS 23.207:…";
+    # the bare document types (TR/TS) are ambiguous (JIS uses them too) and are
+    # excluded. The parser still accepts an optional leading "3GPP ".
+    PREFIXES = ["3GPP"].freeze
+
+    autoload :Builder, "#{__dir__}/tgpp/builder"
+    autoload :Identifier, "#{__dir__}/tgpp/identifier"
+    autoload :Identifiers, "#{__dir__}/tgpp/identifiers"
+    autoload :Parser, "#{__dir__}/tgpp/parser"
+    autoload :Renderer, "#{__dir__}/tgpp/renderer"
+    autoload :UrnGenerator, "#{__dir__}/tgpp/urn_generator"
+    autoload :UrnParser, "#{__dir__}/tgpp/urn_parser"
+
+    # Parse a 3GPP identifier string
+    def self.parse(identifier)
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Tgpp::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    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.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    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 3GPP flavor with the registry (external key stays "3gpp").
+Pubid::Registry.register(:"3gpp", Pubid::Tgpp)

data/lib/pubid/type_resolver.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Resolves a polymorphic `_type` string (e.g. "pubid:iso:technical-report")
+  # to the concrete Ruby class that owns it.
+  #
+  # Each flavor's Identifier base owns a `polymorphic_type_map` for the types
+  # defined in its own namespace. A nested polymorphic attribute (e.g. a GOST
+  # Harmonized identifier's adopted ISO identifier) carries a `_type` from a
+  # different flavor, so the owning flavor's map misses. This service routes
+  # the lookup to the registered flavor whose name appears in the type's
+  # second segment ("pubid:<flavor>:…"), giving every from_hash caller a
+  # single cross-flavor dispatch path.
+  class TypeResolver
+    TYPE_PREFIX = "pubid:"
+    SEGMENT_SEPARATOR = ":"
+
+    class << self
+      # @param type [String, nil] Polymorphic _type, e.g. "pubid:iso:technical-report".
+      # @return [Class<Pubid::Identifier>, nil] The concrete class, or nil if
+      #   the type is blank, malformed, or unknown to its flavor.
+      def resolve(type)
+        return nil unless type.is_a?(String)
+
+        flavor_name = flavor_segment(type)
+        return nil unless flavor_name
+
+        # Ensure the flavor module is loaded so its self-register call has
+        # run; without this, Registry may know of flavors that haven't yet
+        # populated their Identifier base's polymorphic_type_map.
+        ::Pubid.eager_load_flavors!
+
+        flavor = ::Pubid::Registry.get(flavor_name)
+        return nil unless flavor
+
+        identifier_base = flavor::Identifier
+        identifier_base.polymorphic_type_map[type]
+      rescue NameError
+        # Flavor module is registered but its Identifier base cannot be
+        # loaded (autoload failure). Treat as unresolvable.
+        nil
+      end
+
+      private
+
+      # The flavor name is the segment between the leading "pubid:" and the
+      # type-name, e.g. "iso" in "pubid:iso:technical-report".
+      def flavor_segment(type)
+        return nil unless type.start_with?(TYPE_PREFIX)
+
+        remainder = type[TYPE_PREFIX.length..]
+        flavor_end = remainder.index(SEGMENT_SEPARATOR)
+        return nil unless flavor_end
+
+        remainder[0, flavor_end]
+      end
+    end
+  end
+end

data/lib/pubid/un/builder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Un
+    class Builder
+      YEAR_REGEX = /\A\d{4}\z/.freeze
+
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        tokens = extract_tokens(data)
+        raise "UN identifier has no tokens" if tokens.empty?
+
+        number = tokens.last
+        path = tokens[0...-1]
+        year_token = path.reverse.find { |t| t.match?(YEAR_REGEX) }
+
+        Identifiers::Document.new(
+          path: path,
+          number: number,
+          date: year_token ? ::Pubid::Components::Date.new(year: year_token) : nil,
+        )
+      end
+
+      private
+
+      def extract_tokens(data)
+        raw = data.is_a?(Hash) ? data[:token] : data
+        case raw
+        when Array
+          raw.map { |h| h.is_a?(Hash) ? h[:token].to_s : h.to_s }
+        when Hash
+          [raw[:token].to_s]
+        else
+          [raw.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/pubid/un/identifier.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Un
+    class Identifier < ::Pubid::Identifier
+      attribute :path, :string, collection: true, default: []
+      attribute :number, :string
+
+      UN_TYPE_MAP = {
+        "pubid:un:document" => "Pubid::Un::Identifiers::Document",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: UN_TYPE_MAP
+        map "path", to: :path
+        map "number", to: :number
+      end
+
+      PUBLISHER = "UN"
+
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      def self.parse(identifier)
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse UN identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

data/lib/pubid/un/identifiers/document.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Un
+    module Identifiers
+      class Document < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubun,
+            stage_code: :published,
+            type_code: :un,
+            abbr: ["UN"],
+            name: "UN Document",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :un, web: :document, title: "UN Document", short: "UN" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/un/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Un
+    module Identifiers
+      autoload :Document, "#{__dir__}/identifiers/document"
+    end
+  end
+end