pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/bsi.rb

@@ -2,21 +2,6 @@
 
 module Pubid
   module Bsi
-    extend Pubid::PrefixesSupport
-
-    # Leading tokens a printed BSI reference can start with, curated from the
-    # parser grammar (lib/pubid/bsi/parser.rb): the publisher (`bs` => BS/BSI),
-    # the native series/type rules that begin references (dd, pd, pas, na, ts,
-    # handbook => HB, pp, bip, ep_type), and the "BS <adopted-org>" combos the
-    # grammar builds from `bs` + `adopted_org_prefix`. Deliberately EXCLUDES the
-    # aerospace single/multi-letter prefixes (see
-    # identifiers/aerospace_standard.rb SINGLE_LETTER_PREFIXES / the parser's
-    # `single_letter_prefix` rule — A/B/C/S/X ...) because they are dangerously
-    # ambiguous and never lead a routable reference on their own; and the bare
-    # adopted forms (ISO/IEC/EN alone), which route to their own SDOs.
-    PREFIXES = (%w[BS BSI DD PD PAS NA TS HB PP BIP EP] +
-      ["BS EN", "BS ISO", "BS IEC", "BS EN ISO", "BS EN IEC"]).freeze
-
     module Components
       autoload :Code, "#{__dir__}/bsi/components/code"
       autoload :Date, "#{__dir__}/bsi/components/date"
@@ -27,256 +12,21 @@ module Pubid
     autoload :Builder, "#{__dir__}/bsi/builder"
     autoload :Identifier, "#{__dir__}/bsi/identifier"
     autoload :Identifiers, "#{__dir__}/bsi/identifiers"
-    # NOTE: bsi/model.rb is legacy/unused (nothing references Pubid::Bsi::Model)
-    # and defines a conflicting `class Identifier < Lutaml::Model::Serializable`.
-    # It is intentionally NOT autoloaded so it can never clash with the real
-    # Pubid::Bsi::Identifier (single_identifier.rb).
+    autoload :Model, "#{__dir__}/bsi/model"
     autoload :Parser, "#{__dir__}/bsi/parser"
-    autoload :Renderer, "#{__dir__}/bsi/renderer"
+    autoload :Scheme, "#{__dir__}/bsi/scheme"
     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)
-      unless string.is_a?(String)
-        raise Pubid::Errors::InvalidInputError,
-              Pubid::INPUT_NOT_A_STRING_MESSAGE
-      end
-
-      if string.length > Pubid::MAX_INPUT_LENGTH
-        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-      end
-
       Identifier.parse(string)
     end
 
     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,43 +5,31 @@ 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:
-    # - +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.
+    # objects. Flavors subclass and override only `cast` and optionally
+    # `default_identifier_class`.
     #
     # The build loop:
     # 1. Flattens array-of-hashes input (from Parslet transforms)
-    # 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
+    # 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)
     class Base
       attr_reader :identifier
 
-      def initialize(identifier_class = nil)
+      def initialize(identifier_class = default_identifier_class)
         @identifier_class = identifier_class
       end
 
       def build(data)
         data = flatten_array(data) if data.is_a?(Array)
-        identifier_class = @identifier_class || select_class(data)
-        identifier = identifier_class.new
+        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.
@@ -99,9 +87,8 @@ module Pubid
       }.freeze
 
       def locate_typed_stage(typed_stage_string)
-        raise NotImplementedError,
-              "#{self.class} must implement locate_typed_stage " \
-              "(rely on the flavor module's locate_stage method)"
+        typed_stage_string = "" if typed_stage_string.nil?
+        @scheme.locate_typed_stage_by_abbr(typed_stage_string)
       end
 
       def convert_roman_to_integer(roman_numeral)
@@ -125,11 +112,9 @@ module Pubid
 
       def parse_date(value)
         value = value.to_s
-        if value.match?(/^\d{4}(-\d{2}){0,2}$/)
-          year, month, day = value.split("-")
-          Pubid::Components::Date.new(year: year,
-                                       month: month || nil,
-                                       day: day || nil)
+        if value.match?(/^\d{4}(-\d{2})?$/)
+          year, month = value.split("-")
+          Pubid::Components::Date.new(year: year, month: month || nil)
         elsif value.is_a?(Integer) || (value.is_a?(String) && value.match?(/^\d{4}$/))
           Pubid::Components::Date.new(year: value)
         else
@@ -137,40 +122,6 @@ 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,3 +1,4 @@
+require_relative "identifier"
 # frozen_string_literal: true
 
 module Pubid
@@ -45,27 +46,22 @@ module Pubid
       base_document&.typed_stage
     end
 
-    # `**opts` carries render flags this method does not name — `annotated:`
-    # above all. Without it the closed keyword list raised
-    # `ArgumentError: unknown keyword: :annotated` for every bundled
-    # identifier, which is worse than a missing span: a wrapper is exactly the
-    # shape a consumer renders.
     def to_s(lang: :en, lang_single: false, with_edition: false, format: nil,
-stage_format_long: nil, with_date: nil, **opts)
+stage_format_long: nil, with_date: nil)
       result = base_document.to_s(lang: lang, lang_single: lang_single,
-                                  with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)
+                                  with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)
 
       supplements.each do |supplement|
         # ISO DirectivesSupplement always uses " + " (space before)
-        # CEN-style supplements (AC, A) without base use "+" (no space before)
-        # Other ISO supplements with base use " + " (space before)
+        # CEN-style supplements (AC, A) without base_identifier use "+" (no space before)
+        # Other ISO supplements with base_identifier use " + " (space before)
         if supplement.class.name&.include?("DirectivesSupplement") ||
-            (supplement.class.attributes.key?(:base) && !supplement.base.nil?)
+            (supplement.class.attributes.key?(:base_identifier) && !supplement.base_identifier.nil?)
           result += " + #{supplement.to_s(lang: lang, lang_single: lang_single,
-                                          with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)}"
+                                          with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)}"
         else
           result += "+#{supplement.to_s(lang: lang, lang_single: lang_single,
-                                        with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)}"
+                                        with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)}"
         end
       end
 
@@ -107,13 +103,9 @@ stage_format_long: nil, with_date: nil, **opts)
             parts << supplement.date.year.to_s
           end
 
-          # Add supplement number if present. `supplement` is polymorphic and
-          # `number` is a Components::Code on ::Pubid::Identifier but a plain
-          # :string in a growing number of flavors, so read through either.
+          # Add supplement number if present
           if supplement.number
-            number = supplement.number
-            value = number.respond_to?(:value) ? number.value : number
-            parts << "v#{value}"
+            parts << "v#{supplement.number.value}"
           end
         end
       end

data/lib/pubid/ccsds/builder.rb

@@ -34,21 +34,20 @@ 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_s }
+        corr_numbers = corr_array.map { |c| c[:cor_number].to_i }
 
         # 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. The corrigendum
-        # sequence is stored in the inherited `number` attribute (mirroring ISO).
+        # Build Corrigendum object for each corrigendum number
         # 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: current_base,
-            number: cor_num,
+            base_identifier: current_base,
+            cor_number: cor_num,
           )
         end
       end

data/lib/pubid/ccsds/identifier.rb

@@ -2,75 +2,15 @@
 
 module Pubid
   module Ccsds
-    # 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` 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.
+    module Identifier
       def self.parse(identifier)
-        unless identifier.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if identifier.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
         # Apply legacy update_codes normalization first
         normalized = Core::UpdateCodes.apply(identifier, :ccsds)
         parsed = Pubid::Ccsds::Parser.parse(normalized)
         Pubid::Ccsds::Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse CCSDS identifier '#{identifier}': #{e.message}"
       end
-
-      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
-      # CCSDS_TYPE_MAP remains as the key_value polymorphic_map.
     end
   end
 end

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

@@ -3,15 +3,12 @@
 module Pubid
   module Ccsds
     module Identifiers
-      # CCSDS base identifier (a published standard).
-      #
-      # Format: CCSDS NUMBER.PART-TYPE-EDITION[-SUFFIX][ - LANGUAGE Translated]
-      # Examples: CCSDS 120.0-G-4, CCSDS 100.0-G-1-S, CCSDS 551.1-O-2 - Russian Translated
-      #
-      # Attributes, the key_value mapping and from_hash dispatch live on the
-      # abstract root Pubid::Ccsds::Identifier; this concrete type only carries
-      # its typed stage and rendering.
-      class Base < Pubid::Ccsds::Identifier
+      # CCSDS identifier
+      # Format: CCSDS NUMBER.PART-TYPE-EDITION[-SUFFIX]
+      # Example: CCSDS 120.0-G-4, CCSDS 100.0-G-1-S
+      class Base < Lutaml::Model::Serializable
+        # CCSDS uses a simple architecture without typed stages
+        # TYPED_STAGES includes default stage for base identifiers
         TYPED_STAGES = [
           Pubid::Components::TypedStage.new(
             abbr: [""],
@@ -20,20 +17,60 @@ module Pubid
           ),
         ].freeze
 
+        # Type information for this identifier class
+        #
+        # @return [Hash] Type information with key, title, and short form
         def self.type
-          { key: :base, web: :base, title: "Base Standard", short: nil }
+          { key: :base, title: "Base Standard", short: nil }
         end
 
-        # Composes its string by hand rather than going through `render`, so
-        # the annotation hook has to be applied on the way out.
-        def to_s(**opts)
+        # Generate URN for this identifier
+        #
+        # @return [String] URN representation
+
+        # Include CCSDS-specific attributes in serialization
+        def base_hash
+          hash = super
+          # CCSDS uses plain strings for type, edition, suffix
+          hash[:type] = type if type
+          hash[:suffix] = suffix if suffix
+          hash[:language] = language if language
+          hash
+        end
+
+        attribute :number, :string
+        attribute :part, :string
+        attribute :type, :string # B, G, M, R, Y, O, etc.
+        attribute :edition, :string
+        attribute :suffix, :string # Optional suffix like -S
+        attribute :language, :string # Language metadata (e.g., "French", "Russian")
+
+        def publisher
+          "CCSDS"
+        end
+
+        def to_s
           result = "#{publisher} #{number}"
           result += ".#{part}" if part
           result += "-#{type}" if type
           result += "-#{edition}" if edition
           result += "-#{suffix}" if suffix
+
+          # Add language metadata
           result += " - #{language} Translated" if language
-          annotate_plain_render(result, **opts)
+
+          result
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Base)
+
+          number == other.number &&
+            part == other.part &&
+            type == other.type &&
+            edition == other.edition &&
+            suffix == other.suffix &&
+            language == other.language
         end
       end
     end

data/lib/pubid/ccsds/identifiers/corrigendum.rb

@@ -17,22 +17,21 @@ module Pubid
         #
         # @return [Hash] Type information with key, title, and short form
         def self.type
-          { key: :cor,
-            web: :corrigendum, title: "Corrigendum", short: "Cor" }
+          { key: :cor, title: "Corrigendum", short: "Cor" }
         end
 
-        # The corrigendum sequence number is stored in the inherited `number`
-        # attribute (mirroring ISO), so it serializes via Base's key_value as
-        # { _type, number: '1', base: {...} } with no corrigendum-specific map.
-        def to_s(**opts)
-          base_str = base.to_s
-          annotate_plain_render("#{base_str} Cor. #{number}", **opts)
+        attribute :cor_number, :integer
+
+        def to_s
+          base_str = base_identifier.to_s
+          "#{base_str} Cor. #{cor_number}"
         end
 
         def ==(other)
           return false unless other.is_a?(Corrigendum)
 
-          base == other.base && number == other.number
+          base_identifier == other.base_identifier &&
+            cor_number == other.cor_number
         end
       end
     end