pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/asme/parser.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Asme
+    class Parser < ::Pubid::Parser::Grammar
+      # Basic building blocks
+      rule(:space) { str(" ") }
+      # Regular dash, en-dash, em-dash
+      rule(:dash) do
+        str("-") | str("–") | str("—")
+      end
+      rule(:slash) { str("/") }
+      rule(:dot) { str(".") }
+      rule(:digit) { match("[0-9]") }
+      rule(:digits) { digit.repeat(1) }
+      rule(:letter) { match("[A-Z]") }
+      rule(:letters) { letter.repeat(1) }
+      rule(:underscore) { str("_") }
+
+      # Roman numerals (longest first for proper matching - added X)
+      rule(:roman_numeral) do
+        str("XIII") | str("XII") | str("XI") | str("VIII") |
+          str("VII") | str("VI") | str("IV") | str("IX") | str("X") |
+          str("III") | str("II") | str("V") | str("I")
+      end
+
+      # BPVC special letter codes
+      rule(:bpvc_letter_code) do
+        str("NCA") | str("NCD") | str("SSC") | str("BPV") | str("NUC") |
+          str("NB") | str("NC") | str("ND") | str("NE") | str("NF") | str("NG") |
+          letter # Single letter for A, B, C, D, M
+      end
+
+      # BPVC complete subdivision
+      rule(:bpvc_subdivision) do
+        str("BPVC") >>
+          (
+            # Special: COMPLETE CODE BIND
+            (space >> str("COMPLETE CODE BIND")).as(:special) |
+            # Dash notation: BPVC-CC-BPV
+            (dash >> str("CC") >> dash >> bpvc_letter_code.as(:case_code)) |
+            # Standard dotted notation
+            (
+              dot >>
+              (
+                # SSC with complex subdivision: BPVC.SSC.XI.II.V.IX
+                (str("SSC") >> (dot >> roman_numeral).repeat(1).as(:ssc_sections)).as(:ssc_code) |
+                # CC = Case Code: BPVC.CC.BPV or BPVC.CC.NC.XI
+                (str("CC") >> dot >> bpvc_letter_code.as(:case_code) >>
+                 (dot >> (roman_numeral | bpvc_letter_code)).maybe.as(:case_sub)) |
+                # Standard roman numeral subdivision: BPVC.I or BPVC.III.1.NB
+                (roman_numeral.as(:section) >>
+                 (dot >> (digits | bpvc_letter_code).as(:subsection)).maybe >>
+                 (dot >> bpvc_letter_code.as(:sub_subsection)).maybe >>
+                 # Language suffix with underscore: _ES
+                 (underscore >> letters.as(:lang_suffix)).maybe)
+              )
+            ).as(:subdivision)
+          ).as(:bpvc_code)
+      end
+
+      # Multi-character designator codes (updated with EA)
+      rule(:multi_char_code) do
+        str("PVHO") | str("PASE") | str("PTC") | str("PTB") | str("PDS") | str("PCC") |
+          str("V&V") | str("V V") | # Both ampersand and space variants
+          str("VVUQ") |  # Additional V&V variant
+          str("TDP") | str("RTP") | str("RT") |
+          str("RA-S") |  # New: RA-S with dash
+          str("RA") |
+          str("QME") | str("QAI") | str("QEI") |
+          str("NUM") | str("NQA") | str("NML") |
+          str("OM") |
+          str("HST") | str("HRT") |
+          str("FFS") |
+          str("TES") |
+          str("TR") | # Keep TR separate for space-separated pattern
+          str("STS") | # New: STS-1
+          str("CSD") | str("CA") |
+          str("BTH") | str("BPE") |
+          str("ANDE") | str("AED") |
+          str("AG") |
+          str("NM") |  # New: NM.1, NM.2, NM.3
+          str("EA")    # New: EA-3
+      end
+
+      # Publisher patterns
+      rule(:asme_publisher) { str("ASME") }
+      rule(:csa_publisher) { str("CSA") }
+      rule(:api_publisher) { str("API") }
+      rule(:iso_publisher) { str("ISO") }
+      rule(:ans_publisher) { str("ANS") }
+
+      # Joint publisher patterns
+      rule(:iso_asme_publisher) do
+        str("ISO/ASME").as(:joint_publisher) >> space
+      end
+
+      rule(:asme_ans_publisher) do
+        str("ASME/ANS").as(:joint_publisher) >> space
+      end
+
+      rule(:csa_asme_publisher) do
+        csa_publisher.as(:first_publisher) >> space >>
+          match("[A-Z0-9.]").repeat(1).as(:first_code) >>
+          slash >> asme_publisher.as(:second_publisher) >> space
+      end
+
+      rule(:api_asme_publisher) do
+        api_publisher.as(:first_publisher) >> space >>
+          match("[0-9-]").repeat(1).as(:first_code) >>
+          slash >> asme_publisher.as(:second_publisher) >> space
+      end
+
+      # Standard ASME publisher
+      rule(:publisher) { asme_publisher >> space }
+
+      # Designator (longest match first!)
+      rule(:designator) do
+        (
+          bpvc_subdivision |      # Try BPVC patterns first
+          multi_char_code |       # Multi-char codes BEFORE letters
+          str("ISO") |
+          str("CSA") |
+          str("API") |
+          str("ANS") |
+          letters                 # Fallback for single-letter
+        ).as(:designator)
+      end
+
+      # Number part - can start with dot (NM.1), be dotted (16.5), OR dash-separated (BTH-1)
+      rule(:number_part) do
+        (
+          # Starting with dot (for NM.1, VVUQ 20.1, etc.)
+          (dot >> match("[0-9A-Z]").repeat(1) >>
+           (dot >> match("[0-9A-Z]").repeat(1)).repeat) |
+          # Dash-separated first (for BTH-1, CA-1 patterns)
+          (dash >> match("[0-9A-Z]").repeat(1) >>
+           (dot >> match("[0-9A-Z]").repeat(1)).repeat) |
+          # Regular dotted numbers
+          (match("[0-9A-Z]").repeat(1) >>
+           (dot >> match("[0-9A-Z]").repeat(1)).repeat)
+        ).as(:number)
+      end
+
+      # PTC special: space-separated number with optional suffix
+      rule(:ptc_number) do
+        space >>
+          (
+            match("[0-9]").repeat(1) >>
+            (dot >> match("[0-9]").repeat(1)).repeat
+          ).as(:number) >>
+          # Optional space + suffix (like "TW" or "PM")
+          (space >> letters.as(:ptc_suffix)).maybe
+      end
+
+      # TR special: space-separated number (like "ASME TR A17.1-8.4-2013")
+      rule(:tr_number) do
+        space >>
+          (
+            match("[A-Z0-9]").repeat(1) >>
+            (dot >> match("[0-9A-Z]").repeat(1)).repeat >>
+            # Allow dash for patterns like A17.1-8.4
+            (dash >> match("[0-9]").repeat(1) >>
+             (dot >> match("[0-9]").repeat(1)).repeat).maybe
+          ).as(:number)
+      end
+
+      # Number with optional preceding space (for V V 10, V&V 10, VVUQ 20.1, etc.)
+      rule(:spaced_number_part) do
+        space.maybe >> number_part
+      end
+
+      # Year (4-digit)
+      rule(:year_4digit) { digit.repeat(4, 4).as(:year) }
+
+      # Draft year patterns: 20XX, 202X
+      rule(:draft_year) do
+        (str("20XX") | str("202X") | (str("20") >> digit >> str("X"))).as(:draft_year)
+      end
+
+      # Reaffirmation notation
+      rule(:reaffirmation) do
+        space >> str("(R") >> year_4digit.as(:reaffirmation) >> str(")")
+      end
+
+      # CSA dual-published number (for ASME/CSA format)
+      rule(:csa_portion) do
+        slash >> str("CSA") >> space >>
+          (letter >> match("[0-9.]").repeat(1)).as(:csa_number)
+      end
+
+      # Parenthetical revision note after year - different from [Draft ...] notation
+      rule(:parenthetical_revision) do
+        space >> str("(") >>
+          (str("Proposed revision of") | str("Revision of")) >>
+          space >> match("[^)]").repeat(1).as(:ref_standard) >>
+          str(")")
+      end
+
+      # Revision note [Draft Proposed Revision of ...]
+      rule(:revision_note) do
+        space >> str("[") >> match("[^\\]]").repeat(1).as(:revision_note) >> str("]")
+      end
+
+      # Language notation - support both before and after year
+      rule(:language) do
+        space >> str("(") >> letters.as(:language) >> str(")")
+      end
+
+      # Handbook keyword
+      rule(:handbook_keyword) do
+        (space >> str("Handbook")).as(:handbook)
+      end
+
+      # Standard identifier components
+      rule(:standard_components) do
+        publisher >>
+          designator >>
+          number_part.maybe >>
+          (csa_portion | handbook_keyword).maybe >>
+          # Language can come before or after year
+          language.maybe >>
+          (
+            dash >> (draft_year | year_4digit)
+          ).maybe >>
+          language.maybe >>
+          reaffirmation.maybe >>
+          revision_note.maybe
+      end
+
+      # Joint published identifier - CSA first
+      rule(:csa_asme_identifier) do
+        csa_asme_publisher >>
+          designator >>
+          number_part.maybe >>
+          (dash >> (draft_year | year_4digit)).maybe >>
+          language.maybe >>
+          reaffirmation.maybe
+      end
+
+      # Joint published identifier - API first
+      rule(:api_asme_identifier) do
+        api_asme_publisher >>
+          designator >>
+          number_part.maybe >>
+          (dash >> (draft_year | year_4digit)).maybe >>
+          language.maybe >>
+          reaffirmation.maybe
+      end
+
+      # Joint published identifier - ISO/ASME
+      rule(:iso_asme_identifier) do
+        iso_asme_publisher >>
+          number_part >>
+          (dash >> (draft_year | year_4digit)).maybe >>
+          language.maybe >>
+          reaffirmation.maybe
+      end
+
+      # Joint published identifier - ASME/ANS
+      rule(:asme_ans_identifier) do
+        asme_ans_publisher >>
+          designator >>
+          number_part.maybe >>
+          (dash >> (draft_year | year_4digit)).maybe >>
+          language.maybe >>
+          reaffirmation.maybe
+      end
+
+      # Standard ASME identifier
+      rule(:standard) do
+        publisher >>
+          (
+            # Special case for PTC with space-separated number
+            (str("PTC").as(:designator) >> ptc_number >>
+             (dash >> (draft_year | year_4digit)).maybe) |
+            # Special case for TR with space-separated number
+            (str("TR").as(:designator) >> tr_number >>
+             (dash >> (draft_year | year_4digit)).maybe) |
+            # Regular pattern with designator + optional spaced number
+            (designator >> spaced_number_part.maybe >>
+             # CSA portion can be followed by handbook keyword
+             ((csa_portion >> handbook_keyword.maybe) | handbook_keyword).maybe >>
+             # Language can come before or after year
+             language.maybe >>
+             (dash >> (draft_year | year_4digit)).maybe >>
+             language.maybe)
+          ) >>
+          # Parenthetical revision note (after year)
+          parenthetical_revision.maybe >>
+          reaffirmation.maybe >>
+          revision_note.maybe
+      end
+
+      rule(:identifier) do
+        csa_asme_identifier |
+          api_asme_identifier |
+          iso_asme_identifier |
+          asme_ans_identifier |
+          standard
+      end
+
+      root(:identifier)
+    end
+  end
+end

data/lib/pubid/asme/renderer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    # Human-readable renderer for ASME identifiers.
+    #
+    # Produces strings like:
+    #   "ASME B16.5-2020"
+    #   "CSA B44.10/ASME A17.10"
+    #   "ASME BPVC III.1.NB-2023"
+    #   "ASME PTC 4-2013"
+    #
+    # The renderer is registered as the `:human` format in the ASME format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+        parts = []
+
+        if id.first_publisher && id.first_code
+          # CSA B44.10/ASME A17.10 or API 579-2/ASME PTB-14 format
+          parts << id.first_publisher
+          parts << id.first_code
+          parts << "/#{id.second_publisher}" if id.second_publisher
+          parts << id.number.to_s if id.number && id.number.to_s != ""
+        elsif id.joint_publisher
+          # ISO/ASME or ASME/ANS format
+          parts << id.joint_publisher
+          parts << id.number.to_s if id.number && id.number.to_s != ""
+        else
+          # Standard ASME format
+          parts << id.publisher if id.publisher
+          parts << id.number.to_s if id.number
+        end
+
+        result = parts.join(" ")
+
+        if id.ptc_suffix
+          result += " #{id.ptc_suffix}"
+        end
+
+        if id.csa_number
+          result += "/CSA #{id.csa_number}"
+        end
+
+        if id.handbook
+          result += " Handbook"
+        end
+
+        if id.draft_year
+          result += "-#{id.draft_year}"
+        elsif id.year
+          result += "-#{id.year}"
+        end
+
+        result += " #{id.parenthetical_revision}" if id.parenthetical_revision
+        result += " (#{id.language})" if id.language
+        result += " (#{id.reaffirmation})" if id.reaffirmation
+        result += " #{id.revision_note}" if id.revision_note
+
+        # Normalize all em-dashes and en-dashes to regular dash
+        result.gsub(/[–—]/, "-")
+      end
+    end
+  end
+end

data/lib/pubid/asme/single_identifier.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    # Descends from Pubid::Asme::Identifier (the flavor base) so every concrete
+    # ASME identifier is `is_a?(Pubid::Asme::Identifier)`.
+    class SingleIdentifier < Identifier
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+
+      attribute :publisher, :string
+      # The document code lives on the concrete leaf as a single `number`
+      # column holding the WHOLE printed code ("B18.3", "BPVC-CC-BPV") — see
+      # Identifiers::Standard, which explains why it is not split into
+      # designator + number. It cannot be declared here: SingleIdentifier is
+      # inherited by Identifiers::Base and Identifiers::Standard, and
+      # redefining the `number` that ::Pubid::Identifier types as a
+      # Components::Code on an inherited-from class resolves
+      # nondeterministically under multi-flavor load.
+      attribute :year, :string
+      attribute :reaffirmation, :string     # R2020
+      attribute :language, :string          # (SPANISH)
+      attribute :csa_number, :string        # CSA dual-published number
+      attribute :draft_year, :string        # 20XX or 202X for drafts
+      attribute :revision_note, :string     # [Draft Proposed Revision of ...]
+      attribute :parenthetical_revision, :string # (Revision of ASME ...)
+      attribute :handbook, :boolean, default: -> { false } # Handbook flag
+      attribute :ptc_suffix, :string # PTC suffix like "TW" or "PM"
+
+      # Joint published attributes
+      attribute :joint_publisher, :string   # ISO/ASME or ASME/ANS
+      attribute :first_publisher, :string   # CSA or API (when first)
+      attribute :first_code, :string        # Code from first publisher
+      attribute :second_publisher, :string  # ASME (when second)
+    end
+  end
+end

data/lib/pubid/asme/urn_generator.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "asme"]
+
+        special_type = special_identifier_type_component
+        parts << special_type if special_type
+
+        parts << publisher_component
+
+        if identifier.number
+          parts << identifier.number.to_s
+        end
+
+        part = maybe(:part)
+        if part
+          p = part.to_s
+          parts[-1] = "#{parts[-1]}-#{p}"
+        end
+
+        subpart = maybe(:subpart)
+        if subpart
+          sp = subpart.to_s
+          parts[-1] = "#{parts[-1]}-#{sp}"
+        end
+
+        if identifier.draft_year
+          parts << identifier.draft_year.to_s
+        elsif identifier.year
+          parts << identifier.year.to_s
+        end
+
+        edition = maybe(:edition)
+        if edition
+          e = edition.number || edition.to_s
+          parts << "ed.#{e}"
+        end
+
+        if special_type != "ptc" && identifier.ptc_suffix
+          parts << "ptc-suffix.#{identifier.ptc_suffix}"
+        end
+
+        if special_type != "csa" && identifier.csa_number
+          parts << "csa.#{identifier.csa_number}"
+        end
+
+        if identifier.first_publisher
+          parts << "pub1.#{identifier.first_publisher.to_s.downcase}"
+        end
+
+        if identifier.first_code
+          parts << "code1.#{identifier.first_code}"
+        end
+
+        if identifier.second_publisher
+          parts << "pub2.#{identifier.second_publisher.to_s.downcase}"
+        end
+
+        if identifier.joint_publisher
+          parts << "joint.#{identifier.joint_publisher.to_s.downcase}"
+        end
+
+        if identifier.language
+          parts << identifier.language.to_s.downcase
+        end
+
+        if identifier.reaffirmation
+          parts << "reaff.#{identifier.reaffirmation}"
+        end
+
+        if identifier.revision_note
+          parts << "revnote.#{identifier.revision_note}"
+        end
+
+        if identifier.parenthetical_revision
+          parts << "prev.#{identifier.parenthetical_revision}"
+        end
+
+        languages = maybe(:languages)
+        if languages&.any?
+          lang_codes = languages.map(&:code).join(",")
+          parts << lang_codes
+        end
+
+        parts.join(":")
+      end
+
+      private
+
+      def special_identifier_type_component
+        if identifier.handbook
+          return "handbook"
+        end
+
+        if identifier.ptc_suffix
+          return "ptc"
+        end
+
+        if identifier.csa_number
+          return "csa"
+        end
+
+        class_name = identifier.class.name.to_s
+        case class_name
+        when /PTC/
+          "ptc"
+        when /Handbook/
+          "handbook"
+        end
+      end
+
+      def publisher_component
+        pub = "asme"
+
+        if identifier.publisher
+          p = identifier.publisher.to_s
+          pub = p.to_s.downcase
+        end
+
+        copubs = maybe(:copublishers)
+        if copubs&.any?
+          cp = copubs.map(&:to_s)
+          pub = "#{pub}-#{cp.join('-').downcase}"
+        end
+
+        pub
+      end
+    end
+  end
+end

data/lib/pubid/asme/urn_parser.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    # Parses ASME URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:asme:{publisher}:{code}:{year}
+    #
+    # publisher is the lowercase publisher string. code is the alphanumeric
+    # designation (e.g., "B16.5", "PTC1", "BPVC-2023"). The year separator
+    # in human-readable form is `-`, not `:`.
+    #
+    # Examples:
+    # - urn:asme:asme:B16.5:2020   → ASME B16.5-2020
+    # - urn:asme:asme:PTC1:2020    → ASME PTC1-2020
+    # - urn:asme:asme:BPVC-2023    → ASME BPVC-2023
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        _publisher, code, year = parts
+
+        text = "ASME #{code}"
+        text += "-#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/asme.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    extend Pubid::PrefixesSupport
+
+    # Sole ASME publisher token (see the parser's `asme_publisher` rule).
+    PREFIXES = ["ASME"].freeze
+
+    autoload :Builder, "#{__dir__}/asme/builder"
+    autoload :Components, "#{__dir__}/asme/components/code"
+    autoload :Identifier, "#{__dir__}/asme/identifier"
+    autoload :Identifiers, "#{__dir__}/asme/identifiers"
+    autoload :Parser, "#{__dir__}/asme/parser"
+    autoload :Renderer, "#{__dir__}/asme/renderer"
+    autoload :SingleIdentifier, "#{__dir__}/asme/single_identifier"
+    autoload :UrnGenerator, "#{__dir__}/asme/urn_generator"
+    autoload :UrnParser, "#{__dir__}/asme/urn_parser"
+
+    def self.parse(str)
+      Identifier.parse(str)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    SingleIdentifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    SingleIdentifier.format_registry.register(:human, renderer: Asme::Renderer)
+
+    # 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 Uasme flavor with the registry
+Pubid::Registry.register(:asme, Pubid::Asme)