jekyll-imgflow 0.1.10 → 0.3.0

data/lib/jekyll-imgflow/imgflow_tag.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "shellwords"
+
 module Jekyll
   class ImgflowTag < Liquid::Tag
     def initialize(tag_name, markup, tokens)
@@ -36,7 +38,7 @@ module Jekyll
 
     def expand_preset_markup(markup, preset_manager)
       # Parse markup to extract image path, preset name, and user options
-      parts = markup.split
+      parts = Shellwords.split(markup)
       image_path = parts.first
 
       # Extract preset name and user options
@@ -55,8 +57,14 @@ module Jekyll
       # Get preset markup from PresetManager
       preset_markup = preset_manager.build_markup_from_preset(preset_name, user_options)
 
-      # Combine image path with preset markup
-      "#{image_path} #{preset_markup}"
+      # Combine image path with preset markup. Keep the path quoted because
+      # filenames may contain spaces.
+      image_markup = if image_path.include?(" ")
+                       "\"#{image_path.gsub('"', '\\"')}\""
+                     else
+                       image_path
+                     end
+      "#{image_markup} #{preset_markup}"
     end
 
     def process_operations(components, parsed, context)
@@ -82,73 +90,77 @@ module Jekyll
                     "unknown"
                   end
 
-      # Process operations using clean architecture
       operations = parsed[:operations]
+      results = if operations.empty?
+                  [input_path]
+                else
+                  process_variants(components, operations.first, original_name, input_path,
+                                   page_path)
+                end
+
+      relative_results = results.uniq.map { |result| relative_result_path(result, site) }
+      parsed = parsed.merge(markup_format: "picture") if relative_results.length > 1
+      generate_html(relative_results, parsed, context)
+    end
 
-      result = if operations.empty?
-                 # No operations - use original image
-                 input_path
-               else
-                 # Generate filename early to check existence
-                 operation = operations.first
-                 params = operation[:params]
-
-                 # For default versions, include default format and quality for proper identification
-                 if determine_version_type(params, components[:config]) == :default
-                   params = params.dup
-                   params[:format] ||= components[:config].formats.first  # Use default format
-                   params[:quality] ||= components[:config].quality       # Use default quality
-                 end
-
-                 # Preserve original directory structure under output
-                 subdir = File.dirname(original_name)
-                 subdir = nil if subdir == "."
-
-                 filename = components[:filename_generator].generate_filename(input_path, params)
-                 output_path = components[:path_resolver].resolve_source_output_path(filename, subdir)
-
-                 # Determine version type
-                 version_type = determine_version_type(params, components[:config])
-
-                 # Check if version exists in manifest
-                 Jekyll.logger.debug "🔍 ImgflowTag: Checking existence - original_name: #{original_name}, version_type: #{version_type}, page_path: #{page_path}"
-                 Jekyll.logger.debug "🔍 ImgflowTag: Params being checked: #{params.inspect}"
-
-                 if components[:manifest].version_exists?(original_name, params, version_type)
-                   # Version exists - update page usage and return path
-                   Jekyll.logger.debug "✅ ImgflowTag: Version exists! Updating page usage"
-                   components[:manifest].update_page_usage(original_name, params, version_type,
-                                                           page_path)
-                   output_path
-                 else
-                   # Version doesn't exist - create it
-                   Jekyll.logger.debug "❌ ImgflowTag: Version doesn't exist - creating"
-                   versions = components[:manifest].get_versions(original_name)
-                   Jekyll.logger.debug "🔍 ImgflowTag: Manifest has - default: #{versions['default']&.length || 0}, specialized: #{versions['specialized']&.length || 0}"
-
-                   components[:operation_processor].process_operation(
-                     original_name,
-                     operation,
-                     input_path,
-                     page_path
-                   )
-                 end
-               end
-
-      # Convert absolute paths to relative for HTML generation
-      relative_result = if result.start_with?(site.dest)
-                          # Processed images - remove site.dest and leading /
-                          result.sub(%r{^#{Regexp.escape(site.dest)}/}, "")
-                        elsif result.start_with?(site.source)
-                          # Original images - convert from source to relative and remove leading /
-                          result.sub(%r{^#{Regexp.escape(site.source)}/}, "")
-                        else
-                          # Already relative or other format - remove leading / if present
-                          result.start_with?("/") ? result[1..] : result
-                        end
+    def process_variants(components, operation, original_name, input_path, page_path)
+      params = operation[:params].dup
+      formats = Array(params.delete(:formats) || params[:format])
+      # When no format is explicitly specified, generate all configured formats
+      # (avif, webp, png, jpg) so browsers get a <picture> with <source> tags for
+      # modern formats and an <img> fallback. This applies to both default-width
+      # versions (which find pre-generated files in the manifest cache) and
+      # specialized versions (which are generated on-demand).
+      formats = components[:config].formats if formats.empty?
+
+      formats.map do |format|
+        variant_params = params.dup
+        variant_params[:format] = format
+        process_variant(components, operation, variant_params, original_name, input_path, page_path)
+      end
+    end
+
+    def process_variant(components, operation, params, original_name, input_path, page_path)
+      config = components[:config]
+      if determine_version_type(params, config) == :default
+        params[:format] ||= config.formats.first
+        params[:quality] ||= config.quality
+      end
 
-      # Generate HTML for the result
-      generate_html([relative_result], parsed, context)
+      digest = components[:filename_generator].file_digest(input_path)
+      variant = operation.merge(params: params, file_digest: digest)
+      subdir = File.dirname(original_name)
+      subdir = nil if subdir == "."
+      filename = components[:filename_generator].generate_filename(input_path, params)
+      output_path = components[:path_resolver].resolve_source_output_path(filename, subdir)
+      version_type = determine_version_type(params, config)
+
+      if components[:manifest].version_exists?(original_name, params, version_type, digest) &&
+         File.file?(output_path)
+        components[:stats]&.record_cache_hit
+        components[:manifest].update_page_usage(original_name, params, version_type, page_path)
+        return output_path
+      end
+
+      unless components[:operation_processor]
+        Jekyll.logger.warn "ImgFlow:", "No image provider available — " \
+                                       "rendering original without optimization."
+        return input_path
+      end
+
+      components[:operation_processor].process_operation(
+        original_name, variant.merge(force_processing: true), input_path, page_path
+      )
+    end
+
+    def relative_result_path(result, site)
+      if result.start_with?(site.dest)
+        result.sub(%r{^#{Regexp.escape(site.dest)}/}, "")
+      elsif result.start_with?(site.source)
+        result.sub(%r{^#{Regexp.escape(site.source)}/}, "")
+      else
+        result.delete_prefix("/")
+      end
     end
 
     def generate_html(results, parsed, context)
@@ -181,7 +193,8 @@ module Jekyll
         a: extract_prefixed_attrs(base_attrs, "a-"),
         parent: extract_prefixed_attrs(base_attrs, "parent-"),
         alt: base_attrs[:alt],
-        link: base_attrs[:link]
+        link: base_attrs[:link],
+        modal: base_attrs[:modal]
       }
     end
 
@@ -232,8 +245,10 @@ module Jekyll
         filename_generator = JekyllImgFlow::FilenameGenerator.new
         registry = JekyllImgFlow::ProviderRegistry.new(config)
         provider = registry.current_provider
-        operation_processor = JekyllImgFlow::OperationProcessor.new(provider, path_resolver,
-                                                                    manifest, config)
+        if provider
+          operation_processor = JekyllImgFlow::OperationProcessor.new(provider, path_resolver,
+                                                                      manifest, config)
+        end
         preset_manager = JekyllImgFlow::PresetManager.new(site, config)
 
         site.imgflow_components = {
@@ -244,6 +259,7 @@ module Jekyll
           registry: registry,
           provider: provider,
           operation_processor: operation_processor,
+          stats: operation_processor&.stats,
           preset_manager: preset_manager
         }
       end

data/lib/jekyll-imgflow/manifest_manager.rb

@@ -2,7 +2,6 @@
 
 require "json"
 require "fileutils"
-require "digest"
 
 module JekyllImgFlow
   # Manages the manifest of generated images
@@ -13,9 +12,11 @@ module JekyllImgFlow
 
     def initialize(site)
       @site = site
-      # Place manifest in _site - rebuilt on each Jekyll build
-      @manifest_path = File.join(@site.dest, "assets", "images", "imgflow-manifest.json")
-      @manifest = load_manifest
+      @config = JekyllImgFlow::Config.new(site)
+      @file_cleaner = GeneratedFileCleaner.new(site, @config)
+      @manifest_path = File.join(@site.source, @config.cache_dir, "imgflow-manifest.json")
+      @legacy_manifest_paths = legacy_manifest_paths
+      @manifest = load_manifest(manifest_load_path)
       @current_provider = current_provider
 
       # Check if provider changed and invalidate cache if needed
@@ -23,20 +24,22 @@ module JekyllImgFlow
     end
 
     # Load existing manifest or create new one
-    def load_manifest
-      if File.exist?(@manifest_path)
+    def load_manifest(path = @manifest_path)
+      if path && File.exist?(path)
         begin
-          data = JSON.parse(File.read(@manifest_path))
+          data = JSON.parse(File.read(path))
 
           # Handle new format with provider at top level
           if data.is_a?(Hash) && data.key?("images")
             @cached_provider = data["provider"]
-            data["images"] || {}
+            images = data["images"] || {}
           else
             # Old format - just image data
             @cached_provider = nil
-            data
+            images = data
           end
+
+          migrate_legacy_manifest(images)
         rescue JSON::ParserError => e
           Jekyll.logger.warn "ImgFlow: Corrupt manifest file, starting fresh: #{e.message}"
           @cached_provider = nil
@@ -48,6 +51,23 @@ module JekyllImgFlow
       end
     end
 
+    # Detect and migrate legacy manifest entries (pre-0.1.11 format).
+    # Old entries have operations like {"width": 400} without format/quality
+    # and no file_digest. Clearing them lets the build re-register existing
+    # output files without reprocessing (output_up_to_date? check handles this).
+    def migrate_legacy_manifest(images)
+      legacy = images.any? do |_name, data|
+        versions = data.dig("versions", "default") || []
+        versions.any? { |v| v["file_digest"].nil? || !v["operations"].key?("format") }
+      end
+      if legacy
+        Jekyll.logger.info "ImgFlow: Detected legacy manifest format, " \
+                           "clearing entries for re-registration."
+        images.clear
+      end
+      images
+    end
+
     # Save manifest to disk
     def save
       # Store current provider at top level of manifest
@@ -55,44 +75,98 @@ module JekyllImgFlow
         "provider" => @current_provider,
         "images" => @manifest
       }
+      content = JSON.pretty_generate(manifest_data)
+      if File.exist?(@manifest_path) && File.binread(@manifest_path) == content
+        cleanup_legacy_manifests
+        return
+      end
 
-      FileUtils.mkdir_p(File.dirname(@manifest_path))
-      File.write(@manifest_path, JSON.pretty_generate(manifest_data))
+      directory = File.dirname(@manifest_path)
+      temporary_path = "#{@manifest_path}.tmp-#{Process.pid}-#{Thread.current.object_id}"
+      FileUtils.mkdir_p(directory)
+      File.open(temporary_path, "wb") do |file|
+        file.write(content)
+        file.flush
+        file.fsync
+      end
+      File.rename(temporary_path, @manifest_path)
+      cleanup_legacy_manifests
+    ensure
+      FileUtils.rm_f(temporary_path) if temporary_path
     end
 
     # Get current provider from site config
-    def current_provider
-      config = JekyllImgFlow::Config.new(@site)
-      # Get first available provider from backend_priority
-      config.backend_priority&.first || "unknown"
-    end
+    def current_provider = @config.backend_priority&.first || "unknown"
 
     # Clean up manifest entries for deleted original images
-    # @param current_originals [Array<String>] Array of current original image basenames
+    # @param current_originals [Array<String>] Paths relative to the originals directory
     def cleanup_deleted_originals(current_originals)
       current_set = current_originals.to_set
 
       @manifest.each_key do |original_name|
-        # Extract basename without extension
-        basename = File.basename(original_name, ".*")
+        next if current_set.include?(original_name)
+
+        data = @manifest.delete(original_name)
+        VERSION_TYPES.each do |type|
+          (data.dig("versions", type) || []).each do |version|
+            @file_cleaner.delete(version["output"])
+          end
+        end
+        Jekyll.logger.debug "🗑️  Removed manifest entry for deleted original: #{original_name}"
+      end
+    end
+
+    def cleanup_obsolete_defaults(expected_operations)
+      @manifest.each_value do |data|
+        versions = data.dig("versions", "default") || []
+        versions.reject! do |version|
+          obsolete = expected_operations.none? do |operations|
+            same_operations?(version["operations"], operations)
+          end
+          @file_cleaner.delete(version["output"]) if obsolete
+          obsolete
+        end
+      end
+    end
+
+    def reset_page_usage
+      @manifest.each_value do |data|
+        (data.dig("versions", "specialized") || []).each do |version|
+          version["used_on"] = []
+        end
+      end
+    end
 
-        # If original no longer exists, remove from manifest
-        unless current_set.include?(basename)
-          @manifest.delete(original_name)
-          Jekyll.logger.debug "🗑️  Removed manifest entry for deleted original: #{original_name}"
+    # Normalize operations for consistent comparison after JSON persistence.
+    def normalize_operations(operations)
+      case operations
+      when Hash
+        operations.to_h do |key, value|
+          [key.to_s, normalize_operations(value)]
         end
+      when Array
+        operations.map { |value| normalize_operations(value) }
+      when Symbol
+        operations.to_s
+      else
+        operations
       end
     end
 
+    def same_operations?(left, right) = normalize_operations(left) == normalize_operations(right)
+
     # Check if a specific image version exists and is up-to-date
-    def version_exists?(original_name, operations, type = :specialized)
+    def version_exists?(original_name, operations, type = :specialized, file_digest = nil)
       return false unless @manifest[original_name]
 
       # Provider change is already handled in initialize, so just check operations
       versions = @manifest.dig(original_name, "versions", type.to_s) || []
       Jekyll.logger.debug "🔍 ManifestManager: Looking for operations: #{operations.inspect} in #{versions.length} #{type} versions"
 
-      result = versions.any? { |v| v["operations"] == operations }
+      result = versions.any? do |version|
+        same_operations?(version["operations"], operations) &&
+          (!file_digest || version["file_digest"] == file_digest)
+      end
       Jekyll.logger.debug "🔍 ManifestManager: Final result: #{result}"
       result
     end
@@ -112,25 +186,9 @@ module JekyllImgFlow
                          "Provider changed from '#{@cached_provider}' to '#{@current_provider}'"
       Jekyll.logger.warn "ImgFlow:", "Invalidating cache and cleaning optimized directory..."
 
-      # Get optimized directory path
-      config = JekyllImgFlow::Config.new(@site)
-      optimized_dir = File.join(@site.source, config.output)
-
-      # Safety guard: prevent deletion of _site itself
-      raise "Refusing to delete optimized directory: path resolves to site dest or is empty" if optimized_dir == @site.dest || optimized_dir.empty?
-
-      # Delete all files in optimized directory
-      if Dir.exist?(optimized_dir)
-        deleted_count = 0
-        Dir.glob(File.join(optimized_dir, "**", "*")).each do |file|
-          if File.file?(file)
-            File.delete(file)
-            deleted_count += 1
-          end
-        end
-        Jekyll.logger.warn "ImgFlow:",
-                           "Deleted #{deleted_count} cached images from optimized directory"
-      end
+      deleted_count = @file_cleaner.clear
+      Jekyll.logger.warn "ImgFlow:",
+                         "Deleted #{deleted_count} cached images from optimized directory"
 
       # Clear manifest cache
       @manifest.clear
@@ -146,7 +204,7 @@ module JekyllImgFlow
       return unless @manifest[original_name]
 
       versions = @manifest.dig(original_name, "versions", type.to_s) || []
-      version = versions.find { |v| v["operations"] == operations }
+      version = versions.find { |v| same_operations?(v["operations"], operations) }
       version&.dig("output")
     end
 
@@ -162,7 +220,7 @@ module JekyllImgFlow
 
       # Get the existing version to preserve provider
       versions = @manifest.dig(original_name, "versions", type.to_s) || []
-      version = versions.find { |v| v["operations"] == operations }
+      version = versions.find { |v| same_operations?(v["operations"], operations) }
       provider = version&.dig("provider")
       Jekyll.logger.debug "🔍 update_page_usage: provider=#{provider}, current used_on=#{version&.dig('used_on')&.inspect}"
 
@@ -183,9 +241,10 @@ module JekyllImgFlow
       @manifest[original_name]["file_digest"] = file_digest if file_digest
 
       versions = @manifest[original_name]["versions"][type.to_s] ||= []
+      normalized_operations = normalize_operations(operations)
 
       # Find or create version entry
-      version = versions.find { |v| v["operations"] == operations }
+      version = versions.find { |v| same_operations?(v["operations"], normalized_operations) }
 
       # Normalize page_path to array
       page_paths = if page_path.is_a?(Array)
@@ -200,16 +259,19 @@ module JekyllImgFlow
         page_paths.each do |path|
           version["used_on"] << path if path && !version["used_on"].include?(path)
         end
+        version["output"] = output_path
+        version["file_digest"] = file_digest if file_digest
         # Update provider if provided
         version["provider"] = provider if provider
       else
         # Create new version entry
         versions << {
           "output" => output_path,
-          "operations" => operations,
+          "operations" => normalized_operations,
           "type" => type.to_s,
           "used_on" => page_paths,
           "created_at" => Time.now.to_i,
+          "file_digest" => file_digest,
           "provider" => provider
         }
       end
@@ -220,7 +282,7 @@ module JekyllImgFlow
       return false unless @manifest[original_name]
 
       versions = @manifest.dig(original_name, "versions", "default") || []
-      versions.any? { |v| v["operations"] == operations }
+      versions.any? { |v| same_operations?(v["operations"], operations) }
     end
 
     # Find orphaned specialized images (not used on any page)
@@ -261,16 +323,14 @@ module JekyllImgFlow
       cleaned = []
 
       orphans.each do |orphan|
-        output_file = File.join(@site.source, orphan["output"])
-        if File.exist?(output_file)
-          File.delete(output_file)
+        if @file_cleaner.delete(orphan["output"])
           cleaned << orphan["output"]
           Jekyll.logger.info "🗑️  Cleaned orphaned image: #{orphan['output']}"
         end
 
         # Remove from manifest
         versions = @manifest.dig(orphan["original"], "versions", "specialized") || []
-        versions.reject! { |v| v["operations"] == orphan["operations"] }
+        versions.reject! { |v| same_operations?(v["operations"], orphan["operations"]) }
       end
 
       cleaned
@@ -288,5 +348,24 @@ module JekyllImgFlow
       versions = @manifest[original_name]["versions"]
       (versions["default"]&.any? || false) || (versions["specialized"]&.any? || false)
     end
+
+    private
+
+    def legacy_manifest_paths
+      [
+        File.join(@site.source, "assets", "images", "imgflow-manifest.json"),
+        File.join(@site.dest, "assets", "images", "imgflow-manifest.json")
+      ].reject { |path| path == @manifest_path }
+    end
+
+    def manifest_load_path
+      return @manifest_path if File.exist?(@manifest_path)
+
+      @legacy_manifest_paths.find { |path| File.exist?(path) }
+    end
+
+    def cleanup_legacy_manifests
+      @legacy_manifest_paths.each { |path| FileUtils.rm_f(path) }
+    end
   end
 end

data/lib/jekyll-imgflow/modal_assets.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module JekyllImgFlow
+  # Inline CSS and JS for the image modal/lightbox feature.
+  # Injected by hooks.rb into pages that contain data-imgflow-modal triggers.
+  module ModalAssets
+    CSS = <<~CSS
+      .imgflow-modal-overlay{position:fixed;inset:0;background:rgba(0,0,0,.85);
+      display:flex;align-items:center;justify-content:center;z-index:9999;
+      cursor:pointer;animation:imgflow-fade .15s ease-out}
+      .imgflow-modal-image{max-width:90vw;max-height:90vh;object-fit:contain;
+      cursor:auto;border-radius:4px;box-shadow:0 4px 30px rgba(0,0,0,.5)}
+      .imgflow-modal-close{position:absolute;top:1rem;right:1rem;
+      background:rgba(255,255,255,.2);border:none;color:#fff;font-size:2rem;
+      width:3rem;height:3rem;border-radius:50%;cursor:pointer;
+      display:flex;align-items:center;justify-content:center;line-height:1}
+      .imgflow-modal-close:hover{background:rgba(255,255,255,.4)}
+      @keyframes imgflow-fade{from{opacity:0}to{opacity:1}}
+    CSS
+
+    JS = <<~JS
+      (function(){
+      function openModal(src,alt){
+      var o=document.createElement('div');
+      o.className='imgflow-modal-overlay';
+      var i=document.createElement('img');
+      i.src=src;i.alt=alt||'';i.className='imgflow-modal-image';
+      var b=document.createElement('button');
+      b.className='imgflow-modal-close';b.setAttribute('aria-label','Close');
+      b.innerHTML='&times;';
+      o.appendChild(b);o.appendChild(i);document.body.appendChild(o);
+      function c(){document.body.removeChild(o);
+      document.removeEventListener('keydown',k);}
+      function k(e){if(e.key==='Escape')c();}
+      o.addEventListener('click',function(e){
+      if(e.target===o||e.target===b)c();});
+      document.addEventListener('keydown',k);}
+      document.addEventListener('click',function(e){
+      var t=e.target.closest('[data-imgflow-modal]');
+      if(!t)return;e.preventDefault();
+      openModal(t.getAttribute('href'),t.getAttribute('data-imgflow-alt'));});
+      })();
+    JS
+
+    def self.inject(html)
+      return html unless html&.include?("data-imgflow-modal")
+
+      style_tag = "<style>\n#{CSS}</style>"
+      script_tag = "<script>\n#{JS}</script>"
+
+      if html.include?("</head>")
+        html = html.sub("</head>", "#{style_tag}\n</head>")
+        html = html.sub("</body>", "#{script_tag}\n</body>") if html.include?("</body>")
+      elsif html.include?("</body>")
+        html = html.sub("</body>", "#{style_tag}\n#{script_tag}\n</body>")
+      else
+        html = "#{html}\n#{style_tag}\n#{script_tag}"
+      end
+
+      html
+    end
+  end
+
+  # Modal wrapping logic for HtmlGenerator — extracted to keep HtmlGenerator
+  # under the RuboCop class length limit.
+  module ModalWrapper
+    # Formats that produce raw URLs/srcsets (not wrappable HTML elements)
+    NON_HTML_FORMATS = %w[direct_url naked_srcset].freeze
+
+    # Check if the current markup format produces an HTML element
+    def html_element?
+      !NON_HTML_FORMATS.include?(@markup_format)
+    end
+
+    # Determine if modal behavior is enabled for this image
+    # Per-image modal:true/false overrides config default
+    # Modal is skipped when an explicit link is set
+    def modal_enabled?
+      return false if @attributes[:link]
+
+      modal_attr = @attributes[:modal]
+      return modal_attr.to_s == "true" if modal_attr
+
+      @config&.image_modal ? true : false
+    end
+
+    # Pick the best image path for the modal — prefer the fallback format
+    # (e.g. jpg) for maximum browser compatibility
+    def modal_image_path
+      fallback_ext = @config&.fallback_format ? ".#{@config.fallback_format}" : ".jpg"
+      fallback = @results.find { |r| File.extname(r).downcase == fallback_ext }
+      fallback || @results.last
+    end
+
+    # Wrap HTML in modal trigger anchor
+    def wrap_with_modal(html)
+      modal_href = html_path(modal_image_path)
+      return html unless modal_href
+
+      data_attrs = " data-imgflow-modal"
+      alt = @attributes[:alt]
+      data_attrs += " data-imgflow-alt=\"#{escape_attr_value(alt)}\"" if alt
+
+      "<a href=\"#{modal_href}\"#{data_attrs}>#{html}</a>"
+    end
+  end
+end