jekyll-theme-centos 2.52.0.beta.33 → 2.52.0.beta.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab9808f290e727eba0d2e8918e9115ae65c9d058f03cc0d5a5c5a4b7b3076b5a
-  data.tar.gz: d65f9a18ca1772cf59166e6efa0136d70d3e43dda7783e9f99a32136c6587df9
+  metadata.gz: eb03b8524faeb2a8ced08783f43b9f19019d76923a1b2136966bd51678fac8ff
+  data.tar.gz: 1975121e2011726602a952cf41043d2d3531ae5d764b4b20084c76bbb52389d8
 SHA512:
-  metadata.gz: 347cd972a2aa0740bd0ebd4256878b569347615927d8460d87d3076181b7082d21ce754e68a25ceadef97785491eec6cdb935ae8bc856de3e55bd895143d8d18
-  data.tar.gz: 37490f38ef21de11de52a0418a729882c8fb0277c46db77e20a503452bc611f2d34a3236d411ec24053086fc9f36f8ec71fc87a63d3b80413d98154cc73d8052
+  metadata.gz: 761dc927d30ba7b818c11a6478e549d8cad29a4e4579211b70d28015b38866890d2314cda159a10c6161b7bd0e3cbaa98f494daa6fb57f3b23f00446fd62c02a
+  data.tar.gz: 11b84e8e917a6c99bcf6e0cb3457176c1386441f63d7e39ce12f80eff8e11e936bf52992416cd26bf405c19b53a345b98b3270b05ccd33043f097d39d8b42741

data/_plugins/converter_link.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+# This Jekyll plugin, `converter_link`, automatically enhances `<a>` tags
+# within Markdown content by adding specific Bootstrap-related CSS classes and
+# external-link icons. This functionality is conditional, applying different
+# sets of classes based on whether a link is located inside a Bootstrap alert
+# box or is a regular link. It explicitly avoids modifying elements that are
+# designated as buttons by having the `.btn` class.
+#
+# === External Link Icon Support ===
+#
+# For links pointing to external domains (different from site.url), the plugin
+# automatically adds a Font Awesome external-link icon (fa-solid fa-external-link)
+# at the end of the link text, similar to the link component behavior.
+#
+# === External Link Detection & Target Management ===
+#
+# The plugin automatically detects external links and manages their behavior:
+# - Relative URLs (starting with /, ../) and same-domain absolute URLs open in the same window
+# - Absolute URLs pointing to different domains (http:// or https://) automatically get target="_blank"
+# - Links with target="_blank" automatically receive rel="noopener noreferrer" protection
+# against security vulnerabilities (window.opener access, referrer leakage)
+#
+# === Configuration ===
+#
+# You can customize the classes applied by this plugin by adding a
+# `converter_link` section to your `_config.yml` file.
+#
+# * `enabled`: Boolean (default: true) that controls whether the plugin runs.
+#   Set to false to disable automatic link styling and icon insertion.
+#
+# * `default_link_classes`: Defines the classes to be applied to all links that are not
+# inside an .alert. Example: `default_link_classes: "text-decoration-none"`
+#
+# * `alert_link_classes`: Defines the classes for links specifically located within an
+# .alert box. Example: `alert_link_classes: "text-decoration-underline"`
+#
+# * `external_link_icon`: Boolean (default: true) that controls whether external-link
+#   icons are added to cross-domain external links. Set to false to disable.
+#
+# If no configuration is provided, the plugin will use default fallback classes
+# and enable external link icons.
+#
+# Here is an example `_config.yml` setup:
+#
+# ```yaml
+# converter_link:
+#   enabled: true
+#   default_link_classes: "link link-offset-3 link-offset-3-hover link-underline-primary link-underline-opacity-0 link-underline-opacity-100-hover"
+#   alert_link_classes: "alert-link"
+#   external_link_icon: true
+# ```
+
+require 'jekyll'
+require 'nokogiri'
+
+module Jekyll
+  module Converters
+    # This custom converter applies specific CSS classes to <a> tags
+    # based on their context (e.g., inside an alert box) and excludes
+    # buttons, all done via Nokogiri's powerful CSS selectors.
+    # It also adds external-link icons for cross-domain external links.
+    class LinkConverter < Jekyll::Converters::Markdown
+      def self.name
+        'LinkConverter'
+      end
+
+      # Extract domain from a URL by removing protocol and path components
+      # Example: "https://example.com/path?query=1#anchor" -> "example.com"
+      def extract_domain(url)
+        return '' if url.nil? || url.empty?
+
+        # Remove protocol (http:// or https://)
+        domain = url.sub(%r{^https?://}, '')
+
+        # Extract just the domain part (before /, ?, or #)
+        domain = domain.split(%r{[/?#]}).first
+
+        # Convert to lowercase for case-insensitive comparison
+        domain.downcase
+      end
+
+      # Check if a link is an external link pointing to a different domain
+      # Returns true if:
+      # - Link starts with http:// or https://
+      # - Link domain is different from site.url domain
+      # - Link doesn't already have an external-link icon child
+      def is_external_different_domain_link?(link, site_domain)
+        href = link['href'].to_s
+
+        # Check if it's an absolute URL with http/https
+        return false unless href =~ %r{^https?://}
+
+        # Extract domain from the link
+        link_domain = extract_domain(href)
+
+        # Check if domains are different
+        return false if link_domain == site_domain || link_domain.empty?
+
+        # Check if an icon has already been added (avoid duplicates)
+        # Check for both new icons (fa-external-link) and old icons
+        # (fa-external-link-alt, fa-up-right-from-square, etc.)
+        return false if link.css('i[class*="fa-external-link"]').any?
+        return false if link.css('i[class*="up-right-from-square"]').any?
+        return false if link.css('svg[data-icon="external-link"]').any?
+        return false if link.css('svg[data-icon="up-right-from-square"]').any?
+        return false if link.css('svg[data-icon="arrow-up-right-from-square"]').any?
+
+        true
+      end
+
+      # Determine if a link points to an external domain
+      # Returns true if:
+      # - Link is absolute (starts with http:// or https://)
+      # - Link domain is different from site.url domain
+      # Returns false if:
+      # - Link is relative (starts with /, ../)
+      # - Link domain matches site.url domain
+      def cross_domain_external_link?(link, site_domain)
+        href = link['href'].to_s
+
+        # Relative URLs (starting with / or ../) are internal links
+        return false if href =~ %r{^(/|\.\.)}
+
+        # Check if it's an absolute URL with http/https
+        return false unless href =~ %r{^https?://}
+
+        # Extract domain from the link
+        link_domain = extract_domain(href)
+
+        # Check if domains are different
+        return false if link_domain == site_domain || link_domain.empty?
+
+        true
+      end
+
+      # Add target="_blank" to external cross-domain links
+      # Only adds if target is not already set
+      def add_external_target_blank(link, site_domain)
+        # Skip if link already has a target attribute
+        return if link['target'].to_s.strip != ''
+
+        # Add target="_blank" if this is a cross-domain external link
+        return unless cross_domain_external_link?(link, site_domain)
+
+        link['target'] = '_blank'
+      end
+
+      # Add security attributes to links with target="_blank"
+      # Adds rel="noopener noreferrer" to prevent security vulnerabilities
+      # Preserves any existing rel attribute values
+      def add_external_target_protection(link)
+        target = link['target'].to_s
+
+        # Only add protection for target="_blank"
+        return unless target == '_blank'
+
+        # Get existing rel attribute (if any)
+        existing_rel = link['rel'].to_s.strip
+        rel_values = existing_rel.empty? ? [] : existing_rel.split(/\s+/)
+
+        # Add required security values if not already present
+        rel_values << 'noopener' unless rel_values.include?('noopener')
+        rel_values << 'noreferrer' unless rel_values.include?('noreferrer')
+
+        # Set the updated rel attribute
+        link['rel'] = rel_values.join(' ')
+      end
+
+      def matches(ext)
+        ext =~ /^\.md$/i
+      end
+
+      def output_ext(_ext)
+        '.html'
+      end
+
+      def convert(content)
+        html = super(content)
+        config = @config['converter_link'] || {}
+
+        return html unless plugin_enabled?(config)
+
+        doc = Nokogiri::HTML::DocumentFragment.parse(html)
+
+        apply_link_styles(doc, config)
+        add_external_link_features(doc, config)
+
+        doc.to_html
+      rescue StandardError => e
+        Jekyll.logger.error 'LinkConverter Error:', "An error occurred during link conversion: #{e.message}"
+        Jekyll.logger.error 'Backtrace:', e.backtrace.join("\n")
+
+        html
+      end
+
+      # Check if the plugin is enabled in configuration
+      # Defaults to true if not explicitly configured
+      def plugin_enabled?(config)
+        enabled = config.key?('enabled') ? config['enabled'] : true
+        unless enabled
+          Jekyll.logger.info 'LinkConverter:', 'Disabled via configuration. Skipping custom link modification.'
+        end
+        enabled
+      end
+
+      # Apply CSS classes to links based on their context (alert or default)
+      def apply_link_styles(doc, config)
+        default_classes = config.fetch('default_link_classes',
+                                       'link link-offset-3 link-offset-3-hover link-underline-primary link-underline-opacity-0 link-underline-opacity-100-hover')
+        alert_classes = config.fetch('alert_link_classes', 'alert-link')
+
+        # Apply alert classes to links inside p.alert
+        doc.css('p.alert a:not(.btn)').each do |link|
+          add_classes(link, alert_classes)
+        end
+
+        # Apply default classes to all other non-alert links
+        doc.css('a:not(.btn)').each do |link|
+          add_classes(link, default_classes) unless link.ancestors('p.alert').any?
+        end
+      end
+
+      # Add CSS classes to a link element
+      def add_classes(link, classes_string)
+        classes_string.split(' ').each { |cls| link.add_class(cls) }
+      end
+
+      # Add external link features: target="_blank", icons, and security attributes
+      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
+
+      # Extract site domain from Jekyll configuration
+      def extract_site_domain
+        site_url = @config['url'] || @config['baseurl'] || ''
+        extract_domain(site_url)
+      end
+
+      # Add external-link icon to cross-domain external links
+      def add_external_icon(link, site_domain, config, doc)
+        external_link_icon = config.fetch('external_link_icon', true)
+
+        return unless external_link_icon
+        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'
+        link.add_child(icon)
+      end
+    end
+  end
+end

data/_plugins/optimizer_compressor.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+# This Jekyll plugin, `html_compressor`, automatically compresses HTML, CSS, and
+# JavaScript files generated by Jekyll to reduce their file size and improve page
+# load performance. It runs after the entire site is built and processes all output
+# files in the destination directory.
+#
+# === How It Works ===
+#
+# The plugin uses a post-write hook that runs after Jekyll finishes writing all
+# files to the output directory (public/). It then traverses the directory tree
+# and compresses files using the minify-html gem (Rust-based minifier):
+#
+# - **HTML Compression:** Removes comments, whitespace, and optional tags using
+#   proper HTML parsing. Expected reduction: 10-25%
+#
+# - **CSS Compression:** Removes comments and whitespace from inline and standalone
+#   CSS files. Skips pre-minified files (*.min.css).
+#   Expected reduction: 10-20%
+#
+# - **JavaScript Compression:** Removes comments and unnecessary whitespace from
+#   inline and standalone JavaScript files using proper parsing. Skips pre-minified
+#   files (*.min.js). Renames compressed files to *.min.js. Expected reduction: 20-30%
+#
+# === Error Handling ===
+#
+# The plugin is designed to fail gracefully:
+# - If compression fails for any file, the original file is preserved
+# - Errors are logged as warnings but do not break the build
+# - Statistics are still displayed for successfully compressed files
+#
+# === Performance ===
+#
+# Processing typically adds less than 1 second to the total build time. The
+# minify-html gem (Rust-based) provides efficient processing.
+#
+# === Requirements ===
+#
+# This plugin requires the 'minify_html' gem. Install with:
+#   gem install minify_html
+#
+# === Configuration ===
+#
+# This plugin is always enabled and has no configuration options. It is designed
+# to work automatically with no setup required. To verify it's working, build
+# your site and check that files in public/ are smaller and have minimal whitespace.
+#
+# === W3C HTML Validation Compatibility ===
+#
+# This plugin uses minify-html's built-in `ensure_spec_compliant_unquoted_attribute_values`
+# option to maintain W3C validation compliance. This preserves attribute quotes on values
+# containing special characters, preventing unquoting issues with attributes like:
+# prefix="og: https://ogp.me/ns#"
+#
+# === CSS/JavaScript Minification Note ===
+#
+# The minify-html Ruby gem only exposes HTML minification through its public API.
+# CSS and JavaScript minification are supported internally through wrapper tags:
+# CSS is wrapped in `<style>` tags and JS in `<script>` tags for minification,
+# then extracted. This is the only approach supported by the gem's design.
+
+require 'jekyll'
+require 'pathname'
+
+begin
+  require 'minify_html'
+rescue LoadError
+  raise Jekyll::Errors::FatalException, "Missing required gem 'minify_html'. " \
+    'Install with: gem install minify_html'
+end
+
+module Jekyll
+  # Main HTML/CSS/JS compression module
+  class HtmlCompressor
+    # Default minify-html options for HTML compression
+    HTML_MINIFY_OPTIONS = {
+      keep_html_and_head_opening_tags: true,
+      keep_closing_tags: true,
+      minify_css: true,
+      minify_js: true,
+      remove_bangs: true,
+      remove_processing_instructions: true,
+      ensure_spec_compliant_unquoted_attribute_values: true
+    }.freeze
+
+    # Compression types with display names for logging
+    COMPRESSION_TYPES = [
+      { type: :html, display_name: 'HTML' },
+      { type: :css, display_name: 'CSS' },
+      { type: :js, display_name: 'JS' }
+    ].freeze
+
+    def initialize
+      @stats = {
+        html: { count: 0, before: 0, after: 0 },
+        css: { count: 0, before: 0, after: 0 },
+        js: { count: 0, before: 0, after: 0 },
+        errors: []
+      }
+      @start_time = Time.now
+    end
+
+    # Main entry point: compress all files in the site destination
+    def self.compress_site(site)
+      compressor = new
+      compressor.process_site(site)
+    end
+
+    def process_site(site)
+      dest = Pathname.new(site.dest)
+      return unless dest.directory?
+
+      Jekyll.logger.info 'HtmlCompressor:', 'Starting compression...'
+
+      # Find and compress all files
+      find_and_compress_files(dest)
+
+      # Log final statistics
+      log_statistics
+    end
+
+    private
+
+    # Find all compressible files in destination directory
+    def find_and_compress_files(dest)
+      dest.glob('**/*.{html,css,js}').each do |file_path|
+        compress_file(file_path)
+      end
+    rescue StandardError => e
+      Jekyll.logger.error 'HtmlCompressor:', "Error during file discovery: #{e.message}"
+    end
+
+    # Process a single file based on its extension
+    def compress_file(file_path)
+      # Skip pre-minified files
+      return if file_path.to_s.end_with?('.min.css', '.min.js')
+
+      case file_path.extname.downcase
+      when '.html'
+        safe_compress(file_path, :html)
+      when '.css'
+        safe_compress(file_path, :css)
+      when '.js'
+        safe_compress(file_path, :js, rename_to_min: true)
+      end
+    rescue StandardError => e
+      Jekyll.logger.warn 'HtmlCompressor:', "Unexpected error processing #{file_path}: #{e.message}"
+    end
+
+    # Safely compress a file, preserving original on error
+    def safe_compress(file_path, type, rename_to_min: false)
+      original_content = file_path.read(encoding: 'UTF-8')
+      original_size = original_content.bytesize
+
+      # Skip empty files
+      return if original_size.zero?
+
+      begin
+        compressed = compress_by_type(original_content, type)
+
+        # Sanity check: ensure result is not empty
+        raise 'Compression resulted in empty content' if compressed.nil? || compressed.strip.empty?
+
+        compressed_size = compressed.bytesize
+
+        # Write compressed file and rename if needed
+        write_compressed_file(file_path, compressed, original_content, rename_to_min: rename_to_min)
+
+        # Update statistics
+        @stats[type][:count] += 1
+        @stats[type][:before] += original_size
+        @stats[type][:after] += compressed_size
+      rescue StandardError => e
+        # Log error but preserve original file
+        error_msg = "Failed to compress #{file_path}: #{e.message}"
+        Jekyll.logger.warn 'HtmlCompressor:', error_msg
+        @stats[:errors] << error_msg
+
+        # Ensure original file is preserved
+        file_path.write(original_content, encoding: 'UTF-8')
+      end
+    rescue StandardError => e
+      Jekyll.logger.warn 'HtmlCompressor:', "Error reading file #{file_path}: #{e.message}"
+      @stats[:errors] << "Read error: #{file_path}"
+    end
+
+    # Write compressed file to disk and rename if needed (e.g., .js to .min.js)
+    def write_compressed_file(file_path, compressed_content, original_content, rename_to_min: false)
+      file_path.write(compressed_content, encoding: 'UTF-8')
+
+      # Rename .js to .min.js if requested
+      if rename_to_min && file_path.extname == '.js'
+        new_path = file_path.sub_ext('.min.js')
+        file_path.rename(new_path)
+      end
+    rescue StandardError => e
+      # Restore original if write/rename fails
+      file_path.write(original_content, encoding: 'UTF-8')
+      raise "Failed to write compressed file: #{e.message}"
+    end
+
+    # Dispatch to appropriate compression method
+    def compress_by_type(content, type)
+      case type
+      when :html then compress_html(content)
+      when :css then compress_css(content)
+      when :js then compress_js(content)
+      end
+    end
+
+    # =========================================================================
+    # Compression using minify-html gem
+    # =========================================================================
+
+    # Compress HTML content using minify-html gem
+    def compress_html(content)
+      minify_html(content, HTML_MINIFY_OPTIONS)
+    rescue StandardError => e
+      raise "HTML minification failed: #{e.message}"
+    end
+
+    # Compress CSS/JS content wrapped in temporary tags, then extract
+    def compress_wrapped(content, wrapper_tag, minify_option)
+      wrapped = "<#{wrapper_tag}>#{content}</#{wrapper_tag}>"
+      minified = minify_html(wrapped, { minify_option => true })
+      match = minified.match(%r{<#{wrapper_tag}>(.*)</#{wrapper_tag}>}m)
+      raise "#{wrapper_tag.upcase} minification resulted in empty content" unless match
+
+      match[1]
+    rescue StandardError => e
+      raise "#{wrapper_tag.upcase} minification failed: #{e.message}"
+    end
+
+    # Compress CSS content using minify-html gem
+    def compress_css(content)
+      compress_wrapped(content, 'style', :minify_css)
+    end
+
+    # Compress JavaScript content using minify-html gem
+    def compress_js(content)
+      compress_wrapped(content, 'script', :minify_js)
+    end
+
+    # =========================================================================
+    # Logging and Statistics
+    # =========================================================================
+
+    # Format file size for display
+    def format_size(bytes)
+      if bytes < 1024
+        "#{bytes}B"
+      elsif bytes < 1_048_576
+        "#{(bytes / 1024.0).round(1)}KB"
+      else
+        "#{(bytes / 1_048_576.0).round(1)}MB"
+      end
+    end
+
+    # Calculate compression percentage
+    def compression_percent(before, after)
+      return 0 if before.zero?
+
+      (((before - after) / before.to_f) * 100).round(1)
+    end
+
+    # Log compression statistics
+    def log_statistics
+      elapsed = Time.now - @start_time
+
+      Jekyll.logger.info 'HtmlCompressor:', 'Compression complete using minify-html gem'
+
+      # Log per-type statistics and calculate totals
+      total_before = 0
+      total_after = 0
+
+      COMPRESSION_TYPES.each do |type_config|
+        type = type_config[:type]
+        display_name = type_config[:display_name]
+        data = @stats[type]
+
+        next if data[:count].zero?
+
+        percent = compression_percent(data[:before], data[:after])
+        before_fmt = format_size(data[:before])
+        after_fmt = format_size(data[:after])
+
+        Jekyll.logger.info 'HtmlCompressor:',
+                           "#{display_name}: #{data[:count]} files (#{before_fmt} → #{after_fmt}, #{percent}% reduction)"
+
+        total_before += data[:before]
+        total_after += data[:after]
+      end
+
+      # Log overall statistics
+      if total_before > 0
+        total_percent = compression_percent(total_before, total_after)
+        total_before_fmt = format_size(total_before)
+        total_after_fmt = format_size(total_after)
+
+        Jekyll.logger.info 'HtmlCompressor:',
+                           "Total: #{total_before_fmt} → #{total_after_fmt} (#{total_percent}% reduction) in #{elapsed.round(2)}s"
+      end
+
+      # Log errors if any
+      return if @stats[:errors].empty?
+
+      Jekyll.logger.warn 'HtmlCompressor:', "#{@stats[:errors].length} compression errors (files preserved):"
+      @stats[:errors].each { |error| Jekyll.logger.warn 'HtmlCompressor:', "  - #{error}" }
+    end
+  end
+end
+
+# Register the post_write hook
+Jekyll::Hooks.register :site, :post_write do |site|
+  Jekyll::HtmlCompressor.compress_site(site)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-theme-centos
 version: !ruby/object:Gem::Version
-  version: 2.52.0.beta.33
+  version: 2.52.0.beta.34
 platform: ruby
 authors:
 - ReleaseBot
@@ -251,6 +251,8 @@ files:
 - _layouts/download/cards.html
 - _layouts/download/default.html
 - _layouts/people/default.html
+- _plugins/converter_link.rb
+- _plugins/optimizer_compressor.rb
 - _sass/base/_customization.scss
 - _sass/base/_light-dark.scss
 - _sass/base/_maps.scss