pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

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

data/lib/pubid/astm.rb

@@ -1,38 +1,50 @@
 # frozen_string_literal: true
 
-require "parslet"
-require "lutaml/model"
-require_relative "identifier"
-require_relative "astm/identifier"
-require_relative "astm/components/code"
-require_relative "astm/single_identifier"
-require_relative "astm/parser"
-require_relative "astm/builder"
-
-# Identifier classes
-require_relative "astm/identifiers/base"
-require_relative "astm/identifiers/standard"
-require_relative "astm/identifiers/iso_dual_published"
-require_relative "astm/identifiers/manual"
-require_relative "astm/identifiers/research_report"
-require_relative "astm/identifiers/data_series"
-require_relative "astm/identifiers/technical_report"
-require_relative "astm/identifiers/monograph"
-require_relative "astm/identifiers/adjunct"
-require_relative "astm/identifiers/work_in_progress"
-
-# Scheme (must be loaded after identifiers)
-require_relative "astm/scheme"
-
 module Pubid
   module Astm
+    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
-  end
 
-  # Register this flavor with the Pubid registry
+    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
 
-# Register Uastm flavor with the registry
 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)

data/lib/pubid/bsi/builder.rb

@@ -3,12 +3,19 @@
 module Pubid
   module Bsi
     class Builder < Pubid::Builder::Base
-      def initialize(scheme)
-        @scheme = scheme
-      end
-
-      def self.build(parsed_data, scheme = Scheme.new)
-        new(scheme).build(parsed_data)
+      # Default typed stage used when an abbreviation lookup yields no match.
+      # Empty/unknown abbreviations fall back to the published British Standard.
+      DEFAULT_TYPED_STAGE = Pubid::Components::TypedStage.new(
+        code: :pubbs,
+        stage_code: :published,
+        type_code: :bs,
+        abbr: ["BS"],
+        name: "British Standard",
+        harmonized_stages: %w[60.00 60.60],
+      ).freeze
+
+      def self.build(parsed_data)
+        new.build(parsed_data)
       end
 
       def build(data)
@@ -122,7 +129,7 @@ module Pubid
           return identifier
         end
 
-        # Determine identifier class using Scheme
+        # Determine identifier class using the module's lookup helpers
         identifier = locate_identifier_klass(data).new
         assign_attributes(identifier, data)
 
@@ -934,17 +941,19 @@ module Pubid
         return Identifiers::AdoptedEuropeanNorm if parsed_hash[:adopted_string]&.match?(/^EN\s+\d/)
         return Identifiers::AdoptedInternationalStandard if parsed_hash[:adopted_string]
 
-        # Use type to determine class via Scheme
+        # Use type to determine class via Pubid::Bsi.locate_stage / locate_type.
+        # Unknown abbreviations fall back to DEFAULT_TYPED_STAGE (published BS).
         type_str = parsed_hash[:type] || parsed_hash[:stage] || ""
-        typed_stage = @scheme.locate_typed_stage_by_abbr(type_str)
-        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+        typed_stage = Bsi.locate_stage(type_str.to_s.upcase) || DEFAULT_TYPED_STAGE
+        Bsi.locate_type(typed_stage.type_code) || Identifiers::BritishStandard
       end
 
       def cast(type, value)
         case type
         when :type
-          # Lookup from register
-          typed_stage = @scheme.locate_typed_stage_by_abbr(value || "")
+          # Lookup from register via Pubid::Bsi.locate_stage.
+          # Unknown abbreviations fall back to DEFAULT_TYPED_STAGE (published BS).
+          typed_stage = Bsi.locate_stage(value.to_s.upcase) || DEFAULT_TYPED_STAGE
           {
             stage: typed_stage.to_stage,
             type: typed_stage.to_type,

data/lib/pubid/bsi/identifier.rb

@@ -2,7 +2,14 @@
 
 module Pubid
   module Bsi
+    # `extend Pubid::IdentifierFacade` adds polymorphic `from_hash` and pairs
+    # with `include Pubid::Bsi::Identifier` in SingleIdentifier (BSI's common
+    # ancestor — there is no Identifiers::Base) for identity (`is_a?`/`===`), so
+    # a consumer handed this module can deserialize and identity-check BSI ids
+    # through it.
     module Identifier
+      extend Pubid::IdentifierFacade
+
       def self.parse(string)
         # Delegate to IEC for bare IEC identifiers
         # This handles IEC-specific features like VAP suffixes (CSV, RLV, etc.)
@@ -15,10 +22,9 @@ module Pubid
         end
 
         parser = Parser.new
-        scheme = Scheme.new
 
         parsed = parser.parse(string)
-        Builder.build(parsed, scheme)
+        Builder.build(parsed)
       rescue Parslet::ParseFailed => e
         raise StandardError, "Failed to parse '#{string}': #{e.message}"
       end

data/lib/pubid/bsi/identifiers/addendum_document.rb

@@ -10,8 +10,8 @@ module Pubid
       # "BS 1902-2.3:Addendum No. 1:1976"
       # "BS 2000-0:Addendum 1:1983"
       # "BS 6034:1981:Addendum No. 1:1986"
-      class AddendumDocument < Base
-        attribute :base_identifier, Base, polymorphic: true
+      class AddendumDocument < SingleIdentifier
+        attribute :base_identifier, ::Pubid::Identifier, polymorphic: true
         attribute :addendum_number, :string
         attribute :addendum_year, :integer
         attribute :addendum_type, :string, default: -> {
@@ -22,37 +22,7 @@ module Pubid
         } # Separator before Addendum (":" or " ")
 
         def to_s(lang: :en, lang_single: false)
-          result = base_identifier.to_s(lang: lang, lang_single: lang_single)
-
-          # Determine separator - if separator is explicitly ":", use it
-          # Otherwise if base has year and doesn't already have double colon, use space
-          base_has_year = base_identifier.to_s =~ /:(\d{4})$/
-
-          sep = if separator == ":"
-                  ":"
-                elsif base_has_year && base_identifier.to_s !~ /:\d{4}:/
-                  " "
-                else
-                  separator
-                end
-
-          # Format: "BASE:Addendum No. N:YEAR" or "BASE Addendum No. N:YEAR" or "BASE:Addendum N:YEAR"
-          result += sep
-          result += "Addendum"
-
-          # Add space after "Addendum" if there's a type prefix (like "No.")
-          if addendum_type.empty?
-            # No type prefix, but still need space before number
-          else
-            result += " #{addendum_type}"
-          end
-          result += " "
-          result += " "
-
-          result += addendum_number.to_s
-          result += ":#{addendum_year}" if addendum_year
-
-          result
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
 
         def publisher

data/lib/pubid/bsi/identifiers/adopted_european_norm.rb

@@ -7,7 +7,7 @@ module Pubid
       # Example: "BS EN 10077-1:2006" where EN 10077-1:2006 is a CEN identifier object
       # Example: "BS EN ISO 8601:2019" where EN ISO 8601:2019 is a CEN AdoptedEuropeanNorm wrapping ISO
       class AdoptedEuropeanNorm < BritishStandard
-        attribute :adopted_identifier, Base, polymorphic: true # CEN object
+        attribute :adopted_identifier, ::Pubid::Identifier, polymorphic: true # CEN object
         attribute :edition, :string
         attribute :translation_lang, :string
         attribute :translation_upper, :string
@@ -16,53 +16,17 @@ module Pubid
         attribute :expert_commentary, :boolean
         attribute :expert_commentary_topic, :string
 
-        def to_s(lang: :en, lang_single: false)
-          # Get the BSI prefix (BS, PD, DD)
-          prefix = case publisher
-                   when Components::Publisher
-                     publisher.body
-                   when Array
-                     publisher.join("/")
-                   when String
-                     publisher
-                   else
-                     "BS"
-                   end
-
-          result = prefix
-          result += " #{adopted_identifier}" if adopted_identifier
-          result += " ED#{edition}" if edition
-
-          # Reaffirmation notation like (R2004)
-          result += " (R#{reaffirmation_year})" if reaffirmation_year
-
-          # Translation - preserve the "version" or "Translation" suffix if present
-          if translation_lang
-            result += if translation_suffix_type == "version"
-                        " (#{translation_lang} version)"
-                      elsif translation_suffix_type == "Translation"
-                        " (#{translation_lang} Translation)"
-                      else
-                        " (#{translation_lang})"
-                      end
-          elsif translation_upper
-            result += if translation_suffix_type == "Translation"
-                        " (#{translation_upper} Translation)"
-                      else
-                        " (#{translation_upper})"
-                      end
-          end
-
-          # ExpertCommentary suffix
-          if expert_commentary
-            result += if expert_commentary_topic
-                        " ExComm (#{expert_commentary_topic})"
-                      else
-                        " ExComm"
-                      end
-          end
+        # Override self.type to return nil so this polymorphic wrapper is not
+        # registered as a base type. Inherits `:bs` from BritishStandard which
+        # would otherwise shadow it in Bsi.locate_type(:bs) auto-discovery.
+        # AdoptedEuropeanNorm is constructed explicitly by the builder, not
+        # selected by type-code lookup.
+        def self.type
+          nil
+        end
 
-          result
+        def to_s(lang: :en, lang_single: false)
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
 
         # Delegate common methods to adopted identifier