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

data/lib/pubid/ashrae/renderer.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    # Human-readable renderer for ASHRAE identifiers.
+    #
+    # Produces strings like:
+    #   "ASHRAE Standard 15-2024"
+    #   "ASHRAE Guideline 0-2019"
+    #   "ASHRAE Addendum a to Standard 15-2001"
+    #   "ASHRAE Standard 52.2-1999: Addenda Supplement Package"
+    #   "ASHRAE Addenda c and d to Standard 15-1994"
+    #   "ASHRAE Guideline 0-2005 Errata (September 28, 2011)"
+    #   "Interpretations for Standard 15.2-2022"
+    #
+    # The renderer is registered as the +:human+ format in the ASHRAE format
+    # registry and invoked via +render(format: :human)+.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        id = @id
+
+        case id
+        when Identifiers::Addendum
+          render_addendum(id)
+        when Identifiers::AddendaPackage
+          render_addenda_package(id)
+        when Identifiers::CombinedAddenda
+          render_combined_addenda(id)
+        when Identifiers::Errata
+          render_errata(id)
+        when Identifiers::Interpretation
+          render_interpretation(id)
+        when SingleIdentifier
+          render_single(id)
+        else
+          render_single(id)
+        end
+      end
+
+      private
+
+      # SingleIdentifier (Standard, Guideline): "ASHRAE Standard 15-2024"
+      def render_single(id)
+        parts = []
+        parts << id.publisher if id.publisher
+        parts << id.type.to_s if id.type
+        result = parts.join(" ")
+        result += " " if result.length.positive?
+        result += id.code.to_s
+        result += "-#{id.year}" if id.year
+        result += " (#{id.amendment})" if id.amendment
+        result += id.suffix if id.suffix
+        result += " (RA#{id.reaffirmed})" if id.reaffirmed
+        result
+      end
+
+      # Addendum: "ASHRAE Addendum a to Standard 15-2001"
+      def render_addendum(id)
+        return id.base_identifier.to_s unless id.base_identifier
+
+        base_type = id.base_identifier.type || "Standard"
+
+        if id.copublisher
+          "#{id.copublisher} Addendum #{id.addendum_code} to #{id.base_identifier}"
+        else
+          result = "ASHRAE Addendum #{id.addendum_code} to #{base_type} #{id.base_identifier.code}"
+          result += "-#{id.base_identifier.year}" if id.base_identifier.year
+          result
+        end.tap { |r| r << " (#{id.addendum_date})" if id.addendum_date }
+      end
+
+      # AddendaPackage: "ASHRAE Standard 52.2-1999: Addenda Supplement Package"
+      def render_addenda_package(id)
+        return id.base_identifier.to_s unless id.base_identifier
+
+        result = "ASHRAE #{id.base_identifier.type || 'Standard'} #{id.base_identifier.code}"
+        result += "-#{id.base_identifier.year}" if id.base_identifier.year
+        result += ": Addenda #{id.package_description}" if id.package_description
+        result
+      end
+
+      # CombinedAddenda: "ASHRAE Addenda c and d to Standard 15-1994"
+      def render_combined_addenda(id)
+        return id.base_identifier.to_s unless id.base_identifier
+
+        base_type = id.base_identifier.type || "Standard"
+        if id.addendum_codes
+          result = "ASHRAE Addenda #{id.addendum_codes} to #{base_type} #{id.base_identifier.code}"
+        else
+          result = "ASHRAE Addenda to #{base_type} #{id.base_identifier.code}"
+        end
+        result += "-#{id.base_identifier.year}" if id.base_identifier.year
+        result
+      end
+
+      # Errata: "ASHRAE Guideline 0-2005 Errata (September 28, 2011)"
+      def render_errata(id)
+        return id.base_identifier.to_s unless id.base_identifier
+
+        result = id.base_identifier.to_s
+        result += " Errata"
+        result += " (#{id.errata_date})" if id.errata_date
+        result
+      end
+
+      # Interpretation: "Interpretations for Standard 15.2-2022"
+      def render_interpretation(id)
+        return id.base_identifier.to_s unless id.base_identifier
+
+        base_type = id.base_identifier.type || "Standard"
+        result = "Interpretations for #{base_type} #{id.base_identifier.code}"
+        result += "-#{id.base_identifier.year}" if id.base_identifier.year
+        result
+      end
+    end
+  end
+end

data/lib/pubid/ashrae/single_identifier.rb

@@ -5,19 +5,6 @@ module Pubid
     # Base class for single (non-supplement) ASHRAE identifiers
     # Includes: Guideline, Standard
     class SingleIdentifier < Identifiers::Base
-      def to_s
-        parts = []
-        parts << publisher if publisher
-        parts << type.to_s if type
-        result = parts.join(" ")
-        result += " " if result.length.positive?
-        result += code.to_s
-        result += "-#{year}" if year
-        result += " (#{amendment})" if amendment
-        result += suffix if suffix
-        result += " (RA#{reaffirmed})" if reaffirmed
-        result
-      end
     end
   end
 end

data/lib/pubid/ashrae/urn_generator.rb

@@ -9,14 +9,6 @@ module Pubid
         identifier.code.to_s
       end
 
-      def urn_year
-        if identifier.year
-          return identifier.year.to_s
-        end
-
-        nil
-      end
-
       def urn_suffix
         identifier.suffix&.to_s&.downcase
       end

data/lib/pubid/ashrae/urn_parser.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ashrae
+    # Parses ASHRAE URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:ashrae:{number}:{year}:{type}[:{suffix}][:amd.{N}][:reaff.{Y}]
+    #
+    # The type token follows the year; the human-readable form prefixes the
+    # type ("ASHRAE Standard 90.1-2019"). The year separator is `-`.
+    #
+    # Examples:
+    # - urn:ashrae:90.1:2019:standard → ASHRAE Standard 90.1-2019
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        number, year = parts
+        text = "ASHRAE Standard #{number}"
+        text += "-#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/ashrae.rb

@@ -6,16 +6,57 @@ module Pubid
     autoload :Identifier, "#{__dir__}/ashrae/identifier"
     autoload :Identifiers, "#{__dir__}/ashrae/identifiers"
     autoload :Parser, "#{__dir__}/ashrae/parser"
-    autoload :Scheme, "#{__dir__}/ashrae/scheme"
+    autoload :Renderer, "#{__dir__}/ashrae/renderer"
     autoload :SingleIdentifier, "#{__dir__}/ashrae/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/ashrae/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/ashrae/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ashrae/urn_parser"
 
     def self.parse(identifier)
       Identifier.parse(identifier)
     end
+
+    # 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
 
 # Register Uashrae flavor with the registry
 Pubid::Registry.register(:ashrae, Pubid::Ashrae)
+
+# Per-flavor format registry: inherits global formats, overrides :human
+Pubid::Ashrae::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Ashrae::Identifiers::Base.format_registry.register(:human, renderer: Pubid::Ashrae::Renderer)

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

@@ -5,11 +5,19 @@ require "lutaml/model"
 module Pubid
   module Asme
     module Components
+      # Code component for ASME identifiers.
+      #
+      # Stays independent of Pubid::Components::Code because ASME uses
+      # +designator+ (a flavor-specific letter prefix) plus +number+.
       class Code < Lutaml::Model::Serializable
-        attribute :designator, :string    # B, Y, BPVC, etc.
-        attribute :number, :string        # 16.5, 14.43, III.1.NB, etc.
+        attribute :designator, :string
+        attribute :number, :string
 
         def to_s
+          render
+        end
+
+        def render(context: nil)
           "#{designator}#{number}"
         end
       end

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

@@ -4,66 +4,6 @@ module Pubid
   module Asme
     module Identifiers
       class Base < SingleIdentifier
-        def to_s
-          # Handle joint published identifiers
-          parts = []
-          if first_publisher && first_code
-            # CSA B44.10/ASME A17.10 or API 579-2/ASME PTB-14 format
-            parts << first_publisher
-            parts << first_code
-            parts << "/#{second_publisher}" if second_publisher
-            parts << code.to_s if code && code.to_s != ""
-
-          elsif joint_publisher
-            # ISO/ASME or ASME/ANS format
-            parts << joint_publisher
-            parts << code.to_s if code && code.to_s != ""
-
-          else
-            # Standard ASME format
-            parts << publisher if publisher
-            parts << code.to_s if code
-
-          end
-          result = parts.join(" ")
-
-          # PTC suffix (space-separated)
-          if ptc_suffix
-            result += " #{ptc_suffix}"
-          end
-
-          # CSA dual-published (for ASME/CSA format)
-          if csa_number
-            result += "/CSA #{csa_number}"
-          end
-
-          # Handbook keyword
-          if handbook
-            result += " Handbook"
-          end
-
-          # Year
-          if draft_year
-            result += "-#{draft_year}"
-          elsif year
-            result += "-#{year}"
-          end
-
-          # Parenthetical revision (comes after year)
-          result += " #{parenthetical_revision}" if parenthetical_revision
-
-          # Language (can appear in rendered output)
-          result += " (#{language})" if language
-
-          # Reaffirmation
-          result += " (#{reaffirmation})" if reaffirmation
-
-          # Revision note
-          result += " #{revision_note}" if revision_note
-
-          # Normalize all em-dashes (–, —) and en-dashes to regular dash (-)
-          result.gsub(/[–—]/, "-")
-        end
       end
     end
   end

data/lib/pubid/asme/renderer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    # Human-readable renderer for ASME identifiers.
+    #
+    # Produces strings like:
+    #   "ASME B16.5-2020"
+    #   "CSA B44.10/ASME A17.10"
+    #   "ASME BPVC III.1.NB-2023"
+    #   "ASME PTC 4-2013"
+    #
+    # The renderer is registered as the `:human` format in the ASME format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+        parts = []
+
+        if id.first_publisher && id.first_code
+          # CSA B44.10/ASME A17.10 or API 579-2/ASME PTB-14 format
+          parts << id.first_publisher
+          parts << id.first_code
+          parts << "/#{id.second_publisher}" if id.second_publisher
+          parts << id.code.to_s if id.code && id.code.to_s != ""
+        elsif id.joint_publisher
+          # ISO/ASME or ASME/ANS format
+          parts << id.joint_publisher
+          parts << id.code.to_s if id.code && id.code.to_s != ""
+        else
+          # Standard ASME format
+          parts << id.publisher if id.publisher
+          parts << id.code.to_s if id.code
+        end
+
+        result = parts.join(" ")
+
+        if id.ptc_suffix
+          result += " #{id.ptc_suffix}"
+        end
+
+        if id.csa_number
+          result += "/CSA #{id.csa_number}"
+        end
+
+        if id.handbook
+          result += " Handbook"
+        end
+
+        if id.draft_year
+          result += "-#{id.draft_year}"
+        elsif id.year
+          result += "-#{id.year}"
+        end
+
+        result += " #{id.parenthetical_revision}" if id.parenthetical_revision
+        result += " (#{id.language})" if id.language
+        result += " (#{id.reaffirmation})" if id.reaffirmation
+        result += " #{id.revision_note}" if id.revision_note
+
+        # Normalize all em-dashes and en-dashes to regular dash
+        result.gsub(/[–—]/, "-")
+      end
+    end
+  end
+end

data/lib/pubid/asme/urn_parser.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Asme
+    # Parses ASME URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:asme:{publisher}:{code}:{year}
+    #
+    # publisher is the lowercase publisher string. code is the alphanumeric
+    # designation (e.g., "B16.5", "PTC1", "BPVC-2023"). The year separator
+    # in human-readable form is `-`, not `:`.
+    #
+    # Examples:
+    # - urn:asme:asme:B16.5:2020   → ASME B16.5-2020
+    # - urn:asme:asme:PTC1:2020    → ASME PTC1-2020
+    # - urn:asme:asme:BPVC-2023    → ASME BPVC-2023
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        _publisher, code, year = parts
+
+        text = "ASME #{code}"
+        text += "-#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

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/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