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

data/lib/pubid/api/builder.rb

@@ -1,84 +1,39 @@
 # frozen_string_literal: true
 
-require_relative "components/code"
-require_relative "identifiers/bulletin"
-require_relative "identifiers/mpms"
-require_relative "identifiers/recommended_practice"
-require_relative "identifiers/specification"
-require_relative "identifiers/standard"
-require_relative "identifiers/technical_report"
-require_relative "identifiers/continuous_operations_standard"
-require_relative "identifiers/publication"
-require_relative "identifiers/typeless_standard"
-
 module Pubid
   module Api
-    class Builder
-      def build(parsed_hash)
-        # Determine identifier class based on type
-        identifier_class = case parsed_hash[:type]&.to_s
-                           when "BULL"
-                             Identifiers::Bulletin
-                           when "MPMS"
-                             Identifiers::Mpms
-                           when "RP"
-                             Identifiers::RecommendedPractice
-                           when "SPEC"
-                             Identifiers::Specification
-                           when "STD"
-                             Identifiers::Standard
-                           when "TR"
-                             Identifiers::TechnicalReport
-                           when "COS"
-                             Identifiers::ContinuousOperationsStandard
-                           when "PUBL"
-                             Identifiers::Publication
-                           else
-                             # No type = typeless standard
-                             Identifiers::TypelessStandard
-                           end
-
-        identifier = identifier_class.new
-
-        # Number (for non-MPMS)
-        if parsed_hash[:number]
-          identifier.code = Components::Code.new(value: parsed_hash[:number].to_s)
-        end
-
-        # Part
-        if parsed_hash[:part]
-          identifier.part = parsed_hash[:part].to_s
-        end
-
-        # MPMS-specific attributes
-        if parsed_hash[:chapter]
-          identifier.chapter = parsed_hash[:chapter].to_s
-        end
-
-        if parsed_hash[:section]
-          identifier.section = parsed_hash[:section].to_s
-        end
-
-        if parsed_hash[:subsection]
-          identifier.subsection = parsed_hash[:subsection].to_s
-        end
+    class Builder < Pubid::Builder::Base
+      TYPE_CLASS_MAP = {
+        "BULL" => Identifiers::Bulletin,
+        "MPMS" => Identifiers::Mpms,
+        "RP" => Identifiers::RecommendedPractice,
+        "SPEC" => Identifiers::Specification,
+        "STD" => Identifiers::Standard,
+        "TR" => Identifiers::TechnicalReport,
+        "COS" => Identifiers::ContinuousOperationsStandard,
+        "PUBL" => Identifiers::Publication,
+      }.freeze
+
+      private
+
+      def default_identifier_class
+        Identifiers::TypelessStandard
+      end
 
-        # Year
-        if parsed_hash[:year]
-          identifier.year = parsed_hash[:year].to_s
-        end
+      def select_class(data)
+        TYPE_CLASS_MAP[data[:type]&.to_s] || default_identifier_class
+      end
 
-        # Reaffirmation (nested hash with year inside)
-        if parsed_hash[:reaffirmation]
-          reaffirm_data = parsed_hash[:reaffirmation]
-          identifier.reaffirmation = if reaffirm_data.is_a?(Hash) && reaffirm_data[:year]
-                                       reaffirm_data[:year].to_s
-                                     else
-                                       reaffirm_data.to_s
-                                     end
+      def cast(key, value)
+        case key
+        when :number then Components::Code.new(value: value.to_s)
+        when :reaffirmation
+          value.is_a?(Hash) ? (value[:year] || value).to_s : value.to_s
+        when :part, :chapter, :section, :subsection, :year
+          value.to_s
+        else
+          super
         end
-
-        identifier
       end
     end
   end

data/lib/pubid/api/identifier.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "parser"
-require_relative "builder"
-require_relative "single_identifier"
-
 module Pubid
   module Api
     class Identifier

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../single_identifier"
-
 module Pubid
   module Api
     module Identifiers

data/lib/pubid/api/identifiers/bulletin.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

data/lib/pubid/api/identifiers/continuous_operations_standard.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

data/lib/pubid/api/identifiers/mpms.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers
@@ -15,21 +13,7 @@ module Pubid
         end
 
         def to_s
-          parts = ["API", "MPMS"]
-
-          # Add chapter
-          parts << "CH #{chapter}" if chapter
-
-          # Add section/subsection
-          if section
-            parts << ".#{section}"
-            parts << ".#{subsection}" if subsection
-          end
-
-          # Add year
-          parts << "-#{year}" if year
-
-          parts.join(" ").gsub(" .", ".")
+          render(format: :human)
         end
 
         private

data/lib/pubid/api/identifiers/publication.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

data/lib/pubid/api/identifiers/recommended_practice.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

data/lib/pubid/api/identifiers/specification.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers

data/lib/pubid/api/identifiers/typeless_standard.rb

@@ -1,25 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Api
     module Identifiers
       class TypelessStandard < Base
         # No type_string method - renders without type
         def to_s
-          parts = ["API"]
-
-          # Add code/number
-          parts << code_portion if code_portion
-
-          # Add year
-          parts << "-#{year}" if year
-
-          # Add reaffirmation
-          parts << " (R#{reaffirmation})" if reaffirmation
-
-          parts.join(" ")
+          render(format: :human)
         end
       end
     end

data/lib/pubid/api/identifiers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Identifiers
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Bulletin, "#{__dir__}/identifiers/bulletin"
+      autoload :ContinuousOperationsStandard, "#{__dir__}/identifiers/continuous_operations_standard"
+      autoload :Mpms, "#{__dir__}/identifiers/mpms"
+      autoload :Publication, "#{__dir__}/identifiers/publication"
+      autoload :RecommendedPractice, "#{__dir__}/identifiers/recommended_practice"
+      autoload :Specification, "#{__dir__}/identifiers/specification"
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+      autoload :TypelessStandard, "#{__dir__}/identifiers/typeless_standard"
+    end
+  end
+end

data/lib/pubid/api/renderer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    # Human-readable renderer for API identifiers.
+    #
+    # Produces strings like:
+    #   "API Std 650"
+    #   "API MPMS CH 4.1"
+    #   "API 5L-2018"
+    #
+    # The renderer is registered as the +:human+ format in the API format
+    # registry and invoked via +render(format: :human)+.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::Mpms
+          render_mpms(id)
+        when Identifiers::TypelessStandard
+          render_typeless(id)
+        else
+          render_default(id)
+        end
+      end
+
+      private
+
+      def render_default(id)
+        parts = ["API"]
+
+        # Add type if available
+        if id.class.attributes.key?(:type_string) && id.type_string
+          parts << id.type_string
+        end
+
+        # Add code/number with part as one token
+        parts << code_portion(id) if code_portion(id)
+
+        result = parts.join(" ")
+        result += "-#{id.year}" if id.year
+        result += " (R#{id.reaffirmation})" if id.reaffirmation
+        result
+      end
+
+      def render_mpms(id)
+        parts = ["API", "MPMS"]
+
+        # Add chapter
+        parts << "CH #{id.chapter}" if id.chapter
+
+        # Add section/subsection
+        if id.section
+          parts << ".#{id.section}"
+          parts << ".#{id.subsection}" if id.subsection
+        end
+
+        # Add year
+        parts << "-#{id.year}" if id.year
+
+        parts.join(" ").gsub(" .", ".")
+      end
+
+      def render_typeless(id)
+        parts = ["API"]
+
+        # Add code/number
+        parts << code_portion(id) if code_portion(id)
+
+        # Add year
+        parts << "-#{id.year}" if id.year
+
+        # Add reaffirmation
+        parts << " (R#{id.reaffirmation})" if id.reaffirmation
+
+        parts.join(" ")
+      end
+
+      def code_portion(id)
+        return nil unless id.code
+
+        code_str = id.code.to_s
+        code_str += "-#{id.part}" if id.part
+        code_str
+      end
+    end
+  end
+end

data/lib/pubid/api/single_identifier.rb

@@ -17,19 +17,7 @@ module Pubid
       attribute :reaffirmation, :string
 
       def to_s
-        parts = ["API"]
-
-        # Add type if available
-        parts << type_string if self.class.attributes.key?(:type_string) && type_string
-
-        # Add code/number with part as one token
-        parts << code_portion if code_portion
-
-        # Build result - join with space, then add dash+year as one token
-        result = parts.join(" ")
-        result += "-#{year}" if year
-        result += " (R#{reaffirmation})" if reaffirmation
-        result
+        render(format: :human)
       end
 
       private

data/lib/pubid/api/urn_generator.rb

@@ -7,24 +7,6 @@ module Pubid
         "std"
       end
 
-      def urn_number
-        return nil unless identifier.code
-
-        identifier.code.value.to_s
-      end
-
-      def urn_part
-        return nil unless identifier.part
-
-        "-#{identifier.part}"
-      end
-
-      def urn_year
-        return identifier.year.to_s if identifier.year
-
-        nil
-      end
-
       def generate
         parts = ["urn", "api"]
         parts << urn_type

data/lib/pubid/api/urn_parser.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    # Parses API URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:api:{publisher}:{number}[-{part}]:{year}
+    # where slot[1] is the publisher (default "api"), slot[2] is the number
+    # with optional `-part` suffix, slot[3] is the optional year.
+    #
+    # Examples:
+    # - urn:api:api:1104              → API STD 1104
+    # - urn:api:api:1104-1:2020       → API STD 1104-1:2020
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        _type, number = parts
+        idx = 2
+        part = nil
+        if parts[idx]&.start_with?("-")
+          part = parts[idx]
+          idx += 1
+        end
+        year = parts[idx]
+
+        text = "API STD #{number}#{part}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/api.rb

@@ -1,17 +1,63 @@
 # frozen_string_literal: true
 
-require_relative "api/identifier"
-require_relative "api/scheme"
-
 module Pubid
   module Api
+    autoload :Builder, "#{__dir__}/api/builder"
+    autoload :Identifier, "#{__dir__}/api/identifier"
+    autoload :Identifiers, "#{__dir__}/api/identifiers"
+    autoload :Parser, "#{__dir__}/api/parser"
+    autoload :Renderer, "#{__dir__}/api/renderer"
+    autoload :SingleIdentifier, "#{__dir__}/api/single_identifier"
+    autoload :UrnGenerator, "#{__dir__}/api/urn_generator"
+    autoload :UrnParser, "#{__dir__}/api/urn_parser"
+
     def self.parse(input)
       Identifier.parse(input)
     end
-  end
 
-  # Register this flavor with the Pubid registry
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
+    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 < Pubid::Identifier }
+        .reject { |c| c.name&.split("::")&.last == "Base" }
+    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 }
+    rescue NoMethodError
+      nil
+    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 Uapi flavor with the registry
 Pubid::Registry.register(:api, Pubid::Api)
+
+# Per-flavor format registry: inherits global formats, overrides :human
+Pubid::Api::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Api::Identifiers::Base.format_registry.register(:human, renderer: Pubid::Api::Renderer)

data/lib/pubid/ashrae/builder.rb

@@ -3,7 +3,7 @@
 module Pubid
   module Ashrae
     # Builder class for constructing ASHRAE identifier scheme from parsed data
-    # Single Responsibility: Transform parsed data into Scheme objects
+    # Single Responsibility: Transform parsed data into identifier objects
     class Builder
       attr_reader :identifier_class
 
@@ -13,7 +13,7 @@ module Pubid
 
       # Build a scheme object from parsed data
       # @param parsed [Hash, Array] the parsed identifier data
-      # @return [Scheme] the constructed scheme object
+      # @return [identifier] the constructed scheme object
       def build(parsed)
         # Parslet can return array of hashes - merge them
         parsed_hash = parsed.is_a?(Array) ? merge_parsed_array(parsed) : parsed
@@ -71,7 +71,7 @@ module Pubid
 
       # Extract and normalize attributes from parsed data
       # @param parsed [Hash] the parsed data
-      # @return [Hash] normalized attributes for Scheme
+      # @return [Hash] normalized attributes for identifier
       def extract_attributes(parsed)
         attributes = {}
 

data/lib/pubid/ashrae/identifier.rb

@@ -2,7 +2,13 @@
 
 module Pubid
   module Ashrae
+    # `extend Pubid::IdentifierFacade` adds polymorphic `from_hash` and pairs
+    # with `include Pubid::Ashrae::Identifier` in Identifiers::Base for identity
+    # (`is_a?`/`===`), so a consumer handed this module can deserialize and
+    # identity-check ASHRAE ids through it.
     module Identifier
+      extend Pubid::IdentifierFacade
+
       # Parse an ASHRAE identifier string into an identifier object
       # @param identifier [String] The ASHRAE identifier string to parse
       # @return [Identifiers::Base] The appropriate identifier object

data/lib/pubid/ashrae/identifiers/addenda_package.rb

@@ -27,16 +27,6 @@ module Pubid
             short: "Addenda Package" }
         end
 
-        def to_s
-          return base_identifier.to_s unless base_identifier
-
-          # Format: ASHRAE Standard 52.2-1999: Addenda Supplement Package
-          result = "ASHRAE #{base_identifier.type || 'Standard'} #{base_identifier.code}"
-          result += "-#{base_identifier.year}" if base_identifier.year
-          result += ": Addenda #{package_description}" if package_description
-          result
-        end
-
         def copublisher
           base_identifier&.copublisher
         end

data/lib/pubid/ashrae/identifiers/addendum.rb

@@ -27,25 +27,6 @@ module Pubid
           { key: :addendum, title: "ASHRAE Addendum", short: "Addendum" }
         end
 
-        def to_s
-          return base_identifier.to_s unless base_identifier
-
-          # Determine base type name for rendering
-          base_type = base_identifier.type || "Standard"
-
-          if copublisher
-            # Format: ANSI/ASHRAE Addendum a to ANSI/ASHRAE Standard 15-2019
-            result = "#{copublisher} Addendum #{addendum_code} to #{base_identifier}"
-          else
-            # Format: ASHRAE Addendum a to Standard 15-2001
-            result = "ASHRAE Addendum #{addendum_code} to #{base_type} #{base_identifier.code}"
-            result += "-#{base_identifier.year}" if base_identifier.year
-          end
-
-          result += " (#{addendum_date})" if addendum_date
-          result
-        end
-
         def copublisher
           base_identifier&.copublisher
         end

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

@@ -5,6 +5,9 @@ module Pubid
     module Identifiers
       # Base class for all ASHRAE identifiers
       class Base < Pubid::Identifier
+        # Identity for the Pubid::Ashrae::Identifier facade (see its comment).
+        include Pubid::Ashrae::Identifier
+
         attribute :publisher, :string, default: "ASHRAE"
         attribute :code, :string
         attribute :year, :string

data/lib/pubid/ashrae/identifiers/combined_addenda.rb

@@ -27,21 +27,6 @@ module Pubid
             short: "Addenda" }
         end
 
-        def to_s
-          return base_identifier.to_s unless base_identifier
-
-          base_type = base_identifier.type || "Standard"
-          if addendum_codes
-            # Format: ASHRAE Addenda c and d to Standard 15-1994
-            result = "ASHRAE Addenda #{addendum_codes} to #{base_type} #{base_identifier.code}"
-          else
-            # Format: ASHRAE Addenda to Standard 15-1994 (no specific codes)
-            result = "ASHRAE Addenda to #{base_type} #{base_identifier.code}"
-          end
-          result += "-#{base_identifier.year}" if base_identifier.year
-          result
-        end
-
         def copublisher
           base_identifier&.copublisher
         end

data/lib/pubid/ashrae/identifiers/errata.rb

@@ -24,16 +24,6 @@ module Pubid
         def self.type
           { key: :errata, title: "ASHRAE Errata", short: "Errata" }
         end
-
-        def to_s
-          return base_identifier.to_s unless base_identifier
-
-          # Format: ASHRAE Guideline 0-2005 Errata (September 28, 2011)
-          result = base_identifier.to_s
-          result += " Errata"
-          result += " (#{errata_date})" if errata_date
-          result
-        end
       end
     end
   end

data/lib/pubid/ashrae/identifiers/interpretation.rb

@@ -23,16 +23,6 @@ module Pubid
           { key: :interpretation, title: "ASHRAE Interpretations",
             short: "Interpretations" }
         end
-
-        def to_s
-          return base_identifier.to_s unless base_identifier
-
-          # Format: Interpretations for Standard 15.2-2022
-          base_type = base_identifier.type || "Standard"
-          result = "Interpretations for #{base_type} #{base_identifier.code}"
-          result += "-#{base_identifier.year}" if base_identifier.year
-          result
-        end
       end
     end
   end