pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/astm/builder.rb

@@ -0,0 +1,166 @@
+# 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
+
+        # The code is stored as flat index columns on every concrete class (see
+        # Identifiers::CodeNumber) — `number` is what relaton-index keys on —
+        # so the Code built below is unpacked rather than assigned.
+        if parsed_hash[:letter] || parsed_hash[:number]
+          code = build_code(parsed_hash)
+          identifier.letter = code.letter
+          identifier.number = code.number
+          identifier.suffix = code.suffix
+          identifier.subseries = code.subseries
+          identifier.dual_m = code.dual_m || false
+        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.number = 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

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Astm
+    module Components
+      # Code component for ASTM identifiers.
+      #
+      # Stays independent of Pubid::Components::Code because ASTM has a
+      # rich taxonomy: +letter+ (A-G for standards), +suffix+ (A/B/C for
+      # data series), +subseries+ (S1/S4/S10), and +dual_m+ (metric flag).
+      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
+
+        def render(context: nil)
+          to_s
+        end
+      end
+    end
+  end
+end

data/lib/pubid/astm/components.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Components
+      autoload :Code, "#{__dir__}/components/code"
+    end
+  end
+end

data/lib/pubid/astm/identifier.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    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/astm/identifiers/adjunct.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class Adjunct < SingleIdentifier
+        include CodeNumber
+
+        # An adjunct carries no code at all — its whole identity is the
+        # designation ("ADJD2148"). relaton-index keys on
+        # `id.root.number.to_s`, so the designation IS the number here, the
+        # same reasoning that makes a registry slug IANA's number and a draft
+        # slug IETF's.
+        #
+        # It is stored in `number` itself rather than in a separate
+        # `designation` attribute shadowed by a `def number`. Two reasons, both
+        # from CLAUDE.md: defining a `#number` method alongside the attribute is
+        # the construct that corrupts lutaml's accessor resolution, and keeping
+        # both columns made `to_hash` emit the same string twice
+        # ({"number" => "D2148", "designation" => "D2148"}) — the duplication
+        # the BIPM note warns against. The builder assigns `number` and the
+        # renderer reads it; nothing else referenced `designation`.
+        attribute :ea_suffix, :boolean       # -EA
+        attribute :dvd_suffix, :boolean      # DVD
+      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/code_number.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      # Installs the flat, index-friendly code columns on every CONCRETE ASTM
+      # identifier class.
+      #
+      # Why every concrete class and not Pubid::Astm::SingleIdentifier, which
+      # they all inherit from: `number` redefines the parent
+      # ::Pubid::Identifier's `attribute :number, Components::Code` as a plain
+      # :string (Astm::Components::Code is not a subclass of it). Declaring that
+      # on a class the concrete types INHERIT from resolves against the parent
+      # definition nondeterministically under multi-flavor load — it passes an
+      # ASTM-only run and can flip `root.number` to "" under the full suite (the
+      # IEEE lesson; see lib/pubid/ieee/identifiers/code_number.rb and
+      # CLAUDE.md).
+      #
+      # NOTE the module is included by `Standard` AND by `IsoDualPublished`,
+      # which inherits from Standard. That is deliberate, not redundant: a class
+      # that is itself inherited from must still declare the columns so its
+      # subclass holds its own snapshot rather than relying on the parent's.
+      # Every instantiable ASTM class declares them for itself.
+      #
+      # This matters because relaton-index sorts and bsearches every row on
+      # `id.root.number.to_s`, and ASTM kept identity in an
+      # Astm::Components::Code under a `code` attribute, so all 248 parseable
+      # fixture ids keyed "".
+      module CodeNumber
+        def self.included(base)
+          # Bare document number ("2938"), the relaton index key. `letter` is a
+          # sibling column, so E2938 and D2938 narrow to the same bucket and
+          # are then separated by the full hash — the IEEE prefix/number split.
+          base.attribute :number, :string
+          base.attribute :letter, :string
+          base.attribute :suffix, :string
+          base.attribute :subseries, :string
+          # Named for the RARE case with a false default, so the canonical
+          # to_hash drops it from every ordinary row.
+          base.attribute :dual_m, :boolean, default: -> { false }
+        end
+
+        # The composed document code, rebuilt on demand from the split columns.
+        # ASTM's renderer reads the individual fields (`code.letter`,
+        # `code.number`, `code.dual_m`) in several places, so the component has
+        # to keep its structure rather than collapsing to a string as ASME's
+        # does.
+        #
+        # Deliberately NOT an attribute and NOT memoised: the columns are
+        # writable (the base #exclude rebuilds through them), so a cached Code
+        # would go stale. nil when there is no number and no letter, preserving
+        # the nil-`code` branches the renderer and URN generator both test.
+        def code
+          return nil if number.nil? && letter.nil?
+
+          Components::Code.new(
+            letter: letter,
+            number: number,
+            suffix: suffix,
+            subseries: subseries,
+            dual_m: dual_m,
+          )
+        end
+
+        # Every field of the code is identity-bearing — Code#to_s renders all
+        # of them and they are all in the serialized hash — so all of them must
+        # reach the slug, or two distinct documents share a filename.
+        # CLAUDE.md's rule: a marker that only reaches `==` is not enough.
+        def mr_number_with_part
+          segments = [letter, number, suffix].compact
+          segments << "s#{subseries}" if subseries
+          segments << "m" if dual_m
+          return nil if segments.empty?
+
+          segments.join("-").downcase.gsub(/[^a-z0-9-]+/, "-")
+            .gsub(/\A-+|-+\z/, "")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class DataSeries < Base
+        include CodeNumber
+
+        attribute :hol_suffix, :boolean # HOL suffix
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+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
+        # Re-included even though Standard already does. DO NOT "clean this
+        # up" — it compiles fine without it, passes most tests, and silently
+        # reintroduces the multi-flavor `number` determinism landmine for this
+        # class alone, visible only under the full suite.
+        #
+        # Two Ruby facts make the repeat both necessary and safe:
+        #   * `included(base)` fires on EVERY `include` call, so this gives
+        #     IsoDualPublished its own `attribute :number` resolved against its
+        #     own table rather than a snapshot inherited from Standard;
+        #   * `Module#include` does NOT re-insert a module already present via
+        #     a superclass, so CodeNumber keeps the ancestor position Standard
+        #     gave it — still BELOW Standard. That is what lets
+        #     Standard#mr_number_with_part's `super` reach CodeNumber's
+        #     implementation instead of being shadowed here.
+        include CodeNumber
+
+        # 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.
+        # Uses Pubid::Iso.build so this flavor never reaches into ISO's
+        # internal class hierarchy.
+        # @return [Pubid::Iso::Identifier] 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
+          Pubid::Iso.build(
+            type: :is,
+            publisher: "ISO",
+            copublishers: ["ASTM"],
+            number: code&.number,
+            year: year&.to_s,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class Manual < Base
+        include CodeNumber
+
+        attribute :edition, :string          # 9TH, 2ND
+        attribute :supplement, :boolean      # -SUP-
+        attribute :tp_designation, :string   # TP for technical publications
+
+        # Both markers distinguish real documents that share a number —
+        # "ASTM MNL15-EB" vs "ASTM MNLTP15-EB", and "ASTM MNL20-2ND-EB" vs
+        # "ASTM MNL20-2ND-SUP-EB" — so both must reach the slug, not just the
+        # hash.
+        def mr_number_with_part
+          mr_join(tp_designation&.downcase, super, (supplement ? "sup" : nil))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class Monograph < Base
+        include CodeNumber
+
+        attribute :edition, :string # 2ND, 4TH
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class ResearchReport < Base
+        include CodeNumber
+
+        attribute :committee, :string # A01, C09
+
+        # Research-report numbers restart per committee, so the committee is
+        # part of the identity: "ASTM RR:A01-1001" and "ASTM RR:C09-1001" are
+        # different documents. The renderer already prints it; the slug has to
+        # carry it too or they share a filename.
+        def mr_number_with_part
+          mr_join(committee&.downcase, super)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class Standard < Base
+        include CodeNumber
+
+        attribute :sub_year, :string        # a, b, c
+        attribute :reapproval, :string      # (2023)
+
+        attribute :edition, :string # e1
+
+        # A reapproved edition is a distinct document — "ASTM C1870-18(2024)"
+        # and "ASTM C1870-18" have different hashes — so the marker has to
+        # reach the slug as well as `==`, or they share a filename.
+        def mr_number_with_part
+          mr_join(super, (reapproval ? "r#{reapproval}" : nil))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class TechnicalReport < Base
+        include CodeNumber
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      class WorkInProgress < Base
+        include CodeNumber
+
+      end
+    end
+  end
+end

data/lib/pubid/astm/identifiers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :CodeNumber, "#{__dir__}/identifiers/code_number"
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+      autoload :IsoDualPublished, "#{__dir__}/identifiers/iso_dual_published"
+      autoload :Manual, "#{__dir__}/identifiers/manual"
+      autoload :ResearchReport, "#{__dir__}/identifiers/research_report"
+      autoload :DataSeries, "#{__dir__}/identifiers/data_series"
+      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+      autoload :Monograph, "#{__dir__}/identifiers/monograph"
+      autoload :Adjunct, "#{__dir__}/identifiers/adjunct"
+      autoload :WorkInProgress, "#{__dir__}/identifiers/work_in_progress"
+    end
+  end
+end