jekyll-imgflow 0.3.3 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d59e73749066617a2c71322c3c80c5161ea847872a7864cf65c9133a8a315e24
-  data.tar.gz: 861a4df0428da9bdd3221b89838ebb4d85d598172465569b5cdc28e14f243ede
+  metadata.gz: e314c5d37485b9d821e58bd4614798c9e61e3b944c60f6bbb948fb50a6fe9c2b
+  data.tar.gz: f9b64d4bc5119727cda256d7e1b1fb77e9ee6c9a1b19e97175290cf8f23df1c9
 SHA512:
-  metadata.gz: aae0d3bb14c346d432881a29844b1221225599dd77767d087faccc14023f0d527fcc36c4eeb0e5a1df4fa9a87f86276ea42388e2364f7158f12af8ba0512d459
-  data.tar.gz: ba868a71465128a9f6f7259ad2852b7b16093b30496fd9a2e9d9f259e811908b2541b3f14a002475201a26576236921f76dbd52782797facb2d4a27e496c81de
+  metadata.gz: 9102a522a856e6fe440eb207b31c18d350e81a68055b13745ef835e51d257920e115b0054af3494534f9116e89616b13d99fd57c9aed132250bce6e98f280497
+  data.tar.gz: e6039b8fe325d7604fea5267c2f9fdfa40b8990647a8e0dfa936c7c2add4376b66cca4a28d8f548f6c0799321660f076902a27cba4dc3e734c424a683b7c0fdd

data/README.md

@@ -8,6 +8,7 @@ A [Jekyll](https://jekyllrb.com/) plugin for automatic image optimization with m
 [![Status](https://img.shields.io/badge/status-active-success)](https://github.com/gundestrup/jekyll-imgflow)
 [![Semgrep](https://img.shields.io/badge/Semgrep-scanned-1B2B34?logo=semgrep&logoColor=white)](https://semgrep.dev/)
 [![CodeFactor](https://www.codefactor.io/repository/github/gundestrup/jekyll-imgflow/badge)](https://www.codefactor.io/repository/github/gundestrup/jekyll-imgflow)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=gundestrup_jekyll-imgflow&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=gundestrup_jekyll-imgflow)
 [![codecov](https://codecov.io/gh/gundestrup/jekyll-imgflow/branch/main/graph/badge.svg)](https://codecov.io/gh/gundestrup/jekyll-imgflow)
 [![VS Code Extension](https://img.shields.io/badge/VS%20Code%20Companion-jekyll--imgflow-blue?logo=visual-studio-code)](https://github.com/gundestrup/jekyll-imgflow-vscode)
 [![License](https://img.shields.io/github/license/gundestrup/jekyll-imgflow)](LICENSE)
@@ -98,6 +99,28 @@ ImgFlow has two processing flows: **Build-Time** (pre-generation) and **Runtime*
 
 **See:** [providers.md](docs/providers.md) for detailed provider comparison and setup
 
+### SVG File Handling
+
+SVG files are supported as input by all providers. Since SVGs are vector
+graphics, they are rasterized before format conversion (WebP, AVIF, JPG, PNG).
+
+- **Weserv** (via librsvg): When an SVG has no explicit pixel dimensions
+  (e.g. `width="100%"` with a large `viewBox`), ImgFlow automatically
+  caps the rasterization at 2000px wide to prevent memory exhaustion.
+  If a resize or crop operation is present, the target dimensions are used
+  directly.
+- **Sharp, LibVips, Imgproxy, Flyimg**: Handle SVGs via their respective
+  rasterization backends. SVGs with very large viewBox dimensions may be
+  slow or fail depending on the provider's memory limits.
+- **ImageMagick**: SVG processing is slower than other providers without
+  the `librsvg` delegate installed. Set `FULL_SVG_TEST=true` to include
+  SVGs in ImageMagick test runs.
+
+SVGs with explicit `width` and `height` attributes (in pixels, not
+percentages) are always processed at the specified size first, then resized
+to the target dimensions — this is the recommended way to author SVGs for
+image processing.
+
 ## 🚀 Quick Commands
 
 ```bash

data/lib/jekyll-imgflow/build_time_processor.rb

@@ -44,35 +44,11 @@ module JekyllImgFlow
       original_paths = find_original_images
       Jekyll.logger.info "📸 Found #{original_paths.length} original images"
 
-      originals_dir = File.join(@site.source, @config.originals)
-
       # Clean up manifest entries for deleted originals
-      current_originals = original_paths.map { |path| path.sub("#{originals_dir}/", "") }
-      @manifest.cleanup_deleted_originals(current_originals)
-      @manifest.cleanup_obsolete_defaults(expected_default_operations)
-      @manifest.reset_page_usage unless incremental_build?
+      prepare_manifest(original_paths)
 
       # Build tasks for each original image
-      original_paths.reject { |path| AnimatedGifDetector.animated?(path) }.each do |path|
-        original_name = path.sub("#{originals_dir}/", "")
-        file_digest = @filename_generator.file_digest(path)
-
-        # Check if needs processing (file changed or provider changed)
-        if needs_processing?(original_name, path, file_digest)
-          Jekyll.logger.info "🔧 Queuing default versions for: #{original_name}"
-
-          # Build default tasks
-          tasks = BatchManager.build_default_tasks(
-            original_name, path, @config, @site, file_digest: file_digest
-          )
-          force_processing = source_digest_changed?(original_name, file_digest)
-          tasks.each { |task| task[:force_processing] = force_processing }
-          @batch_manager.add_tasks(tasks)
-        else
-          expected_default_operations.length.times { @operation_processor.stats.record_cache_hit }
-          Jekyll.logger.debug "⏭️  Skipping #{original_name} - already up-to-date"
-        end
-      end
+      queue_default_tasks(original_paths)
 
       # Process all queued tasks
       results = @batch_manager.process_all
@@ -89,6 +65,39 @@ module JekyllImgFlow
 
     private
 
+    def prepare_manifest(original_paths)
+      originals_dir = File.join(@site.source, @config.originals)
+      current_originals = original_paths.map { |path| path.sub("#{originals_dir}/", "") }
+      @manifest.cleanup_deleted_originals(current_originals)
+      @manifest.cleanup_obsolete_defaults(expected_default_operations)
+      @manifest.reset_page_usage unless incremental_build?
+    end
+
+    def queue_default_tasks(original_paths)
+      originals_dir = File.join(@site.source, @config.originals)
+      original_paths.reject { |path| AnimatedGifDetector.animated?(path) }.each do |path|
+        queue_tasks_for(path, path.sub("#{originals_dir}/", ""))
+      end
+    end
+
+    def queue_tasks_for(path, original_name)
+      file_digest = @filename_generator.file_digest(path)
+      unless needs_processing?(original_name, path, file_digest)
+        expected_default_operations.length.times { @operation_processor.stats.record_cache_hit }
+        Jekyll.logger.debug "⏭️  Skipping #{original_name} - already up-to-date"
+        return
+      end
+
+      Jekyll.logger.info "🔧 Queuing default versions for: #{original_name}"
+
+      tasks = BatchManager.build_default_tasks(
+        original_name, path, @config, @site, file_digest: file_digest
+      )
+      force_processing = source_digest_changed?(original_name, file_digest)
+      tasks.each { |task| task[:force_processing] = force_processing }
+      @batch_manager.add_tasks(tasks)
+    end
+
     def register_skipped_tasks(completed_tasks)
       provider_name = @registry.current_provider&.class&.provider_name || "unknown"
       completed_tasks.each do |completed|
@@ -127,13 +136,17 @@ module JekyllImgFlow
       current_provider = @registry.current_provider&.class&.provider_name || "unknown"
 
       expected_default_operations.any? do |operations|
-        version = default_versions.find do |candidate|
-          @manifest.same_operations?(candidate["operations"], operations)
-        end
+        version = find_default_version(default_versions, operations)
         !current_default_version?(version, current_provider, file_digest)
       end
     end
 
+    def find_default_version(default_versions, operations)
+      default_versions.find do |candidate|
+        @manifest.same_operations?(candidate["operations"], operations)
+      end
+    end
+
     def expected_default_operations
       @config.sizes.each_value.flat_map do |width|
         @config.formats.map do |format|

data/lib/jekyll-imgflow/config.rb

@@ -22,6 +22,18 @@ module JekyllImgFlow
     DEFAULT_FALLBACK_FORMAT = "jpg"
     DEFAULT_IMAGE_MODAL = true
 
+    # Core config keys mapped to their defaults (assigned as @ivar per key).
+    CORE_CONFIG_DEFAULTS = {
+      "originals" => DEFAULT_ORIGINALS,
+      "output" => DEFAULT_OUTPUT,
+      "input_formats" => DEFAULT_INPUT_FORMATS,
+      "sizes" => DEFAULT_SIZES,
+      "formats" => DEFAULT_FORMATS,
+      "quality" => DEFAULT_QUALITY,
+      "backend_priority" => DEFAULT_BACKEND_PRIORITY,
+      "fallback_format" => DEFAULT_FALLBACK_FORMAT
+    }.freeze
+
     attr_reader :site, :originals, :output, :input_formats, :sizes, :formats,
                 :quality, :backend_priority, :imgproxy_url,
                 :weserv_url, :flyimg_url,
@@ -37,14 +49,9 @@ module JekyllImgFlow
     end
 
     def assign_core_config(cfg)
-      @originals = cfg["originals"] || DEFAULT_ORIGINALS
-      @output = cfg["output"] || DEFAULT_OUTPUT
-      @input_formats = cfg["input_formats"] || DEFAULT_INPUT_FORMATS
-      @sizes = cfg["sizes"] || DEFAULT_SIZES
-      @formats = cfg["formats"] || DEFAULT_FORMATS
-      @quality = cfg["quality"] || DEFAULT_QUALITY
-      @backend_priority = cfg["backend_priority"] || DEFAULT_BACKEND_PRIORITY
-      @fallback_format = cfg["fallback_format"] || DEFAULT_FALLBACK_FORMAT
+      CORE_CONFIG_DEFAULTS.each do |key, default|
+        instance_variable_set("@#{key}", cfg[key] || default)
+      end
       @image_modal = cfg.fetch("image_modal", DEFAULT_IMAGE_MODAL)
     end
 

data/lib/jekyll-imgflow/modal_assets.rb

@@ -135,17 +135,23 @@ module JekyllImgFlow
 
       max_width = @config.sizes.values.max
       Dir.children(directory).filter_map do |filename|
-        candidate = JekyllImgFlow::FilenameGenerator.new.parse_filename(filename)
-        next unless candidate[:base_name] == parsed[:base_name]
-        next unless candidate[:hash] == parsed[:hash]
-        next if max_width && candidate[:width] > max_width
-
-        File.join(File.dirname(result), filename)
+        matching_variant_path(filename, parsed, max_width, result)
       end
     rescue Errno::ENOENT
       []
     end
 
+    # Return the output path for +filename+ when it is a variant of the same
+    # image (same base name and content hash) within the max configured width.
+    def matching_variant_path(filename, parsed, max_width, result)
+      candidate = JekyllImgFlow::FilenameGenerator.new.parse_filename(filename)
+      return unless candidate[:base_name] == parsed[:base_name]
+      return unless candidate[:hash] == parsed[:hash]
+      return if max_width && candidate[:width] > max_width
+
+      File.join(File.dirname(result), filename)
+    end
+
     def modal_width(result)
       JekyllImgFlow::FilenameGenerator.new.parse_filename(File.basename(result))[:width] || 0
     end

data/lib/jekyll-imgflow/parser.rb

@@ -110,44 +110,51 @@ module JekyllImgFlow
       operations = []
       operation_options = options.slice(*OPERATION_PARAMS)
 
-      # Handle crop+resize combination (needs sequential processing)
-      has_crop = operation_options[:ratio] || operation_options[:aspect_ratio]
-      has_resize = operation_options[:width] || operation_options[:height]
+      add_crop_resize_operations(operations, operation_options)
+      add_simple_operations(operations, operation_options)
+      add_format_operation(operations, operation_options)
+      add_optimize_operation(operations, operation_options)
+
+      operations
+    end
+
+    def self.add_crop_resize_operations(operations, opts)
+      has_crop = opts[:ratio] || opts[:aspect_ratio]
+      has_resize = opts[:width] || opts[:height]
+      crop_params = opts.slice(:ratio, :aspect_ratio, :keep, :position)
 
       if has_crop && has_resize
-        crop_params = operation_options.slice(:ratio, :aspect_ratio, :keep, :position)
-        resize_params = operation_options.except(:ratio, :aspect_ratio, :keep, :position)
         operations << { type: :crop, params: crop_params }
-        operations << { type: :resize, params: resize_params }
+        operations << { type: :resize, params: opts.except(:ratio, :aspect_ratio, :keep, :position) }
       elsif has_crop
-        crop_params = operation_options.slice(:ratio, :aspect_ratio, :keep, :position)
         operations << { type: :crop, params: crop_params }
       elsif has_resize
-        operations << { type: :resize, params: operation_options }
+        operations << { type: :resize, params: opts }
       end
+    end
 
-      # Add simple operations using mappings
+    def self.add_simple_operations(operations, opts)
       SIMPLE_OPERATIONS.each do |key, builder|
-        operations << builder.call(operation_options[key]) if operation_options[key]
+        operations << builder.call(opts[key]) if opts[key]
       end
+    end
 
-      # Handle format operation (can be array or single value)
-      if operation_options[:format] || operation_options[:formats]
-        format_value = operation_options[:format] || operation_options[:formats]
-        operations << if format_value.is_a?(Array)
-                        { type: :format, params: { formats: format_value } }
-                      else
-                        { type: :format, params: { format: format_value } }
-                      end
-      end
+    def self.add_format_operation(operations, opts)
+      return unless opts[:format] || opts[:formats]
 
-      # Handle optimize operation
-      if operation_options[:optimize] || operation_options[:level]
-        operations << { type: :optimize,
-                        params: { level: operation_options[:level] || :medium } }
-      end
+      format_value = opts[:format] || opts[:formats]
+      operations << if format_value.is_a?(Array)
+                      { type: :format, params: { formats: format_value } }
+                    else
+                      { type: :format, params: { format: format_value } }
+                    end
+    end
 
-      operations
+    def self.add_optimize_operation(operations, opts)
+      return unless opts[:optimize] || opts[:level]
+
+      operations << { type: :optimize,
+                      params: { level: opts[:level] || :medium } }
     end
 
     def self.extract_html_attributes(options)

data/lib/jekyll-imgflow/picture_tag_preset_migrator.rb

@@ -99,61 +99,11 @@ module JekyllImgFlow
     # @return [Hash, nil] ImgFlow preset data or nil if not convertible
     def convert_preset_to_imgflow(preset_name, preset_data)
       operations = []
-
-      # Handle multi-width presets - use the largest width as primary
-      if preset_data["widths"]
-        max_width = Array(preset_data["widths"]).max
-        operations << { "resize" => { "width" => max_width } }
-      elsif preset_data["base_width"]
-        # For pixel-ratio presets, use base_width
-        operations << { "resize" => { "width" => preset_data["base_width"] } }
-      elsif preset_data["width"]
-        # Direct width setting
-        operations << { "resize" => { "width" => preset_data["width"] } }
-      end
-
-      # Handle height (less common in Picture Tag)
-      if preset_data["height"]
-        if operations.any? && operations.last["resize"]
-          # Add height to existing resize operation
-          operations.last["resize"]["height"] = preset_data["height"]
-        else
-          operations << { "resize" => { "height" => preset_data["height"] } }
-        end
-      end
-
-      # Convert quality (if specified)
-      operations << { "quality" => { "quality" => preset_data["quality"] } } if preset_data["quality"]
-
-      # Convert formats - Picture Tag uses 'original', ImgFlow uses actual format
-      if preset_data["formats"]
-        formats = Array(preset_data["formats"]).map do |format|
-          case format
-          when "original"
-            "jpg" # Default to jpg for 'original'
-          else
-            format
-          end
-        end
-        operations << { "format" => { "formats" => formats } }
-      end
-
-      # Convert crop (aspect ratio) - handle both ratio and aspect_ratio with precedence
-      ratio_value = preset_data["ratio"] || preset_data["aspect_ratio"] || preset_data["crop"]
-      operations << { "crop" => { "ratio" => ratio_value } } if ratio_value
-
-      # Convert gravity/position - handle both position and gravity with precedence
-      position_value = preset_data["position"] || preset_data["gravity"]
-      if position_value
-        if operations.any? { |op| op["crop"] }
-          # Add to existing crop operation
-          crop_op = operations.find { |op| op["crop"] }
-          crop_op["crop"]["position"] = position_value
-        else
-          # Create new crop operation
-          operations << { "crop" => { "position" => position_value } }
-        end
-      end
+      add_resize_operation(operations, preset_data)
+      add_quality_operation(operations, preset_data)
+      add_format_operation(operations, preset_data)
+      add_crop_operation(operations, preset_data)
+      add_position_operation(operations, preset_data)
 
       return if operations.empty?
 
@@ -171,30 +121,84 @@ module JekyllImgFlow
       }
     end
 
+    def add_resize_operation(operations, preset_data)
+      width = preset_width(preset_data)
+      operations << { "resize" => { "width" => width } } if width
+
+      return unless preset_data["height"]
+
+      if operations.any? && operations.last["resize"]
+        operations.last["resize"]["height"] = preset_data["height"]
+      else
+        operations << { "resize" => { "height" => preset_data["height"] } }
+      end
+    end
+
+    def preset_width(preset_data)
+      return Array(preset_data["widths"]).max if preset_data["widths"]
+      return preset_data["base_width"] if preset_data["base_width"]
+
+      preset_data["width"] if preset_data["width"]
+    end
+
+    def add_quality_operation(operations, preset_data)
+      return unless preset_data["quality"]
+
+      operations << { "quality" => { "quality" => preset_data["quality"] } }
+    end
+
+    def add_format_operation(operations, preset_data)
+      return unless preset_data["formats"]
+
+      formats = Array(preset_data["formats"]).map do |format|
+        format == "original" ? "jpg" : format
+      end
+      operations << { "format" => { "formats" => formats } }
+    end
+
+    def add_crop_operation(operations, preset_data)
+      ratio_value = preset_data["ratio"] || preset_data["aspect_ratio"] || preset_data["crop"]
+      operations << { "crop" => { "ratio" => ratio_value } } if ratio_value
+    end
+
+    def add_position_operation(operations, preset_data)
+      position_value = preset_data["position"] || preset_data["gravity"]
+      return unless position_value
+
+      crop_op = operations.find { |op| op["crop"] }
+      if crop_op
+        crop_op["crop"]["position"] = position_value
+      else
+        operations << { "crop" => { "position" => position_value } }
+      end
+    end
+
     # Generate description for ImgFlow preset
     # @param preset_name [String] Preset name
     # @param preset_data [Hash] Original preset data
     # @return [String] Description
     def generate_description(preset_name, preset_data)
-      operations = []
+      parts = []
+      add_width_description(parts, preset_data)
+      parts << "height: #{preset_data['height']}" if preset_data["height"]
+      parts << "quality: #{preset_data['quality']}" if preset_data["quality"]
+      parts << "formats: #{Array(preset_data['formats']).join(',')}" if preset_data["formats"]
+      parts << "crop: #{preset_data['crop']}" if preset_data["crop"]
+      parts << "gravity: #{preset_data['gravity']}" if preset_data["gravity"]
+
+      "Migrated from Picture Tag preset '#{preset_name}'. #{parts.join(', ')}"
+    end
 
+    def add_width_description(parts, preset_data)
       if preset_data["widths"]
-        operations << "widths: #{Array(preset_data['widths']).join(',')}"
-        operations << "using max width: #{Array(preset_data['widths']).max}"
+        parts << "widths: #{Array(preset_data['widths']).join(',')}"
+        parts << "using max width: #{Array(preset_data['widths']).max}"
       elsif preset_data["base_width"]
-        operations << "base_width: #{preset_data['base_width']}"
-        operations << "pixel_ratios: #{Array(preset_data['pixel_ratios']).join(',')}"
+        parts << "base_width: #{preset_data['base_width']}"
+        parts << "pixel_ratios: #{Array(preset_data['pixel_ratios']).join(',')}"
       elsif preset_data["width"]
-        operations << "width: #{preset_data['width']}"
+        parts << "width: #{preset_data['width']}"
       end
-
-      operations << "height: #{preset_data['height']}" if preset_data["height"]
-      operations << "quality: #{preset_data['quality']}" if preset_data["quality"]
-      operations << "formats: #{Array(preset_data['formats']).join(',')}" if preset_data["formats"]
-      operations << "crop: #{preset_data['crop']}" if preset_data["crop"]
-      operations << "gravity: #{preset_data['gravity']}" if preset_data["gravity"]
-
-      "Migrated from Picture Tag preset '#{preset_name}'. #{operations.join(', ')}"
     end
 
     # Save ImgFlow preset to YAML file

data/lib/jekyll-imgflow/preset_manager.rb

@@ -132,55 +132,65 @@ module JekyllImgFlow
     # @return [Hash] Tags in key => value format
     def yaml_to_tags(preset)
       tags = {}
-      preset_operations = preset["operations"] || []
-
-      preset_operations.each do |op|
+      (preset["operations"] || []).each do |op|
         next unless op.is_a?(Hash)
 
         op.each do |op_type, params|
           next unless params.is_a?(Hash)
 
-          # Store operation type for operations that don't have specific params
-          # This allows Parser to detect the operation type
-          case op_type.to_s
-          when "resize"
-            # Resize params: width, height (both optional, at least one required)
-            tags[:width] = params["width"] if params["width"]
-            tags[:height] = params["height"] if params["height"]
-          when "crop"
-            # Crop params: ratio or width/height
-            tags[:ratio] = params["ratio"] if params["ratio"]
-            tags[:aspect_ratio] = params["aspect_ratio"] if params["aspect_ratio"]
-            tags[:width] = params["width"] if params["width"] && !tags[:width]
-            tags[:height] = params["height"] if params["height"] && !tags[:height]
-          when "format"
-            # Format params: format or formats
-            if params["formats"]
-              tag_value = params["formats"].is_a?(Array) ? params["formats"].join(",") : params["formats"]
-              tags[:formats] = tag_value
-            elsif params["format"]
-              tags[:format] = params["format"]
-            end
-          when "quality"
-            tags[:quality] = params["quality"] if params["quality"]
-          when "optimize"
-            tags[:optimize] = true
-            tags[:level] = params["level"] if params["level"]
-          when "opacity"
-            tags[:opacity] = params["opacity"] if params["opacity"]
-          else
-            # Generic handling for unknown operations
-            params.each do |key, value|
-              tag_value = value.is_a?(Array) ? value.join(",") : value
-              tags[key.to_sym] = tag_value
-            end
-          end
+          merge_operation_tags(tags, op_type.to_s, params)
         end
       end
 
       tags
     end
 
+    def merge_operation_tags(tags, op_type, params)
+      case op_type
+      when "resize" then merge_resize_tags(tags, params)
+      when "crop" then merge_crop_tags(tags, params)
+      when "format" then merge_format_tag(tags, params)
+      when "quality" then tags[:quality] = params["quality"] if params["quality"]
+      when "optimize" then merge_optimize_tags(tags, params)
+      when "opacity" then tags[:opacity] = params["opacity"] if params["opacity"]
+      else
+        merge_generic_tags(tags, params)
+      end
+    end
+
+    def merge_resize_tags(tags, params)
+      tags[:width] = params["width"] if params["width"]
+      tags[:height] = params["height"] if params["height"]
+    end
+
+    def merge_crop_tags(tags, params)
+      tags[:ratio] = params["ratio"] if params["ratio"]
+      tags[:aspect_ratio] = params["aspect_ratio"] if params["aspect_ratio"]
+      tags[:width] = params["width"] if params["width"] && !tags[:width]
+      tags[:height] = params["height"] if params["height"] && !tags[:height]
+    end
+
+    def merge_optimize_tags(tags, params)
+      tags[:optimize] = true
+      tags[:level] = params["level"] if params["level"]
+    end
+
+    def merge_format_tag(tags, params)
+      if params["formats"]
+        tag_value = params["formats"].is_a?(Array) ? params["formats"].join(",") : params["formats"]
+        tags[:formats] = tag_value
+      elsif params["format"]
+        tags[:format] = params["format"]
+      end
+    end
+
+    def merge_generic_tags(tags, params)
+      params.each do |key, value|
+        tag_value = value.is_a?(Array) ? value.join(",") : value
+        tags[key.to_sym] = tag_value
+      end
+    end
+
     # Merge preset tags with user options (user options override)
     # @param preset_tags [Hash] Tags from preset
     # @param user_options [Hash] User-provided options