pubid 2.0.0 → 2.0.2

data/lib/pubid/jcgm/builder.rb

@@ -24,7 +24,18 @@ module Pubid
         Jcgm.locate_type(typed_stage.type_code)
       end
 
+      # The bound grammar flattens the old `(base as base)` wrapper (the
+      # bindings cannot nest): the base document keeps the canonical
+      # number/date captures and the supplement layer captures
+      # supp_number/supp_date. Rebuild the nested shape the builder has
+      # always consumed — the base fields rename under :base and the
+      # supplement layer takes type_with_stage plus its own
+      # supp_number/supp_date, which is exactly the tree the
+      # amendment/corrigendum rules produced before the flatten.
+      SUPPLEMENT_STAGES = %w[Amd Cor Corrigendum].freeze
+
       def build(parsed_hash)
+        parsed_hash = unflatten_supplement(parsed_hash)
         klass = locate_identifier_klass(parsed_hash)
 
         # GUM guides store their part number in the shared `number` attribute
@@ -52,6 +63,30 @@ module Pubid
 
       private
 
+      def unflatten_supplement(parsed_hash)
+        stage = parsed_hash[:type_with_stage]
+        return parsed_hash if parsed_hash[:base] || stage.nil? ||
+          !SUPPLEMENT_STAGES.include?(stage)
+
+        base_hash = {}
+        %i[publisher number gum_number date languages].each do |key|
+          base_hash[key] = parsed_hash.delete(key) if parsed_hash[key]
+        end
+        stage = parsed_hash.delete(:type_with_stage)
+        supplement_hash = { type_with_stage: stage }
+        if parsed_hash[:supp_number]
+          supplement_hash[:number] = parsed_hash.delete(:supp_number)
+        end
+        if parsed_hash[:supp_date]
+          supplement_hash[:date] = parsed_hash.delete(:supp_date)
+        end
+        # Keep the base as a raw hash: the shared assign_attributes loop
+        # routes :base through cast, which recursively builds it — the
+        # same path the tree backend's nested subtree took.
+        supplement_hash[:base] = base_hash
+        parsed_hash.merge(supplement_hash)
+      end
+
       def default_identifier_class
         Identifiers::Guide
       end

data/lib/pubid/jcgm/parser.rb

@@ -1,158 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Jcgm
-    class Parser < ::Pubid::Parser::Grammar
-      include ::Pubid::Parser::CommonParseRules
-      include ::Pubid::Parser::CommonParseMethods
-
-      root :identifier
-
-      rule(:identifier) do
-        meeting_identifier | amendment_identifier | corrigendum_identifier |
-          numbered_corrigendum_identifier | base | named_guide_identifier
-      end
-
-      # "JCGM 200:2008 Corrigendum" — a base guide plus a trailing
-      # " Corrigendum" word (no number). Must precede base: Parslet
-      # is an ordered PEG that commits to the first matching alternative, so if
-      # base ran first it would consume "JCGM 200:2008" and root
-      # would fail on the leftover " Corrigendum". Emits type_with_stage so the
-      # builder routes it to Corrigendum.
-      rule(:corrigendum_identifier) do
-        base.as(:base) >> space >>
-          str("Corrigendum").as(:type_with_stage)
-      end
-
-      # "JCGM 101:2008/Cor 1:2009" — a base guide plus a slash-separated
-      # numbered corrigendum (mirrors the ISO/IEC supplement form). The
-      # trailing :YYYY is optional so "JCGM 101:2008/Cor 1" also parses.
-      # Must precede base for the same PEG-commit reason as corrigendum_identifier.
-      rule(:numbered_corrigendum_identifier) do
-        base.as(:base) >>
-          str("/") >> str("Cor").as(:type_with_stage) >>
-          supplement_separator >> digits.as(:number) >>
-          corrigendum_date.maybe
-      end
-
-      # "Amd 1" and the dotted "Amd.1:2026" BIPM prints on its
-      # publications page (bipm.org, JCGM 100:2008/Amd.1:2026) are both
-      # accepted on input; rendering stays "Amd 1".
-      rule(:supplement_separator) do
-        space | (str(".") >> space.maybe)
-      end
-
-      # Dateless "named" guides: "JCGM GUM", "JCGM VIM-3" (and future "VIM-N").
-      # Last in the alternation — only reached when base fully fails
-      # (these have no date, so number_portion/date_portion never match).
-      rule(:named_guide_identifier) do
-        publisher >> space >> named_number
-      end
-
-      rule(:named_number) do
-        (str("GUM") | (str("VIM") >> (str("-") >> digits).maybe)).as(:number)
-      end
-
-      # Committee/meeting record, e.g. "JCGM 17th Meeting (2012)". Diverges
-      # from base right after the digits (base wants ":", meeting
-      # wants the ordinal suffix), so ordered choice is unambiguous. Emits the
-      # same tokens as a guide plus type_with_stage "Meeting", so the generic
-      # builder path resolves it to Identifiers::Meeting (like "Amd").
-      #
-      # The trailing " (YYYY)" group is optional, so the partial reference
-      # "JCGM 11st Meeting" parses with `date` left nil. JCGM numbers its
-      # meetings in one sequence, so the ordinal alone names the event and the
-      # year is redundant detail. The whole group is `.maybe` (not the year
-      # inside it), so a dangling "(" or a truncated year still fails —
-      # the same shape as `date_portion.maybe` in `rule(:base)`.
-      rule(:meeting_identifier) do
-        publisher >> space >> digits.as(:number) >> ordinal_suffix >>
-          space >> str("Meeting").as(:type_with_stage) >>
-          (space >> str("(") >> year_digits.as(:date) >> str(")")).maybe
-      end
-
-      rule(:ordinal_suffix) do
-        str("st") | str("nd") | str("rd") | str("th")
-      end
-
-      # `date_portion` is optional so a partial reference that omits the
-      # trailing `:YYYY` date (e.g. "JCGM 100") parses with `date` left nil,
-      # letting relaton match a collection via `matches?(row, ignore: [:date])`.
-      # The whole sub-rule is `.maybe` (not the year inside it) so a dangling
-      # ":" still fails. Mirrors ETSI (lib/pubid/etsi/parser.rb).
-      rule(:base) do
-        publisher >> space >> number_portion >>
-          date_portion.maybe >> language_portion.maybe
-      end
-
-      rule(:amendment_identifier) do
-        base.as(:base) >>
-          str("/") >> amendment_type >>
-          supplement_separator >> digits.as(:number) >>
-          amendment_date.maybe
-      end
-
-      rule(:publisher) do
-        str("JCGM").as(:publisher)
-      end
-
-      # Number can be plain (100, 200) or GUM-prefixed (GUM-1, GUM-6)
-      rule(:number_portion) do
-        gum_number | standard_number
-      end
-
-      rule(:standard_number) do
-        digits.as(:number)
-      end
-
-      rule(:gum_number) do
-        str("GUM-") >> digits.as(:gum_number)
-      end
-
-      # Date can be YYYY or YYYY-MM-DD
-      rule(:date_portion) do
-        str(":") >> (full_date | year_only)
-      end
-
-      rule(:year_only) do
-        year_digits.as(:date)
-      end
-
-      rule(:full_date) do
-        (year_digits >> str("-") >> month_digits >> str("-") >> day_digits).as(:date)
-      end
-
-      # Language: "(E)", "(F)", "(E/F)", "(F/E)"
-      rule(:language_portion) do
-        str("(") >>
-          (
-            # Multi-language: E/F, F/E
-            (str("E/F") | str("F/E")) |
-            # Single language: E, F, R, etc.
-            match("[A-Z]")
-          ).as(:languages) >>
-          str(")")
-      end
-
-      # Amendment support
-      rule(:amendment_type) do
-        str("Amd").as(:type_with_stage)
-      end
-
-      rule(:amendment_number) do
-        digits.as(:number)
-      end
-
-      rule(:amendment_date) do
-        str(":") >> (full_date | year_only)
-      end
-
-      # Numbered corrigendum date: same shape as amendment_date.
-      rule(:corrigendum_date) do
-        str(":") >> (full_date | year_only)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/jcgm.rb

@@ -32,10 +32,9 @@ module Pubid
         raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
-      parser = Parser.new
       builder = Builder.new
 
-      parsed = Pubid::Parg::Backend.parse(:jcgm, identifier)
+      parsed = Pubid::Parg::Model.bound(:jcgm, identifier)
       builder.build(parsed)
     end
 

data/lib/pubid/jis/builder.rb

@@ -9,12 +9,14 @@ module Pubid
 
       def build(data)
         # Handle supplement case first; the SYMBOL clause (if any) attaches to
-        # the outermost identifier, be it the base or the supplement.
-        identifier = if data[:amendment]
+        # the outermost identifier, be it the base or the supplement. The
+        # bindings bind the supplement's fields flat (amd_type/amd_number/…),
+        # so their presence marks the supplement kind.
+        identifier = if data[:amd_type]
                        build_amendment(data)
-                     elsif data[:explanation]
+                     elsif data[:expl_type]
                        build_explanation(data)
-                     elsif data[:corrigendum]
+                     elsif data[:corr_type]
                        build_corrigendum(data)
                      else
                        build_single_identifier(data)
@@ -58,49 +60,36 @@ module Pubid
       end
 
       def build_amendment(data)
-        amd_data = data[:amendment]
+        # The bindings carry the supplement's fields at the top level; the
+        # base document shares them.
+        base = build_single_identifier(data)
 
-        # Build base document (without supplement)
-        base_data = data.except(:amendment)
-        base = build_single_identifier(base_data)
-
-        # Build amendment
         Identifiers::Amendment.new(
           base: base,
-          number: amd_data[:amd_number].to_i,
-          year: amd_data[:amd_year].to_i,
-          reaffirmed: (true if amd_data[:amd_reaffirmed]),
+          number: data[:amd_number].to_i,
+          year: data[:amd_year].to_i,
+          reaffirmed: (true if data[:amd_reaffirmed]),
         )
       end
 
       def build_explanation(data)
-        expl_data = data[:explanation]
-
-        # Build base document (without supplement)
-        base_data = data.except(:explanation)
-        base = build_single_identifier(base_data)
+        base = build_single_identifier(data)
 
-        # Build explanation
         Identifiers::Explanation.new(
           base: base,
-          number: expl_data[:expl_number]&.to_i,
+          number: data[:expl_number]&.to_i,
           year: base.year,
         )
       end
 
       def build_corrigendum(data)
-        corr_data = data[:corrigendum]
-
-        # Build base document (without supplement)
-        base_data = data.except(:corrigendum)
-        base = build_single_identifier(base_data)
+        base = build_single_identifier(data)
 
-        # Build corrigendum
         Identifiers::Corrigendum.new(
           base: base,
-          number: corr_data[:corr_number].to_i,
-          year: corr_data[:corr_year].to_i,
-          reaffirmed: (true if corr_data[:corr_reaffirmed]),
+          number: data[:corr_number].to_i,
+          year: data[:corr_year].to_i,
+          reaffirmed: (true if data[:corr_reaffirmed]),
         )
       end
 

data/lib/pubid/jis/identifier.rb

@@ -174,7 +174,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:jis, identifier)
+        parsed = Pubid::Parg::Model.bound(:jis, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/jis/parser.rb

@@ -1,135 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Jis
-    class Parser < ::Pubid::Parser::Grammar
-      # Japanese character normalization
-      rule(:jp_dash) { str("ｰ") } # Full-width dash
-      rule(:jp_space) { str("　") }  # Full-width space
-      rule(:jp_colon) { str("：") }  # Full-width colon
-      rule(:jp_lparen) { str("（") }
-      rule(:jp_rparen) { str("）") }
-
-      # Normalized separators
-      rule(:dash) { (str("-") | jp_dash).as(:dash) }
-      rule(:space) { str(" ") | jp_space }
-      rule(:colon) { str(":") | jp_colon }
-
-      # Basic elements
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-      rule(:letter) { match["A-Z"] }
-
-      # JIS prefix (optional, handles both "JIS " and "JIS/")
-      rule(:jis_prefix) { str("JIS") >> (space | str("/")).maybe }
-
-      # Type prefix (TR or TS, can come with or without slash)
-      rule(:type_prefix) do
-        (str("TR") | str("TS")).as(:type) >> (space | str("/"))
-      end
-
-      # Series letter
-      rule(:series) { letter.as(:series) }
-
-      # Number (preserve as string to maintain leading zeros)
-      rule(:number) { digits.as(:number) }
-
-      # Parts (multi-level: -1, -2-1, -3-2-1, etc.)
-      rule(:part) do
-        dash >> digits.as(:part)
-      end
-
-      rule(:parts) { part.repeat(0).as(:parts) }
-
-      # Reaffirmation marker (再確認): trailing "R" on a year
-      rule(:reaffirmed) { str("R").maybe.as(:reaffirmed) }
-
-      # Year
-      rule(:year) do
-        colon >> digits.as(:year) >> reaffirmed
-      end
-
-      # Language code
-      rule(:language) do
-        (str("(") | jp_lparen) >>
-          match["EJ"].as(:language) >>
-          (str(")") | jp_rparen)
-      end
-
-      # All-parts notation (Japanese)
-      rule(:all_parts) do
-        ((jp_lparen >> str("規格群") >> jp_rparen) |
-         (str("(") >> str("規格群") >> str(")"))).as(:all_parts)
-      end
-
-      # Amendment supplement
-      rule(:amendment) do
-        str("/") >>
-          (str("AMENDMENT") | str("AMD")).as(:amd_type) >>
-          space >>
-          digits.as(:amd_number) >>
-          colon >>
-          digits.as(:amd_year) >>
-          str("R").maybe.as(:amd_reaffirmed)
-      end
-
-      # Explanation supplement
-      rule(:explanation) do
-        str("/") >>
-          (str("EXPLANATION") | str("EXPL")).as(:expl_type) >>
-          (space >> digits.as(:expl_number)).maybe
-      end
-
-      # Corrigendum supplement
-      rule(:corrigendum) do
-        str("/") >>
-          (str("CORRIGENDUM") | str("CORR")).as(:corr_type) >>
-          space >>
-          digits.as(:corr_number) >>
-          colon >>
-          digits.as(:corr_year) >>
-          str("R").maybe.as(:corr_reaffirmed)
-      end
-
-      # Supplements (AMD, EXPL or CORRIGENDUM, only one for JIS)
-      rule(:supplement) do
-        amendment.as(:amendment) | explanation.as(:explanation) |
-          corrigendum.as(:corrigendum)
-      end
-
-      # Graphical-symbol sub-reference (e.g. JIS Z 8210 safety signs):
-      # "SYMBOL <id>" where <id> runs to the end of the string and may be a
-      # number, an alphanumeric code or a free-text phrase. The keyword may
-      # also appear bare with no value.
-      rule(:symbol_clause) do
-        space >> str("SYMBOL").as(:symbol_present) >>
-          (space >> match["^\n"].repeat(1).as(:symbol_value)).maybe
-      end
-
-      # Main identifier
-      rule(:identifier) do
-        jis_prefix.maybe >>
-          type_prefix.maybe >>
-          space.maybe >>
-          series >>
-          space.maybe >>
-          number >>
-          parts >>
-          year.maybe >>
-          language.maybe >>
-          all_parts.maybe >>
-          supplement.maybe >>
-          symbol_clause.maybe
-      end
-
-      rule(:root) { identifier }
-
-      # Parse and normalize Japanese characters
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/nist/builder.rb

@@ -85,9 +85,13 @@ module Pubid
 
         # NEW: Check for CIRC supplement pattern
         # Note: :base_portion is lost during parser merge, so check for supplement indicators
+        # circ_series routes the bare "NBS.CIRC.sup" form: the edition-2
+        # grammar cannot carry the zero-width supplement_empty marker the
+        # Parslet tree used, and the series capture marks every circular
+        # supplement head.
         if parsed_hash[:supplement_date_range] || parsed_hash[:supplement_slash_year] ||
             parsed_hash[:supplement_month_year] || parsed_hash[:supplement_year] ||
-            parsed_hash[:supplement_empty] ||
+            parsed_hash[:supplement_empty] || parsed_hash[:circ_series] ||
             parsed_hash[:supplement] || parsed_hash[:base_portion]
           return build_circular_supplement(parsed_hash)
         end

data/lib/pubid/nist/caster.rb

@@ -128,7 +128,16 @@ module Pubid
                                                  id: value[:owmwp_year])
           { first_number: Components::Code.new(value: number_part), edition: edition_part }
 
-        when :first_number, :second_number
+        # The polymorphic number wrappers split per branch in the grammar
+        # (asme's designator/designator_code pattern): first_number /
+        # second_number (string) arrive over the bare branches,
+        # first_number_composite / second_number_composite (raw) over the
+        # branches carrying inner captures. The composite keys map onto
+        # the same dispatch.
+        when :first_number, :first_number_composite, :second_number,
+             :second_number_composite
+          type = :first_number if type == :first_number_composite
+          type = :second_number if type == :second_number_composite
           return nil if value.nil? || value.to_s.strip.empty?
 
           # NEW: Handle OWMWP date-based number (nested hash structure)
@@ -1039,8 +1048,9 @@ module Pubid
 
         when :edition_month, :edition_year, :edition_day, :edition_has_rev
           # These work together: edition_month + edition_year -> single edition ID
-          # Skip processing if this is edition_month alone (will be processed with edition_year)
-          return nil if type == :edition_month
+          # Skip processing if this is edition_month or edition_day alone
+          # (both are consumed by the edition_year branch via parsed_hash)
+          return nil if type == :edition_month || type == :edition_day
 
           # Process edition_year, combining with edition_month if present
           return nil if value.nil? || value.to_s.strip.empty?

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

@@ -346,7 +346,7 @@ module Pubid
       # @param format [:full, :long, :abbreviated, :short, :mr] output format
       def to_s(format = nil)
         # Handle both keyword argument (hash) and positional argument (symbol/string)
-        annotated = format.is_a?(Hash) ? format[:annotated] : nil
+        flags = plain_render_flags(format)
         format = format[:format] if format.is_a?(Hash)
 
         # Default to parsed_format if available (preserves input format on round-trip)
@@ -358,7 +358,42 @@ module Pubid
         # NIST's `to_s` takes a POSITIONAL format and its `render` override
         # builds no rendering context, so neither the flag nor the context
         # reaches the shared hook. Apply the annotation fallback here.
-        annotate_plain_render(rendered, annotated: annotated)
+        annotate_plain_render(rendered, **flags)
+      end
+
+      # The keyword flags a positional-format `to_s` hands to
+      # `annotate_plain_render`. Ruby fills the positional `format` with a
+      # Hash when a caller passes keywords, so they arrive here.
+      #
+      # `with_publisher: false` cuts the leading `NIST`/`NBS` from the
+      # finished string ({#publisher_prefixes}), which covers every place a
+      # NIST style prints a publisher — the compound `NBS …` series, the
+      # `default_publisher` subclasses and a supplement's base — in one
+      # step.
+      def plain_render_flags(format)
+        return {} unless format.is_a?(Hash)
+
+        format.slice(:annotated, :with_publisher)
+      end
+      private :plain_render_flags
+
+      # The MR style (`NIST.SP.800-53`) is a fixed machine form and ignores
+      # `with_publisher:`. The test reads the OUTPUT, not the requested
+      # format: several subclasses pick their style themselves (an id parsed
+      # from an MR string still renders the short style), so the format a
+      # caller asked for does not say which style came back.
+      def apply_with_publisher(result, format, with_publisher)
+        mr_style = result.is_a?(String) && result.match?(/\A(?:NIST|NBS)\./)
+        return result if mr_style
+
+        super
+      end
+      private :apply_with_publisher
+
+      # Every leading publisher token a NIST short style can print: the
+      # parsed publisher, and the two `default_publisher` values.
+      def publisher_prefixes
+        [publisher.to_s, "NIST", "NBS"]
       end
 
       # NIST has its own defined MR format (to_mr_style) used by relaton-nist

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

@@ -57,7 +57,7 @@ module Pubid
           # string: with the flag set, `super` returns a string ending in
           # "</span>" and the anchor no longer matches. Render plain, rewrite,
           # then annotate.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
           format = format[:format] if format.is_a?(Hash)
 
           result = super(format)
@@ -72,7 +72,7 @@ module Pubid
                                  "e#{edition.id || '?'}.#{edition.additional_text}")
           end
 
-          annotate_plain_render(result, annotated: annotated)
+          annotate_plain_render(result, **flags)
         end
       end
     end

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

@@ -41,7 +41,7 @@ module Pubid
           # Hash. Normalise it away before `super`, so the annotation is applied
           # once, here, and covers the date-range branch too — that branch
           # returns a hand-composed string and never reached `super` at all.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
           format = format[:format] || :short if format.is_a?(Hash)
 
           # Handle date range supplements (no base identifier)
@@ -52,7 +52,7 @@ module Pubid
                      super(format)
                    end
 
-          annotate_plain_render(result, annotated: annotated)
+          annotate_plain_render(result, **flags)
         end
       end
     end

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

@@ -45,7 +45,7 @@ module Pubid
           # a Hash — Ruby converts keywords for a method that accepts none.
           # The same idiom `Identifiers::Base#to_s` uses. This renderer
           # ignores `format`, so only the flag is read.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
 
           result = "#{publisher} #{series}"
 
@@ -61,7 +61,7 @@ module Pubid
             result += " #{vol_str}n#{issue_number.number}"
           end
 
-          annotate_plain_render(result, annotated: annotated)
+          annotate_plain_render(result, **flags)
         end
       end
     end

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

@@ -91,7 +91,7 @@ module Pubid
           # a Hash — Ruby converts keywords for a method that accepts none.
           # The same idiom `Identifiers::Base#to_s` uses. This renderer
           # ignores `format`, so only the flag is read.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
 
           # Use actual series attribute if it contains subseries (e.g., "CRPL-F-B")
           # Otherwise use default series_code ("CRPL")
@@ -129,7 +129,7 @@ module Pubid
           result += append_short_components
 
           result += range_notation if range_notation
-          annotate_plain_render(result, annotated: annotated)
+          annotate_plain_render(result, **flags)
         end
       end
     end

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

@@ -38,7 +38,7 @@ module Pubid
           # string: with the flag set, `super` returns a string ending in
           # "</span>" and the anchor no longer matches. Render plain, rewrite,
           # then annotate.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
           format = format[:format] if format.is_a?(Hash)
 
           # Use the base to_s method first
@@ -50,7 +50,7 @@ module Pubid
                                  "#{edition.type}#{edition.id}-#{edition.additional_text}")
           end
 
-          annotate_plain_render(result, annotated: annotated)
+          annotate_plain_render(result, **flags)
         end
       end
     end

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

@@ -40,7 +40,7 @@ module Pubid
           # `super` is handed a SYMBOL below, so the base's annotation hook
           # never sees the flag. Capture it here and wrap what comes back —
           # exactly once, because the base returned plain text.
-          annotated = format.is_a?(Hash) ? format[:annotated] : nil
+          flags = plain_render_flags(format)
 
           # Handle both keyword argument (hash) and positional argument (symbol/string)
           effective_format = if format.is_a?(Hash)
@@ -56,7 +56,7 @@ module Pubid
                        super(effective_format)
                      end
 
-          annotate_plain_render(rendered, annotated: annotated)
+          annotate_plain_render(rendered, **flags)
         end
       end
     end