jekyll-imgflow 0.1.9 → 0.2.0

data/lib/jekyll-imgflow/providers/libvips.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "shellwords"
 require "open3"
+require "fileutils"
 require_relative "base_provider"
 
 module JekyllImgFlow
@@ -17,15 +17,20 @@ module JekyllImgFlow
       def execute(input_path, output_path)
         return if @operations.empty?
 
-        # Build single vips command with all operations
-        command = build_vips_command(input_path, output_path)
-        execute_command(command)
+        # Build and execute vips commands (array form, no shell).
+        # Cleanup markers ([:cleanup, path]) are handled by execute_command.
+        commands = build_vips_commands(input_path, output_path)
+        commands.each { |cmd_array| execute_command(cmd_array) }
 
-        reset_operations
         output_path
+      ensure
+        reset_operations
       end
 
-      def build_vips_command(input_path, output_path)
+      # Build all vips commands as an array of command arrays.
+      # Each sub-array is passed directly to Open3.capture3 (no shell).
+      # Returns Array[Array[String]].
+      def build_vips_commands(input_path, output_path)
         has_crop = @operations.any? { |op| op[:type] == :crop }
         has_resize = @operations.any? { |op| op[:type] == :resize }
         has_watermark = @operations.any? { |op| op[:type] == :watermark }
@@ -38,20 +43,32 @@ module JekyllImgFlow
         elsif has_crop && has_resize
           build_sequential_crop_resize(input_path, output_path)
         elsif has_resize
-          build_resize_command(input_path, output_path)
+          [build_resize_command(input_path, output_path)]
         elsif has_crop
-          build_crop_command(input_path, output_path)
+          svg?(input_path) ? build_svg_crop_pipeline(input_path, output_path) : [build_crop_command(input_path, output_path)]
         else
-          build_copy_command(input_path, output_path)
+          [build_copy_command(input_path, output_path)]
         end
       end
 
+      # Convenience wrapper for backward compatibility with tests.
+      # Returns the commands joined as a debug string.
+      def build_vips_command(input_path, output_path)
+        build_vips_commands(input_path, output_path).map do |cmd|
+          if cmd.is_a?(Array) && cmd.first == :cleanup
+            "rm -f #{cmd[1]}"
+          else
+            cmd.join(" ")
+          end
+        end.join(" && ")
+      end
+
       def build_alpha_pipeline(input_path, output_path, has_crop, has_resize)
         commands = []
         temp_path = input_path.gsub(/\.[^.]+$/, ".tmp_base.jpg")
 
         if has_crop && has_resize
-          commands << build_sequential_crop_resize(input_path, temp_path)
+          commands.concat(build_sequential_crop_resize(input_path, temp_path))
           base_path = temp_path
         elsif has_resize
           commands << build_resize_command(input_path, temp_path)
@@ -64,19 +81,18 @@ module JekyllImgFlow
         end
 
         commands << build_alpha_command(base_path, output_path)
-        commands << "rm -f #{temp_path.shellescape}" unless base_path == input_path
-        commands.join(" && ")
+        commands << [:cleanup, temp_path] unless base_path == input_path
+        commands
       end
 
       def build_watermark_pipeline(input_path, output_path, has_crop, has_resize)
         temp_path = input_path.gsub(/\.[^.]+$/, ".tmp_base.jpg")
-        final_path = output_path
 
         commands = []
 
         # Step 1: Process crop/resize/copy to produce base image
         if has_crop && has_resize
-          commands << build_sequential_crop_resize(input_path, temp_path)
+          commands.concat(build_sequential_crop_resize(input_path, temp_path))
           base_path = temp_path
         elsif has_resize
           commands << build_resize_command(input_path, temp_path)
@@ -97,106 +113,115 @@ module JekyllImgFlow
         end
 
         # Step 3: Composite watermark over base
-        commands << build_composite_command(base_path, final_path)
+        commands.concat(build_composite_commands(base_path, output_path))
 
         # Step 4: Cleanup temp files
         temp_files = [temp_path, base_path == input_path ? nil : base_path].compact
-        temp_files.each { |f| commands << "rm -f #{f.shellescape}" }
+        temp_files.each { |f| commands << [:cleanup, f] }
 
-        commands.join(" && ")
+        commands
       end
 
-      def build_composite_command(base_path, output_path)
+      def build_composite_commands(base_path, output_path)
         wm_op = @operations.find { |op| op[:type] == :watermark }
         watermark_path = wm_op[:watermark_path]
         position = wm_op[:options][:position]
         opacity = wm_op[:options][:opacity]
-        format_spec = build_format_spec(output_path)
 
         if opacity && opacity < 1.0
           wm_temp = watermark_path.gsub(/\.[^.]+$/, ".tmp_wm.png")
           alpha_value = opacity
-          temp_cmd = ["vips", "linear", watermark_path.shellescape,
-                      "'#{wm_temp}[alpha]'", "\"1 1 1 #{alpha_value}\"", "0"].join(" ")
-          full_cmd = ["#{temp_cmd} && vips composite2",
-                      base_path.shellescape, wm_temp.shellescape,
-                      format_spec, "over",
-                      position_to_vips_xy(position, base_path, watermark_path)].join(" ")
-          # Add cleanup
-          "#{full_cmd} && rm -f #{wm_temp.shellescape}"
+          # Step 1: Apply alpha to watermark
+          alpha_cmd = ["vips", "linear", watermark_path,
+                       "#{wm_temp}[alpha]", "1 1 1 #{alpha_value}", "0"]
+          # Step 2: Composite
+          xy_args = position_to_vips_xy(position, base_path, watermark_path)
+          composite_cmd = ["vips", "composite2", base_path, wm_temp,
+                           build_format_spec(output_path), "over"] + xy_args
+          # Step 3: Cleanup wm_temp
+          [alpha_cmd, composite_cmd, [:cleanup, wm_temp]]
         else
-          ["vips", "composite2", base_path.shellescape,
-           watermark_path.shellescape, format_spec, "over",
-           position_to_vips_xy(position, base_path, watermark_path)].join(" ")
+          xy_args = position_to_vips_xy(position, base_path, watermark_path)
+          [["vips", "composite2", base_path, watermark_path,
+            build_format_spec(output_path), "over"] + xy_args]
         end
       end
 
+      # Return x/y arguments as an array of strings (no shell substitution).
+      # Pre-computes image dimensions via vips header in Ruby.
       def position_to_vips_xy(position, _base_path, watermark_path)
-        # Get image dimensions to calculate x/y from compass positions
-        # vips composite2 uses --x and --y for overlay placement
         case position.to_s
         when "northeast", "top-right"
-          # Need watermark width; use shell substitution
-          "--x $(vips header #{watermark_path.shellescape} width) --y 0"
+          width = vips_image_dimension(watermark_path, "width")
+          ["--x", width.to_s, "--y", "0"]
         when "southwest", "bottom-left"
-          "--x 0 --y $(vips header #{watermark_path.shellescape} height)"
+          height = vips_image_dimension(watermark_path, "height")
+          ["--x", "0", "--y", height.to_s]
         when "southeast", "bottom-right"
-          "--x $(vips header #{watermark_path.shellescape} width) " \
-          "--y $(vips header #{watermark_path.shellescape} height)"
+          width = vips_image_dimension(watermark_path, "width")
+          height = vips_image_dimension(watermark_path, "height")
+          ["--x", width.to_s, "--y", height.to_s]
         else
-          "--x 0 --y 0" # northwest, top-left, center, centre, and default
+          ["--x", "0", "--y", "0"] # northwest, top-left, center, centre, and default
         end
       end
 
+      # Get an image dimension (width or height) using vips header.
+      # Returns integer or 0 if vips is unavailable.
+      def vips_image_dimension(image_path, field)
+        stdout, _, status = Open3.capture3("vips", "header", image_path, field)
+        return 0 unless status.success?
+
+        stdout.strip.to_i
+      rescue StandardError
+        0
+      end
+
       def build_alpha_command(input_path, output_path)
         alpha_op = @operations.find { |op| op[:type] == :alpha_opacity }
         opacity = alpha_op[:opacity]
         alpha_value = opacity.round(2)
 
         # vips linear multiplies alpha band: "1 1 1 alpha" scales alpha
-        ["vips", "linear", input_path.shellescape, output_path.shellescape,
-         "\"1 1 1 #{alpha_value}\"", "0"].join(" ")
+        ["vips", "linear", input_path, output_path,
+         "1 1 1 #{alpha_value}", "0"]
       end
 
       def build_sequential_crop_resize(input_path, output_path)
-        # Build temp file path for intermediate crop result
-        temp_path = input_path.gsub(/\.[^.]+$/, ".tmp_crop.jpg")
-
-        # First command: crop only
-        crop_cmd = build_crop_command(input_path, temp_path)
-
-        # Second command: resize + format + quality + alpha (all together)
-        resize_cmd = build_resize_command(temp_path, output_path)
-
-        # Combine with && and cleanup temp file
-        "#{crop_cmd} && #{resize_cmd} && rm -f #{temp_path.shellescape}"
+        if svg?(input_path)
+          # SVG: use thumbnail with --crop to do crop+resize in one step
+          resize_op = @operations.find { |op| op[:type] == :resize }
+          format_spec = build_format_spec(output_path)
+          width = resize_op[:width]
+          height = resize_op[:height]
+          [["vips", "thumbnail", input_path, format_spec,
+            width.to_s, "--height=#{height}", "--crop=attention"]]
+        else
+          temp_path = input_path.gsub(/\.[^.]+$/, ".tmp_crop.jpg")
+          [build_crop_command(input_path, temp_path),
+           build_resize_command(temp_path, output_path),
+           [:cleanup, temp_path]]
+        end
       end
 
       def build_resize_command(input_path, output_path)
         resize_op = @operations.find { |op| op[:type] == :resize }
-        resize_data = resize_op[:options] || {}
-
-        if resize_op[:width] && resize_op[:height]
-          # Both dimensions specified - use VipsResize with vscale for exact dimensions
-          # ResizeTag has already done the calculations, so we use both scale factors
-          scale_x = resize_data[:scale_x]
-          scale_y = resize_data[:scale_y]
-          format_spec = build_format_spec(output_path)
-
-          # Only add vscale if we have both scale factors
-          if scale_x && scale_y
-            ["vips", "VipsResize", input_path.shellescape, format_spec,
-             scale_x.to_s, "--vscale=#{scale_y}"].join(" ")
-          else
-            # Fallback to scale_x only if scale_y is missing
-            ["vips", "VipsResize", input_path.shellescape, format_spec,
-             (scale_x || 1.0).to_s].join(" ")
-          end
+        format_spec = build_format_spec(output_path)
+        width = resize_op[:width]
+        height = resize_op[:height]
+
+        # Use `vips thumbnail` for all resize operations. thumbnail is the
+        # recommended high-level resize API — it uses shrink-on-load for
+        # JPEGs (efficient), handles SVGs safely by bounding render size
+        # during load, and supports all image formats.
+        # See https://www.libvips.org/API/current/func.thumbnail.html
+        if width && height
+          # Both dimensions: thumbnail to width, cap height, crop to fill
+          ["vips", "thumbnail", input_path, format_spec,
+           width.to_s, "--height=#{height}", "--crop=attention"]
         else
-          # Only one dimension - use VipsResize with scale_x (maintain aspect ratio)
-          scale_x = resize_data[:scale_x] || 1.0
-          format_spec = build_format_spec(output_path)
-          ["vips", "VipsResize", input_path.shellescape, format_spec, scale_x.to_s].join(" ")
+          # Only width: thumbnail maintains aspect ratio
+          ["vips", "thumbnail", input_path, format_spec, width.to_s]
         end
       end
 
@@ -204,81 +229,108 @@ module JekyllImgFlow
         crop_op = @operations.find { |op| op[:type] == :crop }
         opts = crop_op[:options] || {}
         params = crop_op[:params] || {}
-
-        # Check if we should use smartcrop (when keep parameter is specified)
-        # JPT keep options: attention (default), entropy, center
-        # Check both options (from CropTag) and params (from OperationProcessor)
         keep = opts[:keep] || params[:keep] || params[:position]
 
         if crop_op[:ratio] && keep && %w[attention entropy center
                                          centre].include?(keep.to_s)
-          # Use libvips smartcrop for intelligent cropping
           crop_width = opts[:calculated_width]
           crop_height = opts[:calculated_height]
-
-          # Map keep parameter to libvips interestingness
           interestingness = case keep.to_s
                             when "entropy" then "entropy"
                             when "center", "centre" then "centre"
-                            else "attention" # default
+                            else "attention"
                             end
-
-          # vips smartcrop input.jpg output.jpg width height --interesting=attention
-          ["vips", "smartcrop", input_path.shellescape, output_path.shellescape,
+          ["vips", "smartcrop", input_path, output_path,
            crop_width.to_s, crop_height.to_s,
-           "--interesting=#{interestingness}"].join(" ")
+           "--interesting=#{interestingness}"]
         else
-          # Use basic extract_area for manual cropping or when no keep parameter
           crop_x = crop_op[:ratio] ? opts[:calculated_x] : (opts[:x] || 0)
           crop_y = crop_op[:ratio] ? opts[:calculated_y] : (opts[:y] || 0)
           crop_width = crop_op[:ratio] ? opts[:calculated_width] : opts[:width]
           crop_height = crop_op[:ratio] ? opts[:calculated_height] : opts[:height]
-
-          # vips extract_area input.jpg output.jpg left top width height
-          ["vips", "extract_area", input_path.shellescape, output_path.shellescape,
-           crop_x.to_s, crop_y.to_s, crop_width.to_s, crop_height.to_s].join(" ")
+          ["vips", "extract_area", input_path, output_path,
+           crop_x.to_s, crop_y.to_s, crop_width.to_s, crop_height.to_s]
         end
       end
 
+      # SVG crop: use `vips thumbnail` with --crop to crop during thumbnailing.
+      # This avoids the coordinate mismatch that occurs when rasterizing at a
+      # different size than the SVG's viewBox (which caused "bad extract area").
+      # thumbnail --crop uses smartcrop (attention/entropy/centre) to select
+      # the most interesting region — this is the correct behavior for SVGs
+      # since they have no fixed pixel dimensions.
+      def build_svg_crop_pipeline(input_path, output_path)
+        crop_op = @operations.find { |op| op[:type] == :crop }
+        opts = crop_op[:options] || {}
+        crop_width = crop_op[:ratio] ? opts[:calculated_width] : (opts[:width] || 1000)
+        crop_height = crop_op[:ratio] ? opts[:calculated_height] : (opts[:height] || 1000)
+        format_spec = build_format_spec(output_path)
+
+        keep = opts[:keep] || crop_op[:params]&.[](:keep) || crop_op[:params]&.[](:position)
+        interestingness = case keep.to_s
+                          when "entropy" then "entropy"
+                          when "center", "centre" then "centre"
+                          else "attention"
+                          end
+
+        [["vips", "thumbnail", input_path, format_spec,
+          crop_width.to_s, "--height=#{crop_height}",
+          "--crop=#{interestingness}"]]
+      end
+
       def build_copy_command(input_path, output_path)
-        # vips copy input.jpg output.jpg[format]
         format_spec = build_format_spec(output_path)
-        ["vips", "copy", input_path.shellescape, format_spec].join(" ")
+        # For SVGs, `vips copy` rasterizes at intrinsic size (potentially
+        # huge). Use thumbnail with a large cap to bound the render safely.
+        return ["vips", "thumbnail", input_path, format_spec, "2000"] if svg?(input_path)
+
+        # vips copy input.jpg output.jpg[format]
+        ["vips", "copy", input_path, format_spec]
       end
 
+      # Build vips output specification with format and quality.
+      # Returns a raw string — no shell quoting needed since commands
+      # are executed via Open3.capture3 array form (no shell).
       def build_format_spec(output_path)
         # Build vips output specification with format and quality
         format_op = @operations.find { |op| op[:type] == :format }
         quality_op = @operations.find { |op| op[:type] == :quality }
 
         # Simple case: no format/quality operations
-        return output_path.shellescape unless format_op || quality_op
+        return output_path unless format_op || quality_op
 
         # Extract format from operation or output path
         ext = format_op ? format_op[:format] : File.extname(output_path).delete(".")
         base = output_path.gsub(/\.[^.]+$/, "")
 
         # Build format spec with quality if present
-        # Use single quotes to preserve bracket syntax (shellescape breaks it)
         if quality_op
           quality = quality_op[:quality]
-          "'#{base}.#{ext}[Q=#{quality}]'"
+          "#{base}.#{ext}[Q=#{quality}]"
         else
-          "'#{base}.#{ext}'"
+          "#{base}.#{ext}"
         end
       end
 
+      # Execute a command array via Open3.capture3 (no shell invocation).
+      # @param command [Array<String>] Command and arguments as array
       def execute_command(command)
-        Jekyll.logger.debug "LibVips command: #{command}"
+        if command.is_a?(Array) && command.first == :cleanup
+          FileUtils.rm_f(command[1])
+          return
+        end
+
+        Jekyll.logger.debug "LibVips command: #{command.join(' ')}"
 
-        # Execute command and capture output
-        stdout, stderr, status = Open3.capture3(command)
+        # Execute command array directly (no shell)
+        stdout, stderr, status = Open3.capture3(*command)
         output = "#{stdout}#{stderr}"
         success = status.success?
 
         unless success
+          cmd_str = command.join(" ")
           # Filter out expected warnings and only log real errors
-          raise "LibVips command failed: #{command}\nError: #{output}" unless output.include?("same file") || output.include?("VipsForeignSave")
+          raise "LibVips command failed: #{cmd_str}\nError: #{output}" unless output.include?("same file") || output.include?("VipsForeignSave")
 
           Jekyll.logger.warn "LibVips warning: #{output.strip}"
           return output.strip # Continue despite warnings

data/lib/jekyll-imgflow/providers/sharp.rb

@@ -21,8 +21,9 @@ module JekyllImgFlow
         command = build_sharp_command(input_path, output_path)
         execute_command(command)
 
-        reset_operations
         output_path
+      ensure
+        reset_operations
       end
 
       def build_sharp_command(input_path, output_path)

data/lib/jekyll-imgflow/providers/weserv.rb

@@ -9,7 +9,7 @@ module JekyllImgFlow
   module Providers
     # Weserv provider implementation using the standardized tag interface
     class Weserv < BaseProvider
-      TIMEOUT = 10
+      TIMEOUT = 30
 
       def available?
         # Check if weserv service is running
@@ -26,8 +26,9 @@ module JekyllImgFlow
 
         # Fetch the result in one request
         fetch_and_save(url, output_path)
-        reset_operations
         output_path
+      ensure
+        reset_operations
       end
 
       def build_combined_weserv_url(input_path)

data/lib/jekyll-imgflow/tags/opacity_tag.rb

@@ -24,13 +24,20 @@ module JekyllImgFlow
 
       def validate_opacity(value)
         # Check if value is numeric before converting
-        raise ArgumentError, "Invalid opacity: '#{value}'. Must be between 0.01 and 0.99." unless value.to_s.match?(/\A\d*\.?\d+\z/)
+        raise ArgumentError, "Invalid opacity: '#{value}'. Must be between 0.01 and 0.99." unless valid_numeric?(value)
 
         opacity = value.to_f
         raise ArgumentError, "Invalid opacity: '#{value}'. Must be between 0.01 and 0.99." unless opacity.between?(0.01, 0.99)
 
         opacity
       end
+
+      def valid_numeric?(value)
+        Float(value)
+        true
+      rescue ArgumentError, TypeError
+        false
+      end
     end
   end
 end

data/lib/jekyll-imgflow/tags/resize_tag.rb

@@ -47,6 +47,8 @@ module JekyllImgFlow
 
         Jekyll.logger.debug "🔍 ResizeTag: About to execute provider - input: #{input_path}, output: #{output_path}"
         @provider.resize(width, height, resize_data)
+        @provider.quality(options[:quality]) if options[:quality]
+        @provider.convert_format(options[:format]) if options[:format]
         result = @provider.execute(input_path, output_path)
         Jekyll.logger.debug "🔍 ResizeTag: Provider executed - result: #{result}, output exists: #{File.exist?(output_path)}"
         result

data/lib/jekyll-imgflow/tags/watermark_tag.rb

@@ -39,13 +39,20 @@ module JekyllImgFlow
 
       def validate_opacity(value)
         # Check if value is numeric before converting
-        raise ArgumentError, "Invalid opacity: '#{value}'. Must be between 0.0 and 1.0." unless value.to_s.match?(/\A\d*\.?\d+\z/)
+        raise ArgumentError, "Invalid opacity: '#{value}'. Must be between 0.0 and 1.0." unless valid_numeric?(value)
 
         opacity = value.to_f
         raise ArgumentError, "Invalid opacity: '#{value}'. Must be between 0.0 and 1.0." unless opacity.between?(0.0, 1.0)
 
         opacity
       end
+
+      def valid_numeric?(value)
+        Float(value)
+        true
+      rescue ArgumentError, TypeError
+        false
+      end
     end
   end
 end

data/lib/jekyll-imgflow/tasks.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rake"
+require "rubygems"
+
+module JekyllImgFlow
+  # Rake tasks for listing and installing built-in presets.
+  #
+  # Tasks (defined in the host project's Rakefile):
+  #   imgflow:presets       — list built-in presets and their install status
+  #   imgflow:install_presets — copy built-in presets into the site's
+  #     _data/imgflow/presets/ directory (use overwrite=true to replace)
+  module Tasks
+    extend Rake::DSL
+
+    class << self
+      # Path to built-in presets shipped with the gem
+      # @return [String]
+      def builtin_presets_dir
+        File.expand_path("presets", __dir__)
+      end
+
+      # Names of built-in presets (without .yml extension)
+      # @return [Array<String>]
+      def builtin_preset_names
+        return [] unless Dir.exist?(builtin_presets_dir)
+
+        Dir.glob(File.join(builtin_presets_dir, "*.yml")).map do |f|
+          File.basename(f, ".yml")
+        end.sort
+      end
+
+      # Path where presets are installed in the consuming site
+      # @return [String]
+      def site_presets_dir
+        File.join(Dir.pwd, "_data", "imgflow", "presets")
+      end
+
+      # List built-in presets and show their install status in the current site
+      def list_presets
+        puts "ImgFlow built-in presets:"
+        puts
+        builtin_preset_names.each do |name|
+          gem_path = File.join(builtin_presets_dir, "#{name}.yml")
+          site_path = File.join(site_presets_dir, "#{name}.yml")
+          site_exists = File.exist?(site_path)
+
+          status = if !site_exists
+                     "not installed"
+                   elsif same_content?(gem_path, site_path)
+                     "up to date"
+                   else
+                     "modified or outdated"
+                   end
+
+          puts "  #{name}"
+          puts "    gem:    #{gem_path}"
+          puts "    site:   #{site_path}"
+          puts "    status: #{status}"
+          puts
+        end
+        puts "To install: bundle exec rake imgflow:install_presets"
+        puts "To overwrite modified copies: bundle exec rake 'imgflow:install_presets[true]'"
+      end
+
+      # Copy built-in presets into the site's _data/imgflow/presets/ directory
+      # @param overwrite [Boolean] If true, replace modified copies
+      # @return [Hash] Summary with :installed and :skipped arrays
+      def install_presets(overwrite: false)
+        installed = []
+        skipped = []
+
+        FileUtils.mkdir_p(site_presets_dir)
+
+        builtin_preset_names.each do |name|
+          gem_path = File.join(builtin_presets_dir, "#{name}.yml")
+          site_path = File.join(site_presets_dir, "#{name}.yml")
+
+          if File.exist?(site_path) && !overwrite
+            if same_content?(gem_path, site_path)
+              puts "  #{name}.yml: already up to date (skip)"
+            else
+              puts "  #{name}.yml: exists and differs (skip — use overwrite: true to replace)"
+              skipped << name
+            end
+          else
+            existed = File.exist?(site_path)
+            FileUtils.cp(gem_path, site_path)
+            action = existed ? "updated" : "installed"
+            puts "  #{name}.yml: #{action}"
+            installed << name
+          end
+        end
+
+        { installed: installed, skipped: skipped }
+      end
+
+      # Check if two files have identical content
+      # @param path_a [String]
+      # @param path_b [String]
+      # @return [Boolean]
+      def same_content?(path_a, path_b)
+        File.read(path_a) == File.read(path_b)
+      rescue Errno::ENOENT
+        false
+      end
+
+      def install_rake_tasks
+        return if Rake::Task.task_defined?("imgflow:presets")
+
+        namespace :imgflow do
+          desc "List built-in ImgFlow presets and their install status"
+          task :presets do
+            JekyllImgFlow::Tasks.list_presets
+          end
+
+          desc "Copy built-in ImgFlow presets into _data/imgflow/presets/"
+          task :install_presets, [:overwrite] do |_task, args|
+            overwrite = args[:overwrite] == "true"
+            JekyllImgFlow::Tasks.install_presets(overwrite: overwrite)
+          end
+        end
+      end
+    end
+
+    install_rake_tasks
+  end
+end

data/lib/jekyll-imgflow/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JekyllImgFlow
-  VERSION = "0.1.9"
+  VERSION = "0.2.0"
 end

data/lib/jekyll-imgflow.rb

@@ -8,12 +8,14 @@ require "net/http"
 require "uri"
 require_relative "jekyll-imgflow/version"
 require_relative "jekyll-imgflow/config"
+require_relative "jekyll-imgflow/generated_file_cleaner"
 require_relative "jekyll-imgflow/manifest_manager"
 require_relative "jekyll-imgflow/tag_scanner"
 require_relative "jekyll-imgflow/path_resolver"
 require_relative "jekyll-imgflow/filename_generator"
 require_relative "jekyll-imgflow/animated_gif_detector"
 require_relative "jekyll-imgflow/operation_processor"
+require_relative "jekyll-imgflow/processing_stats"
 require_relative "jekyll-imgflow/batch_manager"
 require_relative "jekyll-imgflow/preset_manager"
 require_relative "jekyll-imgflow/helpers/http_downloader"