jekyll-minify 1.1.6 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54325d0362b0885bd72860ee0ead6d036e59d4ad47c3c00ce804ef2b7aeacc27
-  data.tar.gz: 563c1fa1a094a967fd1c47ff975ccbcde581bd35eca131ca6af99fb93d6acf20
+  metadata.gz: cb32991092f0b2d76cbe462ef326b8e8e17bcd32412cc4d1d96b067243d86860
+  data.tar.gz: '0586c8ae509a614b9c0f8e155515fc4c9af03754d0d5a53ca1dd29a54bd84af5'
 SHA512:
-  metadata.gz: 50b3e6363ae9ffb636d4364698989e9f764f5d4466d1945f0bdf56445dccf37d62788199349ed4fdb01c2ecd1146245be28991d2a890b69862fc169b35acbb47
-  data.tar.gz: 0566f097397fdaec7134ac312f16fdd950e83d067a7a40163d416fd73ba341403bc6175e51f1213db8c193dd5196fba136886fc278dac5ce66e644cd4a15b43d
+  metadata.gz: 7642d1ab27efa2bf42653839e8683dd06f042b9f202f5ad5f4298087fee430bc70e7a1482773d826fd43151e3ae6a853cc4149e5a013676c33517ed60963e93a
+  data.tar.gz: 0ac5b5eb5f230a58eb60f03c126502ece8d4c5cbd841c021bd30e0d3b42258d281ea06c64469b079dfae29f5b74b200bdc437f2280258ee1e72100fdd1747087

data/lib/jekyll-minify/configuration/schema.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'did_you_mean'
+
+module Jekyll
+  module Minify
+    module Configuration
+      # The type of each setting under CONFIG_KEY, and how a value of the
+      # wrong type is converted or replaced by its default, with a warning.
+      # Configuration.resolve applies it after merging the site's settings.
+      module Schema
+        # Every setting the plugin accepts, and its type: the plugin's own
+        # `enabled` switch, and the Cfg options the minify_html Ruby extension
+        # reads. Keep the options in sync with the minify_html version the
+        # gemspec allows; minify_html silently ignores keys it doesn't know.
+        #
+        # @return [Hash{String => Symbol}]
+        TYPES = %w[
+          enabled
+          allow_noncompliant_unquoted_attribute_values
+          allow_optimal_entities
+          allow_removing_spaces_between_attributes
+          keep_closing_tags
+          keep_comments
+          keep_html_and_head_opening_tags
+          keep_input_type_text_attr
+          keep_ssi_comments
+          minify_css
+          minify_doctype
+          minify_js
+          preserve_brace_template_syntax
+          preserve_chevron_percent_template_syntax
+          remove_bangs
+          remove_processing_instructions
+        ].to_h { |key| [key, :boolean] }.freeze
+
+        # Per type: what the warning says to expect, which values pass as is,
+        # and how a near-miss converts (returns [converted], or nil when the
+        # value can't be converted and the default applies instead).
+        #
+        # @return [Hash{Symbol => Hash}]
+        COERCERS = {
+          # "true"/"false" in any case, surrounding spaces ignored
+          boolean: {
+            expected: 'true or false',
+            accept: ->(value) { [true, false].include?(value) },
+            convert: lambda { |value|
+              word = value.strip.downcase if value.is_a?(String)
+              [word == 'true'] if %w[true false].include?(word)
+            }
+          }
+        }.freeze
+
+        # Site-level keys removed in 2.0.0, mapped to where their settings
+        # live now.
+        #
+        # @return [Hash{String => String}]
+        LEGACY_KEYS = {
+          'with_minify' => "#{CONFIG_KEY}.enabled",
+          'with_minify_data' => "the keys directly under #{CONFIG_KEY}"
+        }.freeze
+
+        # Returns value if its type accepts it; otherwise its conversion,
+        # with a warning; otherwise the default (nil when the key has none),
+        # with a warning.
+        #
+        # @param value [Object] the merged value of key
+        # @param key [String] a TYPES key
+        # @return [Object]
+        def self.coerce(value, key)
+          coercer = COERCERS.fetch(TYPES.fetch(key))
+          return value if coercer[:accept].call(value)
+
+          key_path = "#{CONFIG_KEY}.#{key}"
+          converted = coercer[:convert].call(value)
+          if converted
+            warn_invalid(key_path, value, coercer[:expected], "reading it as #{converted.first.inspect}")
+            return converted.first
+          end
+
+          warn_invalid(key_path, value, coercer[:expected])
+          DEFAULTS[key]
+        end
+
+        # Warns once per LEGACY_KEYS entry present in the site config, even
+        # with an empty value. The old keys stay ignored.
+        #
+        # @param site_config [Hash] Jekyll site configuration hash (site.config)
+        # @return [void]
+        def self.warn_legacy_keys(site_config)
+          (LEGACY_KEYS.keys & site_config.keys).each do |old_key|
+            Jekyll.logger.warn LOG_PREFIX,
+                               "#{old_key} was removed in 2.0.0 and is ignored; " \
+                               "use #{LEGACY_KEYS[old_key]} instead."
+          end
+        end
+
+        # Options under CONFIG_KEY that minify-html no longer reads, mapped to
+        # what replaces them. minify-html 0.16 dropped
+        # ensure_spec_compliant_unquoted_attribute_values and made compliant
+        # quoting its default.
+        #
+        # @return [Hash{String => String}]
+        LEGACY_OPTIONS = {
+          'ensure_spec_compliant_unquoted_attribute_values' =>
+            "#{CONFIG_KEY}.allow_noncompliant_unquoted_attribute_values, which inverts it " \
+            'and defaults to false'
+        }.freeze
+
+        # Returns a copy of settings without the keys TYPES doesn't know.
+        # Warns once per dropped key.
+        #
+        # @param settings [Hash] the site's jekyll_minify mapping
+        # @return [Hash]
+        def self.without_unknown_keys(settings)
+          settings.select do |key, _value|
+            next true if TYPES.key?(key)
+
+            LEGACY_OPTIONS.key?(key) ? warn_legacy_option(key) : warn_unknown(key)
+            false
+          end
+        end
+
+        # Warns that a LEGACY_OPTIONS key is ignored, naming its replacement.
+        #
+        # @param key [String] a LEGACY_OPTIONS key
+        # @return [void]
+        def self.warn_legacy_option(key)
+          Jekyll.logger.warn LOG_PREFIX,
+                             "#{CONFIG_KEY}.#{key} was removed in 2.0.0 and is ignored; " \
+                             "use #{LEGACY_OPTIONS[key]}."
+        end
+
+        # Warns that key is ignored, suggesting the closest known key.
+        #
+        # @param key [Object] the unknown key
+        # @return [void]
+        def self.warn_unknown(key)
+          suggestion = DidYouMean::SpellChecker.new(dictionary: TYPES.keys).correct(key.to_s).first
+          hint = suggestion ? "; did you mean `#{suggestion}`?" : '.'
+          Jekyll.logger.warn LOG_PREFIX, "#{CONFIG_KEY}.#{key} is not a known setting and is ignored#{hint}"
+        end
+
+        # One warning per invalid value per build: resolve runs once per build
+        # (see Configuration.for), so this never repeats file by file.
+        #
+        # @param key_path [String] the setting's dotted path
+        # @param value [Object] the invalid value
+        # @param expected [String] what the setting should be
+        # @param outcome [String] what the plugin does instead
+        # @return [void]
+        def self.warn_invalid(key_path, value, expected, outcome = 'using the default')
+          Jekyll.logger.warn LOG_PREFIX,
+                             "#{key_path} should be #{expected}, got #{value.inspect}; #{outcome}."
+        end
+        private_class_method :warn_legacy_option, :warn_unknown
+      end
+    end
+  end
+end

data/lib/jekyll-minify/configuration.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Minify
+    # Resolves the plugin's settings: the `jekyll_minify` hash from
+    # _config.yml, merged over DEFAULTS so every default key has a value.
+    module Configuration
+      # The top-level _config.yml key the plugin reads.
+      # @return [String]
+      CONFIG_KEY = 'jekyll_minify'
+
+      # Prefix for every log line the plugin writes.
+      # @return [String]
+      LOG_PREFIX = 'jekyll-minify:'
+
+      # Logged once per build when `enabled` resolves to false.
+      # @return [String]
+      DISABLED_NOTICE = "Minification disabled (#{CONFIG_KEY}.enabled: false)."
+
+      # Default options passed to the minify-html gem. The site's
+      # `jekyll_minify` keys (all except `enabled`) are merged over these.
+      # `allow_noncompliant_unquoted_attribute_values` repeats minify-html's
+      # own default on purpose, so W3C-compliant attribute quoting stays the
+      # plugin's default even if minify-html changes its own.
+      #
+      # @return [Hash{Symbol => Boolean}]
+      DEFAULT_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,
+        allow_noncompliant_unquoted_attribute_values: false,
+        keep_input_type_text_attr: true
+      }.freeze
+
+      # Every setting's default, keyed as in _config.yml: the plugin's own
+      # `enabled` switch plus DEFAULT_MINIFY_OPTIONS.
+      #
+      # @return [Hash{String => Boolean}]
+      DEFAULTS = { 'enabled' => true }.merge(DEFAULT_MINIFY_OPTIONS.transform_keys(&:to_s)).freeze
+
+      # Returns a frozen copy of DEFAULTS with the site's own jekyll_minify
+      # settings merged over it. Memoized per site_config object, so a build
+      # resolves its settings, and logs its warnings, once.
+      #
+      # @param site_config [Hash] Jekyll site configuration hash (site.config)
+      # @return [Hash{String => Boolean}]
+      def self.for(site_config)
+        cache[site_config] ||= resolve(site_config)
+      end
+
+      # The minify-html options in resolved settings: every key except the
+      # plugin's own `enabled` switch, with symbol keys as minify-html expects.
+      #
+      # @param settings [Hash{String => Boolean}] a result of {.for}
+      # @return [Hash{Symbol => Boolean}]
+      def self.minify_options(settings)
+        settings.except('enabled').transform_keys(&:to_sym)
+      end
+
+      # Drops every memoized result. Registered on :site, :after_reset below,
+      # so each build (including each `jekyll serve --watch` rebuild) starts
+      # from the site config as it is then.
+      #
+      # @return [void]
+      def self.reset!
+        @cache = nil
+      end
+
+      # Keyed on object identity, and holds its results strongly: a weak map
+      # would let GC drop them mid-build and repeat every warning. reset!
+      # clears it at the start of each build, so it never outgrows one build.
+      #
+      # @return [Hash]
+      def self.cache
+        @cache ||= {}.compare_by_identity
+      end
+
+      # Warns about legacy keys, drops unknown keys, merges the rest over
+      # DEFAULTS, then checks each value's type.
+      #
+      # @param site_config [Hash] Jekyll site configuration hash (site.config)
+      # @return [Hash{String => Boolean}]
+      def self.resolve(site_config)
+        Schema.warn_legacy_keys(site_config)
+        user = Schema.without_unknown_keys(user_settings(site_config[CONFIG_KEY]))
+        # A null value means unset, like Jekyll core config.
+        merged = DEFAULTS.merge(user.compact)
+        merged.each_key { |key| merged[key] = Schema.coerce(merged[key], key) }
+        # An option without a default whose value was invalid: leave it to
+        # minify-html's own default.
+        merged.compact!
+        Jekyll.logger.info LOG_PREFIX, DISABLED_NOTICE unless merged['enabled']
+        merged.freeze
+      end
+
+      # Accepts the top-level key as a mapping, or as a bare true/false
+      # shorthand for `enabled`. Null means unset; anything else is warned
+      # about and ignored.
+      #
+      # @param value [Object] the site's jekyll_minify value
+      # @return [Hash]
+      def self.user_settings(value)
+        case value
+        when Hash        then value
+        when true, false then { 'enabled' => value }
+        when nil         then {}
+        else
+          Schema.warn_invalid(CONFIG_KEY, value, 'a mapping of settings, or true/false')
+          {}
+        end
+      end
+      private_class_method :cache, :resolve, :user_settings
+    end
+  end
+end
+
+# Schema's constants read CONFIG_KEY, defined above.
+require_relative 'configuration/schema'
+
+Jekyll::Hooks.register(:site, :after_reset) { Jekyll::Minify::Configuration.reset! }

data/lib/jekyll-minify/instrumentation.rb

@@ -48,12 +48,14 @@ module Jekyll
            span.set_attribute('minify.total_file_count', types.sum { |t| t[:count] })
            span.set_attribute('minify.total_original_size_bytes', types.sum { |t| t[:original_bytes] })
            span.set_attribute('minify.total_minified_size_bytes', types.sum { |t| t[:minified_bytes] })
+           span.set_attribute('minify.skipped_file_count', result[:skipped])
            span.set_attribute('minify.error_count', result[:errors].length)
          }],
 
-        ['Jekyll::Minify::Minifier', :private, :minify_each_file, 'minify.file_discovery',
-         lambda { |span, _this, args, _result|
+        ['Jekyll::Minify::Minifier', :private, :discover_files, 'minify.file_discovery',
+         lambda { |span, _this, args, result|
            span.set_attribute('minify.dest_path', args[0].to_s)
+           span.set_attribute('minify.discovered_file_count', result.size)
          }],
 
         ['Jekyll::Minify::Minifier', :private, :minify_with_fallback, 'minify.file_process',
@@ -145,9 +147,13 @@ module Jekyll
 
       # Configures the OTel SDK from standard env vars if the SDK gem is available.
       # Silently no-ops when opentelemetry-sdk or opentelemetry-exporter-otlp is
-      # not installed. Uses SimpleSpanProcessor (not the SDK default
-      # BatchSpanProcessor) since Jekyll is a short-lived CLI process that could
-      # exit before a batch timer fires, dropping spans.
+      # not installed. Uses BatchSpanProcessor, which exports from a background
+      # thread, so the build never waits on the collector while a span ends
+      # (SimpleSpanProcessor exports synchronously, inside every traced call).
+      # Spans still reach the collector before Jekyll exits: the post_write hook
+      # below runs after every :low-or-higher post_write hook, this plugin's
+      # minification included, and force-flushes the batch; at_exit shuts the
+      # provider down, exporting anything left (e.g. between serve rebuilds).
       #
       # jekyll-theme-centos loads several instrumented plugins in one process;
       # OpenTelemetry::SDK.configure overwrites the global tracer_provider on
@@ -164,7 +170,7 @@ module Jekyll
         require 'opentelemetry/sdk'
         require 'opentelemetry/exporter/otlp'
         exporter  = OpenTelemetry::Exporter::OTLP::Exporter.new
-        processor = OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(exporter)
+        processor = OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(exporter)
         OpenTelemetry::SDK.configure { |c| c.add_span_processor(processor) }
 
         at_exit { OpenTelemetry.tracer_provider&.shutdown }

data/lib/jekyll-minify/version.rb

@@ -6,6 +6,6 @@ module Jekyll
     # Regenerated alongside the gemspec on every `make jekyll-minify.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.1.6'
+    VERSION = '2.0.0'
   end
 end

data/lib/jekyll-minify.rb

@@ -43,20 +43,22 @@
 #
 # The plugin is enabled by default. You can control it via _config.yml:
 #
-#   with_minify: false               # disable minification (defaults to true)
-#   with_minify_data:                # override minify-html options
-#     remove_bangs: false            # preserve IE conditional comments
-#     minify_css: false              # disable CSS minification
-#     minify_js: false               # disable JS minification
+#   jekyll_minify:
+#     enabled: false                 # disable minification (defaults to true)
+#     remove_bangs: false            # override minify-html options: every key
+#     minify_css: false              # other than `enabled` is passed through
+#     minify_js: false               # to minify-html
 #
-# Defaults to all 8 minify-html options enabled. YAML string keys are automatically
-# converted to symbols for the minify-html gem.
+# Jekyll::Minify::Configuration resolves these settings once per build: it
+# merges them over DEFAULT_MINIFY_OPTIONS, and warns about (then ignores)
+# unknown keys, non-boolean values, and the pre-2.0 `with_minify` keys.
 #
 # === 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:
+# The plugin sets minify-html's `allow_noncompliant_unquoted_attribute_values`
+# to false (minify-html's own default since 0.16) 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#"
 #
 # It also sets `keep_input_type_text_attr` so `<input type="text">` survives
@@ -83,6 +85,7 @@ rescue LoadError
 end
 
 require_relative 'jekyll-minify/version'
+require_relative 'jekyll-minify/configuration'
 require_relative 'jekyll-minify/instrumentation'
 
 module Jekyll
@@ -95,29 +98,21 @@ module Jekyll
     #
     # @example Disable minification in development
     #   # _config-dev.yml
-    #   with_minify: false
+    #   jekyll_minify:
+    #     enabled: false
     #
     # @example Override minify-html options for production
     #   # _config.yml
-    #   with_minify: true
-    #   with_minify_data:
+    #   jekyll_minify:
+    #     enabled: true
     #     remove_bangs: false
     #     minify_css: false
     class Minifier
-      # Default options passed to the minify-html gem.
-      # User overrides from `with_minify_data` in _config.yml are merged over these.
+      # Default options passed to the minify-html gem; an alias of
+      # {Configuration::DEFAULT_MINIFY_OPTIONS}, kept for backward compatibility.
       #
       # @return [Hash{Symbol => Boolean}]
-      DEFAULT_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,
-        keep_input_type_text_attr: true
-      }.freeze
+      DEFAULT_MINIFY_OPTIONS = Configuration::DEFAULT_MINIFY_OPTIONS
 
       # Asset types processed by the minifier, in order.
       # Each entry has :type (Symbol) and :display_name (String) for logging.
@@ -135,6 +130,7 @@ module Jekyll
           html: { count: 0, original_bytes: 0, minified_bytes: 0 },
           css: { count: 0, original_bytes: 0, minified_bytes: 0 },
           js: { count: 0, original_bytes: 0, minified_bytes: 0 },
+          skipped: 0,
           errors: []
         }
         @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -149,21 +145,20 @@ module Jekyll
       end
 
       # Runs the minification pipeline for the given site.
-      # Reads configuration from site.config:
-      # - with_minify (Boolean, defaults to true): enable/disable the plugin
-      # - with_minify_data (Hash, optional): override minify-html options
+      # Reads the jekyll_minify settings from site.config through
+      # {Configuration.for}: `enabled` switches the plugin on or off, and every
+      # other key overrides a minify-html option.
       #
-      # Returns immediately if with_minify is false or the destination directory does not exist.
+      # Returns immediately if jekyll_minify.enabled is false (Configuration
+      # logs that once per build) or the destination directory does not exist.
       #
       # @param site [Jekyll::Site] the Jekyll site object providing dest and config
       # @return [Hash, nil] the run's @stats, or nil if minification was skipped
       def run(site)
-        unless plugin_enabled?(site.config)
-          Jekyll.logger.info 'jekyll-minify:', 'Minification disabled (with_minify: false).'
-          return
-        end
+        settings = Configuration.for(site.config)
+        return unless settings['enabled']
 
-        @minify_options = build_minify_options(site.config)
+        @minify_options = Configuration.minify_options(settings)
 
         dest = Pathname.new(site.dest)
         return unless dest.directory?
@@ -177,46 +172,38 @@ module Jekyll
 
       private
 
-      # Returns false if the site config explicitly disables the plugin.
-      # Defaults to true when the key is absent (matches with_link_decorator convention).
-      #
-      # @param site_config [Hash] Jekyll site configuration hash (site.config)
-      # @return [Boolean]
-      def plugin_enabled?(site_config)
-        site_config.key?('with_minify') ? site_config['with_minify'] : true
-      end
-
-      # Builds effective minify-html options by merging with_minify_data over defaults.
-      # YAML string keys from _config.yml are converted to symbols for minify-html.
-      # Unknown keys are passed through unchanged.
-      #
-      # @param site_config [Hash] Jekyll site configuration hash (site.config)
-      # @return [Hash{Symbol => Boolean}]
-      def build_minify_options(site_config)
-        overrides = (site_config['with_minify_data'] || {}).transform_keys(&:to_sym)
-        DEFAULT_MINIFY_OPTIONS.merge(overrides)
-      end
-
-      # Walks the destination directory and dispatches each eligible file.
+      # Dispatches each file discover_files finds in the destination directory.
       #
       # @param dest [Pathname] the Jekyll site destination directory
       # @return [void]
       def minify_each_file(dest)
-        dest.glob('**/*.{html,css,js}').each do |file_path|
+        discover_files(dest).each do |file_path|
           minify_file(file_path)
         end
       rescue StandardError => e
         Jekyll.logger.error 'jekyll-minify:', "Error during file discovery: #{e.message}"
       end
 
+      # Lists the HTML, CSS, and JS files under dest, including the ones
+      # minify_file then skips. Its own method so the minify.file_discovery
+      # span times the search alone, not the processing that follows.
+      #
+      # @param dest [Pathname] the Jekyll site destination directory
+      # @return [Array<Pathname>]
+      def discover_files(dest)
+        dest.glob('**/*.{html,css,js}')
+      end
+
       # Dispatches a single file to the appropriate minifier based on extension.
-      # Skips files already minified (*.min.css, *.min.js).
+      # Skips files already minified (*.min.css, *.min.js), and .js sources that
+      # already have a minified copy next to them: minifying one would rename the
+      # result onto that copy, replacing a vendor build (such as Bootstrap's).
       #
       # @param file_path [Pathname] path to the file to process
       # @return [void]
       def minify_file(file_path)
         # Skip already-minified files
-        return if file_path.to_s.end_with?('.min.css', '.min.js')
+        return skip_file if file_path.to_s.end_with?('.min.css', '.min.js')
 
         case file_path.extname.downcase
         when '.html'
@@ -224,12 +211,28 @@ module Jekyll
         when '.css'
           minify_with_fallback(file_path, :css)
         when '.js'
-          minify_with_fallback(file_path, :js, rename_to_min: true)
+          minify_js_file(file_path)
         end
       rescue StandardError => e
         Jekyll.logger.warn 'jekyll-minify:', "Unexpected error processing #{file_path}: #{e.message}"
       end
 
+      # Minifies a .js file and renames it to .min.js, unless a .min.js copy
+      # already exists next to it: minifying it would rename the result onto
+      # that copy, replacing a vendor build (such as Bootstrap's).
+      #
+      # @param file_path [Pathname] path to the .js file
+      # @return [void]
+      def minify_js_file(file_path)
+        if minified_sibling?(file_path)
+          Jekyll.logger.debug 'jekyll-minify:',
+                              "Skipping #{file_path}: #{file_path.sub_ext('.min.js').basename} already exists"
+          return skip_file
+        end
+
+        minify_with_fallback(file_path, :js, rename_to_min: true)
+      end
+
       # Minifies a file, restoring the original if anything goes wrong.
       # Skips non-UTF-8 files with a targeted warning.
       # Skips empty files.
@@ -243,13 +246,13 @@ module Jekyll
           original_content = file_path.read(encoding: 'UTF-8')
         rescue Encoding::InvalidByteSequenceError
           Jekyll.logger.warn 'jekyll-minify:', "Skipping #{file_path}: not valid UTF-8"
-          return
+          return skip_file
         end
 
         original_bytes = original_content.bytesize
 
         # Skip empty files
-        return if original_bytes.zero?
+        return skip_file if original_bytes.zero?
 
         begin
           minified = minify_by_type(original_content, type)
@@ -259,10 +262,20 @@ module Jekyll
                               rename_to_min: rename_to_min)
           record_minification_result(type, original_bytes, minified_bytes)
         rescue StandardError => e
-          restore_on_error(file_path, original_content, e)
+          restore_on_error(file_path, original_content, e, rename_to_min: rename_to_min)
         end
       end
 
+      # Counts a discovered file the plugin deliberately leaves unminified:
+      # already minified, a .js source with a .min.js copy, empty, or not
+      # UTF-8. Failed minifications are counted as errors instead.
+      #
+      # @return [void]
+      def skip_file
+        @stats[:skipped] += 1
+        nil
+      end
+
       # Validates that minification produced non-empty content.
       #
       # @param minified [String, nil] the minification output to validate
@@ -285,16 +298,55 @@ module Jekyll
       end
 
       # Logs a minification failure and restores the original file content.
+      # With rename_to_min, the original .js is also renamed to .min.js, so
+      # pages that link the .min.js name (as jekyll-theme-centos does) still
+      # load the script, unminified.
       #
       # @param file_path [Pathname] path to the file being restored
       # @param original_content [String] the unmodified file content to write back
       # @param error [StandardError] the error that triggered the restore
+      # @param rename_to_min [Boolean] if true, renames .js to .min.js
       # @return [void]
-      def restore_on_error(file_path, original_content, error)
+      def restore_on_error(file_path, original_content, error, rename_to_min: false)
+        file_path.write(original_content, encoding: 'UTF-8')
+        kept_as = rename_to_min ? keep_original_as_min_js(file_path) : file_path
         error_msg = "Failed to minify #{file_path}: #{error.message}"
+        error_msg += "; kept it unminified as #{kept_as.basename}" unless kept_as == file_path
         Jekyll.logger.warn 'jekyll-minify:', error_msg
         @stats[:errors] << error_msg
-        file_path.write(original_content, encoding: 'UTF-8')
+      end
+
+      # Whether a .min.js file with the same name as file_path already exists.
+      #
+      # @param file_path [Pathname] path to a .js file
+      # @return [Boolean]
+      def minified_sibling?(file_path)
+        file_path.sub_ext('.min.js').exist?
+      end
+
+      # Renames a .js file to .min.js; leaves any other file as is.
+      #
+      # @param file_path [Pathname] path to the file to rename
+      # @return [Pathname] the file's path after the rename
+      # @raise [SystemCallError] if the rename fails
+      def rename_to_min_js(file_path)
+        return file_path unless file_path.extname == '.js'
+
+        new_path = file_path.sub_ext('.min.js')
+        file_path.rename(new_path)
+        new_path
+      end
+
+      # Renames a restored .js file to .min.js. A failed rename is logged and
+      # leaves the file as .js, so the restore itself never fails on it.
+      #
+      # @param file_path [Pathname] path to the restored file
+      # @return [Pathname] the file's path after the attempt
+      def keep_original_as_min_js(file_path)
+        rename_to_min_js(file_path)
+      rescue StandardError => e
+        Jekyll.logger.warn 'jekyll-minify:', "Could not rename #{file_path} to .min.js: #{e.message}"
+        file_path
       end
 
       # Writes minified content to disk, optionally renaming .js to .min.js.
@@ -307,11 +359,7 @@ module Jekyll
       # @return [void]
       def write_minified_file(file_path, minified_content, original_content, rename_to_min: false)
         file_path.write(minified_content, encoding: 'UTF-8')
-
-        if rename_to_min && file_path.extname == '.js'
-          new_path = file_path.sub_ext('.min.js')
-          file_path.rename(new_path)
-        end
+        rename_to_min_js(file_path) if rename_to_min
       rescue StandardError => e
         # Restore original if write or rename fails
         file_path.write(original_content, encoding: 'UTF-8')
@@ -339,7 +387,7 @@ module Jekyll
 
       # Minifies HTML content using the minify-html gem.
       # Uses @minify_options which defaults to DEFAULT_MINIFY_OPTIONS but may be
-      # overridden via with_minify_data in _config.yml.
+      # overridden via jekyll_minify in _config.yml.
       #
       # @param content [String] raw HTML string
       # @return [String] minified HTML
@@ -351,24 +399,56 @@ module Jekyll
       end
 
       # Minifies CSS or JS content by wrapping it in a temporary HTML tag.
-      # Extracts the minified content between the first pair of wrapper tags.
+      # Extracts the minified content from the single wrapper element.
+      #
+      # The HTML parser ends the wrapper at the first closing-tag sequence, so
+      # content containing one would come back truncated. Such content is
+      # refused before minification (see #ensure_wrappable), and output whose
+      # extracted body still contains one (minify-html can unescape `<\/style`
+      # in CSS strings) is rejected, so the caller keeps the original file.
       #
       # @param content [String] raw CSS or JS string
       # @param wrapper_tag [String] HTML tag name ("style" or "script")
       # @param minify_option [Symbol] minify-html option key (:minify_css or :minify_js)
       # @return [String] minified content without wrapper tags
-      # @raise [RuntimeError] if the minification result is empty or the tag is not found
+      # @raise [RuntimeError] if the content cannot be wrapped safely, or the
+      #   output is not exactly one wrapper element
       def minify_wrapped_content(content, wrapper_tag, minify_option)
+        ensure_wrappable(content, wrapper_tag)
         wrapped  = "<#{wrapper_tag}>#{content}</#{wrapper_tag}>"
         minified = Kernel.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    = minified.match(%r{\A<#{wrapper_tag}>(.*)</#{wrapper_tag}>\z}m)
+        raise "minified output is not a single <#{wrapper_tag}> element" unless match
+        raise "minified output contains a closing </#{wrapper_tag}> sequence" if closing_tag?(match[1], wrapper_tag)
 
         match[1]
       rescue StandardError => e
         raise "#{wrapper_tag.upcase} minification failed: #{e.message}"
       end
 
+      # Raises if content contains a closing-tag sequence for wrapper_tag (any
+      # letter case), which would make minify-html end the wrapper early.
+      #
+      # @param content [String] raw CSS or JS string
+      # @param wrapper_tag [String] HTML tag name ("style" or "script")
+      # @raise [RuntimeError] if the content cannot be wrapped safely
+      # @return [void]
+      def ensure_wrappable(content, wrapper_tag)
+        return unless closing_tag?(content, wrapper_tag)
+
+        raise "content contains a closing </#{wrapper_tag}> sequence; left unminified to avoid truncation"
+      end
+
+      # Whether text contains the start of a closing tag for tag, in any
+      # letter case, as the HTML parser would recognize it.
+      #
+      # @param text [String] the text to search
+      # @param tag [String] HTML tag name
+      # @return [Boolean]
+      def closing_tag?(text, tag)
+        text.match?(%r{</#{tag}}i)
+      end
+
       # Minifies a CSS string by wrapping it in a <style> tag.
       #
       # @param content [String] raw CSS string

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-minify
 version: !ruby/object:Gem::Version
-  version: 1.1.6
+  version: 2.0.0
 platform: ruby
 authors:
 - Alain Reguera Delgado
@@ -35,14 +35,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.15'
+        version: 0.18.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.15'
+        version: 0.18.1
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
   requirement: !ruby/object:Gem::Requirement
@@ -207,6 +207,8 @@ files:
 - LICENSE
 - README.md
 - lib/jekyll-minify.rb
+- lib/jekyll-minify/configuration.rb
+- lib/jekyll-minify/configuration/schema.rb
 - lib/jekyll-minify/instrumentation.rb
 - lib/jekyll-minify/version.rb
 homepage: https://gitlab.com/CentOS/artwork/centos-web/jekyll-minify