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

data/lib/pubid/cen_cenelec.rb

@@ -2,207 +2,20 @@
 
 module Pubid
   module CenCenelec
-    extend Pubid::PrefixesSupport
-
-    # CEN/CENELEC publisher tokens, mirroring the parser's publisher rules
-    # (lib/pubid/cen_cenelec/parser.rb). Adopted-org prefixes (ISO/IEC/CISPR)
-    # are excluded — they route to their own SDOs, not to CEN.
-    PREFIXES = %w[EN CEN CLC CWA HD ES CR ENV].freeze
-
     autoload :Builder, "#{__dir__}/cen_cenelec/builder"
     autoload :Identifier, "#{__dir__}/cen_cenelec/identifier"
     autoload :Identifiers, "#{__dir__}/cen_cenelec/identifiers"
     autoload :Parser, "#{__dir__}/cen_cenelec/parser"
-    autoload :Renderer, "#{__dir__}/cen_cenelec/renderer"
+    autoload :Scheme, "#{__dir__}/cen_cenelec/scheme"
     autoload :SingleIdentifier, "#{__dir__}/cen_cenelec/single_identifier"
     autoload :SupplementIdentifier,
              "#{__dir__}/cen_cenelec/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/cen_cenelec/urn_generator"
-    autoload :UrnParser, "#{__dir__}/cen_cenelec/urn_parser"
-
-    # TYPED_STAGES_REGISTRY for native CEN types
-    # Covers the CEN PROJEX stage-code table per issue #251.
-    TYPED_STAGES_REGISTRY = [
-      # === European Norm (EN) lifecycle ===
-      # Preliminary (pWI EN): proposal/WI stages
-      Pubid::Components::TypedStage.new(
-        code: :pwien, stage_code: :preliminary, type_code: :en,
-        abbr: ["pWI EN"], name: "Preliminary Work Item EN",
-        harmonized_stages: %w[00.60 10.98 10.99 20.60],
-      ),
-      # Proposal (prEN): working draft stages
-      Pubid::Components::TypedStage.new(
-        code: :pren, stage_code: :proposal, type_code: :en,
-        abbr: ["prEN"], name: "Proposal European Norm",
-        harmonized_stages: %w[30.00 30.20 30.60 30.92 30.97 30.98 30.99],
-      ),
-      # Final Proposal (FprEN): enquiry stages
-      Pubid::Components::TypedStage.new(
-        code: :fpren, stage_code: :final_proposal, type_code: :en,
-        abbr: ["FprEN"], name: "Final Proposal European Norm",
-        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.97 40.98 40.99],
-      ),
-      # Formal Vote (FV prEN): COCOR + FV dispatch
-      Pubid::Components::TypedStage.new(
-        code: :fven, stage_code: :formal_vote, type_code: :en,
-        abbr: ["FV prEN"], name: "Formal Vote EN",
-        harmonized_stages: %w[43.20 43.60 43.97 43.98 45.97 45.98 45.99],
-      ),
-      # Vote (vEN): enquiry/vote
-      Pubid::Components::TypedStage.new(
-        code: :ven, stage_code: :vote, type_code: :en,
-        abbr: ["vEN"], name: "Vote EN",
-        harmonized_stages: %w[50.20 50.60 50.97 50.98],
-      ),
-      # Published (EN): ratification + publication milestones
-      Pubid::Components::TypedStage.new(
-        code: :puben, stage_code: :published, type_code: :en,
-        abbr: ["EN"], name: "European Norm",
-        harmonized_stages: %w[60.00 60.55 60.60 65.31 65.51 65.62],
-      ),
-      # Review (rvEN): 2-year review
-      Pubid::Components::TypedStage.new(
-        code: :rven, stage_code: :review, type_code: :en,
-        abbr: ["rvEN"], name: "Review EN",
-        harmonized_stages: %w[90.00 90.20 90.60 90.92 90.93 90.98],
-      ),
-      # Reactivation (racEN)
-      Pubid::Components::TypedStage.new(
-        code: :racen, stage_code: :reactivation, type_code: :en,
-        abbr: ["racEN"], name: "Re-activated EN",
-        harmonized_stages: %w[96.60],
-      ),
-      # Withdrawn (wdEN)
-      Pubid::Components::TypedStage.new(
-        code: :wden, stage_code: :withdrawn, type_code: :en,
-        abbr: ["wdEN"], name: "Withdrawn EN",
-        harmonized_stages: %w[99.60],
-      ),
-
-      # === Technical Specification (TS) ===
-      Pubid::Components::TypedStage.new(
-        code: :pubts, stage_code: :published, type_code: :ts,
-        abbr: ["TS"], name: "Technical Specification",
-        harmonized_stages: %w[60.00 60.60],
-      ),
-      Pubid::Components::TypedStage.new(
-        code: :prts, stage_code: :proposal, type_code: :ts,
-        abbr: ["prTS"], name: "Proposal Technical Specification",
-        harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
-      ),
-
-      # === Technical Report (TR) ===
-      Pubid::Components::TypedStage.new(
-        code: :pubtr, stage_code: :published, type_code: :tr,
-        abbr: ["TR"], name: "Technical Report",
-        harmonized_stages: %w[60.00 60.60],
-      ),
-
-      # === CEN Workshop Agreement (CWA) ===
-      Pubid::Components::TypedStage.new(
-        code: :pubcwa, stage_code: :published, type_code: :cwa,
-        abbr: ["CWA"], name: "CEN Workshop Agreement",
-        harmonized_stages: %w[60.00 60.60],
-      ),
-
-      # === Guide ===
-      Pubid::Components::TypedStage.new(
-        code: :pubguide, stage_code: :published, type_code: :guide,
-        abbr: ["Guide"], name: "Guide",
-        harmonized_stages: %w[60.00 60.60],
-      ),
-
-      # === Harmonization Document (HD) ===
-      Pubid::Components::TypedStage.new(
-        code: :pubhd, stage_code: :published, type_code: :hd,
-        abbr: ["HD"], name: "Harmonization Document",
-        harmonized_stages: %w[60.00 60.60],
-      ),
-
-      # === European Specification (ES) ===
-      Pubid::Components::TypedStage.new(
-        code: :pubes, stage_code: :published, type_code: :es,
-        abbr: ["ES"], name: "European Specification",
-        harmonized_stages: %w[60.00 60.60],
-      ),
-
-      # === CEN Report (CR) ===
-      Pubid::Components::TypedStage.new(
-        code: :pubcr, stage_code: :published, type_code: :cr,
-        abbr: ["CR"], name: "CEN Report",
-        harmonized_stages: %w[60.00 60.60],
-      ),
-
-      # === European Prestandard (ENV) ===
-      Pubid::Components::TypedStage.new(
-        code: :pubenv, stage_code: :published, type_code: :env,
-        abbr: ["ENV"], name: "European Prestandard",
-        harmonized_stages: %w[60.00 60.60],
-      ),
-    ].freeze
-
-    # Default typed stage for when no match is found
-    DEFAULT_TYPED_STAGE = Pubid::Components::TypedStage.new(
-      code: :puben,
-      stage_code: :published,
-      type_code: :en,
-      abbr: ["EN"],
-      name: "European Norm",
-      harmonized_stages: %w[60.00 60.60],
-    ).freeze
 
     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
-
       CenCenelec::Identifier.parse(identifier)
     end
-
-    # Auto-discover all identifier types from the Identifiers namespace
-    # @return [Array<Class>] identifier classes that define a self.type Hash
-    def self.identifier_types
-      @identifier_types ||= Identifiers.constants
-        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
-        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
-        .select { |c| c.type.is_a?(Hash) }
-    end
-
-    # Build typed stage index from the module's TYPED_STAGES_REGISTRY
-    # @return [Array<Pubid::Components::TypedStage>] all typed stages
-    def self.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[: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
 
 Pubid::Registry.register(:cen_cenelec, Pubid::CenCenelec)
-Pubid::Registry.register(:cen, Pubid::CenCenelec)
-
-# Per-flavor format registry: inherits global formats, overrides :human
-# Register on both root hierarchies: SingleIdentifier and Identifiers::Base
-cen_renderer = Pubid::CenCenelec::Renderer
-Pubid::CenCenelec::SingleIdentifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::CenCenelec::SingleIdentifier.format_registry.register(:human, renderer: cen_renderer)
-Pubid::CenCenelec::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::CenCenelec::Identifiers::Base.format_registry.register(:human, renderer: cen_renderer)

data/lib/pubid/cie/builder.rb

@@ -14,30 +14,12 @@ module Pubid
         # Determine identifier class based on parsed content
         identifier_class = determine_class(parsed_hash)
 
-        # Supplement / Corrigendum wrap a nested base.
-        if identifier_class == Cie::Identifiers::Corrigendum
-          return build_corrigendum(parsed_hash)
-        end
-        if identifier_class == Cie::Identifiers::Supplement
-          return build_supplement(parsed_hash)
-        end
-
         # Extract attributes with style detection
         attributes = extract_attributes(parsed_hash)
 
-        # For Bundle, parse each comma-separated member and hoist a shared base.
+        # For Bundle identifier, store original string
         if parsed_hash[:bundle_items] && original_string
-          attributes.merge!(build_bundle(original_string))
-        end
-
-        # `extract_attributes` builds one attribute hash for every CIE type,
-        # but the types do not share one attribute set — only Standard,
-        # DualPublished and Identical declare `s_prefix`, while Conference,
-        # Bundle, Proceedings and TutorialBundle do not. lutaml used to drop
-        # the surplus key without a word; the constructor now refuses it, so
-        # the builder has to stop offering it.
-        attributes = attributes.select do |key, _|
-          identifier_class.attributes.key?(key)
+          attributes[:identifiers_string] = original_string
         end
 
         # Construct identifier
@@ -46,85 +28,6 @@ module Pubid
 
       private
 
-      # Build a Bundle's attributes from its printed form. Parse each member,
-      # then — since a CIE bundle is the parts of one supplement of one standard
-      # — hoist the shared base and keep only the differing supplement
-      # number/part in each doc. If the members don't share a base (not seen in
-      # practice, but the grammar allows it), keep each doc's own base instead.
-      def build_bundle(original_string)
-        members = split_bundle_members(original_string)
-        shared = common_base(members)
-        return { ids: members } unless shared
-
-        ids = members.map do |m|
-          Cie::Identifiers::Supplement.new(number: m.number, part: m.part)
-        end
-        { base: shared, ids: ids }
-      end
-
-      # The publisher prefix is written once, so only the first item carries
-      # "CIE "; prepend it to the rest before parsing each member.
-      def split_bundle_members(original_string)
-        original_string.split(",").each_with_index.map do |item, i|
-          ref = i.zero? ? item.strip : "CIE #{item.strip}"
-          Cie::Identifier.parse(ref)
-        end
-      end
-
-      # The base shared by every member, or nil if they differ (or any is
-      # base-less). Compared by canonical hash so structural equality holds.
-      def common_base(members)
-        bases = members.map(&:base)
-        return nil if bases.any?(&:nil?)
-
-        first = bases.first.to_hash
-        bases.all? { |b| b.to_hash == first } ? bases.first : nil
-      end
-
-      # Supplement: nest the base Standard (the stage/year/language belong to
-      # the base), keep only the -SPN number/part on the wrapper.
-      def build_supplement(parsed_hash)
-        a = extract_attributes(parsed_hash)
-        base = Cie::Identifiers::Standard.new(
-          number: a[:base_number],
-          stage: a[:stage],
-          s_prefix: a.fetch(:s_prefix, false),
-          language: a[:language],
-          year: a[:year],
-          style: "current", # supplements always use the colon style
-        )
-        Cie::Identifiers::Supplement.new(
-          base: base,
-          number: a[:supplement_number],
-          part: a[:supplement_part],
-        )
-      end
-
-      # Corrigendum: nest the base (a Standard, or a Supplement when the base
-      # itself carries -SPN), keep only the /CorN number/year on the wrapper.
-      def build_corrigendum(parsed_hash)
-        a = extract_attributes(parsed_hash)
-        base_std = Cie::Identifiers::Standard.new(
-          number: a[:base_number],
-          year: a[:base_year],
-          style: "current",
-        )
-        base = if a[:base_supplement]
-                 Cie::Identifiers::Supplement.new(
-                   base: base_std,
-                   number: a[:base_supplement],
-                   part: a[:base_supplement_part],
-                 )
-               else
-                 base_std
-               end
-        Cie::Identifiers::Corrigendum.new(
-          base: base,
-          number: a[:cor_number],
-          year: a[:cor_year],
-        )
-      end
-
       # Determine which identifier class to use
       def determine_class(parsed_hash)
         # Tutorial Bundle (special text format)
@@ -147,11 +50,6 @@ module Pubid
           return Cie::Identifiers::Supplement
         end
 
-        # Proceedings paper (x-prefixed or standalone)
-        if parsed_hash[:paper_code]
-          return Cie::Identifiers::Proceedings
-        end
-
         # Conference (x-prefix)
         if parsed_hash[:conference]
           return Cie::Identifiers::Conference
@@ -281,69 +179,47 @@ module Pubid
           date_sep = "slash" # Special format for identical identifiers
         end
 
-        # Style is the sole separator field (no date_separator):
-        #   colon -> current (":")   dash -> legacy ("-")   slash -> slash ("/")
-        style = case date_sep
-                when "colon" then "current"
-                when "dash" then "legacy"
-                when "slash" then "slash"
-                else detect_style_fallback(parsed_hash)
+        # Detect style from date separator
+        style = if date_sep == "colon"
+                  "current"
+                else
+                  (date_sep == "dash" ? "legacy" : detect_style_fallback(parsed_hash))
                 end
         attributes[:style] = style
 
-        # Set year if present
+        # Set year and separator if present
         attributes[:year] = year_value if year_value
+        attributes[:date_separator] = date_sep if date_sep
 
-        # Extract code (flat number/part/iteration/part_separator on the
-        # identifier; the code's style is the identifier's own `style`).
+        # Extract code
         if parsed_hash[:number]
-          attributes[:number] = extract_value(parsed_hash[:number])
+          code_attrs = { number: extract_value(parsed_hash[:number]),
+                         style: style }
           if parsed_hash[:part]
-            attributes[:part] = extract_value(parsed_hash[:part])
+            code_attrs[:part] =
+              extract_value(parsed_hash[:part])
           end
           if parsed_hash[:iteration]
-            attributes[:iteration] = extract_value(parsed_hash[:iteration])
+            code_attrs[:iteration] =
+              extract_value(parsed_hash[:iteration])
           end
 
           # Detect part separator from parser markers
           if parsed_hash[:slash_sep]
-            attributes[:part_separator] = "slash"
+            code_attrs[:part_separator] = "slash"
           elsif parsed_hash[:dash_sep]
-            attributes[:part_separator] = "dash"
+            code_attrs[:part_separator] = "dash"
           end
+
+          attributes[:code] = Components::Code.new(**code_attrs)
         end
 
         # Conference number (separate from regular code)
         if parsed_hash[:conf_number]
-          attributes[:number] =
+          attributes[:conference_number] =
             extract_value(parsed_hash[:conf_number])
         end
 
-        # Proceedings paper: the paper itself is the document, so its identity
-        # (code + running number, e.g. "OP01") is the flat +number+ for both
-        # surface forms. The x-form's parent conference goes to
-        # +conference+; the standalone form keeps its +page+ range.
-        if parsed_hash[:paper_code]
-          attributes[:number] =
-            "#{extract_value(parsed_hash[:paper_code])}" \
-            "#{extract_value(parsed_hash[:paper_number])}"
-          if parsed_hash[:conf_number]
-            attributes[:conference] =
-              extract_value(parsed_hash[:conf_number])
-          end
-        end
-        if parsed_hash[:page_range]
-          attributes[:page] = extract_value(parsed_hash[:page_range])
-        end
-
-        # Conference /slug variant (opaque, verbatim)
-        if parsed_hash[:variant]
-          attributes[:variant] = extract_value(parsed_hash[:variant])
-        end
-
-        # D-series marker
-        attributes[:d_prefix] = true if parsed_hash[:d_prefix]
-
         # Extract language (direct lang_code for slash_colon format)
         lang_code = nil
         lang_format = nil
@@ -449,11 +325,10 @@ module Pubid
             extract_value(parsed_hash[:amd_number])
         end
 
-        # Tutorial bundle: the ordinal is the bundle's own `number` (also its
-        # relaton-index key). A comma-list bundle instead keys via its `ids`
-        # members through #root, so it needs no stored number.
+        # Extract bundle data
         if parsed_hash[:bundle_number]
-          attributes[:number] = extract_value(parsed_hash[:bundle_number])
+          attributes[:bundle_number] =
+            extract_value(parsed_hash[:bundle_number])
         end
 
         # Extract trailing language from legacy_code_with_year

data/lib/pubid/cie/components/code.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Components
+      # Code component for CIE identifiers
+      # Handles number-part-iteration with style awareness
+      class Code < Lutaml::Model::Serializable
+        attribute :number, :string        # "013", "170", "198"
+        attribute :part, :string          # "1", "2", "3"
+        attribute :iteration, :string     # "1" in "006.1"
+        attribute :style, :string         # "legacy" or "current"
+        attribute :part_separator, :string # "slash" or "dash" (preserves original)
+
+        def to_s
+          result = number
+
+          # Handle part AND iteration together (e.g., "19/2.1")
+          if part && iteration
+            # Use slash for part, then dot for iteration
+            result += "/#{part}.#{iteration}"
+          # Handle iteration only (e.g., "006.1", "13.3")
+          elsif iteration
+            result += ".#{iteration}"
+          # Handle part only (separator depends on part_separator or style)
+          elsif part
+            # Use part_separator if explicitly set (preserves original)
+            # Otherwise fall back to style-based separator
+            separator = case part_separator
+                        when "slash"
+                          "/"
+                        when "dash"
+                          "-"
+                        else
+                          # Legacy: slash "/" (e.g., "170/1")
+                          # Current: dash "-" (e.g., "170-1")
+                          style == "legacy" ? "/" : "-"
+                        end
+            result += "#{separator}#{part}"
+          end
+
+          result
+        end
+
+        # Parse code string with style detection
+        def self.parse(code_str, style: :current)
+          return nil if code_str.nil? || code_str.strip.empty?
+
+          # Detect iteration format (dot separator)
+          if code_str.include?(".")
+            parts = code_str.split(".")
+            new(number: parts[0], iteration: parts[1], style: style)
+          # Detect part with separator
+          elsif code_str.include?("/")
+            parts = code_str.split("/")
+            new(number: parts[0], part: parts[1], style: "legacy",
+                part_separator: "slash")
+          elsif code_str.include?("-")
+            parts = code_str.split("-", 2) # Limit to 2 parts
+            new(number: parts[0], part: parts[1], style: "current",
+                part_separator: "dash")
+          # Simple number
+          else
+            new(number: code_str, style: style)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cie/identifier.rb

@@ -2,28 +2,13 @@
 
 module Pubid
   module Cie
-    # Base Identifier class for CIE.
-    #
-    # Inherits the shared Pubid::Identifier contract (format_registry, render,
-    # to_urn, exclude, hash, eql?) while allowing CIE-specific attributes.
-    #
-    # +style+ is the sole number<->year separator field (there is no separate
-    # date_separator): "current" -> ":", "legacy" -> "-", "slash" -> "/".
-    # It defaults to "current" (the dominant value), so canonicalize_hash drops
-    # it from the majority of rows and from_hash restores it.
-    class Identifier < ::Pubid::Identifier
-      attribute :style, :string, default: -> { "current" }
+    # Base Identifier class for CIE
+    # Provides parse() entry point
+    class Identifier < Lutaml::Model::Serializable
+      attribute :style, :string # "legacy" or "current"
 
+      # Parse CIE identifier string
       def self.parse(input)
-        unless input.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if input.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
         parsed = Parser.parse(input)
         builder = Builder.new
         builder.build(parsed, original_string: input)

data/lib/pubid/cie/identifiers/bundle.rb

@@ -5,44 +5,14 @@ require "lutaml/model"
 module Pubid
   module Cie
     module Identifiers
-      # Bundle identifier for CIE: a comma-separated list of sibling documents,
-      # each a full CIE identifier (typically a Supplement).
+      # Bundle identifier for CIE
+      # Handles comma-separated supplement lists
       # Example: CIE 198-SP1.1:2011,198-SP1.2:2011,198-SP1.3:2011,198-SP1.4:2011
-      #
-      # A CIE bundle is the parts of one supplement of one standard, so its
-      # members share a base document. That shared +base+ is hoisted to the
-      # bundle and the +ids+ carry only what differs (supplement number/part);
-      # #root walks +base+ to the origin standard for the relaton-index key.
-      # (Defensive: if members ever don't share a base, each id keeps its own
-      # and +base+ is nil — see Builder#build_bundle.)
       class Bundle < SingleIdentifier
-        attribute :base, Identifier, polymorphic: true
-        attribute :ids, Identifier, polymorphic: true, collection: true
+        attribute :identifiers_string, :string # Store as string for now
 
-        # The origin document: the shared base's root, else the first member's.
-        def root
-          (base || ids&.first)&.root || self
-        end
-
-        # The printed form writes the publisher once: the first member keeps its
-        # "CIE " prefix, the rest are bare. A base-less member is re-based onto
-        # the bundle's shared base for rendering.
-        def to_s(**opts)
-          return "" unless ids&.any?
-
-          result = ids.each_with_index.map do |id, i|
-            member = id.base ? id : rebased(id)
-            i.zero? ? member.to_s : member.to_s.delete_prefix("CIE ")
-          end.join(",")
-
-          annotate_plain_render(result, **opts)
-        end
-
-        private
-
-        # Attach the bundle's shared base to a base-less member for rendering.
-        def rebased(id)
-          Supplement.new(base: base, number: id.number, part: id.part)
+        def to_s
+          identifiers_string || ""
         end
       end
     end

data/lib/pubid/cie/identifiers/conference.rb

@@ -9,27 +9,22 @@ module Pubid
       # Handles x-prefix conference proceedings
       # Example: CIE x038:2013, CIE x038:2013 Amendment 1
       class Conference < SingleIdentifier
-        # :string overrides the base ::Pubid::Identifier Components::Code type.
-        attribute :number, :string
+        attribute :conference_number, :string
         attribute :amendment_number, :string
-        # Techstreet opaque /slug variant (no default -> round-trips cleanly)
-        attribute :variant, :string
 
-        def to_s(**opts)
-          result = "CIE x#{number}"
+        def to_s
+          result = "CIE x#{conference_number}"
 
           # Date with separator
           if year
-            result += "#{date_sep_char}#{year}"
+            separator = date_separator == "colon" ? ":" : "-"
+            result += "#{separator}#{year}"
           end
 
           # Amendment if present
           result += " Amendment #{amendment_number}" if amendment_number
 
-          # Opaque /slug variant if present
-          result += "/#{variant}" if variant
-
-          annotate_plain_render(result, **opts)
+          result
         end
       end
     end