pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/astm/parser.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Astm
+    class Parser < ::Pubid::Parser::Grammar
+      # Basic building blocks
+      rule(:space) { str(" ") }
+      rule(:dash) { str("-") }
+      rule(:slash) { str("/") }
+      rule(:colon) { str(":") }
+      rule(:dot) { str(".") }
+      rule(:digit) { match("[0-9]") }
+      rule(:digits) { digit.repeat(1) }
+      rule(:letter) { match("[A-Z]") }
+      rule(:letters) { letter.repeat(1) }
+
+      # Publisher
+      rule(:publisher) { str("ASTM").as(:publisher) >> space.maybe }
+
+      # Letters A-G for standard types
+      rule(:standard_letter) { match("[A-G]").as(:letter) }
+
+      # Year patterns (2-digit)
+      rule(:year_2digit) { digit.repeat(2, 2).as(:year) }
+
+      # Reapproval notation (may have comment after)
+      rule(:reapproval) do
+        str("(") >> digit.repeat(4, 4).as(:reapproval) >> str(")")
+      end
+
+      # Comment portion (anything after #)
+      rule(:comment) { space.maybe >> str("#") >> match("[^#]").repeat }
+
+      # Edition notations - supports both ordinal (1ST, 2ND) and e-notation (e1, e2)
+      # For e-notation, capture just the digits (not the 'e' prefix)
+      # For ordinal notation, capture the whole string
+      rule(:edition) do
+        (
+          (str("e") >> digits.as(:edition_number)) |
+          str("9TH") | str("8TH") | str("7TH") | str("6TH") |
+          str("5TH") | str("4TH") | str("3RD") | str("2ND") |
+          str("1ST")
+        ).as(:edition)
+      end
+
+      # Sub-year notation (a, b, c)
+      rule(:sub_year) { match("[a-c]").as(:sub_year) }
+
+      # Format suffix
+      rule(:format_suffix) { dash >> str("EB").as(:format_suffix) }
+
+      # Format suffix without dash (for use after supplement which ends with dash)
+      rule(:format_suffix_no_dash) { str("EB").as(:format_suffix) }
+
+      # Supplement notation (ends with dash)
+      rule(:supplement) { dash >> str("SUP").as(:supplement) >> dash }
+
+      # ========================================
+      # Research Report - MOST SPECIFIC (has colon)
+      # ========================================
+      rule(:research_report) do
+        publisher.maybe >>
+          str("RR").as(:type) >>
+          colon >>
+          (letter >> digit.repeat(2, 2)).as(:committee) >>
+          dash >>
+          digits.as(:number)
+      end
+
+      # ========================================
+      # Manual
+      # ========================================
+      rule(:manual) do
+        publisher.maybe >>
+          str("MNL").as(:type) >>
+          str("TP").as(:tp_designation).maybe >>
+          digits.as(:number) >>
+          (dash >> edition).maybe >>
+          (
+            (supplement >> format_suffix_no_dash.maybe) |
+            format_suffix.maybe
+          )
+      end
+
+      # ========================================
+      # Monograph
+      # ========================================
+      rule(:monograph) do
+        publisher.maybe >>
+          str("MONO").as(:type) >>
+          digits.as(:number) >>
+          (dash >> edition).maybe >>
+          format_suffix.maybe
+      end
+
+      # ========================================
+      # Data Series
+      # ========================================
+      rule(:data_series_suffix) { match("[A-Z]").as(:suffix) }
+      # Subseries can be: -S4 OR S4 (when following a letter suffix)
+      rule(:data_series_subseries_with_dash) do
+        dash >> str("S") >> digits.as(:subseries)
+      end
+      rule(:data_series_subseries_no_dash) do
+        digits.as(:subseries) # Directly after letter suffix
+      end
+      rule(:data_series_code) do
+        digits.as(:number) >>
+          (
+            str("HOL").as(:hol_suffix) |
+            (data_series_suffix >> data_series_subseries_no_dash.maybe) |
+            data_series_subseries_with_dash
+          ).maybe
+      end
+
+      rule(:data_series) do
+        publisher.maybe >>
+          str("DS").as(:type) >>
+          data_series_code >>
+          format_suffix.maybe
+      end
+
+      # ========================================
+      # Work in Progress
+      # ========================================
+      rule(:work_in_progress) do
+        publisher.maybe >>
+          str("WK").as(:type) >>
+          digits.as(:number)
+      end
+
+      # ========================================
+      # Adjunct
+      # ========================================
+      # SEMANTIC NOTE: Adjunct identifiers reference a base standard
+      # Structure: ADJ + base_standard_code + adjunct_designation
+      # Examples:
+      #   ADJF3504-EA: Adjunct to F3504, EA = Excel file format
+      #   ADJC033501: Adjunct "01" to C335
+      #   ADJC0450A: Adjunct format "A" to C450
+      #   ADJE11211T: Adjunct "11T" to E112
+      #   ADJDQCALC: Adjunct with text designation (not to numbered standard)
+      # Adjunct formats: EA (Excel), E-PDF, A1A2 (arbitrary identifiers)
+      # One standard can have multiple adjuncts
+      rule(:adjunct) do
+        publisher.maybe >>
+          str("ADJ").as(:type) >>
+          ((letter >> digits) | letters | digits).as(:designation) >>
+          (dash >> str("EA")).maybe.as(:ea_suffix) >>
+          str("DVD").maybe.as(:dvd_suffix)
+      end
+
+      # ========================================
+      # Technical Report
+      # ========================================
+      rule(:technical_report_iso_astm) do
+        str("ISO/ASTMTR").as(:type) >>
+          digits.as(:number) >>
+          format_suffix.maybe >>
+          comment.maybe
+      end
+
+      rule(:technical_report_simple) do
+        publisher.maybe >>
+          str("TR").as(:type) >>
+          digits.as(:number) >>
+          format_suffix.maybe >>
+          comment.maybe
+      end
+
+      rule(:technical_report) do
+        technical_report_iso_astm | technical_report_simple
+      end
+
+      # ========================================
+      # Standard (DEFAULT - handles A-G prefix AND digit-only E-standards)
+      # ========================================
+
+      # SEMANTIC NOTE: 5xxxx digit-only standards are ISO/ASTM dual-published
+      # Examples:
+      #   ASTM 52303-24e1: ASTM's version (e1 = edition 1, not "E" prefix)
+      #   ISO/ASTM 52303:2024: ISO's published version of the same document
+      # These should semantically be IsoDualPublishedIdentifier or similar
+      # Parser currently accepts them as digit-only standards
+
+      # NOTE: Reference Radiographs (RR) are a separate document type not yet implemented
+      # Examples:
+      #   RRE341903: Reference radiograph for standard E3419
+      #   RRE015501: Reference radiograph, volume 1
+      #   RRE2669CS: Adjunct to E2669 reference radiograph
+      # These require separate ReferenceRadiograph identifier class
+
+      # Dual unit pattern: F1862/F1862M
+      rule(:dual_unit) do
+        slash >>
+          standard_letter >>
+          digits >>
+          str("M").as(:dual_m)
+      end
+
+      rule(:standard_code_with_letter) do
+        standard_letter >>
+          digits.as(:number) >>
+          dual_unit.maybe
+      end
+
+      # Digit-only standards (primarily 5xxxx ISO/ASTM dual-published)
+      # Parsed as digit-only, semantic meaning is dual-published with ISO
+      rule(:standard_code_digit_only) do
+        digits.as(:number) # Accept digit-only, no implicit E prefix
+      end
+
+      rule(:standard) do
+        publisher.maybe >>
+          (standard_code_with_letter | standard_code_digit_only) >>
+          (
+            dash >> year_2digit >>
+            sub_year.maybe >>
+            reapproval.maybe >>
+            edition.maybe
+          ).maybe >>
+          comment.maybe
+      end
+
+      # ========================================
+      # Main identifier rule - ORDER MATTERS!
+      # ========================================
+      rule(:identifier) do
+        research_report | # Most specific (has colon)
+          technical_report |      # Has TR prefix
+          manual |                # Has MNL prefix
+          monograph |             # Has MONO prefix
+          data_series |           # Has DS prefix
+          work_in_progress |      # Has WK prefix
+          adjunct |               # Has ADJ prefix
+          standard                # DEFAULT (A-G letter)
+      end
+
+      root(:identifier)
+    end
+  end
+end

data/lib/pubid/astm/renderer.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    # Human-readable renderer for ASTM identifiers.
+    #
+    # Consolidates the per-type rendering logic that used to live inline on
+    # each identifier class. Produces strings like:
+    #   "ASTM E2938-15"
+    #   "ASTM RR:A01-1234"
+    #   "ASTM MNL45-EB"
+    #   "ASTM ADJD2148"
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::Standard
+          render_standard(id)
+        when Identifiers::IsoDualPublished
+          render_standard(id)
+        when Identifiers::ResearchReport
+          render_research_report(id)
+        when Identifiers::DataSeries
+          render_data_series(id)
+        when Identifiers::TechnicalReport
+          render_technical_report(id)
+        when Identifiers::Monograph
+          render_monograph(id)
+        when Identifiers::Adjunct
+          render_adjunct(id)
+        when Identifiers::WorkInProgress
+          render_work_in_progress(id)
+        when Identifiers::Manual
+          render_manual(id)
+        else
+          render_single(id)
+        end
+      end
+
+      private
+
+      def render_single(id)
+        parts = []
+        parts << id.publisher if id.publisher
+        parts << id.prefix if id.class.attributes.key?(:prefix) && id.prefix
+        parts << id.code.to_s if id.code
+        parts << "-#{id.year}" if id.year
+        parts << id.format_suffix if id.format_suffix
+        parts.join(" ")
+      end
+
+      def render_standard(id)
+        parts = []
+        parts << id.publisher if id.publisher
+
+        if id.code
+          code_str = id.code.to_s
+          if id.code.dual_m
+            base_code = "#{id.code.letter}#{id.code.number}"
+            code_str = "#{base_code}/#{base_code}M"
+          end
+          parts << code_str
+        end
+
+        result = parts.join(" ")
+
+        if id.year
+          result += "-#{year_portion(id)}"
+          result += id.sub_year if id.sub_year
+        end
+
+        result += "(#{id.reapproval})" if id.reapproval
+        result += "e#{id.edition}" if id.edition
+
+        result
+      end
+
+      def year_portion(id)
+        year_str = id.year.to_s
+        year_str.length == 4 ? year_str[-2..] : year_str
+      end
+
+      def render_research_report(id)
+        parts = []
+        parts << id.publisher if id.publisher
+        parts << "RR:#{id.committee}-#{id.code.number}" if id.committee && id.code
+        parts.join(" ")
+      end
+
+      def render_data_series(id)
+        parts = []
+        parts << id.publisher if id.publisher
+
+        result = parts.join(" ")
+        result += " " if id.publisher && !result.end_with?(" ")
+
+        result += "DS"
+        result += id.code.to_s if id.code
+        result += "HOL" if id.hol_suffix
+        result += id.format_suffix if id.format_suffix
+        result
+      end
+
+      def render_technical_report(id)
+        if id.publisher == "ISO/ASTM" && (id.code.nil? || id.code.letter.nil?)
+          result = "ISO/ASTMTR"
+        else
+          result = "TR"
+          result += id.code.letter if id.code&.letter
+        end
+        result += id.code.number if id.code&.number
+        result += id.format_suffix if id.format_suffix
+        result
+      end
+
+      def render_monograph(id)
+        parts = []
+        parts << id.publisher if id.publisher
+
+        result = parts.join(" ")
+        result += " " if id.publisher && !result.end_with?(" ")
+
+        result += "MONO"
+        result += id.code.number if id.code
+        result += "-#{id.edition}" if id.edition
+        result += id.format_suffix if id.format_suffix
+        result
+      end
+
+      def render_adjunct(id)
+        result = []
+        result << id.publisher if id.publisher && !id.ea_suffix && !id.dvd_suffix
+        result << "ADJ#{id.number}#{'-EA' if id.ea_suffix}#{'DVD' if id.dvd_suffix}"
+        result.compact.join(" ")
+      end
+
+      def render_work_in_progress(id)
+        parts = []
+        parts << id.publisher if id.publisher
+
+        result = parts.join(" ")
+        result += " " if id.publisher && !result.end_with?(" ")
+
+        result += "WK"
+        result += id.code.number if id.code
+        result
+      end
+
+      def render_manual(id)
+        parts = []
+        parts << id.publisher if id.publisher
+        parts << "MNL"
+        parts << "TP" if id.tp_designation
+        parts << id.code.number if id.code
+
+        result = parts.join
+
+        result += "-#{id.edition}" if id.edition
+
+        if id.publisher
+          result = "#{id.publisher} #{result[id.publisher.length..]}"
+        end
+
+        result += "-SUP" if id.supplement
+        result += id.format_suffix if id.format_suffix
+
+        result
+      end
+    end
+  end
+end

data/lib/pubid/astm/single_identifier.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    # Descends from Pubid::Astm::Identifier (the flavor base) so every concrete
+    # ASTM identifier is `is_a?(Pubid::Astm::Identifier)`.
+    class SingleIdentifier < Identifier
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+      attribute :publisher, :string, default: -> { "ASTM" }
+      # The document code lives on every concrete class as flat index columns
+      # (Identifiers::CodeNumber) — `number` is what relaton-index keys on. It
+      # cannot be declared here: SingleIdentifier is inherited by every ASTM
+      # type, and retyping the inherited `number` on an inherited-from class
+      # resolves nondeterministically under multi-flavor load.
+      attribute :year, :string
+      attribute :format_suffix, :string # -EB for eBook
+
+      # --- MR slug hooks -------------------------------------------------
+      #
+      # ASTM defined none, so the base hooks looked for an inherited
+      # `typed_stage`, `date` and `Components::Edition` that ASTM does not use.
+      # Two consequences, both measured on the corpus before this change:
+      # 201 of 248 ids shared the single slug "astm", and 40 of them RAISED —
+      # `mr_edition` calls `edition.number`, but ASTM's `edition` is a plain
+      # String. That is the same crash BIPM had, recorded in CLAUDE.md.
+      # `to_slug` is what consumers use as an output filename.
+      def mr_edition
+        edition&.to_s&.downcase
+      end
+
+      # ASTM keeps its edition year in a plain `year` string, not the
+      # inherited `date`.
+      def mr_year
+        year&.to_s
+      end
+
+      # The document type is the class, not a typed_stage: without it a
+      # Manual, a DataSeries and a Standard numbered alike share a filename.
+      def mr_type
+        self.class.name.split("::").last
+          .gsub(/([a-z])([A-Z])/, '\1-\2').downcase
+      end
+    end
+  end
+end

data/lib/pubid/astm/urn_generator.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "astm"]
+
+        if identifier.type
+          type = identifier.type&.abbr || identifier.type.to_s
+          parts << type.to_s.downcase
+        else
+          parts << "std"
+        end
+
+        if identifier.code
+          parts << identifier.code.to_s
+        end
+
+        # `number` is deliberately NOT emitted here. It used to be dead code —
+        # ASTM kept everything in `code` and never set the `number` inherited
+        # from ::Pubid::Identifier, so `maybe(:number)` always returned nil.
+        # Now that `number` is the real index column and `code` is composed
+        # from it, emitting both would double the segment
+        # ("urn:astm:std:D2148:2148:22"). `code` already renders the number
+        # along with the letter and the suffixes.
+
+        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
+
+        year = extract_year
+        parts << year if year
+
+        sub_year = maybe(:sub_year)
+        parts << sub_year.to_s if sub_year
+
+        reapproval = maybe(:reapproval)
+        parts << "reapp.#{reapproval}" if reapproval
+
+        edition = maybe(:edition)
+        parts << "e#{edition}" if edition
+
+        wip = maybe(:work_in_progress)
+        parts << "wip" if wip
+
+        wk = maybe(:wk)
+        parts << "wk.#{wk}" if wk
+
+        pub = identifier.publisher
+        if pub
+          p = pub.to_s
+          parts[1] = p.to_s.downcase
+        end
+
+        copubs = maybe(:copublishers)
+        if copubs&.any?
+          cp = copubs.map(&:to_s)
+          parts[1] = "#{parts[1]}-#{cp.join('-').downcase}"
+        end
+
+        if identifier.languages&.any?
+          lang_codes = identifier.languages.map(&:code).join(",")
+          parts << lang_codes
+        end
+
+        parts.join(":")
+      end
+
+      private
+
+      def extract_year
+        year = maybe(:year)
+        if year
+          y = year.to_s
+          y = y[-2..] if y.length == 4
+          return y
+        end
+
+        date = identifier.date
+        if date
+          y = date.year&.to_s
+          if y
+            y = y[-2..] if y.length == 4
+            return y
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/pubid/astm/urn_parser.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    # Parses ASTM URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:astm:{publisher}:{code}:{year}[:sub_year][:reapp.X][:eX][:wip][:wk.X]
+    #
+    # The publisher slot is the lowercase publisher string ("astm" or
+    # "pub-copub"). The code slot is the alphanumeric ASTM code (e.g.,
+    # "D2148", "A1"). Year is **2 digits** in the URN.
+    #
+    # Examples:
+    # - urn:astm:astm:D2148:2022  → ASTM D2148-22
+    # - urn:astm:astm:A1:2002     → ASTM A1-02
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        _publisher, code, year = parts
+
+        text = "ASTM #{code}"
+        text += "-#{year[-2..]}" if year && year.length >= 2
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/astm.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    extend Pubid::PrefixesSupport
+
+    # Sole ASTM publisher token (see the parser's `publisher` rule).
+    PREFIXES = ["ASTM"].freeze
+
+    autoload :Components, "#{__dir__}/astm/components"
+    autoload :Identifier, "#{__dir__}/astm/identifier"
+    autoload :Identifiers, "#{__dir__}/astm/identifiers"
+    autoload :SingleIdentifier, "#{__dir__}/astm/single_identifier"
+    autoload :Parser, "#{__dir__}/astm/parser"
+    autoload :Builder, "#{__dir__}/astm/builder"
+    autoload :Renderer, "#{__dir__}/astm/renderer"
+    autoload :UrnGenerator, "#{__dir__}/astm/urn_generator"
+    autoload :UrnParser, "#{__dir__}/astm/urn_parser"
+
+    def self.parse(str)
+      Identifier.parse(str)
+    end
+
+    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|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      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(:astm, Pubid::Astm)
+
+Pubid::Astm::SingleIdentifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Astm::SingleIdentifier.format_registry.register(:human, renderer: Pubid::Astm::Renderer)