pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

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

@@ -13,58 +13,21 @@ module Pubid
         #
         # @example Standard format
         #   nesc = Pubid::Ieee.parse("C2-1997 National Electric Safety Code")
-        #   nesc.code.number # => "2"   (prefix "C")
-        #   nesc.year        # => "1997"
+        #   nesc.code.value  # => "C2"
+        #   nesc.year.year   # => 1997
         #
         # @example Handbook format
         #   nesc = Pubid::Ieee.parse("2017 NESC Handbook, Premier Edition")
-        #   nesc.year        # => "2017"
+        #   nesc.year.year   # => 2017
         #   nesc.variant     # => "Handbook"
         #   nesc.edition     # => "Premier Edition"
-        #
-        # 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
+        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
 
           # Publisher portion for NESC identifiers
           #
@@ -73,52 +36,18 @@ module Pubid
             "NESC"
           end
 
-          # 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.
+          # Base rendering - override in subclasses
           #
-          # @param trademark [Boolean] append the IEEE trademark symbol (™/®)
           # @return [String] String representation
-          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})"
+          def to_s
+            parts = []
+            if code && year
+              parts << "#{code}-#{year.year}"
+            elsif year
+              parts << year.year.to_s
             end
-            name
+            parts << "National Electrical Safety Code"
+            parts.join(" ")
           end
         end
       end

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

@@ -10,31 +10,16 @@ module Pubid
         # that are under development or review.
         #
         # @example
-        #   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.
+        #   nesc = Pubid::Ieee.parse("Draft National Electrical Safety Code, January 2016")
+        #   nesc.to_s  # => "Draft National Electrical Safety Code, January 2016"
         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(trademark: false, **opts)
+          def to_s
             parts = ["Draft National Electrical Safety Code"]
-            parts << ", #{month} #{year}" if month && year
-            result = parts.join
-            result += trademark_symbol if trademark
-            annotate_plain_render(result, **opts)
+            parts << ", #{month} #{year.year}" if month && year
+            parts.join
           end
         end
       end

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

@@ -11,30 +11,19 @@ module Pubid
         #
         # @example Basic handbook
         #   nesc = Pubid::Ieee.parse("2012 NESC Handbook")
-        #   nesc.to_s  # => "IEEE Std 2012 NESC Handbook"
+        #   nesc.to_s  # => "2012 NESC Handbook"
         #
         # @example With edition
         #   nesc = Pubid::Ieee.parse("2017 NESC Handbook, Premier Edition")
-        #   nesc.to_s  # => "IEEE Std 2017 NESC Handbook, Premier Edition"
+        #   nesc.to_s  # => "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(trademark: false, **opts)
-            abbr = "NESC"
-            abbr += "(R)" if registered
-            parts = [["IEEE Std", year, "#{abbr} Handbook"].compact.join(" ")]
+          def to_s
+            parts = ["#{year.year} NESC Handbook"]
             parts << ", #{edition}" if edition
-            result = parts.join
-            result += trademark_symbol if trademark
-            annotate_plain_render(result, **opts)
+            parts.join
           end
         end
       end

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

@@ -13,20 +13,11 @@ 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(trademark: false, **opts)
-            result = [year, "NESC Redline"].compact.join(" ")
-            result += trademark_symbol if trademark
-            annotate_plain_render(result, **opts)
+          def to_s
+            "#{year.year} NESC Redline"
           end
         end
       end

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

@@ -13,26 +13,11 @@ 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
           #
-          # @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)
+          # @return [String] C2-YYYY format
+          def to_s
+            "C2-#{year.year} National Electrical Safety Code"
           end
         end
       end

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

@@ -6,7 +6,6 @@ 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,15 @@ module Pubid
     module Identifiers
       # Parenthetical Identifier - wraps identifier with parenthetical annotation
       # Example: "IEEE Standard No 18-1968 (ANSI C55.1-1968)"
-      class ParentheticalIdentifier < Identifier
-        attribute :base, Identifier, polymorphic: true
-        attribute :parenthetical_identifier, Identifier, polymorphic: true
+      class ParentheticalIdentifier < Base
+        attribute :base_identifier, Base, polymorphic: true
+        attribute :parenthetical_identifier, Base, polymorphic: true
+
+        def to_s
+          result = base_identifier.to_s
+          result += " (#{parenthetical_identifier})" if parenthetical_identifier
+          result
+        end
       end
     end
   end

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

@@ -8,40 +8,17 @@ 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 < 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"],
-            stage_code: "draft",
-            type_code: "draft",
-            ieee_draft_equivalent: "P",
-            approval_status: "unapproved",
-            project_status: true,
-          ),
-        ].freeze
-
-        def self.type
-          { 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. 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)
+      class ProjectDraftIdentifier < Base
+        # 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)
           # 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 (positional hash)
-          super(args)
+          # Call parent initialize with modified code
+          super
         end
       end
     end

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

@@ -7,18 +7,25 @@ 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 < Identifier
+      class RedlinedStandard < Base
         # The current standard identifier
-        attribute :base, Identifier, polymorphic: true
+        attribute :base_identifier, Base, polymorphic: true
 
         # Optional: the standard this revises
-        attribute :revision_of, Identifier, polymorphic: true
+        attribute :revision_of, Base, polymorphic: true
 
         # Redline flag (always true for this class)
         attribute :redline, :boolean, default: -> { true }
 
+        def to_s
+          result = base_identifier.to_s
+          result += " (Revision of #{revision_of})" if revision_of
+          result += " - Redline" if redline
+          result
+        end
+
         def publisher
-          base&.publisher || "IEEE"
+          base_identifier&.publisher || "IEEE"
         end
       end
     end

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

@@ -8,10 +8,7 @@ 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 < Identifier
-        # Reliable string `number` for relaton's index key (see CodeNumber).
-        include CodeNumber
-
+      class SiStandard < Base
         # TYPED_STAGES for SI standards
         TYPED_STAGES = [
           Components::TypedStage.new(
@@ -32,6 +29,44 @@ module Pubid
 
         # Use proper Draft component (Lutaml::Model object)
         attr_accessor :draft_obj
+
+        def to_s
+          parts = []
+
+          # Publisher (IEEE/ASTM)
+          parts << "IEEE/ASTM"
+
+          # Type (SI or PSI based on typed_stage)
+          parts << if typed_stage&.abbr&.include?("PSI")
+                     "PSI"
+                   else
+                     "SI"
+                   end
+
+          # Code (number) with draft version for PSI
+          code_part = code.to_s
+          if draft_obj
+            # Use Draft component's version attribute
+            code_part += "/D#{draft_obj.version}"
+          end
+          parts << code_part if code
+
+          # Date
+          if month && year
+            parts << ", #{month} #{year}"
+          elsif year
+            parts << "-#{year}"
+          end
+
+          # Relationships (if present)
+          result = parts.join(" ")
+          if relationships && !relationships.empty?
+            rel_strs = relationships.map(&:to_s)
+            result += " (#{rel_strs.join(' / ')})"
+          end
+
+          result
+        end
       end
     end
   end

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

@@ -17,10 +17,7 @@ module Pubid
       #   std = Pubid::Ieee.parse("ANSI/IEEE Std 500-1984")
       #   std.publisher        # => "IEEE"
       #   std.copublisher     # => ["ANSI"]
-      class Standard < Identifier
-        # Reliable string `number` for relaton's index key (see CodeNumber).
-        include CodeNumber
-
+      class Standard < Base
         # TYPED_STAGES for published IEEE standards
         # Standards use "Std" abbreviation for published state
         TYPED_STAGES = [
@@ -32,7 +29,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :std, web: :standard, title: "Standard", short: "Std" }
+          { key: :std, title: "Standard", short: "Std" }
         end
 
         # Render standard IEEE format

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

@@ -3,38 +3,19 @@
 module Pubid
   module Ieee
     module Identifiers
-      # Identifier class for supplement identifiers (amendments, corrigenda, interpretations, etc.)
+      # Base class for supplement identifiers (amendments, corrigenda, interpretations, etc.)
       # Supplements modify or add to a base document
-      class SupplementIdentifier < Identifier
-        attribute :base, Identifier, polymorphic: true
+      class SupplementIdentifier < Base
+        attribute :base_identifier, Base, polymorphic: true
 
-        # Delegate publisher to base
+        # Delegate publisher to base_identifier
         def publisher
-          base&.publisher
+          base_identifier&.publisher
         end
 
-        # Delegate code to base if not overridden
+        # Delegate code to base_identifier if not overridden
         def 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
+          base_identifier&.code
         end
       end
     end

data/lib/pubid/ieee/identifiers.rb

@@ -4,10 +4,9 @@ module Pubid
   module Ieee
     module Identifiers
       autoload :AdoptedStandard, "#{__dir__}/identifiers/adopted_standard"
-      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Base, "#{__dir__}/identifiers/base"
       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,12 +14,11 @@ module Pubid
           # Extract type
           attributes[:type] = extract_value(parsed[:type])
 
-          # 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.
+          # Extract number
           number_str = extract_value(parsed[:number])
-          attributes[:code] = number_str if number_str
+          if number_str
+            attributes[:number] = Components::Code.parse(number_str)
+          end
 
           # Extract year - handle both short (52) and full (1952) formats
           year_str = extract_value(parsed[:year])
@@ -29,13 +28,13 @@ module Pubid
             if year_int.between?(12, 63)
               year_int += 1900
             end
-            attributes[:year] = year_int.to_s
+            attributes[:year] = year_int
           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.to_s
+            attributes[:year] = full_year_str.to_i
           end
 
           # Create identifier

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

@@ -5,36 +5,32 @@ require "lutaml/model"
 module Pubid
   module Ieee
     module Ire
-      # 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
-
+      # Base class for IRE identifiers
+      # IRE (Institute of Radio Engineers): 1912-1963
+      class Identifier < Lutaml::Model::Serializable
         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: -> {}
+        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
 
-        # 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"
+          # Set other attributes
+          attrs = self.class.attributes
+          args.each do |key, value|
+            next if key == :number
+
+            setter = :"#{key}="
+            public_send(setter, value) if attrs.key?(key)
+          end
         end
 
         # Parse IRE identifier string
@@ -44,28 +40,17 @@ module Pubid
           builder.build(parsed)
         end
 
-        def to_s(trademark: false, **opts)
+        def to_s
+          parts = []
           # Year comes FIRST in IRE format - render as 2-digit short year
-          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])
+          if year
+            short_year = year.between?(1900, 1999) ? year - 1900 : year
+            parts << short_year.to_s
           end
-          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
+          parts << publisher
+          parts << type if type
+          parts << number.to_s if number
+          parts.join(" ")
         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 < ::Pubid::Parser::Grammar
+      class Parser < Parslet::Parser
         # Basic building blocks
         rule(:space) { str(" ") }
         rule(:space?) { space.maybe }