pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/ashrae/renderer.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    # Human-readable renderer for ASHRAE identifiers.
+    #
+    # Produces strings like:
+    #   "ASHRAE Standard 15-2024"
+    #   "ASHRAE Guideline 0-2019"
+    #   "ASHRAE Addendum a to Standard 15-2001"
+    #   "ASHRAE Standard 52.2-1999: Addenda Supplement Package"
+    #   "ASHRAE Addenda c and d to Standard 15-1994"
+    #   "ASHRAE Guideline 0-2005 Errata (September 28, 2011)"
+    #   "Interpretations for Standard 15.2-2022"
+    #
+    # The renderer is registered as the +:human+ format in the ASHRAE format
+    # registry and invoked via +render(format: :human)+.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        id = @id
+
+        case id
+        when Identifiers::Addendum
+          render_addendum(id)
+        when Identifiers::AddendaPackage
+          render_addenda_package(id)
+        when Identifiers::CombinedAddenda
+          render_combined_addenda(id)
+        when Identifiers::Errata
+          render_errata(id)
+        when Identifiers::Interpretation
+          render_interpretation(id)
+        when SingleIdentifier
+          render_single(id)
+        else
+          render_single(id)
+        end
+      end
+
+      private
+
+      # SingleIdentifier (Standard, Guideline): "ASHRAE Standard 15-2024"
+      def render_single(id)
+        parts = []
+        parts << id.publisher if id.publisher
+        parts << id.type.to_s if id.type
+        result = parts.join(" ")
+        result += " " if result.length.positive?
+        result += id.number.to_s
+        result += "-#{id.year}" if id.year
+        result += " (#{id.amendment})" if id.amendment
+        result += id.suffix if id.suffix
+        result += " (RA#{id.reaffirmed})" if id.reaffirmed
+        result
+      end
+
+      # Addendum: "ASHRAE Addendum a to Standard 15-2001"
+      def render_addendum(id)
+        return id.base.to_s unless id.base
+
+        base_type = id.base.type || "Standard"
+
+        if id.copublisher
+          "#{id.copublisher} Addendum #{id.addendum_code} to #{id.base}"
+        else
+          result = "ASHRAE Addendum #{id.addendum_code} to #{base_type} #{id.base.number}"
+          result += "-#{id.base.year}" if id.base.year
+          result
+        end.tap { |r| r << " (#{id.addendum_date})" if id.addendum_date }
+      end
+
+      # AddendaPackage: "ASHRAE Standard 52.2-1999: Addenda Supplement Package"
+      def render_addenda_package(id)
+        return id.base.to_s unless id.base
+
+        result = "ASHRAE #{id.base.type || 'Standard'} #{id.base.number}"
+        result += "-#{id.base.year}" if id.base.year
+        result += ": Addenda #{id.package_description}" if id.package_description
+        result
+      end
+
+      # CombinedAddenda: "ASHRAE Addenda c and d to Standard 15-1994"
+      def render_combined_addenda(id)
+        return id.base.to_s unless id.base
+
+        base_type = id.base.type || "Standard"
+        if id.addendum_codes
+          result = "ASHRAE Addenda #{id.addendum_codes} to #{base_type} #{id.base.number}"
+        else
+          result = "ASHRAE Addenda to #{base_type} #{id.base.number}"
+        end
+        result += "-#{id.base.year}" if id.base.year
+        result
+      end
+
+      # Errata: "ASHRAE Guideline 0-2005 Errata (September 28, 2011)"
+      def render_errata(id)
+        return id.base.to_s unless id.base
+
+        result = id.base.to_s
+        result += " Errata"
+        result += " (#{id.errata_date})" if id.errata_date
+        result
+      end
+
+      # Interpretation: "Interpretations for Standard 15.2-2022"
+      def render_interpretation(id)
+        return id.base.to_s unless id.base
+
+        base_type = id.base.type || "Standard"
+        result = "Interpretations for #{base_type} #{id.base.number}"
+        result += "-#{id.base.year}" if id.base.year
+        result
+      end
+    end
+  end
+end

data/lib/pubid/ashrae/single_identifier.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    # Base class for single (non-supplement) ASHRAE identifiers
+    # Includes: Guideline, Standard
+    class SingleIdentifier < Identifier
+    end
+  end
+end

data/lib/pubid/ashrae/supplement_identifier.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Ashrae
+    # Base class for supplement identifiers (addendums, errata, interpretations)
+    # Supplements modify or add to a base document
+    class SupplementIdentifier < Identifier
+      attribute :base, Identifier, polymorphic: true
+
+      # Delegate publisher to base
+      def publisher
+        base&.publisher
+      end
+
+      # Delegate the document code to the base standard.
+      #
+      # The BODY had to move with the `code` -> `number` rename — it was
+      # `base&.code`, and `code` no longer exists anywhere in the hierarchy, so
+      # it raised NoMethodError on every Errata/Addendum/CombinedAddenda/
+      # AddendaPackage/Interpretation. Nothing inside lib/pubid/ashrae calls
+      # it, which is exactly why the suite stayed green while a public method
+      # on five types was broken.
+      #
+      # The NAME deliberately stays `code`. Renaming it to `number` looks
+      # tidier and is wrong twice over: `number` is an inherited lutaml
+      # attribute typed Components::Code, so a String-returning method of that
+      # name makes `to_hash` raise IncorrectModelError on every supplement —
+      # and even typed correctly it would serialize a duplicate of the base's
+      # number onto the wrapper. `code` is not an attribute anywhere, so it is
+      # free to be a plain reader. Use `#root.number` for the index key.
+      def code
+        base&.number
+      end
+    end
+  end
+end

data/lib/pubid/ashrae/urn_generator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      # A supplement carries no number of its own — only the two
+      # single-document leaves declare one — so reach it through #root, which
+      # walks `base` to the standard the supplement attaches to. Without the
+      # fallback every Errata/Addendum URN lost its number when `code` moved
+      # off the shared base onto the leaves.
+      def urn_number
+        num = identifier.number || identifier.root.number
+        return nil if num.nil? || num.to_s.empty?
+
+        num.to_s
+      end
+
+      def urn_suffix
+        identifier.suffix&.to_s&.downcase
+      end
+
+      def urn_amendment
+        "amd.#{identifier.amendment}" if identifier.amendment
+      end
+
+      def urn_reaffirmed
+        "reaff.#{identifier.reaffirmed}" if identifier.reaffirmed
+      end
+
+      def urn_copublisher
+        "copub.#{identifier.copublisher.to_s.downcase}" if identifier.copublisher
+      end
+
+      def urn_addendum
+        val = maybe(:addendum)
+        "add.#{val}" if val
+      end
+
+      def generate
+        parts = ["urn", "ashrae"]
+        parts << urn_number if urn_number
+        parts << urn_year if urn_year
+        parts << identifier.type.to_s.downcase if identifier.type
+        parts << urn_suffix if urn_suffix
+        parts << urn_amendment if urn_amendment
+        parts << urn_reaffirmed if urn_reaffirmed
+        parts << urn_copublisher if urn_copublisher
+
+        parts[1] = identifier.publisher.to_s.downcase if identifier.publisher
+
+        parts << urn_addendum if urn_addendum
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/ashrae/urn_parser.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    # Parses ASHRAE URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:ashrae:{number}:{year}:{type}[:{suffix}][:amd.{N}][:reaff.{Y}]
+    #
+    # The type token follows the year; the human-readable form prefixes the
+    # type ("ASHRAE Standard 90.1-2019"). The year separator is `-`.
+    #
+    # Examples:
+    # - urn:ashrae:90.1:2019:standard → ASHRAE Standard 90.1-2019
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        number, year = parts
+        text = "ASHRAE Standard #{number}"
+        text += "-#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/ashrae.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    extend Pubid::PrefixesSupport
+
+    # ASHRAE publisher token; the ANSI/ASHRAE joint form comes from
+    # Pubid::JOINT_PREFIXES.
+    PREFIXES = ["ASHRAE"].freeze
+
+    autoload :Builder, "#{__dir__}/ashrae/builder"
+    autoload :Identifier, "#{__dir__}/ashrae/identifiers/base"
+    autoload :Identifiers, "#{__dir__}/ashrae/identifiers"
+    autoload :Parser, "#{__dir__}/ashrae/parser"
+    autoload :Renderer, "#{__dir__}/ashrae/renderer"
+    autoload :SingleIdentifier, "#{__dir__}/ashrae/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/ashrae/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/ashrae/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ashrae/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
+
+      Identifier.parse(identifier)
+    end
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+# Register Uashrae flavor with the registry
+Pubid::Registry.register(:ashrae, Pubid::Ashrae)
+
+# Per-flavor format registry: inherits global formats, overrides :human
+Pubid::Ashrae::Identifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Ashrae::Identifier.format_registry.register(:human, renderer: Pubid::Ashrae::Renderer)

data/lib/pubid/asme/builder.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    class Builder
+      def build(parsed_hash)
+        identifier = Identifiers::Standard.new
+
+        # Handle joint publishers
+        if parsed_hash[:joint_publisher]
+          identifier.joint_publisher = parsed_hash[:joint_publisher].to_s
+          identifier.publisher = parsed_hash[:joint_publisher].to_s
+        elsif parsed_hash[:first_publisher]
+          # CSA/ASME or API/ASME format
+          identifier.first_publisher = parsed_hash[:first_publisher].to_s
+          identifier.first_code = parsed_hash[:first_code].to_s
+          identifier.second_publisher = parsed_hash[:second_publisher].to_s
+          identifier.publisher = "#{parsed_hash[:first_publisher]}/#{parsed_hash[:second_publisher]}"
+        else
+          # Standard ASME
+          identifier.publisher = "ASME"
+        end
+
+        # The code is stored as flat index columns on the leaf (see
+        # Identifiers::Standard) — `number` is what relaton-index keys on — so
+        # the Code built below is unpacked rather than assigned.
+        if parsed_hash[:designator]
+          identifier.number = build_code(parsed_hash).to_s
+        elsif parsed_hash[:number]
+          # A joint-published reference ("ISO/ASME 14414-2015") parses to a bare
+          # `number` with no designator. The designator-only guard above dropped
+          # it, so the document number was lost from BOTH the identifier and its
+          # rendering: `to_s` was "ISO/ASME-2015". Pre-existing; recovering it
+          # is what gives these ids an index key.
+          identifier.number = parsed_hash[:number].to_s
+        end
+
+        # Set PTC suffix
+        if parsed_hash[:ptc_suffix]
+          identifier.ptc_suffix = parsed_hash[:ptc_suffix].to_s
+        end
+
+        # Set year
+        if parsed_hash[:year]
+          identifier.year = parsed_hash[:year].to_s
+        end
+
+        # Set draft year
+        if parsed_hash[:draft_year]
+          identifier.draft_year = parsed_hash[:draft_year].to_s
+        end
+
+        # Set reaffirmation
+        if parsed_hash[:reaffirmation]
+          identifier.reaffirmation = "R#{parsed_hash[:reaffirmation]}"
+        end
+
+        # Set language (including lang_suffix from BPVC)
+        if parsed_hash[:language]
+          identifier.language = parsed_hash[:language].to_s
+        elsif parsed_hash[:lang_suffix]
+          identifier.language = parsed_hash[:lang_suffix].to_s
+        end
+
+        # Set CSA number (for ASME/CSA format)
+        if parsed_hash[:csa_number]
+          identifier.csa_number = parsed_hash[:csa_number].to_s
+        end
+
+        # Set handbook flag
+        if parsed_hash[:handbook]
+          identifier.handbook = true
+        end
+
+        # Set revision note
+        if parsed_hash[:revision_note]
+          identifier.revision_note = "[#{parsed_hash[:revision_note]}]"
+        end
+
+        # Set parenthetical revision
+        if parsed_hash[:ref_standard]
+          # Extract the type of revision (Revision/Proposed revision)
+          ref = parsed_hash[:ref_standard].to_s
+          if parsed_hash[:ref_standard].to_s =~ /^(Proposed revision|Revision) of (.+)$/
+            identifier.parenthetical_revision = "(#{$1} of #{$2})"
+          else
+            identifier.parenthetical_revision = "(Revision of #{ref})"
+          end
+        end
+
+        identifier
+      end
+
+      private
+
+      def build_code(parsed_hash)
+        # Handle BPVC subdivision
+        if parsed_hash[:designator].is_a?(Hash) && parsed_hash[:designator][:bpvc_code]
+          bpvc_data = parsed_hash[:designator][:bpvc_code]
+
+          # Build BPVC designator string
+          designator_str = "BPVC"
+
+          if bpvc_data[:special]
+            # BPVC COMPLETE CODE BIND
+            designator_str = "BPVC COMPLETE CODE BIND"
+          elsif bpvc_data[:subdivision] && bpvc_data[:subdivision][:ssc_code]
+            # BPVC.SSC.XI.II.V.IX pattern
+            ssc_sections = bpvc_data[:subdivision][:ssc_sections]
+            sections_str = if ssc_sections.is_a?(Array)
+                             ssc_sections.join(".")
+                           else
+                             ssc_sections.to_s
+                           end
+            designator_str = "BPVC.SSC.#{sections_str}"
+          elsif bpvc_data[:subdivision] && bpvc_data[:subdivision][:case_code]
+            # BPVC.CC.BPV or BPVC.CC.NC.XI - extract from subdivision hash
+            cc = bpvc_data[:subdivision][:case_code].to_s
+            case_sub = bpvc_data[:subdivision][:case_sub]&.to_s
+
+            designator_str = case_sub && !case_sub.empty? ? "BPVC.CC.#{cc}.#{case_sub}" : "BPVC.CC.#{cc}"
+          elsif bpvc_data[:case_code]
+            # Dash notation: BPVC-CC-BPV
+            cc = bpvc_data[:case_code].to_s
+            designator_str = "BPVC-CC-#{cc}"
+          elsif bpvc_data[:subdivision]
+            # Standard subdivision
+            section = bpvc_data[:subdivision][:section].to_s
+            subsection = bpvc_data[:subdivision][:subsection].to_s
+            sub_subsection = bpvc_data[:subdivision][:sub_subsection].to_s
+            lang_suffix = bpvc_data[:subdivision][:lang_suffix].to_s
+
+            parts = [section, subsection, sub_subsection].reject do |p|
+              p.nil? || p.empty?
+            end
+            designator_str = "BPVC.#{parts.join('.')}"
+            designator_str += "_#{lang_suffix}" if !lang_suffix.empty?
+          else
+            # Fallback (shouldn't reach here)
+            designator_str = "BPVC"
+          end
+          number_str = ""
+
+          return Components::Code.new(designator: designator_str,
+                                      number: number_str)
+        end
+
+        # For joint published, handle special cases
+        designator_str = parsed_hash[:designator].to_s
+
+        # Normalize "V V" to "V&V"
+        designator_str = "V&V" if designator_str == "V V"
+
+        # Existing code for non-BPVC designators
+        code = Components::Code.new
+        code.designator = designator_str
+        code.number = parsed_hash[:number].to_s if parsed_hash[:number]
+        code
+      end
+    end
+  end
+end

data/lib/pubid/asme/components/code.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Asme
+    module Components
+      # Code component for ASME identifiers.
+      #
+      # Stays independent of Pubid::Components::Code because ASME uses
+      # +designator+ (a flavor-specific letter prefix) plus +number+.
+      class Code < Lutaml::Model::Serializable
+        attribute :designator, :string
+        attribute :number, :string
+
+        def to_s
+          render
+        end
+
+        def render(context: nil)
+          "#{designator}#{number}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/asme/identifier.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    class Identifier < Pubid::Identifier
+      def self.parse(str)
+        unless str.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if str.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parser = Parser.new
+        builder = Builder.new
+
+        parsed = parser.parse(str)
+        builder.build(parsed)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    module Identifiers
+      class Base < SingleIdentifier
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    module Identifiers
+      class Standard < Base
+        # --- Index columns -------------------------------------------------
+        #
+        # relaton-index sorts and bsearches every row on
+        # `id.root.number.to_s`. ASME used to keep the code inside an
+        # Asme::Components::Code under a `code` attribute, leaving the
+        # inherited `number` nil and every row keyed "".
+        #
+        # `number` holds the WHOLE printed code — "B18.3", "A112.19.12",
+        # "BPVC-CC-BPV" — not a designator/number split.
+        #
+        # The split looks tempting (it is what IEEE does) but it cannot key
+        # this corpus: 152 of the 731 fixture ids are Boiler and Pressure
+        # Vessel Code documents whose entire identity IS the designator
+        # ("BPVC COMPLETE CODE BIND", "BPVC.CC.BPV") with no numeric part at
+        # all. Splitting leaves every one of them with an empty key, and
+        # inventing a number for them would be inventing data.
+        #
+        # Nothing is lost by joining: Components::Code#render is a plain
+        # concatenation of designator and number, and the only readers of
+        # `code` anywhere in lib/pubid/asme are `code.to_s` (renderer.rb,
+        # urn_generator.rb). Keying on the whole code also clusters editions of
+        # one document, which is what relaton narrows on — an ASME reference is
+        # always written "ASME B18.3", never "18.3" alone.
+        #
+        # LANDMINE: `number` redefines the Components::Code attribute inherited
+        # from ::Pubid::Identifier, which resolves nondeterministically when
+        # declared on a class others inherit from. Standard is the only
+        # concrete ASME type and has no subclasses, so it is declared here and
+        # never on SingleIdentifier / Identifiers::Base.
+        # spec/pubid/asme/root_number_spec.rb carries the tripwire and is only
+        # meaningful under the full `rake` suite.
+        # There is deliberately no `#code` reader here. An earlier draft had one
+        # composing `Components::Code.new(number: number)` so the renderer and
+        # the URN generator would not have to change — but because `number`
+        # holds the whole printed code, that Code never carried a designator and
+        # `code.to_s` equalled `number` for all 731 corpus ids. It wrapped a
+        # string in an object whose only job was to unwrap to the same string.
+        # Both readers now use `number` directly.
+        #
+        # ASTM keeps its composed `#code` (Identifiers::CodeNumber) for the
+        # opposite reason: its renderer reads `code.letter` / `code.dual_m`
+        # field-by-field, so the component there carries real structure.
+        attribute :number, :string
+
+        # MR slug. Before the index column landed, every ASME slug was just
+        # "asme": 722 of 731 documents shared one filename, and `to_slug` is
+        # what consumers use as an output filename.
+        #
+        # `handbook` is identity-bearing — it is in the serialized hash and in
+        # `==`, and "ASME A17.1/CSA B44-2019" and "ASME A17.1/CSA B44
+        # Handbook-2019" are different documents — so it has to reach the slug
+        # too. CLAUDE.md's rule: a marker that only reaches `==` still lets two
+        # documents share a filename.
+        def mr_number_with_part
+          mr_join(mr_sanitize(number), (handbook ? "handbook" : nil))
+        end
+
+        # ASME keeps its edition in a plain `year` string, not the inherited
+        # `date`, so the base `mr_year` hook read nil and every edition of one
+        # standard shared a slug.
+        def mr_year
+          year&.to_s
+        end
+
+        # ASME keeps a translation marker in a plain `language` string, not the
+        # inherited `languages` collection the base hook reads. Without this,
+        # "ASME B31.8-2016" and its Spanish edition "ASME B31.8 (SPANISH)-2016"
+        # — different documents, and #== agrees — share one filename.
+        def mr_languages
+          language&.to_s&.downcase
+        end
+
+        # An ASME code legitimately contains "." (B18.3), "-" (BPVC-CC-BPV),
+        # "&" (V&V) and spaces ("BPVC COMPLETE CODE BIND"). Renderers::MrString
+        # joins SEGMENTS with ".", so a dot inside one breaks that structure —
+        # filter by charset, the BIPM `mr_slug` precedent, rather than by an
+        # enumerated escape list. The output emptiness check matters: a value
+        # made only of out-of-charset characters collapses to "", which is
+        # truthy in Ruby and would reach the renderer as a blank segment.
+        def mr_sanitize(value)
+          return nil if value.nil? || value.to_s.empty?
+
+          sanitized = value.to_s.downcase
+            .gsub(/[^a-z0-9-]+/, "-").gsub(/\A-+|-+\z/, "")
+          sanitized.empty? ? nil : sanitized
+        end
+      end
+    end
+  end
+end

data/lib/pubid/asme/identifiers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    module Identifiers
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+    end
+  end
+end