pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

data/lib/pubid/asme.rb

@@ -7,13 +7,54 @@ module Pubid
     autoload :Identifier, "#{__dir__}/asme/identifier"
     autoload :Identifiers, "#{__dir__}/asme/identifiers"
     autoload :Parser, "#{__dir__}/asme/parser"
-    autoload :Scheme, "#{__dir__}/asme/scheme"
+    autoload :Renderer, "#{__dir__}/asme/renderer"
     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/components/code.rb

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

data/lib/pubid/{jis → astm}/components.rb

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

data/lib/pubid/astm/identifier.rb

@@ -10,83 +10,6 @@ module Pubid
         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

@@ -7,14 +7,6 @@ module Pubid
         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

@@ -5,20 +5,6 @@ module Pubid
     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

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../iso/components/publisher"
-require_relative "../../components/date"
-
 module Pubid
   module Astm
     module Identifiers
@@ -28,45 +25,23 @@ module Pubid
         # Rendering is identical to Standard
         # Example: ASTM 52303-24e1
 
-        # Convert to ISO/ASTM dual-published format
-        # @return [Pubid::Iso::Identifiers::InternationalStandard] ISO version
+        # 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
-          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(
+          Pubid::Iso.build(
+            type: :is,
             publisher: "ISO",
-            copublisher: ["ASTM"],
+            copublishers: ["ASTM"],
+            number: code&.number,
+            year: year&.to_s,
           )
-
-          # 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

@@ -7,33 +7,6 @@ module Pubid
         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

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

@@ -5,20 +5,6 @@ module Pubid
     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

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

@@ -5,13 +5,6 @@ module Pubid
     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

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

@@ -7,45 +7,6 @@ module Pubid
         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

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

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

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

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

data/lib/pubid/astm/identifiers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Astm
+    module Identifiers
+      autoload :Base, "#{__dir__}/identifiers/base"
+      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

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.designation}#{'-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

@@ -10,16 +10,6 @@ module Pubid
       attribute :code, Components::Code
       attribute :year, :string
       attribute :format_suffix, :string # -EB for eBook
-
-      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
 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