jekyll-imgflow 0.1.5

data/lib/jekyll-imgflow/operation_processor.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative "filename_generator"
+
+module JekyllImgFlow
+  # OperationProcessor - processes image operations using providers
+  # Handles both single operations and batch operations
+  class OperationProcessor
+    def initialize(provider, path_resolver, manifest = nil, config = nil)
+      @provider = provider
+      @path_resolver = path_resolver
+      @filename_generator = FilenameGenerator.new
+      @manifest = manifest
+      @config = config
+    end
+
+    # Process a single operation on an image
+    # @param operation_type [Symbol] Type of operation (:resize, :crop, :quality, etc.)
+    # @param input_path [String] Path to input image
+    # @param output_path [String] Path to output image
+    # @param params [Hash] Operation parameters
+    # @return [String] Path to processed image
+    def process_single_operation(operation_type, input_path, output_path, params)
+      # Get the appropriate tag class for validation
+      tag_class = JekyllImgFlow::Tags::TagRegistry.get_tag(operation_type)
+      raise "Unknown operation: #{operation_type}" unless tag_class
+
+      # Create tag instance and process
+      tag = tag_class.new(@provider)
+      tag.process(input_path, output_path, params)
+
+      output_path
+    end
+
+    # Process an operation and return the output path
+    # @param original_name [String] Original image filename
+    # @param operation [Hash] Operation structure { type: :resize, params: { width: 800 } }
+    # @param input_path [String] Path to input image
+    # @param page_path [String] Optional page path for manifest tracking
+    # @return [String] Path to processed image
+    def process_operation(original_name, operation, input_path, page_path = nil)
+      type = operation[:type]
+      params = operation[:params]
+
+      # Generate filename using FilenameGenerator (JPT compatible)
+      filename = @filename_generator.generate_filename(input_path, params)
+      # Write to _site during build (after Jekyll copies assets)
+      actual_output_path = @path_resolver.resolve_output_path(filename)
+
+      # Determine version type
+      version_type = determine_version_type(params)
+
+      # Ensure output directory exists before processing
+      FileUtils.mkdir_p(File.dirname(actual_output_path))
+
+      # Process the operation (create the image)
+      process_single_operation(type, input_path, actual_output_path, params)
+
+      # Register in manifest
+      if @manifest
+        # Convert absolute path to relative for manifest storage
+        relative_path = actual_output_path.sub(@path_resolver.site_dest, "")
+
+        provider_name = @provider.class.provider_name
+        @manifest.register_version(
+          original_name,
+          relative_path,
+          params,
+          version_type,
+          page_path,
+          nil, # file_digest
+          provider_name
+        )
+      end
+
+      actual_output_path
+    end
+
+    # Process multiple operations on an image in sequence (batch)
+    # @param operations [Array<Hash>] Array of operations to process
+    # @param input_path [String] Path to input image
+    # @param final_output_path [String] Path to final output image
+    # @return [String] Path to final processed image
+    def process_batch_operations(operations, input_path, final_output_path)
+      return input_path if operations.empty?
+
+      current_input = input_path
+      temp_files = []
+
+      begin
+        # Process each operation in sequence
+        operations.each_with_index do |operation, index|
+          operation_type = operation[:type]
+          params = operation[:params] || {}
+
+          # Determine output path
+          if index == operations.length - 1
+            # Last operation - use final output path
+            output_path = final_output_path
+          else
+            # Intermediate operation - use temp file
+            format = params[:format] || File.extname(input_path).delete(".")
+            output_path = @path_resolver.temp_output_path(format)
+            temp_files << output_path
+          end
+
+          # Process the operation
+          current_input = process_single_operation(operation_type, current_input,
+                                                   output_path, params)
+        end
+
+        current_input
+      ensure
+        # Cleanup temp files even on failure
+        temp_files.each { |f| FileUtils.rm_f(f) }
+      end
+    end
+
+    # Check if operation needs to be processed (cache check)
+    # @param input_path [String] Path to input image
+    # @param output_path [String] Path to output image
+    # @param operations [Hash] Operations to apply
+    # @return [Boolean] True if processing needed
+    def needs_processing?(input_path, output_path, operations)
+      # If output doesn't exist, needs processing
+      return true unless File.exist?(output_path)
+
+      # If input is newer than output, needs processing
+      return true if File.mtime(input_path) > File.mtime(output_path)
+
+      # Check if operations changed by comparing cache key
+      # stored alongside the output file
+      cache_key = @filename_generator.generate_cache_key(operations)
+      cache_file = "#{output_path}.cache_key"
+
+      return true unless File.exist?(cache_file)
+
+      stored_key = File.read(cache_file).strip
+      return true if stored_key != cache_key
+
+      # No cache key file - needs processing to create it
+
+      false
+    end
+
+    # Build operation structure from params hash
+    # Combines all params into a single operation with flat params
+    # @param params [Hash] Parameters hash
+    # @return [Hash] Operation structure { type: :resize, params: { ... } }
+    def build_operation_from_params(params)
+      # Determine primary operation type
+      type = if params[:width] || params[:height]
+               :resize
+             elsif params[:crop]
+               :crop
+             elsif params[:watermark]
+               :watermark
+             else
+               :format
+             end
+
+      # Return unified operation structure with all params flattened
+      {
+        type: type,
+        params: params.compact
+      }
+    end
+
+    # Build operations array from tag parameters
+    # @param tag_params [Hash] Parameters from tag
+    # @return [Array<Hash>] Array of operation hashes
+    def build_operations_from_params(tag_params)
+      [build_operation_from_params(tag_params)]
+    end
+
+    # Determine if operations represent default or specialized version
+    # @param params [Hash] Operation parameters
+    # @return [Symbol] :default or :specialized
+    def determine_version_type(params)
+      @config&.determine_version_type(params) || :specialized
+    end
+  end
+end

data/lib/jekyll-imgflow/parser.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module JekyllImgFlow
+  # Central parser for all ImgFlow markup (tags, presets, etc.)
+  # Optimized version with reduced duplication and complexity
+  class Parser
+    # Define valid operation parameters and attribute types
+    OPERATION_PARAMS = %i[width height ratio aspect_ratio quality format formats
+                          optimize level watermark opacity position keep preset].freeze
+    HTML_ATTRIBUTES = %i[alt class title loading].freeze
+
+    # Simple operation mappings for single-parameter operations
+    SIMPLE_OPERATIONS = {
+      quality: ->(val) { { type: :quality, params: { quality: val } } },
+      watermark: ->(val) { { type: :watermark, params: { text: val } } },
+      opacity: ->(val) { { type: :alpha_opacity, params: { opacity: val } } }
+    }.freeze
+
+    def self.parse(markup, _context = nil)
+      # For KISS architecture: expect structured data from TagScanner
+      return validate_structured_data(markup) if markup.is_a?(Hash) && markup.key?(:image_path)
+
+      # Parse simple markup (backward compatibility)
+      raw_options = parse_markup_to_hash(markup)
+      operations = detect_operations(raw_options)
+      html_attributes = extract_html_attributes(raw_options)
+      image_path = extract_image_path(raw_options, markup)
+
+      # Early return if no image path
+      return build_error_response(raw_options, "No image path found in markup") unless image_path
+
+      # File validation handled by PathResolver when resolving paths
+      build_success_response(image_path, operations, html_attributes, raw_options)
+    end
+
+    def self.parse_markup_to_hash(markup)
+      options = {}
+
+      # Handle different markup formats
+      if markup.include?("=")
+        parse_key_value_format(markup, options)
+      else
+        parse_positional_format(markup, options)
+      end
+
+      options
+    end
+
+    def self.parse_key_value_format(markup, options)
+      parse_key_value_pairs(markup.split, "=", result: options, handle_arrays: false)
+    end
+
+    def self.parse_positional_format(markup, options)
+      # Use Shellwords for proper quote handling
+      parts = Shellwords.split(markup)
+
+      parse_key_value_pairs(
+        parts,
+        ":",
+        result: options,
+        handle_arrays: true,
+        image_path_handler: lambda { |part, result|
+          result[:image_path] = part unless result[:image_path]
+        }
+      )
+    end
+
+    def self.parse_key_value_pairs(pairs, separator, options = {})
+      pairs.each do |pair|
+        if pair.include?(separator)
+          key, value = pair.split(separator, 2)
+          options[:result][key.to_sym] = clean_and_convert_value(value, options)
+        elsif options[:image_path_handler]
+          options[:image_path_handler].call(pair, options[:result])
+        end
+      end
+    end
+
+    def self.clean_and_convert_value(value, options = {})
+      value = value.tr("'\"", "")
+      value = convert_numeric_value(value)
+
+      # Handle comma-separated arrays
+      value = value.split(",").map(&:strip) if options[:handle_arrays] && value.is_a?(String) && value.include?(",")
+
+      value
+    end
+
+    def self.convert_numeric_value(value)
+      return value.to_i if value.match?(/^\d+$/)
+      return value.to_f if value.match?(/^\d+\.\d+$/)
+
+      value
+    end
+
+    def self.validate_structured_data(data)
+      image_path = data[:image_path]
+      operations = data[:operations] || {}
+
+      return build_error_response(data, "No image path found in structured data") unless image_path
+
+      # Operations validation handled by Tags - Parser only parses structure
+      # File validation handled by PathResolver when resolving paths
+      build_success_response(image_path, operations, data[:html_attributes] || {}, data)
+    end
+
+    def self.detect_operations(options)
+      operations = []
+      operation_options = options.slice(*OPERATION_PARAMS)
+
+      # Handle crop+resize combination (needs sequential processing)
+      has_crop = operation_options[:ratio] || operation_options[:aspect_ratio]
+      has_resize = operation_options[:width] || operation_options[:height]
+
+      if has_crop && has_resize
+        crop_params = operation_options.slice(:ratio, :aspect_ratio, :keep, :position)
+        resize_params = operation_options.except(:ratio, :aspect_ratio, :keep, :position)
+        operations << { type: :crop, params: crop_params }
+        operations << { type: :resize, params: resize_params }
+      elsif has_crop
+        crop_params = operation_options.slice(:ratio, :aspect_ratio, :keep, :position)
+        operations << { type: :crop, params: crop_params }
+      elsif has_resize
+        operations << { type: :resize, params: operation_options }
+      end
+
+      # Add simple operations using mappings
+      SIMPLE_OPERATIONS.each do |key, builder|
+        operations << builder.call(operation_options[key]) if operation_options[key]
+      end
+
+      # Handle format operation (can be array or single value)
+      if operation_options[:format] || operation_options[:formats]
+        format_value = operation_options[:format] || operation_options[:formats]
+        operations << if format_value.is_a?(Array)
+                        { type: :format, params: { formats: format_value } }
+                      else
+                        { type: :format, params: { format: format_value } }
+                      end
+      end
+
+      # Handle optimize operation
+      if operation_options[:optimize] || operation_options[:level]
+        operations << { type: :optimize,
+                        params: { level: operation_options[:level] || :medium } }
+      end
+
+      operations
+    end
+
+    def self.extract_html_attributes(options)
+      options.slice(*HTML_ATTRIBUTES)
+    end
+
+    def self.extract_image_path(options, markup)
+      return options[:image_path] if options[:image_path]
+      return if markup.strip.empty?
+
+      # Extract first word (before space or =)
+      markup.split(/[\s=]/, 2).first&.strip
+    end
+
+    # Convert operations array from TagScanner to structured hash
+    def self.convert_operations_array(operations_array)
+      operations_array.each_with_object({}) do |op_str, hash|
+        next unless op_str.include?(":")
+
+        key, value = op_str.split(":", 2)
+        hash[key.strip.to_sym] = clean_and_convert_value(value.strip, handle_arrays: true)
+      end
+    end
+
+    def self.build_error_response(raw_options, error_message)
+      {
+        image_path: nil,
+        operations: [],
+        html_attributes: {},
+        raw_options: raw_options,
+        preset: nil,
+        error: error_message
+      }
+    end
+
+    def self.build_success_response(image_path, operations, html_attributes, raw_options)
+      {
+        image_path: image_path,
+        operations: operations,
+        html_attributes: html_attributes,
+        raw_options: raw_options,
+        preset: raw_options[:preset]
+      }
+    end
+
+    # File validation removed - handled by PathResolver when resolving paths
+    # Operations validation removed - handled by Tags
+  end
+end

data/lib/jekyll-imgflow/path_resolver.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "tmpdir"
+
+module JekyllImgFlow
+  # PathResolver - centralized path management for all image operations
+  class PathResolver
+    def initialize(config)
+      @config = config
+    end
+
+    # Get path information for an image
+    # @param image_name [String] Name of the image file
+    # @return [Hash] Path information for different use cases
+    def paths_for(image_name)
+      {
+        cli: File.join(@config.site.source, @config.originals, image_name), # Full filesystem path
+        http: File.join(@config.originals, image_name), # Relative path for URLs
+        name: image_name # Just the filename
+      }
+    end
+
+    # Get CLI path (convenience method)
+    def cli_path(image_name)
+      paths_for(image_name)[:cli]
+    end
+
+    # Get HTTP path (convenience method)
+    def http_path(image_name)
+      paths_for(image_name)[:http]
+    end
+
+    # Resolve original path with validation
+    # @param image_name [String] Name of the image file
+    # @return [String] Full path to original image file
+    # @raise [ArgumentError] If image cannot be resolved or doesn't exist
+    def resolve_original_path(image_name)
+      full_path = cli_path(image_name)
+
+      # Validate path exists and is readable
+      raise ArgumentError, "Cannot resolve image path: #{image_name} (not found: #{full_path})" unless File.exist?(full_path)
+
+      raise ArgumentError, "Image path is not a file: #{image_name} (path: #{full_path})" unless File.file?(full_path)
+
+      raise ArgumentError, "Image path not readable: #{image_name} (path: #{full_path})" unless File.readable?(full_path)
+
+      # Validate input file format against config
+      file_extension = File.extname(full_path).delete(".").downcase
+      input_formats = @config.input_formats
+
+      raise ArgumentError, "No input_formats configured in unified config" unless input_formats
+
+      unless input_formats.include?(file_extension)
+        raise ArgumentError,
+              "Invalid input format: '#{file_extension}'. Must be one of: #{input_formats.join(', ')}."
+      end
+
+      full_path
+    end
+
+    # Resolve output path for generated filename
+    # @param filename [String] Generated filename
+    # @return [String] Full path to output file in _site (for specialized versions during rendering)
+    def resolve_output_path(filename)
+      # Resolve output path relative to site destination
+      File.join(@config.site.dest, @config.output, filename)
+    end
+
+    # Resolve output path to source directory for default images
+    # @param filename [String] Generated filename
+    # @return [String] Full path to output file in source (for default versions during pre_render)
+    def resolve_source_output_path(filename)
+      # Default images go to source directory so Jekyll can copy them to _site
+      File.join(@config.site.source, @config.output, filename)
+    end
+
+    # Resolve relative output path for manifest storage
+    # @param filename [String] Generated filename
+    # @return [String] Relative path from site root
+    def resolve_relative_output_path(filename)
+      # Return path relative to site root (without leading /)
+      File.join(@config.output, filename)
+    end
+
+    # Get site destination directory
+    # @return [String] Site destination path
+    def site_dest
+      @config.site.dest
+    end
+
+    # Generate temporary output path
+    # @param format [String] File format extension
+    # @return [String] Path to temporary file
+    def temp_output_path(format)
+      File.join(Dir.tmpdir, "imgflow-out-#{SecureRandom.hex}.#{format}")
+    end
+
+    # Generate temporary input path
+    # @param extension [String] File extension
+    # @return [String] Path to temporary file
+    def temp_input_path(extension = "tmp")
+      File.join(Dir.tmpdir, "imgflow-in-#{SecureRandom.hex}.#{extension}")
+    end
+
+    # Build public URL for image
+    # @param relative_path [String] Relative path from site root
+    # @param site [Jekyll::Site] Jekyll site object
+    # @return [String] Public URL
+    def build_url(relative_path, site)
+      base_url = site.config["url"] || "http://localhost:4000"
+      baseurl = site.config["baseurl"] || ""
+      "#{base_url}#{baseurl}/#{relative_path}"
+    end
+
+    # Get relative path from site destination
+    # @param full_path [String] Full filesystem path
+    # @param site [Jekyll::Site] Jekyll site object
+    # @return [String] Relative path
+    def relative_from_dest(full_path, site)
+      # Simple path manipulation - remove site.dest prefix and leading slash
+      if full_path.start_with?(site.dest)
+        relative = full_path[site.dest.length..]
+        relative.start_with?("/") ? relative[1..] : relative
+      else
+        full_path
+      end
+    end
+  end
+end