jekyll-imgflow 0.3.3 → 0.4.0

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

@@ -2,144 +2,98 @@
 
 require "net/http"
 require "uri"
-require "tempfile"
 require_relative "base_provider"
 
 module JekyllImgFlow
   module Providers
     # Flyimg provider implementation using the standardized tag interface
-    class Flyimg < BaseProvider
+    class Flyimg < HttpBase
       TIMEOUT = 60
 
-      def available?
-        # Check if flyimg service is running
-        return false unless @config.respond_to?(:flyimg_url) && @config.flyimg_url
-
-        check_http_service(@config.flyimg_url)
+      def service_url
+        @config.respond_to?(:flyimg_url) ? @config.flyimg_url : nil
       end
 
-      def execute(input_path, output_path)
-        return if @operations.empty?
-
-        # Build single Flyimg URL with all operations combined
-        url = build_combined_flyimg_url(input_path)
-
-        # Fetch the result in one request
-        fetch_and_save(url, output_path)
-        output_path
-      ensure
-        reset_operations
+      def build_combined_flyimg_url(input_path)
+        build_combined_url(input_path)
       end
 
-      def build_combined_flyimg_url(input_path)
-        raise "flyimg_url not set" unless @config.flyimg_url
+      def build_combined_url(input_path)
+        raise "flyimg_url not set" unless service_url
 
         encoded_url = encode_file_url(input_path)
         options = []
 
-        # Add all operations to single options string
-        @operations.each do |operation|
-          case operation[:type]
-          when :resize
-            # Tags now provide complete calculated values.
-            # c_1 forces the image to fill the exact width x height area.
-            # pns_0 allows upscaling when the source is smaller than the target
-            # (Flyimg's pns/preserve-natural-size defaults to 1, blocking enlarge).
-            options << "w_#{operation[:width]}"
-            options << "pns_0"
-            if operation[:height]
-              options << "h_#{operation[:height]}"
-              options << "c_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 (Flyimg's smc option picks the best crop area)
-              crop_width = opts[:calculated_width]
-              crop_height = opts[:calculated_height]
-
-              options << "w_#{crop_width}"
-              options << "h_#{crop_height}"
-              options << "c_1"
-              options << "smc_1"
-            else
-              # Use basic cropping via extract (top-left / bottom-right 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
-              options << "e_1"
-              options << "p1x_#{crop_x}"
-              options << "p1y_#{crop_y}"
-              options << "p2x_#{crop_x + crop_width}"
-              options << "p2y_#{crop_y + crop_height}"
-            end
-
-          when :quality
-            flyimg_quality = translate_quality_to_flyimg(operation[:quality])
-            options << "q_#{flyimg_quality}"
-
-          when :format
-            # Assume validated input from tags
-            options << "o_#{operation[:format]}"
-
-          when :watermark
-            watermark_path = operation[:watermark_path]
-            position = operation[:options][:position]
-            opacity = operation[:options][:opacity]
-
-            # Flyimg watermark parameters
-            encoded_watermark = encode_file_url(watermark_path)
-            position_param = translate_flyimg_position(position)
-            opacity_param = (opacity * 100).round
-            options << "wm_#{encoded_watermark}_#{position_param}_#{opacity_param}"
-
-          when :alpha_opacity
-            opacity = operation[:opacity]
-            options << "a_#{(opacity * 255).round}"
-          end
-        end
+        @operations.each { |operation| append_flyimg_operation(operation, options) }
+
+        preserve_input_format(input_path, options)
+        "#{service_url}/upload/#{options.join(',')}/#{encoded_url}"
+      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
-          options << "o_#{map_format(input_ext)}" unless input_ext.empty?
+      private
+
+      def append_flyimg_operation(operation, options)
+        case operation[:type]
+        when :resize
+          append_flyimg_resize(operation, options)
+        when :crop
+          append_flyimg_crop(operation, options)
+        when :quality
+          options << "q_#{operation[:quality]}"
+        when :format
+          options << "o_#{operation[:format]}"
+        when :watermark
+          append_flyimg_watermark(operation, options)
+        when :alpha_opacity
+          options << "a_#{alpha_byte_value(operation[:opacity])}"
         end
+      end
+
+      def append_flyimg_resize(operation, options)
+        # c_1 forces the image to fill the exact width x height area.
+        # pns_0 allows upscaling when the source is smaller than the target
+        # (Flyimg's pns/preserve-natural-size defaults to 1, blocking enlarge).
+        options << "w_#{operation[:width]}"
+        options << "pns_0"
+        return unless operation[:height]
 
-        # Build combined URL: base/upload/options/options,.../encoded_url
-        options_string = options.join(",")
-        "#{@config.flyimg_url}/upload/#{options_string}/#{encoded_url}"
+        options << "h_#{operation[:height]}"
+        options << "c_1"
       end
 
-      private
+      def append_flyimg_crop(operation, options)
+        geo = crop_geometry(operation)
 
-      def translate_flyimg_position(position)
-        # Translate compass directions to Flyimg 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
+        if geo[:smartcrop]
+          options << "w_#{geo[:width]}"
+          options << "h_#{geo[:height]}"
+          options << "c_1"
+          options << "smc_1"
+        else
+          # Use basic cropping via extract (top-left / bottom-right coordinates)
+          options << "e_1"
+          options << "p1x_#{geo[:x]}"
+          options << "p1y_#{geo[:y]}"
+          options << "p2x_#{geo[:x] + geo[:width]}"
+          options << "p2y_#{geo[:y] + geo[:height]}"
         end
       end
 
+      def append_flyimg_watermark(operation, options)
+        parts = watermark_parts(operation)
+        encoded_watermark = encode_file_url(parts[:watermark_path])
+        position_param = compass_to_short(parts[:position])
+        opacity_param = (parts[:opacity] * 100).round
+        options << "wm_#{encoded_watermark}_#{position_param}_#{opacity_param}"
+      end
+
+      def preserve_input_format(input_path, options)
+        return if op?(:format)
+
+        ext = input_format_ext(input_path)
+        options << "o_#{map_format(ext)}" unless ext.empty?
+      end
+
       def map_format(format)
         case format&.downcase
         when "jpeg", "jpg"
@@ -155,33 +109,9 @@ module JekyllImgFlow
         end
       end
 
-      def fetch_and_save(url, output_path)
-        response = fetch_with_timeout(url)
-        raise "Flyimg 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 "Flyimg request failed: #{e.message}"
-      end
-
-      def translate_quality_to_flyimg(quality)
-        quality
+      # Thin wrapper kept for test compatibility.
+      def translate_flyimg_position(position)
+        compass_to_short(position)
       end
     end
   end

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

@@ -7,31 +7,22 @@ require_relative "base_provider"
 module JekyllImgFlow
   module Providers
     # ImageMagick provider implementation using the standardized tag interface
-    class Imagemagick < BaseProvider
+    class Imagemagick < CliBase
       # Cache rsvg delegate check across all instances (checked once per build)
       @rsvg_available = nil
       @svg_warning_shown = false
 
       def available?
-        # Check if magick or convert CLI is available
-        _, _, status1 = Open3.capture3("which", "magick")
-        _, _, status2 = Open3.capture3("which", "convert")
-        status1.success? || status2.success?
+        cli_available?("magick", "convert")
       end
 
-      def execute(input_path, output_path)
-        return if @operations.empty?
-
+      def before_execute(input_path)
         # Warn once per build about SVG performance with ImageMagick
         warn_svg_performance if svg?(input_path) && !self.class.instance_variable_get(:@svg_warning_shown)
+      end
 
-        # Build single ImageMagick command with all operations combined
-        command = build_combined_imagemagick_command(input_path, output_path)
-        execute_command(command)
-
-        output_path
-      ensure
-        reset_operations
+      def build_commands(input_path, output_path)
+        build_combined_imagemagick_command(input_path, output_path)
       end
 
       def build_combined_imagemagick_command(input_path, output_path)
@@ -47,85 +38,7 @@ module JekyllImgFlow
                           ["magick", input_path.shellescape]
                         end
 
-        # Add all operations
-        @operations.each do |operation|
-          case operation[:type]
-          when :resize
-            # Tags now provide complete calculated values
-            command_parts << "-resize" << if operation[:height]
-                                            "#{operation[:width]}x#{operation[:height]}!"
-                                          else
-                                            operation[:width].to_s
-                                          end
-
-          when :crop
-            opts = operation[:options]
-            params = operation[:params] || {}
-
-            # Check for keep parameter (ImageMagick doesn't support smartcrop, but we handle it gracefully)
-            keep = opts[:keep] || params[:keep] || params[:position]
-
-            if operation[:ratio] && keep && SMARTCROP_POSITIONS.include?(keep.to_s)
-              # ImageMagick doesn't support smartcrop, but we handle the keep parameter
-              # Use center gravity as a reasonable fallback for smartcrop requests
-              crop_width = opts[:calculated_width]
-              crop_height = opts[:calculated_height]
-              crop_x = opts[:calculated_x]
-              crop_y = opts[:calculated_y]
-
-              # Use gravity center for smartcrop-like behavior
-              crop_spec = "#{crop_width}x#{crop_height}+#{crop_x}+#{crop_y}"
-              command_parts << "-gravity" << "center"
-            else
-              # Use basic cropping
-              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
-              crop_spec = "#{crop_width}x#{crop_height}+#{crop_x}+#{crop_y}"
-            end
-            command_parts << "-crop" << crop_spec
-
-          when :quality
-            magick_quality = translate_quality_to_imagemagick(operation[:quality])
-            command_parts << "-quality" << magick_quality.to_s
-
-          when :format
-            # Assume validated input from tags
-            # Format is handled by output filename extension
-            # Quality is set separately if needed
-            unless @operations.any? { |op| op[:type] == :quality }
-              default_quality = @config&.quality || raise("No quality configured")
-              command_parts << "-quality" << default_quality.to_s
-            end
-
-          when :watermark
-            watermark_path = operation[:watermark_path]
-            position = operation[:options][:position]
-
-            # Translate compass directions to ImageMagick gravity format
-            gravity = translate_position(position)
-
-            # Add watermark as composite operation
-            command_parts << watermark_path.shellescape
-            command_parts << "-gravity" << gravity
-            command_parts << "-composite"
-
-          when :alpha_opacity
-            opacity = operation[:opacity]
-            alpha_value = (opacity * 100).round
-            command_parts << "-alpha" << "set"
-            command_parts << "-channel" << "A"
-            command_parts << "-evaluate" << "multiply" << "#{alpha_value}%"
-          end
-        end
+        @operations.each { |operation| append_imagemagick_operation(operation, command_parts) }
 
         # Add output filename
         command_parts << output_path.shellescape
@@ -146,9 +59,56 @@ module JekyllImgFlow
 
       private
 
-      def translate_quality_to_imagemagick(quality)
-        # ImageMagick uses 1-100 directly, no translation needed
-        quality
+      def append_imagemagick_operation(operation, command_parts)
+        case operation[:type]
+        when :resize
+          command_parts << "-resize" << if operation[:height]
+                                          "#{operation[:width]}x#{operation[:height]}!"
+                                        else
+                                          operation[:width].to_s
+                                        end
+        when :crop
+          append_imagemagick_crop(operation, command_parts)
+        when :quality
+          command_parts << "-quality" << operation[:quality].to_s
+        when :format
+          # Format is handled by output filename extension.
+          # Quality is set separately if needed.
+          unless op?(:quality)
+            default_quality = @config&.quality || raise("No quality configured")
+            command_parts << "-quality" << default_quality.to_s
+          end
+        when :watermark
+          append_imagemagick_watermark(operation, command_parts)
+        when :alpha_opacity
+          alpha_value = (operation[:opacity] * 100).round
+          command_parts << "-alpha" << "set"
+          command_parts << "-channel" << "A"
+          command_parts << "-evaluate" << "multiply" << "#{alpha_value}%"
+        end
+      end
+
+      def append_imagemagick_crop(operation, command_parts)
+        geo = crop_geometry(operation)
+
+        if geo[:smartcrop]
+          # ImageMagick doesn't support smartcrop, but we handle the keep parameter
+          # Use center gravity as a reasonable fallback for smartcrop requests
+          command_parts << "-gravity" << "center"
+        end
+
+        crop_spec = "#{geo[:width]}x#{geo[:height]}+#{geo[:x]}+#{geo[:y]}"
+        command_parts << "-crop" << crop_spec
+      end
+
+      def append_imagemagick_watermark(operation, command_parts)
+        parts = watermark_parts(operation)
+        gravity = translate_position(parts[:position])
+
+        # Add watermark as composite operation
+        command_parts << parts[:watermark_path].shellescape
+        command_parts << "-gravity" << gravity
+        command_parts << "-composite"
       end
 
       # Choose a rasterization density (DPI) for SVG input.

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