jekyll-imgflow 0.1.5

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "uri"
+require "net/http"
+require "tempfile"
+require_relative "base_provider"
+
+module JekyllImgFlow
+  module Providers
+    # Imgproxy provider implementation using the standardized tag interface
+    class Imgproxy < BaseProvider
+      TIMEOUT = 10 # seconds
+
+      def available?
+        # Check if imgproxy service is running
+        return false unless @config.respond_to?(:imgproxy_url) && @config.imgproxy_url
+
+        check_http_service(@config.imgproxy_url)
+      end
+
+      def execute(input_path, output_path)
+        return if @operations.empty?
+
+        # Build single Imgproxy URL with all operations combined
+        url = build_combined_imgproxy_url(input_path)
+
+        # Fetch the result in one request
+        fetch_and_save(url, output_path)
+        reset_operations
+        output_path
+      end
+
+      def build_combined_imgproxy_url(input_path)
+        raise "imgproxy_url not set" unless @config.imgproxy_url
+
+        encoded_url = encode_file_url(input_path)
+        operations = []
+
+        # Add all operations to single URL path
+        @operations.each do |operation|
+          case operation[:type]
+          when :resize
+            # Tags now provide complete calculated values
+            operations << if operation[:height]
+                            "rs:fill:#{operation[:width]}:#{operation[:height]}:1"
+                          else
+                            "rs:fit:#{operation[:width]}::1"
+                          end
+
+          when :crop
+            opts = operation[:options]
+            params = operation[:params] || {}
+
+            # Check for keep parameter (smartcrop support)
+            keep = opts[:keep] || params[:keep] || params[:position]
+
+            if operation[:ratio] && keep && SMARTCROP_POSITIONS.include?(keep.to_s)
+              # Use smartcrop with gravity:sm (libvips smart crop)
+              crop_width = opts[:calculated_width]
+              crop_height = opts[:calculated_height]
+
+              operations << "g:sm"
+              operations << "c:#{crop_width}:#{crop_height}"
+            else
+              # Use basic cropping with explicit coordinates
+              if operation[:ratio]
+                crop_x = opts[:calculated_x]
+                crop_y = opts[:calculated_y]
+                crop_width = opts[:calculated_width]
+                crop_height = opts[:calculated_height]
+              else
+                crop_x = opts[:x]
+                crop_y = opts[:y]
+                crop_width = opts[:width]
+                crop_height = opts[:height]
+              end
+              # imgproxy crop format: c:width:height:gravity
+              # Use nowe (north-west) gravity with x/y offsets for pixel-precise cropping
+              operations << "g:nowe:#{crop_x}:#{crop_y}"
+              operations << "c:#{crop_width}:#{crop_height}"
+            end
+
+          when :quality
+            imgproxy_quality = translate_quality_to_imgproxy(operation[:quality])
+            operations << "q:#{imgproxy_quality}"
+
+          when :format
+            # Assume validated input from tags
+            operations << "f:#{operation[:format]}"
+
+          when :watermark
+            watermark_path = operation[:watermark_path]
+            position = operation[:options][:position]
+            operation[:options][:opacity]
+
+            # Imgproxy watermark parameters
+            encoded_watermark = encode_file_url(watermark_path)
+            position_param = translate_imgproxy_position(position)
+            operations << "wm:#{encoded_watermark}:#{position_param}:10:10"
+
+          when :alpha_opacity
+            opacity = operation[:opacity]
+            operations << "a:#{(opacity * 255).round}"
+          end
+        end
+
+        # Preserve format when no explicit format operation is requested.
+        # Without this, chained HTTP requests (e.g. quality-only steps after a
+        # prior format conversion) would lose the previously converted format.
+        unless @operations.any? { |op| op[:type] == :format }
+          input_ext = File.extname(input_path).delete(".").downcase
+          operations << "f:#{input_ext}" unless input_ext.empty?
+        end
+
+        # Build combined URL: base/insecure/operations/operations/.../plain/encoded_url
+        operations_path = operations.join("/")
+        "#{@config.imgproxy_url}/insecure/#{operations_path}/plain/#{encoded_url}"
+      end
+
+      private
+
+      def translate_imgproxy_position(position)
+        # Translate compass directions to Imgproxy position format
+        case position
+        when "northwest" then "tl"
+        when "northeast" then "tr"
+        when "southwest" then "bl"
+        when "southeast" then "br"
+        when "center" then "c"
+        else position
+        end
+      end
+
+      def fetch_and_save(url, output_path)
+        response = fetch_with_timeout(url)
+        raise "Imgproxy request failed" if response.empty?
+
+        FileUtils.mkdir_p(File.dirname(output_path))
+        File.write(output_path, response)
+      end
+
+      def fetch_with_timeout(url)
+        uri = URI(url)
+        Net::HTTP.start(uri.host, uri.port,
+                        use_ssl: uri.scheme == "https",
+                        open_timeout: TIMEOUT,
+                        read_timeout: TIMEOUT) do |http|
+          request = Net::HTTP::Get.new(uri)
+          response = http.request(request)
+
+          raise "HTTP #{response.code}: #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+          response.body
+        end
+      rescue StandardError => e
+        raise "Imgproxy request failed: #{e.message}"
+      end
+
+      def translate_quality_to_imgproxy(quality)
+        quality
+      end
+    end
+  end
+end

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

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "open3"
+require_relative "base_provider"
+
+module JekyllImgFlow
+  module Providers
+    # Libvips provider implementation using the standardized tag interface
+    class Libvips < BaseProvider
+      def available?
+        # Check if vips CLI is available
+        _, _, status = Open3.capture3("which", "vips")
+        status.success?
+      end
+
+      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)
+
+        reset_operations
+        output_path
+      end
+
+      def build_vips_command(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 }
+        has_alpha = @operations.any? { |op| op[:type] == :alpha_opacity }
+
+        if has_watermark
+          build_watermark_pipeline(input_path, output_path, has_crop, has_resize)
+        elsif has_alpha
+          build_alpha_pipeline(input_path, output_path, has_crop, has_resize)
+        elsif has_crop && has_resize
+          build_sequential_crop_resize(input_path, output_path)
+        elsif has_resize
+          build_resize_command(input_path, output_path)
+        elsif has_crop
+          build_crop_command(input_path, output_path)
+        else
+          build_copy_command(input_path, output_path)
+        end
+      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)
+          base_path = temp_path
+        elsif has_resize
+          commands << build_resize_command(input_path, temp_path)
+          base_path = temp_path
+        elsif has_crop
+          commands << build_crop_command(input_path, temp_path)
+          base_path = temp_path
+        else
+          base_path = input_path
+        end
+
+        commands << build_alpha_command(base_path, output_path)
+        commands << "rm -f #{temp_path.shellescape}" unless base_path == input_path
+        commands.join(" && ")
+      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)
+          base_path = temp_path
+        elsif has_resize
+          commands << build_resize_command(input_path, temp_path)
+          base_path = temp_path
+        elsif has_crop
+          commands << build_crop_command(input_path, temp_path)
+          base_path = temp_path
+        else
+          base_path = input_path
+        end
+
+        # Step 2: Apply alpha opacity if present (before watermark)
+        alpha_op = @operations.find { |op| op[:type] == :alpha_opacity }
+        if alpha_op
+          alpha_temp = input_path.gsub(/\.[^.]+$/, ".tmp_alpha.jpg")
+          commands << build_alpha_command(base_path, alpha_temp)
+          base_path = alpha_temp
+        end
+
+        # Step 3: Composite watermark over base
+        commands << build_composite_command(base_path, final_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}" }
+
+        commands.join(" && ")
+      end
+
+      def build_composite_command(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}"
+        else
+          ["vips", "composite2", base_path.shellescape,
+           watermark_path.shellescape, format_spec, "over",
+           position_to_vips_xy(position, base_path, watermark_path)].join(" ")
+        end
+      end
+
+      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"
+        when "southwest", "bottom-left"
+          "--x 0 --y $(vips header #{watermark_path.shellescape} height)"
+        when "southeast", "bottom-right"
+          "--x $(vips header #{watermark_path.shellescape} width) " \
+          "--y $(vips header #{watermark_path.shellescape} height)"
+        else
+          "--x 0 --y 0" # northwest, top-left, center, centre, and default
+        end
+      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(" ")
+      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}"
+      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
+        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(" ")
+        end
+      end
+
+      def build_crop_command(input_path, output_path)
+        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
+                            end
+
+          # vips smartcrop input.jpg output.jpg width height --interesting=attention
+          ["vips", "smartcrop", input_path.shellescape, output_path.shellescape,
+           crop_width.to_s, crop_height.to_s,
+           "--interesting=#{interestingness}"].join(" ")
+        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(" ")
+        end
+      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(" ")
+      end
+
+      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
+
+        # 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}]'"
+        else
+          "'#{base}.#{ext}'"
+        end
+      end
+
+      def execute_command(command)
+        Jekyll.logger.debug "LibVips command: #{command}"
+
+        # Execute command and capture output
+        stdout, stderr, status = Open3.capture3(command)
+        output = "#{stdout}#{stderr}"
+        success = status.success?
+
+        unless success
+          # Filter out expected warnings and only log real errors
+          raise "LibVips command failed: #{command}\nError: #{output}" unless output.include?("same file") || output.include?("VipsForeignSave")
+
+          Jekyll.logger.warn "LibVips warning: #{output.strip}"
+          return output.strip # Continue despite warnings
+
+        end
+
+        output.strip
+      end
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "open3"
+require_relative "base_provider"
+
+module JekyllImgFlow
+  module Providers
+    # Sharp provider implementation using the standardized tag interface
+    class Sharp < BaseProvider
+      def available?
+        # Check if sharp CLI is available
+        _, _, status = Open3.capture3("which", "sharp")
+        status.success?
+      end
+
+      def execute(input_path, output_path)
+        return if @operations.empty?
+
+        # Build Sharp command
+        command = build_sharp_command(input_path, output_path)
+        execute_command(command)
+
+        reset_operations
+        output_path
+      end
+
+      def build_sharp_command(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 }
+
+        if has_watermark
+          build_watermark_pipeline(input_path, output_path, has_crop, has_resize)
+        elsif has_crop && has_resize
+          build_sequential_crop_resize(input_path, output_path)
+        elsif has_resize
+          build_resize_command(input_path, output_path)
+        elsif has_crop
+          build_crop_command(input_path, output_path)
+        else
+          build_copy_command(input_path, output_path)
+        end
+      end
+
+      def build_watermark_pipeline(input_path, output_path, has_crop, has_resize)
+        temp_path = input_path.gsub(/\.[^.]+$/, ".tmp_base.jpg")
+        commands = []
+
+        if has_crop && has_resize
+          commands << build_sequential_crop_resize(input_path, temp_path)
+          base_path = temp_path
+        elsif has_resize
+          commands << build_resize_command(input_path, temp_path)
+          base_path = temp_path
+        elsif has_crop
+          commands << build_crop_command(input_path, temp_path)
+          base_path = temp_path
+        else
+          base_path = input_path
+        end
+
+        commands << build_composite_command(base_path, output_path)
+        commands << "rm -f #{temp_path.shellescape}" unless base_path == input_path
+        commands.join(" && ")
+      end
+
+      def build_composite_command(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]
+
+        gravity = translate_position(position)
+
+        command_parts = ["sharp", "-i", base_path.shellescape,
+                         "-o", output_path.shellescape]
+
+        format_op = @operations.find { |op| op[:type] == :format }
+        quality_op = @operations.find { |op| op[:type] == :quality }
+        command_parts += ["-f", format_op[:format]] if format_op
+        command_parts += ["-q#{quality_op[:quality]}"] if quality_op
+
+        if opacity && opacity < 1.0
+          wm_temp = watermark_path.gsub(/\.[^.]+$/, ".tmp_wm.png")
+          alpha_value = (opacity * 255).round
+          temp_cmd = ["sharp", "-i", watermark_path.shellescape,
+                      "-o", wm_temp.shellescape,
+                      "ensureAlpha", alpha_value.to_s].join(" ")
+          command_parts += ["composite", wm_temp.shellescape,
+                            "--gravity", gravity, "--blend", "over"]
+          "#{temp_cmd} && #{command_parts.join(' ')} " \
+            "&& rm -f #{wm_temp.shellescape}"
+        else
+          command_parts += ["composite", watermark_path.shellescape,
+                            "--gravity", gravity, "--blend", "over"]
+          command_parts.join(" ")
+        end
+      end
+
+      def translate_position(position)
+        case position.to_s
+        when "northwest" then "northwest"
+        when "northeast" then "northeast"
+        when "southwest" then "southwest"
+        when "southeast" then "southeast"
+        when "center" then "center"
+        else position.to_s
+        end
+      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}"
+      end
+
+      def build_resize_command(input_path, output_path)
+        resize_op = @operations.find { |op| op[:type] == :resize }
+
+        # sharp -i input.jpg -o output.jpg resize width [height] -f format -q quality
+        command_parts = ["sharp", "-i", input_path.shellescape, "-o", output_path.shellescape]
+
+        # Add resize
+        command_parts += if resize_op[:height]
+                           ["resize", resize_op[:width].to_s, resize_op[:height].to_s]
+                         else
+                           ["resize", resize_op[:width].to_s]
+                         end
+
+        # Add format, quality, alpha
+        format_op = @operations.find { |op| op[:type] == :format }
+        quality_op = @operations.find { |op| op[:type] == :quality }
+        alpha_op = @operations.find { |op| op[:type] == :alpha_opacity }
+
+        command_parts += ["-f", format_op[:format]] if format_op
+        command_parts += ["-q#{quality_op[:quality]}"] if quality_op
+        if alpha_op
+          alpha_value = (alpha_op[:opacity] * 255).round
+          command_parts += ["alpha", "{alpha:#{alpha_value}}"]
+        end
+
+        command_parts.join(" ")
+      end
+
+      def build_crop_command(input_path, output_path)
+        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 smartcrop for intelligent cropping (Sharp uses libvips backend)
+          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
+                            end
+
+          # sharp -i input.jpg -o output.jpg smartcrop width height --interesting=attention
+          ["sharp", "-i", input_path.shellescape, "-o", output_path.shellescape,
+           "smartcrop", crop_width.to_s, crop_height.to_s,
+           "--interesting=#{interestingness}"].join(" ")
+        else
+          # Use basic extract 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]
+
+          # sharp -i input.jpg -o output.jpg extract top left width height
+          ["sharp", "-i", input_path.shellescape, "-o", output_path.shellescape,
+           "extract", crop_y.to_s, crop_x.to_s, crop_width.to_s, crop_height.to_s].join(" ")
+        end
+      end
+
+      def build_copy_command(input_path, output_path)
+        # sharp -i input.jpg -o output.jpg -f format -q quality
+        command_parts = ["sharp", "-i", input_path.shellescape, "-o", output_path.shellescape]
+
+        format_op = @operations.find { |op| op[:type] == :format }
+        quality_op = @operations.find { |op| op[:type] == :quality }
+        alpha_op = @operations.find { |op| op[:type] == :alpha_opacity }
+
+        command_parts += ["-f", format_op[:format]] if format_op
+        command_parts += ["-q#{quality_op[:quality]}"] if quality_op
+        if alpha_op
+          alpha_value = (alpha_op[:opacity] * 255).round
+          command_parts += ["alpha", "{alpha:#{alpha_value}}"]
+        end
+
+        command_parts.join(" ")
+      end
+    end
+  end
+end