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

data/lib/pubid/ogc/parser.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Ogc
+    # Parslet grammar for OGC identifiers.
+    #
+    # Recognizes `<yy>-<nnn>` optionally followed by a revision suffix that
+    # begins with a letter (r/c/a/R…) and may carry a trailing letter
+    # (e.g. "r3a"). An optional leading "OGC" publisher token is accepted for
+    # leniency, though the canonical printed form omits it.
+    #
+    # Examples: "25-023", "24-032r1", "01-009a", "04-095c1", "OGC 24-032r1".
+    class Parser < Parslet::Parser
+      rule(:space) { match["\\s"].repeat(1) }
+      rule(:digits) { match["0-9"].repeat(1) }
+
+      # Optional leading publisher token, e.g. "OGC " — consumed, not captured.
+      rule(:publisher) { (str("OGC") >> space).maybe }
+
+      # Revision suffix: a run of letters/digits that starts after the numeric
+      # part (which greedily consumes all digits, so the suffix begins with a
+      # separator letter). Kept as a single token for the builder to normalize.
+      rule(:revision) { match["A-Za-z0-9"].repeat(1).as(:revision) }
+
+      rule(:identifier) do
+        publisher >>
+          digits.as(:year) >> str("-") >> digits.as(:number) >>
+          revision.maybe >> space.maybe
+      end
+
+      root(:identifier)
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/ogc/renderer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ogc
+    # Human-readable renderer for OGC identifiers.
+    #
+    # Produces the canonical printed form, e.g.:
+    #   "24-032r1"
+    #   "01-009a"
+    #   "OGC 24-032r1"   (only when with_publisher: true)
+    #
+    # Registered as the `:human` format in the OGC format registry and invoked
+    # via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "OGC"
+
+      def render(**_opts)
+        id = @id
+        result = +""
+        result << "#{PUBLISHER} " if with_publisher?(id)
+        result << "#{id.year}-#{id.number}"
+        result << id.revision.to_s if id.revision
+        result
+      end
+
+      private
+
+      def with_publisher?(id)
+        id.respond_to?(:with_publisher) && id.with_publisher == true
+      end
+    end
+  end
+end

data/lib/pubid/ogc/urn_generator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ogc
+    # Emits `urn:ogc:<year>:<number>[:<revision>]`, e.g. `urn:ogc:24:032:r1`.
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "ogc", identifier.year.to_s, identifier.number.to_s]
+        parts << identifier.revision.to_s if identifier.revision
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/ogc/urn_parser.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ogc
+    # Parses OGC URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:ogc:<year>:<number>[:<revision>]`.
+    #
+    # Examples:
+    # - urn:ogc:25:023    → 25-023
+    # - urn:ogc:24:032:r1 → 24-032r1
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        year, number, revision = split_parts(body)
+        text = "#{year}-#{number}"
+        text += revision.to_s if revision
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/ogc.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ogc
+    extend Pubid::PrefixesSupport
+
+    # OGC identifiers are digit-leading (`25-023`) and carry no publisher token
+    # in the printed form. Per the PREFIXES inclusion policy, bare numeric
+    # patterns are NOT listed (they would make cross-flavor routing ambiguous).
+    # Instead the sole entry is the publisher token "OGC", which relaton uses to
+    # route a reference to this flavor even though it is not literally present
+    # in the id string.
+    PREFIXES = ["OGC"].freeze
+
+    autoload :Builder, "#{__dir__}/ogc/builder"
+    autoload :Identifier, "#{__dir__}/ogc/identifier"
+    autoload :Identifiers, "#{__dir__}/ogc/identifiers"
+    autoload :Parser, "#{__dir__}/ogc/parser"
+    autoload :Renderer, "#{__dir__}/ogc/renderer"
+    autoload :UrnGenerator, "#{__dir__}/ogc/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ogc/urn_parser"
+
+    # Parse an OGC identifier string
+    def self.parse(identifier)
+      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: Ogc::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 OGC flavor with the registry
+Pubid::Registry.register(:ogc, Pubid::Ogc)

data/lib/pubid/oiml/builder.rb

@@ -21,8 +21,8 @@ module Pubid
           return build_short_amendment(parsed_hash)
         end
 
-        # Check for supplements first (have base_identifier)
-        if parsed_hash[:base_identifier]
+        # Check for supplements first (have base)
+        if parsed_hash[:base]
           return build_supplement(parsed_hash)
         end
 
@@ -53,11 +53,11 @@ module Pubid
         end
 
         # Build the base document
-        base_identifier = build_base_document(base_hash)
+        base = build_base_document(base_hash)
 
         # Create amendment
         amendment = Identifiers::Amendment.new
-        amendment.base_identifier = base_identifier
+        amendment.base = base
 
         # Extract year from edition_format if present, otherwise from year directly
         year_value = if parsed_hash[:edition_format].is_a?(Hash)
@@ -97,8 +97,8 @@ module Pubid
         supplement.joined = true if plus_marker
 
         # Recursively parse base identifier
-        if parsed_hash[:base_identifier]
-          supplement.base_identifier = build(parsed_hash[:base_identifier])
+        if parsed_hash[:base]
+          supplement.base = build(parsed_hash[:base])
         end
 
         # Extract year from edition_format if present, otherwise from year directly
@@ -116,7 +116,7 @@ module Pubid
         # Annex with no year of its own but a dated base ("R 60:2017 Annexes"):
         # the year belongs to the base and must render glued to it.
         if supplement.is_a?(Identifiers::Annex) && !year_value &&
-            supplement.base_identifier&.date
+            supplement.base&.date
           supplement.year_on_base = true
         end
 
@@ -214,6 +214,11 @@ module Pubid
       # Structured: :issue and :sequence captured directly as zero-padded
       # strings. Citation: :volume_roman, :issue_arabic, :article_id —
       # decode the 8-digit article_id to recover year+issue+sequence.
+      #
+      # For the citation form, the parsed roman volume is cross-checked
+      # against the year decoded from the article_id; a mismatch warns but
+      # does not raise (the article_id is the source of truth — the roman
+      # volume is redundant display).
       def apply_bulletin_locator(identifier, parsed_hash)
         if parsed_hash[:article_id]
           article_id = parsed_hash[:article_id].to_s
@@ -221,6 +226,7 @@ module Pubid
           identifier.date.year = article_id[0, 4]
           identifier.issue = article_id[4, 2]
           identifier.sequence = article_id[6, 2]
+          warn_on_volume_mismatch(identifier, parsed_hash[:volume_roman])
           return
         end
 
@@ -228,6 +234,24 @@ module Pubid
         identifier.sequence = parsed_hash[:sequence].to_s if parsed_hash[:sequence]
       end
 
+      # Citation form carries the volume in two places: spelled out as a
+      # roman numeral ("LXVII") and encoded in the 8-digit article_id
+      # (year+issue+sequence, where year - 1959 = volume). They should
+      # agree; if they don't, the input was malformed. Warn loudly so the
+      # user sees the discrepancy, but continue using the article_id
+      # (deterministic) rather than the roman (possibly mistyped).
+      def warn_on_volume_mismatch(identifier, parsed_volume_roman)
+        return unless parsed_volume_roman && identifier.date&.year
+
+        declared = parsed_volume_roman.to_s
+        computed = Identifiers::Bulletin.to_roman(identifier.date.year.to_i -
+                                                  Identifiers::Bulletin::BASE_YEAR_OFFSET)
+        return if declared == computed
+
+        warn "OIML Bulletin citation volume mismatch: parsed '#{declared}' " \
+             "but article_id year #{identifier.date.year} implies '#{computed}'"
+      end
+
       def extract_language(lang_data)
         # Handle both direct string and nested hash from parser
         case lang_data

data/lib/pubid/oiml/identifier.rb

@@ -37,7 +37,7 @@ module Pubid
       # lutaml's polymorphic_map only validates `_type` on deserialization; it
       # does not re-instantiate the concrete subclass. Route by `_type` so
       # `Pubid::Oiml::Identifier.from_hash(h)` returns the right class (and its
-      # nested base_identifier), mirroring Pubid::Iso::Identifier.from_hash.
+      # nested base), mirroring Pubid::Iso::Identifier.from_hash.
       def self.from_hash(data, options = {})
         type = data["_type"] || data[:_type]
         klass_name = OIML_TYPE_MAP[type]
@@ -48,6 +48,14 @@ module Pubid
         super
       end
 
+      # Uniform class-level parse entry, mirroring every other flavor's
+      # `Pubid::<Flavor>::Identifier.parse`. OIML's real logic lives in the
+      # module method, so delegate to it (same pattern as jcgm/nist/plateau).
+      # The `Pubid::MAX_INPUT_LENGTH` ReDoS guard lives in `Pubid::Oiml.parse`.
+      def self.parse(identifier)
+        Pubid::Oiml.parse(identifier)
+      end
+
       def to_urn
         UrnGenerator.new(self).generate
       end

data/lib/pubid/oiml/parser.rb

@@ -20,7 +20,7 @@ module Pubid
       rule(:identifier) do
         amendment_identifier | amendment_short | annex_letter_identifier |
           annex_identifier | plus_supplement_identifier |
-          trailing_supplement_identifier | bulletin_identifier | base_identifier
+          trailing_supplement_identifier | bulletin_identifier | base
       end
 
       # Publisher - always "OIML"
@@ -44,10 +44,9 @@ module Pubid
       rule(:two_digits) { match('\d').repeat(2, 2) }
 
       # Roman numeral token composed of I,V,X,L,C,D,M (uppercase, matching
-      # OIML's print convention). Consumed but not captured — the 8-digit
-      # article id in the same citation carries year/issue/sequence
-      # deterministically, so the roman volume is redundant for parsing.
-      rule(:roman_numeral) { match("[IVXLCDM]").repeat(1) }
+      # OIML's print convention). Captured so the builder can cross-check
+      # the declared volume against the year implied by the article_id.
+      rule(:roman_numeral) { match("[IVXLCDM]").repeat(1).as(:volume_roman) }
 
       # Bulletin locator — citation form. The format OIML prints on the
       # article page is: "LXVII(2) 20260211" where LXVII is the volume in
@@ -62,7 +61,7 @@ module Pubid
       # Bulletin identifier — no code; the locator (when present) is the
       # (year, issue, sequence) tuple drawn from either the structured
       # YYYY-II-SS form or the citation VOLUME(ISSUE) ARTID form. Both
-      # decode to the same record. Tried before base_identifier because
+      # decode to the same record. Tried before base because
       # "Bulletin" is a word that the single-letter doc_type rule cannot
       # match.
       rule(:bulletin_identifier) do
@@ -188,7 +187,7 @@ module Pubid
       rule(:amendment_identifier) do
         str("Amendment") >> space >> lparen >> year_digits.as(:year) >> rparen >>
           space >> str("to") >> space >>
-          base_without_language.as(:base_identifier) >>
+          base_without_language.as(:base) >>
           language_portion.maybe.as(:language)
       end
 
@@ -210,7 +209,7 @@ module Pubid
       # amendment_short is tried first; it only matches when a year follows the
       # word, so the no-year trailing form falls through to here.
       rule(:trailing_supplement_identifier) do
-        base_without_language.as(:base_identifier) >>
+        base_without_language.as(:base) >>
           space >> (str("Amendment") | str("Errata")).as(:trailing_marker) >>
           language_portion.maybe.as(:language)
       end
@@ -220,7 +219,7 @@ module Pubid
       # and errata to dated bases (e.g. "OIML B 10:2011+Amendment:2012").
       # Annexes already encode the year-on-base intent via their own model.
       rule(:plus_supplement_identifier) do
-        base_without_language.as(:base_identifier) >>
+        base_without_language.as(:base) >>
           str("+") >>
           (str("Amendment") | str("Errata")).as(:plus_marker) >>
           (colon >> year_digits.as(:year)).maybe >>
@@ -230,7 +229,7 @@ module Pubid
       # Annex identifier - "BASE Annexes Edition YYYY" / "BASE Annexes:YYYY" /
       # "BASE:YYYY Annexes" (year on the base, no annex year).
       rule(:annex_identifier) do
-        base_without_language.as(:base_identifier) >>
+        base_without_language.as(:base) >>
           space >> str("Annexes").as(:annex_marker) >>
           (
             (space >> edition_text >> space >> year_digits.as(:year)).as(:edition_format) |
@@ -246,7 +245,7 @@ module Pubid
 
       # Annex with letter - "BASE Annex A Edition YYYY" / "BASE:YYYY Annex B-C"
       rule(:annex_letter_identifier) do
-        base_without_language.as(:base_identifier) >>
+        base_without_language.as(:base) >>
           space >> str("Annex") >> space >> annex_letter_value >>
           ((space >> edition_text >> space >> year_digits.as(:year)) | (colon >> year_digits.as(:year))).maybe >>
           language_portion.maybe.as(:language)
@@ -262,7 +261,7 @@ module Pubid
       end
 
       # Base identifier for recursion and standalone parsing
-      rule(:base_identifier) do
+      rule(:base) do
         publisher >>
           doc_type >>
           full_number >>

data/lib/pubid/oiml/renderer.rb

@@ -138,7 +138,7 @@ module Pubid
         # Plus-joined: "BASE+Amendment:YEAR" / "BASE+Errata:YEAR" with both
         # the base and the supplement carrying their own year.
         if id.joined
-          base_str = strip_language(id.base_identifier.to_s)
+          base_str = strip_language(id.base.to_s)
           result = "#{base_str}+#{id.supplement_type}"
           result += ":#{id.year}" if id.year
           result += " (#{id.language})" if id.language
@@ -149,7 +149,7 @@ module Pubid
         # publication year kept on the base identifier. The word comes from the
         # concrete supplement class.
         if id.trailing
-          base_str = strip_language(id.base_identifier.to_s)
+          base_str = strip_language(id.base.to_s)
           result = "#{base_str} #{id.supplement_type}"
           result += " (#{id.language})" if id.language
           return result
@@ -157,16 +157,16 @@ module Pubid
 
         base_format = if format && format != :short
                         format
-                      elsif id.base_identifier.class.attributes.key?(:parsed_format) && id.base_identifier.parsed_format == "long"
+                      elsif id.base.class.attributes.key?(:parsed_format) && id.base.parsed_format == "long"
                         :long
                       else
                         :short
                       end
 
-        base_str = if id.base_identifier.is_a?(SingleIdentifier)
-                     id.base_identifier.to_s(format: base_format)
+        base_str = if id.base.is_a?(SingleIdentifier)
+                     id.base.to_s(format: base_format)
                    else
-                     id.base_identifier.to_s
+                     id.base.to_s
                    end
         base_str = strip_language(base_str)
 
@@ -182,14 +182,14 @@ module Pubid
         # "BASE:YYYY Annex(es)" — the year is glued to the base, the marker
         # carries none. Keep the base date instead of stripping it.
         if id.year_on_base
-          base_str = strip_language(id.base_identifier.to_s)
+          base_str = strip_language(id.base.to_s)
           marker = id.letter ? "Annex #{id.letter}" : "Annexes"
           result = "#{base_str} #{marker}"
           result += " (#{id.language})" if id.language
           return result
         end
 
-        base_format = if id.base_identifier.class.attributes.key?(:parsed_format) && id.base_identifier.parsed_format == "long"
+        base_format = if id.base.class.attributes.key?(:parsed_format) && id.base.parsed_format == "long"
                         :long
                       else
                         :short
@@ -203,10 +203,10 @@ module Pubid
                          :short
                        end
 
-        base_str = if id.base_identifier.is_a?(SingleIdentifier)
-                     id.base_identifier.to_s(format: base_format)
+        base_str = if id.base.is_a?(SingleIdentifier)
+                     id.base.to_s(format: base_format)
                    else
-                     id.base_identifier.to_s
+                     id.base.to_s
                    end
         result = base_str.sub(/:.*/, "").sub(/\s+Edition\s+\d{4}/, "").sub(
           /\(.*\)/, ""
@@ -219,8 +219,8 @@ module Pubid
           result += " Annexes"
           if id.year
             result += annex_format == :long ? " Edition #{id.year}" : ":#{id.year}"
-          elsif id.base_identifier.date
-            result += annex_format == :long ? " Edition #{id.base_identifier.date.render(context: @context)}" : ":#{id.base_identifier.date.render(context: @context)}"
+          elsif id.base.date
+            result += annex_format == :long ? " Edition #{id.base.date.render(context: @context)}" : ":#{id.base.date.render(context: @context)}"
           end
         end
 

data/lib/pubid/oiml/single_identifier.rb

@@ -103,6 +103,26 @@ module Pubid
         raise NotImplementedError, "Subclasses must implement type_string"
       end
 
+      # OIML keeps identity in `code` (Components::Code) and `type_string`
+      # (e.g. "R", "V", "D"), not in the inherited `number`/`typed_stage` —
+      # the generic MrString renderer would otherwise drop both and produce
+      # `OIML.<year>`. Losslessness for issue #142 requires the type letter
+      # and document number to appear in MR.
+      def mr_number_with_part
+        segments = []
+        segments << code&.number&.to_s if code&.number
+        segments << code&.part&.to_s if code&.part
+        segments << code&.subpart&.to_s if code&.subpart
+        segments << code&.suffix&.to_s if code&.suffix
+        return nil if segments.empty?
+
+        segments.join("-")
+      end
+
+      def mr_type
+        type_string&.downcase
+      end
+
       # Subclasses override this
     end
   end

data/lib/pubid/oiml/supplement_identifier.rb

@@ -5,7 +5,7 @@ module Pubid
     class SupplementIdentifier < Identifier
       # Base class for OIML supplements (amendments, annexes)
       # These wrap a base identifier like ISO amendments
-      attribute :base_identifier, Oiml::Identifier, polymorphic: true
+      attribute :base, Oiml::Identifier, polymorphic: true
       attribute :year, :string
       attribute :language, :string
       # True for the trailing-word shorthand ("OIML R 138:2009 Amendment"),
@@ -21,28 +21,28 @@ module Pubid
       } # Track supplement's parsed format
 
       # Serialization delta on top of Oiml::Identifier's shared block. The
-      # nested base_identifier is (de)serialized recursively through the
+      # nested base is (de)serialized recursively through the
       # polymorphic router so its own `_type` selects the right subclass.
       key_value do
-        map "base_identifier",
-            with: { to: :base_identifier_to_kv, from: :base_identifier_from_kv }
+        map "base",
+            with: { to: :base_to_kv, from: :base_from_kv }
         map "year", to: :year
         map "trailing", to: :trailing
         map "joined", to: :joined
       end
 
-      def base_identifier_to_kv(model, doc)
-        base = model.base_identifier
+      def base_to_kv(model, doc)
+        base = model.base
         return unless base
 
         doc.add_child(
-          Lutaml::KeyValue::DataModel::Element.new("base_identifier",
+          Lutaml::KeyValue::DataModel::Element.new("base",
                                                    base.to_hash),
         )
       end
 
-      def base_identifier_from_kv(model, value)
-        model.base_identifier = ::Pubid::Oiml::Identifier.from_hash(value) if value
+      def base_from_kv(model, value)
+        model.base = ::Pubid::Oiml::Identifier.from_hash(value) if value
       end
 
       attr_reader :requested_format

data/lib/pubid/oiml/urn_parser.rb

@@ -4,18 +4,35 @@ module Pubid
   module Oiml
     # Parses OIML URNs back into identifiers.
     #
-    # UrnGenerator emits: `urn:oiml:{type}:{number}[-{part}]` where type
-    # is the lowercase document class (r for Recommendation, d for Document).
+    # UrnGenerator emits: `urn:oiml:{type}:{locator}` where type is the
+    # lowercase document class — single letter for typed documents
+    # (r, d, b, g, …) or the word "bulletin" for Bulletin issues. The
+    # locator is the number-part-subpart for typed documents and the
+    # YYYY-II-SS tuple for Bulletins.
     #
     # Examples:
-    # - urn:oiml:r:111-1 → OIML R 111-1
-    # - urn:oiml:d:1     → OIML D 1
+    # - urn:oiml:r:111-1           → OIML R 111-1
+    # - urn:oiml:d:1               → OIML D 1
+    # - urn:oiml:bulletin:2026-02-11 → OIML Bulletin 2026-02-11
     class UrnParser < Pubid::UrnParser::Base
       def parse_urn(urn)
         body = strip_namespace(urn)
         parts = split_parts(body)
-        type_token, number = parts
-        flavor_parse("OIML #{type_token.upcase} #{number}")
+        type_token = parts.fetch(0)
+        number = parts[1]
+
+        text = "OIML #{display_type(type_token)}"
+        text += " #{number}" if number
+        flavor_parse(text)
+      end
+
+      private
+
+      # URN type tokens are lowercase. Typed documents use a single letter
+      # that maps cleanly via upcase; Bulletin is the multi-letter word
+      # that the human parser expects capitalized.
+      def display_type(token)
+        token.downcase == "bulletin" ? "Bulletin" : token.upcase
       end
     end
   end

data/lib/pubid/oiml.rb

@@ -19,6 +19,10 @@ module Pubid
     autoload :UrnParser, "#{__dir__}/oiml/urn_parser"
 
     def self.parse(identifier)
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       parser = Parser.new
       builder = Builder.new
 

data/lib/pubid/omg/builder.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Omg
+    # Builds a Pubid::Omg::Identifier from a parse tree.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        Identifiers::Specification.new(
+          acronym: data[:acronym].to_s,
+          version: data[:version]&.to_s,
+        )
+      end
+    end
+  end
+end

data/lib/pubid/omg/identifier.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Omg
+    # Base class for every OMG identifier AND the flavor's parse/create
+    # entry point.
+    class Identifier < ::Pubid::Identifier
+      # The spec family acronym, e.g. "AMI4CCM", "UML", "CORBA".
+      attribute :acronym, :string
+
+      # Free-form version string. Stored verbatim because OMG versioning is
+      # loose ("1.0", "2.5.1", "5 beta 3", "1.1"). Use Version#to_s for
+      # rendering.
+      attribute :version, :string
+
+      OMG_TYPE_MAP = {
+        "pubid:omg:specification" => "Pubid::Omg::Identifiers::Specification",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: OMG_TYPE_MAP
+        map "acronym", to: :acronym
+        map "version", to: :version
+      end
+
+      PUBLISHER = "OMG"
+
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      def self.parse(identifier)
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse OMG identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end