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

data/lib/pubid/nist/supplement_identifier.rb

@@ -6,23 +6,23 @@ module Pubid
     # Supplements wrap a base identifier with additional edition information
     #
     # Architecture follows ISO pattern:
-    # - base_identifier: The base document being supplemented
+    # - base: The base document being supplemented
     # - edition: Edition information for the supplement
     #
     # Examples:
     # - "NBS CIRC 101e2supp" → CircularSupplement(base: "NBS CIRC 101", edition: e2)
     # - "NBS CIRC 25supp-1924" → CircularSupplement(base: "NBS CIRC 25", edition: 1924)
-    class SupplementIdentifier < Identifiers::Base
-      attribute :base_identifier, Identifiers::Base, polymorphic: true
+    class SupplementIdentifier < Identifier
+      attribute :base, Identifier, polymorphic: true
 
-      # Delegate publisher to base_identifier
+      # Delegate publisher to base
       def publisher
-        base_identifier&.publisher
+        base&.publisher
       end
 
-      # Delegate series to base_identifier
+      # Delegate series to base
       def series
-        base_identifier&.series
+        base&.series
       end
 
       def to_s(format = :short)
@@ -31,9 +31,9 @@ module Pubid
           return "NBS CIRC sup#{supplement_date_range_start}-#{supplement_date_range_end}"
         end
 
-        return super unless base_identifier
+        return super unless base
 
-        result = base_identifier.to_s(format)
+        result = base.to_s(format)
 
         # NEW: Handle update attribute (e.g., "Upd12-1926" for supplement patterns)
         if update

data/lib/pubid/nist.rb

@@ -13,6 +13,7 @@ module Pubid
       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"
@@ -20,7 +21,7 @@ module Pubid
     autoload :CircularSupplementBuilder, "#{__dir__}/nist/circular_supplement_builder"
     autoload :Components, "#{__dir__}/nist/components"
     autoload :Configuration, "#{__dir__}/nist/configuration"
-    autoload :Identifier, "#{__dir__}/nist/identifier"
+    autoload :Identifier, "#{__dir__}/nist/identifiers/base"
     autoload :Identifiers, "#{__dir__}/nist/identifiers"
     autoload :Parser, "#{__dir__}/nist/parser"
     autoload :ParserOutputNormalizer, "#{__dir__}/nist/parser_output_normalizer"
@@ -36,7 +37,7 @@ module Pubid
     #
     # NIST identifier classes use `typed_stages` (not the `self.type` Hash
     # pattern used by CEN/JCGM/ANSI), so they cannot be auto-discovered.
-    # Identifiers::Base is the fallback for unmapped series (e.g. AMS, VTS)
+    # Identifier is the fallback for unmapped series (e.g. AMS, VTS)
     # and must be excluded from typed-stage aggregation.
     IDENTIFIER_TYPES = [
       Identifiers::SpecialPublication,
@@ -59,12 +60,12 @@ module Pubid
       Identifiers::CommercialStandardEmergency,
       Identifiers::CommercialStandardsMonthly,
       Identifiers::DatedDocument,
-      Identifiers::Base, # Fallback for unmapped series
+      Identifier, # Fallback for unmapped series
     ].freeze
 
     # Parse a NIST identifier string
     # @param identifier [String] the identifier string to parse
-    # @return [Identifiers::Base] the parsed identifier
+    # @return [Identifier] the parsed identifier
     def self.parse(identifier)
       if identifier.length > Pubid::MAX_INPUT_LENGTH
         raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
@@ -86,36 +87,36 @@ module Pubid
     end
 
     # Per-flavor format registry: inherits global formats, overrides :human
-    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifiers::Base.format_registry.register(:human, renderer: Nist::Renderer)
+    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).
-    # Identifiers::Base is the fallback for unmapped series and is excluded
+    # 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 == Identifiers::Base }
+      IDENTIFIER_TYPES.reject { |klass| klass == Identifier }
     end
 
     # Aggregate TYPED_STAGES from all identifier classes.
-    # Identifiers::Base is excluded because it has no typed stages and acts
+    # 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 == Identifiers::Base }
+        .reject { |klass| klass == Identifier }
         .flat_map(&:typed_stages)
         .freeze
     end
 
     # Lookup: type code -> identifier class.
-    # Identifiers::Base is excluded so it never gets selected by type code.
+    # 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 == Identifiers::Base }
+        .reject { |klass| klass == Identifier }
         .find { |klass| klass.typed_stages.any? { |ts| ts.type_code.to_s == type_str } }
     end
 

data/lib/pubid/oasis/builder.rb

@@ -0,0 +1,77 @@
+# 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 spec / 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). `spec` is the run of leading name fragments
+    # before the first recognized fragment; `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 { spec:, version:, stage:, part:, label: }.
+      # Each fragment is classified once into a [fragment, kind] pair. `spec` 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)
+        {
+          spec: 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,82 @@
+# 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). `spec`/`label` are plain
+      # slug fragments; `version`/`stage`/`part` carry the recognized fragment
+      # verbatim (e.g. "3.0", "v1.2.1", "PS01", "Errata01", "Pt8", "Part1").
+      attribute :spec, :string
+      attribute :version, :string
+      # `stage`/`part` intentionally override the inherited Components::Stage /
+      # Components::Code attributes with plain strings (same mechanism JIS uses
+      # for `number`, W3C for `date`): OASIS stages/parts are opaque tokens that
+      # must round-trip exactly and are never re-parsed as structured parts.
+      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 "spec", to: :spec
+        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
+
+      # 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 [RuntimeError] If parsing fails
+      def self.parse(identifier)
+        # Reject pathological inputs before they reach the parser
+        # (CodeQL rb/polynomial-redos barrier — inline .length by design).
+        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 OASIS identifier '#{identifier}': #{e.message}"
+      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 < Parslet::Parser
+      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,74 @@
+# 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).
+      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: 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)

data/lib/pubid/ogc/builder.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ogc
+    # Turns the parse tree into an Ogc::Identifiers::Document. OGC has a single
+    # document type, so there is no type dispatch.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        Identifiers::Document.new(
+          year: data[:year].to_s,
+          number: data[:number].to_s,
+          revision: normalize_revision(data[:revision]),
+        )
+      end
+
+      private
+
+      # Normalize the revision suffix to its canonical lowercased form (the
+      # shape the relaton index stores, e.g. "R1" -> "r1"). nil when there is
+      # no revision.
+      def normalize_revision(revision)
+        return nil if revision.nil?
+
+        normalized = revision.to_s.strip.downcase
+        normalized.empty? ? nil : normalized
+      end
+    end
+  end
+end

data/lib/pubid/ogc/identifier.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ogc
+    # Base class for every OGC identifier AND the flavor's parse/create entry
+    # point. There is a single concrete type (Identifiers::Document), so this
+    # base mostly exists to hold the shared attributes and the polymorphic
+    # serialization mapping.
+    class Identifier < ::Pubid::Identifier
+      # OGC ids are digit-leading (`<yy>-<nnn>`) with no publisher token in the
+      # printed form. Everything is kept as a string to preserve zero-padding
+      # ("032", not 32) and the exact revision suffix.
+      attribute :year, :string   # the "<yy>" field, e.g. "24"
+      attribute :number, :string # the "<nnn>" field, e.g. "032"
+      # Optional revision suffix, stored as the full lowercased token including
+      # its separator letter: "r1", "c1", "a", "r3a", "r12a". nil when absent.
+      attribute :revision, :string
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization: maps
+      # the concrete class's polymorphic_name to its class name so a stored hash
+      # rebuilds the correct identifier type via from_hash.
+      OGC_TYPE_MAP = {
+        "pubid:ogc:document" => "Pubid::Ogc::Identifiers::Document",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: OGC_TYPE_MAP
+        map "year", to: :year
+        map "number", to: :number
+        map "revision", to: :revision
+      end
+
+      # Publisher is always "OGC". 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 = "OGC"
+
+      attr_reader :with_publisher
+
+      # Basic string representation. Delegates to the human renderer. The
+      # printed OGC id carries no publisher token, so with_publisher defaults to
+      # false; pass with_publisher: true to prepend "OGC ".
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      # Capture the with_publisher flag on EVERY render call (default false), so
+      # it can never leak across calls: a bare render/to_s always renders
+      # without the publisher token regardless of a prior with_publisher: true.
+      # The base `render` only forwards `:with_edition` to the renderer, so the
+      # flag is threaded via this per-call instance write (the renderer reads
+      # `id.with_publisher`).
+      def render(format: :human, with_publisher: false, **opts)
+        @with_publisher = with_publisher
+        super(format: format, **opts)
+      end
+
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
+      # OGC_TYPE_MAP remains as the key_value polymorphic_map.
+
+      # Parse an OGC identifier string into an identifier object.
+      # @param identifier [String] The OGC identifier string to parse
+      # @return [Identifier] The document identifier object
+      # @raise [ArgumentError] If the input exceeds the maximum length
+      # @raise [RuntimeError] If parsing fails
+      def self.parse(identifier)
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        Builder.build(Parser.parse(identifier))
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse OGC identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ogc
+    module Identifiers
+      # The sole OGC identifier type. An OGC document is numbered
+      # `<yy>-<nnn>[<revision>]` with no publisher token in the printed form.
+      class Document < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :ogc,
+            stage_code: :published,
+            type_code: :ogc,
+            abbr: ["OGC"],
+            name: "OGC Document",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :ogc, web: :document, title: "OGC Document", short: "OGC" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ogc/identifiers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ogc
+    # Namespace for concrete OGC identifier types.
+    module Identifiers
+      autoload :Document, "#{__dir__}/identifiers/document"
+    end
+  end
+end