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

data/lib/pubid/iec/identifier.rb

@@ -1,256 +1,294 @@
-require_relative "../identifier"
 # frozen_string_literal: true
-require_relative "../components/typed_stage"
-require_relative "../components/factory"
 
 module Pubid
   module Iec
+    # Mixin for pure wrapper identifiers (Vap/Consolidated/Sheet) whose common
+    # ID fields are delegated to a wrapped base. lutaml merges a subclass's
+    # key_value block onto the parent's, so without this the delegated fields
+    # would serialize twice — once at the wrapper's top level and once inside
+    # "base". No-op the delegated maps so they serialize once. (Mirrors
+    # Iso::BundledIdentifier.) Fragment keeps its own stage/edition, so it
+    # suppresses a subset inline instead of including this.
+    module DelegatedFieldSuppression
+      def number_to_kv(_model, _doc); end
+      def part_to_kv(_model, _doc); end
+      def subpart_to_kv(_model, _doc); end
+      def stage_iteration_to_kv(_model, _doc); end
+      def year_to_kv(_model, _doc); end
+      def publisher_to_kv(_model, _doc); end
+      def copublishers_to_kv(_model, _doc); end
+      def stage_to_kv(_model, _doc); end
+    end
+
     class Identifier < ::Pubid::Identifier
-      # Long-tail document types that `create` may build but which are not in
-      # Scheme.identifiers (the parse/build candidate set). Loaded lazily (not
-      # at require time) to avoid a circular load with identifiers/base.rb.
-      EXTRA_CREATE_KLASS_FILES = %w[
-        conformity_assessment technology_report white_paper
-        societal_technology_trend_report systems_reference_document
-        interpretation_sheet
-      ].freeze
-      def self.parse(string)
-        # Route URN strings to the URN parser (mirrors Iso::Identifier.parse)
-        if Pubid::FormatDetector.detect(string) == :urn
-          return Pubid::Iec::UrnParser.parse(string)
-        end
+      # Override base types with IEC-specific ones. publisher defaults to the
+      # type's implied publisher (IEC), so an omitted publisher key reconstructs
+      # correctly on from_hash. number/part/subpart are IEC codes.
+      attribute :publisher, ::Pubid::Iec::Components::Publisher,
+                default: -> { self.class.default_publisher }
+      attribute :copublishers, ::Pubid::Iec::Components::Publisher,
+                collection: true
+      attribute :number, ::Pubid::Iec::Components::Code
+      attribute :part, ::Pubid::Iec::Components::Code
+      attribute :subpart, ::Pubid::Iec::Components::Code
 
-        # Apply legacy update_codes normalization first, before any other preprocessing
-        normalized = Core::UpdateCodes.apply(string, :iec)
-        parsed = Pubid::Iec::Parser.new.parse(normalized)
-        if parsed.nil? || parsed.empty?
-          raise Pubid::Iec::Parser::ParseError,
-                "Invalid identifier format"
-        end
+      # The publisher implied when none is serialized (IEC for every type).
+      def self.default_publisher
+        ::Pubid::Iec::Components::Publisher.new(body: "IEC")
+      end
 
-        Pubid::Iec::Builder.new(Pubid::Iec::Scheme).build(parsed)
+      # typed_stage is the single source of truth for stage (and, with the
+      # class, the doctype). Default to the class's published typed_stage so an
+      # omitted "stage" key reconstructs the published state on from_hash.
+      attribute :typed_stage, ::Pubid::Components::TypedStage,
+                default: -> { self.class.published_typed_stage }
+
+      # The class's published typed_stage (canonical surface form), or nil for
+      # types without a published stage.
+      def self.published_typed_stage
+        return nil unless const_defined?(:TYPED_STAGES)
+
+        ts = self::TYPED_STAGES.find { |t| t.stage_code.to_s == "published" }
+        return nil unless ts
+
+        ts = ts.dup
+        ts.original_abbr = ts.canonical_abbreviation
+        ts
       end
 
-      # Factory mirroring pubid 1.x's `Pubid::Iec::Identifier.create` API.
-      # See {Pubid::Iso::Identifier.create} for the shared design. Builds the
-      # IEC `Components::*` subclasses (not the base ones) and populates
-      # type/stage from the resolved TypedStage, so that a created identifier
-      # round-trips `==` against the same identifier produced by `parse`.
-      def self.create(type: nil, stage: nil, **opts)
-        # A VAP suffix (CSV/RLV/…) is the outermost wrapper around the base
-        # document (which may itself be amended); rebuild it first.
-        if (vap = opts.delete(:vap))
-          base = create(type: type, stage: stage, **opts)
-          return Identifiers::VapIdentifier.new(
-            base_identifier: base,
-            vap_suffix: Components::VapSuffix.new(code: Array(vap).first.to_s),
-          )
-        end
+      # type and generic stage are derived from typed_stage, never stored — so
+      # the doctype (fixed by the class / _type) can't be lost when "stage" is
+      # omitted for the published default.
+      def type
+        typed_stage&.to_type
+      end
 
-        # Structured index rows carry amendments/corrigendums as a flat list
-        # alongside the base document's keys; rebuild the supplement wrapping
-        # the recursively-created base, mirroring what parse produces.
-        if (supp = extract_supplement(opts))
-          return build_supplement(supp, type: type, stage: stage, opts: opts)
-        end
+      def stage
+        typed_stage&.to_stage
+      end
 
-        # A nested base: holds the base document of a supplement whose own
-        # number/year sit at the top level (e.g. an Interpretation Sheet).
-        if (base_hash = opts.delete(:base))
-          return build_based_supplement(type: type, base_hash: base_hash,
-                                        opts: opts)
-        end
+      # Polymorphic type map for lutaml::Model key_value serialization. Maps
+      # polymorphic_name -> class name for from_hash dispatch. Includes the
+      # compound wrappers (Consolidated/Vap/Sheet) and the synthetic
+      # SingleIdentifier base, which appear as nested `_type` values even though
+      # they aren't identifier_types. Validated against build_type_map by spec.
+      IEC_TYPE_MAP = {
+        "pubid:iec:international-standard" => "Pubid::Iec::Identifiers::InternationalStandard",
+        "pubid:iec:technical-specification" => "Pubid::Iec::Identifiers::TechnicalSpecification",
+        "pubid:iec:technical-report" => "Pubid::Iec::Identifiers::TechnicalReport",
+        "pubid:iec:publicly-available-specification" => "Pubid::Iec::Identifiers::PubliclyAvailableSpecification",
+        "pubid:iec:guide" => "Pubid::Iec::Identifiers::Guide",
+        "pubid:iec:operational-document" => "Pubid::Iec::Identifiers::OperationalDocument",
+        "pubid:iec:component-specification" => "Pubid::Iec::Identifiers::ComponentSpecification",
+        "pubid:iec:conformity-assessment" => "Pubid::Iec::Identifiers::ConformityAssessment",
+        "pubid:iec:societal-technology-trend-report" => "Pubid::Iec::Identifiers::SocietalTechnologyTrendReport",
+        "pubid:iec:systems-reference-document" => "Pubid::Iec::Identifiers::SystemsReferenceDocument",
+        "pubid:iec:technology-report" => "Pubid::Iec::Identifiers::TechnologyReport",
+        "pubid:iec:test-report-form" => "Pubid::Iec::Identifiers::TestReportForm",
+        "pubid:iec:white-paper" => "Pubid::Iec::Identifiers::WhitePaper",
+        "pubid:iec:working-document" => "Pubid::Iec::Identifiers::WorkingDocument",
+        "pubid:iec:amendment" => "Pubid::Iec::Identifiers::Amendment",
+        "pubid:iec:corrigendum" => "Pubid::Iec::Identifiers::Corrigendum",
+        "pubid:iec:interpretation-sheet" => "Pubid::Iec::Identifiers::InterpretationSheet",
+        "pubid:iec:fragment-identifier" => "Pubid::Iec::Identifiers::FragmentIdentifier",
+        "pubid:iec:consolidated-identifier" => "Pubid::Iec::Identifiers::ConsolidatedIdentifier",
+        "pubid:iec:vap-identifier" => "Pubid::Iec::Identifiers::VapIdentifier",
+        "pubid:iec:sheet-identifier" => "Pubid::Iec::Identifiers::SheetIdentifier",
+        "pubid:iec:base" => "Pubid::Iec::Identifiers::Base",
+        "pubid:iec:single-identifier" => "Pubid::Iec::SingleIdentifier",
+      }.freeze
 
-        klass = resolve_create_class(type: type, stage: stage)
-        attrs = coerce_create_attrs(opts)
-        ts = resolve_create_typed_stage(klass, stage)
-        if ts
-          attrs[:typed_stage] = ts
-          # Parse derives `type` and `stage` from the TypedStage (see
-          # Builder#cast for :type_with_stage); mirror that here.
-          attrs[:type] ||= ts.to_type
-          attrs[:stage] ||= ts.to_stage
-        end
-        klass.new(**attrs)
+      # SingleIdentifier lives outside Pubid::Iec::Identifiers but appears as a
+      # nested `_type`, so the shared polymorphic_type_map needs it explicitly
+      # (see Pubid::Identifier#additional_identifier_classes).
+      def self.additional_identifier_classes
+        [Pubid::Iec::SingleIdentifier]
       end
+      private_class_method :additional_identifier_classes
 
-      # Pop a supplement spec off the flat opts hash, if present. Returns
-      # { klass:, entry: } or nil. Amendments take precedence over
-      # corrigendums for the (rare) consolidated rows that carry both.
-      def self.extract_supplement(opts)
-        if (amds = opts.delete(:amendments))
-          { klass: Identifiers::Amendment, entry: Array(amds).first }
-        elsif (cors = opts.delete(:corrigendums))
-          { klass: Identifiers::Corrigendum, entry: Array(cors).first }
-        end
+      # Build the type map from the live class list, for the validation spec.
+      def self.build_type_map
+        types = Pubid::Iec.identifier_types
+        extra = [Identifiers::ConsolidatedIdentifier, Identifiers::VapIdentifier,
+                 Identifiers::SheetIdentifier, Identifiers::Base, SingleIdentifier]
+        (types + extra).uniq.to_h { |klass| [klass.polymorphic_name, klass.name] }
       end
 
-      # Build an Amendment/Corrigendum from { number:, year: } wrapping a base
-      # identifier created from the remaining opts (which may themselves carry
-      # a type, e.g. an amendment to a TR).
-      def self.build_supplement(supp, type:, stage:, opts:)
-        base = create(type: type, stage: stage, **opts)
-        klass = supp[:klass]
-        entry = supp[:entry] || {}
-        ts = klass::TYPED_STAGES.find { |t| t.stage_code.to_sym == :published }
-        attrs = { base_identifier: base, typed_stage: ts,
-                  type: ts.to_type, stage: ts.to_stage }
-        if (n = entry[:number])
-          attrs[:number] = Components::Code.new(number: n.to_s)
-        end
-        if (y = entry[:year])
-          attrs[:date] = ::Pubid::Components::Date.new(year: y.to_s)
-        end
-        klass.new(**attrs)
+      # The base Pubid::Identifier no longer auto-maps attributes, so each
+      # flavor's top class declares its own key_value mapping. Subclasses merge
+      # their own blocks on top of this one (e.g. SupplementIdentifier adds
+      # base; VapIdentifier adds vap), so list every base attribute IEC
+      # serializes here once. Code/Date are flattened to plain scalars; the
+      # verbose type/stage trees are not mapped (type/stage are recomputed from
+      # typed_stage, which serializes as just its code under "stage").
+      key_value do
+        map "_type", to: :_type, polymorphic_map: IEC_TYPE_MAP
+        # Code components serialize as their plain string value, not {value,...}.
+        map "number", with: { to: :number_to_kv, from: :number_from_kv }
+        map "part", with: { to: :part_to_kv, from: :part_from_kv }
+        map "subpart", with: { to: :subpart_to_kv, from: :subpart_from_kv }
+        map "stage_iteration",
+            with: { to: :stage_iteration_to_kv, from: :stage_iteration_from_kv }
+        # IEC dates are year-only, so flatten the Date component to a scalar year.
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "edition", to: :edition, render_default: false
+        map "languages", to: :languages, render_default: false
+        # publisher emitted only when the primary isn't the IEC default;
+        # copublishers (the other bodies) as an array, omitted when empty.
+        map "publisher", with: { to: :publisher_to_kv, from: :publisher_from_kv }
+        map "copublishers",
+            with: { to: :copublishers_to_kv, from: :copublishers_from_kv }
+        # `type` and generic `stage` are fully derived from `typed_stage`, so we
+        # serialize only the unique typed-stage code under "stage" and recompute
+        # the rest on load. _type already pins the document type.
+        map "stage", with: { to: :stage_to_kv, from: :stage_from_kv }
+        # Omit the `false` default; only the meaningful `true` is serialized.
+        map "all_parts", with: { to: :all_parts_to_kv, from: :all_parts_from_kv }
       end
 
-      # Build a supplement whose base document is carried in a nested base:
-      # hash (e.g. type: "ISH"); the supplement's own number/year are the
-      # remaining top-level keys.
-      def self.build_based_supplement(type:, base_hash:, opts:)
-        klass = (type && locate_klass_by_type_or_short(type)) ||
-                Identifiers::InternationalStandard
-        base = create(**base_hash.transform_keys(&:to_sym))
-        attrs = coerce_create_attrs(opts)
-                .slice(:number, :part, :subpart, :date, :publisher, :copublishers)
-        attrs[:base_identifier] = base
-        if klass.const_defined?(:TYPED_STAGES) &&
-            (ts = klass::TYPED_STAGES.find { |t| t.stage_code.to_sym == :published })
-          attrs[:typed_stage] = ts
-          attrs[:type] ||= ts.to_type
-          attrs[:stage] ||= ts.to_stage
-        end
-        klass.new(**attrs)
+      # --- Code components <-> plain string ---
+      def number_to_kv(model, doc) = emit_code(doc, "number", model.number)
+      def number_from_kv(model, value) = model.number = build_code(value)
+      def part_to_kv(model, doc) = emit_code(doc, "part", model.part)
+      def part_from_kv(model, value) = model.part = build_code(value)
+      def subpart_to_kv(model, doc) = emit_code(doc, "subpart", model.subpart)
+      def subpart_from_kv(model, value) = model.subpart = build_code(value)
+
+      def emit_code(doc, key, code)
+        v = code.is_a?(::Pubid::Components::Code) ? code.value : code
+        return if v.nil? || v.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, v.to_s))
       end
 
-      # Coerce a 1.x-style attribute hash into IEC Component instances,
-      # matching what the parser/builder produces. Unknown keys are dropped.
-      def self.coerce_create_attrs(opts)
-        out = {}
-        if (v = opts[:publisher])
-          out[:publisher] = Components::Publisher.new(body: v.to_s)
-        end
-        if (copubs = opts[:copublishers] || opts[:copublisher])
-          out[:copublishers] =
-            Array(copubs).map { |c| Components::Publisher.new(body: c.to_s) }
-        end
-        if (v = opts[:number])
-          out[:number] = Components::Code.new(number: v.to_s)
-        end
-        # Indexes fold the subpart into a single "2-4" part string; parse
-        # keeps part and subpart separate, so split to match.
-        part, subpart = split_part(opts[:part], opts[:subpart])
-        out[:part] = Components::Code.new(number: part.to_s) unless part.nil?
-        out[:subpart] = Components::Code.new(number: subpart.to_s) unless subpart.nil?
-        if (v = opts[:year])
-          out[:date] = ::Pubid::Components::Date.new(year: v.to_s)
-        end
-        if (v = opts[:edition])
-          out[:edition] = ::Pubid::Components::Edition.new(number: v)
-        end
-        if (v = opts[:language])
-          out[:languages] = [::Pubid::Components::Language.new(code: v.to_s)]
-        end
-        out[:database] = true if opts[:database]
-        out
+      def build_code(value)
+        return if value.nil? || value.to_s.empty?
+
+        ::Pubid::Iec::Components::Code.new(value: value.to_s)
       end
 
-      # Split a folded "2-4" part into [part, subpart], matching parse. A part
-      # without a dash (or an explicit subpart already supplied) is untouched.
-      def self.split_part(part, subpart)
-        return [nil, subpart] if part.nil?
-        if subpart.nil? && part.to_s.include?("-")
-          part.to_s.split("-", 2)
-        else
-          [part, subpart]
-        end
+      def stage_iteration_to_kv(model, doc)
+        iter = model.stage_iteration
+        v = iter.is_a?(::Pubid::Components::Iteration) ? iter.number : iter
+        return if v.nil? || v.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("stage_iteration",
+                                                              v.to_s))
       end
 
-      def self.resolve_create_class(type:, stage:)
-        if type && supplement_type?(type)
-          # Supplements are built from amendments:/corrigendums: data (which
-          # carry the supplement number/year); an explicit supplement `type:`
-          # alone has no base to wrap.
-          raise ArgumentError,
-                "#{type} requires a base_identifier; pass amendments:/" \
-                "corrigendums: instead of type:"
-        end
+      def stage_iteration_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
 
-        klass =
-          if type
-            locate_klass_by_type_or_short(type)
-          elsif stage
-            ts = safe_locate_typed_stage(stage)
-            ts && locate_klass_by_type_or_short(ts.type_code)
-          end
-        klass || Identifiers::InternationalStandard
+        model.stage_iteration =
+          ::Pubid::Components::Iteration.new(number: value.to_s)
       end
 
-      # True when `type` names a supplement identifier (Amendment/Corrigendum/
-      # Fragment) by key, downcased key, or short abbreviation.
-      def self.supplement_type?(type)
-        t = type.to_s
-        Scheme.supplement_identifiers.any? do |k|
-          k.type[:key].to_s == t || k.type[:key].to_s == t.downcase ||
-            Array(k.type[:short]).map(&:to_s).include?(t)
-        end
+      # --- date <-> scalar year (IEC dates are year-only) ---
+      def year_to_kv(model, doc)
+        y = model.date&.year
+        return if y.nil? || y.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("year", y.to_s))
+      end
+
+      def year_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
+
+        (model.date ||= ::Pubid::Components::Date.new).year = value.to_s
       end
 
-      # Structured indexes store `type:` as the registry key (:tr), an
-      # upper-cased abbreviation ("TR"), or a title ("Technology Report").
-      # Try each spelling, across every IEC identifier class (the create
-      # candidate set is wider than Scheme.identifiers).
-      def self.locate_klass_by_type_or_short(type)
-        t = type.to_s
-        all_create_klasses.detect { |k| k.type[:key].to_s == t } ||
-          all_create_klasses.detect { |k| k.type[:key].to_s == t.downcase } ||
-          all_create_klasses.detect { |k| Array(k.type[:short]).map(&:to_s).include?(t) } ||
-          all_create_klasses.detect { |k| k.type[:title].to_s == t }
+      # --- publisher: primary only when non-default; copublishers as a list ---
+      def publisher_to_kv(model, doc)
+        pub = model.publisher&.body
+        return if pub.nil? || pub == model.class.default_publisher&.body
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("publisher", pub))
+      end
+
+      def publisher_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
+
+        model.publisher = ::Pubid::Iec::Components::Publisher.new(body: value.to_s)
       end
 
-      # All IEC identifier classes that `create` may build, including the
-      # long-tail document types absent from Scheme.identifiers. Memoized;
-      # the extra classes are required here (not at load time) to dodge the
-      # circular require with identifiers/base.rb.
-      def self.all_create_klasses
-        @all_create_klasses ||= begin
-          extra = EXTRA_CREATE_KLASS_FILES.map do |f|
-            require_relative "identifiers/#{f}"
-            Identifiers.const_get(camelize_klass_file(f))
-          end
-          Scheme.identifiers + extra
+      def copublishers_to_kv(model, doc)
+        cp = model.copublishers
+        return unless cp&.any?
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("copublishers", cp.map(&:body)),
+        )
+      end
+
+      def copublishers_from_kv(model, value)
+        list = Array(value).map(&:to_s)
+        return unless list.any?
+
+        model.copublishers = list.map do |cp|
+          ::Pubid::Iec::Components::Publisher.new(body: cp)
         end
       end
 
-      def self.camelize_klass_file(file)
-        file.split("_").map(&:capitalize).join
+      # --- all_parts: omit the false default ---
+      def all_parts_to_kv(model, doc)
+        return unless model.all_parts
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("all_parts", true))
+      end
+
+      def all_parts_from_kv(model, value)
+        model.all_parts = value
+      end
+
+      # Serialize typed_stage as just its unique code (e.g. "cd", "fdis"); the
+      # published default is omitted (recomputed from the class on load).
+      def stage_to_kv(model, doc)
+        ts = model.typed_stage
+        return unless ts&.code
+        return if ts.stage_code.to_s == "published"
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("stage", ts.code.to_s),
+        )
       end
 
-      # IEC Scheme raises ArgumentError on miss instead of returning nil;
-      # wrap so the same control flow works as in the ISO factory.
-      def self.safe_locate_typed_stage(abbr)
-        Scheme.locate_typed_stage_by_abbr(abbr.to_s)
-      rescue ArgumentError
-        nil
+      # Resolve the typed-stage code back within this identifier's class.
+      def stage_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
+
+        ts = (model.class.const_defined?(:TYPED_STAGES) &&
+              model.class::TYPED_STAGES.find { |t| t.code.to_s == value.to_s }) ||
+             Pubid::Iec.all_typed_stages.find { |t| t.code.to_s == value.to_s }
+        return unless ts
+
+        ts = ts.dup
+        ts.original_abbr = ts.canonical_abbreviation
+        model.typed_stage = ts
       end
 
-      def self.resolve_create_typed_stage(klass, stage)
-        if stage
-          safe_locate_typed_stage(stage)
-        elsif klass.const_defined?(:TYPED_STAGES)
-          klass.const_get(:TYPED_STAGES).find do |ts|
-            ts.stage_code.to_sym == :published
-          end
+      def self.parse(string)
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        # Route URN strings to the URN parser (mirrors Iso::Identifier.parse)
+        if Pubid::FormatDetector.detect(string) == :urn
+          return Pubid::Iec::UrnParser.parse(string)
         end
+
+        # Apply legacy update_codes normalization first, before any other preprocessing
+        normalized = Core::UpdateCodes.apply(string, :iec)
+        parsed = Pubid::Iec::Parser.new.parse(normalized)
+        if parsed.nil? || parsed.empty?
+          raise Pubid::Iec::Parser::ParseError,
+                "Invalid identifier format"
+        end
+
+        Pubid::Iec::Builder.new.build(parsed)
       end
-      private_class_method :resolve_create_class,
-                           :safe_locate_typed_stage,
-                           :resolve_create_typed_stage, :coerce_create_attrs,
-                           :extract_supplement, :build_supplement,
-                           :build_based_supplement,
-                           :locate_klass_by_type_or_short, :all_create_klasses,
-                           :camelize_klass_file, :supplement_type?,
-                           :split_part
+
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
+      # IEC_TYPE_MAP remains as the key_value polymorphic_map.
     end
   end
 end

data/lib/pubid/iec/identifiers/amendment.rb

@@ -1,6 +1,4 @@
-require_relative "../supplement_identifier"
 # frozen_string_literal: true
-require_relative "../../components/typed_stage"
 
 module Pubid
   module Iec
@@ -86,7 +84,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :amd, title: "Amendment", short: "AMD" }
+          { key: :amd,
+            web: :amendment, title: "Amendment", short: "AMD" }
         end
       end
     end

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

@@ -1,9 +1,4 @@
-require_relative "../single_identifier"
 # frozen_string_literal: true
-require_relative "../components/publisher"
-require_relative "../components/code"
-require_relative "../components/vap_suffix"
-require_relative "../components/trf_info"
 
 module Pubid
   module Iec
@@ -12,37 +7,17 @@ module Pubid
       # Inherits from SingleIdentifier to get common functionality
       # Single Responsibility: Common IEC identifier attributes and behavior
       class Base < SingleIdentifier
-        # IEC-specific attributes
-        attribute :vap_suffix, Components::VapSuffix, default: -> {}
+        # IEC-specific attributes. VAP codes live on VapIdentifier, not here.
         attribute :trf_info, Components::TrfInfo, default: -> {}
         attribute :database, :boolean, default: -> { false }
         attribute :fragment, :string, default: -> {}
         attribute :version, :string, default: -> {}
         attribute :decision_sheet, :string, default: -> {}
 
-        def to_s(_format = :short)
-          parts = []
-
-          # Publisher and type portion (from typed_stage) - uses inherited method
-          parts << publisher_portion
-
-          # Number portion (number with part/subpart)
-          parts << number_portion
-
-          # Edition if present - add space before edition
-          parts << " #{edition}" if edition&.number
-
-          # VAP suffix
-          parts << vap_suffix.render_with_space if vap_suffix
-
-          # Database flag
-          parts << " DB" if database
-
-          # All-parts marker — rendered the same as the generic
-          # HumanReadable renderer for parity (see Pubid::Renderers::HumanReadable#render).
-          parts << " (all parts)" if all_parts
-
-          parts.compact.join
+        # database is the only Base-specific serialized key (emitted when set);
+        # merged onto the common map inherited from Identifier.
+        key_value do
+          map "database", to: :database, render_default: false
         end
 
         def number_portion
@@ -70,9 +45,6 @@ module Pubid
         def validate!
           super if defined?(super)
 
-          # Validate VAP suffix if present
-          vap_suffix&.validate!
-
           # Validate TRF info if present
           trf_info&.validate! if trf_info && !trf_info.empty?
         end

data/lib/pubid/iec/identifiers/component_specification.rb

@@ -1,5 +1,4 @@
-require_relative "base"
-require_relative "../../components/typed_stage"
+# frozen_string_literal: true
 
 module Pubid
   module Iec
@@ -20,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :cs, title: "Component Specification", short: "CS" }
+          { key: :cs,
+            web: :component_specification, title: "Component Specification", short: "CS" }
         end
 
         # Override publisher_portion to add CS

data/lib/pubid/iec/identifiers/conformity_assessment.rb

@@ -1,5 +1,4 @@
-require_relative "base"
-require_relative "../../components/typed_stage"
+# frozen_string_literal: true
 
 module Pubid
   module Iec