pubid 1.15.19 → 2.0.0.pre.alpha.2

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Astm
+    module Components
+      class Code < Lutaml::Model::Serializable
+        attribute :letter, :string       # A-G for standards
+        attribute :number, :string       # Main number
+        attribute :suffix, :string       # A, B, C for data series
+        attribute :subseries, :string    # S1, S4, S10 for data series
+        attribute :dual_m, :boolean      # M suffix for metric (dual unit)
+
+        def to_s
+          if letter
+            parts = [letter, number]
+            parts << suffix if suffix
+            result = parts.join
+            result += "-S#{subseries}" if subseries
+            result += "M" if dual_m
+          else
+            # No letter (e.g., DataSeries, ISO/ASTM dual)
+            result = number.to_s
+            result += suffix if suffix
+            result += "-S#{subseries}" if subseries
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/astm/identifier.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    class Identifier < Pubid::Identifier
+      def self.parse(str)
+        parser = Parser.new
+        builder = Builder.new
+
+        parsed = parser.parse(str)
+        builder.build(parsed)
+      end
+
+      # Factory that builds an ASTM identifier from a hash of primitives.
+      # Default is {Identifiers::Standard}.
+      #
+      # ASTM's Code Component has :letter (single letter A–Z) + :number
+      # (rest); `.create` accepts either an already-split pair or a
+      # combined `:code` string which it splits at the first digit.
+      TYPE_KEY_TO_KLASS = {
+        standard:           "Standard",
+        adjunct:            "Adjunct",
+        manual:             "Manual",
+        monograph:          "Monograph",
+        research_report:    "ResearchReport",
+        technical_report:   "TechnicalReport",
+        data_series:        "DataSeries",
+        iso_dual_published: "IsoDualPublished",
+        work_in_progress:   "WorkInProgress",
+      }.freeze
+
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts, klass: klass))
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::Standard if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown ASTM type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.coerce_create_attrs(opts, klass:)
+        attrs = { publisher: (opts[:publisher] || "ASTM").to_s }
+
+        if opts[:letter] || opts[:number]
+          attrs[:code] = Pubid::Astm::Components::Code.new(
+            letter:    opts[:letter]&.to_s,
+            number:    opts[:number]&.to_s,
+            suffix:    opts[:suffix]&.to_s,
+            subseries: opts[:subseries]&.to_s,
+            dual_m:    opts[:dual_m],
+          )
+        elsif (combined = opts[:code])
+          letter, number = split_astm_code(combined.to_s)
+          attrs[:code] = Pubid::Astm::Components::Code.new(
+            letter: letter, number: number,
+          )
+        end
+
+        attrs[:year] = opts[:year].to_s if opts[:year]
+        attrs[:format_suffix] = opts[:format_suffix].to_s if opts[:format_suffix]
+
+        # Pass through subclass-specific kwargs (designation, edition,
+        # committee, …) when the class declares them.
+        opts.each do |k, v|
+          next if attrs.key?(k)
+          next if %i[publisher code letter number suffix subseries
+                     dual_m year format_suffix].include?(k)
+          attrs[k] = v if klass.attributes.key?(k)
+        end
+        attrs
+      end
+
+      # ASTM codes use a single letter prefix (A–Z) followed by digits.
+      # "A36" → ["A", "36"]; "E1444" → ["E", "1444"]. Codes without a
+      # leading letter (data series numbers, etc.) pass through with
+      # letter: nil.
+      def self.split_astm_code(str)
+        match = str.match(/\A([A-Za-z])(\d.*)\z/)
+        return match.captures if match
+
+        [nil, str]
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs,
+                           :split_astm_code
+    end
+  end
+end

data/lib/pubid/astm/identifiers/adjunct.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class Adjunct < SingleIdentifier
+        attribute :designation, :string      # D2148, F3504, G0088, C062702
+        attribute :ea_suffix, :boolean       # -EA
+        attribute :dvd_suffix, :boolean      # DVD
+
+        def to_s
+          result = []
+          # Only include publisher for simple adjuncts (no EA or DVD suffix)
+          result << publisher if publisher && !ea_suffix && !dvd_suffix
+          result << "ADJ#{designation}#{'-EA' if ea_suffix}#{'DVD' if dvd_suffix}"
+          result.compact.join(" ")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class Base < SingleIdentifier
+        def self.parse(str)
+          Pubid::Astm::Identifier.parse(str)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/astm/identifiers/data_series.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class DataSeries < Base
+        attribute :hol_suffix, :boolean # HOL suffix
+
+        def to_s
+          parts = []
+          parts << publisher if publisher
+
+          result = parts.join(" ")
+          result += " " if publisher && !result.end_with?(" ")
+
+          result += "DS"
+          result += code.to_s if code
+          result += "HOL" if hol_suffix
+          result += format_suffix if format_suffix
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/astm/identifiers/iso_dual_published.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../../iso/components/publisher"
+require_relative "../../components/date"
+
+module Pubid
+  module Astm
+    module Identifiers
+      # IsoDualPublished represents ASTM standards that are dual-published with ISO
+      #
+      # SEMANTIC NOTE: ISO/ASTM dual-published standards (typically 5xxxx series)
+      # - ASTM version: ASTM 52303-24e1 (e1 = edition 1, not "E" prefix)
+      # - ISO version: ISO/ASTM 52303:2024
+      #
+      # Distinguishing feature: Starts with digit (typically 5xxxx series)
+      # These are ASTM's version of standards jointly developed with ISO
+      class IsoDualPublished < Standard
+        # Inherits all behavior from Standard:
+        # - sub_year (a, b, c)
+        # - reapproval ((2023))
+        # - edition (e1)
+        # - code (number without letter prefix)
+        # - year (2024 → 24)
+
+        # No additional attributes needed - same structure as Standard
+        # The semantic difference is the classification itself
+
+        # Rendering is identical to Standard
+        # Example: ASTM 52303-24e1
+
+        # Convert to ISO/ASTM dual-published format
+        # @return [Pubid::Iso::Identifiers::InternationalStandard] ISO version
+        #
+        # @example Convert ASTM to ISO format
+        #   astm = Pubid::Astm.parse("ASTM 52303-24e1")
+        #   iso = astm.to_iso_identifier
+        #   iso.to_s # => "ISO/ASTM 52303:2024"
+        def to_iso_identifier
+          require_relative "../../iso/identifiers/international_standard"
+          require_relative "../../iso/components/code"
+          require_relative "../../components/publisher"
+
+          iso = Pubid::Iso::Identifiers::InternationalStandard.new
+
+          # Set publisher as ISO with ASTM as copublisher (in Publisher component)
+          iso.publisher = Pubid::Iso::Components::Publisher.new(
+            publisher: "ISO",
+            copublisher: ["ASTM"],
+          )
+
+          # Also set copublishers attribute (array of Publisher objects) for rendering
+          astm_publisher = ::Pubid::Components::Publisher.new(body: "ASTM")
+          iso.copublishers = [astm_publisher]
+
+          # Set code number (same as ASTM) - use ISO Code component
+          if code
+            iso_code = Pubid::Iso::Components::Code.new
+            iso_code.number = code.number
+            iso.number = iso_code
+          end
+
+          # Set year as date component - use base Date component
+          if year
+            iso_date = ::Pubid::Components::Date.new
+            iso_date.year = year.to_s
+            iso.date = iso_date
+          end
+
+          iso
+        end
+      end
+    end
+  end
+end

data/lib/pubid/astm/identifiers/manual.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class Manual < Base
+        attribute :edition, :string          # 9TH, 2ND
+        attribute :supplement, :boolean      # -SUP-
+        attribute :tp_designation, :string   # TP for technical publications
+
+        def to_s
+          parts = []
+          parts << publisher if publisher
+          parts << "MNL"
+          parts << "TP" if tp_designation
+          parts << code.number if code
+
+          result = parts.join
+
+          # Edition with dash separator
+          result += "-#{edition}" if edition
+
+          # Add separator after publisher
+          if publisher
+            # Insert space after publisher
+            result = "#{publisher} #{result[publisher.length..]}"
+          end
+
+          # Add supplement if present
+          result += "-SUP" if supplement
+
+          # Add format suffix (already has dash from builder)
+          result += format_suffix if format_suffix
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/astm/identifiers/monograph.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class Monograph < Base
+        attribute :edition, :string # 2ND, 4TH
+
+        def to_s
+          parts = []
+          parts << publisher if publisher
+
+          result = parts.join(" ")
+          result += " " if publisher && !result.end_with?(" ")
+
+          result += "MONO"
+          result += code.number if code
+          result += "-#{edition}" if edition
+          result += format_suffix if format_suffix
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/astm/identifiers/research_report.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class ResearchReport < Base
+        attribute :committee, :string # A01, C09
+
+        def to_s
+          parts = []
+          parts << publisher if publisher
+          parts << "RR:#{committee}-#{code.number}" if committee && code
+          parts.join(" ")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class Standard < Base
+        attribute :sub_year, :string        # a, b, c
+        attribute :reapproval, :string      # (2023)
+        attribute :edition, :string # e1
+
+        def to_s
+          parts = []
+          parts << publisher if publisher
+
+          # Code with potential dual unit
+          if code
+            code_str = code.to_s
+            # Check if this is a dual unit designation
+            if code.dual_m
+              # F1862/F1862M format
+              base_code = "#{code.letter}#{code.number}"
+              code_str = "#{base_code}/#{base_code}M"
+            end
+            parts << code_str
+          end
+
+          # Join parts with space (ASTM E2938)
+          result = parts.join(" ")
+
+          # Append year directly without space
+          if year
+            result += "-#{year_portion}"
+            result += sub_year if sub_year
+          end
+
+          # Append reapproval
+          result += "(#{reapproval})" if reapproval
+
+          # Append edition
+          result += "e#{edition}" if edition
+
+          result
+        end
+
+        def year_portion
+          # Convert 4-digit to 2-digit (e.g., 2015 → 15)
+          year.to_s.length == 4 ? year.to_s[-2..] : year.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class TechnicalReport < Base
+        def to_s
+          # Check if ISO/ASTM format: publisher "ISO/ASTM" without TR letter in code
+          if publisher == "ISO/ASTM" && (code.nil? || code.letter.nil?)
+            result = "ISO/ASTMTR"
+          else
+            # Simple TR format
+            result = "TR"
+            result += code.letter if code&.letter
+          end
+          result += code.number if code&.number
+          result += format_suffix if format_suffix
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/astm/identifiers/work_in_progress.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class WorkInProgress < Base
+        def to_s
+          parts = []
+          parts << publisher if publisher
+
+          result = parts.join(" ")
+          result += " " if publisher && !result.end_with?(" ")
+
+          result += "WK"
+          result += code.number if code
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/astm/parser.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Astm
+    class Parser < Parslet::Parser
+      # 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