jekyll-imgflow 0.1.5

data/lib/jekyll-imgflow/imgflow_tag.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class ImgflowTag < Liquid::Tag
+    def initialize(tag_name, markup, tokens)
+      super
+      @markup = markup.strip
+    end
+
+    def render(context)
+      # Get components
+      components = get_imgflow_components(context)
+
+      # Check if markup contains preset
+      markup_to_parse = if @markup.include?("preset:")
+                          # Route through PresetManager: preset → tags:value → Parser
+                          expand_preset_markup(@markup, components[:preset_manager])
+                        else
+                          # Direct route: markup → Parser
+                          @markup
+                        end
+
+      # Use central parser to parse markup (uniform for both paths)
+      parsed = JekyllImgFlow::Parser.parse(markup_to_parse, context)
+
+      # Process operations through the new architecture
+      process_operations(components, parsed, context)
+    rescue StandardError => e
+      # Handle errors gracefully - don't crash the build for one image
+      Jekyll.logger.error "ImgFlow Error: #{e.message}"
+      Jekyll.logger.debug "ImgFlow Backtrace: #{e.backtrace.first(5).join("\n")}"
+      "<!-- ImgFlow Error: #{e.message} -->"
+    end
+
+    private
+
+    def expand_preset_markup(markup, preset_manager)
+      # Parse markup to extract image path, preset name, and user options
+      parts = markup.split
+      image_path = parts.first
+
+      # Extract preset name and user options
+      preset_name = nil
+      user_options = {}
+
+      parts[1..].each do |part|
+        if part.start_with?("preset:")
+          preset_name = part.split(":", 2).last
+        elsif part.include?(":")
+          key, value = part.split(":", 2)
+          user_options[key.to_sym] = value
+        end
+      end
+
+      # 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}"
+    end
+
+    def process_operations(components, parsed, context)
+      return "" unless parsed[:image_path]
+
+      site = context.registers[:site]
+      page = context.registers[:page]
+      original_name = File.basename(parsed[:image_path])
+
+      # Get page path for manifest tracking
+      # Try multiple attributes to get the page identifier
+      page_path = if page
+                    page["path"] || page["url"] || page["name"] || "unknown"
+                  else
+                    "unknown"
+                  end
+
+      # Resolve input path
+      input_path = resolve_image_path(parsed[:image_path], site, components[:config])
+      raise ArgumentError, "Input image file not found: #{input_path}" unless File.file?(input_path)
+
+      # Process operations using clean architecture
+      operations = parsed[:operations]
+
+      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
+
+                 filename = components[:filename_generator].generate_filename(input_path, params)
+                 output_path = components[:path_resolver].resolve_output_path(filename)
+
+                 # 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
+
+      # Generate HTML for the result
+      generate_html([relative_result], parsed, context)
+    end
+
+    def generate_html(results, parsed, context)
+      return "" if results.empty?
+
+      # Extract attributes and markup format from parsed data
+      attributes = extract_element_attributes(parsed)
+      markup_format = parsed[:markup_format] || "img"
+
+      # Get config from components
+      components = get_imgflow_components(context)
+      config = components[:config]
+
+      # Use unified HTML generator with config
+      JekyllImgFlow::HtmlGenerator.generate(results, attributes, markup_format, context, config)
+    end
+
+    # Extract element-specific attributes from parsed data
+    def extract_element_attributes(parsed)
+      # Start with basic HTML attributes
+      base_attrs = parsed[:html_attributes] || {}
+
+      # Build element-specific attribute structure
+      {
+        img: base_attrs.reject do |k, _v|
+          k.to_s.start_with?("picture-", "source-", "a-", "parent-")
+        end,
+        picture: extract_prefixed_attrs(base_attrs, "picture-"),
+        source: extract_prefixed_attrs(base_attrs, "source-"),
+        a: extract_prefixed_attrs(base_attrs, "a-"),
+        parent: extract_prefixed_attrs(base_attrs, "parent-"),
+        alt: base_attrs[:alt],
+        link: base_attrs[:link]
+      }
+    end
+
+    # Extract attributes with a specific prefix
+    def extract_prefixed_attrs(attrs, prefix)
+      attrs.select { |k, _v| k.to_s.start_with?(prefix) }
+           .transform_keys { |k| k.to_s.sub(prefix, "") }
+    end
+
+    def render_liquid_variable(variable, context)
+      # Simple liquid variable rendering
+      variable_name = variable.tr("{}", "").strip
+      context[variable_name] || variable
+    end
+
+    # Determine if params represent a default or specialized version
+    def determine_version_type(params, config)
+      config.determine_version_type(params)
+    end
+
+    def resolve_image_path(image_path, site, config)
+      # Use PathResolver for consistent path handling
+      path_resolver = JekyllImgFlow::PathResolver.new(config)
+
+      # Handle different path formats
+      if image_path.start_with?("/") || image_path.include?("/")
+        # Absolute or relative path
+        File.join(site.source, image_path)
+      else
+        # Use PathResolver to get CLI path (full filesystem path)
+        path_resolver.cli_path(image_path)
+      end
+    end
+
+    def get_imgflow_components(context)
+      # Get or create ImgFlow components
+      site = context.registers[:site]
+
+      # Cache components on site object
+      unless site.imgflow_components
+        config = JekyllImgFlow::Config.new(site)
+        manifest = JekyllImgFlow::ManifestManager.new(site)
+        path_resolver = JekyllImgFlow::PathResolver.new(config)
+        filename_generator = JekyllImgFlow::FilenameGenerator.new
+        registry = JekyllImgFlow::ProviderRegistry.new(config)
+        provider = registry.current_provider
+        operation_processor = JekyllImgFlow::OperationProcessor.new(provider, path_resolver,
+                                                                    manifest, config)
+        preset_manager = JekyllImgFlow::PresetManager.new(site, config)
+
+        site.imgflow_components = {
+          config: config,
+          manifest: manifest,
+          path_resolver: path_resolver,
+          filename_generator: filename_generator,
+          registry: registry,
+          provider: provider,
+          operation_processor: operation_processor,
+          preset_manager: preset_manager
+        }
+      end
+
+      # Manifest is shared with BuildTimeProcessor for page usage tracking
+
+      site.imgflow_components
+    end
+  end
+end
+
+# Register the tag with Liquid
+Liquid::Template.register_tag("imgflow", Jekyll::ImgflowTag)

data/lib/jekyll-imgflow/manifest_manager.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "digest"
+
+module JekyllImgFlow
+  # Manages the manifest of generated images
+  # Tracks default vs specialized versions and page usage for cleanup
+  class ManifestManager
+    VERSION_TYPES = %w[default specialized].freeze
+    attr_reader :manifest_path
+
+    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
+      @current_provider = current_provider
+
+      # Check if provider changed and invalidate cache if needed
+      handle_provider_change if provider_changed?
+    end
+
+    # Load existing manifest or create new one
+    def load_manifest
+      if File.exist?(@manifest_path)
+        begin
+          data = JSON.parse(File.read(@manifest_path))
+
+          # Handle new format with provider at top level
+          if data.is_a?(Hash) && data.key?("images")
+            @cached_provider = data["provider"]
+            data["images"] || {}
+          else
+            # Old format - just image data
+            @cached_provider = nil
+            data
+          end
+        rescue JSON::ParserError => e
+          Jekyll.logger.warn "ImgFlow: Corrupt manifest file, starting fresh: #{e.message}"
+          @cached_provider = nil
+          {}
+        end
+      else
+        @cached_provider = nil
+        {}
+      end
+    end
+
+    # Save manifest to disk
+    def save
+      # Store current provider at top level of manifest
+      manifest_data = {
+        "provider" => @current_provider,
+        "images" => @manifest
+      }
+
+      FileUtils.mkdir_p(File.dirname(@manifest_path))
+      File.write(@manifest_path, JSON.pretty_generate(manifest_data))
+    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
+
+    # Clean up manifest entries for deleted original images
+    # @param current_originals [Array<String>] Array of current original image basenames
+    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, ".*")
+
+        # 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}"
+        end
+      end
+    end
+
+    # Check if a specific image version exists and is up-to-date
+    def version_exists?(original_name, operations, type = :specialized)
+      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 }
+      Jekyll.logger.debug "🔍 ManifestManager: Final result: #{result}"
+      result
+    end
+
+    # Check if the provider has changed since the manifest was created
+    def provider_changed?
+      # If no cached provider, this is a new manifest
+      return false if @cached_provider.nil?
+
+      # Provider changed if current doesn't match cached
+      @cached_provider != @current_provider
+    end
+
+    # Handle provider change by invalidating cache and cleaning optimized directory
+    def handle_provider_change
+      Jekyll.logger.warn "ImgFlow:",
+                         "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.dest, 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
+
+      # Clear manifest cache
+      @manifest.clear
+      Jekyll.logger.warn "ImgFlow:",
+                         "Manifest cache cleared - all images will be regenerated with '#{@current_provider}'"
+
+      # Update cached provider to current
+      @cached_provider = @current_provider
+    end
+
+    # Get output path for a specific version
+    def get_version_output(original_name, operations, type = :specialized)
+      return unless @manifest[original_name]
+
+      versions = @manifest.dig(original_name, "versions", type.to_s) || []
+      version = versions.find { |v| v["operations"] == operations }
+      version&.dig("output")
+    end
+
+    # Update page usage for an existing version
+    # This is a convenience method that calls register_version
+    def update_page_usage(original_name, operations, type, page_path)
+      Jekyll.logger.debug "🔍 update_page_usage: original_name=#{original_name}, operations=#{operations.inspect}, type=#{type}, page_path=#{page_path}"
+
+      # Get the existing version's output path (already relative)
+      output_path = get_version_output(original_name, operations, type)
+      Jekyll.logger.debug "🔍 update_page_usage: output_path=#{output_path}"
+      return unless output_path
+
+      # Get the existing version to preserve provider
+      versions = @manifest.dig(original_name, "versions", type.to_s) || []
+      version = versions.find { |v| v["operations"] == operations }
+      provider = version&.dig("provider")
+      Jekyll.logger.debug "🔍 update_page_usage: provider=#{provider}, current used_on=#{version&.dig('used_on')&.inspect}"
+
+      # Call register_version to update page usage (output_path is already relative)
+      register_version(original_name, output_path, operations, type, page_path, nil, provider)
+      Jekyll.logger.debug "🔍 update_page_usage: completed register_version call"
+    end
+
+    # Register a new image version
+    def register_version(original_name, output_path, operations, type, page_path,
+                         file_digest = nil, provider = nil)
+      @manifest[original_name] ||= {
+        "versions" => { "default" => [], "specialized" => [] },
+        "file_digest" => file_digest # Store SHA256 digest of original file
+      }
+
+      # Update file digest if provided
+      @manifest[original_name]["file_digest"] = file_digest if file_digest
+
+      versions = @manifest[original_name]["versions"][type.to_s] ||= []
+
+      # Find or create version entry
+      version = versions.find { |v| v["operations"] == operations }
+
+      # Normalize page_path to array
+      page_paths = if page_path.is_a?(Array)
+                     page_path
+                   else
+                     (page_path ? [page_path] : [])
+                   end
+
+      if version
+        # Add pages to used_on list if not already present
+        version["used_on"] ||= []
+        page_paths.each do |path|
+          version["used_on"] << path if path && !version["used_on"].include?(path)
+        end
+        # Update provider if provided
+        version["provider"] = provider if provider
+      else
+        # Create new version entry
+        versions << {
+          "output" => output_path,
+          "operations" => operations,
+          "type" => type.to_s,
+          "used_on" => page_paths,
+          "created_at" => Time.now.to_i,
+          "provider" => provider
+        }
+      end
+    end
+
+    # Check if image version is default type
+    def default_version?(original_name, operations)
+      return false unless @manifest[original_name]
+
+      versions = @manifest.dig(original_name, "versions", "default") || []
+      versions.any? { |v| v["operations"] == operations }
+    end
+
+    # Find orphaned specialized images (not used on any page)
+    def find_orphans
+      orphans = []
+
+      @manifest.each do |original_name, data|
+        specialized = data.dig("versions", "specialized") || []
+        specialized.each do |version|
+          next unless version["used_on"].nil? || version["used_on"].empty?
+
+          orphans << {
+            "original" => original_name,
+            "output" => version["output"],
+            "operations" => version["operations"]
+          }
+        end
+      end
+
+      orphans
+    end
+
+    # Remove page from all image version usage tracking
+    def remove_page_usage(page_path)
+      @manifest.each_value do |data|
+        VERSION_TYPES.each do |type|
+          versions = data.dig("versions", type) || []
+          versions.each do |version|
+            version["used_on"]&.delete(page_path)
+          end
+        end
+      end
+    end
+
+    # Cleanup orphaned specialized images
+    def cleanup_orphans
+      orphans = find_orphans
+      cleaned = []
+
+      orphans.each do |orphan|
+        output_file = if orphan["output"].start_with?("/")
+                        orphan["output"]
+                      else
+                        File.join(@site.dest,
+                                  orphan["output"])
+                      end
+        if File.exist?(output_file)
+          File.delete(output_file)
+          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"] }
+      end
+
+      cleaned
+    end
+
+    # Get all versions for an original image
+    def get_versions(original_name)
+      @manifest.dig(original_name, "versions") || { "default" => [], "specialized" => [] }
+    end
+
+    # Check if original image has any versions
+    def versions?(original_name)
+      return false unless @manifest[original_name]
+
+      versions = @manifest[original_name]["versions"]
+      (versions["default"]&.any? || false) || (versions["specialized"]&.any? || false)
+    end
+  end
+end