pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/tgpp.rb

@@ -0,0 +1,83 @@
+# 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)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, 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,40 @@
+# 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)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      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

data/lib/pubid/un/parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Un
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:slash) { str("/") }
+      rule(:un_prefix) { (str("UN") >> str(" ")).maybe }
+      rule(:token) { match("[A-Z0-9.]").repeat(1) }
+
+      rule(:identifier) do
+        un_prefix >>
+          token.as(:token) >>
+          (slash >> token.as(:token)).repeat(1)
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/un/renderer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Un
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        (@id.path + [@id.number]).join("/")
+      end
+    end
+  end
+end

data/lib/pubid/un.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Un
+    extend Pubid::PrefixesSupport
+
+    PREFIXES = ["UN"].freeze
+
+    autoload :Builder, "#{__dir__}/un/builder"
+    autoload :Identifier, "#{__dir__}/un/identifier"
+    autoload :Identifiers, "#{__dir__}/un/identifiers"
+    autoload :Parser, "#{__dir__}/un/parser"
+    autoload :Renderer, "#{__dir__}/un/renderer"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Un::Renderer)
+
+    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
+
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
+      end
+    end
+
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    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
+
+Pubid::Registry.register(:un, Pubid::Un)

data/lib/pubid/urn_generator/base.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Pubid
+  module UrnGenerator
+    # Base class for all flavor-specific URN generators.
+    # Provides template methods for common URN parts.
+    # Flavors subclass and override only what differs.
+    class Base
+      URN_CONTEXT = Rendering::RenderingContext.urn.freeze
+      private_constant :URN_CONTEXT
+
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        parts = ["urn", urn_namespace]
+        parts << urn_publisher if urn_publisher
+        parts << urn_type if urn_type
+        parts << urn_number if urn_number
+        parts << urn_part if urn_part
+        parts << urn_subpart if urn_subpart
+        parts << urn_year if urn_year
+        parts << urn_edition if urn_edition
+        parts << urn_language if urn_language
+        parts.join(":")
+      end
+
+      # Template methods — override in subclasses
+
+      def urn_namespace
+        flavor_name.downcase
+      end
+
+      def urn_publisher
+        pub = maybe(:publisher)
+        return nil unless pub
+
+        pub.is_a?(Components::Publisher) ? pub.render(context: URN_CONTEXT) : pub.to_s.downcase
+      end
+
+      def urn_type
+        nil
+      end
+
+      def urn_number
+        val = maybe(:number) || maybe(:code)
+        return nil unless val
+
+        val.is_a?(Components::Code) ? val.render(context: URN_CONTEXT) : val.to_s
+      end
+
+      def urn_part
+        val = maybe(:part)
+        return nil unless val
+
+        "-#{val.is_a?(Components::Code) ? val.render(context: URN_CONTEXT) : val}"
+      end
+
+      def urn_subpart
+        val = maybe(:subpart)
+        return nil unless val
+
+        "-#{val.is_a?(Components::Code) ? val.render(context: URN_CONTEXT) : val}"
+      end
+
+      def urn_year
+        date = maybe(:date)
+        if date.is_a?(Components::Date)
+          return date.render(context: URN_CONTEXT) if date.present?
+        elsif date
+          return date.to_s
+        end
+        maybe(:year)&.to_s
+      end
+
+      def urn_edition
+        ed = maybe(:edition)
+        return nil unless ed
+
+        num = ed.is_a?(Components::Edition) ? ed.number : ed
+        return nil unless num
+
+        "ed.#{num}"
+      end
+
+      def urn_language
+        langs = maybe(:languages)
+        return nil unless langs&.any?
+
+        langs.map(&:code).join(",")
+      end
+
+      def maybe(method_name)
+        return nil unless identifier.class.attributes.key?(method_name)
+
+        identifier.public_send(method_name)
+      end
+
+      private
+
+      def flavor_name
+        parts = identifier.class.name.split("::")
+        parts[1] || "unknown"
+      end
+    end
+  end
+end

data/lib/pubid/urn_parser/base.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Pubid
+  module UrnParser
+    # Base class for flavor-specific URN parsers.
+    #
+    # A UrnParser inverts its sibling UrnGenerator: it consumes the URN
+    # emitted by {Pubid::{Flavor}::UrnGenerator} and rebuilds an Identifier.
+    # The preferred strategy is to reconstruct a human-readable identifier
+    # string from the URN fields and delegate to the flavor's text parser —
+    # this keeps parsing logic in one place (the flavor's text parser).
+    #
+    # Subclasses MUST override {#parse_urn}. They typically use
+    # {#strip_namespace} and {#flavor_parse} helpers and may pass through
+    # {#build_from_parts} for the common `urn:{flavor}:{publisher}:{type}:
+    # {number}:{year}` shape.
+    class Base
+      # Parse a URN string into an Identifier.
+      # @param urn [String]
+      # @return [Pubid::Identifier]
+      def self.parse(urn)
+        new.parse_urn(urn)
+      end
+
+      # Subclasses override.
+      # @raise [NotImplementedError]
+      def parse_urn(_urn)
+        raise NotImplementedError,
+              "#{self.class} must implement #parse_urn"
+      end
+
+      protected
+
+      # The flavor module this parser belongs to (e.g., Pubid::Sae).
+      # Derived from the class name: Pubid::Sae::UrnParser → Pubid::Sae.
+      def flavor_module
+        @flavor_module ||=
+          begin
+            path = self.class.name.to_s.split("::")
+            Object.const_get(path[0..-2].join("::"))
+          end
+      end
+
+      # The lowercase flavor name used as the URN namespace (e.g., "sae").
+      # Defaults to the last segment of the module name. Override in
+      # subclasses whose URN namespace differs from the module name
+      # (e.g., CenCenelec emits URNs under "urn:cen:").
+      def flavor_name
+        @flavor_name ||= flavor_module.name.split("::").last.downcase
+      end
+
+      # Validate the URN starts with `urn:{flavor}:` and return the body.
+      # @param urn [String]
+      # @return [String] body after `urn:{flavor}:`
+      # @raise [Errors::ParseError] if prefix is wrong
+      def strip_namespace(urn)
+        prefix = "urn:#{flavor_name}:"
+        unless urn.downcase.start_with?(prefix)
+          raise Errors::ParseError,
+                "Invalid #{flavor_name.upcase} URN: #{urn.inspect}"
+        end
+
+        urn[prefix.length..]
+      end
+
+      # Delegate to the flavor's text parser.
+      # @param code [String] human-readable identifier
+      # @return [Pubid::Identifier]
+      def flavor_parse(code)
+        flavor_module.parse(code)
+      end
+
+      # Split the URN body on ":" into parts.
+      # @param body [String]
+      # @return [Array<String>]
+      def split_parts(body)
+        body.split(":")
+      end
+    end
+  end
+end

data/lib/pubid/urn_parser/errors.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Pubid
+  module UrnParser
+    # Deprecated. The URN error moved to {Pubid::Errors::UrnParseError}, so
+    # that every pubid failure lives in one namespace under the marker module
+    # {Pubid::Errors::Error}. This alias keeps the nine `raise` sites in the
+    # flavor URN parsers, and any consumer rescuing the old name, working
+    # unchanged.
+    module Errors
+      ParseError = ::Pubid::Errors::UrnParseError
+    end
+  end
+end

data/lib/pubid/urn_parser.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Parses URN strings back into Identifier objects.
+  #
+  # Each flavor's {UrnParser} inverts the corresponding {UrnGenerator}. The
+  # {Base} class provides shared utilities (validation, splitting, dispatch
+  # back to the flavor's text parser); subclasses implement the per-flavor
+  # field reconstruction.
+  module UrnParser
+    autoload :Base, "pubid/urn_parser/base"
+    autoload :Errors, "pubid/urn_parser/errors"
+  end
+end