Merge branch...

Merge branch '345744-feature-flag-enable-cmark-commonmark-renderer-use_cmark_renderer' into 'master'

[Feature flag] Enable cmark CommonMark renderer (`:use_cmark_renderer`)

See merge request gitlab-org/gitlab!75800

config/feature_flags/development/use_cmark_renderer.yml

----
-name: use_cmark_renderer
-introduced_by_url: https://gitlab.com/gitlab-org/gitlab/-/merge_requests/61792
-rollout_issue_url: https://gitlab.com/gitlab-org/gitlab/-/issues/345744
-milestone: '14.6'
-type: development
-group: group::project management
-default_enabled: true

lib/banzai/filter/footnote_filter.rb

@@ -7,13 +7,14 @@ module Banzai
     # Footnotes are supported in CommonMark.  However we were stripping
     # the ids during sanitization.  Those are now allowed.
     #
-    # Footnotes are numbered the same - the first one has `id=fn1`, the
-    # second is `id=fn2`, etc.  In order to allow footnotes when rendering
-    # multiple markdown blocks on a page, we need to make each footnote
-    # reference unique.
-    #
+    # Footnotes are numbered as an increasing integer starting at `1`.
+    # The `id` associated with a footnote is based on the footnote reference
+    # string.  For example, `[^foot]` will generate `id="fn-foot"`.
+    # In order to allow footnotes when rendering multiple markdown blocks
+    # on a page, we need to make each footnote reference unique.
+
     # This filter adds a random number to each footnote (the same number
-    # can be used for a single render). So you get `id=fn1-4335` and `id=fn2-4335`.
+    # can be used for a single render). So you get `id=fn-1-4335` and `id=fn-foot-4335`.
     #
     class FootnoteFilter < HTML::Pipeline::Filter
       FOOTNOTE_ID_PREFIX              = 'fn-'
@@ -26,53 +27,24 @@ module Banzai
       CSS_FOOTNOTE   = 'sup > a[data-footnote-ref]'
       XPATH_FOOTNOTE = Gitlab::Utils::Nokogiri.css_to_xpath(CSS_FOOTNOTE).freeze
 
-      # only needed when feature flag use_cmark_renderer is turned off
-      INTEGER_PATTERN                     = /\A\d+\z/.freeze
-      FOOTNOTE_ID_PREFIX_OLD              = 'fn'
-      FOOTNOTE_LINK_ID_PREFIX_OLD         = 'fnref'
-      FOOTNOTE_LI_REFERENCE_PATTERN_OLD   = /\A#{FOOTNOTE_ID_PREFIX_OLD}\d+\z/.freeze
-      FOOTNOTE_LINK_REFERENCE_PATTERN_OLD = /\A#{FOOTNOTE_LINK_ID_PREFIX_OLD}\d+\z/.freeze
-      FOOTNOTE_START_NUMBER               = 1
-      CSS_SECTION_OLD                     = "ol > li[id=#{FOOTNOTE_ID_PREFIX_OLD}#{FOOTNOTE_START_NUMBER}]"
-      XPATH_SECTION_OLD                   = Gitlab::Utils::Nokogiri.css_to_xpath(CSS_SECTION_OLD).freeze
-
       def call
-        if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
         # Sanitization stripped off the section class - add it back in
         return doc unless section_node = doc.at_xpath(XPATH_SECTION)
 
         section_node.append_class('footnotes')
-        else
-          return doc unless first_footnote = doc.at_xpath(XPATH_SECTION_OLD)
-          return doc unless first_footnote.parent
-
-          first_footnote.parent.wrap('<section class="footnotes">')
-        end
 
         rand_suffix = "-#{random_number}"
         modified_footnotes = {}
 
-        xpath_footnote = if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-                           XPATH_FOOTNOTE
-                         else
-                           Gitlab::Utils::Nokogiri.css_to_xpath('sup > a[id]')
-                         end
-
-        doc.xpath(xpath_footnote).each do |link_node|
-          if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
+        doc.xpath(XPATH_FOOTNOTE).each do |link_node|
           ref_num = link_node[:id].delete_prefix(FOOTNOTE_LINK_ID_PREFIX)
           ref_num.gsub!(/[[:punct:]]/, '\\\\\&')
-          else
-            ref_num = link_node[:id].delete_prefix(FOOTNOTE_LINK_ID_PREFIX_OLD)
-          end
 
-          css = Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml) ? "section[data-footnotes] li[id=#{fn_id(ref_num)}]" : "li[id=#{fn_id(ref_num)}]"
+          css = "section[data-footnotes] li[id=#{fn_id(ref_num)}]"
           node_xpath = Gitlab::Utils::Nokogiri.css_to_xpath(css)
           footnote_node = doc.at_xpath(node_xpath)
 
           if footnote_node || modified_footnotes[ref_num]
-            next if Feature.disabled?(:use_cmark_renderer, default_enabled: :yaml) && !INTEGER_PATTERN.match?(ref_num)
-
             link_node[:href] += rand_suffix
             link_node[:id]   += rand_suffix
 
@@ -103,13 +75,11 @@ module Banzai
       end
 
       def fn_id(num)
-        prefix = Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml) ? FOOTNOTE_ID_PREFIX : FOOTNOTE_ID_PREFIX_OLD
-        "#{prefix}#{num}"
+        "#{FOOTNOTE_ID_PREFIX}#{num}"
       end
 
       def fnref_id(num)
-        prefix = Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml) ? FOOTNOTE_LINK_ID_PREFIX : FOOTNOTE_LINK_ID_PREFIX_OLD
-        "#{prefix}#{num}"
+        "#{FOOTNOTE_LINK_ID_PREFIX}#{num}"
       end
     end
   end

lib/banzai/filter/markdown_engines/common_mark.rb

@@ -4,8 +4,8 @@
 # This module is used in Banzai::Filter::MarkdownFilter.
 # Used gem is `commonmarker` which is a ruby wrapper for libcmark (CommonMark parser)
 # including GitHub's GFM extensions.
+# We now utilize the renderer built in `C`, rather than the ruby based renderer.
 # Homepage: https://github.com/gjtorikian/commonmarker
-
 module Banzai
   module Filter
     module MarkdownEngines
@@ -22,57 +22,29 @@ module Banzai
           :VALIDATE_UTF8               # replace illegal sequences with the replacement character U+FFFD.
         ].freeze
 
-        RENDER_OPTIONS_C = [
+        RENDER_OPTIONS = [
           :GITHUB_PRE_LANG,  # use GitHub-style <pre lang> for fenced code blocks.
           :FOOTNOTES,        # render footnotes.
           :FULL_INFO_STRING, # include full info strings of code blocks in separate attribute.
           :UNSAFE            # allow raw/custom HTML and unsafe links.
         ].freeze
 
-        # The `:GITHUB_PRE_LANG` option is not used intentionally because
-        # it renders a fence block with language as `<pre lang="LANG"><code>some code\n</code></pre>`
-        # while GitLab's syntax is `<pre><code lang="LANG">some code\n</code></pre>`.
-        # If in the future the syntax is about to be made GitHub-compatible, please, add `:GITHUB_PRE_LANG` render option below
-        # and remove `code_block` method from `lib/banzai/renderer/common_mark/html.rb`.
-        RENDER_OPTIONS_RUBY = [
-          # as of commonmarker 0.18.0, we need to use :UNSAFE to get the same as the original :DEFAULT
-          # https://github.com/gjtorikian/commonmarker/pull/81
-          :UNSAFE # allow raw/custom HTML and unsafe links.
-        ].freeze
-
         def initialize(context)
           @context = context
-          @renderer = Banzai::Renderer::CommonMark::HTML.new(options: render_options) if Feature.disabled?(:use_cmark_renderer, default_enabled: :yaml)
         end
 
         def render(text)
-          if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-            CommonMarker.render_html(text, render_options, extensions)
-          else
-            doc = CommonMarker.render_doc(text, PARSE_OPTIONS, extensions)
-
-            @renderer.render(doc)
-          end
+          CommonMarker.render_html(text, render_options, EXTENSIONS)
         end
 
         private
 
-        def extensions
-          if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-            EXTENSIONS
-          else
-            EXTENSIONS + [
-              :tagfilter # strips out several "unsafe" HTML tags from being used: https://github.github.com/gfm/#disallowed-raw-html-extension-
-            ].freeze
-          end
-        end
-
         def render_options
           @context[:no_sourcepos] ? render_options_no_sourcepos : render_options_sourcepos
         end
 
         def render_options_no_sourcepos
-          Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml) ? RENDER_OPTIONS_C : RENDER_OPTIONS_RUBY
+          RENDER_OPTIONS
         end
 
         def render_options_sourcepos

lib/banzai/filter/markdown_post_escape_filter.rb

@@ -10,6 +10,8 @@ module Banzai
 
       CSS_A          = 'a'
       XPATH_A        = Gitlab::Utils::Nokogiri.css_to_xpath(CSS_A).freeze
+      CSS_LANG_TAG   = 'pre'
+      XPATH_LANG_TAG = Gitlab::Utils::Nokogiri.css_to_xpath(CSS_LANG_TAG).freeze
 
       def call
         return doc unless result[:escaped_literals]
@@ -32,22 +34,12 @@ module Banzai
           node.attributes['title'].value = node.attributes['title'].value.gsub(SPAN_REGEX, '\1') if node.attributes['title']
         end
 
-        doc.xpath(lang_tag).each do |node|
+        doc.xpath(XPATH_LANG_TAG).each do |node|
           node.attributes['lang'].value  = node.attributes['lang'].value.gsub(SPAN_REGEX, '\1') if node.attributes['lang']
         end
 
         doc
       end
-
-      private
-
-      def lang_tag
-        if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-          Gitlab::Utils::Nokogiri.css_to_xpath('pre')
-        else
-          Gitlab::Utils::Nokogiri.css_to_xpath('code')
-        end
-      end
     end
   end
 end

lib/banzai/filter/plantuml_filter.rb

@@ -25,12 +25,7 @@ module Banzai
       private
 
       def lang_tag
-        @lang_tag ||=
-          if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-            Gitlab::Utils::Nokogiri.css_to_xpath('pre[lang="plantuml"] > code').freeze
-          else
-            Gitlab::Utils::Nokogiri.css_to_xpath('pre > code[lang="plantuml"]').freeze
-          end
+        @lang_tag ||= Gitlab::Utils::Nokogiri.css_to_xpath('pre[lang="plantuml"] > code').freeze
       end
 
       def settings

lib/banzai/filter/sanitization_filter.rb

@@ -28,12 +28,10 @@ module Banzai
         allowlist[:attributes]['li'] = %w[id]
         allowlist[:transformers].push(self.class.remove_non_footnote_ids)
 
-        if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
         # Allow section elements with data-footnotes attribute
         allowlist[:elements].push('section')
         allowlist[:attributes]['section'] = %w(data-footnotes)
         allowlist[:attributes]['a'].push('data-footnote-ref', 'data-footnote-backref')
-        end
 
         allowlist
       end
@@ -61,13 +59,8 @@ module Banzai
             return unless node.name == 'a' || node.name == 'li'
             return unless node.has_attribute?('id')
 
-            if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
             return if node.name == 'a' && node['id'] =~ Banzai::Filter::FootnoteFilter::FOOTNOTE_LINK_REFERENCE_PATTERN
             return if node.name == 'li' && node['id'] =~ Banzai::Filter::FootnoteFilter::FOOTNOTE_LI_REFERENCE_PATTERN
-            else
-              return if node.name == 'a' && node['id'] =~ Banzai::Filter::FootnoteFilter::FOOTNOTE_LINK_REFERENCE_PATTERN_OLD
-              return if node.name == 'li' && node['id'] =~ Banzai::Filter::FootnoteFilter::FOOTNOTE_LI_REFERENCE_PATTERN_OLD
-            end
 
             node.remove_attribute('id')
           end

lib/banzai/filter/syntax_highlight_filter.rb

@@ -70,11 +70,11 @@ module Banzai
       private
 
       def parse_lang_params(node)
-        node = node.parent if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
+        node = node.parent
 
         # Commonmarker's FULL_INFO_STRING render option works with the space delimiter.
         # But the current behavior of GitLab's markdown renderer is different - it grabs everything as the single
-        # line, including language and its options. To keep backward compatability, we have to parse the old format and
+        # line, including language and its options. To keep backward compatibility, we have to parse the old format and
         # merge with the new one.
         #
         # Behaviors before separating language and its parameters:
@@ -91,11 +91,7 @@ module Banzai
         return unless language
 
         language, language_params = language.split(LANG_PARAMS_DELIMITER, 2)
-
-        if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
         language_params = [node.attr('data-meta'), language_params].compact.join(' ')
-        end
-
         formatted_language_params = format_language_params(language_params)
 
         [language, formatted_language_params]

lib/banzai/renderer/common_mark/html.rb

-# frozen_string_literal: true
-
-# Remove this entire file when removing `use_cmark_renderer` feature flag and switching to the CMARK html renderer.
-# https://gitlab.com/gitlab-org/gitlab/-/issues/345744
-module Banzai
-  module Renderer
-    module CommonMark
-      class HTML < CommonMarker::HtmlRenderer
-        def code_block(node)
-          block do
-            out("<pre#{sourcepos(node)}><code")
-            out(' lang="', node.fence_info, '"') if node.fence_info.present?
-            out('>')
-            out(escape_html(node.string_content))
-            out('</code></pre>')
-          end
-        end
-      end
-    end
-  end
-end

lib/gitlab/asciidoc/syntax_highlighter/html_pipeline_adapter.rb

@@ -7,11 +7,7 @@ module Gitlab
         register_for 'gitlab-html-pipeline'
 
         def format(node, lang, opts)
-          if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
           %(<pre #{lang ? %[lang="#{lang}"] : ''}><code>#{node.content}</code></pre>)
-          else
-            %(<pre><code #{lang ? %[ lang="#{lang}"] : ''}>#{node.content}</code></pre>)
-          end
         end
       end
     end

spec/lib/banzai/filter/footnote_filter_spec.rb

@@ -56,52 +56,6 @@ RSpec.describe Banzai::Filter::FootnoteFilter do
     it 'properly adds the necessary ids and classes' do
       expect(doc.to_html).to eq filtered_footnote.strip
     end
-
-    context 'using ruby-based HTML renderer' do
-      # first[^1] and second[^second]
-      # [^1]: one
-      # [^second]: two
-      let(:footnote) do
-        <<~EOF
-          <p>first<sup><a href="#fn1" id="fnref1">1</a></sup> and second<sup><a href="#fn2" id="fnref2">2</a></sup></p>
-          <p>same reference<sup><a href="#fn1" id="fnref1">1</a></sup></p>
-          <ol>
-          <li id="fn1">
-          <p>one <a href="#fnref1">↩</a></p>
-          </li>
-          <li id="fn2">
-          <p>two <a href="#fnref2">↩</a></p>
-          </li>
-          </ol>
-        EOF
-      end
-
-      let(:filtered_footnote) do
-        <<~EOF
-          <p>first<sup class="footnote-ref"><a href="#fn1-#{identifier}" id="fnref1-#{identifier}">1</a></sup> and second<sup class="footnote-ref"><a href="#fn2-#{identifier}" id="fnref2-#{identifier}">2</a></sup></p>
-          <p>same reference<sup class="footnote-ref"><a href="#fn1-#{identifier}" id="fnref1-#{identifier}">1</a></sup></p>
-          <section class="footnotes"><ol>
-          <li id="fn1-#{identifier}">
-          <p>one <a href="#fnref1-#{identifier}" class="footnote-backref">↩</a></p>
-          </li>
-          <li id="fn2-#{identifier}">
-          <p>two <a href="#fnref2-#{identifier}" class="footnote-backref">↩</a></p>
-          </li>
-          </ol></section>
-        EOF
-      end
-
-      let(:doc)        { filter(footnote) }
-      let(:identifier) { link_node[:id].delete_prefix('fnref1-') }
-
-      before do
-        stub_feature_flags(use_cmark_renderer: false)
-      end
-
-      it 'properly adds the necessary ids and classes' do
-        expect(doc.to_html).to eq filtered_footnote
-      end
-    end
   end
 
   context 'when detecting footnotes' do

spec/lib/banzai/filter/markdown_filter_spec.rb

@@ -5,7 +5,6 @@ require 'spec_helper'
 RSpec.describe Banzai::Filter::MarkdownFilter do
   include FilterSpecHelper
 
-  shared_examples_for 'renders correct markdown' do
   describe 'markdown engine from context' do
     it 'defaults to CommonMark' do
       expect_next_instance_of(Banzai::Filter::MarkdownEngines::CommonMark) do |instance|
@@ -33,11 +32,7 @@ RSpec.describe Banzai::Filter::MarkdownFilter do
       it 'adds language to lang attribute when specified' do
         result = filter("```html\nsome code\n```", no_sourcepos: true)
 
-          if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
         expect(result).to start_with('<pre lang="html"><code>')
-          else
-            expect(result).to start_with('<pre><code lang="html">')
-          end
       end
 
       it 'does not add language to lang attribute when not specified' do
@@ -49,21 +44,13 @@ RSpec.describe Banzai::Filter::MarkdownFilter do
       it 'works with utf8 chars in language' do
         result = filter("```日\nsome code\n```", no_sourcepos: true)
 
-          if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
         expect(result).to start_with('<pre lang="日"><code>')
-          else
-            expect(result).to start_with('<pre><code lang="日">')
-          end
       end
 
       it 'works with additional language parameters' do
         result = filter("```ruby:red gem foo\nsome code\n```", no_sourcepos: true)
 
-          if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
         expect(result).to start_with('<pre lang="ruby:red" data-meta="gem foo"><code>')
-          else
-            expect(result).to start_with('<pre><code lang="ruby:red gem foo">')
-          end
       end
     end
   end
@@ -101,29 +88,7 @@ RSpec.describe Banzai::Filter::MarkdownFilter do
       result = filter(text, no_sourcepos: true)
 
       expect(result).to include('<td>foot <sup')
-
-        if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
       expect(result).to include('<section class="footnotes" data-footnotes>')
-        else
-          expect(result).to include('<section class="footnotes">')
-        end
-      end
-    end
-  end
-
-  context 'using ruby-based HTML renderer' do
-    before do
-      stub_feature_flags(use_cmark_renderer: false)
-    end
-
-    it_behaves_like 'renders correct markdown'
     end
-
-  context 'using c-based HTML renderer' do
-    before do
-      stub_feature_flags(use_cmark_renderer: true)
-    end
-
-    it_behaves_like 'renders correct markdown'
   end
 end

spec/lib/banzai/filter/plantuml_filter_spec.rb

@@ -5,16 +5,10 @@ require 'spec_helper'
 RSpec.describe Banzai::Filter::PlantumlFilter do
   include FilterSpecHelper
 
-  shared_examples_for 'renders correct markdown' do
   it 'replaces plantuml pre tag with img tag' do
     stub_application_setting(plantuml_enabled: true, plantuml_url: "http://localhost:8080")
 
-      input = if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-                '<pre lang="plantuml"><code>Bob -> Sara : Hello</code></pre>'
-              else
-                '<pre><code lang="plantuml">Bob -> Sara : Hello</code></pre>'
-              end
-
+    input = '<pre lang="plantuml"><code>Bob -> Sara : Hello</code></pre>'
     output = '<div class="imageblock"><div class="content"><img class="plantuml" src="http://localhost:8080/png/U9npoazIqBLJ24uiIbImKl18pSd91m0rkGMq"></div></div>'
     doc = filter(input)
 
@@ -24,14 +18,8 @@ RSpec.describe Banzai::Filter::PlantumlFilter do
   it 'does not replace plantuml pre tag with img tag if disabled' do
     stub_application_setting(plantuml_enabled: false)
 
-      if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
     input = '<pre lang="plantuml"><code>Bob -> Sara : Hello</code></pre>'
     output = '<pre lang="plantuml"><code>Bob -&gt; Sara : Hello</code></pre>'
-      else
-        input = '<pre><code lang="plantuml">Bob -> Sara : Hello</code></pre>'
-        output = '<pre><code lang="plantuml">Bob -&gt; Sara : Hello</code></pre>'
-      end
-
     doc = filter(input)
 
     expect(doc.to_s).to eq output
@@ -40,32 +28,10 @@ RSpec.describe Banzai::Filter::PlantumlFilter do
   it 'does not replace plantuml pre tag with img tag if url is invalid' do
     stub_application_setting(plantuml_enabled: true, plantuml_url: "invalid")
 
-      input = if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-                '<pre lang="plantuml"><code>Bob -> Sara : Hello</code></pre>'
-              else
-                '<pre><code lang="plantuml">Bob -> Sara : Hello</code></pre>'
-              end
-
+    input = '<pre lang="plantuml"><code>Bob -> Sara : Hello</code></pre>'
     output = '<div class="listingblock"><div class="content"><pre class="plantuml plantuml-error"> Error: cannot connect to PlantUML server at "invalid"</pre></div></div>'
     doc = filter(input)
 
     expect(doc.to_s).to eq output
   end
-  end
-
-  context 'using ruby-based HTML renderer' do
-    before do
-      stub_feature_flags(use_cmark_renderer: false)
-    end
-
-    it_behaves_like 'renders correct markdown'
-  end
-
-  context 'using c-based HTML renderer' do
-    before do
-      stub_feature_flags(use_cmark_renderer: true)
-    end
-
-    it_behaves_like 'renders correct markdown'
-  end
 end

spec/lib/banzai/filter/sanitization_filter_spec.rb

@@ -177,53 +177,6 @@ RSpec.describe Banzai::Filter::SanitizationFilter do
           expect(act.to_html).to eq exp
         end
       end
-
-      context 'using ruby-based HTML renderer' do
-        before do
-          stub_feature_flags(use_cmark_renderer: false)
-        end
-
-        it 'allows correct footnote id property on links' do
-          exp = %q(<a href="#fn1" id="fnref1">foo/bar.md</a>)
-          act = filter(exp)
-
-          expect(act.to_html).to eq exp
-        end
-
-        it 'allows correct footnote id property on li element' do
-          exp = %q(<ol><li id="fn1">footnote</li></ol>)
-          act = filter(exp)
-
-          expect(act.to_html).to eq exp
-        end
-
-        it 'removes invalid id for footnote links' do
-          exp = %q(<a href="#fn1">link</a>)
-
-          %w[fnrefx test xfnref1].each do |id|
-            act = filter(%(<a href="#fn1" id="#{id}">link</a>))
-
-            expect(act.to_html).to eq exp
-          end
-        end
-
-        it 'removes invalid id for footnote li' do
-          exp = %q(<ol><li>footnote</li></ol>)
-
-          %w[fnx test xfn1].each do |id|
-            act = filter(%(<ol><li id="#{id}">footnote</li></ol>))
-
-            expect(act.to_html).to eq exp
-          end
-        end
-
-        it 'allows footnotes numbered higher than 9' do
-          exp = %q(<a href="#fn15" id="fnref15">link</a><ol><li id="fn15">footnote</li></ol>)
-          act = filter(exp)
-
-          expect(act.to_html).to eq exp
-        end
-      end
     end
   end
 end

spec/lib/banzai/filter/syntax_highlight_filter_spec.rb

@@ -19,7 +19,6 @@ RSpec.describe Banzai::Filter::SyntaxHighlightFilter do
     end
   end
 
-  shared_examples_for 'renders correct markdown' do
   context "when no language is specified" do
     it "highlights as plaintext" do
       result = filter('<pre><code>def fun end</code></pre>')
@@ -40,11 +39,7 @@ RSpec.describe Banzai::Filter::SyntaxHighlightFilter do
 
   context "when a valid language is specified" do
     it "highlights as that language" do
-        result = if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-                   filter('<pre lang="ruby"><code>def fun end</code></pre>')
-                 else
-                   filter('<pre><code lang="ruby">def fun end</code></pre>')
-                 end
+      result = filter('<pre lang="ruby"><code>def fun end</code></pre>')
 
       expect(result.to_html.delete("\n")).to eq('<div class="gl-relative markdown-code-block js-markdown-code"><pre class="code highlight js-syntax-highlight language-ruby" lang="ruby" v-pre="true"><code><span id="LC1" class="line" lang="ruby"><span class="k">def</span> <span class="nf">fun</span> <span class="k">end</span></span></code></pre><copy-code></copy-code></div>')
     end
@@ -54,11 +49,7 @@ RSpec.describe Banzai::Filter::SyntaxHighlightFilter do
 
   context "when an invalid language is specified" do
     it "highlights as plaintext" do
-        result = if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-                   filter('<pre lang="gnuplot"><code>This is a test</code></pre>')
-                 else
-                   filter('<pre><code lang="gnuplot">This is a test</code></pre>')
-                 end
+      result = filter('<pre lang="gnuplot"><code>This is a test</code></pre>')
 
       expect(result.to_html.delete("\n")).to eq('<div class="gl-relative markdown-code-block js-markdown-code"><pre class="code highlight js-syntax-highlight language-plaintext" lang="plaintext" v-pre="true"><code><span id="LC1" class="line" lang="plaintext">This is a test</span></code></pre><copy-code></copy-code></div>')
     end
@@ -73,11 +64,7 @@ RSpec.describe Banzai::Filter::SyntaxHighlightFilter do
     %w(math mermaid plantuml suggestion).each do |lang|
       context "when #{lang} is specified" do
         it "highlights as plaintext but with the correct language attribute and class" do
-            result = if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-                       filter(%{<pre lang="#{lang}"><code>This is a test</code></pre>})
-                     else
-                       filter(%{<pre><code lang="#{lang}">This is a test</code></pre>})
-                     end
+          result = filter(%{<pre lang="#{lang}"><code>This is a test</code></pre>})
 
           expect(result.to_html.delete("\n")).to eq(%{<div class="gl-relative markdown-code-block js-markdown-code"><pre class="code highlight js-syntax-highlight language-#{lang}" lang="#{lang}" v-pre="true"><code><span id="LC1" class="line" lang="#{lang}">This is a test</span></code></pre><copy-code></copy-code></div>})
         end
@@ -87,34 +74,18 @@ RSpec.describe Banzai::Filter::SyntaxHighlightFilter do
 
       context "when #{lang} has extra params" do
         let(:lang_params) { 'foo-bar-kux' }
-
-          let(:xss_lang) do
-            if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-              "#{lang} data-meta=\"foo-bar-kux\"&lt;script&gt;alert(1)&lt;/script&gt;"
-            else
-              "#{lang}#{described_class::LANG_PARAMS_DELIMITER}&lt;script&gt;alert(1)&lt;/script&gt;"
-            end
-          end
+        let(:xss_lang) { "#{lang} data-meta=\"foo-bar-kux\"&lt;script&gt;alert(1)&lt;/script&gt;" }
 
         it "includes data-lang-params tag with extra information" do
-            result = if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-                       filter(%{<pre lang="#{lang}" data-meta="#{lang_params}"><code>This is a test</code></pre>})
-                     else
-                       filter(%{<pre><code lang="#{lang}#{delimiter}#{lang_params}">This is a test</code></pre>})
-                     end
+          result = filter(%{<pre lang="#{lang}" data-meta="#{lang_params}"><code>This is a test</code></pre>})
 
           expect(result.to_html.delete("\n")).to eq(%{<div class="gl-relative markdown-code-block js-markdown-code"><pre class="code highlight js-syntax-highlight language-#{lang}" lang="#{lang}" #{data_attr}="#{lang_params}" v-pre="true"><code><span id="LC1" class="line" lang="#{lang}">This is a test</span></code></pre><copy-code></copy-code></div>})
         end
 
         include_examples "XSS prevention", lang
 
-          if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
         include_examples "XSS prevention",
                          "#{lang} data-meta=\"foo-bar-kux\"&lt;script&gt;alert(1)&lt;/script&gt;"
-          else
-            include_examples "XSS prevention",
-                             "#{lang}#{described_class::LANG_PARAMS_DELIMITER}&lt;script&gt;alert(1)&lt;/script&gt;"
-          end
 
         include_examples "XSS prevention",
           "#{lang} data-meta=\"foo-bar-kux\"<script>alert(1)</script>"
@@ -131,15 +102,9 @@ RSpec.describe Banzai::Filter::SyntaxHighlightFilter do
 
       context 'when delimiter is space' do
         it 'delimits on the first appearance' do
-            if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
           result = filter(%{<pre lang="#{lang}" data-meta="#{lang_params} more-things"><code>This is a test</code></pre>})
 
           expect(result.to_html.delete("\n")).to eq(expected_result)
-            else
-              result = filter(%{<pre><code lang="#{lang}#{delimiter}#{lang_params}#{delimiter}more-things">This is a test</code></pre>})
-
-              expect(result.to_html.delete("\n")).to eq(%{<div class="gl-relative markdown-code-block js-markdown-code"><pre class="code highlight js-syntax-highlight language-#{lang}" lang="#{lang}" #{data_attr}="#{lang_params}#{delimiter}more-things" v-pre="true"><code><span id="LC1" class="line" lang="#{lang}">This is a test</span></code></pre><copy-code></copy-code></div>})
-            end
         end
       end
 
@@ -147,11 +112,7 @@ RSpec.describe Banzai::Filter::SyntaxHighlightFilter do
         it 'delimits on the first appearance' do
           result = filter(%{<pre lang="#{lang}#{delimiter}#{lang_params} more-things"><code>This is a test</code></pre>})
 
-            if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
           expect(result.to_html.delete("\n")).to eq(expected_result)
-            else
-              expect(result.to_html.delete("\n")).to eq(%{<div class="gl-relative markdown-code-block js-markdown-code"><pre class=\"code highlight js-syntax-highlight language-plaintext\" lang=\"plaintext\" v-pre=\"true\"><code><span id=\"LC1\" class=\"line\" lang=\"plaintext\">This is a test</span></code></pre><copy-code></copy-code></div>})
-            end
         end
       end
     end
@@ -173,11 +134,7 @@ RSpec.describe Banzai::Filter::SyntaxHighlightFilter do
     end
 
     it "highlights as plaintext" do
-        result = if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-                   filter('<pre lang="ruby"><code>This is a test</code></pre>')
-                 else
-                   filter('<pre><code lang="ruby">This is a test</code></pre>')
-                 end
+      result = filter('<pre lang="ruby"><code>This is a test</code></pre>')
 
       expect(result.to_html.delete("\n")).to eq('<div class="gl-relative markdown-code-block js-markdown-code"><pre class="code highlight js-syntax-highlight" lang="" v-pre="true"><code><span id="LC1" class="line" lang="">This is a test</span></code></pre><copy-code></copy-code></div>')
     end
@@ -200,21 +157,4 @@ RSpec.describe Banzai::Filter::SyntaxHighlightFilter do
 
     include_examples "XSS prevention", "ruby"
   end
-  end
-
-  context 'using ruby-based HTML renderer' do
-    before do
-      stub_feature_flags(use_cmark_renderer: false)
-    end
-
-    it_behaves_like 'renders correct markdown'
-  end
-
-  context 'using c-based HTML renderer' do
-    before do
-      stub_feature_flags(use_cmark_renderer: true)
-    end
-
-    it_behaves_like 'renders correct markdown'
-  end
 end

spec/lib/banzai/pipeline/full_pipeline_spec.rb

@@ -65,47 +65,6 @@ RSpec.describe Banzai::Pipeline::FullPipeline do
 
       expect(html.lines.map(&:strip).join("\n")).to eq filtered_footnote.strip
     end
-
-    context 'using ruby-based HTML renderer' do
-      let(:html)       { described_class.to_html(footnote_markdown, project: project) }
-      let(:identifier) { html[/.*fnref1-(\d+).*/, 1] }
-      let(:footnote_markdown) do
-        <<~EOF
-          first[^1] and second[^second] and twenty[^twenty]
-          [^1]: one
-          [^second]: two
-          [^twenty]: twenty
-        EOF
-      end
-
-      let(:filtered_footnote) do
-        <<~EOF
-          <p dir="auto">first<sup class="footnote-ref"><a href="#fn1-#{identifier}" id="fnref1-#{identifier}">1</a></sup> and second<sup class="footnote-ref"><a href="#fn2-#{identifier}" id="fnref2-#{identifier}">2</a></sup> and twenty<sup class="footnote-ref"><a href="#fn3-#{identifier}" id="fnref3-#{identifier}">3</a></sup></p>
-
-          <section class="footnotes"><ol>
-          <li id="fn1-#{identifier}">
-          <p>one <a href="#fnref1-#{identifier}" class="footnote-backref"><gl-emoji title="leftwards arrow with hook" data-name="leftwards_arrow_with_hook" data-unicode-version="1.1">↩</gl-emoji></a></p>
-          </li>
-          <li id="fn2-#{identifier}">
-          <p>two <a href="#fnref2-#{identifier}" class="footnote-backref"><gl-emoji title="leftwards arrow with hook" data-name="leftwards_arrow_with_hook" data-unicode-version="1.1">↩</gl-emoji></a></p>
-          </li>
-          <li id="fn3-#{identifier}">
-          <p>twenty <a href="#fnref3-#{identifier}" class="footnote-backref"><gl-emoji title="leftwards arrow with hook" data-name="leftwards_arrow_with_hook" data-unicode-version="1.1">↩</gl-emoji></a></p>
-          </li>
-          </ol></section>
-        EOF
-      end
-
-      before do
-        stub_feature_flags(use_cmark_renderer: false)
-      end
-
-      it 'properly adds the necessary ids and classes' do
-        stub_commonmark_sourcepos_disabled
-
-        expect(html.lines.map(&:strip).join("\n")).to eq filtered_footnote
-      end
-    end
   end
 
   describe 'links are detected as malicious' do

spec/lib/banzai/pipeline/plain_markdown_pipeline_spec.rb

@@ -5,8 +5,10 @@ require 'spec_helper'
 RSpec.describe Banzai::Pipeline::PlainMarkdownPipeline do
   using RSpec::Parameterized::TableSyntax
 
-  shared_examples_for 'renders correct markdown' do
-    describe 'CommonMark tests', :aggregate_failures do
+  describe 'backslash escapes', :aggregate_failures do
+    let_it_be(:project) { create(:project, :public) }
+    let_it_be(:issue)   { create(:issue, project: project) }
+
     it 'converts all reference punctuation to literals' do
       reference_chars = Banzai::Filter::MarkdownPreEscapeFilter::REFERENCE_CHARACTERS
       markdown = reference_chars.split('').map {|char| char.prepend("\\") }.join
@@ -71,11 +73,7 @@ RSpec.describe Banzai::Pipeline::PlainMarkdownPipeline do
       let(:markdown) { %Q(``` foo\\@bar\nfoo\n```) }
 
       it 'renders correct html' do
-          if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
         correct_html_included(markdown, %Q(<pre data-sourcepos="1:1-3:3" lang="foo@bar"><code>foo\n</code></pre>))
-          else
-            correct_html_included(markdown, %Q(<code lang="foo@bar">foo\n</code>))
-          end
       end
 
       where(:markdown, :expected) do
@@ -88,11 +86,6 @@ RSpec.describe Banzai::Pipeline::PlainMarkdownPipeline do
       end
     end
   end
-  end
-
-  describe 'backslash escapes' do
-    let_it_be(:project) { create(:project, :public) }
-    let_it_be(:issue)   { create(:issue, project: project) }
 
   def correct_html_included(markdown, expected)
     result = described_class.call(markdown, {})
@@ -101,21 +94,4 @@ RSpec.describe Banzai::Pipeline::PlainMarkdownPipeline do
 
     result
   end
-
-    context 'using ruby-based HTML renderer' do
-      before do
-        stub_feature_flags(use_cmark_renderer: false)
-      end
-
-      it_behaves_like 'renders correct markdown'
-    end
-
-    context 'using c-based HTML renderer' do
-      before do
-        stub_feature_flags(use_cmark_renderer: true)
-      end
-
-      it_behaves_like 'renders correct markdown'
-    end
-  end
 end

spec/lib/gitlab/asciidoc_spec.rb

@@ -11,7 +11,6 @@ module Gitlab
       allow_any_instance_of(ApplicationSetting).to receive(:current).and_return(::ApplicationSetting.create_from_defaults)
     end
 
-    shared_examples_for 'renders correct asciidoc' do
     context "without project" do
       let(:input) { '<b>ascii</b>' }
       let(:context) { {} }
@@ -95,12 +94,7 @@ module Gitlab
         # Move this test back to the items hash when removing `use_cmark_renderer` feature flag.
         it "does not convert dangerous fenced code with inline script into HTML" do
           input = '```mypre"><script>alert(3)</script>'
-            output =
-              if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-                "<div>\n<div>\n<div class=\"gl-relative markdown-code-block js-markdown-code\">\n<pre class=\"code highlight js-syntax-highlight language-plaintext\" lang=\"plaintext\" v-pre=\"true\"><code></code></pre>\n<copy-code></copy-code>\n</div>\n</div>\n</div>"
-              else
-                "<div>\n<div>\n<div class=\"gl-relative markdown-code-block js-markdown-code\">\n<pre class=\"code highlight js-syntax-highlight language-plaintext\" lang=\"plaintext\" v-pre=\"true\"><code><span id=\"LC1\" class=\"line\" lang=\"plaintext\">\"&gt;</span></code></pre>\n<copy-code></copy-code>\n</div>\n</div>\n</div>"
-              end
+          output = "<div>\n<div>\n<div class=\"gl-relative markdown-code-block js-markdown-code\">\n<pre class=\"code highlight js-syntax-highlight language-plaintext\" lang=\"plaintext\" v-pre=\"true\"><code></code></pre>\n<copy-code></copy-code>\n</div>\n</div>\n</div>"
 
           expect(render(input, context)).to include(output)
         end
@@ -851,23 +845,6 @@ module Gitlab
         end
       end
     end
-    end
-
-    context 'using ruby-based HTML renderer' do
-      before do
-        stub_feature_flags(use_cmark_renderer: false)
-      end
-
-      it_behaves_like 'renders correct asciidoc'
-    end
-
-    context 'using c-based HTML renderer' do
-      before do
-        stub_feature_flags(use_cmark_renderer: true)
-      end
-
-      it_behaves_like 'renders correct asciidoc'
-    end
 
     def render(*args)
       described_class.render(*args)

spec/support/helpers/stub_gitlab_calls.rb

@@ -92,12 +92,7 @@ module StubGitlabCalls
   end
 
   def stub_commonmark_sourcepos_disabled
-    render_options =
-      if Feature.enabled?(:use_cmark_renderer, default_enabled: :yaml)
-        Banzai::Filter::MarkdownEngines::CommonMark::RENDER_OPTIONS_C
-      else
-        Banzai::Filter::MarkdownEngines::CommonMark::RENDER_OPTIONS_RUBY
-      end
+    render_options = Banzai::Filter::MarkdownEngines::CommonMark::RENDER_OPTIONS
 
     allow_any_instance_of(Banzai::Filter::MarkdownEngines::CommonMark)
       .to receive(:render_options)