pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

data/lib/pubid/api/single_identifier.rb

@@ -2,36 +2,21 @@
 
 module Pubid
   module Api
-    class SingleIdentifier < Pubid::Identifier
+    class SingleIdentifier < Identifier
       # Generate URN for this identifier
       #
       # @return [String] URN representation
 
-      def publisher
-        "API"
-      end
+      # Stored as a plain string (always "API") so it round-trips through
+      # to_hash/from_hash. Was a `def publisher` method, which made lutaml
+      # serialize a String against the Components::Publisher attribute.
+      attribute :publisher, :string, default: -> { "API" }
 
       attribute :code, Components::Code
       attribute :part, :string
       attribute :year, :string
       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
-      end
-
       private
 
       def code_portion

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

@@ -1,57 +1,9 @@
 # frozen_string_literal: true
 
-module Pubid
-  module Ashrae
-    module Identifier
-      # 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
-      # @raise [Parslet::ParseFailed] If parsing fails
-      def self.parse(identifier)
-        parsed = Parser.parse(identifier)
-        Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse ASHRAE identifier '#{identifier}': #{e.message}"
-      end
-
-      # Factory that builds an ASHRAE identifier from a hash of primitives.
-      # Dispatch on `:type` to the matching subclass; default is
-      # {Identifiers::Standard}.
-      TYPE_KEY_TO_KLASS = {
-        standard:         "Standard",
-        guideline:        "Guideline",
-        addendum:         "Addendum",
-        addenda_package:  "AddendaPackage",
-        combined_addenda: "CombinedAddenda",
-        errata:           "Errata",
-        interpretation:   "Interpretation",
-      }.freeze
-
-      def self.create(type: nil, **opts)
-        klass = resolve_create_class(type)
-        klass.new(**coerce_create_attrs(opts))
-      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 ASHRAE type: #{type.inspect}" unless klass_name
-
-        Identifiers.const_get(klass_name)
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = { publisher: (opts[:publisher] || "ASHRAE").to_s }
-        if (v = opts[:code] || opts[:number])
-          attrs[:code] = v.to_s
-        end
-        %i[year suffix amendment reaffirmed copublisher].each do |k|
-          attrs[k] = opts[k].to_s unless opts[k].nil?
-        end
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
-    end
-  end
-end
+# The ASHRAE flavor base class is Pubid::Ashrae::Identifier — a real
+# Pubid::Identifier subclass that every concrete ASHRAE identifier descends
+# from, so `is_a?` identity and the shared polymorphic `from_hash` work natively
+# (no facade needed). Its body, `.parse`, and the Identifiers::Base back-compat
+# alias live in identifiers/base.rb; this file just ensures it is loaded when a
+# consumer references Pubid::Ashrae::Identifier directly.
+require_relative "identifiers/base"

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

@@ -2,22 +2,36 @@
 
 module Pubid
   module Ashrae
-    module Identifiers
-      # Base class for all ASHRAE identifiers
-      class Base < Pubid::Identifier
-        attribute :publisher, :string, default: "ASHRAE"
-        attribute :code, :string
-        attribute :year, :string
-        attribute :type, :string
-        attribute :suffix, :string # R (revision), P (proposed), etc.
-        attribute :amendment, :string
-        attribute :reaffirmed, :string
-        attribute :copublisher, :string
-
-        def self.parse(string)
-          Ashrae::Identifier.parse(string)
-        end
+    # Base class for all ASHRAE identifiers. Canonical name
+    # Pubid::Ashrae::Identifier; every concrete ASHRAE identifier descends from
+    # it, and Identifiers::Base — aliased at the foot of this file — points back
+    # to it.
+    class Identifier < ::Pubid::Identifier
+      # Parse an ASHRAE identifier string into an identifier object
+      # @param identifier [String] The ASHRAE identifier string to parse
+      # @return [Pubid::Ashrae::Identifier] The appropriate identifier object
+      # @raise [Parslet::ParseFailed] If parsing fails
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse ASHRAE identifier '#{identifier}': #{e.message}"
       end
+
+      attribute :publisher, :string, default: "ASHRAE"
+      attribute :code, :string
+      attribute :year, :string
+      attribute :type, :string
+      attribute :suffix, :string # R (revision), P (proposed), etc.
+      attribute :amendment, :string
+      attribute :reaffirmed, :string
+      attribute :copublisher, :string
+    end
+
+    module Identifiers
+      # Backward-compatible alias: ASHRAE's base class used to be
+      # Pubid::Ashrae::Identifiers::Base. It is now Pubid::Ashrae::Identifier.
+      Base = Pubid::Ashrae::Identifier
     end
   end
 end

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

data/lib/pubid/ashrae/parser.rb

@@ -650,6 +650,10 @@ module Pubid
       root(:identifier)
 
       def self.parse(string)
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         # Strip leading/trailing whitespace
         cleaned = string.strip
 

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,61 @@ 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)
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       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)