pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/nist/urn_parser.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    # Parses NIST URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:nist:{type}:{code}[.{revision}].supp
+    #
+    # type is the lowercase series (sp, fips, ir, nistcir, …). code is the
+    # alphanumeric designation. revision is `r{N}` when present. The `.supp`
+    # suffix marks the series as supplementable.
+    #
+    # Examples:
+    # - urn:nist:sp:800-53.supp        → NIST SP 800-53
+    # - urn:nist:sp:800-53.r5.supp     → NIST SP 800-53r5
+    # - urn:nist:fips:199.supp         → NIST FIPS 199
+    class UrnParser < Pubid::UrnParser::Base
+      TYPE_UPCASE = {
+        "sp" => "SP",
+        "fips" => "FIPS",
+        "ir" => "IR",
+        "nistcir" => "NISTCIR",
+        "nbs" => "NBS",
+        "nistir" => "NISTIR",
+        "csf" => "CSF",
+        "gcr" => "GCR",
+        "itl" => "ITL",
+        "jres" => "JRES",
+        "lcirc" => "LCIRC",
+        "mon" => "MONO",
+        "ms" => "MS",
+        "nsrds" => "NSRDS",
+        "tn" => "TN",
+        "wp" => "WP",
+      }.freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        type_token, payload = parts
+        code, revision = parse_payload(payload)
+
+        text = "NIST #{type_label(type_token)} #{code}"
+        text += revision if revision
+        flavor_parse(text)
+      end
+
+      private
+
+      def parse_payload(payload)
+        # Strip the trailing ".supp" supplement marker.
+        stripped = payload.sub(/\.supp\z/, "")
+        # Split revision suffix from code (e.g., "800-53.r5" → ["800-53", "r5"]).
+        match = stripped.match(/^(.*)\.(r\d+)$/i)
+        return [stripped, nil] unless match
+
+        [match[1], match[2]]
+      end
+
+      def type_label(token)
+        TYPE_UPCASE.fetch(token.downcase) { token.upcase }
+      end
+    end
+  end
+end

data/lib/pubid/nist.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Nist
+    extend Pubid::PrefixesSupport
+
+    # Publisher prefixes (NBS/NIST) plus the "simple series" tokens that can
+    # *begin* a printed reference on their own — mirrors the parser's
+    # `publisher` and `simple_series` rules (lib/pubid/nist/parser.rb). Compound
+    # series that only appear glued to a publisher (e.g. "NBS CRPL-F-A") are
+    # excluded because they never lead a routable reference by themselves.
+    PREFIXES = %w[
+      NIST NBS
+      AMS VTS BSS BMS BH FIPS GCR HB MONO MP NCSTAR NSRDS IR SP TN CSWP
+      AI CIRC CS CSM CRPL LCIRC OWMWP PC RPT SIBS TIBM TTB EAB JPCRD JRES
+      CHIPS NWIRP RB
+    ].freeze
+
+    autoload :Builder, "#{__dir__}/nist/builder"
+    autoload :Caster, "#{__dir__}/nist/caster"
+    autoload :CircularSupplementBuilder, "#{__dir__}/nist/circular_supplement_builder"
+    autoload :Components, "#{__dir__}/nist/components"
+    autoload :Configuration, "#{__dir__}/nist/configuration"
+    autoload :Identifier, "#{__dir__}/nist/identifiers/base"
+    autoload :Identifiers, "#{__dir__}/nist/identifiers"
+    autoload :Parser, "#{__dir__}/nist/parser"
+    autoload :ParserOutputNormalizer, "#{__dir__}/nist/parser_output_normalizer"
+    autoload :Preprocessor, "#{__dir__}/nist/preprocessor"
+    autoload :Renderer, "#{__dir__}/nist/renderer"
+    autoload :Router, "#{__dir__}/nist/router"
+    autoload :Series, "#{__dir__}/nist/series"
+    autoload :SupplementIdentifier, "#{__dir__}/nist/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/nist/urn_generator"
+    autoload :UrnParser, "#{__dir__}/nist/urn_parser"
+
+    # Explicit registry of NIST identifier classes.
+    #
+    # NIST identifier classes use `typed_stages` (not the `self.type` Hash
+    # pattern used by CEN/JCGM/ANSI), so they cannot be auto-discovered.
+    # Identifier is the fallback for unmapped series (e.g. AMS, VTS)
+    # and must be excluded from typed-stage aggregation.
+    IDENTIFIER_TYPES = [
+      Identifiers::SpecialPublication,
+      Identifiers::FederalInformationProcessingStandards,
+      Identifiers::InteragencyReport,
+      Identifiers::Handbook,
+      Identifiers::TechnicalNote,
+      Identifiers::Circular,
+      Identifiers::CircularSupplement,
+      Identifiers::CrplReport,
+      Identifiers::Report,
+      Identifiers::Monograph,
+      Identifiers::MiscellaneousPublication,
+      Identifiers::GrantContractorReport,
+      Identifiers::Ncstar,
+      Identifiers::Owmwp,
+      Identifiers::Nsrds,
+      Identifiers::LetterCircular,
+      Identifiers::CommercialStandard,
+      Identifiers::CommercialStandardEmergency,
+      Identifiers::CommercialStandardsMonthly,
+      Identifiers::DatedDocument,
+      Identifier, # Fallback for unmapped series
+    ].freeze
+
+    # Parse a NIST identifier string
+    # @param identifier [String] the identifier string to parse
+    # @return [Identifier] the parsed identifier
+    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
+
+      # Use the Parser class's preprocessing method
+      # Note: We call the class method directly to ensure preprocessing is applied
+      parsed = Parser.class_parse_with_preprocessing(identifier)
+
+      # Builder is stateless — lookups go through this module (Pubid::Nist)
+      builder = Builder.new
+      builder.build(parsed)
+    end
+
+    # Get the configuration instance
+    # @return [Configuration] the configuration instance
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Nist::Renderer)
+
+    # All identifier classes for external consumption (export, website).
+    # Identifier is the fallback for unmapped series and is excluded
+    # from external type listings.
+    # @return [Array<Class>] identifier classes
+    def self.identifier_types
+      IDENTIFIER_TYPES.reject { |klass| klass == Identifier }
+    end
+
+    # Aggregate TYPED_STAGES from all identifier classes.
+    # Identifier is excluded because it has no typed stages and acts
+    # as the fallback for unmapped series.
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types
+        .reject { |klass| klass == Identifier }
+        .flat_map(&:typed_stages)
+        .freeze
+    end
+
+    # Lookup: type code -> identifier class.
+    # Identifier is excluded so it never gets selected by type code.
+    # @param code [String, Symbol] the type code to find
+    # @return [Class, nil] the matching identifier class, or nil
+    def self.locate_type(code)
+      type_str = code.to_s
+      identifier_types
+        .reject { |klass| klass == Identifier }
+        .find { |klass| klass.typed_stages.any? { |ts| ts.type_code.to_s == type_str } }
+    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
+
+Pubid::Registry.register(:nist, Pubid::Nist)

data/lib/pubid/oasis/builder.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oasis
+    # Turns the parse tree into an `Identifiers::Standard`: stores the slug
+    # verbatim in `original`, then performs a best-effort, ORDER-INDEPENDENT
+    # decomposition into number / version / stage / part / label.
+    #
+    # Decomposition splits `original` on "-" and classifies each *whole*
+    # fragment (so a stage-like substring inside a spec name — e.g. "CSDL" — is
+    # never mistaken for a stage). `number` is the specification name: the run
+    # of leading name fragments before the first recognized fragment, and the
+    # key relaton-index sorts and binary-searches on. `version`/`stage`/`part`
+    # are the first fragment of each recognized kind; `label` is any name
+    # fragment appearing after the first recognized one. Anything the
+    # classifier cannot place stays only in `original`, so the printed form
+    # always round-trips.
+    class Builder
+      # A fragment is a version when it is `v?N(.N)+` (e.g. "3.0", "v1.2.1",
+      # "V1.0"). Bare integers are deliberately NOT versions (too ambiguous
+      # with spec-name tokens).
+      VERSION_RE = /\Av?\d+(?:\.\d+)+\z/i
+      # OASIS approval-stage tokens (+ optional revision digits). Longest-first
+      # so shared prefixes classify correctly (CSPRD/CSD before CS, COS before
+      # CS/OS).
+      STAGE_RE = /\A(?:CSPRD|CSD|COS|CS|WD|OS|PS|PRD|CD|Errata)\d*\z/
+      # Part tokens across the three observed spellings, plus bare "Pt"/"P".
+      PART_RE = /\A(?:Part|Pt|part|P)\d*\z/
+
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        original = data[:original].to_s
+        Identifiers::Standard.new(original: original, **decompose(original))
+      end
+
+      private
+
+      # @return [Hash] best-effort { number:, version:, stage:, part:, label: }.
+      # Each fragment is classified once into a [fragment, kind] pair. `number`
+      # is the leading run of name fragments; `label` is any name fragment after
+      # the first recognized one; version/stage/part are the first of each kind.
+      def decompose(original)
+        pairs = original.split("-").map { |f| [f, classify(f)] }
+        lead = pairs.take_while { |_, kind| kind.nil? }
+        rest = pairs.drop(lead.length)
+        {
+          number: names(lead),
+          version: first_of(rest, :version),
+          stage: first_of(rest, :stage),
+          part: first_of(rest, :part),
+          label: names(rest),
+        }
+      end
+
+      # @return [Symbol, nil] :version / :stage / :part, or nil for a name token
+      def classify(fragment)
+        return :version if fragment.match?(VERSION_RE)
+        return :stage if fragment.match?(STAGE_RE)
+        return :part if fragment.match?(PART_RE)
+
+        nil
+      end
+
+      # First fragment of the given kind among [fragment, kind] pairs, or nil.
+      def first_of(pairs, kind)
+        pairs.find { |_, k| k == kind }&.first
+      end
+
+      # Name (unclassified) fragments among the pairs, re-joined, or nil.
+      def names(pairs)
+        fragments = pairs.select { |_, kind| kind.nil? }.map(&:first)
+        fragments.empty? ? nil : fragments.join("-")
+      end
+    end
+  end
+end

data/lib/pubid/oasis/identifier.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oasis
+    # Base class for every OASIS identifier AND the flavor's parse/create entry
+    # point. The single concrete type `Identifiers::Standard` descends from this
+    # class, so a parsed OASIS id is an instance of `Pubid::Oasis::Identifier`.
+    #
+    # OASIS identifiers are free-form slugs with an inconsistent internal
+    # structure (spec name + version + approval stage + part + label, in
+    # varying order). To guarantee a lossless round-trip we always keep the
+    # exact printed slug verbatim in `original` (which alone drives `to_s`); the
+    # remaining component fields are a best-effort decomposition for relaton
+    # querying and can be nil without ever affecting the rendered string.
+    class Identifier < ::Pubid::Identifier
+      # The exact slug printed after "OASIS " — always set. Drives `to_s`, so
+      # the printed form round-trips verbatim regardless of decomposition.
+      attribute :original, :string
+      # Best-effort decomposition (any may be nil). `number`/`label` are plain
+      # slug fragments; `version`/`stage`/`part` carry the recognized fragment
+      # verbatim (e.g. "3.0", "v1.2.1", "PS01", "Errata01", "Pt8", "Part1").
+      #
+      # `number` holds the specification name ("OSLC-CM", "STIX", "amqp-core").
+      # It is the key relaton-index sorts and binary-searches on
+      # (`id.root.number.to_s`), and it deliberately CLUSTERS: every version,
+      # stage and part of one specification shares it, the same shape as an
+      # IETF draft slug or an IANA registry slug.
+      #
+      # `number`/`stage`/`part` intentionally override the inherited
+      # Components::Code / Components::Stage attributes with plain strings (the
+      # mechanism JIS uses for `number` and W3C for `date`): OASIS names,
+      # stages and parts are opaque tokens that must round-trip exactly and are
+      # never re-parsed as structured parts. Redefining an inherited attribute
+      # is only deterministic under multi-flavor load because this class body
+      # lives in ONE file and is never reopened, so lutaml has finished
+      # building the table before `Identifiers::Standard` snapshots it — DO NOT
+      # split this class across two files.
+      attribute :number, :string
+      attribute :version, :string
+      attribute :stage, :string
+      attribute :part, :string
+      attribute :label, :string
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization: maps
+      # the subclass's polymorphic_name to its class name so a stored hash
+      # rebuilds the correct identifier type via from_hash.
+      OASIS_TYPE_MAP = {
+        "pubid:oasis:standard" => "Pubid::Oasis::Identifiers::Standard",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: OASIS_TYPE_MAP
+        map "original", to: :original
+        map "number", to: :number
+        map "version", to: :version
+        map "stage", to: :stage
+        map "part", to: :part
+        map "label", to: :label
+      end
+
+      # Publisher is always "OASIS". A plain constant (not a `publisher` method)
+      # so it doesn't shadow the inherited lutaml `publisher` attribute, which
+      # would otherwise fail serialization type validation.
+      PUBLISHER = "OASIS"
+
+      attr_reader :with_publisher
+
+      def to_s(with_publisher: true, **opts)
+        @with_publisher = with_publisher
+        render(format: :human, **opts)
+      end
+
+      # The decomposition fields. Excluding any of them must also clear
+      # `original`, which still spells the excluded value out verbatim.
+      DECOMPOSITION_KEYS = %i[number version stage part label].freeze
+
+      # Widen a partial reference. `#matches?` is
+      # `exclude(*ignore) == other.exclude(*ignore)`, and `original` carries
+      # every component verbatim, so without this a bare "OASIS WSDM" could
+      # never match "OASIS WSDM-v1.1" however much the caller ignored.
+      #
+      # `original` is cleared ONLY when the exclusion touches the
+      # decomposition — the "reset the whole cluster" rule CSA applies to its
+      # year-format siblings. A plain `==` still compares `original`, so two
+      # slugs that decompose alike but print differently stay distinct: the
+      # decomposition loses fragment order and drops repeated fragments, so it
+      # is not by itself an identity.
+      def exclude(*args)
+        result = super
+        result.original = nil if args.intersect?(DECOMPOSITION_KEYS)
+        result
+      end
+
+      # MR string hooks. `to_slug` delegates to `to_mr_string` and consumers
+      # use it as an output FILENAME, so the slug must be unique per document.
+      #
+      # The publisher lives in the PUBLISHER constant rather than the inherited
+      # lutaml attribute, so the base `mr_publisher` returns nil (the BIPM and
+      # IANA case) and is supplied here.
+      def mr_publisher
+        PUBLISHER.downcase
+      end
+
+      # The whole verbatim slug, not the decomposed fields: decomposition loses
+      # fragment order and drops repeated fragments, so "x-1.0-os-Pt1" and
+      # "x-1.0-Pt1-os" would assemble to one slug. `original` cannot collide.
+      def mr_number_with_part
+        mr_sanitize(original)
+      end
+
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier;
+      # OASIS_TYPE_MAP remains as the key_value polymorphic_map.
+
+      # Parse an OASIS identifier string into an identifier object
+      # @param identifier [String] The OASIS identifier string to parse
+      # @return [Identifier] The Standard identifier object
+      # @raise [Pubid::Errors::ParseError] If parsing fails
+      def self.parse(identifier)
+        # Reject pathological inputs before they reach the parser
+        # (CodeQL rb/polynomial-redos barrier — inline .length by design).
+        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
+
+      private
+
+      # Filter by CHARSET, not by an enumerated escape list, so a field added
+      # later cannot leak an unsafe character (the BIPM `mr_slug` precedent).
+      # Three characters need it today: the "." in every version —
+      # Renderers::MrString joins SEGMENTS with ".", so a dot inside one breaks
+      # the documented segment structure — plus the space and "]" of a few
+      # malformed records.
+      #
+      # A RUN of non-alphanumerics collapses to one "-", which is why "-" is
+      # outside the kept set (BIPM's form, not ETSI's): "v3.0]-PS01" would
+      # otherwise print a bare "--".
+      #
+      # Caveat, the same one BIPM records: "-" is both the intra-slug join and
+      # the substitute, so two slugs differing ONLY in which non-slug character
+      # they use collapse onto one MR string. The corpus has exactly one such
+      # pair, the malformed "OpenC2-MQTT-v1.0] -CS01" spelled once with a
+      # normal space and once with a non-breaking one — two spellings of one
+      # document. Every genuinely distinct identifier keeps its own slug.
+      def mr_sanitize(value)
+        slug = value.to_s.downcase.gsub(/[^a-z0-9]+/, "-")
+          .gsub(/\A-+|-+\z/, "")
+        slug.empty? ? nil : slug
+      end
+    end
+  end
+end

data/lib/pubid/oasis/identifiers/standard.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oasis
+    module Identifiers
+      # The sole OASIS identifier type. OASIS records carry no document-type
+      # distinction in the printed id (every record is `type: OASIS`); the
+      # approval stage lives in the `stage` component field, not in the class.
+      # Example: "OASIS OSLC-CoreShapes-3.0-PS01-Pt8".
+      class Standard < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :oasis,
+            stage_code: :published,
+            type_code: :oasis,
+            abbr: ["OASIS"],
+            name: "OASIS Standard",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :oasis, web: :standard, title: "OASIS Standard",
+            short: "OASIS" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oasis/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oasis
+    module Identifiers
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+    end
+  end
+end

data/lib/pubid/oasis/parser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Oasis
+    # Parslet grammar for printed OASIS identifiers, e.g.
+    #   "OASIS OSLC-CoreShapes-3.0-PS01-Pt8"
+    #   "OASIS amqp-core"
+    #
+    # OASIS slugs are free-form with a highly inconsistent internal structure
+    # (varying fragment order, three part spellings, mixed case, a few
+    # malformed records with spaces or stray characters). The grammar therefore
+    # only strips the "OASIS " publisher prefix and captures the remainder
+    # verbatim; the spec/version/stage/part/label decomposition is done in the
+    # Builder with order-independent fragment classification. Keeping
+    # decomposition out of the PEG avoids brittle backtracking and guarantees a
+    # lossless round-trip.
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:prefix) { str("OASIS") >> str(" ") }
+
+      # The whole slug, captured verbatim (any character, incl. spaces / "]").
+      rule(:slug) { any.repeat(1).as(:original) }
+
+      rule(:identifier) { prefix >> slug }
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/oasis/renderer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oasis
+    # Human-readable renderer for OASIS identifiers.
+    #
+    # Renders the verbatim slug (`original`), prefixed with the "OASIS "
+    # publisher token unless `id.with_publisher == false`. Because rendering is
+    # a pure echo of `original`, the printed form always round-trips exactly.
+    #
+    #   "OASIS OSLC-CoreShapes-3.0-PS01-Pt8"  (with publisher)
+    #   "OSLC-CoreShapes-3.0-PS01-Pt8"        (without)
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "OASIS"
+
+      def render(context: nil, **opts)
+        id = @id
+        body = id.original.to_s
+        with_publisher?(id) ? "#{PUBLISHER} #{body}" : body
+      end
+
+      private
+
+      def with_publisher?(id)
+        id.with_publisher != false
+      end
+    end
+  end
+end

data/lib/pubid/oasis/urn_generator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oasis
+    # Emits `urn:oasis:<slug>`, echoing the verbatim `original` as a single URN
+    # segment (OASIS slugs never contain ":"). The only characters that occur in
+    # real records outside the URN-safe set are the space and a stray "]" (both
+    # only in a handful of malformed records); these are percent-encoded so the
+    # URN stays well-formed, and UrnParser reverses them exactly.
+    #
+    #   "OASIS amqp-core"          -> "urn:oasis:amqp-core"
+    #   "OASIS OSLC-CM-v1.0-CS01"  -> "urn:oasis:OSLC-CM-v1.0-CS01"
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      # Character -> percent-encoding for the non-URN-safe characters that
+      # actually appear in OASIS slugs. Kept explicit (not a blanket URI escape)
+      # so clean slugs — dots, hyphens, mixed case — pass through unchanged.
+      ENCODE = { " " => "%20", "]" => "%5D" }.freeze
+
+      def generate
+        slug = identifier.original.to_s.gsub(/[ \]]/) { |c| ENCODE[c] }
+        "urn:oasis:#{slug}"
+      end
+    end
+  end
+end

data/lib/pubid/oasis/urn_parser.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oasis
+    # Parses OASIS URNs back into identifiers by reconstructing the printed form
+    # and delegating to the flavor's text parser.
+    #
+    # UrnGenerator emits `urn:oasis:<slug>` (single segment) with the space and
+    # "]" characters percent-encoded; reverse exactly those two here.
+    #
+    #   urn:oasis:OSLC-CM-v1.0-CS01 -> OASIS OSLC-CM-v1.0-CS01
+    #   urn:oasis:amqp-core         -> OASIS amqp-core
+    class UrnParser < Pubid::UrnParser::Base
+      DECODE = { "%20" => " ", "%5D" => "]" }.freeze
+
+      def parse_urn(urn)
+        slug = strip_namespace(urn).gsub(/%20|%5D/, DECODE)
+        flavor_parse("OASIS #{slug}")
+      end
+    end
+  end
+end

data/lib/pubid/oasis.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oasis
+    extend Pubid::PrefixesSupport
+
+    # Sole OASIS publisher token (see the parser's `prefix` rule). Everything
+    # after "OASIS " is a free-form slug, so there are no leading type tokens to
+    # exclude.
+    PREFIXES = ["OASIS"].freeze
+
+    autoload :Builder, "#{__dir__}/oasis/builder"
+    autoload :Identifier, "#{__dir__}/oasis/identifier"
+    autoload :Identifiers, "#{__dir__}/oasis/identifiers"
+    autoload :Parser, "#{__dir__}/oasis/parser"
+    autoload :Renderer, "#{__dir__}/oasis/renderer"
+    autoload :UrnGenerator, "#{__dir__}/oasis/urn_generator"
+    autoload :UrnParser, "#{__dir__}/oasis/urn_parser"
+
+    # Parse an OASIS identifier string
+    def self.parse(identifier)
+      # Reject pathological inputs before they reach the parser
+      # (CodeQL rb/polynomial-redos barrier — inline .length by design).
+      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: Oasis::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 OASIS flavor with the registry
+Pubid::Registry.register(:oasis, Pubid::Oasis)