jekyll-imgflow 0.3.2 → 0.4.0

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

@@ -2,162 +2,89 @@
 
 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
+    class Imgproxy < HttpBase
       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)
+      def service_url
+        @config.respond_to?(:imgproxy_url) ? @config.imgproxy_url : nil
       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)
-        output_path
-      ensure
-        reset_operations
+      def build_combined_imgproxy_url(input_path)
+        build_combined_url(input_path)
       end
 
-      def build_combined_imgproxy_url(input_path)
-        raise "imgproxy_url not set" unless @config.imgproxy_url
+      def build_combined_url(input_path)
+        raise "imgproxy_url not set" unless service_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"
-            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}"
-            end
-            operations << "c:#{crop_width}:#{crop_height}"
-
-          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
+        @operations.each { |operation| append_imgproxy_operation(operation, operations) }
 
-        # 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
+        preserve_input_format(input_path, operations)
         operations_path = operations.join("/")
-        "#{@config.imgproxy_url}/insecure/#{operations_path}/plain/#{encoded_url}"
+        "#{service_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
+      def append_imgproxy_operation(operation, operations)
+        case operation[:type]
+        when :resize
+          operations << if operation[:height]
+                          "rs:fill:#{operation[:width]}:#{operation[:height]}:1"
+                        else
+                          "rs:fit:#{operation[:width]}::1"
+                        end
+        when :crop
+          append_imgproxy_crop(operation, operations)
+        when :quality
+          operations << "q:#{operation[:quality]}"
+        when :format
+          operations << "f:#{operation[:format]}"
+        when :watermark
+          append_imgproxy_watermark(operation, operations)
+        when :alpha_opacity
+          operations << "a:#{alpha_byte_value(operation[:opacity])}"
         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)
+      def append_imgproxy_crop(operation, operations)
+        geo = crop_geometry(operation)
+
+        operations << if geo[:smartcrop]
+                        # Use smartcrop with gravity:sm (libvips smart crop)
+                        "g:sm"
+                      else
+                        # imgproxy crop format: c:width:height:gravity
+                        # Use nowe (north-west) gravity with x/y offsets for pixel-precise cropping
+                        "g:nowe:#{geo[:x]}:#{geo[:y]}"
+                      end
+        operations << "c:#{geo[:width]}:#{geo[:height]}"
       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)
+      def append_imgproxy_watermark(operation, operations)
+        parts = watermark_parts(operation)
+        encoded_watermark = encode_file_url(parts[:watermark_path])
+        position_param = compass_to_short(parts[:position])
+        operations << "wm:#{encoded_watermark}:#{position_param}:10:10"
+      end
 
-          raise "HTTP #{response.code}: #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+      def preserve_input_format(input_path, operations)
+        return if op?(:format)
 
-          response.body
-        end
-      rescue StandardError => e
-        raise "Imgproxy request failed: #{e.message}"
+        ext = input_format_ext(input_path)
+        operations << "f:#{ext}" unless ext.empty?
       end
 
-      def translate_quality_to_imgproxy(quality)
-        quality
+      # Thin wrapper kept for test compatibility.
+      def translate_imgproxy_position(position)
+        compass_to_short(position)
       end
     end
   end

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

@@ -7,48 +7,49 @@ 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.
       # Each sub-array is passed directly to Open3.capture3 (no shell).
       # Returns Array[Array[String]].
       def build_vips_commands(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
-          svg?(input_path) ? build_svg_crop_pipeline(input_path, output_path) : [build_crop_command(input_path, output_path)]
-        else
-          [build_copy_command(input_path, output_path)]
-        end
+        flags = operation_flags
+        operation_builder = select_operation_builder(flags)
+        operation_builder.call(input_path, output_path)
+      end
+
+      def select_operation_builder(flags)
+        return ->(input, output) { build_watermark_pipeline(input, output, flags[:crop], flags[:resize]) } if flags[:watermark]
+        return ->(input, output) { build_alpha_pipeline(input, output, flags[:crop], flags[:resize]) } if flags[:alpha]
+        return ->(input, output) { build_sequential_crop_resize(input, output) } if flags[:crop] && flags[:resize]
+        return ->(input, output) { [build_resize_command(input, output)] } if flags[:resize]
+        return ->(input, output) { crop_commands(input, output) } if flags[:crop]
+
+        ->(input, output) { [build_copy_command(input, output)] }
+      end
+
+      def operation_flags
+        {
+          crop: op?(:crop),
+          resize: op?(:resize),
+          watermark: op?(:watermark),
+          alpha: op?(:alpha_opacity)
+        }
+      end
+
+      def crop_commands(input_path, output_path)
+        svg?(input_path) ? build_svg_crop_pipeline(input_path, output_path) : [build_crop_command(input_path, output_path)]
       end
 
       # Convenience wrapper for backward compatibility with tests.
@@ -64,85 +65,62 @@ module JekyllImgFlow
       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.concat(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
-
+        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 = []
-
-        # Step 1: Process crop/resize/copy to produce base image
-        if has_crop && has_resize
-          commands.concat(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
+        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, base_path)
+        commands
+      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
+      def build_base_pipeline(input_path, temp_path, has_crop, has_resize)
+        return [build_sequential_crop_resize(input_path, temp_path), temp_path] if has_crop && has_resize
+        return [[build_resize_command(input_path, temp_path)], temp_path] if has_resize
+        return [[build_crop_command(input_path, temp_path)], temp_path] if has_crop
 
-        # Step 3: Composite watermark over base
-        commands.concat(build_composite_commands(base_path, output_path))
+        [[], input_path]
+      end
 
-        # Step 4: Cleanup temp files
-        temp_files = [temp_path, base_path == input_path ? nil : base_path].compact
-        temp_files.each { |f| commands << [:cleanup, f] }
+      def apply_watermark_alpha(base_path, input_path, commands)
+        alpha_op = find_op(:alpha_opacity)
+        return [base_path, commands] unless alpha_op
 
-        commands
+        alpha_temp = temp_path(input_path, "tmp_alpha.jpg")
+        [alpha_temp, commands << build_alpha_command(base_path, alpha_temp)]
+      end
+
+      def cleanup_paths(commands, input_path, temp_path, base_path)
+        temp_files = [temp_path, base_path == input_path ? nil : base_path].compact
+        temp_files.each { |file| commands << [:cleanup, file] }
       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
@@ -169,6 +147,9 @@ module JekyllImgFlow
       # Get an image dimension (width or height) using vips header.
       # Returns integer or 0 if vips is unavailable.
       def vips_image_dimension(image_path, field)
+        return 0 unless %w[width height].include?(field)
+
+        # nosemgrep: ruby.lang.security.dangerous-exec.dangerous-exec -- Open3 receives an argument array and field is allowlisted.
         stdout, _, status = Open3.capture3("vips", "header", image_path, field)
         return 0 unless status.success?
 
@@ -178,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,
@@ -190,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]
@@ -226,31 +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]
-
-        if crop_op[:ratio] && keep && %w[attention entropy center
-                                         centre].include?(keep.to_s)
-          crop_width = opts[:calculated_width]
-          crop_height = opts[:calculated_height]
-          interestingness = case keep.to_s
-                            when "entropy" then "entropy"
-                            when "center", "centre" then "centre"
-                            else "attention"
-                            end
-          ["vips", "smartcrop", input_path, output_path,
-           crop_width.to_s, crop_height.to_s,
-           "--interesting=#{interestingness}"]
-        else
-          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_path, output_path,
-           crop_x.to_s, crop_y.to_s, crop_width.to_s, crop_height.to_s]
-        end
+        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(geo, input_path, output_path)
+      end
+
+      def build_smartcrop_command(geo, input_path, output_path)
+        interestingness = smartcrop_interestingness(geo[:keep])
+        ["vips", "smartcrop", input_path, output_path,
+         geo[:width].to_s, geo[:height].to_s,
+         "--interesting=#{interestingness}"]
+      end
+
+      def build_extract_command(geo, input_path, output_path)
+        ["vips", "extract_area", input_path, output_path,
+         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.
@@ -260,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}",
@@ -293,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
@@ -323,6 +289,7 @@ module JekyllImgFlow
         Jekyll.logger.debug "LibVips command: #{command.join(' ')}"
 
         # Execute command array directly (no shell)
+        # nosemgrep: ruby.lang.security.dangerous-exec.dangerous-exec -- command is an argument array; no shell is invoked.
         stdout, stderr, status = Open3.capture3(*command)
         output = "#{stdout}#{stderr}"
         success = status.success?