jekyll-imgflow 0.3.3 → 0.4.0

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

@@ -7,24 +7,17 @@ require_relative "base_provider"
 module JekyllImgFlow
   module Providers
     # Libvips provider implementation using the standardized tag interface
-    class Libvips < BaseProvider
+    class Libvips < CliBase
       def available?
-        # Check if vips CLI is available
-        _, _, status = Open3.capture3("which", "vips")
-        status.success?
+        cli_available?("vips")
       end
 
-      def execute(input_path, output_path)
-        return if @operations.empty?
-
-        # Build and execute vips commands (array form, no shell).
-        # Cleanup markers ([:cleanup, path]) are handled by execute_command.
-        commands = build_vips_commands(input_path, output_path)
-        commands.each { |cmd_array| execute_command(cmd_array) }
+      def build_commands(input_path, output_path)
+        build_vips_commands(input_path, output_path)
+      end
 
-        output_path
-      ensure
-        reset_operations
+      def run_command(cmd)
+        execute_command(cmd)
       end
 
       # Build all vips commands as an array of command arrays.
@@ -48,10 +41,10 @@ module JekyllImgFlow
 
       def operation_flags
         {
-          crop: @operations.any? { |op| op[:type] == :crop },
-          resize: @operations.any? { |op| op[:type] == :resize },
-          watermark: @operations.any? { |op| op[:type] == :watermark },
-          alpha: @operations.any? { |op| op[:type] == :alpha_opacity }
+          crop: op?(:crop),
+          resize: op?(:resize),
+          watermark: op?(:watermark),
+          alpha: op?(:alpha_opacity)
         }
       end
 
@@ -72,19 +65,19 @@ module JekyllImgFlow
       end
 
       def build_alpha_pipeline(input_path, output_path, has_crop, has_resize)
-        temp_path = input_path.gsub(/\.[^.]+$/, ".tmp_base.jpg")
-        commands, base_path = build_base_pipeline(input_path, temp_path, has_crop, has_resize)
+        temp = temp_path(input_path, "tmp_base.jpg")
+        commands, base_path = build_base_pipeline(input_path, temp, has_crop, has_resize)
         commands << build_alpha_command(base_path, output_path)
-        commands << [:cleanup, temp_path] unless base_path == input_path
+        commands << [:cleanup, temp] unless base_path == input_path
         commands
       end
 
       def build_watermark_pipeline(input_path, output_path, has_crop, has_resize)
-        temp_path = input_path.gsub(/\.[^.]+$/, ".tmp_base.jpg")
-        commands, base_path = build_base_pipeline(input_path, temp_path, has_crop, has_resize)
+        temp = temp_path(input_path, "tmp_base.jpg")
+        commands, base_path = build_base_pipeline(input_path, temp, has_crop, has_resize)
         base_path, commands = apply_watermark_alpha(base_path, input_path, commands)
         commands.concat(build_composite_commands(base_path, output_path))
-        cleanup_paths(commands, input_path, temp_path, base_path)
+        cleanup_paths(commands, input_path, temp, base_path)
         commands
       end
 
@@ -97,10 +90,10 @@ module JekyllImgFlow
       end
 
       def apply_watermark_alpha(base_path, input_path, commands)
-        alpha_op = @operations.find { |op| op[:type] == :alpha_opacity }
+        alpha_op = find_op(:alpha_opacity)
         return [base_path, commands] unless alpha_op
 
-        alpha_temp = input_path.gsub(/\.[^.]+$/, ".tmp_alpha.jpg")
+        alpha_temp = temp_path(input_path, "tmp_alpha.jpg")
         [alpha_temp, commands << build_alpha_command(base_path, alpha_temp)]
       end
 
@@ -110,26 +103,24 @@ module JekyllImgFlow
       end
 
       def build_composite_commands(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]
-
-        if opacity && opacity < 1.0
-          wm_temp = watermark_path.gsub(/\.[^.]+$/, ".tmp_wm.png")
-          alpha_value = opacity
+        wm_op = find_op(:watermark)
+        parts = watermark_parts(wm_op)
+
+        if parts[:opacity] && parts[:opacity] < 1.0
+          wm_temp = temp_path(parts[:watermark_path], "tmp_wm.png")
+          alpha_value = parts[:opacity]
           # Step 1: Apply alpha to watermark
-          alpha_cmd = ["vips", "linear", watermark_path,
+          alpha_cmd = ["vips", "linear", parts[:watermark_path],
                        "#{wm_temp}[alpha]", "1 1 1 #{alpha_value}", "0"]
           # Step 2: Composite
-          xy_args = position_to_vips_xy(position, base_path, watermark_path)
+          xy_args = position_to_vips_xy(parts[:position], base_path, parts[:watermark_path])
           composite_cmd = ["vips", "composite2", base_path, wm_temp,
                            build_format_spec(output_path), "over"] + xy_args
           # Step 3: Cleanup wm_temp
           [alpha_cmd, composite_cmd, [:cleanup, wm_temp]]
         else
-          xy_args = position_to_vips_xy(position, base_path, watermark_path)
-          [["vips", "composite2", base_path, watermark_path,
+          xy_args = position_to_vips_xy(parts[:position], base_path, parts[:watermark_path])
+          [["vips", "composite2", base_path, parts[:watermark_path],
             build_format_spec(output_path), "over"] + xy_args]
         end
       end
@@ -168,9 +159,8 @@ module JekyllImgFlow
       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)
+        alpha_op = find_op(:alpha_opacity)
+        alpha_value = alpha_op[:opacity].round(2)
 
         # vips linear multiplies alpha band: "1 1 1 alpha" scales alpha
         ["vips", "linear", input_path, output_path,
@@ -180,22 +170,22 @@ module JekyllImgFlow
       def build_sequential_crop_resize(input_path, output_path)
         if svg?(input_path)
           # SVG: use thumbnail with --crop to do crop+resize in one step
-          resize_op = @operations.find { |op| op[:type] == :resize }
+          resize_op = find_op(:resize)
           format_spec = build_format_spec(output_path)
           width = resize_op[:width]
           height = resize_op[:height]
           [["vips", "thumbnail", input_path, format_spec,
             width.to_s, "--height=#{height}", "--crop=attention"]]
         else
-          temp_path = input_path.gsub(/\.[^.]+$/, ".tmp_crop.jpg")
-          [build_crop_command(input_path, temp_path),
-           build_resize_command(temp_path, output_path),
-           [:cleanup, temp_path]]
+          temp = temp_path(input_path, "tmp_crop.jpg")
+          [build_crop_command(input_path, temp),
+           build_resize_command(temp, output_path),
+           [:cleanup, temp]]
         end
       end
 
       def build_resize_command(input_path, output_path)
-        resize_op = @operations.find { |op| op[:type] == :resize }
+        resize_op = find_op(:resize)
         format_spec = build_format_spec(output_path)
         width = resize_op[:width]
         height = resize_op[:height]
@@ -216,35 +206,23 @@ module JekyllImgFlow
       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] || {}
-        keep = opts[:keep] || params[:keep] || params[:position]
-        return build_smartcrop_command(crop_op, opts, keep, input_path, output_path) if smartcrop?(crop_op, keep)
+        crop_op = find_op(:crop)
+        geo = crop_geometry(crop_op)
+        return build_smartcrop_command(geo, input_path, output_path) if geo[:smartcrop]
 
-        build_extract_command(crop_op, opts, input_path, output_path)
+        build_extract_command(geo, input_path, output_path)
       end
 
-      def smartcrop?(crop_op, keep)
-        crop_op[:ratio] && keep && %w[attention entropy center centre].include?(keep.to_s)
-      end
-
-      def build_smartcrop_command(_crop_op, opts, keep, input_path, output_path)
-        interestingness = %w[center centre].include?(keep.to_s) ? "centre" : keep.to_s
-        interestingness = "attention" unless %w[entropy centre].include?(interestingness)
+      def build_smartcrop_command(geo, input_path, output_path)
+        interestingness = smartcrop_interestingness(geo[:keep])
         ["vips", "smartcrop", input_path, output_path,
-         opts[:calculated_width].to_s, opts[:calculated_height].to_s,
+         geo[:width].to_s, geo[:height].to_s,
          "--interesting=#{interestingness}"]
       end
 
-      def build_extract_command(crop_op, opts, input_path, output_path)
-        ratio = crop_op[:ratio]
-        x = ratio ? opts[:calculated_x] : (opts[:x] || 0)
-        y = ratio ? opts[:calculated_y] : (opts[:y] || 0)
-        width = ratio ? opts[:calculated_width] : opts[:width]
-        height = ratio ? opts[:calculated_height] : opts[:height]
+      def build_extract_command(geo, input_path, output_path)
         ["vips", "extract_area", input_path, output_path,
-         x.to_s, y.to_s, width.to_s, height.to_s]
+         geo[:x].to_s, geo[:y].to_s, geo[:width].to_s, geo[:height].to_s]
       end
 
       # SVG crop: use `vips thumbnail` with --crop to crop during thumbnailing.
@@ -254,18 +232,12 @@ module JekyllImgFlow
       # the most interesting region — this is the correct behavior for SVGs
       # since they have no fixed pixel dimensions.
       def build_svg_crop_pipeline(input_path, output_path)
-        crop_op = @operations.find { |op| op[:type] == :crop }
-        opts = crop_op[:options] || {}
-        crop_width = crop_op[:ratio] ? opts[:calculated_width] : (opts[:width] || 1000)
-        crop_height = crop_op[:ratio] ? opts[:calculated_height] : (opts[:height] || 1000)
+        crop_op = find_op(:crop)
+        geo = crop_geometry(crop_op)
+        crop_width = geo[:width] || 1000
+        crop_height = geo[:height] || 1000
         format_spec = build_format_spec(output_path)
-
-        keep = opts[:keep] || crop_op[:params]&.[](:keep) || crop_op[:params]&.[](:position)
-        interestingness = case keep.to_s
-                          when "entropy" then "entropy"
-                          when "center", "centre" then "centre"
-                          else "attention"
-                          end
+        interestingness = smartcrop_interestingness(geo[:keep])
 
         [["vips", "thumbnail", input_path, format_spec,
           crop_width.to_s, "--height=#{crop_height}",
@@ -287,8 +259,8 @@ module JekyllImgFlow
       # are executed via Open3.capture3 array form (no shell).
       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 }
+        format_op = find_op(:format)
+        quality_op = find_op(:quality)
 
         # Simple case: no format/quality operations
         return output_path unless format_op || quality_op

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

@@ -7,37 +7,23 @@ require_relative "base_provider"
 module JekyllImgFlow
   module Providers
     # Sharp provider implementation using the standardized tag interface
-    class Sharp < BaseProvider
+    class Sharp < CliBase
       def available?
-        # Check if sharp CLI is available
-        _, _, status = Open3.capture3("which", "sharp")
-        status.success?
+        cli_available?("sharp")
       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)
-
-        output_path
-      ensure
-        reset_operations
+      def build_commands(input_path, output_path)
+        build_sharp_command(input_path, 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
+        if op?(:watermark)
+          build_watermark_pipeline(input_path, output_path, op?(:crop), op?(:resize))
+        elsif op?(:crop) && op?(:resize)
           build_sequential_crop_resize(input_path, output_path)
-        elsif has_resize
+        elsif op?(:resize)
           build_resize_command(input_path, output_path)
-        elsif has_crop
+        elsif op?(:crop)
           build_crop_command(input_path, output_path)
         else
           build_copy_command(input_path, output_path)
@@ -45,47 +31,41 @@ module JekyllImgFlow
       end
 
       def build_watermark_pipeline(input_path, output_path, has_crop, has_resize)
-        temp_path = input_path.gsub(/\.[^.]+$/, ".tmp_base.jpg")
+        temp = temp_path(input_path, "tmp_base.jpg")
         commands = []
 
         if has_crop && has_resize
-          commands << build_sequential_crop_resize(input_path, temp_path)
-          base_path = temp_path
+          commands << build_sequential_crop_resize(input_path, temp)
+          base_path = temp
         elsif has_resize
-          commands << build_resize_command(input_path, temp_path)
-          base_path = temp_path
+          commands << build_resize_command(input_path, temp)
+          base_path = temp
         elsif has_crop
-          commands << build_crop_command(input_path, temp_path)
-          base_path = temp_path
+          commands << build_crop_command(input_path, temp)
+          base_path = temp
         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 << "rm -f #{temp.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)
+        wm_op = find_op(:watermark)
+        parts = watermark_parts(wm_op)
+        gravity = translate_position(parts[: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", sharp_format(format_op[:format])] if format_op
-        command_parts += ["-q#{quality_op[:quality]}"] if quality_op
+        add_format_quality(command_parts)
 
-        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,
+        if parts[:opacity] && parts[:opacity] < 1.0
+          wm_temp = temp_path(parts[:watermark_path], "tmp_wm.png")
+          alpha_value = alpha_byte_value(parts[:opacity])
+          temp_cmd = ["sharp", "-i", parts[:watermark_path].shellescape,
                       "-o", wm_temp.shellescape,
                       "ensureAlpha", alpha_value.to_s].join(" ")
           command_parts += ["composite", wm_temp.shellescape,
@@ -93,7 +73,7 @@ module JekyllImgFlow
           "#{temp_cmd} && #{command_parts.join(' ')} " \
             "&& rm -f #{wm_temp.shellescape}"
         else
-          command_parts += ["composite", watermark_path.shellescape,
+          command_parts += ["composite", parts[:watermark_path].shellescape,
                             "--gravity", gravity, "--blend", "over"]
           command_parts.join(" ")
         end
@@ -112,20 +92,20 @@ module JekyllImgFlow
 
       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")
+        temp = temp_path(input_path, "tmp_crop.jpg")
 
         # First command: crop only
-        crop_cmd = build_crop_command(input_path, temp_path)
+        crop_cmd = build_crop_command(input_path, temp)
 
         # Second command: resize + format + quality + alpha (all together)
-        resize_cmd = build_resize_command(temp_path, output_path)
+        resize_cmd = build_resize_command(temp, output_path)
 
         # Combine with && and cleanup temp file
-        "#{crop_cmd} && #{resize_cmd} && rm -f #{temp_path.shellescape}"
+        "#{crop_cmd} && #{resize_cmd} && rm -f #{temp.shellescape}"
       end
 
       def build_resize_command(input_path, output_path)
-        resize_op = @operations.find { |op| op[:type] == :resize }
+        resize_op = find_op(: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]
@@ -137,58 +117,28 @@ module JekyllImgFlow
                            ["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", sharp_format(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
-
+        add_format_quality_alpha(command_parts)
         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] || {}
+        crop_op = find_op(:crop)
+        geo = crop_geometry(crop_op)
 
-        # 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)
+        if geo[:smartcrop]
           # 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
+          interestingness = smartcrop_interestingness(geo[:keep])
 
           # 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,
+           "smartcrop", geo[:width].to_s, geo[: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(" ")
+           "extract", geo[:y].to_s, geo[:x].to_s, geo[:width].to_s,
+           geo[:height].to_s].join(" ")
         end
       end
 
@@ -196,17 +146,7 @@ module JekyllImgFlow
         # 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", sharp_format(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
-
+        add_format_quality_alpha(command_parts)
         command_parts.join(" ")
       end
 
@@ -215,6 +155,23 @@ module JekyllImgFlow
       def sharp_format(format)
         format.to_s == "jpg" ? "jpeg" : format
       end
+
+      private
+
+      def add_format_quality(command_parts)
+        format_op = find_op(:format)
+        quality_op = find_op(:quality)
+        command_parts.push("-f", sharp_format(format_op[:format])) if format_op
+        command_parts.push("-q#{quality_op[:quality]}") if quality_op
+      end
+
+      def add_format_quality_alpha(command_parts)
+        add_format_quality(command_parts)
+        alpha_op = find_op(:alpha_opacity)
+        return unless alpha_op
+
+        command_parts.push("alpha", "{alpha:#{alpha_byte_value(alpha_op[:opacity])}}")
+      end
     end
   end
 end