pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/iso/identifier.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    class Identifier < ::Pubid::Identifier
+      # Override base types with ISO-specific ones.
+      # Defaults to the type's implied publisher (ISO for most; IWA has none),
+      # so an omitted publisher key reconstructs correctly on from_hash.
+      attribute :publisher, ::Pubid::Iso::Components::Publisher,
+                default: -> { self.class.default_publisher }
+      attribute :copublishers, ::Pubid::Iso::Components::Publisher,
+                collection: true
+
+      # The publisher implied when none is serialized. ISO for most types;
+      # publisher-less types (IWA) override this to nil.
+      def self.default_publisher
+        ::Pubid::Iso::Components::Publisher.new
+      end
+
+      # 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 with no stages (e.g. TC documents).
+      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
+
+      # type and 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
+
+      def stage
+        typed_stage&.to_stage
+      end
+
+      # Return a copy with the lifecycle stage set from an ISO harmonized stage
+      # code (e.g. "90.92"). typed_stage is the single source of truth, so this
+      # is all that is needed to surface the stage in #to_s and #to_urn. Returns
+      # an unchanged copy if the code is not recognised.
+      def with_harmonized_stage(harmonized_code)
+        ts = Pubid::Iso.locate_stage_by_harmonized_code(harmonized_code)
+        ts ? dup.tap { |id| id.typed_stage = ts } : dup
+      end
+
+      attribute :number, ::Pubid::Iso::Components::Code
+      attribute :part, ::Pubid::Iso::Components::Code
+      attribute :subpart, ::Pubid::Iso::Components::Code
+
+      # Polymorphic type map for lutaml::Model key_value serialization
+      # Maps polymorphic_name → class name for deserialization
+      # Validated by spec to stay in sync with identifier_types
+      ISO_TYPE_MAP = {
+        "pubid:iso:international-standard" => "Pubid::Iso::Identifiers::InternationalStandard",
+        "pubid:iso:international-standardized-profile" => "Pubid::Iso::Identifiers::InternationalStandardizedProfile",
+        "pubid:iso:international-workshop-agreement" => "Pubid::Iso::Identifiers::InternationalWorkshopAgreement",
+        "pubid:iso:technical-report" => "Pubid::Iso::Identifiers::TechnicalReport",
+        "pubid:iso:technical-specification" => "Pubid::Iso::Identifiers::TechnicalSpecification",
+        "pubid:iso:pas" => "Pubid::Iso::Identifiers::Pas",
+        "pubid:iso:guide" => "Pubid::Iso::Identifiers::Guide",
+        "pubid:iso:recommendation" => "Pubid::Iso::Identifiers::Recommendation",
+        "pubid:iso:amendment" => "Pubid::Iso::Identifiers::Amendment",
+        "pubid:iso:corrigendum" => "Pubid::Iso::Identifiers::Corrigendum",
+        "pubid:iso:supplement" => "Pubid::Iso::Identifiers::Supplement",
+        "pubid:iso:addendum" => "Pubid::Iso::Identifiers::Addendum",
+        "pubid:iso:extract" => "Pubid::Iso::Identifiers::Extract",
+        "pubid:iso:directives" => "Pubid::Iso::Identifiers::Directives",
+        "pubid:iso:directives-supplement" => "Pubid::Iso::Identifiers::DirectivesSupplement",
+        "pubid:iso:data" => "Pubid::Iso::Identifiers::Data",
+        "pubid:iso:tc-document" => "Pubid::Iso::Identifiers::TcDocument",
+        "pubid:iso:technology-trends-assessments" => "Pubid::Iso::Identifiers::TechnologyTrendsAssessments",
+        "pubid:iso:bundled-identifier" => "Pubid::Iso::BundledIdentifier",
+      }.freeze
+
+      # BundledIdentifier lives outside Pubid::Iso::Identifiers but carries a
+      # polymorphic `_type`, so the shared polymorphic_type_map needs it
+      # explicitly (see Pubid::Identifier#additional_identifier_classes).
+      def self.additional_identifier_classes
+        [Pubid::Iso::BundledIdentifier]
+      end
+      private_class_method :additional_identifier_classes
+
+      # Build type map from Pubid::Iso.identifier_types for validation
+      def self.build_type_map
+        Pubid::Iso.identifier_types.to_h do |klass|
+          [klass.polymorphic_name, klass.name]
+        end
+      end
+
+      # The base Pubid::Identifier no longer auto-maps attributes, so each
+      # flavor's top class must declare its own key_value mapping. Subclasses
+      # merge their own blocks on top of this one (e.g. SupplementIdentifier
+      # adds base; Directives adds subgroup), so list every base
+      # attribute ISO serializes here once.
+      key_value do
+        map "_type", to: :_type, polymorphic_map: ISO_TYPE_MAP
+        # Code components serialize as their plain string value, not {value,number}.
+        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 }
+        # date serialized flat as year/month/day, nils omitted.
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "month", with: { to: :month_to_kv, from: :month_from_kv }
+        map "day", with: { to: :day_to_kv, from: :day_from_kv }
+        # ISO/IEC undated reference (e.g. ISO 16634:--). The `false` default
+        # is omitted; only the meaningful `true` round-trips via to_hash.
+        map "undated", with: { to: :undated_to_kv, from: :undated_from_kv }
+        map "edition", to: :edition
+        map "languages", to: :languages
+        # publisher emitted only when the primary isn't the type 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 }
+        map "locality", to: :locality
+        # `type` and generic `stage` are fully derived from `typed_stage`
+        # (builder sets them via to_type/to_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
+
+      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. "is", "dis",
+      # "committee_draft_amd"). type/stage are recomputed from it on load.
+      def stage_to_kv(model, doc)
+        ts = model.typed_stage
+        return unless ts&.code
+        # Omit the published default (recomputed from the class on load).
+        return if ts.stage_code.to_s == "published"
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("stage", ts.code.to_s),
+        )
+      end
+
+      # Resolve the typed-stage code back to the full TypedStage within this
+      # identifier's class, then derive type/stage from it.
+      def stage_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
+
+        # The fallback consults the flavor-wide table. It used to call
+        # `Pubid::Iso::Scheme`, a class removed repo-wide in e3c19ea1 — so any
+        # code absent from the class's own TYPED_STAGES raised NameError
+        # instead of falling back. The IEC twin (iec/identifier.rb) was
+        # migrated at the time; ISO was missed.
+        ts = (model.class.const_defined?(:TYPED_STAGES) &&
+              model.class::TYPED_STAGES.find { |t| t.code.to_s == value.to_s }) ||
+             Pubid::Iso.locate_stage_by_code(value)
+        return unless ts
+
+        # The renderer prefers `original_abbr` (the parsed surface form); without
+        # it the supplement renderer falls back to `short_abbr` (e.g. "AMD").
+        # Resolving from a code has no surface form, so render the canonical
+        # abbreviation (`abbr.first`, e.g. "Amd").
+        ts = ts.dup
+        ts.original_abbr = ts.canonical_abbreviation
+        model.typed_stage = ts
+      end
+
+      # --- 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 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 stage_iteration_from_kv(model, value)
+        model.stage_iteration = ::Pubid::Components::Iteration.new(number: value.to_s)
+      end
+
+      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
+
+      def build_code(value)
+        ::Pubid::Iso::Components::Code.new(value: value.to_s)
+      end
+
+      # --- date serialized flat as year/month/day ---
+      def year_to_kv(model, doc) = emit_date_part(doc, "year", model.date&.year)
+      def year_from_kv(model, value) = date_for(model).year = value.to_s
+      def month_to_kv(model, doc) = emit_date_part(doc, "month", model.date&.month)
+      def month_from_kv(model, value) = date_for(model).month = value.to_s
+      def day_to_kv(model, doc) = emit_date_part(doc, "day", model.date&.day)
+      def day_from_kv(model, value) = date_for(model).day = value.to_s
+
+      # --- date undated flag (ISO/IEC undated reference, e.g. ISO 16634:--) ---
+      # The `false` default is omitted; only the meaningful `true` round-trips
+      # via to_hash / from_hash.
+      def undated_to_kv(model, doc)
+        return unless model.date&.undated?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("undated", true))
+      end
+
+      def undated_from_kv(model, value)
+        date_for(model).undated = value.to_s == "true"
+      end
+
+      def emit_date_part(doc, key, val)
+        return if val.nil? || val.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, val.to_s))
+      end
+
+      def date_for(model)
+        model.date ||= ::Pubid::Components::Date.new
+      end
+
+      # --- publisher: primary only when non-default; copublishers as a list ---
+      def publisher_to_kv(model, doc)
+        pub = model.publisher&.publisher
+        return if pub.nil? || pub == model.class.default_publisher&.publisher
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("publisher", pub))
+      end
+
+      def publisher_from_kv(model, value)
+        publisher_for(model).publisher = value.to_s
+      end
+
+      def copublishers_to_kv(model, doc)
+        cp = model.publisher&.copublisher
+        return unless cp&.any?
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("copublishers", cp.map(&:to_s)),
+        )
+      end
+
+      def copublishers_from_kv(model, value)
+        list = Array(value).map(&:to_s)
+        return unless list.any?
+
+        # Mirror Builder#parse: copublishers live both on the primary
+        # publisher (as strings) and as the top-level `copublishers`
+        # collection of Publisher objects. `==` compares the latter, so
+        # populate both or a deserialized id never equals a parsed one.
+        publisher_for(model).copublisher = list
+        model.copublishers = list.map do |cp|
+          ::Pubid::Iso::Components::Publisher.new(publisher: cp)
+        end
+      end
+
+      def publisher_for(model)
+        model.publisher ||= ::Pubid::Iso::Components::Publisher.new
+      end
+
+      def self.parse(string, format: :auto)
+        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
+
+        format = Pubid::FormatDetector.detect(string) if format == :auto
+
+        case format
+        when :urn
+          Pubid::Iso::UrnParser.parse(string)
+        when :mr_string
+          Pubid::Parsers::MrString.parse(string)
+        else
+          parsed = Pubid::Iso::Parser.new.parse(string)
+          Pubid::Iso::Builder.new.build(parsed)
+        end
+      end
+
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier, which
+      # routes `_type` through polymorphic_type_map (ISO_TYPE_MAP's dynamic
+      # equivalent). ISO_TYPE_MAP remains as the key_value polymorphic_map.
+    end
+  end
+end

data/lib/pubid/iso/identifiers/addendum.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Addendum < SupplementIdentifier
+
+        # Override URN supplement type to use generic "sup" instead of "add"
+        # This matches the ISO URN specification where addendums use "sup"
+        def urn_supplement_type
+          "sup"
+        end
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwi_add,
+            abbr: ["PWI Add"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :add,
+            stage_code: :proposal,
+            name: "Proposed Work Item for Addendum",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :np_add,
+            abbr: ["NP Add"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :add,
+            stage_code: :proposal,
+            name: "New Work Item Proposal for Addendum",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :awi_add,
+            abbr: ["AWI Add"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :add,
+            stage_code: :preliminary,
+            name: "Approved Work Item for Addendum",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wd_add,
+            abbr: ["WD Add"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :add,
+            stage_code: :working_draft,
+            name: "Working Draft for Addendum",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :committee_draft_add,
+            abbr: ["CD Add"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :add,
+            stage_code: :cd,
+            name: "Committee Draft for Addendum",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :dad,
+            abbr: ["DAD", "DAdd", "D ADD", "Dad", "DIS Add"],
+            short_abbr: "DAD",
+            # "DAdd" stays in `abbr` so it still parses, but render the canonical
+            # "DAD" (pubid v1 legacy_abbr parity). No long_abbr → no long render.
+            long_abbr: nil,
+            type_code: :add,
+            stage_code: :dad,
+            name: "Draft Addendum",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fdad,
+            abbr: ["FDAD", "FDAdd", "FD ADD", "FDad", "FDIS Add"],
+            short_abbr: "FDAD",
+            # See :dad — parse "FDAdd", render canonical "FDAD" (v1 parity).
+            long_abbr: nil,
+            type_code: :add,
+            stage_code: :fdad,
+            name: "Final Draft Addendum",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :published,
+            abbr: ["Add", "ADD", "Add.", "Addendum"],
+            short_abbr: "ADD",
+            long_abbr: "Add",
+            type_code: :add,
+            stage_code: :published,
+            name: "Addendum",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :add,
+            web: :addendum, title: "Addendum", short: "ADD" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Amendment < SupplementIdentifier
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwi_amd,
+            abbr: ["PWI Amd"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :proposal,
+            name: "Proposed Work Item for Amendment",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :np_amd,
+            abbr: ["NP Amd"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :proposal,
+            name: "New Work Item Proposal for Amendment",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :awi_amd,
+            abbr: ["AWI Amd"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :preliminary,
+            name: "Approved Work Item for Amendment",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wd_amd,
+            abbr: ["WD Amd"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :working_draft,
+            name: "Working Draft for Amendment",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :committee_draft_amd,
+            abbr: ["CD Amd"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :cd,
+            name: "Committee Draft for Amendment",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pdam,
+            abbr: ["PDAM"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :cd,
+            name: "Proposed Draft Amendment (Legacy)",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :damd,
+            abbr: ["DAM", "DAmd"],
+            short_abbr: "DAM",
+            # "DAmd" stays in `abbr` so it still parses, but render the canonical
+            # "DAM" (matches pubid v1's legacy_abbr semantics: parse the long
+            # spelling, emit the short one). No long_abbr → no long rendering.
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :damd,
+            name: "Draft Amendment",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fdamd,
+            abbr: ["FDAM", "FDAmd"],
+            short_abbr: "FDAM",
+            # See :damd — parse "FDAmd", render canonical "FDAM" (v1 parity).
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :fdamd,
+            name: "Final Draft Amendment",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fpdam,
+            abbr: ["FPDAM"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :fdamd,
+            name: "Final Proposed Draft Amendment (Legacy)",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :prf_amd,
+            abbr: ["PRF Amd"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :prf,
+            name: "Proof Amendment",
+            harmonized_stages: %w[50.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :published,
+            abbr: ["Amd", "AMD", "Amd."],
+            short_abbr: "AMD",
+            long_abbr: "Amd",
+            type_code: :amd,
+            stage_code: :published,
+            name: "Amendment",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :amd,
+            web: :amendment, title: "Amendment", short: "AMD" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Corrigendum < SupplementIdentifier
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwi_cor,
+            abbr: ["PWI Cor"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :cor,
+            stage_code: :proposal,
+            name: "Proposed Work Item for Corrigendum",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :npcor,
+            abbr: ["NP Cor"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :cor,
+            stage_code: :proposal,
+            name: "New Work Item Proposal for Corrigendum",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :awicor,
+            abbr: ["AWI Cor"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :cor,
+            stage_code: :preliminary,
+            name: "Approved Work Item for Corrigendum",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wdcor,
+            abbr: ["WD Cor"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :cor,
+            stage_code: :working_draft,
+            name: "Working Draft for Corrigendum",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :cdcor,
+            abbr: ["CD Cor", "pDCOR"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :cor,
+            stage_code: :cd,
+            name: "Committee Draft for Corrigendum",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :dcor,
+            abbr: ["DCor", "DCOR", "DIS Cor"],
+            short_abbr: "DCOR",
+            long_abbr: "DCor",
+            type_code: :cor,
+            stage_code: :dcor,
+            name: "Draft Corrigendum",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fdcor,
+            abbr: ["FDCor", "FDCOR", "FCOR", "FDIS Cor"],
+            short_abbr: "FDCOR",
+            long_abbr: "FDCor",
+            type_code: :cor,
+            stage_code: :fdcor,
+            name: "Final Draft Corrigendum",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :prfcor,
+            abbr: ["PRF Cor"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :cor,
+            stage_code: :prf,
+            name: "Proof Corrigendum",
+            harmonized_stages: %w[50.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pubcor,
+            abbr: ["Cor", "COR", "Cor."],
+            short_abbr: "COR",
+            long_abbr: "Cor",
+            type_code: :cor,
+            stage_code: :published,
+            name: "Corrigendum",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :cor,
+            web: :corrigendum, title: "Corrigendum", short: "COR" }
+        end
+      end
+    end
+  end
+end