pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.2

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

@@ -50,10 +50,13 @@ module Pubid
         attribute :update_year, :string
         attribute :addendum, :string
         attribute :addendum_number, :string
-        attribute :supplement, :string
-        attribute :supplement_date_range_start, :string # For date ranges like Jan1924-Jan1926
-        attribute :supplement_date_range_end, :string
-        attribute :supplement_has_revision, :boolean, default: -> { false }
+        # Single source of truth for the supplement: a structured component with
+        # isolated parts (number / year / month / date-range / revision), so a
+        # supplement's year is queryable independently of its number. Presence
+        # (non-nil) means "is a supplement"; an all-empty component is a bare
+        # "sup" marker. Replaces the former flat :supplement string plus the
+        # separate date-range/has_revision fields.
+        attribute :supplement, Components::Supplement
         attribute :errata, :string
         attribute :index, :string
         attribute :insert, :string
@@ -84,6 +87,90 @@ module Pubid
           # See lib/pubid/nist/builder.rb lines 368-472 for compound number logic
         end
 
+        # Attributes that are build artifacts or rendering aliases, not part
+        # of an identifier's logical identity. They diverge between equally-
+        # valid spellings of the same id (e.g. long "Rev. 1" vs short "r1"):
+        #   - edition_component: redundant alias of :edition
+        #   - first_number/second_number: decomposed parts of the canonical
+        #     :number, retained from the parse for building
+        #   - parsed_format: records the input format for round-trip rendering
+        EQUALITY_IGNORED_ATTRS = %i[
+          edition_component first_number second_number parsed_format
+        ].freeze
+
+        # Logical identity comparison: equal when every attribute except the
+        # build artifacts/aliases above matches. (Edition#== already ignores
+        # its rendering-only original_prefix.)
+        def ==(other)
+          return false unless other.instance_of?(self.class)
+
+          self.class.attributes.each_key.all? do |name|
+            EQUALITY_IGNORED_ATTRS.include?(name) || send(name) == other.send(name)
+          end
+        end
+
+        alias eql? ==
+
+        def hash
+          vals = self.class.attributes.each_key.reject do |name|
+            EQUALITY_IGNORED_ATTRS.include?(name)
+          end.map { |name| send(name) }
+          [self.class, *vals].hash
+        end
+
+        # Wildcard / partial-identifier match. Treats +self+ as a QUERY pattern
+        # and +candidate+ as a concrete document: every ID part SET on the query
+        # must equal the candidate's, while parts left unset (nil/empty) are
+        # wildcards that match any value. So a query carrying no edition and no
+        # supplement matches that document across ALL editions, years, and
+        # supplements — the basis for "select docs by ID parts".
+        #
+        # Asymmetric (unlike ==): "NBS CIRC 25".matches?("NBS CIRC 25sup1924")
+        # is true, but not the reverse. The candidate must be the same class or
+        # a subclass so series-level identity still holds.
+        def matches?(candidate)
+          return false unless candidate.is_a?(self.class)
+
+          self.class.attributes.each_key.all? do |name|
+            next true if EQUALITY_IGNORED_ATTRS.include?(name)
+
+            query_val = public_send(name)
+            next true if query_val.nil? ||
+              (query_val.respond_to?(:empty?) && query_val.empty?)
+
+            query_val == candidate.public_send(name)
+          end
+        end
+
+        # Return a copy with the named attributes nil'd. Overrides
+        # Pubid::Identifier#exclude because NIST's initialize is keyword-only
+        # (initialize(**attributes)) while the inherited exclude rebuilds via
+        # the positional self.class.new(attrs) form — passing a positional
+        # hash to a keyword-only initializer raises ArgumentError. Rebuild
+        # with the keyword splat instead.
+        def exclude(*args)
+          excluded_args = args.dup
+          excluded_args << :date if excluded_args.delete(:year)
+
+          attrs = self.class.attributes.each_with_object({}) do |(name, _), h|
+            h[name] = excluded_args.include?(name) ? nil : send(name)
+          end
+          self.class.new(**attrs)
+        end
+
+        # Short-form supplement fragment ("sup", "sup1924", "supJan1924",
+        # "suprev", " supJun1925-Jun1926"), rendered from the structured
+        # component. A present-but-empty component is the bare "sup" marker; a
+        # number-less date range gets the leading space the number would have
+        # supplied. Shared by base and the per-series to_short_style overrides.
+        def supplement_short
+          return "" unless supplement
+
+          prefix = (supplement.range? && !number) ? " " : ""
+          rendered = supplement.to_s(:short)
+          prefix + (rendered.empty? ? "sup" : rendered)
+        end
+
         # Compute revision from edition component for backward compatibility
         # @return [String, nil] revision string (e.g., "r5") or nil
         def revision
@@ -333,30 +420,22 @@ module Pubid
             end
           end
 
-          # V2: Use version_component if available, else use version string
+          # V2: Use version_component if available, else use version string.
+          # Attach directly (no leading space) to match edition rendering
+          # (e.g. "800-53r5"), so version reads "800-45ver2" not
+          # "800-45 ver2".
           if version_component
-            result += " #{version_component.to_s(:short)}"
+            result += version_component.to_s(:short)
           elsif version
-            result += " Ver. #{version}"
+            result += "ver#{version}"
           end
 
-          # Add supplement with date range support - FIX: proper spacing
-          if supplement_date_range_start && supplement_date_range_end
-            result += "supp#{supplement_date_range_start}-#{supplement_date_range_end}"
-          elsif supplement_has_revision
-            result += "supprev"
-          elsif supplement && !supplement.empty?
-            # Smart dash logic:
-            # - If supplement starts with letter (month like "Jan1924"), NO dash
-            # - If supplement is digits only (year like "1924"), WITH dash
-            result += if supplement.match?(/^[A-Z]/)
-                        "supp#{supplement}"
-                      else
-                        "supp-#{supplement}"
-                      end
-          elsif supplement
-            result += "supp"
-          end
+          # Add supplement. NIST/NBS canonical short form is single-p "sup"
+          # with the suffix attached directly, no dash (relaton-data-nist
+          # uses "sup2", "sup1940", "supA"); date-range keeps its inner dash.
+          # Rendered from the structured component; a present-but-empty
+          # component is the bare "sup" marker.
+          result += supplement_short
 
           # Add other attributes
           result += errata.to_s if errata

data/lib/pubid/nist/identifiers/circular_supplement.rb

@@ -38,7 +38,7 @@ module Pubid
         def to_s(format = :short)
           # Handle date range supplements (no base identifier)
           if supplement_date_range_start && supplement_date_range_end
-            return "NBS CIRC supp#{supplement_date_range_start}-#{supplement_date_range_end}"
+            return "NBS CIRC sup#{supplement_date_range_start}-#{supplement_date_range_end}"
           end
 
           # Use parent's rendering for base + supplement

data/lib/pubid/nist/identifiers/crpl_report.rb

@@ -121,10 +121,7 @@ module Pubid
           result += part.to_s if part
 
           # Add supplement with "sup" prefix for CRPL identifiers
-          if supplement
-            # Check if supplement already has "sup" prefix (for backward compatibility)
-            result += (supplement.start_with?("sup") ? supplement : "sup#{supplement}")
-          end
+          result += supplement_short
 
           result += range_notation if range_notation
           result

data/lib/pubid/nist/identifiers/federal_information_processing_standards.rb

@@ -86,6 +86,16 @@ module Pubid
           if edition
             result += "#{edition.type}#{edition.id}"
           end
+
+          # Mirror Base#to_short_style update rendering — FIPS overrides
+          # to_short_style entirely, so update (e.g. /Upd2) would otherwise
+          # be dropped.
+          if update_component
+            result += update_component.to_s(:short)
+          elsif update
+            result += "-upd#{update}"
+          end
+
           result
         end
       end

data/lib/pubid/nist/identifiers/report.rb

@@ -52,8 +52,7 @@ module Pubid
         def to_short_style
           result = "#{default_publisher} #{series_code}"
           result += " #{number}" if number
-          result += "sup#{supplement}" if supplement && !supplement.empty?
-          result += "sup" if supplement == ""
+          result += supplement_short
           result
         end
 

data/lib/pubid/nist/parser.rb

@@ -204,9 +204,12 @@ module Pubid
         # FIXED: Pattern must start with "v" or digit to avoid matching "rev 2013" as "v" + " 2013"
         # CRITICAL: Added word boundary \b to prevent matching "v" within "rev"
         # CRITICAL FIX: Use \b to ensure match starts at word boundary
-        cleaned = cleaned.gsub(/(\b(?:v|\d)[v\d]*[-A-Z]*)\s+(\d+)\s+(\d+)/, '\1.\2.\3') # Three parts
-        # CRITICAL FIX: Use \b to ensure match starts at word boundary
-        cleaned = cleaned.gsub(/(\b(?:v|\d)[v\d]*)\s+(\d+)/, '\1.\2') # Two parts
+        cleaned = cleaned.gsub(/(\b(?:v|\d)[v\d]*[-A-Z]*)\s+(\d+)(?!(?i:pd|wd|prd)\b)\s+(\d+)(?!(?i:pd|wd|prd)\b)/, '\1.\2.\3') # Three parts
+        # CRITICAL FIX: Use \b to ensure match starts at word boundary.
+        # Negative lookahead: don't swallow the digit of a numeric draft
+        # stage ("189 2pd" must stay split, not become "189.2pd"); letter
+        # stages ("ipd") already don't match the trailing \d+.
+        cleaned = cleaned.gsub(/(\b(?:v|\d)[v\d]*)\s+(\d+)(?!(?i:pd|wd|prd)\b)/, '\1.\2') # Two parts
 
         # Fix update patterns: ensure space before -upd or /upd (not just at end)
         # Enhanced to handle optional digits after upd: -upd, -upd1, /upd, /upd1
@@ -240,6 +243,16 @@ module Pubid
         # Normalize "sup" to "supp" for LCIRC patterns to match circ_supplement_identifier rule
         cleaned = cleaned.gsub(/(\d+)sup(\d+\/\d{4})/, '\1supp\2') # 118sup12/1926 → 118supp12/1926
 
+        # Unify dashed/undashed year supplements: "supp-YYYY" → "suppYYYY".
+        # A bare dash before a 4-digit year is not semantic — "25supp-1924" and
+        # "25supp1924" denote the same publication (the genuine edition marker is
+        # explicit "e", e.g. "25suppe1924"). Collapsing the dash here gives both
+        # spellings ONE parse tree (the normal first_number path), so they build
+        # to an identical Circular with supplement=<year>, with equal ==/URN.
+        # Guard: 4 digits NOT followed by another digit or a slash, so the
+        # dash-slash form "supp-12/1926" (supplement_dash_slash_year) is untouched.
+        cleaned = cleaned.gsub(/(\d)(supp?)-(\d{4})(?![\d\/])/, '\1\2\3') # 25supp-1924 → 25supp1924
+
         # REMOVED: Revision letter patterns that add space before revision with letter
         # These conflicted with the fix at lines 131-142 which keeps "22r1a" together
         # for second_number pattern matching. The comprehensive fix now handles:
@@ -361,6 +374,21 @@ module Pubid
         # Fix verbose "Revision" format: " Revision (r)" → " r"
         cleaned = cleaned.gsub(/\s+Revision\s+\(r\)/, " r")
 
+        # Fix verbose "Part N" → short "ptN": "800-57 Part 2 Rev. 1" →
+        # "800-57pt2 Rev. 1". The grammar already accepts short "ptN" (and
+        # "ptN Rev. M"); only the verbose spelling was unsupported. Attaches
+        # to the preceding number so the existing part rule applies.
+        cleaned = cleaned.gsub(/\s+Part\s+(\d+)/, 'pt\1')
+
+        # Normalize verbose addendum " Add"/" add" (with or without period)
+        # to the canonical " Add." the grammar accepts, and uppercase a
+        # doc-number letter that immediately precedes it ("800-38a Add" →
+        # "800-38A Add.") — NIST doc-number letters are canonically uppercase
+        # and the letter_number grammar rule only splits the uppercase form.
+        # Scoped to the addendum context so bare markers like "800-90r"
+        # (revision) are left untouched.
+        cleaned = cleaned.gsub(/(\d[a-z]?)\s+Add\b\.?/i) { "#{Regexp.last_match(1).upcase} Add." }
+
         # Fix verbose "rev YYYY" format: "126 rev 2013" → "126r2013"
         # Removes space between number and "rev", and converts to "r" prefix
         # Handles patterns like "NIST SP 260-126 rev 2013" → "NIST SP 260-126r2013"
@@ -634,6 +662,11 @@ module Pubid
           # NEW: Exclude "draft" keyword
           str("draft").absent? >>
           (
+            # Trailing bare supplement marker on a compound second number
+            # (e.g. "800-53sup") so it isn't split into "53s" + "up". Builder
+            # strips the marker and sets supplement="" (canonical "sup").
+            (digits >> (str("supp") | str("sup")) >>
+              (digit.absent? >> letter.absent?)) |
             # NEW: Revision pattern with U+letter suffix (e.g., "22r1Ua", "38Ua")
             # MUST come BEFORE general letter suffix to avoid matching just "U" from "Ua"
             (digits >> str("r") >> digits >> str("U") >> lower_letter) |

data/lib/pubid/nist/supplement_identifier.rb

@@ -28,7 +28,7 @@ module Pubid
       def to_s(format = :short)
         # Handle date range supplements (no base identifier)
         if supplement_date_range_start && supplement_date_range_end
-          return "NBS CIRC supp#{supplement_date_range_start}-#{supplement_date_range_end}"
+          return "NBS CIRC sup#{supplement_date_range_start}-#{supplement_date_range_end}"
         end
 
         return super unless base_identifier
@@ -37,34 +37,18 @@ module Pubid
 
         # NEW: Handle update attribute (e.g., "Upd12-1926" for supplement patterns)
         if update
-          # Check if this is an implicit supplement (no explicit "sup/supp" marker, just update)
-          # For implicit supplements like "145r11/1925", don't add "sup" before the update
+          # Implicit supplements (e.g. "145r11/1925") have no explicit marker;
+          # everything else uses the canonical single-p "sup" marker
+          # (relaton-data-nist uses "sup" across all series).
           is_implicit = self.class.attributes.key?(:implicit_supplement) && implicit_supplement == true
-
-          if is_implicit
-            # Implicit supplement: "{base}/{update}" (e.g., "145/Upd1-192511")
-          else
-            # Explicit supplement: "{base}sup/{update}" (e.g., "118sup/Upd12-1926")
-            is_circ_supplement = ["LCIRC", "CIRC"].include?(series.to_s)
-            result += is_circ_supplement ? "sup" : "supp"
-          end
+          result += "sup" unless is_implicit
           result += "/#{update}"
           return result
         end
 
-        # Original supplement rendering
-        # For LCIRC/CIRC supplements with update, use "sup"
-        # For LCIRC/CIRC supplements without update, normalize "sup" to "supp" for consistency
-        is_circ_supplement = ["LCIRC", "CIRC"].include?(series.to_s)
-        # When update is present, use "sup" (e.g., "118sup/Upd1-192612")
-        # When update is not present, use "supp" (e.g., "378Gsupp" - normalized from "sup")
-        result += if is_circ_supplement && !update
-                    "supp"
-                  elsif is_circ_supplement
-                    "sup"
-                  else
-                    "supp"
-                  end
+        # Canonical supplement marker is single-p "sup" across all NIST/NBS
+        # series (relaton-data-nist: SP/CIRC/HB/RPT/LC/IR/MONO/BMS all use "sup").
+        result += "sup"
 
         # Add edition information if present (just ID, not type prefix)
         if edition&.id

data/lib/pubid/nist/urn_generator.rb

@@ -61,18 +61,24 @@ module Pubid
           identifier_parts << identifier.stage.to_s
         end
 
+        # Supplement is now a structured component. Preserve the existing URN
+        # branching exactly: range → "supp{start}-{end}", revision → "supprev",
+        # a valued supplement → "suppX"/"supp-X" (dash unless it starts with an
+        # uppercase letter), and — quirk retained — a nil (absent) supplement
+        # still emits "supp", while a present-but-empty one emits nothing.
         supp = identifier.supplement
-        if identifier.supplement_date_range_start && identifier.supplement_date_range_end
-          identifier_parts << "supp#{identifier.supplement_date_range_start}-#{identifier.supplement_date_range_end}"
-        elsif identifier.supplement_has_revision
+        if supp&.range?
+          identifier_parts << "supp#{supp.month}#{supp.year}-#{supp.month_end}#{supp.year_end}"
+        elsif supp&.has_revision
           identifier_parts << "supprev"
-        elsif supp && !supp.empty?
-          identifier_parts << if supp.match?(/^[A-Z]/)
-                                "supp#{supp}"
+        elsif supp && !supp.value_string.empty?
+          value = supp.value_string
+          identifier_parts << if value.match?(/^[A-Z]/)
+                                "supp#{value}"
                               else
-                                "supp-#{supp}"
+                                "supp-#{value}"
                               end
-        elsif !supp
+        elsif supp.nil?
           identifier_parts << "supp"
         end
 

data/lib/pubid/nist.rb

@@ -5,6 +5,7 @@ module Pubid
     autoload :Builder, "#{__dir__}/nist/builder"
     autoload :Components, "#{__dir__}/nist/components"
     autoload :Configuration, "#{__dir__}/nist/configuration"
+    autoload :Identifier, "#{__dir__}/nist/identifier"
     autoload :Identifiers, "#{__dir__}/nist/identifiers"
     autoload :Parser, "#{__dir__}/nist/parser"
     autoload :Scheme, "#{__dir__}/nist/scheme"

data/lib/pubid/oiml/identifier.rb

@@ -6,6 +6,56 @@ module Pubid
       def to_urn
         UrnGenerator.new(self).generate
       end
+
+      # Factory mirroring pubid 1.x's `Pubid::Oiml::Identifier.create` API.
+      # Default subclass is {Identifiers::Recommendation}.
+      TYPE_KEY_TO_KLASS = {
+        recommendation:    "Recommendation",
+        document:          "Document",
+        guide:             "Guide",
+        vocabulary:        "Vocabulary",
+        basic_publication: "BasicPublication",
+        expert_report:     "ExpertReport",
+        seminar_report:    "SeminarReport",
+        annex:             "Annex",
+      }.freeze
+
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts))
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::Recommendation if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown OIML type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = { publisher: (opts[:publisher] || "OIML").to_s }
+
+        if opts[:code].is_a?(Pubid::Oiml::Components::Code)
+          attrs[:code] = opts[:code]
+        elsif opts[:code] || opts[:number]
+          attrs[:code] = Pubid::Oiml::Components::Code.new(
+            number:  (opts[:number] || opts[:code])&.to_s,
+            part:    opts[:part]&.to_s,
+            subpart: opts[:subpart]&.to_s,
+          )
+        end
+
+        if (v = opts[:year])
+          attrs[:date] = Pubid::Components::Date.new(year: v.to_s)
+        end
+        %i[stage iteration language edition].each do |k|
+          attrs[k] = opts[k].to_s unless opts[k].nil?
+        end
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
     end
   end
 end

data/lib/pubid/plateau/identifier.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    # Plateau factory entry point. `.parse` lives on `Pubid::Plateau`
+    # itself for historical reasons; this module hosts `.create` for API
+    # consistency with the other pubid flavors.
+    module Identifier
+      # Delegate to the flavor module so callers can use
+      # `Pubid::Plateau::Identifier.parse` consistently with other flavors.
+      def self.parse(identifier)
+        Pubid::Plateau.parse(identifier)
+      end
+
+      # Factory that builds a PLATEAU identifier from a hash of primitives.
+      #
+      # Dispatch on `:type`:
+      #   * `:handbook` (default)            → Identifiers::Handbook
+      #   * `:technical_report` / `:tr`      → Identifiers::TechnicalReport
+      #   * `:annex`                         → Identifiers::Annex
+      #
+      # Attributes are plain integers/strings — no Component wrapping.
+      # `:publisher` is silently ignored (PLATEAU is hardcoded).
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts, klass: klass))
+      end
+
+      def self.resolve_create_class(type)
+        case type&.to_sym
+        when nil, :handbook
+          Identifiers::Handbook
+        when :technical_report, :tr
+          Identifiers::TechnicalReport
+        when :annex
+          Identifiers::Annex
+        else
+          raise ArgumentError, "Unknown PLATEAU type: #{type.inspect}"
+        end
+      end
+
+      def self.coerce_create_attrs(opts, klass:)
+        attrs = {}
+        attrs[:number] = opts[:number].to_i if opts[:number]
+        attrs[:annex]  = opts[:annex].to_i  if opts[:annex]
+        # :edition exists only on Handbook (and possibly TechnicalReport);
+        # silently drop on Annex.
+        if opts[:edition] && klass.attributes.key?(:edition)
+          attrs[:edition] = opts[:edition].to_s
+        end
+        # TODO(create-shim): :publisher silently ignored (PLATEAU hardcoded).
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
+    end
+  end
+end

data/lib/pubid/plateau.rb

@@ -5,6 +5,7 @@ require "parslet"
 module Pubid
   module Plateau
     autoload :Builder, "#{__dir__}/plateau/builder"
+    autoload :Identifier, "#{__dir__}/plateau/identifier"
     autoload :Identifiers, "#{__dir__}/plateau/identifiers"
     autoload :Parser, "#{__dir__}/plateau/parser"
     autoload :Scheme, "#{__dir__}/plateau/scheme"

data/lib/pubid/renderers/base.rb

@@ -14,6 +14,40 @@ module Pubid
       def self.render(identifier)
         new(identifier).render
       end
+
+      # Partitions a value into (leading separators, core, trailing separators)
+      # so "- : / space , ." stay OUTSIDE the annotation span (v1 parity).
+      SEMANTIC_SPLIT = %r{\A([-:/ ,.]*)(.*?)([-:/ ,.]*)\z}m
+
+      # type_code (a string) → semantic CSS class for the typed-stage token.
+      # Anything not listed (and not the default "is") renders as "doctype".
+      TYPED_STAGE_CSS = {
+        "amd" => "amendment",
+        "cor" => "corrigendum",
+        "add" => "addendum",
+      }.freeze
+
+      private
+
+      # Wrap a rendered value in a <span class="css_class"> when annotation is
+      # enabled, keeping leading/trailing separator chars outside the span.
+      def annotate(value, css_class, annotated:)
+        str = value.to_s
+        return value unless annotated && css_class && !str.empty?
+
+        lead, core, trail = str.match(SEMANTIC_SPLIT).captures
+        return value if core.empty?
+
+        %(#{lead}<span class="#{css_class}">#{core}</span>#{trail})
+      end
+
+      # Choose between "stage" and a type/supplement class for a typed stage.
+      def typed_stage_css(typed_stage)
+        code = typed_stage&.type_code.to_s
+        return "stage" if code.empty? || code == "is"
+
+        TYPED_STAGE_CSS[code] || "doctype"
+      end
     end
   end
 end

data/lib/pubid/renderers/directives_renderer.rb

@@ -27,18 +27,13 @@ module Pubid
       private
 
       def render_publisher_portion(context)
-        pub_str = @id.publisher.render(context:) if @id.publisher
+        ann = context.annotated
+        pub_str = annotate(@id.publisher.render(context:), "publisher",
+                           annotated: ann) if @id.publisher
         abbr = @id.typed_stage ? @id.typed_stage.abbreviation(format_long: false) : ""
+        abbr = annotate(abbr, typed_stage_css(@id.typed_stage), annotated: ann) unless abbr.empty?
         subgroup_str = @id.subgroup.render(context:) if @id.subgroup
 
-        unless @id.publisher&.copublished?
-          return [
-            pub_str,
-            (subgroup_str ? " #{subgroup_str}" : ""),
-            (abbr.empty? ? "" : " #{abbr}"),
-          ].join
-        end
-
         [
           pub_str,
           (subgroup_str ? " #{subgroup_str}" : ""),
@@ -47,13 +42,17 @@ module Pubid
       end
 
       def render_number_portion(context)
+        ann = context.annotated
         parts = []
-        parts << @id.number.render(context:) if @id.number
-        parts << " #{@id.part.render(context:)}" if @id.part
-        parts << "-#{@id.subpart.render(context:)}" if @id.subpart
-        parts << ".#{@id.stage_iteration.render(context:)}" if @id.stage_iteration
+        parts << annotate(@id.number.render(context:), "docnumber",
+                          annotated: ann) if @id.number
+        parts << " #{annotate(@id.part.render(context:), 'part', annotated: ann)}" if @id.part
+        parts << "-#{annotate(@id.subpart.render(context:), 'part', annotated: ann)}" if @id.subpart
+        if @id.stage_iteration
+          parts << ".#{annotate(@id.stage_iteration.render(context:), 'iteration', annotated: ann)}"
+        end
         date_str = @id.date.render(context:) if @id.date && context.with_date
-        parts << ":#{date_str}" if date_str
+        parts << ":#{annotate(date_str, 'year', annotated: ann)}" if date_str
         result = parts.join.strip
         result.empty? ? nil : result
       end

data/lib/pubid/renderers/guide_renderer.rb

@@ -6,10 +6,14 @@ module Pubid
       private
 
       def render_publisher_and_stage(context)
-        pub_str = @id.publisher.render(context:) if @id.publisher
+        ann = context.annotated
+        pub_str = annotate(@id.publisher.render(context:), "publisher",
+                           annotated: ann) if @id.publisher
         stage_str = @id.typed_stage.render(context:) if @id.typed_stage
 
         if stage_str && !stage_str.empty?
+          stage_str = annotate(stage_str, typed_stage_css(@id.typed_stage),
+                               annotated: ann)
           "#{pub_str} #{stage_str}"
         else
           pub_str

data/lib/pubid/renderers/human_readable.rb

@@ -17,12 +17,16 @@ module Pubid
       private
 
       def render_publisher_and_stage(context)
-        pub_str = @id.publisher.render(context:) if @id.publisher
+        ann = context.annotated
+        pub_str = annotate(@id.publisher.render(context:), "publisher",
+                           annotated: ann) if @id.publisher
         stage_str = @id.typed_stage.render(context:) if @id.typed_stage
 
         if stage_str && !stage_str.empty?
           has_copub = @id.publisher&.copublished?
           sep = has_copub ? " " : "/"
+          stage_str = annotate(stage_str, typed_stage_css(@id.typed_stage),
+                               annotated: ann)
           "#{pub_str}#{sep}#{stage_str}"
         else
           pub_str
@@ -30,18 +34,25 @@ module Pubid
       end
 
       def render_number_portion(context)
+        ann = context.annotated
         parts = []
-        parts << @id.number.render(context:) if @id.number
-        parts << "-#{@id.part.render(context:)}" if @id.part
-        parts << "-#{@id.subpart.render(context:)}" if @id.subpart
-        parts << ".#{@id.stage_iteration.render(context:)}" if @id.stage_iteration
+        parts << annotate(@id.number.render(context:), "docnumber",
+                          annotated: ann) if @id.number
+        parts << "-#{annotate(@id.part.render(context:), 'part', annotated: ann)}" if @id.part
+        parts << "-#{annotate(@id.subpart.render(context:), 'part', annotated: ann)}" if @id.subpart
+        if @id.stage_iteration
+          parts << ".#{annotate(@id.stage_iteration.render(context:), 'iteration', annotated: ann)}"
+        end
         date_str = @id.date.render(context:) if @id.date && context.with_date
-        parts << ":#{date_str}" if date_str
+        parts << ":#{annotate(date_str, 'year', annotated: ann)}" if date_str
         parts.join
       end
 
       def render_edition_portion(context)
-        @id.edition.render(context:) if @id.edition&.number
+        return unless @id.edition&.number
+
+        annotate(@id.edition.render(context:), "edition",
+                 annotated: context.annotated)
       end
 
       def render_language_portion(context, with_edition: false)
@@ -49,7 +60,8 @@ module Pubid
 
         use_single = with_edition ? false : context.with_language_code == :single
         rendered = @id.languages.map do |l|
-          l.render(context:, lang_single: use_single)
+          annotate(l.render(context:, lang_single: use_single), "language",
+                   annotated: context.annotated)
         end
         "(#{rendered.join(use_single ? '/' : ',')})"
       end