pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

data/lib/pubid/bsi/single_identifier.rb

@@ -3,6 +3,11 @@
 module Pubid
   module Bsi
     class SingleIdentifier < Pubid::Identifier
+      # Identity for the Pubid::Bsi::Identifier facade: SingleIdentifier is the
+      # common ancestor of every concrete BSI identifier, so including the
+      # facade module here makes them all `is_a?(Pubid::Bsi::Identifier)`.
+      include Pubid::Bsi::Identifier
+
       # Generate URN for this identifier
       #
       # @return [String] URN representation
@@ -30,76 +35,7 @@ module Pubid
       attribute :space_separated_part, :boolean, default: -> { false }
 
       def to_s(lang: :en, lang_single: false)
-        # Build string representation
-        parts = []
-
-        # For supplement/addendum base identifiers, flex_prefix replaces publisher+prefix
-        parts << publisher.to_s if publisher
-        if flex_prefix
-          # Flex prefix is the full prefix including BS (e.g., "BS CECC" becomes "BS" + space + "CECC")
-          parts << flex_prefix
-        elsif prefix
-          # Standard publisher
-
-          # Prefix if present (specialized prefix like A, AU, C, etc.)
-          parts << prefix.to_s
-        end
-
-        # Number with iteration, part, and subpart
-        if number
-          number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
-
-          # Collection (second number with slash)
-          if second_number
-            second_val = second_number.is_a?(Components::Code) ? second_number.value : second_number
-            number_str += "/#{second_val}"
-          end
-
-          # Part and subpart - check if space-separated
-          space_separated = space_separated_part
-          if part
-            part_val = part.is_a?(Components::Code) ? part.value : part
-            # Trim part value to remove leading/trailing spaces from parser
-            part_str = part_val.to_s.strip
-            # Use space for space-separated parts, dash otherwise
-            separator = space_separated ? " " : "-"
-            number_str += "#{separator}#{part_str}"
-          end
-          if subpart
-            subpart_val = subpart.is_a?(Components::Code) ? subpart.value : subpart
-            subpart_str = subpart_val.to_s.strip
-            number_str += "-#{subpart_str}"
-          end
-
-          # Iteration (bracket notation like 1000[9])
-          if iteration && !iteration.empty?
-            number_str += "[#{iteration}]"
-          end
-
-          parts << number_str
-        end
-
-        result = parts.join(" ")
-
-        # Date
-        if date
-          year_val = date.is_a?(Components::Date) ? date.year : date.to_i
-          result += ":#{year_val}"
-          # Month if present
-          result += "-#{format('%02d', month)}" if month
-        end
-
-        # Edition
-        result += " v#{edition}" if edition
-
-        # Translation
-        if translation_lang
-          result += " (#{translation_lang})"
-        elsif translation_upper
-          result += " (#{translation_upper})"
-        end
-
-        result
+        render(format: :human, lang: lang, lang_single: lang_single)
       end
 
       def <=>(other)

data/lib/pubid/bsi/urn_generator.rb

@@ -44,9 +44,8 @@ module Pubid
           parts << "/#{second}"
         end
 
-        if identifier.date
-          year = identifier.date.year
-          parts << year.to_s
+        if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
+          parts << identifier.date.render(context: URN_CONTEXT)
         elsif identifier.year
           parts << identifier.year.to_s
         end

data/lib/pubid/bsi/urn_parser.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Bsi
+    # Parses BSI URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:bsi:{publisher}:{number}:{year}[:{supp_type}:{supp_number}:{supp_year}]
+    #
+    # publisher is the lowercase publisher (e.g., "bs", "pd"). supplement
+    # triples (`amd`/`cor`/`add`) follow the base identifier.
+    #
+    # Examples:
+    # - urn:bsi:bs:9001:2015                → BS 9001:2015
+    # - urn:bsi:bs:9001:2015:amd:1:2020     → BS 9001:2015/A1:2020
+    class UrnParser < Pubid::UrnParser::Base
+      SUPPLEMENT_ABBR = {
+        "amd" => "Amd",
+        "cor" => "Cor",
+        "add" => "Add",
+      }.freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        publisher_token, number, year, *supplement_parts = parts
+        publisher = publisher_token.upcase
+        text = "#{publisher} #{number}"
+        text += ":#{year}" if year
+        text += build_supplements(supplement_parts)
+        flavor_parse(text)
+      end
+
+      private
+
+      def build_supplements(parts)
+        return "" if parts.empty?
+
+        chunks = parts.each_slice(3).to_a
+        chunks.map { |type, num, supp_year| render_supplement(type, num, supp_year) }.join
+      end
+
+      def render_supplement(type, num, supp_year)
+        label = SUPPLEMENT_ABBR.fetch(type.downcase) { type.capitalize }
+        suffix = num ? " #{num}" : ""
+        suffix += ":#{supp_year}" if supp_year
+        "/#{label}#{suffix}"
+      end
+    end
+  end
+end

data/lib/pubid/bsi.rb

@@ -14,9 +14,193 @@ module Pubid
     autoload :Identifiers, "#{__dir__}/bsi/identifiers"
     autoload :Model, "#{__dir__}/bsi/model"
     autoload :Parser, "#{__dir__}/bsi/parser"
-    autoload :Scheme, "#{__dir__}/bsi/scheme"
+    autoload :Renderer, "#{__dir__}/bsi/renderer"
     autoload :SingleIdentifier, "#{__dir__}/bsi/single_identifier"
     autoload :UrnGenerator, "#{__dir__}/bsi/urn_generator"
+    autoload :UrnParser, "#{__dir__}/bsi/urn_parser"
+
+    # TYPED_STAGES_REGISTRY for native BSI types. Used by Pubid::Bsi.locate_stage
+    # to map abbreviations (e.g. "BS", "PD", "Handbook") to typed stages.
+    TYPED_STAGES_REGISTRY = [
+      # British Standard (BS)
+      Pubid::Components::TypedStage.new(
+        code: :pubbs,
+        stage_code: :published,
+        type_code: :bs,
+        abbr: ["BS"],
+        name: "British Standard",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+      Pubid::Components::TypedStage.new(
+        code: :drbs,
+        stage_code: :draft,
+        type_code: :bs,
+        abbr: ["Draft BS", "DBS"],
+        name: "Draft British Standard",
+        harmonized_stages: %w[30.00 30.20 30.60 40.00 40.20 40.60],
+      ),
+
+      # Published Document (PD)
+      Pubid::Components::TypedStage.new(
+        code: :pubpd,
+        stage_code: :published,
+        type_code: :pd,
+        abbr: ["PD"],
+        name: "Published Document",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Publicly Available Specification (PAS)
+      Pubid::Components::TypedStage.new(
+        code: :pubpas,
+        stage_code: :published,
+        type_code: :pas,
+        abbr: ["PAS"],
+        name: "Publicly Available Specification",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # National Annex (NA)
+      Pubid::Components::TypedStage.new(
+        code: :pubna,
+        stage_code: :published,
+        type_code: :na,
+        abbr: ["NA"],
+        name: "National Annex",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Draft Document (DD)
+      Pubid::Components::TypedStage.new(
+        code: :pubdd,
+        stage_code: :published,
+        type_code: :dd,
+        abbr: ["DD"],
+        name: "Draft Document",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Flex Document
+      Pubid::Components::TypedStage.new(
+        code: :pubflex,
+        stage_code: :published,
+        type_code: :flex,
+        abbr: ["Flex", "BSI Flex"],
+        name: "BSI Flex",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Handbook
+      Pubid::Components::TypedStage.new(
+        code: :pubhandbook,
+        stage_code: :published,
+        type_code: :handbook,
+        abbr: ["Handbook", "HB"],
+        name: "BSI Handbook",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Practice Guide (PP)
+      Pubid::Components::TypedStage.new(
+        code: :pubpp,
+        stage_code: :published,
+        type_code: :pp,
+        abbr: ["PP"],
+        name: "Published Practice",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # British Industrial Practice (BIP)
+      Pubid::Components::TypedStage.new(
+        code: :pubbip,
+        stage_code: :published,
+        type_code: :bip,
+        abbr: ["BIP"],
+        name: "British Industrial Practice",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Aerospace/Specialized British Standard (with letter prefix)
+      Pubid::Components::TypedStage.new(
+        code: :pubaerospace,
+        stage_code: :published,
+        type_code: :aerospace,
+        abbr: ["BS A", "BS AU", "BS C", "BS M", "BS S", "BS L", "BS TA",
+               "BS MA", "BS PL", "BS QC", "BS G", "BS HC", "BS F", "BS X", "BS B"],
+        name: "Aerospace/Specialized British Standard",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Index
+      Pubid::Components::TypedStage.new(
+        code: :pubindex,
+        stage_code: :published,
+        type_code: :index,
+        abbr: ["Index"],
+        name: "BSI Index",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Method
+      Pubid::Components::TypedStage.new(
+        code: :pubmethod,
+        stage_code: :published,
+        type_code: :method,
+        abbr: ["Method", "Methods"],
+        name: "BSI Method",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Section
+      Pubid::Components::TypedStage.new(
+        code: :pubsection,
+        stage_code: :published,
+        type_code: :section,
+        abbr: ["Section"],
+        name: "BSI Section",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # DISC (Delivering Information Solutions to Customers)
+      Pubid::Components::TypedStage.new(
+        code: :pubdisc,
+        stage_code: :published,
+        type_code: :disc,
+        abbr: ["DISC"],
+        name: "DISC",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Detailed Specification (with N or C notation)
+      Pubid::Components::TypedStage.new(
+        code: :pubdetailed_spec,
+        stage_code: :published,
+        type_code: :detailed_specification,
+        abbr: ["DETAILED SPEC"],
+        name: "Detailed Specification",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Standalone Amendment
+      Pubid::Components::TypedStage.new(
+        code: :standalone_amendment,
+        stage_code: :published,
+        type_code: :amendment,
+        abbr: ["AMD"],
+        name: "Amendment",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Technical Specification
+      Pubid::Components::TypedStage.new(
+        code: :pubts,
+        stage_code: :published,
+        type_code: :ts,
+        abbr: ["TS"],
+        name: "Technical Specification",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+    ].freeze
 
     def self.parse(string)
       Identifier.parse(string)
@@ -25,8 +209,47 @@ module Pubid
     def self.transform(data)
       Builder.build(data)
     end
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # Includes classes with explicit type declarations (Hash or nil).
+    # @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 }
+        .select { |c| c.singleton_methods(false).include?(:type) }
+        .reject { |c| c.name&.split("::")&.last == "Base" }
+    end
+
+    # Build typed stage index from the module's TYPED_STAGES_REGISTRY
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= TYPED_STAGES_REGISTRY
+    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&.dig(: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 Ubsi flavor with the registry
 Pubid::Registry.register(:bsi, Pubid::Bsi)
+
+# Per-flavor format registry: inherits global formats, overrides :human.
+# SingleIdentifier is the abstract base for every concrete BSI identifier
+# (including Amendment and Corrigendum), so wiring the registry here covers
+# the whole flavor in one shot.
+Pubid::Bsi::SingleIdentifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Bsi::SingleIdentifier.format_registry.register(:human, renderer: Pubid::Bsi::Renderer)

data/lib/pubid/builder/base.rb

@@ -5,31 +5,43 @@ module Pubid
     # Base class for all flavor-specific builders.
     #
     # Provides the shared build loop that converts parsed data into identifier
-    # objects. Flavors subclass and override only `cast` and optionally
-    # `default_identifier_class`.
+    # objects. Flavors subclass and override:
+    # - +select_class(data)+ to dispatch by data shape (default returns
+    #   +default_identifier_class+).
+    # - +cast(key, value)+ to transform raw parsed values into components.
+    # - +handle_key(identifier, key, value)+ for non-attribute side effects.
     #
     # The build loop:
     # 1. Flattens array-of-hashes input (from Parslet transforms)
-    # 2. Iterates each key-value pair
-    # 3. Calls `cast(key, value)` to convert raw values to component objects
-    # 4. Assigns the result to the identifier via `send`
-    # 5. Silently skips unknown attributes (rescue NoMethodError)
+    # 2. Asks +select_class(data)+ for the identifier class
+    # 3. Iterates each key-value pair
+    # 4. Calls +cast(key, value)+ to convert raw values to component objects
+    # 5. Assigns the result to the identifier via setter
+    # 6. Silently skips unknown attributes
     class Base
       attr_reader :identifier
 
-      def initialize(identifier_class = default_identifier_class)
+      def initialize(identifier_class = nil)
         @identifier_class = identifier_class
       end
 
       def build(data)
         data = flatten_array(data) if data.is_a?(Array)
-        identifier = @identifier_class.new
+        identifier_class = @identifier_class || select_class(data)
+        identifier = identifier_class.new
         assign_attributes(identifier, data)
         identifier
       end
 
       private
 
+      # Override in subclasses to dispatch to a specific identifier class
+      # based on the shape of the parsed data (type code, supplement marker,
+      # etc.). Defaults to +default_identifier_class+.
+      def select_class(_data)
+        default_identifier_class
+      end
+
       # Override in subclasses to convert raw parsed values to component objects.
       # Return a Hash to assign multiple attributes, or a single value.
       # Return nil to skip the assignment.
@@ -87,8 +99,9 @@ module Pubid
       }.freeze
 
       def locate_typed_stage(typed_stage_string)
-        typed_stage_string = "" if typed_stage_string.nil?
-        @scheme.locate_typed_stage_by_abbr(typed_stage_string)
+        raise NotImplementedError,
+              "#{self.class} must implement locate_typed_stage " \
+              "(rely on the flavor module's locate_stage method)"
       end
 
       def convert_roman_to_integer(roman_numeral)
@@ -122,6 +135,40 @@ module Pubid
         end
       end
 
+      # Splits a compound document number ("1234", "1234-1", "1234-1-2")
+      # into number/part/subpart Code components. Flavor-specific dash/slash
+      # normalization lives in +normalize_number_with_part+; legacy year
+      # extraction (e.g. ISO "4037-1979") lives in +extract_legacy_year+.
+      def parse_number_with_part(value, code_class:)
+        normalized = normalize_number_with_part(value)
+        parts = normalized.split("-").reject(&:empty?)
+        number = parts.shift
+        part = parts.shift&.strip
+        subpart = parts.any? ? parts.join("-") : nil
+
+        legacy = extract_legacy_year(number, part, code_class)
+        return legacy if legacy
+
+        part = convert_roman_to_integer(part) if part
+
+        code_hash = { number: code_class.new(value: number) }
+        code_hash[:part] = code_class.new(value: part) if part
+        code_hash[:subpart] = code_class.new(value: subpart) if subpart
+        code_hash
+      end
+
+      # Hook: normalize the raw number_with_part string before splitting.
+      # Override in subclasses for flavor-specific dash/slash/space handling.
+      def normalize_number_with_part(value)
+        value.to_s
+      end
+
+      # Hook: detect a year masquerading as a part (e.g. "4037-1979") and
+      # return a number+date hash, or nil to continue normal splitting.
+      def extract_legacy_year(_number, _part, _code_class)
+        nil
+      end
+
       def parse_languages(value)
         original_value = value.to_s
         normalized_value = original_value.gsub("/", ",")

data/lib/pubid/bundled_identifier.rb

@@ -1,4 +1,3 @@
-require_relative "identifier"
 # frozen_string_literal: true
 
 module Pubid

data/lib/pubid/ccsds/builder.rb

@@ -34,20 +34,21 @@ module Pubid
         # Extract corrigenda numbers
         corr_array = data[:corrigenda]
         corr_array = [corr_array] unless corr_array.is_a?(Array)
-        corr_numbers = corr_array.map { |c| c[:cor_number].to_i }
+        corr_numbers = corr_array.map { |c| c[:cor_number].to_s }
 
         # Build base identifier (without corrigenda)
         base_data = data.dup
         base_data.delete(:corrigenda)
         base = build_base(base_data)
 
-        # Build Corrigendum object for each corrigendum number
+        # Build Corrigendum object for each corrigendum number. The corrigendum
+        # sequence is stored in the inherited `number` attribute (mirroring ISO).
         # Note: CCSDS uses "Cor. 1" format (single corrigendum per identifier)
         # If multiple corrigenda exist, we build the last one wrapping the base
         corr_numbers.reduce(base) do |current_base, cor_num|
           Identifiers::Corrigendum.new(
             base_identifier: current_base,
-            cor_number: cor_num,
+            number: cor_num,
           )
         end
       end

data/lib/pubid/ccsds/identifier.rb

@@ -2,7 +2,57 @@
 
 module Pubid
   module Ccsds
-    module Identifier
+    # Abstract root for every CCSDS identifier AND the flavor's parse entry
+    # point — mirrors Pubid::Iso::Identifier / Pubid::Jis::Identifier. Concrete
+    # identifiers (Identifiers::Base, Identifiers::Corrigendum) descend from this
+    # class, so a parsed CCSDS id is an instance of Pubid::Ccsds::Identifier and
+    # relaton-index can pass this class as `pubid_class` for from_hash/to_hash.
+    #
+    # Keeping the root abstract (it is never itself a serialized type, so it is
+    # absent from CCSDS_TYPE_MAP) is what breaks the polymorphic recursion a
+    # supplement's `base_identifier` would otherwise hit if it pointed at a
+    # concrete type that is also its own superclass.
+    class Identifier < ::Pubid::Identifier
+      # CCSDS stores every code component as a plain string (the Builder passes
+      # strings, never Components::Code/Edition objects), so override the
+      # inherited Components::Code/Edition attribute types with :string. This
+      # both matches the runtime values and yields a lean, round-trippable
+      # key_value (`to_hash`) serialization instead of nested component hashes.
+      # `type` (single book-color letter B/G/M/R/Y/O), `suffix`, and `language`
+      # are likewise CCSDS-specific plain strings.
+      attribute :number, :string
+      attribute :part, :string
+      attribute :edition, :string
+      attribute :type, :string
+      attribute :suffix, :string
+      attribute :language, :string
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization,
+      # mapping each concrete class's polymorphic_name to its class name.
+      CCSDS_TYPE_MAP = {
+        "pubid:ccsds:base" => "Pubid::Ccsds::Identifiers::Base",
+        "pubid:ccsds:corrigendum" => "Pubid::Ccsds::Identifiers::Corrigendum",
+      }.freeze
+
+      # The shared Pubid::Identifier no longer auto-maps attributes, so the
+      # flavor's root declares the full key_value mapping; subclasses
+      # (SupplementIdentifier/Corrigendum) merge their own blocks on top. Every
+      # value is a plain string, so a direct `to:` map round-trips.
+      key_value do
+        map "_type", to: :_type, polymorphic_map: CCSDS_TYPE_MAP
+        map "number", to: :number
+        map "part", to: :part
+        map "edition", to: :edition
+        map "type", to: :type
+        map "suffix", to: :suffix
+        map "language", to: :language
+      end
+
+      def publisher
+        "CCSDS"
+      end
+
+      # Parse a CCSDS identifier string into the appropriate identifier object.
       def self.parse(identifier)
         # Apply legacy update_codes normalization first
         normalized = Core::UpdateCodes.apply(identifier, :ccsds)
@@ -12,73 +62,20 @@ module Pubid
         raise "Failed to parse CCSDS identifier '#{identifier}': #{e.message}"
       end
 
-      # Factory that builds a CCSDS identifier from a hash of primitives.
-      #
-      # Accepts the field shape used by relaton-data-ccsds index entries:
-      # `:publisher`, `:number`, `:series`, `:part`, `:book_color`,
-      # `:retired`, `:edition`, plus the parsed-shape fields `:type`,
-      # `:suffix`, `:language`. CCSDS 2.x maps these as:
-      #
-      #   * `:series` + `:number`  → combined number ("A" + "20" → "A20")
-      #   * `:book_color`          → `:type`            (B/G/M/R/Y/O)
-      #   * `:publisher`           → ignored (hardcoded "CCSDS")
-      #   * `:retired`             → ignored (no 2.x field)
-      #
-      # Supplement subclasses (currently just Corrigendum, via `type: :cor`)
-      # raise ArgumentError until `base:` kwarg is wired through.
-      def self.create(type: nil, **opts)
-        if type
-          type_sym = type.to_sym
-          base_type_key = Identifiers::Base.type[:key].to_sym
-
-          if type_sym != base_type_key
-            supplement = supplement_klass_for(type_sym)
-            if supplement
-              # TODO(create-shim): supplement subclasses (Corrigendum)
-              # require a base_identifier. Wire `base:` kwarg through once
-              # a caller needs it.
-              raise ArgumentError, "#{supplement} requires a " \
-                                   "base_identifier; Identifier.create " \
-                                   "cannot build supplements yet"
-            end
-
-            # Not a class-dispatch key — treat as book_color data
-            # (e.g. `type: "G"` for Green Book) and merge back into opts.
-            opts = opts.merge(type: type)
-          end
-        end
-
-        Identifiers::Base.new(**coerce_create_attrs(opts))
-      end
-
-      def self.supplement_klass_for(type_sym)
-        Scheme.supplement_identifiers.find do |k|
-          k.type[:key].to_sym == type_sym
-        end
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = {}
-
-        if opts[:number]
-          num = opts[:number].to_s
-          attrs[:number] =
-            opts[:series] ? "#{opts[:series]}#{num}" : num
+      # Dispatch deserialization to the concrete class named by the stored
+      # `_type`, so `from_hash` rebuilds a Corrigendum rather than a bare root
+      # (lutaml resolves `_type` only for validation, not instantiation).
+      # Mirrors Pubid::Jis::Identifier.from_hash. The `klass == self` guard lets
+      # the matched subclass fall through to lutaml's inherited from_hash.
+      def self.from_hash(data, options = {})
+        type = data["_type"] || data[:_type]
+        klass_name = CCSDS_TYPE_MAP[type]
+        if klass_name
+          klass = Object.const_get(klass_name)
+          return klass.from_hash(data, options) unless klass == self
         end
-
-        attrs[:type] = opts[:book_color].to_s if opts[:book_color]
-        # Allow caller to pass :type as data when no :book_color given
-        # (parsed identifiers expose it via Base#type attribute).
-        attrs[:type] = opts[:type].to_s if opts[:type] && !attrs[:type]
-
-        %i[part edition suffix language].each do |k|
-          v = opts[k]
-          attrs[k] = v.to_s unless v.nil?
-        end
-
-        attrs
+        super
       end
-      private_class_method :supplement_klass_for, :coerce_create_attrs
     end
   end
 end