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

data/lib/pubid/ieee/identifiers/nesc/base.rb

@@ -13,21 +13,58 @@ module Pubid
         #
         # @example Standard format
         #   nesc = Pubid::Ieee.parse("C2-1997 National Electric Safety Code")
-        #   nesc.code.value  # => "C2"
-        #   nesc.year.year   # => 1997
+        #   nesc.code.number # => "2"   (prefix "C")
+        #   nesc.year        # => "1997"
         #
         # @example Handbook format
         #   nesc = Pubid::Ieee.parse("2017 NESC Handbook, Premier Edition")
-        #   nesc.year.year   # => 2017
+        #   nesc.year        # => "2017"
         #   nesc.variant     # => "Handbook"
         #   nesc.edition     # => "Premier Edition"
-        class Base < Lutaml::Model::Serializable
-          attribute :code, Pubid::Ieee::Components::Code # "C2" code designation
-          attribute :year, Pubid::Components::Date # Publication year
-          attribute :variant, :string              # Handbook, Redline, etc.
-          attribute :edition, :string              # Edition notation
-          attribute :draft, :boolean               # Draft flag
-          attribute :month, :string                # For draft identifiers
+        #
+        # Reparented onto Pubid::Ieee::Identifier (it used to descend from bare
+        # Lutaml::Model::Serializable) so NESC shares `#root`, a polymorphic
+        # `_type` and from_hash routing with every other IEEE type — see
+        # Pubid::Ieee::Aiee::Identifier for the same migration. Three
+        # attributes were reconciled against the base to avoid type collisions:
+        #
+        #   `code`  -> travels as the runtime `code_obj` (base #code returns
+        #              it); the concrete leaves serialize the flat split
+        #              columns via the CodeNumber mixin.
+        #   `year`  -> the base's plain `:string` year (was a
+        #              Pubid::Components::Date), matching IEEE's scalar-date
+        #              convention. `nesc.year` is now "2017", not a component.
+        #   `draft` -> dropped; the base declares a `:string` `draft` (the draft
+        #              *designator*), so a boolean here would corrupt it. Test
+        #              draft-ness with `#draft?` / the Nesc::Draft class.
+        #
+        # This class is abstract and enforces it in #initialize: the builder
+        # always instantiates a concrete leaf (Nesc::Edition for the plain
+        # year-first form), because only leaves may redefine `number` as a
+        # :string (see the CodeNumber mixin) and only leaves declare the
+        # NESC-specific `polymorphic_name` that from_hash routes on.
+        class Base < Pubid::Ieee::Identifier
+          attribute :variant, :string # Handbook, Redline, etc.
+          # Registered-trademark "(R)" after the full name or abbreviation
+          attribute :registered, :boolean
+          # Whether the "(NESC)"/"(NESC(R))" abbreviation suffix was present
+          attribute :abbr_suffix, :boolean
+          # Registered-trademark "(R)" inside the "(NESC(R))" suffix
+          attribute :abbr_suffix_registered, :boolean
+
+          # Guards the abstract contract — see the class docs. Ruby has no
+          # `abstract`, and an instantiated Base would carry the derived
+          # `_type` "pubid:ieee:base" (which from_hash cannot resolve back to
+          # NESC) and a nil `number` (the empty relaton index key).
+          def initialize(args = {}, **kwargs)
+            if instance_of?(Base)
+              raise NotImplementedError,
+                    "#{self.class} is abstract; instantiate a concrete NESC " \
+                    "type (Standard, Edition, Handbook, Redline, Draft)"
+            end
+
+            super
+          end
 
           # Publisher portion for NESC identifiers
           #
@@ -36,18 +73,52 @@ module Pubid
             "NESC"
           end
 
-          # Base rendering - override in subclasses
+          # Whether this is a draft of the code. NESC has no `draft` attribute
+          # of its own (the base's `draft` is the draft designator string), so
+          # draft-ness lives in the class.
+          #
+          # @return [Boolean]
+          def draft?
+            is_a?(Nesc::Draft)
+          end
+
+          # Rendering for year-first NESC identifiers (the C2-code standard form
+          # overrides this in Nesc::Standard). IEEE catalogues the year-first
+          # editions with the "IEEE Std" prefix, so it is prepended here.
           #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] String representation
-          def to_s
-            parts = []
-            if code && year
-              parts << "#{code}-#{year.year}"
-            elsif year
-              parts << year.year.to_s
+          def to_s(trademark: false, **opts)
+            result = ["IEEE Std", year, name_portion].compact.join(" ")
+            result += trademark_symbol if trademark
+            annotate_plain_render(result, **opts)
+          end
+
+          # Trademark symbol for this document's own code. A NESC string starts
+          # with the publication *year*, so the string-scanning
+          # Pubid::Ieee.trademark_symbol would pick the wrong field — an
+          # edition year of 2030 would silently render ®.
+          #
+          # @return [String] "®" or "™"
+          def trademark_symbol
+            Pubid::Ieee.trademark_symbol_for(code_obj&.number,
+                                             code_obj&.prefix,
+                                             publishers: [publisher])
+          end
+
+          # The document-name portion, including the registered marks and the
+          # optional "(NESC(R))" abbreviation suffix.
+          #
+          # @return [String] e.g. "National Electrical Safety Code(R) (NESC(R))"
+          def name_portion
+            name = "National Electrical Safety Code"
+            name += "(R)" if registered
+            if abbr_suffix
+              suffix = "NESC"
+              suffix += "(R)" if abbr_suffix_registered
+              name += " (#{suffix})"
             end
-            parts << "National Electrical Safety Code"
-            parts.join(" ")
+            name
           end
         end
       end

data/lib/pubid/ieee/identifiers/nesc/draft.rb

@@ -10,16 +10,31 @@ module Pubid
         # that are under development or review.
         #
         # @example
-        #   nesc = Pubid::Ieee.parse("Draft National Electrical Safety Code, January 2016")
-        #   nesc.to_s  # => "Draft National Electrical Safety Code, January 2016"
+        #   nesc = Pubid::Ieee.parse("Draft NESC, June 2011")
+        #   nesc.to_s
+        #   # => "Draft National Electrical Safety Code, June 2011"
+        #
+        # NOTE: the spelled-out "Draft National Electrical Safety Code, …" form
+        # is claimed by the generic IEEE grammar before it reaches the NESC
+        # sub-parser, so it does not currently build this class. Pre-existing
+        # dispatcher gap, pinned in spec/pubid/ieee/ire_nesc_roundtrip_spec.rb.
         class Draft < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-draft"
+          end
+
           # Render draft identifier
           #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] Draft format with optional month and year
-          def to_s
+          def to_s(trademark: false, **opts)
             parts = ["Draft National Electrical Safety Code"]
-            parts << ", #{month} #{year.year}" if month && year
-            parts.join
+            parts << ", #{month} #{year}" if month && year
+            result = parts.join
+            result += trademark_symbol if trademark
+            annotate_plain_render(result, **opts)
           end
         end
       end

data/lib/pubid/ieee/identifiers/nesc/edition.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    module Identifiers
+      module Nesc
+        # A plain year-first NESC edition — the National Electrical Safety Code
+        # itself, referenced by publication year rather than by its C2 code.
+        #
+        # @example
+        #   nesc = Pubid::Ieee.parse(
+        #     "2017 National Electrical Safety Code(R) (NESC(R))",
+        #   )
+        #   nesc.to_s
+        #   # => "IEEE Std 2017 National Electrical Safety Code(R) (NESC(R))"
+        #
+        # Rendering is Nesc::Base's; this class exists so that the builder never
+        # instantiates the abstract Base. Only concrete leaves may carry the
+        # CodeNumber mixin's `:string` `number` (see the mixin's notes on the
+        # multi-flavor attribute-resolution landmine), and every identifier that
+        # can be a `#root` needs a non-empty `number` for the relaton index.
+        class Edition < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-edition"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/identifiers/nesc/handbook.rb

@@ -11,19 +11,30 @@ module Pubid
         #
         # @example Basic handbook
         #   nesc = Pubid::Ieee.parse("2012 NESC Handbook")
-        #   nesc.to_s  # => "2012 NESC Handbook"
+        #   nesc.to_s  # => "IEEE Std 2012 NESC Handbook"
         #
         # @example With edition
         #   nesc = Pubid::Ieee.parse("2017 NESC Handbook, Premier Edition")
-        #   nesc.to_s  # => "2017 NESC Handbook, Premier Edition"
+        #   nesc.to_s  # => "IEEE Std 2017 NESC Handbook, Premier Edition"
         class Handbook < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-handbook"
+          end
+
           # Render handbook identifier
           #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] YYYY NESC Handbook format with optional edition
-          def to_s
-            parts = ["#{year.year} NESC Handbook"]
+          def to_s(trademark: false, **opts)
+            abbr = "NESC"
+            abbr += "(R)" if registered
+            parts = [["IEEE Std", year, "#{abbr} Handbook"].compact.join(" ")]
             parts << ", #{edition}" if edition
-            parts.join
+            result = parts.join
+            result += trademark_symbol if trademark
+            annotate_plain_render(result, **opts)
           end
         end
       end

data/lib/pubid/ieee/identifiers/nesc/redline.rb

@@ -13,11 +13,20 @@ module Pubid
         #   nesc = Pubid::Ieee.parse("2017 NESC Redline")
         #   nesc.to_s  # => "2017 NESC Redline"
         class Redline < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          def self.polymorphic_name
+            "pubid:ieee:nesc-redline"
+          end
+
           # Render redline identifier
           #
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] YYYY NESC Redline format
-          def to_s
-            "#{year.year} NESC Redline"
+          def to_s(trademark: false, **opts)
+            result = [year, "NESC Redline"].compact.join(" ")
+            result += trademark_symbol if trademark
+            annotate_plain_render(result, **opts)
           end
         end
       end

data/lib/pubid/ieee/identifiers/nesc/standard.rb

@@ -13,11 +13,26 @@ module Pubid
         #   nesc = Pubid::Ieee.parse("C2-1997 National Electric Safety Code")
         #   nesc.to_s  # => "C2-1997 National Electrical Safety Code"
         class Standard < Base
+          include Pubid::Ieee::Identifiers::CodeNumber
+
+          # Distinct from Identifiers::Standard, whose derived polymorphic name
+          # is also "pubid:ieee:standard".
+          def self.polymorphic_name
+            "pubid:ieee:nesc-standard"
+          end
+
           # Render standard NESC identifier
           #
-          # @return [String] C2-YYYY format
-          def to_s
-            "C2-#{year.year} National Electrical Safety Code"
+          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
+          # @return [String] C2-YYYY format (bare "C2" when the year is absent,
+          #   e.g. a partial reference produced by `#exclude(:year)`)
+          def to_s(trademark: false, **opts)
+            # Unlike the year-first NESC editions, this form renders a code, so
+            # the mark goes after it and before the year — as everywhere else.
+            code_part = "C2"
+            code_part += trademark_symbol if trademark
+            code_part += "-#{year}" if year
+            annotate_plain_render("#{code_part} National Electrical Safety Code", **opts)
           end
         end
       end

data/lib/pubid/ieee/identifiers/nesc.rb

@@ -6,6 +6,7 @@ module Pubid
       module Nesc
         autoload :Base, "#{__dir__}/nesc/base"
         autoload :Draft, "#{__dir__}/nesc/draft"
+        autoload :Edition, "#{__dir__}/nesc/edition"
         autoload :Handbook, "#{__dir__}/nesc/handbook"
         autoload :Redline, "#{__dir__}/nesc/redline"
         autoload :Standard, "#{__dir__}/nesc/standard"

data/lib/pubid/ieee/identifiers/parenthetical_identifier.rb

@@ -5,9 +5,9 @@ module Pubid
     module Identifiers
       # Parenthetical Identifier - wraps identifier with parenthetical annotation
       # Example: "IEEE Standard No 18-1968 (ANSI C55.1-1968)"
-      class ParentheticalIdentifier < Base
-        attribute :base_identifier, Base, polymorphic: true
-        attribute :parenthetical_identifier, Base, polymorphic: true
+      class ParentheticalIdentifier < Identifier
+        attribute :base, Identifier, polymorphic: true
+        attribute :parenthetical_identifier, Identifier, polymorphic: true
       end
     end
   end

data/lib/pubid/ieee/identifiers/project_draft_identifier.rb

@@ -8,7 +8,12 @@ module Pubid
       # where P1234 is the project number and D5 is the draft version
       # This is distinct from a StandardIdentifier - the "P" indicates project status,
       # not a code prefix like "C" in "C57.12"
-      class ProjectDraftIdentifier < Base
+      class ProjectDraftIdentifier < Identifier
+        # Reliable string `number` for relaton's index key (see CodeNumber).
+        # Its #initialize `super` chains through CodeNumber, which sets `number`
+        # from the (P-stripped) code after the parent builds code_obj.
+        include CodeNumber
+
         TYPED_STAGES = [
           Components::TypedStage.new(
             abbr: ["P"],
@@ -24,16 +29,19 @@ module Pubid
           { key: :P, title: "Project Draft", short: "P" }
         end
 
-        # Override initialize to strip "P" prefix from code before creating Code object
-        # The "P" is reflected in the typed_stage, not in the Code component itself
-        def initialize(**args)
+        # Override initialize to strip "P" prefix from code before creating Code
+        # object. The "P" is reflected in the typed_stage, not in the Code
+        # component itself. Accepts keyword args or a single positional hash (the
+        # base #exclude/matching rebuild passes the latter).
+        def initialize(args = {}, **kwargs)
+          args = kwargs.empty? ? args.dup : args.merge(kwargs)
           # If code is provided with "P" prefix (e.g., "P1234"), strip it
           if args[:code].is_a?(String) && args[:code].start_with?("P")
             args[:code] = args[:code][1..] # Strip leading "P"
           end
 
-          # Call parent initialize with modified code
-          super
+          # Call parent initialize with modified code (positional hash)
+          super(args)
         end
       end
     end

data/lib/pubid/ieee/identifiers/redlined_standard.rb

@@ -7,18 +7,18 @@ module Pubid
       # IEEE standard with optional revision note, marked as redline
       # Example: "IEEE Std 1018-2013 (Revison of IEEE Std 1018-2004) - Redline"
       # Contains: base standard + optional revision standard + redline flag
-      class RedlinedStandard < Base
+      class RedlinedStandard < Identifier
         # The current standard identifier
-        attribute :base_identifier, Base, polymorphic: true
+        attribute :base, Identifier, polymorphic: true
 
         # Optional: the standard this revises
-        attribute :revision_of, Base, polymorphic: true
+        attribute :revision_of, Identifier, polymorphic: true
 
         # Redline flag (always true for this class)
         attribute :redline, :boolean, default: -> { true }
 
         def publisher
-          base_identifier&.publisher || "IEEE"
+          base&.publisher || "IEEE"
         end
       end
     end

data/lib/pubid/ieee/identifiers/si_standard.rb

@@ -8,7 +8,10 @@ module Pubid
       # Handles both:
       # - SI: Published standards (IEEE/ASTM SI 10-1997)
       # - PSI: Proposed SI (drafts: IEEE/ASTM PSI 10/D2, October 2015)
-      class SiStandard < Base
+      class SiStandard < Identifier
+        # Reliable string `number` for relaton's index key (see CodeNumber).
+        include CodeNumber
+
         # TYPED_STAGES for SI standards
         TYPED_STAGES = [
           Components::TypedStage.new(

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

@@ -17,7 +17,10 @@ module Pubid
       #   std = Pubid::Ieee.parse("ANSI/IEEE Std 500-1984")
       #   std.publisher        # => "IEEE"
       #   std.copublisher     # => ["ANSI"]
-      class Standard < Base
+      class Standard < Identifier
+        # Reliable string `number` for relaton's index key (see CodeNumber).
+        include CodeNumber
+
         # TYPED_STAGES for published IEEE standards
         # Standards use "Std" abbreviation for published state
         TYPED_STAGES = [

data/lib/pubid/ieee/identifiers/supplement_identifier.rb

@@ -3,19 +3,38 @@
 module Pubid
   module Ieee
     module Identifiers
-      # Base class for supplement identifiers (amendments, corrigenda, interpretations, etc.)
+      # Identifier class for supplement identifiers (amendments, corrigenda, interpretations, etc.)
       # Supplements modify or add to a base document
-      class SupplementIdentifier < Base
-        attribute :base_identifier, 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 code to base_identifier if not overridden
+        # Delegate code to base if not overridden
         def code
-          base_identifier&.code
+          base&.code
+        end
+
+        # `publisher` is a pure delegation to `base`, so it must never be
+        # serialized independently on the wrapper. lutaml's default-tracking
+        # otherwise emits it asymmetrically — omitted on the parse path (the
+        # wrapper's own attribute is never assigned) but present after
+        # `from_hash` (deserialization assigns it) — which breaks the canonical
+        # `to_hash` round-trip for a supplement whose base carries a non-default
+        # publisher (e.g. an ANSI/ISO corrigendum). The truth lives in `base`.
+        def to_hash(*args)
+          hash = super
+          if hash.is_a?(::Hash)
+            # `publisher` and `code` are delegated to `base`; never serialize
+            # them on the wrapper (they'd duplicate base.publisher/base.number
+            # and, for publisher, desync across parse vs from_hash).
+            hash.delete("publisher")
+            hash.delete("code")
+          end
+          hash
         end
       end
     end

data/lib/pubid/ieee/identifiers.rb

@@ -4,9 +4,10 @@ module Pubid
   module Ieee
     module Identifiers
       autoload :AdoptedStandard, "#{__dir__}/identifiers/adopted_standard"
-      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
       autoload :ConformanceIdentifier,
                "#{__dir__}/identifiers/conformance_identifier"
+      autoload :CodeNumber, "#{__dir__}/identifiers/code_number"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :CsaDualPublished, "#{__dir__}/identifiers/csa_dual_published"
       autoload :DualIdentifier, "#{__dir__}/identifiers/dual_identifier"

data/lib/pubid/ieee/ire/builder.rb

@@ -14,11 +14,12 @@ module Pubid
           # Extract type
           attributes[:type] = extract_value(parsed[:type])
 
-          # Extract number
+          # Extract the document designation. It travels as `code:` so the base
+          # initializer parses it into `code_obj` and the CodeNumber mixin
+          # hoists the flat split columns (number/prefix/parts/separator) that
+          # relaton indexes on.
           number_str = extract_value(parsed[:number])
-          if number_str
-            attributes[:number] = Components::Code.parse(number_str)
-          end
+          attributes[:code] = number_str if number_str
 
           # Extract year - handle both short (52) and full (1952) formats
           year_str = extract_value(parsed[:year])
@@ -28,13 +29,13 @@ module Pubid
             if year_int.between?(12, 63)
               year_int += 1900
             end
-            attributes[:year] = year_int
+            attributes[:year] = year_int.to_s
           end
 
           # Override with full_year if present
           full_year_str = extract_value(parsed[:full_year])
           if full_year_str
-            attributes[:year] = full_year_str.to_i
+            attributes[:year] = full_year_str.to_i.to_s
           end
 
           # Create identifier

data/lib/pubid/ieee/ire/identifier.rb

@@ -5,32 +5,36 @@ require "lutaml/model"
 module Pubid
   module Ieee
     module Ire
-      # Base class for IRE identifiers
-      # IRE (Institute of Radio Engineers): 1912-1963
-      class Identifier < Lutaml::Model::Serializable
-        attribute :publisher, :string, default: -> { "IRE" }
-        attribute :type, :string # "Trans.", "Standard", "Std"
-        attribute :number, Components::Code
-        attribute :year, :integer
-
-        def initialize(**args)
-          super()
-
-          # Handle number as string or Code object
-          if args[:number].is_a?(String)
-            self.number = Components::Code.parse(args[:number])
-          elsif args[:number]
-            self.number = args[:number]
-          end
+      # IRE identifiers (Institute of Radio Engineers: 1912-1963).
+      #
+      # Reparented onto Pubid::Ieee::Identifier + the CodeNumber mixin for the
+      # same reasons AIEE was (see Pubid::Ieee::Aiee::Identifier): descending
+      # from bare Lutaml::Model::Serializable left IRE without `#root` (relaton
+      # keys its index on `id.root.number.to_s` -> NoMethodError), without a
+      # polymorphic `_type` (so `from_hash` could not route back), and — because
+      # an IRE object was not a ::Pubid::Identifier — unassignable to
+      # Identifiers::AdoptedStandard#adopted_identifiers, which raised
+      # Lutaml::Model::IncorrectModelError on `to_hash` for the IRE-adopted
+      # forms ("IEEE Std 159-1972 (52 IRE 7 S2)").
+      #
+      # The document designation ("7.S2") is carried in the shared `code_obj`
+      # and serialized as the flat split columns (number/prefix/parts/
+      # separator); the publication year uses the base's plain `:string` `year`
+      # (IRE previously declared its own `:integer` one, which would collide).
+      class Identifier < Pubid::Ieee::Identifier
+        include Pubid::Ieee::Identifiers::CodeNumber
 
-          # Set other attributes
-          attrs = self.class.attributes
-          args.each do |key, value|
-            next if key == :number
+        attribute :publisher, :string, default: -> { "IRE" }
+        # IRE spells its type word out when present ("Trans.", "Standard",
+        # "Std") and omits it otherwise, so the base's "Std" default must go —
+        # else "52 IRE 7.S2" would render as "52 IRE Std 7.S2".
+        attribute :type, :string, default: -> {}
 
-            setter = :"#{key}="
-            public_send(setter, value) if attrs.key?(key)
-          end
+        # A distinct polymorphic name so from_hash routes to IRE. The derived
+        # default (last name segment "Identifier") would be
+        # "pubid:ieee:identifier", colliding with the base class.
+        def self.polymorphic_name
+          "pubid:ieee:ire"
         end
 
         # Parse IRE identifier string
@@ -40,17 +44,28 @@ module Pubid
           builder.build(parsed)
         end
 
-        def to_s
-          parts = []
+        def to_s(trademark: false, **opts)
           # Year comes FIRST in IRE format - render as 2-digit short year
-          if year
-            short_year = year.between?(1900, 1999) ? year - 1900 : year
-            parts << short_year.to_s
+          result = [(short_year if year), publisher, type, code&.to_s]
+            .compact.join(" ")
+          # The code is the last token, so the end of the string already *is*
+          # the code boundary — but the symbol is picked from the code, not by
+          # scanning the string (which starts with the year).
+          if trademark
+            result += Pubid::Ieee.trademark_symbol_for(code_obj&.number,
+                                                       code_obj&.prefix,
+                                                       publishers: [publisher])
           end
-          parts << publisher
-          parts << type if type
-          parts << number.to_s if number
-          parts.join(" ")
+          annotate_plain_render(result, **opts)
+        end
+
+        private
+
+        # IRE prints the publication year first, abbreviated to two digits for
+        # the 20th century ("1952" => "52").
+        def short_year
+          value = year.to_i
+          (value.between?(1900, 1999) ? value - 1900 : value).to_s
         end
       end
     end

data/lib/pubid/ieee/ire/parser.rb

@@ -7,7 +7,7 @@ module Pubid
     module Ire
       # Parser for IRE (Institute of Radio Engineers) identifiers
       # Historical period: 1912-1963 (merged into IEEE in 1963)
-      class Parser < Parslet::Parser
+      class Parser < ::Pubid::Parser::Grammar
         # Basic building blocks
         rule(:space) { str(" ") }
         rule(:space?) { space.maybe }