pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/asme/parser.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Asme
+    class Parser < Parslet::Parser
+      # 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/scheme.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          @identifiers ||= [
+            Identifiers::Standard,
+          ].freeze
+        end
+
+        def supplement_identifiers
+          @supplement_identifiers ||= [].freeze
+        end
+
+        def typed_stages
+          @typed_stages ||= [].freeze
+        end
+
+        def supplement_typed_stages
+          @supplement_typed_stages ||= [].freeze
+        end
+
+        def locate_typed_stage_by_abbr(_abbr)
+          raise ArgumentError,
+                "ASME identifiers do not use typed stages"
+        end
+
+        def locate_identifier_klass_by_type_code(_type_code)
+          raise ArgumentError,
+                "ASME identifiers do not use type codes"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/asme/single_identifier.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    class SingleIdentifier < Pubid::Identifier
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+
+      attribute :publisher, :string
+      attribute :code, Components::Code
+      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.code
+          parts << identifier.code.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.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    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 :Scheme, "#{__dir__}/asme/scheme"
+    autoload :SingleIdentifier, "#{__dir__}/asme/single_identifier"
+    autoload :UrnGenerator, "#{__dir__}/asme/urn_generator"
+
+    def self.parse(str)
+      Identifier.parse(str)
+    end
+  end
+end
+
+# Register Uasme flavor with the registry
+Pubid::Registry.register(:asme, Pubid::Asme)

data/lib/pubid/astm/builder.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    class Builder
+      def build(parsed_hash)
+        # Determine identifier class based on type
+        identifier_class = determine_identifier_class(parsed_hash)
+        identifier = identifier_class.new
+
+        # Build code component if present
+        if parsed_hash[:letter] || parsed_hash[:number]
+          identifier.code = build_code(parsed_hash)
+        end
+
+        # Set publisher
+        # Special case: handle "ISO/ASTMTR" type - split into publisher "ISO/ASTM" and type "TR"
+        if parsed_hash[:type]&.to_s == "ISO/ASTMTR"
+          identifier.publisher = "ISO/ASTM"
+        else
+          identifier.publisher = parsed_hash[:publisher].to_s if parsed_hash[:publisher]
+          identifier.publisher ||= "ASTM"
+        end
+
+        # Set year (convert 2-digit to 4-digit)
+        if parsed_hash[:year]
+          identifier.year = convert_year(parsed_hash[:year].to_s)
+        end
+
+        # Set format suffix with dash prefix
+        if parsed_hash[:format_suffix]
+          identifier.format_suffix = "-#{parsed_hash[:format_suffix]}"
+        end
+
+        # Type-specific attributes
+        build_type_specific_attributes(identifier, parsed_hash)
+
+        identifier
+      end
+
+      private
+
+      def determine_identifier_class(parsed_hash)
+        type = parsed_hash[:type]&.to_s
+
+        # Check for ISO/ASTM dual-published standards (5xxxx series)
+        # These are digit-only identifiers starting with "5"
+        # No explicit type, check if it's a digit-only number
+        if (type.nil? || type.empty?) && parsed_hash[:number] && !parsed_hash[:letter]
+          number_str = parsed_hash[:number].to_s
+          # If starts with "5", likely ISO/ASTM dual-published
+          if number_str.start_with?("5")
+            return Identifiers::IsoDualPublished
+          end
+
+          # Other digit-only numbers are still Standard
+          return Identifiers::Standard
+        end
+
+        case type
+        when "RR"
+          Identifiers::ResearchReport
+        when "MNL"
+          Identifiers::Manual
+        when "MONO"
+          Identifiers::Monograph
+        when "DS"
+          Identifiers::DataSeries
+        when "WK"
+          Identifiers::WorkInProgress
+        when "ADJ"
+          Identifiers::Adjunct
+        when "TR"
+          Identifiers::TechnicalReport
+        when "ISO/ASTMTR" # Handle ISO/ASTM Technical Report
+          Identifiers::TechnicalReport
+        else
+          # Default to Standard (A-G prefix)
+          Identifiers::Standard
+        end
+      end
+
+      def build_code(parsed_hash)
+        code = Components::Code.new
+        # Special case: for "TR" type with "ISO/ASTM" publisher, don't set letter
+        # as the "TR" is part of the type/identifier format, not the code letter
+        if parsed_hash[:letter] && !(parsed_hash[:type]&.to_s == "TR" && parsed_hash[:publisher]&.to_s&.start_with?("ISO/ASTM"))
+          code.letter = parsed_hash[:letter].to_s
+        end
+        code.number = parsed_hash[:number].to_s if parsed_hash[:number]
+        code.suffix = parsed_hash[:suffix].to_s if parsed_hash[:suffix]
+        code.subseries = parsed_hash[:subseries].to_s if parsed_hash[:subseries]
+        code.dual_m = true if parsed_hash[:dual_m]
+        code
+      end
+
+      def build_type_specific_attributes(identifier, parsed_hash)
+        # Research Report
+        if identifier.is_a?(Identifiers::ResearchReport) && parsed_hash[:committee]
+          identifier.committee = parsed_hash[:committee].to_s
+        end
+
+        # Manual
+        if identifier.is_a?(Identifiers::Manual)
+          identifier.edition = parsed_hash[:edition].to_s if parsed_hash[:edition]
+          identifier.supplement = true if parsed_hash[:supplement]
+          identifier.tp_designation = parsed_hash[:tp_designation].to_s if parsed_hash[:tp_designation]
+        end
+
+        # Monograph
+        if identifier.is_a?(Identifiers::Monograph) && parsed_hash[:edition]
+          identifier.edition = parsed_hash[:edition].to_s
+        end
+
+        # Data Series
+        if identifier.is_a?(Identifiers::DataSeries) && parsed_hash[:hol_suffix]
+          identifier.hol_suffix = true
+        end
+
+        # Adjunct
+        if identifier.is_a?(Identifiers::Adjunct)
+          identifier.designation = parsed_hash[:designation].to_s if parsed_hash[:designation]
+          identifier.ea_suffix = true if parsed_hash[:ea_suffix]
+          identifier.dvd_suffix = true if parsed_hash[:dvd_suffix]
+        end
+
+        # Standard-specific
+        if identifier.is_a?(Identifiers::Standard)
+          identifier.sub_year = parsed_hash[:sub_year].to_s if parsed_hash[:sub_year]
+          identifier.reapproval = parsed_hash[:reapproval].to_s if parsed_hash[:reapproval]
+          # Handle edition - can be from :edition_number (e1) or :edition (1ST)
+          # The parsed hash can have nested structure: {:edition=>{:edition_number=>"1"}} or {:edition=>"1ST"}
+          edition_data = parsed_hash[:edition]
+          if edition_data
+            if edition_data.is_a?(Hash)
+              # e-notation: {:edition_number=>"1"}
+              identifier.edition = edition_data[:edition_number].to_s if edition_data[:edition_number]
+            else
+              # Ordinal notation: "1ST"
+              identifier.edition = edition_data.to_s
+            end
+          end
+        end
+      end
+
+      def convert_year(year_str)
+        return year_str if year_str.length == 4
+
+        # 2-digit year conversion
+        year_int = year_str.to_i
+        if year_int <= 24
+          "20#{year_str}"
+        else
+          "19#{year_str}"
+        end
+      end
+    end
+  end
+end