pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/csa/renderer.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    # Human-readable renderer for CSA identifiers that extend Pubid::Identifier.
+    #
+    # Produces strings like:
+    #   "CSA B149.1:20"
+    #   "CAN/CSA-C22.2 NO. 60601-1-9:15"
+    #   "CSA C22.2 NO. 286:23"
+    #   "CSA MH SERIES 3.14:20"
+    #
+    # The renderer is registered as the +:human+ format in the CSA format
+    # registry and invoked via +render(format: :human)+.
+    #
+    # Note: Some CSA identifier types (Bundled, Combined, CanadianAdopted,
+    # CsaAdopted, Package) extend Lutaml::Model::Serializable directly,
+    # not Pubid::Identifier, so they keep their own to_s implementations.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        id = @id
+        @context = context
+
+        case id
+        when Identifiers::Series
+          render_series(id)
+        when Identifiers::Cec
+          render_cec(id)
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      # Base rendering: "CSA B149.1:20", "CAN/CSA-C22.2-05"
+      def render_base(id)
+        prefix = publisher_prefix_for(id)
+
+        # Handle code_only identifiers (empty string means no prefix)
+        if prefix == ""
+          # No prefix for code_only identifiers
+          parts = []
+        else
+          # Determine if we need space after prefix
+          # CAN/CSA- and CAN3- end with dash, so no space needed
+          needs_space = !prefix.end_with?("-")
+
+          parts = []
+          parts << prefix
+        end
+
+        # Code and year together
+        code_part = id.number.to_s if id.number
+
+        # NO. keyword
+        if id.no_number
+          code_part += " NO. #{id.no_number}"
+        end
+
+        # Series prefix and keyword (before year)
+        if id.series_prefix
+          code_part += " #{id.series_prefix} SERIES"
+        elsif id.series
+          # SERIES without prefix
+          code_part += " SERIES"
+        end
+
+        parts << code_part if code_part
+
+        # Year with proper format (colon or dash)
+        if id.year
+          # Use dash if year_format is dash, otherwise colon
+          separator = id.year_format == "dash" ? "-" : ":"
+          year_part = separator
+          year_part += id.year_prefix if id.year_prefix # Add M or F prefix
+          year_part += "F" if id.french && id.year_format != "dash" && !id.year_prefix # Only add F if no prefix
+          # Convert 4-digit year back to 2-digit for M/F prefix preservation
+          # M1983 → M83, F1983 → F83, 1983 → 83, 20xx → xx
+          # However, preserve original 4-digit format if the input was 4-digit (original_year_4digit)
+          year_str = id.year.to_s
+          year_part += if id.original_year_4digit
+                         # Preserve 4-digit format (e.g., "M1981" stays "M1981")
+                         year_str
+                       elsif id.year_prefix&.match?(/^[MF]$/) && year_str.length == 4 && year_str.start_with?("19")
+                         # M/F + 4-digit year (1900s) → convert to 2-digit with prefix
+                         year_str[2..3]
+                       elsif year_str.length == 4 && year_str.start_with?("20")
+                         # 2000s → just last 2 digits
+                         year_str[2..3]
+                       elsif year_str.length == 4 && year_str.start_with?("19") && !id.original_year_4digit
+                         # 1900s with no M/F prefix, but original was 2-digit (e.g., CAN3-Z299.0-86)
+                         # Convert back to 2-digit
+                         year_str[2..3]
+                       else
+                         # Other formats - keep as-is
+                         year_str
+                       end
+          parts[-1] += year_part
+        end
+
+        result = if prefix == ""
+                   # No prefix, just join parts
+                   parts.join(" ")
+                 elsif !prefix.end_with?("-")
+                   parts.join(" ")
+                 elsif parts.length == 2
+                   # No space after dash-ending prefix - join first two parts directly
+                   # If there are more parts after code, they should still have spaces
+                   parts.join
+                 else
+                   # More than 2 parts shouldn't happen in current design
+                   parts.join
+                 end
+
+        # Reaffirmation - preserve original format and determine spacing
+        if id.reaffirmation && !id.reaffirmation.to_s.empty?
+          result += render_reaffirmation(id)
+        end
+
+        # Package (already has leading space from parser)
+        if id.package
+          result += id.package
+        end
+
+        result
+      end
+
+      # CEC rendering: "CSA C22.2 NO. 286:23"
+      def render_cec(id)
+        parts = []
+
+        # Publisher prefix (CSA, CAN/CSA-, CAN3-)
+        prefix = publisher_prefix_for(id)
+
+        # Determine if we need space after prefix
+        # CAN/CSA- and CAN3- end with dash, so no space needed
+        needs_space = !prefix.end_with?("-")
+
+        parts << prefix unless prefix == ""
+
+        # CEC Part (C22.2, C22.3, etc.)
+        parts << id.cec_part.render(context: @context) if id.cec_part
+
+        # NO. notation - this is the key semantic component
+        parts << "NO."
+
+        # Number after NO.
+        parts << id.no_number.render(context: @context) if id.no_number
+
+        # Determine separator based on prefix ending
+        result = if prefix == ""
+                   parts.join(" ")
+                 elsif needs_space
+                   parts.join(" ")
+                 elsif parts.length <= 2
+                   # No space after dash-ending prefix (CAN/CSA-, CAN3-)
+                   # Join first two parts directly, rest with spaces
+                   parts.join
+                 else
+                   parts[0] + parts[1..].join(" ")
+                 end
+
+        # Year with proper format (colon or dash)
+        if id.year
+          # Use dash if year_format is dash, otherwise colon
+          separator = id.year_format == "dash" ? "-" : ":"
+          year_part = separator
+
+          # Convert 4-digit year back to 2-digit for display
+          year_str = id.year.to_s
+          display_year = if year_str.length == 4 && year_str.start_with?("20")
+                           year_str[2..3]
+                         elsif year_str.length == 4 && year_str.start_with?("19")
+                           year_str[2..3]
+                         else
+                           year_str
+                         end
+
+          # Add prefix if present
+          year_part += if id.year_prefix
+                         id.year_prefix + display_year
+                       elsif id.french && id.year_format != "dash"
+                         # Only add F if no prefix already set
+                         "F#{display_year}"
+                       else
+                         display_year
+                       end
+
+          result += year_part
+        end
+
+        # Reaffirmation
+        if id.reaffirmation && !id.reaffirmation.to_s.empty?
+          result += render_reaffirmation(id)
+        end
+
+        result
+      end
+
+      # Series rendering: "CSA MH SERIES 3.14:20"
+      def render_series(id)
+        result = series_publisher_prefix_portion(id)
+
+        # Add code FIRST (before SERIES keyword)
+        result += id.number.to_s
+
+        # Add space before series prefix/SERIES keyword
+        result += " "
+
+        # Add series prefix if present
+        result += "#{id.series_prefix} " if id.series_prefix && !id.series_prefix.empty?
+
+        # Add SERIES keyword
+        result += "SERIES"
+
+        # Add year
+        result += series_year_portion(id)
+
+        # Add reaffirmation
+        result += render_reaffirmation(id) if id.reaffirmation && !id.reaffirmation.to_s.empty?
+
+        result
+      end
+
+      private
+
+      # Reaffirmation rendering helper - shared across Base, Cec, and Series
+      def render_reaffirmation(id)
+        # Check if year was originally 2-digit (original_year_4digit flag)
+        year_was_2digit = !id.original_year_4digit
+
+        # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
+        reaffirmation_was_4digit = id.original_reaffirmation_4digit
+
+        # Preserve original reaffirmation format
+        reaffirmation_str = if reaffirmation_was_4digit
+                              # Original was 4-digit, keep as-is
+                              id.reaffirmation.to_s
+                            elsif id.reaffirmation.to_s.length == 4 && id.reaffirmation.to_s.start_with?("19", "20")
+                              # Original was 2-digit, convert 4-digit storage back to 2-digit
+                              id.reaffirmation.to_s[2..3]
+                            else
+                              # Already 2-digit or other format
+                              id.reaffirmation.to_s
+                            end
+
+        # Determine spacing based on original formats
+        if year_was_2digit && reaffirmation_was_4digit
+          # Year was 2-digit, reaffirmation was 4-digit → add space
+          " (R#{reaffirmation_str})"
+        else
+          # Both 2-digit, both 4-digit, or other cases → no space
+          "(R#{reaffirmation_str})"
+        end
+      end
+
+      # The publisher prefix to print. A code_only identifier printed none, so
+      # it must not gain the default "CSA" — see SingleIdentifier#code_only.
+      def publisher_prefix_for(id)
+        return "" if id.respond_to?(:code_only) && id.code_only
+
+        id.publisher_prefix || "CSA"
+      end
+
+      def series_publisher_prefix_portion(id)
+        prefix = publisher_prefix_for(id)
+
+        # Handle code_only identifiers (empty string means no prefix)
+        return "" if prefix == ""
+
+        # Determine if we need space after prefix
+        # CAN/CSA- and CAN3- end with dash, so no space needed
+        needs_space = !prefix.end_with?("-")
+
+        needs_space ? "#{prefix} " : prefix
+      end
+
+      def series_year_portion(id)
+        return "" unless id.year
+
+        # Use dash if year_format is dash, otherwise colon
+        separator = id.year_format == "dash" ? "-" : ":"
+        year_part = separator
+        year_part += id.year_prefix if id.year_prefix # Add M or F prefix
+        year_part += "F" if id.french && id.year_format != "dash" && !id.year_prefix # Only add F if no prefix
+
+        # Convert 4-digit year back to 2-digit
+        year_str = id.year.to_s
+        year_part += if year_str.length == 4 && year_str.start_with?("20")
+                       year_str[2..3]
+                     else
+                       year_str
+                     end
+
+        year_part
+      end
+    end
+  end
+end

data/lib/pubid/csa/single_identifier.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    class SingleIdentifier < Identifier
+      # The document code — "B149.1", "Z240", "C22.2" — and the relaton index
+      # key: Relaton::Index sorts and bsearches every row on
+      # `id.root.number.to_s`, so it must never be empty.
+      #
+      # It is the `number` INHERITED from ::Pubid::Identifier, not a
+      # redeclaration: Pubid::Csa::Components::Code is a bare alias of
+      # Pubid::Components::Code, which is exactly the parent's declared type.
+      # That matters. CSA's base is split across two files (csa/identifier.rb +
+      # csa/single_identifier.rb) — the IEEE shape in which a leaf can snapshot
+      # a half-built parent attribute table (CLAUDE.md, the `number`
+      # determinism landmine). Declaring nothing here keeps CSA clear of it.
+      # The attribute was named `code` before; there is no alias.
+      attribute :no_number, :string
+      attribute :year, :string
+      attribute :year_format, :string  # "colon" or "dash"
+      attribute :year_prefix, :string  # "F" or "M"
+      attribute :original_year_4digit, :boolean, default: -> {
+        false
+      } # Track if original input was 4-digit (e.g., "M1981" vs "M83")
+      attribute :french, :boolean
+      attribute :reaffirmation, :string
+      attribute :original_reaffirmation_4digit, :boolean, default: -> {
+        false
+      } # Track if original reaffirmation was 4-digit (e.g., "R2004" vs "R04")
+      attribute :has_publisher, :boolean  # Track if CSA prefix present
+      attribute :series_prefix, :string   # MH, RV, etc.
+      attribute :series, :boolean         # Track if SERIES keyword present
+      attribute :package, :string         # Package portion (Code, Handbook, etc.)
+      attribute :publisher_prefix, :string # Original prefix: "CAN/CSA-", "CSA", "CAN3-"
+
+      # True when the reference printed no publisher at all ("C22.1-15"), so
+      # rendering must not supply the default "CSA".
+      #
+      # This used to be an empty-string `publisher_prefix` sentinel, which the
+      # canonical `to_hash` drops (it strips empty and default-valued
+      # attributes by design) — so a code-only identifier came back
+      # from `from_hash` with a nil prefix and re-rendered as
+      # "CSA C22.1-15". Named for the RARE case with a `false` default,
+      # per CLAUDE.md, so it is dropped from every ordinary row.
+      attribute :code_only, :boolean, default: -> { false }
+
+      # A flat, index-friendly serialized shape: the `Components::Code`
+      # attributes collapse to bare scalars (`number: C22.2-286`, not
+      # `number: {value: C22.2-286}`), the ISO/ETSI/ITU `key_value` pattern.
+      #
+      # This is deliberately a serialization mapping rather than an
+      # `attribute :number, :string` redeclaration. CSA's base is split across
+      # two files (csa/identifier.rb + csa/single_identifier.rb) — the IEEE
+      # shape in which a leaf can snapshot a half-built parent attribute table
+      # — so a retype here would reintroduce the `number` determinism landmine
+      # recorded in CLAUDE.md. The runtime attribute stays a Components::Code;
+      # only the hash is flat.
+      #
+      # A lutaml key_value block is EXHAUSTIVE — an unmapped attribute is
+      # dropped, `_type` included — so every attribute above appears here. It
+      # lives on SingleIdentifier, which only the single-document types
+      # inherit; the container types descend from Csa::Identifier directly and
+      # keep the default shape for their nested `base`/`identifiers`.
+      key_value do
+        map "_type", to: :_type
+        map "number", with: { to: :number_to_kv, from: :number_from_kv }
+        map "no_number",
+            with: { to: :no_number_to_kv, from: :no_number_from_kv }
+        map "year", to: :year
+        map "year_format", to: :year_format
+        map "year_prefix", to: :year_prefix
+        map "original_year_4digit", to: :original_year_4digit
+        map "french", to: :french
+        map "reaffirmation", to: :reaffirmation
+        map "original_reaffirmation_4digit", to: :original_reaffirmation_4digit
+        map "has_publisher", to: :has_publisher
+        map "series_prefix", to: :series_prefix
+        map "series", to: :series
+        map "package", to: :package
+        map "publisher_prefix", to: :publisher_prefix
+        map "code_only", to: :code_only
+      end
+
+      def number_to_kv(model, doc)
+        emit_kv(doc, "number", model.number)
+      end
+
+      def number_from_kv(model, value)
+        model.number = Components::Code.new(value: value.to_s)
+      end
+
+      # `no_number` is a plain :string here but a Components::Code on Cec, so
+      # the converter reads through whichever it is given.
+      def no_number_to_kv(model, doc)
+        emit_kv(doc, "no_number", model.no_number)
+      end
+
+      def no_number_from_kv(model, value)
+        model.no_number =
+          if model.class.attributes[:no_number].type == Components::Code
+            Components::Code.new(value: value.to_s)
+          else
+            value.to_s
+          end
+      end
+
+      # Emit a scalar, skipping a nil or empty value so the canonical
+      # no-defaults hash never gains an empty key.
+      def emit_kv(doc, key, value)
+        text = value.respond_to?(:value) ? value.value : value
+        return if text.nil? || text.to_s.empty?
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new(key, text.to_s),
+        )
+      end
+    end
+  end
+end

data/lib/pubid/csa/urn_generator.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      # A code_only identifier printed no publisher, so it keeps an empty
+      # publisher segment rather than falling back to "csa" in #generate.
+      def urn_publisher_prefix
+        return "" if code_only?
+        return nil unless identifier.publisher_prefix
+
+        identifier.publisher_prefix.to_s.downcase
+      end
+
+      def code_only?
+        identifier.respond_to?(:code_only) && identifier.code_only
+      end
+
+      def urn_number
+        return nil unless identifier.number
+
+        identifier.number.render(context: URN_CONTEXT)
+      end
+
+      def urn_no_number
+        "no.#{identifier.no_number}" if identifier.no_number
+      end
+
+      def urn_series
+        "series.#{identifier.series}" if identifier.series
+      end
+
+      def urn_series_prefix
+        "series.#{identifier.series_prefix}" if identifier.series_prefix
+      end
+
+      def urn_year_csa
+        return nil unless identifier.year
+
+        year = identifier.year.to_s
+        year = year[-2..] if year.length == 4 && year.start_with?("20")
+        year
+      end
+
+      def urn_reaffirmation
+        "reaff.#{identifier.reaffirmation}" if identifier.reaffirmation
+      end
+
+      def urn_package
+        "pkg.#{identifier.package}" if identifier.package
+      end
+
+      def urn_year_format
+        "format.dash" if identifier.year_format == "dash"
+      end
+
+      def urn_french
+        "french" if identifier.french
+      end
+
+      def generate
+        parts = ["urn", "csa"]
+
+        prefix = urn_publisher_prefix || "csa"
+        parts << prefix
+
+        parts << urn_number if urn_number
+        parts << urn_no_number if urn_no_number
+        parts << urn_series if urn_series
+        parts << urn_series_prefix if urn_series_prefix
+
+        year = urn_year_csa
+        if year
+          year = "#{identifier.year_prefix}#{year}" if identifier.year_prefix
+          parts << year
+        end
+
+        parts << urn_reaffirmation if urn_reaffirmation
+        parts << urn_package if urn_package
+        parts << urn_year_format if urn_year_format
+        parts << urn_french if urn_french
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/csa/urn_parser.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    # Parses CSA URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:csa:{publisher}:{code}:{year}:format.{format}
+    #
+    # The trailing `format.X` token records the year-separator style used
+    # in the human-readable form (`dash` for `-`, `colon` for `:`).
+    #
+    # Examples:
+    # - urn:csa:csa:Z240.2.1:16:format.dash → CSA Z240.2.1-16
+    class UrnParser < Pubid::UrnParser::Base
+      YEAR_SEPARATOR = { "dash" => "-", "colon" => ":" }.freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        format_token = parts.find { |p| p.start_with?("format.") }
+        separator = YEAR_SEPARATOR.fetch(format_token&.split(".")&.last, "-")
+
+        payload = parts.reject { |p| p.start_with?("format.") }
+        _publisher, code, year = payload
+        text = "CSA #{code}"
+        text += "#{separator}#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/csa/wrapper_identifier.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Csa
+    # WrapperIdentifier is the base class for all CSA identifiers that wrap
+    # other identifiers.
+    # Examples:
+    #   - CanadianAdopted: CAN/{base}
+    #   - CsaAdopted:      CSA {ISO/IEC/CISPR identifier}
+    #
+    # The wrapper pattern allows proper MODEL-DRIVEN architecture where
+    # adoptions are objects that contain other identifier objects, not string
+    # prefixes.
+    class WrapperIdentifier < Identifier
+      # The wrapped identifier (recursively parsed).
+      #
+      # A real lutaml attribute, not an attr_accessor: the accessor was
+      # invisible to `to_hash`, `from_hash` AND `#exclude` (which iterates
+      # `self.class.attributes`), so a wrapper serialized to a hash with no
+      # identifier in it at all. It is named `base` — the uniform parent
+      # accessor every flavor uses — so the inherited `#root` walks it to the
+      # origin document and `exclude_from_nested` reaches inside. There is no
+      # `wrapped_identifier` alias.
+      #
+      # Typed as the cross-flavor `::Pubid::Identifier`, not the CSA one:
+      # CsaAdopted wraps ISO/IEC/CISPR ids, and lutaml enforces the declared
+      # type — `polymorphic: true` widens it only to SUBCLASSES, so a narrower
+      # type raises Lutaml::Model::IncorrectModelError on `to_hash`. The
+      # Ieee::Identifiers::AdoptedStandard precedent. The nested child carries
+      # its own `_type`, so `from_hash` routes it back via TypeResolver.
+      attribute :base, ::Pubid::Identifier, polymorphic: true
+
+      # Reaffirmation year (common across wrappers)
+      attribute :reaffirmation, :string
+
+      # Whether the reaffirmation was printed 4-digit ("(R2004)") rather than
+      # 2-digit ("(R04)"). CanadianAdopted#to_s reads it to choose the spacing
+      # and to render the year back in its original width.
+      attribute :original_reaffirmation_4digit, :boolean, default: -> { false }
+
+      # Year format tracking (for compatibility)
+      attribute :year_format, :string
+
+      # Subclasses MUST implement to_s
+      def to_s(**_opts)
+        raise NotImplementedError, "Subclasses must implement to_s method"
+      end
+
+      # The matching primitives relaton uses to normalise a reference before
+      # comparing it. An adoption wrapper peels to the document it adopts;
+      # without these the inherited defaults return the WRAPPER, which is a
+      # silently wrong answer rather than a loud one.
+      def base_document
+        base ? base.base_document : self
+      end
+
+      def drop_supplements
+        base || self
+      end
+    end
+  end
+end

data/lib/pubid/csa.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    extend Pubid::PrefixesSupport
+
+    # Sole CSA publisher token (see the parser's `publisher` rule).
+    PREFIXES = ["CSA"].freeze
+
+    autoload :Builder, "#{__dir__}/csa/builder"
+    autoload :Identifier, "#{__dir__}/csa/identifier"
+    autoload :Identifiers, "#{__dir__}/csa/identifiers"
+    autoload :Parser, "#{__dir__}/csa/parser"
+    autoload :Renderer, "#{__dir__}/csa/renderer"
+    autoload :SingleIdentifier, "#{__dir__}/csa/single_identifier"
+    autoload :UrnGenerator, "#{__dir__}/csa/urn_generator"
+    autoload :UrnParser, "#{__dir__}/csa/urn_parser"
+    autoload :WrapperIdentifier, "#{__dir__}/csa/wrapper_identifier"
+    autoload :CompositeIdentifier, "#{__dir__}/csa/composite_identifier"
+    autoload :Components, "#{__dir__}/csa/components"
+
+    def self.parse(identifier_string)
+      unless identifier_string.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if identifier_string.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      Identifier.parse(identifier_string)
+    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
+
+  # Register this flavor with the Pubid registry
+end
+
+# Register Ucsa flavor with the registry
+Pubid::Registry.register(:csa, Pubid::Csa)
+
+# Per-flavor format registry: inherits global formats, overrides :human
+Pubid::Csa::SingleIdentifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Csa::SingleIdentifier.format_registry.register(:human, renderer: Pubid::Csa::Renderer)