pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/tgpp/parser.rb

@@ -1,78 +0,0 @@
-# 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
-    #   3GPP TS 23.207                (bare reference)
-    #
-    # The release and the version are both optional: a user reference names the
-    # document alone ("3GPP TS 23.207"), and relaton parses that bare form to
-    # search the index. Only the type and the dotted number core are required,
-    # so "TS" and "TS foo" are still rejected.
-    class Parser < ::Pubid::Parser::Grammar
-      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.
-      #
-      # A trailing segment shaped exactly like a version is a mistyped "/"
-      # separator ("TS 23.207:2.0.0"), not a release: no release in the 88,464
-      # published index rows contains a dot at all. Reject it rather than
-      # silently misfiling the version as the release — which only became
-      # reachable once the version segment was made optional.
-      rule(:release) do
-        (version_core >> any.absent?).absent? >>
-          match["^/:"].repeat(1).as(:release)
-      end
-
-      # Three-part version, kept as a string.
-      rule(:version_core) do
-        digits >> str(".") >> digits >> str(".") >> digits
-      end
-      rule(:version) { version_core.as(:version) }
-
-      rule(:identifier) do
-        publisher_prefix.maybe >>
-          type >> space >>
-          number_core >> suffix.maybe >> parts >>
-          (str(":") >> release).maybe >>
-          (str("/") >> version).maybe
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
-    end
-  end
-end

data/lib/pubid/tgpp/renderer.rb

@@ -1,52 +0,0 @@
-# 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)
-    #   "TS 23.207"                            (partial reference)
-    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
-        "#{head.join(' ')} #{id.code}#{qualifiers(id)}"
-      end
-
-      private
-
-      # The trailing ":<release>" and "/<version>" qualifiers. Both are
-      # optional: a handful of legacy records omit the release entirely
-      # (e.g. "TS 29.215/2.0.0"), and a partial user reference omits both
-      # (e.g. "TS 23.207"). Render no separator for an absent one.
-      #
-      # Blank, not just nil: the grammar cannot produce "", but a hand-built
-      # hash can, and a dangling "TS 23.207:" would not re-parse. This mirrors
-      # the same guard in UrnGenerator#tail_segments.
-      def qualifiers(id)
-        result = +""
-        result << ":#{id.release}" unless blank?(id.release)
-        result << "/#{id.version}" unless blank?(id.version)
-        result
-      end
-
-      def blank?(value)
-        value.nil? || value.empty?
-      end
-
-      # 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

@@ -1,39 +0,0 @@
-# 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.
-    #
-    # A partial identifier has no release, no version, or neither. Only the
-    # TRAILING empty segments are dropped, so a bare reference gets the clean
-    # `urn:3gpp:ts:23.207` rather than a malformed `urn:3gpp:ts:23.207::`. An
-    # INTERIOR empty segment is kept, so the release-less form keeps the URN it
-    # has always emitted: `TS 29.215/2.0.0` -> `urn:3gpp:ts:29.215::2.0.0`.
-    class UrnGenerator < Pubid::UrnGenerator::Base
-      def generate
-        (head_segments + tail_segments).join(":")
-      end
-
-      private
-
-      # The namespace, the document type and the code. Always present.
-      def head_segments
-        ["urn", "3gpp", identifier.type_prefix.downcase, identifier.code]
-      end
-
-      # The two optional qualifiers, with the trailing empty ones removed.
-      def tail_segments
-        segments = [identifier.release, identifier.version]
-        # NOTE: `empty?`, not `any?` — a bare `Array#any?` tests element
-        # truthiness, so `[nil, nil].any?` is false and would strip nothing.
-        segments.pop until segments.empty? || !blank?(segments.last)
-        segments.map(&:to_s)
-      end
-
-      def blank?(value)
-        value.nil? || value.empty?
-      end
-    end
-  end
-end

data/lib/pubid/tgpp/urn_parser.rb

@@ -1,30 +0,0 @@
-# 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)
-        # A partial identifier drops its trailing segments, and the 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 only the segments present, so
-        # neither the release colon nor the version slash dangles.
-        result = "#{type.upcase} #{code}"
-        result += ":#{release}" unless release.nil? || release.empty?
-        result += "/#{version}" unless version.nil? || version.empty?
-        flavor_parse(result)
-      end
-    end
-  end
-end

data/lib/pubid/tgpp.rb

@@ -1,83 +0,0 @@
-# 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

@@ -1,59 +0,0 @@
-# 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

@@ -1,42 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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

@@ -1,24 +0,0 @@
-# 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

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

data/lib/pubid/un/parser.rb

@@ -1,25 +0,0 @@
-# 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

@@ -1,11 +0,0 @@
-# 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

@@ -1,46 +0,0 @@
-# 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_parser/base.rb

@@ -1,81 +0,0 @@
-# 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

@@ -1,16 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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