jekyll-imgflow 0.1.5

data/lib/jekyll-imgflow/config.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module JekyllImgFlow
+  class Config
+    attr_reader :site, :originals, :output, :input_formats, :sizes, :formats,
+                :quality, :backend_priority, :imgproxy_url,
+                :image_compressor_url, :weserv_url, :flyimg_url,
+                :optimize_qualities
+
+    def initialize(site)
+      shared = site.config["shared_images_configs"] || {}
+      overrides = site.config["imgflow"] || {}
+      cfg = shared.merge(overrides)
+
+      @site             = site
+      @originals        = cfg["originals"]
+      @output           = cfg["output"]
+      @input_formats    = cfg["input_formats"]
+      @sizes            = cfg["sizes"]
+      @formats          = cfg["formats"]
+      @quality          = cfg["quality"]
+      @backend_priority = cfg["backend_priority"]
+
+      # Validate required config fields
+      raise ArgumentError, "No originals configured in unified config" unless @originals
+      raise ArgumentError, "No output configured in unified config" unless @output
+      raise ArgumentError, "No input_formats configured in unified config" unless @input_formats
+      raise ArgumentError, "No formats configured in unified config" unless @formats
+      raise ArgumentError, "No sizes configured in unified config" unless @sizes
+
+      @imgproxy_url = cfg["imgproxy_url"]
+      @image_compressor_url = cfg["image_compressor_url"]
+      @weserv_url       = cfg["weserv_url"]
+      @flyimg_url       = cfg["flyimg_url"]
+      @optimize_qualities = cfg["optimize_qualities"] || {
+        "low" => 30,
+        "medium" => 50, # Uses default quality
+        "high" => 85, # Uses default quality
+        "maximum" => 95,
+        "default" => 75
+      }
+
+      validate_backend_priority!
+    end
+
+    def cache_dir
+      merged_config["cache_dir"] || ".cache/imgflow"
+    end
+
+    def docker_config
+      {
+        enabled: merged_config.key?("imgproxy_url") ||
+          merged_config.key?("weserv_url") ||
+          merged_config.key?("flyimg_url") ||
+          merged_config.key?("image_compressor_url"),
+        imgproxy_url: @imgproxy_url,
+        weserv_url: @weserv_url,
+        flyimg_url: @flyimg_url,
+        image_compressor_url: @image_compressor_url
+      }
+    end
+
+    def docker_enabled
+      docker_config[:enabled]
+    end
+
+    def sharp_url
+      merged_config["sharp_url"]
+    end
+
+    # Determine if params represent a default or specialized version
+    # @param params [Hash] Operation parameters
+    # @return [Symbol] :default or :specialized
+    def determine_version_type(params)
+      if params[:width] && @sizes.value?(params[:width]) &&
+         (!params[:format] || @formats.include?(params[:format])) &&
+         (!params[:quality] || params[:quality] == @quality)
+        :default
+      else
+        :specialized
+      end
+    end
+
+    # Format validation methods
+    def supported_input_format?(format)
+      normalized_format = format.to_s.downcase.delete(".")
+      @input_formats.map(&:downcase).include?(normalized_format)
+    end
+
+    def supported_output_format?(format)
+      normalized_format = format.to_s.downcase.delete(".")
+      @formats.map(&:downcase).include?(normalized_format)
+    end
+
+    def validate_input_format!(format)
+      return if supported_input_format?(format)
+
+      raise ArgumentError,
+            "Unsupported input format '#{format}'. Supported formats: #{@input_formats.join(', ')}"
+    end
+
+    def validate_output_format!(format)
+      return if supported_output_format?(format)
+
+      raise ArgumentError,
+            "Unsupported output format '#{format}'. Supported formats: #{@formats.join(', ')}"
+    end
+
+    # Get normalized format lists
+    def normalized_input_formats
+      @input_formats.map(&:downcase)
+    end
+
+    def normalized_output_formats
+      @formats.map(&:downcase)
+    end
+
+    private
+
+    def merged_config
+      shared = @site.config["shared_images_configs"] || {}
+      overrides = @site.config["imgflow"] || {}
+      shared.merge(overrides)
+    end
+
+    def validate_backend_priority!
+      # No manual-only providers to validate
+    end
+  end
+end

data/lib/jekyll-imgflow/filename_generator.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module JekyllImgFlow
+  # Generates unique filenames for processed images
+  # Compatible with Jekyll Picture Tag format
+  class FilenameGenerator
+    # Generate filename for processed image (Jekyll Picture Tag compatible)
+    # @param original_name [String] Original image filename
+    # @param operations [Hash] Operations applied to image
+    # @return [String] Generated filename (without path)
+    def generate_filename(original_name, operations)
+      base_name = File.basename(original_name, ".*")
+      width = operations[:width]
+      format = operations[:format] || File.extname(original_name).delete(".")
+
+      # Generate hash using Jekyll Picture Tag approach
+      hash = generate_jpt_hash(original_name, operations)
+
+      "#{base_name}-#{width}-#{hash}.#{format}"
+    end
+
+    # Generate cache key for operations (SHA256 for manifest tracking)
+    # @param operations [Hash] Operations hash
+    # @return [String] Cache key
+    def generate_cache_key(operations)
+      # Sort keys to ensure consistent hashing
+      sorted_operations = operations.sort.to_h
+      Digest::SHA256.hexdigest(sorted_operations.to_json)
+    end
+
+    # Get file digest for manifest tracking
+    # @param original_path [String] Path to original image
+    # @return [String] SHA256 digest of file
+    def file_digest(original_path)
+      Digest::SHA256.file(original_path).hexdigest
+    end
+
+    # Parse filename to extract width and hash
+    # @param filename [String] Generated filename
+    # @return [Hash] Parsed components {base_name, width, hash, format}
+    def parse_filename(filename)
+      # Parse pattern: basename-width-hash.format - simple string operations
+      # Find last dot to separate format
+      last_dot = filename.rindex(".")
+      return {} unless last_dot
+
+      format = filename[(last_dot + 1)..]
+      name_part = filename[0...last_dot]
+
+      # Find last dash to separate hash
+      last_dash = name_part.rindex("-")
+      return {} unless last_dash
+
+      hash = name_part[(last_dash + 1)..]
+      name_without_hash = name_part[0...last_dash]
+
+      # Find second-to-last dash to separate width
+      second_last_dash = name_without_hash.rindex("-")
+      return {} unless second_last_dash
+
+      width_str = name_without_hash[(second_last_dash + 1)..]
+      base_name = name_without_hash[0...second_last_dash]
+
+      # Validate components
+      return {} unless hash.match?(/^[a-f0-9]+$/)
+      return {} unless width_str.match?(/^\d+$/)
+
+      {
+        base_name: base_name,
+        width: width_str.to_i,
+        hash: hash,
+        format: format
+      }
+    end
+
+    private
+
+    # Generate hash using Jekyll Picture Tag approach
+    # @param original_path [String] Path to original image (relative or absolute)
+    # @param operations [Hash] Operations hash
+    # @return [String] 9-character MD5 hash
+    def generate_jpt_hash(original_path, operations)
+      # Get filename digest (MD5 of filename) - exactly like JPT
+      filename = File.basename(original_path)
+      file_digest = Digest::MD5.hexdigest(filename)
+
+      # Build settings array (like Jekyll Picture Tag)
+      settings = [
+        file_digest,
+        operations[:crop],
+        operations[:keep],
+        operations[:quality]
+      ]
+
+      # Generate MD5 hash of settings (9 chars like JPT)
+      Digest::MD5.hexdigest(settings.join)[0..8]
+    end
+  end
+end

data/lib/jekyll-imgflow/helpers/http_downloader.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "fileutils"
+require "tmpdir"
+require "net/http"
+require "uri"
+
+module JekyllImgFlow
+  module Helpers
+    # HTTP Downloader - handles downloading images from HTTP/HTTPS/file:// URLs
+    class HttpDownloader
+      # Download a file from URL to temporary location
+      # @param url [String] URL to download (http://, https://, or file://)
+      # @return [String] Path to downloaded temporary file
+      def self.download(url)
+        uri = URI(url)
+
+        # Handle file:// URLs for local file processing
+        if uri.scheme == "file"
+          download_file_url(uri)
+        else
+          download_http_url(uri)
+        end
+      end
+
+      private_class_method def self.download_file_url(uri)
+        # For file:// URLs, copy the local file to temp
+        source_path = uri.path
+        ext = File.extname(source_path)
+        tmp = File.join(Dir.tmpdir, "imgflow-#{SecureRandom.hex}#{ext}")
+        FileUtils.cp(source_path, tmp)
+        tmp
+      end
+
+      private_class_method def self.download_http_url(uri)
+        # For HTTP/HTTPS URLs, download the file
+        ext = File.extname(uri.path)
+        tmp = File.join(Dir.tmpdir, "imgflow-#{SecureRandom.hex}#{ext}")
+
+        begin
+          response = Net::HTTP.get_response(uri)
+
+          # Handle redirects
+          if response.is_a?(Net::HTTPRedirection)
+            location = response["location"]
+            raise "Redirect without location" unless location
+
+            # Follow the redirect
+            redirect_uri = URI(location)
+            redirect_uri = URI("#{uri.scheme}://#{uri.host}#{location}") if location.start_with?("/")
+
+            response = Net::HTTP.get_response(redirect_uri)
+          end
+
+          raise "HTTP request failed: #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+          File.write(tmp, response.body, mode: "wb")
+        rescue StandardError => e
+          FileUtils.rm_f(tmp)
+          raise "Failed to download #{uri}: #{e.message}"
+        end
+
+        tmp
+      end
+    end
+  end
+end

data/lib/jekyll-imgflow/hooks.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module JekyllImgFlow
+  # Initialize ImgFlow components on site
+  Jekyll::Hooks.register :site, :after_init do |site|
+    Jekyll.logger.info "🔌 ImgFlow: Initializing components on site"
+
+    # Add imgflow_components attribute to site if not already present
+    unless site.respond_to?(:imgflow_components)
+      site.define_singleton_method(:imgflow_components) { @imgflow_components }
+      site.define_singleton_method(:imgflow_components=) { |value| @imgflow_components = value }
+    end
+
+    # Components will be initialized on first use (lazy loading)
+    Jekyll.logger.info "✅ ImgFlow: Components ready for initialization"
+  end
+
+  # BuildTimeProcessor runs BEFORE template rendering - ideal architecture
+  Jekyll::Hooks.register :site, :pre_render do |site|
+    Jekyll.logger.info "🔌 ImgFlow pre_render hook - creating default versions"
+
+    # Initialize and run BuildTimeProcessor
+    build_time_processor = BuildTimeProcessor.new(site)
+    build_time_processor.process_changed_images
+
+    Jekyll.logger.info "✅ ImgFlow: Default versions created and manifest saved"
+  end
+
+  # Save final manifest after template rendering (single writer)
+  Jekyll::Hooks.register :site, :post_write do |site|
+    Jekyll.logger.info "🔌 ImgFlow post_write hook - saving final manifest with page usage"
+
+    if site.imgflow_components && site.imgflow_components[:manifest]
+      site.imgflow_components[:manifest].save
+      Jekyll.logger.info "✅ ImgFlow: Final manifest saved with all page usage data"
+    else
+      Jekyll.logger.warn "⚠️  ImgFlow: No manifest found to save"
+    end
+
+    # Clean up orphaned specialized images in production
+    cleanup_orphaned_images(site) if Jekyll.env != "development"
+  end
+
+  def self.cleanup_orphaned_images(site)
+    Jekyll.logger.info "🧹 ImgFlow: Checking for orphaned specialized images..."
+
+    # Use ManifestManager to find and cleanup orphans
+    manifest = ManifestManager.new(site)
+    cleaned = manifest.cleanup_orphans
+
+    if cleaned.any?
+      Jekyll.logger.info "✅ ImgFlow: Removed #{cleaned.length} orphaned specialized images"
+    else
+      Jekyll.logger.info "✅ ImgFlow: No orphaned images found"
+    end
+  end
+end

data/lib/jekyll-imgflow/html_generator.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+module JekyllImgFlow
+  # Unified HTML Generator for all markup formats
+  # Supports Picture Tag compatibility with multiple markup formats and attributes
+  class HtmlGenerator
+    MARKUP_FORMATS = %w[auto picture img data_auto data_picture data_img direct_url
+                        naked_srcset].freeze
+
+    # Generate HTML based on markup format and attributes
+    # @param results [Array<String>] Processed image paths
+    # @param attributes [Hash] HTML attributes by element
+    # @param markup_format [String] Markup format (auto, picture, img, data_auto, etc.)
+    # @param context [Liquid::Context] Liquid context
+    # @param config [JekyllImgFlow::Config] ImgFlow configuration
+    # @return [String] Generated HTML
+    def self.generate(results, attributes, markup_format, context, config = nil)
+      return "" if results.empty?
+
+      generator = new(results, attributes, markup_format, context, config)
+      generator.generate
+    end
+
+    def initialize(results, attributes, markup_format, context, config = nil)
+      @results = results
+      @attributes = normalize_attributes(attributes)
+      @markup_format = markup_format || "img"
+      @context = context
+      @config = config
+      @path_resolver = config ? JekyllImgFlow::PathResolver.new(config) : nil
+      @fallback_formats = fallback_formats
+    end
+
+    def generate
+      html = case @markup_format
+             when "picture", "auto"
+               generate_picture_element
+             when "data_picture"
+               generate_data_picture_element
+             when "data_img", "data_auto"
+               generate_data_img_element
+             when "direct_url"
+               generate_direct_url
+             when "naked_srcset"
+               generate_naked_srcset
+             else
+               generate_img_element # Default fallback
+             end
+
+      # Wrap in link if specified
+      html = wrap_with_link(html) if @attributes[:link]
+
+      # Wrap in parent container if specified
+      html = wrap_with_parent(html) if @attributes[:parent]&.any?
+
+      html
+    end
+
+    private
+
+    # Get fallback formats from config or use sensible defaults
+    def fallback_formats
+      if @config&.formats
+        # Convert format names to extensions and add dots
+        @config.formats.map { |fmt| ".#{fmt}" }
+      else
+        # Fallback to common formats if no config available
+        %w[.jpg .jpeg .png]
+      end
+    end
+
+    # Normalize attributes from different sources
+    def normalize_attributes(attributes)
+      return default_attributes if attributes.nil? || attributes.empty?
+
+      {
+        img: attributes[:img] || {},
+        picture: attributes[:picture] || {},
+        source: attributes[:source] || {},
+        a: attributes[:a] || {},
+        parent: attributes[:parent] || {},
+        alt: attributes[:alt],
+        link: attributes[:link]
+      }
+    end
+
+    def default_attributes
+      {
+        img: {},
+        picture: {},
+        source: {},
+        a: {},
+        parent: {},
+        alt: nil,
+        link: nil
+      }
+    end
+
+    # Generate standard <picture> element with <source> tags
+    def generate_picture_element
+      picture_attrs = build_attributes(@attributes[:picture])
+      img_attrs = build_img_attributes
+
+      html = "<picture#{picture_attrs}>"
+
+      # Generate source elements for each format (except fallback)
+      format_groups = group_by_format(@results)
+
+      format_groups.each do |ext, files|
+        next if @fallback_formats.include?(ext) # Skip fallback formats
+
+        mime_type = mime_type_for(ext)
+        source_attrs = build_attributes(@attributes[:source])
+        srcset = files.map { |f| html_path(f) }.join(", ")
+
+        html << "<source srcset=\"#{srcset}\" type=\"#{mime_type}\"#{source_attrs}>"
+      end
+
+      # Fallback img element
+      fallback = find_fallback_image(@results)
+      html << "<img src=\"#{html_path(fallback)}\"#{img_attrs}>"
+      html << "</picture>"
+
+      html
+    end
+
+    # Generate standard <img> element
+    def generate_img_element
+      img_attrs = build_img_attributes
+      primary = @results.first
+
+      # Build srcset if multiple results
+      srcset_attr = if @results.length > 1
+                      srcset = generate_srcset_string(@results)
+                      " srcset=\"#{srcset}\""
+                    else
+                      ""
+                    end
+
+      "<img src=\"#{html_path(primary)}\"#{srcset_attr}#{img_attrs}>"
+    end
+
+    # Generate <picture> element with data-* attributes for lazy loading
+    def generate_data_picture_element
+      picture_attrs = build_attributes(@attributes[:picture])
+      img_attrs = build_data_img_attributes
+
+      html = "<picture#{picture_attrs}>"
+
+      # Generate source elements with data-srcset
+      format_groups = group_by_format(@results)
+
+      format_groups.each do |ext, files|
+        next if @fallback_formats.include?(ext)
+
+        mime_type = mime_type_for(ext)
+        source_attrs = build_attributes(@attributes[:source])
+        srcset = files.map { |f| html_path(f) }.join(", ")
+
+        html << "<source data-srcset=\"#{srcset}\" type=\"#{mime_type}\"#{source_attrs}>"
+      end
+
+      # Fallback img with data-src
+      fallback = find_fallback_image(@results)
+      html << "<img data-src=\"#{html_path(fallback)}\"#{img_attrs}>"
+      html << "</picture>"
+
+      html
+    end
+
+    # Generate <img> element with data-* attributes for lazy loading
+    def generate_data_img_element
+      img_attrs = build_data_img_attributes
+      primary = @results.first
+
+      # Build data-srcset if multiple results
+      srcset_attr = if @results.length > 1
+                      srcset = generate_srcset_string(@results)
+                      " data-srcset=\"#{srcset}\""
+                    else
+                      ""
+                    end
+
+      "<img data-src=\"#{html_path(primary)}\"#{srcset_attr}#{img_attrs}>"
+    end
+
+    # Generate just the URL (for direct_url format)
+    def generate_direct_url
+      absolute_url(@results.first)
+    end
+
+    # Generate just the srcset string (for naked_srcset format)
+    def generate_naked_srcset
+      generate_srcset_string(@results)
+    end
+
+    # Build img attributes including alt, loading, and custom attributes
+    def build_img_attributes
+      attrs = @attributes[:img].dup
+      attrs["alt"] = @attributes[:alt] if @attributes[:alt]
+      attrs["loading"] = "lazy" unless attrs["loading"]
+
+      build_attributes(attrs)
+    end
+
+    # Build img attributes with data-* for lazy loading
+    def build_data_img_attributes
+      attrs = @attributes[:img].dup
+      attrs["alt"] = @attributes[:alt] if @attributes[:alt]
+      attrs["class"] = [attrs["class"], "lazy"].compact.join(" ")
+
+      build_attributes(attrs)
+    end
+
+    # Build HTML attribute string from hash
+    def build_attributes(attrs_hash)
+      return "" if attrs_hash.nil? || attrs_hash.empty?
+
+      attrs_hash.filter_map do |key, value|
+        if value.is_a?(TrueClass)
+          " #{escape_attr_name(key)}" # Boolean attribute
+        elsif value.is_a?(FalseClass) || value.nil?
+          nil # Skip false/nil attributes
+        else
+          " #{escape_attr_name(key)}=\"#{escape_attr_value(value)}\""
+        end
+      end.join
+    end
+
+    # Wrap HTML in anchor tag
+    def wrap_with_link(html)
+      link_attrs = build_attributes(@attributes[:a])
+      href = escape_attr_value(@attributes[:link])
+
+      "<a href=\"#{href}\"#{link_attrs}>#{html}</a>"
+    end
+
+    # Wrap HTML in parent container
+    def wrap_with_parent(html)
+      parent_attrs = build_attributes(@attributes[:parent])
+
+      "<div#{parent_attrs}>#{html}</div>"
+    end
+
+    # Group results by file extension/format
+    def group_by_format(results)
+      results.group_by { |r| File.extname(r).downcase }
+    end
+
+    # Find fallback image (prefer jpg/jpeg/png)
+    def find_fallback_image(results)
+      results.find { |r| r.match?(/\.(jpe?g|png)$/i) } || results.first
+    end
+
+    # Generate srcset string from results
+    def generate_srcset_string(results)
+      results.map do |result|
+        width = extract_width_from_filename(result)
+        descriptor = width ? "#{width}w" : "1x"
+        "#{absolute_url(result)} #{descriptor}"
+      end.join(", ")
+    end
+
+    # Extract width from filename (format: base_name-width-hash.format)
+    def extract_width_from_filename(result)
+      filename = File.basename(result, ".*")
+      match = filename.match(/-(\d+)-[a-f0-9]+$/)
+      match ? match[1].to_i : nil
+    end
+
+    # Get MIME type for file extension
+    def mime_type_for(ext)
+      case ext.downcase
+      when ".webp"
+        "image/webp"
+      when ".avif"
+        "image/avif"
+      when ".jp2"
+        "image/jp2"
+      when ".jxr"
+        "image/jxr"
+      when ".png"
+        "image/png"
+      when ".svg"
+        "image/svg+xml"
+      when ".gif"
+        "image/gif"
+      else
+        "image/jpeg" # .jpg, .jpeg, and default
+      end
+    end
+
+    # Escape HTML attribute name
+    def escape_attr_name(name)
+      name.to_s.gsub(/[^a-zA-Z0-9\-_:]/, "")
+    end
+
+    # Escape HTML attribute value
+    def escape_attr_value(value)
+      value.to_s
+           .gsub("&", "&amp;")
+           .gsub('"', "&quot;")
+           .gsub("'", "&#39;")
+           .gsub("<", "&lt;")
+           .gsub(">", "&gt;")
+    end
+
+    # Get correct path for HTML generation (relative paths for Jekyll sites)
+    def html_path(relative_path)
+      # For HTML generation, we want relative paths within the site
+      # Remove leading slash to make it relative to site root
+      relative_path.start_with?("/") ? relative_path[1..] : relative_path
+    end
+
+    # Get absolute URL when needed (for direct_url format)
+    def absolute_url(relative_path)
+      return relative_path unless @context && @context.registers[:site]
+
+      site = @context.registers[:site]
+      base_url = site.config["url"] || "http://localhost:4000"
+      baseurl = site.config["baseurl"] || ""
+
+      # Ensure base_url ends without trailing slash and baseurl starts without slash
+      base_url = base_url.chomp("/")
+      baseurl = baseurl[1..] if baseurl.start_with?("/")
+
+      # Build URL parts carefully to avoid double slashes
+      url_parts = [base_url]
+      url_parts << baseurl unless baseurl.empty?
+      url_parts << html_path(relative_path)
+
+      url_parts.join("/")
+    end
+  end
+end