pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.9

data/lib/pubid/omg/parser.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Omg
+    # Parslet grammar for OMG specification identifiers.
+    #
+    # Accepts:
+    #   OMG {ACRONYM}[ {VERSION}]
+    #
+    # ACRONYM is uppercase letters/digits, at least 1 char.
+    # VERSION is digits/dots/spaces/beta+space+digit, e.g. "1.0", "2.5.1",
+    # "5 beta 3".
+    class Parser < Parslet::Parser
+      rule(:space) { str(" ") }
+
+      # Acronym: starts with uppercase, may contain uppercase + lowercase +
+      # digits (covers "SysML", "AMI4CCM", "UML", "CORBA", "BMM", ...).
+      rule(:acronym) { (match("[A-Z]") >> match("[A-Za-z0-9]").repeat).as(:acronym) }
+
+      # Version: digits with optional dots, optionally followed by " beta N".
+      rule(:version) do
+        (match("[0-9]").repeat(1) >>
+          (str(".") >> match("[0-9]").repeat(1)).repeat >>
+          (str(" beta ") >> match("[0-9]").repeat(1)).maybe).as(:version)
+      end
+
+      rule(:identifier) do
+        str("OMG") >> space >> acronym >> (space >> version).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,19 @@
+# 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 CORBA"
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        result = "OMG #{@id.acronym}"
+        result += " #{@id.version}" if @id.version && !@id.version.empty?
+        result
+      end
+    end
+  end
+end

data/lib/pubid/omg.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  # OMG (Object Management Group) specification flavor.
+  #
+  # Covers formal OMG specifications identified by an acronym (UML, SysML,
+  # CORBA, AMI4CCM, ...) 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/parsers/mr_string.rb

@@ -2,6 +2,28 @@
 
 module Pubid
   module Parsers
+    # Parses a machine-readable (MR) identifier string back into an Identifier.
+    #
+    # The MR format produced by `Renderers::MrString` mirrors the human form,
+    # lowercased and filename-safe:
+    #
+    #   iso.9001.2015                              → ISO 9001:2015
+    #   iso-iec.17031-1.2020                       → ISO/IEC 17031-1:2020
+    #   iso.1234-1-2-3.2020                        → ISO 1234-1-2-3:2020
+    #   iso.tr.14627.2017                          → ISO/TR 14627:2017
+    #   iso.16634.--                               → ISO 16634:--
+    #   iso.9001.2015_amd.1.2020                   → ISO 9001:2015/Amd 1:2020
+    #   iso-iec.13818-1.2015_amd.3.2016_cor.1.2017 → ISO/IEC 13818-1:2015/Amd 3:2016/Cor 1:2017
+    #
+    # Copublishers join with `-` (`iso-iec`), supplements append with `_`
+    # (`iso.9001.2015_amd.1.2020`). Both round-trip back to `/` here. The
+    # flavor's own parser is case-insensitive on the type/publisher tokens
+    # we emit, so the lowercased slug re-parses cleanly.
+    #
+    # Note: NIST, CSA, IEEE, JIS, and SAE emit their own MR shapes that this
+    # parser does not attempt to reverse (their `to_s` already round-trips
+    # through the flavor's own parser, so callers should use that path for
+    # those flavors).
     class MrString < Base
       FLAVOR_MAP = {
         "ISO" => :iso,
@@ -59,6 +81,14 @@ module Pubid
         ccsds: :Ccsds,
       }.freeze
 
+      # Lower-case type codes the renderer emits as a separate MR segment
+      # (e.g. `iso.tr.14627`). When the parser sees one of these in the
+      # second position, it splits it back out as `/TYPE`.
+      TYPE_CODES = %w[
+        tr ts pas is amd cor suppl add ext guide spec
+        standard corrigendum amendment
+      ].freeze
+
       def self.parse(mr_string)
         flavor = detect_flavor(mr_string)
 
@@ -75,19 +105,83 @@ module Pubid
       end
 
       def self.detect_flavor(mr_string)
-        publisher = mr_string.split(".").first.upcase
+        publisher = mr_string.split(/[._-]/).first.to_s.upcase
         FLAVOR_MAP[publisher] || :iso
       end
 
+      # Convert the MR slug back to a human-readable identifier string the
+      # flavor's own parser will accept. Splits on `_` first so each segment
+      # (head + each supplement) is converted independently, then re-joined
+      # with `/`. Within the head, the copublisher separator `-` (first
+      # segment only) is restored to `/`.
       def self.convert_to_human_readable(mr_string)
-        parts = mr_string.split(".")
-        if parts.size > 2
-          year_part = parts.pop
-          parts.join(" ") + ":#{year_part}"
-        else
-          parts.join(" ")
+        head, *supplements = mr_string.split("_")
+        human = convert_head(head)
+        return human if supplements.empty?
+
+        supplements.inject(human) do |acc, supp|
+          "#{acc}/#{convert_supplement(supp)}"
+        end
+      end
+
+      # Converts a head segment like `iso-iec.13818-1.2015` to
+      # `ISO/IEC 13818-1:2015`.
+      def self.convert_head(head)
+        parts = head.split(".")
+        return parts.join(" ").upcase if parts.length <= 1
+
+        publisher, *rest = parts
+
+        # Optional type code segment (iso.tr.14627.2017 → ISO/TR 14627:2017).
+        type_segment = nil
+        if rest.first && TYPE_CODES.include?(rest.first.downcase)
+          type_segment = rest.shift.upcase
+        end
+
+        # Trailing language segment — bare language code(s) with no parens.
+        # Detect by length <= 5 and all-alpha (en, fr, en-fr, ru).
+        language_segment = nil
+        if rest.last&.match?(/\A[a-z]{2}(-[a-z]{2})*\z/)
+          language_segment = rest.pop
         end
+
+        # Trailing year segment (may be `--` for undated, or YYYY[-MM[-DD]]).
+        year_segment = nil
+        if rest.any? && rest.last.match?(/\A(?:\d{4}(?:-\d{2}){0,2}|--)\z/)
+          year_segment = rest.pop
+        end
+
+        # Copublishers in the first segment: `iso-iec` → `ISO/IEC`. Multi-word
+        # publisher bodies (e.g. `cen-cenelec`) round-trip the same way.
+        publisher_part = publisher.split("-").map(&:upcase).join("/")
+        publisher_part = "#{publisher_part}/#{type_segment}" if type_segment
+
+        number_part = rest.join(" ")
+        result = publisher_part
+        result += " #{number_part}" unless number_part.empty?
+        result += ":#{year_segment}" if year_segment
+        if language_segment
+          langs = language_segment.split("-").join(",")
+          result += "(#{langs})"
+        end
+        result
+      end
+
+      # Converts a supplement segment like `amd.1.2020` to `Amd 1:2020`.
+      # The first token is the lowercase type code; remaining tokens are
+      # number and optional year.
+      def self.convert_supplement(supp)
+        tokens = supp.split(".")
+        type = tokens.shift&.upcase
+        year = tokens.last&.match?(/\A\d{4}\z/) ? tokens.pop : nil
+        number = tokens.join(" ")
+
+        result = type.to_s
+        result += " #{number}" unless number.empty?
+        result += ":#{year}" if year
+        result
       end
     end
   end
 end
+

data/lib/pubid/plateau/builder.rb

@@ -9,7 +9,7 @@ module Pubid
 
       def build(parsed)
         # Check for annex supplement first
-        if parsed[:base_identifier] && parsed[:annex_letter]
+        if parsed[:base] && parsed[:annex_letter]
           return build_annex(parsed)
         end
 
@@ -29,7 +29,11 @@ module Pubid
         }
 
         params[:annex] = parsed[:annex].to_s.to_i if parsed[:annex]
-        params[:edition] = parsed[:edition].to_s if parsed[:edition]
+        # Only Handbook carries an edition; a legacy Latin TR captures the
+        # edition slice via the shared handbook rule, so drop it here.
+        if parsed[:edition] && klass == Identifiers::Handbook
+          params[:edition] = parsed[:edition].to_s
+        end
 
         klass.new(**params)
       end
@@ -38,10 +42,10 @@ module Pubid
 
       def build_annex(parsed)
         # Recursively parse base identifier
-        base = build(parsed[:base_identifier])
+        base = build(parsed[:base])
 
         Identifiers::Annex.new(
-          base_identifier: base,
+          base: base,
           letter: parsed[:annex_letter].to_s,
         )
       end

data/lib/pubid/plateau/identifier.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
 # Pubid::Plateau::Identifier is the PLATEAU base class (a real Pubid::Identifier
-# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
-# live in identifiers/base.rb. This file just ensures it is loaded.
-require_relative "identifiers/base"
+# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.

data/lib/pubid/plateau/identifiers/base.rb

@@ -3,7 +3,7 @@
 module Pubid
   module Plateau
     # Base class for all PLATEAU identifiers. Canonical name
-    # Pubid::Plateau::Identifier (Identifiers::Base is a back-compat alias).
+    # Pubid::Plateau::Identifier.
     class Identifier < ::Pubid::Identifier
       # Delegate to the flavor module so callers can use
       # `Pubid::Plateau::Identifier.parse` consistently with other flavors.
@@ -51,10 +51,5 @@ module Pubid
       end
     end
 
-    module Identifiers
-      # Backward-compatible alias: PLATEAU's base class used to be
-      # Pubid::Plateau::Identifiers::Base. It is now Pubid::Plateau::Identifier.
-      Base = Pubid::Plateau::Identifier
-    end
   end
 end

data/lib/pubid/plateau/identifiers/handbook.rb

@@ -6,7 +6,7 @@ module Pubid
       # PLATEAU Handbook
       # Format: PLATEAU Handbook #NN[-annex] [第X.Y版]
       # Example: PLATEAU Handbook #00 第1.0版
-      class Handbook < Base
+      class Handbook < Identifier
         attribute :edition, :string, default: -> {}
 
         def type_string

data/lib/pubid/plateau/identifiers/technical_report.rb

@@ -6,7 +6,7 @@ module Pubid
       # PLATEAU Technical Report
       # Format: PLATEAU Technical Report #NN[-annex]
       # Example: PLATEAU Technical Report #01
-      class TechnicalReport < Base
+      class TechnicalReport < Identifier
         def type_string
           "Technical Report"
         end

data/lib/pubid/plateau/identifiers.rb

@@ -4,7 +4,6 @@ module Pubid
   module Plateau
     module Identifiers
       autoload :Annex, "#{__dir__}/identifiers/annex"
-      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :Handbook, "#{__dir__}/identifiers/handbook"
       autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
     end

data/lib/pubid/plateau/parser.rb

@@ -21,17 +21,23 @@ module Pubid
       # Number: #00, #01, #46, etc.
       rule(:number) { hash >> digits.as(:number) }
 
-      # Annex: -1, -2, etc.
-      rule(:annex) { dash >> digits.as(:annex) }
+      # Annex: -1, -2, etc. Legacy Latin references use "_" as the sub-number
+      # separator (e.g. "#46_1"); both render as the canonical dash.
+      rule(:annex) { (dash | str("_")) >> digits.as(:annex) }
 
-      # Edition: 第1.0版, 第2.3版, etc. (only for Handbook)
+      # Edition (Handbook only). Canonical form is 第X.Y版; legacy Latin
+      # references write the bare X.Y (e.g. "PLATEAU Handbook #00 1.0"). Both
+      # capture the same numeric :edition slice, so they build the same object
+      # and render to the canonical 第X.Y版.
       rule(:edition_part) do
         str("第") >>
           (digits >> str(".") >> digits).as(:edition) >>
           str("版")
       end
 
-      rule(:edition) { space >> edition_part }
+      rule(:edition_latin) { (digits >> str(".") >> digits).as(:edition) }
+
+      rule(:edition) { space >> (edition_part | edition_latin) }
 
       # Annex supplement: "Annex A", "Annex B", etc.
       rule(:annex_letter) { match["A-Z"].as(:annex_letter) }
@@ -45,6 +51,10 @@ module Pubid
           number >> annex.maybe >> edition.maybe
       end
 
+      # Technical Report has no edition. A legacy Latin TR reference carrying a
+      # trailing edition (e.g. "#00 1.0") is matched by the `handbook` rule
+      # (doc_type matches either keyword, tried first); the builder dispatches
+      # on :type and drops the captured edition for Technical Report.
       rule(:technical_report) do
         publisher >> space >> doc_type >> space >>
           number >> annex.maybe
@@ -52,7 +62,7 @@ module Pubid
 
       # Annex identifier (supplement)
       rule(:annex_identifier) do
-        (handbook | technical_report).as(:base_identifier) >> annex_supplement
+        (handbook | technical_report).as(:base) >> annex_supplement
       end
 
       rule(:identifier) { annex_identifier | handbook | technical_report }

data/lib/pubid/plateau/renderer.rb

@@ -44,7 +44,7 @@ module Pubid
       end
 
       def render_supplement(id)
-        "#{id.base_identifier} #{id.supplement_string}"
+        "#{id.base} #{id.supplement_string}"
       end
     end
   end

data/lib/pubid/plateau/supplement_identifier.rb

@@ -7,7 +7,7 @@ module Pubid
     # Base class for PLATEAU supplements (Annex)
     # Supplements reference a base identifier
     class SupplementIdentifier < Pubid::Identifier
-      attribute :base_identifier, Identifiers::Base
+      attribute :base, Identifier
       attribute :letter, :string, default: -> {}
 
       def publisher
@@ -19,20 +19,20 @@ module Pubid
         raise NotImplementedError, "Subclasses must implement supplement_string"
       end
 
-      # Override base_hash to extract edition, type, and annex from base_identifier
+      # Override base_hash to extract edition, type, and annex from base
       def base_hash
         hash = super
         # For Plateau supplements, edition comes from the base identifier
-        if base_identifier.class.attributes.key?(:edition) && base_identifier.edition
-          hash[:edition] = base_identifier.edition
+        if base.class.attributes.key?(:edition) && base.edition
+          hash[:edition] = base.edition
         end
-        # Include type from base_identifier
-        if base_identifier.class.attributes.key?(:type_string) && base_identifier.type_string
-          hash[:type] = base_identifier.type_string
+        # Include type from base
+        if base.class.attributes.key?(:type_string) && base.type_string
+          hash[:type] = base.type_string
         end
-        # Include annex from base_identifier
-        if base_identifier.class.attributes.key?(:annex) && base_identifier.annex
-          hash[:annex] = base_identifier.annex
+        # Include annex from base
+        if base.class.attributes.key?(:annex) && base.annex
+          hash[:annex] = base.annex
         end
         hash
       end
@@ -60,7 +60,7 @@ module Pubid
       def ==(other)
         return false unless other.class == self.class
 
-        base_identifier == other.base_identifier &&
+        base == other.base &&
           letter == other.letter
       end
     end

data/lib/pubid/plateau.rb

@@ -10,7 +10,7 @@ module Pubid
     PREFIXES = ["PLATEAU"].freeze
 
     autoload :Builder, "#{__dir__}/plateau/builder"
-    autoload :Identifier, "#{__dir__}/plateau/identifier"
+    autoload :Identifier, "#{__dir__}/plateau/identifiers/base"
     autoload :Identifiers, "#{__dir__}/plateau/identifiers"
     autoload :Parser, "#{__dir__}/plateau/parser"
     autoload :Renderer, "#{__dir__}/plateau/renderer"
@@ -27,9 +27,9 @@ module Pubid
     end
 
     # Per-flavor format registry: inherits global formats, overrides :human
-    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifiers::Base.format_registry.register(:human, renderer: Plateau::Renderer)
-    SupplementIdentifier.format_registry = Identifiers::Base.format_registry
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Plateau::Renderer)
+    SupplementIdentifier.format_registry = Identifier.format_registry
 
     # Auto-discover all identifier types from the Identifiers namespace
     # @return [Array<Class>] identifier classes that define a self.type Hash

data/lib/pubid/renderers/human_readable.rb

@@ -3,7 +3,9 @@
 module Pubid
   module Renderers
     class HumanReadable < Base
-      def render(context:, with_edition: false)
+      # `**_opts` absorbs render flags that only some flavors honour (e.g. the
+      # IEEE-specific `:trademark`), so the shared renderer tolerates them.
+      def render(context:, with_edition: false, **_opts)
         parts = []
         parts << render_publisher_and_stage(context)
         parts << render_number_portion(context)

data/lib/pubid/renderers/mr_string.rb

@@ -2,13 +2,55 @@
 
 module Pubid
   module Renderers
+    # Machine-readable string renderer.
+    #
+    # Produces a lossless, dot-separated, all-lowercase, filename-safe slug:
+    #
+    #   iso 9001:2015                       -> iso.9001.2015
+    #   iso/iec 17031-1:2020                -> iso-iec.17031-1.2020
+    #   iso 1234-1-2-3:2020                 -> iso.1234-1-2-3.2020
+    #   iso/tr 14627:2017                   -> iso.tr.14627.2017
+    #   iso 16634:--                        -> iso.16634.--
+    #   iso 9001:2015/amd 1:2020            -> iso.9001.2015_amd.1.2020
+    #   iso/iec 13818-1:2015/amd 3:2016/cor 1:2017
+    #                                       -> iso-iec.13818-1.2015_amd.3.2016_cor.1.2017
+    #
+    # The renderer recurses into a supplement's `base` (one level per
+    # `mr_supplement_suffix`) so chained Cor-Amd-IS structures render fully,
+    # instead of every supplement layer collapsing onto its own
+    # type/number/year and dropping the base (issue #142).
+    #
+    # Character set is restricted to [a-z0-9.-] plus `_` (supplement
+    # separator), so `to_mr_string` doubles as a filesystem-/URL-safe slug.
+    # `Identifier#to_slug` delegates here; NIST is the one flavor that
+    # overrides `to_slug` because its MR shape is fixed by the pubid standard
+    # and stays uppercase.
     class MrString < Base
+      SEPARATOR_SUPPLEMENT = "_"
+
       def render(context: nil, **)
+        suffix = @id.mr_supplement_suffix
+
+        if suffix
+          base = @id.base
+          head = base ? self.class.new(base).render : ""
+          head.empty? ? suffix : "#{head}#{SEPARATOR_SUPPLEMENT}#{suffix}"
+        else
+          render_flat(@id)
+        end
+      end
+
+      private
+
+      def render_flat(id)
         parts = []
-        parts << @id.mr_publisher
-        parts << @id.mr_type
-        parts << @id.mr_number_with_part
-        parts << @id.mr_year
+        parts << id.mr_publisher
+        parts << id.mr_type
+        parts << id.mr_number_with_part
+        parts << id.mr_year
+        parts << id.mr_edition
+        parts << id.mr_languages
+        parts << id.mr_all_parts
         parts.compact.join(".")
       end
     end

data/lib/pubid/renderers/supplement_renderer.rb

@@ -6,7 +6,7 @@ module Pubid
       def render(context:, with_edition: false)
         parts = []
 
-        base_str = @id.base_identifier.to_s(
+        base_str = @id.base.to_s(
           with_edition: with_edition,
           stage_format_long: context.stage_format_long,
           with_date: context.with_date,

data/lib/pubid/rendering/supplement.rb

@@ -4,14 +4,14 @@ module Pubid
   module Rendering
     module Supplement
       # Render supplement identifiers (amendment, corrigendum, addendum, etc.)
-      # @param base_identifier [Identifier] base identifier
+      # @param base [Identifier] base identifier
       # @param supplements [Array<Hash>] list of supplements
       # @param options [Hash] rendering options
       # @return [String] formatted supplement string
-      def render_supplements(base_identifier, supplements, **options)
-        return base_identifier.to_s(**options) unless supplements&.any?
+      def render_supplements(base, supplements, **options)
+        return base.to_s(**options) unless supplements&.any?
 
-        result = base_identifier.to_s(**options)
+        result = base.to_s(**options)
 
         supplements.each do |supp|
           result += render_single_supplement(supp, **options)

data/lib/pubid/sae/builder.rb

@@ -10,7 +10,7 @@ module Pubid
       private
 
       def default_identifier_class
-        Identifiers::Base
+        Identifier
       end
 
       def cast(type, value)

data/lib/pubid/sae/identifier.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
 # Pubid::Sae::Identifier is the SAE base class (a real Pubid::Identifier
-# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
-# live in identifiers/base.rb. This file just ensures it is loaded.
-require_relative "identifiers/base"
+# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.

data/lib/pubid/sae/identifiers/base.rb

@@ -2,8 +2,7 @@
 
 module Pubid
   module Sae
-    # Base SAE Identifier. Canonical name Pubid::Sae::Identifier (Identifiers::Base
-    # is a back-compat alias). SAE has a single identifier class that IS the
+    # Base SAE Identifier. Canonical name Pubid::Sae::Identifier. SAE has a single identifier class that IS the
     # document type, so this class is both the base and the only concrete type.
     # Handles all SAE document types (AMS, AIR, ARP, AS, MA).
     class Identifier < ::Pubid::Identifier
@@ -26,12 +25,16 @@ module Pubid
       def year
         date&.year
       end
-    end
 
-    module Identifiers
-      # Backward-compatible alias: SAE's base class used to be
-      # Pubid::Sae::Identifiers::Base. It is now Pubid::Sae::Identifier.
-      Base = Pubid::Sae::Identifier
+      # SAE encodes the document class (AS, ARP, AMS, AIR, J, …) in `type.abbr`,
+      # not in `typed_stage.type_code`, so the generic mr_type returns nil.
+      # Losslessness requires the type letter to appear in MR — without it,
+      # `SAE J300` and `SAE AS300` would collide on `SAE.300.<year>`.
+      # Lowercased to match the all-lowercase MR convention (issue #142).
+      def mr_type
+        type&.abbr&.to_s&.downcase
+      end
     end
+
   end
 end

data/lib/pubid/sae/identifiers.rb

@@ -3,7 +3,6 @@
 module Pubid
   module Sae
     module Identifiers
-      autoload :Base, "#{__dir__}/identifiers/base"
     end
   end
 end

data/lib/pubid/sae.rb

@@ -10,7 +10,7 @@ module Pubid
 
     autoload :Builder, "#{__dir__}/sae/builder"
     autoload :Components, "#{__dir__}/sae/components"
-    autoload :Identifier, "#{__dir__}/sae/identifier"
+    autoload :Identifier, "#{__dir__}/sae/identifiers/base"
     autoload :Identifiers, "#{__dir__}/sae/identifiers"
     autoload :Parser, "#{__dir__}/sae/parser"
     autoload :Renderer, "#{__dir__}/sae/renderer"
@@ -62,5 +62,5 @@ end
 Pubid::Registry.register(:sae, Pubid::Sae)
 
 # Per-flavor format registry: inherits global formats, overrides :human
-Pubid::Sae::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::Sae::Identifiers::Base.format_registry.register(:human, renderer: Pubid::Sae::Renderer)
+Pubid::Sae::Identifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Sae::Identifier.format_registry.register(:human, renderer: Pubid::Sae::Renderer)