pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/oiml/single_identifier.rb

@@ -5,7 +5,6 @@ module Pubid
     class SingleIdentifier < Identifier
       # Base class for OIML single identifiers (non-supplements)
       attribute :publisher, :string
-      attribute :code, Oiml::Components::Code
       attribute :date, Pubid::Components::Date
       attribute :edition, :string
       attribute :stage, :string
@@ -16,46 +15,24 @@ module Pubid
       } # Track parsed format
 
       # Serialization delta on top of Oiml::Identifier's shared block. The
-      # `code` (number/part/subpart/suffix) and `date` (year) components are
-      # flattened to top-level keys rather than nested hashes, mirroring ISO
-      # (lib/pubid/iso/identifier.rb). `type` is intentionally omitted
-      # (recomputed from the class on load).
+      # `date` (year) component is flattened to a top-level key rather than a
+      # nested hash, mirroring ISO (lib/pubid/iso/identifier.rb). `type` is
+      # intentionally omitted (recomputed from the class on load).
+      #
+      # The code columns (number/part/subpart/suffix/space_suffix) are NOT
+      # here: they are declared, and mapped, by Identifiers::CodeNumber on each
+      # concrete leaf, because redefining the inherited `number` on this class
+      # — which every leaf inherits — is the multi-flavor determinism landmine.
+      # Keeping the mapping with the attribute is also what lets Bulletin, the
+      # one leaf with no code, omit both.
       key_value do
         map "publisher", to: :publisher
-        map "number", with: { to: :number_to_kv, from: :number_from_kv }
-        map "part", with: { to: :part_to_kv, from: :part_from_kv }
-        map "subpart", with: { to: :subpart_to_kv, from: :subpart_from_kv }
-        map "suffix", with: { to: :suffix_to_kv, from: :suffix_from_kv }
-        map "space_suffix",
-            with: { to: :space_suffix_to_kv, from: :space_suffix_from_kv }
         map "year", with: { to: :year_to_kv, from: :year_from_kv }
         map "edition", to: :edition
         map "stage", to: :stage
         map "iteration", to: :iteration
       end
 
-      # --- code components flattened to top-level keys ---
-      def number_to_kv(model, doc) = emit_kv(doc, "number", model.code&.number)
-      def number_from_kv(model, value) = code_for(model).number = value.to_s
-      def part_to_kv(model, doc) = emit_kv(doc, "part", model.code&.part)
-      def part_from_kv(model, value) = code_for(model).part = value.to_s
-      def subpart_to_kv(model, doc) = emit_kv(doc, "subpart", model.code&.subpart)
-      def subpart_from_kv(model, value) = code_for(model).subpart = value.to_s
-      def suffix_to_kv(model, doc) = emit_kv(doc, "suffix", model.code&.suffix)
-      def suffix_from_kv(model, value) = code_for(model).suffix = value.to_s
-
-      def space_suffix_to_kv(model, doc)
-        return unless model.code&.space_suffix
-
-        doc.add_child(
-          Lutaml::KeyValue::DataModel::Element.new("space_suffix", true),
-        )
-      end
-
-      def space_suffix_from_kv(model, value)
-        code_for(model).space_suffix = value
-      end
-
       # --- date flattened to a top-level year ---
       def year_to_kv(model, doc) = emit_kv(doc, "year", model.date&.year)
 
@@ -69,10 +46,6 @@ module Pubid
         doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, value.to_s))
       end
 
-      def code_for(model)
-        model.code ||= Components::Code.new
-      end
-
       attr_reader :requested_format
 
       # Type is determined by the subclass
@@ -103,6 +76,37 @@ module Pubid
         raise NotImplementedError, "Subclasses must implement type_string"
       end
 
+      # OIML keeps identity in the code columns and `type_string` (e.g. "R",
+      # "V", "D"), not in the inherited `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.
+      #
+      # Reads through `code`, which every code-bearing leaf composes from its
+      # split columns (Identifiers::CodeNumber); Bulletin has no code and
+      # returns nil here, keeping its (year, issue, sequence) slug.
+      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
+
+      # Bulletin overrides `code`; every other leaf gets it from
+      # Identifiers::CodeNumber. Returning nil here keeps #== , the renderer
+      # and the URN generator total for the abstract class itself.
+      def code
+        nil
+      end
+
+      def mr_type
+        type_string&.downcase
+      end
+
       # Subclasses override this
     end
   end

data/lib/pubid/oiml/supplement_identifier.rb

@@ -5,9 +5,36 @@ 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
+
+      # Delegate the document code to the wrapped standard, mirroring
+      # Pubid::Etsi::Identifiers::SupplementIdentifier#code.
+      #
+      # PRE-EXISTING BUG this closes: `UrnGenerator#urn_number` calls
+      # `identifier.code` for every non-Bulletin type, but a supplement
+      # descends from Oiml::Identifier directly — it is a SIBLING of
+      # SingleIdentifier, which is where `code` used to live — so it inherited
+      # no `code` at all and `to_urn` raised NoMethodError for every Amendment,
+      # Errata and Annex. Verified against a baseline captured on main: all
+      # five supplement fixtures already raised there, so this is a fix, not a
+      # regression introduced by the move to split index columns.
+      #
+      # It stayed hidden because spec/pubid/oiml/urn_spec.rb only exercises a
+      # bare Recommendation and spec/pubid/oiml/fixtures_spec.rb globs a bad
+      # path and runs 0 examples (hand-off: ten-dead-fixture-specs).
+      # `iteration` is the same story: declared on SingleIdentifier, read
+      # unconditionally by UrnGenerator#urn_iteration, absent from the
+      # supplement branch of the hierarchy. (`stage` escapes because
+      # ::Pubid::Identifier declares one, so it merely returns nil.)
+      def code
+        base&.code
+      end
+
+      def iteration
+        base&.iteration
+      end
       # True for the trailing-word shorthand ("OIML R 138:2009 Amendment"),
       # where the supplement word is appended after a dated base instead of the
       # "Amendment (YYYY) to BASE" prose form. The word itself comes from the
@@ -21,28 +48,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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Oiml
     extend Pubid::PrefixesSupport
@@ -19,6 +20,15 @@ module Pubid
     autoload :UrnParser, "#{__dir__}/oiml/urn_parser"
 
     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
+
       parser = Parser.new
       builder = Builder.new
 

data/lib/pubid/omg/builder.rb

@@ -0,0 +1,20 @@
+# 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,
+          part: data[:part]&.to_s,
+        )
+      end
+    end
+  end
+end

data/lib/pubid/omg/identifier.rb

@@ -0,0 +1,61 @@
+# 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
+
+      # The document part: the volume or format segment after the version,
+      # e.g. "Superstructure", "Infrastructure", "PDF".
+      #
+      # This retypes the `part` that ::Pubid::Identifier declares as a
+      # Components::Code, because an OMG part is a name and not a numbered
+      # part. Reusing the inherited name is what gives relaton `remove_part!`
+      # as `exclude(:part)`, and what lets Renderers::Annotator wrap the value
+      # from its own TOKENS table. The declaration sits once, on the class
+      # every OMG identifier inherits from, whose body lives in this one file
+      # and is never reopened — the placement the number-retype tranches
+      # require.
+      attribute :part, :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
+        map "part", to: :part
+      end
+
+      PUBLISHER = "OMG"
+
+      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/omg/identifiers/specification.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Omg
+    module Identifiers
+      # OMG specification identifier.
+      #
+      # Examples:
+      #   OMG AMI4CCM 1.0
+      #   OMG UML 2.5.1
+      #   OMG DDS 5 beta 3
+      #   OMG CORBA
+      class Specification < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubomg,
+            stage_code: :published,
+            type_code: :omg,
+            abbr: ["OMG"],
+            name: "OMG Specification",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :omg, web: :specification, title: "OMG Specification",
+            short: "OMG" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/omg/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Omg
+    module Identifiers
+      autoload :Specification, "#{__dir__}/identifiers/specification"
+    end
+  end
+end

data/lib/pubid/omg/parser.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Omg
+    # Parslet grammar for OMG specification identifiers.
+    #
+    # Accepts:
+    #   OMG {ACRONYM}[ {VERSION}][ {PART}]
+    #
+    # ACRONYM is the URL segment of https://www.omg.org/spec/<ACRONYM>/, e.g.
+    # "UML", "DDS-XTypes", "EDMC-FIBO/BE", "VSIPL++", "smartant".
+    # VERSION is digits/dots, optionally followed by a beta label, e.g. "1.0",
+    # "2.5.1", "5 beta 3", "2.5 beta".
+    # PART is the volume or format segment, e.g. "Superstructure", "PDF". A
+    # space or a slash separates it.
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:space) { str(" ") }
+
+      # Acronym: the URL segment OMG gives the specification, kept verbatim,
+      # because a consumer builds the URL from it. It starts with a letter,
+      # which may be lower case ("smartant"). Letters, digits and "+" follow
+      # ("SysML", "AMI4CCM", "VSIPL++"). A hyphen or a slash joins further
+      # segments ("DDS-PSM-Cxx", "EDMC-FIBO/BE"). Each segment is non-empty,
+      # so a hyphen or a slash never ends the acronym.
+      #
+      # The slash in "EDMC-FIBO/BE" belongs to the acronym: OMG serves the
+      # document at /spec/EDMC-FIBO/BE/. A slash after the version separates
+      # the document part instead (see the identifier rule).
+      rule(:acronym_char) { match("[A-Za-z0-9+]") }
+
+      rule(:acronym) do
+        (match("[A-Za-z]") >> acronym_char.repeat >>
+          (match("[-/]") >> acronym_char.repeat(1)).repeat).as(:acronym)
+      end
+
+      # Version: digits with optional dots, optionally followed by " beta" and
+      # an optional beta number. OMG writes the label both ways: the document
+      # at /spec/UML/2.5/Beta1 gives its own version as "2.5 beta", and DDS 1.4
+      # supersedes /spec/DDS/1.4/Beta2.
+      #
+      # The beta number must stay optional here. The document part below would
+      # otherwise swallow a bare "beta" and report the version as "2.5" — a
+      # silent wrong answer, not a parse failure.
+      #
+      # Both halves of the beta label end at a word boundary. Parslet never
+      # backtracks into a `.maybe` that already succeeded, so an unanchored
+      # literal makes the version eat the front of a document part and then
+      # reject the whole identifier: "OMG DDS 1.4 beta2" and
+      # "OMG DDS 1.4 betawave" would raise instead of reading the part.
+      rule(:word_boundary) { match("[A-Za-z0-9]").absent? }
+
+      rule(:beta) do
+        str(" beta") >> word_boundary >>
+          (space >> match("[0-9]").repeat(1) >> word_boundary).maybe
+      end
+
+      rule(:version) do
+        (match("[0-9]").repeat(1) >>
+          (str(".") >> match("[0-9]").repeat(1)).repeat >>
+          beta.maybe).as(:version)
+      end
+
+      # After the version, OMG separates the document part with either a
+      # space or a slash. The renderer prints a space, so the two spellings of
+      # one document stay equal.
+      rule(:part_separator) { space | str("/") }
+
+      # Document part: the volume or format segment OMG puts after the
+      # version. UML 2.1.1 is two documents, Superstructure and
+      # Infrastructure, and the URL carries the same segment
+      # (/spec/UML/2.1.1/Superstructure). A format name (/spec/DDS/1.4/PDF)
+      # occupies the same position.
+      rule(:part) { match("[A-Za-z0-9]").repeat(1).as(:part) }
+
+      # Only a space separates a part that follows the acronym directly. The
+      # acronym rule takes a slash there, so a slash separator is legal only
+      # after a version.
+      rule(:identifier) do
+        str("OMG") >> space >> acronym >>
+          ((space >> version >> (part_separator >> part).maybe) |
+            (space >> part)).maybe
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/omg/renderer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Omg
+    # Human-readable renderer for OMG specification identifiers.
+    #
+    # Produces:
+    #   "OMG AMI4CCM 1.0"
+    #   "OMG UML 2.5.1"
+    #   "OMG UML 2.1.1 Superstructure"
+    #   "OMG CORBA"
+    #
+    # The document part always prints behind a space. OMG writes it behind
+    # either a space or a slash, and the parser takes both, so normalizing
+    # here is what keeps the two spellings of one document equal.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        result = "OMG #{@id.acronym}"
+        result += " #{@id.version}" if present?(@id.version)
+        result += " #{@id.part}" if present?(@id.part)
+        result
+      end
+
+      private
+
+      def present?(value)
+        value && !value.empty?
+      end
+    end
+  end
+end

data/lib/pubid/omg.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "pubid"
+module Pubid
+  # OMG (Object Management Group) specification flavor.
+  #
+  # Covers formal OMG specifications identified by an acronym (UML, SysML,
+  # CORBA, DDS-XTypes, EDMC-FIBO/BE, ...) with optional version (`1.0`, `2.5.1`,
+  # `5 beta 3`).
+  module Omg
+    extend Pubid::PrefixesSupport
+
+    PREFIXES = ["OMG"].freeze
+
+    autoload :Builder, "#{__dir__}/omg/builder"
+    autoload :Identifier, "#{__dir__}/omg/identifier"
+    autoload :Identifiers, "#{__dir__}/omg/identifiers"
+    autoload :Parser, "#{__dir__}/omg/parser"
+    autoload :Renderer, "#{__dir__}/omg/renderer"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Omg::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(:omg, Pubid::Omg)

data/lib/pubid/parser/grammar.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "parslet"
+require_relative "../errors"
+
+module Pubid
+  module Parser
+    # The superclass of every flavor grammar.
+    #
+    # Its only job is to keep parslet out of pubid's public contract. Every
+    # grammar failure originates in `Parslet::Atoms::Base#parse`, which
+    # `Parslet::Parser` does not override, so one override here covers all 46
+    # grammars, both public entry points of every flavor, and the cross-flavor
+    # delegation routes (`Pubid::Iso.parse("ITU-T G.711")` runs ITU's grammar)
+    # — without touching the 131 `parse` methods.
+    #
+    # The name is `Grammar`, not `Base`, because {Pubid::Parsers::Base} already
+    # exists and means something unrelated (the MR-string parser).
+    #
+    # Known limit: a rule atom parsed directly, `Parser.new.<rule>.parse(str)`,
+    # bypasses this and raises a bare `Parslet::ParseFailed`. Nothing in the
+    # gem does that.
+    class Grammar < ::Parslet::Parser
+      # @param io [String, IO]
+      # @param options [Hash] passed through to parslet
+      # @raise [Pubid::Errors::ParseError]
+      def parse(io, options = {})
+        super
+      rescue ::Pubid::Errors::ParseError
+        # A nested grammar already wrapped it. Keep the inner flavor and input.
+        raise
+      rescue ::Parslet::ParseFailed => e
+        raise wrap_parse_failure(e, io)
+      end
+
+      private
+
+      # @param error [Parslet::ParseFailed]
+      # @param io [String, IO] what was handed to {#parse}
+      # @return [Pubid::Errors::ParseError]
+      def wrap_parse_failure(error, io)
+        ::Pubid::Errors::ParseError.new(
+          error.message,
+          error.parse_failure_cause,
+          input: io.is_a?(String) ? io : nil,
+          flavor: pubid_flavor_name,
+        )
+      end
+
+      # "Pubid::Iso::Parser" -> "iso"; "Pubid::Ieee::Aiee::Parser" -> "ieee".
+      #
+      # Resolved through {Pubid::Registry} rather than taken from the module
+      # name, because the two disagree: `Pubid::Tgpp` registers as `"3gpp"`,
+      # and `Pubid::CenCenelec` registers twice (`"cen_cenelec"` first, then
+      # the `"cen"` alias). Reporting the registered name is what lets a caller
+      # feed `error.flavor` straight back to `Pubid::Registry.get`.
+      # @return [String, nil]
+      def pubid_flavor_name
+        parts = self.class.name.to_s.split("::")
+        return nil unless parts[0] == "Pubid" && parts.length > 1
+
+        registered_flavor_name(parts[1]) || parts[1].downcase
+      end
+
+      # @param module_name [String] e.g. "Tgpp"
+      # @return [String, nil] the registered name, nil if not registered
+      def registered_flavor_name(module_name)
+        ::Pubid::Registry.canonical_name(::Pubid.const_get(module_name))
+      rescue ::NameError
+        nil
+      end
+    end
+  end
+end

data/lib/pubid/parser.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Parser
+    autoload :Grammar, "pubid/parser/grammar"
     autoload :CommonParseMethods, "pubid/parser/common_parse_methods"
     autoload :CommonParseRules, "pubid/parser/common_parse_rules"
   end