pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/asme.rb

@@ -2,64 +2,18 @@
 
 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 :Scheme, "#{__dir__}/asme/scheme"
     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
 

data/lib/pubid/astm/builder.rb

@@ -8,16 +8,9 @@ module Pubid
         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.
+        # Build code component if present
         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
+          identifier.code = build_code(parsed_hash)
         end
 
         # Set publisher
@@ -126,7 +119,7 @@ module Pubid
 
         # Adjunct
         if identifier.is_a?(Identifiers::Adjunct)
-          identifier.number = parsed_hash[:designation].to_s if parsed_hash[:designation]
+          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

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

@@ -5,11 +5,6 @@ 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
@@ -32,10 +27,6 @@ module Pubid
           end
           result
         end
-
-        def render(context: nil)
-          to_s
-        end
       end
     end
   end

data/lib/pubid/astm/identifier.rb

@@ -4,15 +4,6 @@ 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
 

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

@@ -4,24 +4,17 @@ 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 :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

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

@@ -4,9 +4,21 @@ module Pubid
   module Astm
     module Identifiers
       class DataSeries < Base
-        include CodeNumber
-
         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

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../../iso/components/publisher"
+require_relative "../../components/date"
+
 module Pubid
   module Astm
     module Identifiers
@@ -12,22 +15,6 @@ module Pubid
       # 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))
@@ -41,23 +28,45 @@ module Pubid
         # 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
+        # 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
-          Pubid::Iso.build(
-            type: :is,
+          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",
-            copublishers: ["ASTM"],
-            number: code&.number,
-            year: year&.to_s,
+            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

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

@@ -4,18 +4,35 @@ 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))
+        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

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

@@ -4,9 +4,21 @@ module Pubid
   module Astm
     module Identifiers
       class Monograph < Base
-        include CodeNumber
-
         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

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

@@ -4,16 +4,13 @@ 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)
+        def to_s
+          parts = []
+          parts << publisher if publisher
+          parts << "RR:#{committee}-#{code.number}" if committee && code
+          parts.join(" ")
         end
       end
     end

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

@@ -4,18 +4,47 @@ 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))
+        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

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

@@ -4,8 +4,19 @@ module Pubid
   module Astm
     module Identifiers
       class TechnicalReport < Base
-        include CodeNumber
-
+        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

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

@@ -4,8 +4,17 @@ module Pubid
   module Astm
     module Identifiers
       class WorkInProgress < Base
-        include CodeNumber
+        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

data/lib/pubid/astm/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Astm
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:dash) { str("-") }

data/lib/pubid/astm/scheme.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "identifiers/standard"
+require_relative "identifiers/manual"
+require_relative "identifiers/research_report"
+require_relative "identifiers/data_series"
+require_relative "identifiers/technical_report"
+require_relative "identifiers/monograph"
+require_relative "identifiers/adjunct"
+require_relative "identifiers/work_in_progress"
+require_relative "identifiers/iso_dual_published"
+
+module Pubid
+  module Astm
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          @identifiers ||= [
+            Identifiers::Standard,
+            Identifiers::Manual,
+            Identifiers::ResearchReport,
+            Identifiers::DataSeries,
+            Identifiers::TechnicalReport,
+            Identifiers::Monograph,
+            Identifiers::Adjunct,
+            Identifiers::WorkInProgress,
+            Identifiers::IsoDualPublished,
+          ].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,
+                "ASTM identifiers do not use typed stages"
+        end
+
+        def locate_identifier_klass_by_type_code(_type_code)
+          raise ArgumentError,
+                "ASTM identifiers do not use type codes"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/astm/single_identifier.rb

@@ -2,45 +2,23 @@
 
 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
+    class SingleIdentifier < Pubid::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 :code, Components::Code
       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
+      def to_s
+        parts = []
+        parts << publisher if publisher
+        parts << prefix if self.class.attributes.key?(:prefix) && prefix
+        parts << code.to_s if code
+        parts << "-#{year}" if year
+        parts << format_suffix if format_suffix
+        parts.join(" ")
       end
     end
   end

data/lib/pubid/astm/urn_generator.rb

@@ -17,13 +17,11 @@ module Pubid
           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.
+        number = maybe(:number)
+        if number
+          num = number.to_s
+          parts << num
+        end
 
         part = maybe(:part)
         if part