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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16698d2e32777261efbf6842754351b03a2a0d272992ca1525ebd3fbedaf648d
-  data.tar.gz: 46d2aa4fb40d9f9ab3fcf7f42bdc3c9b2662637653a9e5c98f26baebecaea0cd
+  metadata.gz: fd077b48356a46dfb52d7b95e932c29e91e5fe1a7859c1128ddda22d768b4a96
+  data.tar.gz: 4e8059d20bed9297393f54bb894958a6c0ab8d92bef895fcb7528c291b3ff349
 SHA512:
-  metadata.gz: 638b16ccaed8a371fecee3ec8372a9790ae4649d689d0aeafa306b4b1681e0df42365d5ede2da46da743f8b42e7a70ddcc882774a6c6c333a1a2fec8d30255e4
-  data.tar.gz: 2d55ed5b29d6121665c808d697832307bcea629345b7782308c5c0fe76ffc9baae849f752a8f75b5d77c7b3aaed782be9e15dcc9e1dc85e7c229ae77cf4431b8
+  metadata.gz: 329f3776c53f4021bfd2d25bd8698fb9c01309a66f56e9334d815aee3fde8ce25b509637f97ffc4ef91f0dfb67d10768a33505a939109a305d34b2e917af8f6c
+  data.tar.gz: 79c43b4e3ca83fe379a588f20490850e6a88757e382f0f9b9fc88d9f31923aff8fd8a5d48670c33a0d0705747820c6b3548260334ebf4e63a09b60dab82ad4ec

data/README.adoc

@@ -1729,9 +1729,13 @@ The V2 implementation strictly follows these design principles:
 
 Object-Oriented Design:: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
 MECE Organization:: Mutually Exclusive (no overlap), Collectively Exhaustive (full coverage), clear boundaries
-Separation of Concerns:: Parser handles syntax only, Builder handles transformation only, Identifier handles rendering only
+Separation of Concerns:: Parser handles syntax only, Builder handles transformation only, Renderer handles formatting only
+Self-Describing Types:: Each identifier class IS the type definition — no central registry required for type metadata
+Renderer Pattern:: Dedicated per-flavor Renderer classes handle human-readable output; identifier `to_s` delegates to `render(format: :human)` via `FormatRegistry`
+Single Source of Truth:: Series matching, type metadata, and rendering logic live in exactly one place per concern
 Extensibility:: Use inheritance and polymorphism, plugin/registry architecture, avoid hardcoding
 Test Quality:: Each class has dedicated spec file, no lowering pass thresholds, test actual behavior
+Autoload Everywhere:: Ruby autoload replaces `require_relative` for internal library code — lazy loading, no circular dependency risk
 
 === Pre-parser Normalization (update_codes.yaml)
 

data/data/nist/update_codes.yaml

@@ -1,3 +1,28 @@
+# NIST pre-parser normalization rules.
+#
+# This file is applied to every NIST identifier string BEFORE any Ruby
+# preprocessing (see lib/pubid/nist/preprocessor.rb). Each entry is one
+# of:
+#
+#   "plain string": "replacement"
+#       Full-line match (^...$), literal. Use for specific malformed IDs
+#       that have a single canonical form.
+#
+#   "/regex/": "replacement"          (no flags)
+#   "/regex/imx": "replacement"       (i = IGNORECASE, m = MULTILINE,
+#                                       x = EXTENDED)
+#       Applied via gsub. Use for general patterns that are pure
+#       string→string substitutions.
+#
+# Design split (MECE):
+#   - This file: data-driven lookups and pure subs that any maintainer
+#     (including non-Rubyists) can extend safely.
+#   - Preprocessor (Ruby): stateful or interdependent transformations
+#     where stage order, conditional logic, or external state (e.g.,
+#     Roman numeral conversion, year-range reverts) make YAML unsuitable.
+#
+# Reorder entries with care — later entries often match patterns produced
+# by earlier ones. Run `bundle exec rspec spec/pubid/nist/` after edits.
 NBS MN: NBS MONO
 NIST MN: NIST MONO
 NIST MP: NBS MP

data/lib/pubid/amca/builder.rb

@@ -3,7 +3,7 @@
 module Pubid
   module Amca
     # Builder class for constructing ACMA 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

data/lib/pubid/amca/identifier.rb

@@ -1,57 +1,6 @@
 # frozen_string_literal: true
 
-module Pubid
-  module Amca
-    module Identifier
-      # Parse an ACMA identifier string into an identifier object
-      # @param identifier [String] The ACMA identifier string to parse
-      # @return [Pubid::Amca::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 ACMA identifier '#{identifier}': #{e.message}"
-      end
-
-      # Factory that builds an AMCA identifier from a hash of primitives.
-      #
-      # Dispatch on `:type`:
-      #   * `:standard` (default) → Identifiers::Standard
-      #   * `:publication`        → Identifiers::Publication
-      #   * `:interpretation`     → Identifiers::Interpretation
-      #
-      # AMCA stores the "AMCA" prefix in the `copublisher` string
-      # attribute (matching parsed output); `.create` defaults it to
-      # "AMCA" unless the caller supplies one.
-      def self.create(type: nil, **opts)
-        klass = resolve_create_class(type)
-        klass.new(**coerce_create_attrs(opts))
-      end
-
-      def self.resolve_create_class(type)
-        case type&.to_sym
-        when nil, :standard       then Identifiers::Standard
-        when :publication         then Identifiers::Publication
-        when :interpretation      then Identifiers::Interpretation
-        else
-          raise ArgumentError, "Unknown AMCA type: #{type.inspect}"
-        end
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = { copublisher: (opts[:copublisher] || "AMCA").to_s }
-        if (v = opts[:code] || opts[:number])
-          attrs[:code] = Pubid::Components::Code.new(value: v.to_s)
-        end
-        if (v = opts[:year])
-          attrs[:year] = Pubid::Components::Date.new(year: v.to_s)
-        end
-        attrs[:suffix] = opts[:suffix].to_s if opts[:suffix]
-        attrs[:reaffirmed] = opts[:reaffirmed].to_s if opts[:reaffirmed]
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
-    end
-  end
-end
+# Pubid::Amca::Identifier is the AMCA base class (a real Pubid::Identifier
+# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
+# live in identifiers/base.rb. This file just ensures it is loaded.
+require_relative "identifiers/base"

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

@@ -2,63 +2,74 @@
 
 module Pubid
   module Amca
-    module Identifiers
-      # Base identifier class for ACMA identifiers
-      # Single Responsibility: Common functionality for all ACMA identifier types
-      class Base < Pubid::Identifier
-        # Override base_hash to handle AMCA-specific copublisher format (string, not array)
-        def base_hash
-          hash = super
-          # AMCA's copublisher is a string, not an array, so remove it from copublishers
-          hash.delete(:copublishers) if hash[:copublishers]
-          hash
-        end
+    # Base identifier class for AMCA identifiers. Canonical name
+    # Pubid::Amca::Identifier (Identifiers::Base is a back-compat alias); common
+    # functionality for all AMCA identifier types.
+    class Identifier < ::Pubid::Identifier
+      # @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 ACMA identifier '#{identifier}': #{e.message}"
+      end
 
-        attribute :copublisher, :string
-        attribute :code, Components::Code
-        attribute :year, Components::Date
-        attribute :suffix, :string
-        attribute :reaffirmed, :string
+      # Stored as a plain string (always "AMCA") 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 and raise.
+      attribute :publisher, :string, default: -> { "AMCA" }
+      attribute :copublisher, :string
+      attribute :code, Components::Code
+      attribute :year, Components::Date
+      attribute :suffix, :string
+      attribute :reaffirmed, :string
 
-        # AMCA uses a fixed publisher string
-        def publisher
-          "AMCA"
-        end
+      # Explicit key_value mapping: only these keys serialize (the inherited
+      # Pubid::Identifier attributes — including :type, which subclasses expose
+      # as a class-metadata Hash via `self.type` — are intentionally dropped).
+      # code/year are flattened to their scalar value and rebuilt on load, since
+      # the Builder may store them as either a String or a component.
+      key_value do
+        map "_type", to: :_type
+        map "publisher", to: :publisher
+        map "copublisher", to: :copublisher
+        map "code", with: { to: :code_to_kv, from: :code_from_kv }
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "suffix", to: :suffix
+        map "reaffirmed", to: :reaffirmed
+      end
 
-        # Render the identifier as a string
-        def to_s
-          parts = []
-          parts << copublisher if copublisher
-          # type is a hash, get the title
-          t = self.class.attributes.key?(:type) ? type : nil
-          if t.is_a?(Hash) && t[:title]
-            parts << t[:title].to_s
-          end
-          parts << code.to_s
-          parts << "-#{year}" if year
+      def to_urn
+        UrnGenerator.new(self).generate
+      end
 
-          result = parts.compact.join(" ")
+      def code_to_kv(model, doc)
+        v = model.code.is_a?(::Pubid::Components::Code) ? model.code.value : model.code
+        return if v.nil? || v.to_s.empty?
 
-          # Handle additional copublisher after year (e.g., /ASHRAE 51-16)
-          if copublisher&.include?("/") && year
-            type_title = t.is_a?(Hash) ? t[:title].to_s : ""
-            result = "#{copublisher} #{type_title} #{code}-#{year}"
-          end
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("code", v.to_s))
+      end
 
-          result += " (#{reaffirmed})" if reaffirmed
+      def code_from_kv(model, value)
+        model.code = ::Pubid::Components::Code.new(value: value.to_s)
+      end
 
-          result
-        end
+      def year_to_kv(model, doc)
+        y = model.year.is_a?(::Pubid::Components::Date) ? model.year.year : model.year
+        return if y.nil? || y.to_s.empty?
 
-        def self.parse(string)
-          Amca::Identifier.parse(string)
-        end
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("year", y.to_s))
+      end
 
-        def to_urn
-          require_relative "../urn_generator"
-          UrnGenerator.new(self).generate
-        end
+      def year_from_kv(model, value)
+        model.year = ::Pubid::Components::Date.new(year: value.to_s)
       end
     end
+
+    module Identifiers
+      # Backward-compatible alias: AMCA's base class used to be
+      # Pubid::Amca::Identifiers::Base. It is now Pubid::Amca::Identifier.
+      Base = Pubid::Amca::Identifier
+    end
   end
 end

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

@@ -24,27 +24,6 @@ reaffirmed: nil, interpretation_code: nil)
         def self.type
           { key: :interpretation, title: "Interpretation", short: "Interp" }
         end
-
-        def type
-          Interpretation.type
-        end
-
-        # @return [String] the rendered interpretation identifier
-        def to_s
-          parts = []
-          parts << @copublisher if @copublisher
-          parts << @code.to_s
-
-          if @interpretation_code
-            parts << "– #{@interpretation_code}"
-          elsif @year
-            parts << "-#{@year}"
-          end
-
-          parts << " #{@suffix}" if @suffix
-
-          parts.join(" ").squeeze(" ")
-        end
       end
     end
   end

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

@@ -24,23 +24,6 @@ reaffirmed: nil, revision: nil)
         def self.type
           { key: :publication, title: "Publication", short: nil }
         end
-
-        def type
-          Publication.type
-        end
-
-        # @return [String] the rendered publication identifier
-        def to_s
-          parts = []
-          parts << @copublisher if @copublisher
-          parts << "Publication"
-          parts << @code.to_s
-          parts << "-#{@year}" if @year
-          parts << " (Rev. #{@revision})" if @revision
-          parts << " (#{@reaffirmed})" if @reaffirmed && !@revision
-
-          parts.join(" ").squeeze(" ")
-        end
       end
     end
   end

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

@@ -12,10 +12,6 @@ module Pubid
         def self.type
           { key: :standard, title: "Standard", short: nil }
         end
-
-        def type
-          Standard.type
-        end
       end
     end
   end

data/lib/pubid/amca/renderer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Human-readable renderer for AMCA identifiers.
+    #
+    # Produces strings like:
+    #   "AMCA Standard 210-16"
+    #   "AMCA Publication 211-22 (Rev. 01-23)"
+    #   "ANSI/AMCA 204 Interp"
+    #   "AMCA 99 JW Interp"
+    #
+    # The renderer is registered as the `:human` format in the AMCA format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::Publication
+          render_publication(id)
+        when Identifiers::Interpretation
+          render_interpretation(id)
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      def render_base(id)
+        parts = []
+        parts << id.copublisher if id.copublisher
+        t = id.class.respond_to?(:type) ? id.class.type : nil
+        if t.is_a?(Hash) && t[:title]
+          parts << t[:title].to_s
+        end
+        parts << id.code.to_s
+        parts << "-#{id.year}" if id.year
+
+        result = parts.compact.join(" ")
+
+        if id.copublisher&.include?("/") && id.year
+          type_title = t.is_a?(Hash) ? t[:title].to_s : ""
+          result = "#{id.copublisher} #{type_title} #{id.code}-#{id.year}"
+        end
+
+        result += " (#{id.reaffirmed})" if id.reaffirmed
+
+        result
+      end
+
+      def render_publication(id)
+        parts = []
+        parts << id.copublisher if id.copublisher
+        parts << "Publication"
+        parts << id.code.to_s
+        parts << "-#{id.year}" if id.year
+        parts << " (Rev. #{id.revision})" if id.revision
+        parts << " (#{id.reaffirmed})" if id.reaffirmed && !id.revision
+
+        parts.join(" ").squeeze(" ")
+      end
+
+      def render_interpretation(id)
+        parts = []
+        parts << id.copublisher if id.copublisher
+        parts << id.code.to_s
+
+        if id.interpretation_code
+          parts << "– #{id.interpretation_code}"
+        elsif id.year
+          parts << "-#{id.year}"
+        end
+
+        parts << " #{id.suffix}" if id.suffix
+
+        parts.join(" ").squeeze(" ")
+      end
+    end
+  end
+end

data/lib/pubid/amca/single_identifier.rb

@@ -5,29 +5,6 @@ module Pubid
     # Base class for single (non-supplement) ACMA identifiers
     # Includes: Standard, Publication
     class SingleIdentifier < Identifiers::Base
-      def to_s
-        parts = []
-        parts << copublisher if copublisher
-        # type is a hash, get the title
-        t = self.class.attributes.key?(:type) ? type : nil
-        if t.is_a?(Hash) && t[:title]
-          parts << t[:title].to_s
-        end
-        parts << code.to_s
-        parts << "-#{year}" if year
-
-        result = parts.compact.join(" ")
-
-        # Handle additional copublisher after year (e.g., /ASHRAE 51-16)
-        if copublisher&.include?("/") && year
-          type_title = t.is_a?(Hash) ? t[:title].to_s : ""
-          result = "#{copublisher} #{type_title} #{code}-#{year}"
-        end
-
-        result += " (#{reaffirmed})" if reaffirmed
-
-        result
-      end
     end
   end
 end

data/lib/pubid/amca/urn_generator.rb

@@ -28,7 +28,8 @@ module Pubid
       end
 
       def urn_type
-        identifier.type&.to_s&.downcase
+        (identifier.class.respond_to?(:type) ? identifier.class.type : nil)
+          &.to_s&.downcase
       end
 
       def generate

data/lib/pubid/amca/urn_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Amca
+    # Parses AMCA URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:amca:{number}:{year}[:{copub.publisher}[:{other tokens}]]
+    #
+    # The current generator can leak the Type Hash literal into the URN
+    # (e.g., `copub.amca:{:key => :standard, ...}`). This parser filters
+    # any token containing `{` so round-trip works for the common case.
+    #
+    # Examples:
+    # - urn:amca:210:08              → AMCA 210-08
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body).reject { |p| p.include?("{") }
+
+        number, year = parts
+        text = "AMCA #{number}"
+        text += "-#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/amca.rb

@@ -6,9 +6,10 @@ module Pubid
     autoload :Identifiers, "#{__dir__}/amca/identifiers"
     autoload :Builder, "#{__dir__}/amca/builder"
     autoload :Parser, "#{__dir__}/amca/parser"
-    autoload :Scheme, "#{__dir__}/amca/scheme"
+    autoload :Renderer, "#{__dir__}/amca/renderer"
     autoload :SingleIdentifier, "#{__dir__}/amca/single_identifier"
     autoload :UrnGenerator, "#{__dir__}/amca/urn_generator"
+    autoload :UrnParser, "#{__dir__}/amca/urn_parser"
 
     # Parse an ACMA identifier string into an identifier object
     # @param identifier [String] The ACMA identifier string to parse
@@ -17,6 +18,46 @@ module Pubid
     def self.parse(identifier)
       Identifier.parse(identifier)
     end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifiers::Base.format_registry.register(:human, renderer: Amca::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
 
   # Register this flavor with the Pubid registry

data/lib/pubid/ansi/builder.rb

@@ -3,9 +3,11 @@
 module Pubid
   module Ansi
     class Builder < Pubid::Builder::Base
-      def initialize(scheme)
-        @scheme = scheme
-        super(Identifiers::Standard)
+      def build(data)
+        data = flatten_array(data) if data.is_a?(Array)
+        identifier = default_identifier_class.new
+        assign_attributes(identifier, data)
+        identifier
       end
 
       private

data/lib/pubid/ansi/identifier.rb

@@ -6,50 +6,8 @@ module Pubid
     class Identifier < ::Pubid::Identifier
       def self.parse(string)
         parsed = Pubid::Ansi::Parser.new.parse(string)
-        Pubid::Ansi::Builder.new(Pubid::Ansi::Scheme).build(parsed)
+        Pubid::Ansi::Builder.new.build(parsed)
       end
-
-      # Factory that builds an ANSI identifier from a hash of primitives.
-      #
-      # Defaults to {Identifiers::Standard} (ANSI has Standard and
-      # AmericanNationalStandard, both sharing the same type key `:ans`).
-      #
-      # ANSI quirk: the parser stores the publication year in the `part`
-      # attribute, not `date`. `.create` mirrors that — `:year` is coerced
-      # into `part` so the rendered output matches a parsed identifier.
-      def self.create(type: nil, **opts)
-        klass = resolve_create_class(type)
-        klass.new(**coerce_create_attrs(opts))
-      end
-
-      def self.resolve_create_class(type)
-        case type&.to_sym
-        when nil, :ans, :standard
-          Identifiers::Standard
-        when :american_national_standard
-          Identifiers::AmericanNationalStandard
-        else
-          raise ArgumentError, "Unknown ANSI type: #{type.inspect}"
-        end
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = {
-          publisher: Pubid::Components::Publisher.new(
-            body: (opts[:publisher] || "ANSI").to_s,
-          ),
-        }
-        if (v = opts[:number])
-          attrs[:number] = Pubid::Components::Code.new(value: v.to_s)
-        end
-        # ANSI parser stores year in part; mirror that here.
-        year_or_part = opts[:year] || opts[:part]
-        if year_or_part
-          attrs[:part] = Pubid::Components::Code.new(value: year_or_part.to_s)
-        end
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
     end
   end
 end

data/lib/pubid/ansi/identifiers/american_national_standard.rb

@@ -4,7 +4,8 @@ module Pubid
       # American National Standard identifier
       class AmericanNationalStandard < SingleIdentifier
         def self.type
-          { key: :ans, title: "American National Standard", short: "ANS" }
+          { key: :ans, web: :american_national_standard,
+            title: "American National Standard", short: "ANS" }
         end
       end
     end

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

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "american_national_standard"
-
 module Pubid
   module Ansi
     module Identifiers
       # American National Standard identifier
       class Standard < SingleIdentifier
         def self.type
-          { key: :ans, title: "American National Standard", short: "ANS" }
+          { key: :ans, web: :standard,
+            title: "American National Standard", short: "ANS" }
         end
       end
     end