jekyll-link-decorator 1.7.0 → 2.0.0

data/lib/jekyll-link-decorator/instrumentation.rb

@@ -6,10 +6,12 @@ module Jekyll
     #
     # All tracing is configured centrally in TRACED_METHODS — no span code lives
     # in business logic classes. To add a span: append one entry. To rename a
-    # method: update the one entry. When a method is removed from its class the
-    # stale entry raises NoMethodError in tests, signalling the entry to delete.
+    # method: update the one entry. A stale entry, naming a method its class
+    # no longer defines with that visibility, fails the instrumentation spec
+    # that checks every row.
     #
-    # Requires opentelemetry-api at runtime; falls back to a no-op if absent.
+    # Uses OpenTelemetry once it is loaded (setup_sdk! loads it through
+    # opentelemetry-sdk); otherwise spans go to a no-op tracer.
     # Users opt in to real tracing by adding opentelemetry-sdk and
     # opentelemetry-exporter-otlp to their site Gemfile and exporting:
     #
@@ -18,6 +20,17 @@ module Jekyll
     module Instrumentation
       TRACER_NAME = 'jekyll-link-decorator'
 
+      # Secrets in a URL, each with its replacement: the user:password@
+      # part, after a scheme or at the start of the endpoint, and the query
+      # string. The OTLP exporter's invalid-url error echoes the whole
+      # endpoint, so setup_sdk! removes them before logging. The user:password
+      # match is greedy up to the last @ before the path, so a password
+      # containing @ is removed whole.
+      URL_SECRETS = [
+        [%r{(\A|//|\s)[^\s/]*@}, '\1[REDACTED]@'],
+        [/\?[^\s#]*/, '?[REDACTED]']
+      ].freeze
+
       # Central instrumentation registry.
       #
       # Each row: [class_name, method_type, method_name, span_name, attribute_proc]
@@ -29,38 +42,76 @@ module Jekyll
       #
       # attribute_proc: ->(span, this, args, result) or nil
       #   span   — OTel span (or NoopSpan); call span.set_attribute after super returns
-      #   this   — receiver object (instance or nil for class methods)
+      #   this   — receiver: the instance, or the class/module for :class rows
       #   args   — positional args array as passed to the method
       #   result — return value of the original method
+      #   An error raised by the proc is recorded on the span, which is marked
+      #   as failed; it is never re-raised.
       # :nocov: — attribute procs are configuration data; coverage comes from integration tests
       TRACED_METHODS = [
-        # decorate_html is the converter's entry point — one span per page converted
-        ['Jekyll::Converters::LinkDecorator', :instance, :decorate_html, 'link.decorate_page',
+        # The post_convert hook: one root span per page or document Jekyll
+        # converts, naming the page and, in link.decorated, whether it went
+        # through the decorator. A decoration failure leaves link.decorated
+        # true; the error shows on link.html_render instead.
+        ['Jekyll::LinkDecorator::PostConvertHook', :class, :call, 'link.page_decorate',
+         lambda { |span, _this, args, result|
+           doc = args[0]
+           span.set_attribute('link.page_path', doc.relative_path.to_s)
+           span.set_attribute('link.page_url', doc.url.to_s)
+           span.set_attribute('link.decorated', result == true)
+         }],
+
+        # decorate_html is the Decorator's entry point — a child of
+        # link.page_decorate for each decorated page, and a root span for
+        # each decorate_links filter call
+        ['Jekyll::LinkDecorator::Decorator', :instance, :decorate_html, 'link.html_decorate',
          lambda { |span, _this, args, result|
            span.set_attribute('link.html_size_bytes', args[0].to_s.bytesize)
            span.set_attribute('link.output_size_bytes', result.to_s.bytesize)
          }],
 
-        ['Jekyll::Converters::LinkDecorator', :instance, :apply_link_styles, 'link.style_apply',
+        ['Jekyll::LinkDecorator::Decorator', :instance, :apply_link_styles, 'link.style_apply',
          lambda { |span, _this, args, _result|
            doc = args[0]
-           span.set_attribute('link.styled_link_count', doc.respond_to?(:css) ? doc.css('a:not(.btn)').size : 0)
+           span.set_attribute('link.styled_link_count',
+                              doc.respond_to?(:css) ? doc.css(Decorator::DECORATED_LINKS).size : 0)
          }],
 
-        ['Jekyll::Converters::LinkDecorator', :instance, :add_external_link_features,
-         'link.external_link_features',
-         lambda { |span, _this, args, _result|
+        ['Jekyll::LinkDecorator::Decorator', :instance, :add_external_link_features, 'link.external_link_apply',
+         # link.external_link_count: the links the phase treats as
+         # cross-domain, which get target and the icon. Authors may set
+         # target="_blank" on their own links too, so the rel pass protects
+         # more: link.new_tab_link_count counts those, with or without a
+         # site url.
+         lambda { |span, this, args, _result|
            doc = args[0]
+           site_domain = this.extract_site_domain
+           links = doc.respond_to?(:css) ? this.external_link_candidates(doc, site_domain) : []
            span.set_attribute('link.external_link_count',
-                              doc.respond_to?(:css) ? doc.css('a[target="_blank"]').size : 0)
+                              links.count { |link| this.cross_domain_external_link?(link, site_domain) })
+           new_tab = doc.respond_to?(:css) ? doc.css(Decorator::DECORATED_LINKS) : []
+           span.set_attribute('link.new_tab_link_count',
+                              new_tab.count { |link| this.new_tab_link?(link) })
          }],
 
-        # add_heading_anchors is private on LinkDecorator; visibility is preserved on the wrapper
-        ['Jekyll::Converters::LinkDecorator', :private, :add_heading_anchors, 'link.heading_anchors', nil]
+        # render is decorate_html's body, outside its rescue, so this span
+        # records failures in settings, parsing, or any phase
+        ['Jekyll::LinkDecorator::Decorator', :private, :render, 'link.html_render', nil],
+
+        # add_heading_anchors is private on Decorator; visibility is preserved on the wrapper.
+        # Counts the headings carrying an anchor after the phase, including
+        # any the author wrote, which the phase leaves as they are; with
+        # heading anchors off the phase adds none.
+        ['Jekyll::LinkDecorator::Decorator', :private, :add_heading_anchors, 'link.heading_anchor_add',
+         lambda { |span, this, args, _result|
+           doc = args[0]
+           headings = doc.respond_to?(:css) ? doc.css(Decorator::HEADINGS) : []
+           span.set_attribute('link.heading_anchor_count', headings.count { |heading| this.anchored_heading?(heading) })
+         }]
       ].freeze
       # :nocov:
 
-      # Returns the active OTel tracer, or a no-op tracer if opentelemetry-api is absent.
+      # Returns the active OTel tracer, or a no-op tracer if OpenTelemetry is not loaded.
       def self.tracer
         @tracer ||=
           if defined?(OpenTelemetry)
@@ -90,10 +141,10 @@ module Jekyll
 
       # Returns true when OTel is requested via standard environment variables.
       #
-      # install! guards on this so the prepend wrappers are only applied when
-      # a real exporter is configured. In CI and local tests (no OTel env vars)
-      # business logic classes are untouched, keeping allow_any_instance_of stubs
-      # and other RSpec mechanics fully functional.
+      # The plugin calls install! at load time only when this returns true,
+      # so without OTel env vars (as in CI and local tests) business logic
+      # classes stay unwrapped, keeping allow_any_instance_of stubs and other
+      # RSpec mechanics fully functional.
       def self.enabled?
         ENV.key?('OTEL_EXPORTER_OTLP_ENDPOINT') || ENV.key?('OTEL_SERVICE_NAME')
       end
@@ -117,16 +168,21 @@ module Jekyll
       #
       # Called from install! so that spans are exported to the configured backend
       # without requiring sites to add a separate initializer. Silently no-ops when
-      # opentelemetry-sdk or opentelemetry-exporter-otlp is not installed.
+      # opentelemetry-sdk or opentelemetry-exporter-otlp is not installed. Any
+      # other setup error, such as the exporter rejecting a malformed
+      # OTEL_EXPORTER_OTLP_* variable, logs one warning, with any URL
+      # secrets redacted (URL_SECRETS), and leaves spans unexported:
+      # install! runs at plugin load, so raising would fail the build.
       #
       # SimpleSpanProcessor is used instead of the SDK default (BatchSpanProcessor)
       # because Jekyll is a short-lived CLI process. BatchSpanProcessor exports on a
-      # 5-second schedule; outer spans that close last (decorate_page) are silently
+      # 5-second schedule; outer spans that close last (link.page_decorate) are silently
       # dropped when the process exits before the next flush. Simple exports each
       # span synchronously the moment it closes, guaranteeing no span loss.
       #
       # jekyll-theme-centos loads several instrumented plugins in one process
-      # (jekyll-l10n uses the 'l10n.' tracer, jekyll-minify uses 'minify.'), and
+      # (jekyll-l10n and jekyll-minify each use their own tracer, with 'l10n.'
+      # and 'minify.' span names), and
       # OpenTelemetry::SDK.configure unconditionally overwrites the global
       # tracer_provider on every call — so only the first plugin to reach this
       # method (see sdk_already_configured?) actually configures the SDK; every
@@ -148,6 +204,15 @@ module Jekyll
       rescue LoadError
         nil
         # :nocov:
+      rescue StandardError => e
+        warn_sdk_setup_failed(e)
+      end
+
+      # Logs why setup_sdk! failed, with any URL secrets redacted.
+      def self.warn_sdk_setup_failed(error)
+        reason = URL_SECRETS.reduce(error.message) { |message, (pattern, mask)| message.gsub(pattern, mask) }
+        Jekyll.logger.warn 'LinkDecorator:', "OpenTelemetry SDK setup failed, spans will not be exported: #{reason}"
+        nil
       end
 
       # True when some plugin (this one or another) already installed a real
@@ -157,7 +222,7 @@ module Jekyll
           OpenTelemetry.tracer_provider.is_a?(OpenTelemetry::SDK::Trace::TracerProvider)
       end
 
-      # Resolves a dot-separated class name to a constant; returns nil on NameError.
+      # Resolves a ::-separated class name to a constant; returns nil on NameError.
       def self.resolve_class(name)
         name.split('::').reduce(Object) { |m, c| m.const_get(c) }
       rescue NameError
@@ -174,17 +239,26 @@ module Jekyll
       end
 
       # Builds an anonymous module that wraps each listed method in a span.
+      #
+      # An error raised by the method propagates unchanged. The wrapper does
+      # not record it: opentelemetry-api's Tracer#in_span already records it
+      # and sets the span's error status, so recording here too would add a
+      # second exception event.
       def self.build_wrapper_module(entries)
         Module.new do
           entries.each do |_class_name, method_type, method_name, span_name, attr_proc|
             define_method(method_name) do |*args, **kwargs, &blk|
               Instrumentation.instrument(span_name) do |span|
                 result = super(*args, **kwargs, &blk)
-                attr_proc&.call(span, self, args, result)
+                begin
+                  attr_proc&.call(span, self, args, result)
+                rescue StandardError => e
+                  # Tracing must never fail a build: keep the result, report the bug on the span.
+                  # in_span never sees this error, so mark the span failed here.
+                  span.record_exception(e)
+                  span.status = OpenTelemetry::Trace::Status.error(e.message) if defined?(OpenTelemetry::Trace::Status)
+                end
                 result
-              rescue StandardError => e
-                span.record_exception(e)
-                raise
               end
             end
             private method_name if method_type == :private
@@ -192,7 +266,8 @@ module Jekyll
         end
       end
 
-      private_class_method :build_wrapper_module, :prepend_wrappers, :setup_sdk!, :sdk_already_configured?
+      private_class_method :build_wrapper_module, :prepend_wrappers, :setup_sdk!, :warn_sdk_setup_failed,
+                           :sdk_already_configured?
 
       # No-op tracer used when opentelemetry-api is not loaded.
       class NoopTracer

data/lib/jekyll-link-decorator/post_convert_hook.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module LinkDecorator
+    # Decorates each page and document right after Jekyll converts it and
+    # before layouts apply, which is where :post_convert fires. Only content
+    # the stock Markdown converter handled is decorated, so every extension
+    # listed in the site's markdown_ext qualifies, not just `.md`.
+    module PostConvertHook
+      # Returns true when it handed doc to the decorator, false when it left
+      # doc alone (not Markdown, or the plugin is disabled). The trace span
+      # records it as link.decorated. true does not mean the page came out
+      # decorated: decorate_html never raises, so a failure leaves doc as it
+      # was, logs a LinkDecorator Error:, and shows as an error on the
+      # link.html_render span.
+      def self.call(doc)
+        return false unless markdown?(doc) && Configuration.for(doc.site.config)['enabled']
+
+        doc.content = Decorator.new(doc.site.config).decorate_html(doc.content)
+        true
+      end
+
+      def self.markdown?(doc)
+        doc.site.find_converter_instance(Jekyll::Converters::Markdown).matches(doc.extname)
+      end
+      private_class_method :markdown?
+    end
+  end
+end
+
+Jekyll::Hooks.register(%i[pages documents], :post_convert) { |doc| Jekyll::LinkDecorator::PostConvertHook.call(doc) }

data/lib/jekyll-link-decorator/version.rb

@@ -3,9 +3,10 @@
 module Jekyll
   module LinkDecorator
     # Autogenerated by jekyll-link-decorator.gemspec.rb — do not edit by hand.
-    # Regenerated alongside the gemspec on every `make gemspec` run (locally
-    # or in CI), so it always matches spec.version in the built gem. Any
-    # hand edit is overwritten on the next run.
-    VERSION = '1.7.0'
+    # Regenerated alongside the gemspec on every
+    # `make jekyll-link-decorator.gemspec` run (locally or in CI), so it
+    # always matches spec.version in the built gem. Any hand edit is
+    # overwritten on the next run.
+    VERSION = '2.0.0'
   end
 end

data/lib/jekyll-link-decorator.rb

@@ -6,334 +6,34 @@
 # default classes; links carrying a `.btn` class are left untouched.
 #
 # For links to a different domain than the site's own (site.url), it adds
-# target="_blank", the rel="noopener noreferrer" security attributes, and an
-# external-link icon at the end of the link text.
+# target="_blank" and an external-link icon at the end of the link text.
+# Every link that opens in a new tab, including one the author marked
+# target="_blank", gets rel="noopener noreferrer".
 #
-# It can also inject a permalink icon into each heading (h1-h6) so every
+# It also injects a permalink icon into each heading (h1-h6) so every
 # section gets a shareable URL.
 #
-# Turn these on and customize them from `_config.yml` with the
-# `with_link_decorator`, `with_link_decorator_data`, `with_heading_anchor`,
-# and `with_heading_anchor_data` keys. See docs/configuration.md for the
-# full key reference, defaults, and worked `_config.yml` examples.
+# Every feature is on by default. Turn features off or customize them from
+# `_config.yml` under the `jekyll_link_decorator` key (heading anchors
+# under its nested `heading_anchor` key). See docs/configuration.md for
+# the full key reference, defaults, and worked `_config.yml` examples.
 #
 # A link that already carries its own Bootstrap link-utility class (see
-# LINK_CLASS_FAMILIES below) keeps that class instead of getting the
-# plugin's default for the same family.
+# LINK_CLASS_FAMILIES in jekyll-link-decorator/decorator.rb) keeps that
+# class instead of getting the plugin's default for the same family.
+#
+# Pages and documents are decorated by a :post_convert hook (see
+# jekyll-link-decorator/post_convert_hook.rb) after Jekyll's own Markdown
+# conversion; the decorate_links Liquid filter below covers HTML built
+# elsewhere, such as markdownified data fields.
 
-require 'nokogiri'
 require_relative 'jekyll-link-decorator/version'
 require_relative 'jekyll-link-decorator/instrumentation'
-
-EXISTING_ICON_SELECTORS = [
-  'i[class*="fa-external-link"]',
-  'i[class*="up-right-from-square"]',
-  'svg[data-icon="external-link"]',
-  'svg[data-icon="up-right-from-square"]',
-  'svg[data-icon="arrow-up-right-from-square"]'
-].freeze
+require_relative 'jekyll-link-decorator/configuration'
+require_relative 'jekyll-link-decorator/decorator'
+require_relative 'jekyll-link-decorator/post_convert_hook'
 
 module Jekyll
-  module Converters
-    # Applies CSS classes to <a> tags based on context (e.g., inside an alert
-    # box) via Nokogiri CSS selectors, excluding buttons. Also adds
-    # external-link icons for cross-domain links.
-    class LinkDecorator < Jekyll::Converters::Markdown
-      DEFAULT_LINK_CLASSES = 'link link-offset-3 link-offset-3-hover link-underline-primary ' \
-                             'link-underline-opacity-0 link-underline-opacity-100-hover focus-ring'
-      DEFAULT_ALERT_LINK_CLASSES = 'alert-link focus-ring'
-
-      # Bootstrap 5 link-utility "families" whose defaults must not silently
-      # override an author's own explicit class from the same family — see
-      # classes_to_add_for.
-      #
-      # Each entry carries a single `pattern:` regex, anchored \A...\z and
-      # matched per class token (not against the whole class string), so a
-      # compound name like "social-link-danger" or "sidebar-link-offset-2" is
-      # never mistaken for an override.
-      #
-      # Enumerated families (offset, both opacity families) lock to Bootstrap's
-      # fixed value set, so an out-of-range value like "link-opacity-42" isn't
-      # recognized as an override either. Color and focus-ring families
-      # (link-{color}, link-underline-{color}, focus-ring(-{color})?) stay
-      # generic (\S+) since Bootstrap themes can define arbitrary custom color names.
-      LINK_CLASS_FAMILIES = [
-        { # link-{color}, e.g. link-primary, link-body-emphasis (bare colored-link class;
-          # excludes link-underline-*, link-offset-*, and link-opacity-* families)
-          pattern: /\Alink-(?!underline\b|offset-|opacity-)\S+\z/
-        },
-        { # link-underline-{color}, e.g. link-underline-success (excludes -opacity-*)
-          pattern: /\Alink-underline-(?!opacity)\S+\z/
-        },
-        { # link-offset-{1,2,3}, each with an optional -hover variant
-          pattern: /\Alink-offset-[123](-hover)?\z/
-        },
-        { # link-underline-opacity-{0,10,25,50,75,100}, each with an optional -hover variant
-          pattern: /\Alink-underline-opacity-(?:0|10|25|50|75|100)(-hover)?\z/
-        },
-        { # link-opacity-{10,25,50,75,100}, each with an optional -hover variant
-          # (controls link-text opacity, distinct from link-underline-opacity-*)
-          pattern: /\Alink-opacity-(?:10|25|50|75|100)(-hover)?\z/
-        },
-        { # focus-ring and focus-ring-{color}, e.g. focus-ring-primary, focus-ring-success
-          # Bootstrap 5.3 focus-ring has no hover, offset, or opacity variants — only bare
-          # and color forms; color stays generic (\S+) for custom theme colors
-          pattern: /\Afocus-ring(-\S+)?\z/
-        }
-      ].freeze
-      DEFAULT_EXTERNAL_LINK_ICON = true
-      DEFAULT_EXTERNAL_LINK_ICON_EXCLUDED_TAGS = [].freeze
-      DEFAULT_HEADING_ANCHOR      = false
-      DEFAULT_HEADING_ANCHOR_ICON = 'heading-anchor-hash'
-
-      def self.name
-        'LinkDecorator'
-      end
-
-      # Returns a URL's domain, stripped of scheme and path.
-      # "https://example.com/path?query=1#anchor" -> "example.com"
-      def extract_domain(url)
-        return '' if url.nil? || url.empty?
-
-        domain = url.sub(%r{^https?://}, '')
-        domain = domain.split(%r{[/?#]}).first
-        domain.downcase
-      end
-
-      # True when this link needs the external-link icon: an absolute,
-      # cross-domain link that doesn't already have one.
-      def is_external_different_domain_link?(link, site_domain)
-        return false unless absolute_different_domain?(link, site_domain)
-        return false if EXISTING_ICON_SELECTORS.any? { |sel| link.css(sel).any? }
-
-        true
-      end
-
-      # True when href is an absolute http(s) URL on a domain other than
-      # site_domain. Shared by is_external_different_domain_link? and
-      # cross_domain_external_link? below.
-      def absolute_different_domain?(link, site_domain)
-        href = link['href'].to_s
-        return false unless %r{^https?://}.match?(href)
-
-        link_domain = extract_domain(href)
-        return false if link_domain == site_domain || link_domain.empty?
-
-        true
-      end
-      private :absolute_different_domain?
-
-      # True when this link needs target="_blank": absolute and cross-domain.
-      # Relative URLs (/, ../) are always treated as internal.
-      def cross_domain_external_link?(link, site_domain)
-        href = link['href'].to_s
-        return false if %r{^(/|\.\.)}.match?(href)
-
-        absolute_different_domain?(link, site_domain)
-      end
-
-      # Sets target="_blank" on a cross-domain link, unless it already has a target.
-      def add_external_target_blank(link, site_domain)
-        return if link['target'].to_s.strip != ''
-        return unless cross_domain_external_link?(link, site_domain)
-
-        link['target'] = '_blank'
-      end
-
-      # Adds rel="noopener noreferrer" to a target="_blank" link, keeping any
-      # rel values the author already set.
-      def add_external_target_protection(link)
-        target = link['target'].to_s
-        return unless target == '_blank'
-
-        existing_rel = link['rel'].to_s.strip
-        rel_values = existing_rel.empty? ? [] : existing_rel.split(/\s+/)
-        rel_values << 'noopener' unless rel_values.include?('noopener')
-        rel_values << 'noreferrer' unless rel_values.include?('noreferrer')
-
-        link['rel'] = rel_values.join(' ')
-      end
-
-      def matches(ext)
-        ext =~ /^\.md$/i
-      end
-
-      def output_ext(_ext)
-        '.html'
-      end
-
-      def convert(content)
-        html = super
-        decorate_html(html)
-      end
-
-      def decorate_html(html)
-        enabled = @config.key?('with_link_decorator') ? @config['with_link_decorator'] : true
-        config = @config['with_link_decorator_data'] || {}
-
-        return html unless plugin_enabled?(enabled)
-
-        doc = Nokogiri::HTML::DocumentFragment.parse(html)
-
-        apply_link_styles(doc, config)
-        add_external_link_features(doc, config)
-        add_heading_anchors(doc)
-
-        doc.to_html
-      rescue StandardError => e
-        Jekyll.logger.error 'LinkDecorator Error:',
-                            "An error occurred during link decoration: #{e.message}"
-        Jekyll.logger.error 'Backtrace:', e.backtrace.join("\n")
-
-        html
-      end
-
-      # Logs a notice when disabled; returns the given enabled flag unchanged.
-      # The caller (decorate_html) decides what "enabled" defaults to.
-      def plugin_enabled?(enabled)
-        unless enabled
-          Jekyll.logger.info 'LinkDecorator:',
-                             'Disabled via configuration. Skipping custom link modification.'
-        end
-        enabled
-      end
-
-      # Applies alert_classes to links inside an .alert box, default_classes
-      # to every other link.
-      def apply_link_styles(doc, config)
-        default_classes = config.fetch('default_link_classes', DEFAULT_LINK_CLASSES)
-        alert_classes   = config.fetch('alert_link_classes',   DEFAULT_ALERT_LINK_CLASSES)
-
-        doc.css('p.alert a:not(.btn), blockquote.alert a:not(.btn)').each do |link|
-          add_classes(link, alert_classes)
-        end
-
-        doc.css('a:not(.btn)').each do |link|
-          next if link.ancestors('p.alert, blockquote.alert').any?
-
-          add_classes(link, classes_to_add_for(link, default_classes))
-        end
-      end
-
-      # Drops any default class belonging to a family the link already customizes,
-      # so the author's explicit class wins instead of losing silently to a
-      # same-specificity Bootstrap !important rule declared later in the sheet.
-      # See LINK_CLASS_FAMILIES for how each family's pattern is matched.
-      def classes_to_add_for(link, default_classes)
-        link_classes = link['class'].to_s.split
-        LINK_CLASS_FAMILIES.reduce(default_classes) do |classes, family|
-          next classes unless link_classes.any? { |token| token.match?(family[:pattern]) }
-
-          classes.split.grep_v(family[:pattern]).join(' ')
-        end
-      end
-
-      def add_classes(link, classes_string)
-        classes_string.split.each { |cls| link.add_class(cls) }
-      end
-
-      # Adds target="_blank", the external-link icon, and rel security
-      # attributes to every link on the page, in that order.
-      def add_external_link_features(doc, config)
-        site_domain = extract_site_domain
-        return if site_domain.empty?
-
-        doc.css('a:not(.btn)').each do |link|
-          add_external_target_blank(link, site_domain)
-          add_external_icon(link, site_domain, config, doc)
-          add_external_target_protection(link)
-        end
-      end
-
-      def extract_site_domain
-        site_url = @config['url'] || @config['baseurl'] || ''
-        extract_domain(site_url)
-      end
-
-      # Injects a permalink anchor into each heading (h1-h6). The anchor's
-      # glyph defaults to a plain "#"; with_heading_anchor_data can swap it
-      # for a Font Awesome icon or any other class list.
-      def add_heading_anchors(doc)
-        enabled = @config.key?('with_heading_anchor') ? @config['with_heading_anchor'] : DEFAULT_HEADING_ANCHOR
-        return unless enabled
-
-        ha_data    = @config['with_heading_anchor_data'] || {}
-        icon_class = ha_data.fetch('icon', DEFAULT_HEADING_ANCHOR_ICON)
-        icon_size  = ha_data['icon_size']
-        full_icon  = [icon_class, icon_size].compact.join(' ')
-        id_counts  = {}
-
-        doc.css('h1, h2, h3, h4, h5, h6').each do |heading|
-          next if heading.css('.heading-anchor').any?
-
-          id = resolve_heading_id(heading, id_counts)
-
-          anchor = Nokogiri::XML::Node.new('a', doc)
-          anchor['class']            = 'heading-anchor p-1 mx-1 focus-ring'
-          anchor['href']             = "##{id}"
-          anchor['data-copy-anchor'] = "##{id}"
-          anchor['aria-label']       = "Link to #{heading.text.strip}"
-
-          icon = Nokogiri::XML::Node.new('i', doc)
-          icon['class']       = full_icon
-          icon['aria-hidden'] = 'true'
-          anchor.add_child(icon)
-
-          heading.add_child(anchor)
-        end
-      end
-
-      # Returns the heading's existing id, or generates one from its text and
-      # assigns it. id_counts tracks slugs already used, so repeated headings
-      # get unique "-1", "-2", ... suffixes.
-      def resolve_heading_id(heading, id_counts)
-        existing = heading['id'].to_s.strip
-        return existing unless existing.empty?
-
-        base = slugify(heading.text)
-        n = id_counts[base].to_i
-        id_counts[base] = n + 1
-        final_id = n.zero? ? base : "#{base}-#{n}"
-        heading['id'] = final_id
-        final_id
-      end
-
-      # Converts heading text to a URL-safe slug, loosely mirroring the slug
-      # rules in jekyll-theme-centos-base's link.html.liquid (same characters
-      # stripped and replaced), plus collapsing repeated/edge hyphens so
-      # headings with unusual punctuation still get a clean id.
-      def slugify(text)
-        text.strip
-            .downcase
-            .tr(' ', '-')
-            .delete('"\'?&#/')
-            .gsub(/-{2,}/, '-')
-            .gsub(/\A-|-\z/, '')
-      end
-
-      private :add_heading_anchors, :resolve_heading_id, :slugify
-
-      # Appends the external-link icon to a cross-domain link, unless the
-      # icon is disabled, the link already has an icon-bearing tag excluded
-      # via external_link_icon_excluded_tags, or one is already present.
-      def add_external_icon(link, site_domain, config, doc)
-        external_link_icon = config.fetch('external_link_icon', DEFAULT_EXTERNAL_LINK_ICON)
-
-        return unless external_link_icon
-
-        exclude_tags = config.fetch('external_link_icon_excluded_tags', DEFAULT_EXTERNAL_LINK_ICON_EXCLUDED_TAGS)
-        return if exclude_tags.any? { |tag| link.css(tag).any? }
-
-        return unless is_external_different_domain_link?(link, site_domain)
-
-        icon = Nokogiri::XML::Node.new('i', doc)
-        icon['class'] = 'fa-solid fa-external-link ms-1'
-        icon['aria-hidden'] = 'true'
-        link.add_child(icon)
-      end
-    end
-  end
-
   module Filters
     # Liquid filter that applies link decoration to already-converted HTML.
     # Use after the markdownify filter to decorate links in YAML data fields:
@@ -341,8 +41,7 @@ module Jekyll
     module LinkDecoratorFilter
       def decorate_links(html)
         site = @context.registers[:site]
-        decorator = Jekyll::Converters::LinkDecorator.new(site.config)
-        decorator.decorate_html(html)
+        Jekyll::LinkDecorator::Decorator.new(site.config).decorate_html(html)
       end
     end
   end