jekyll-imgflow 0.3.3 → 0.4.1

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

@@ -2,6 +2,7 @@
 
 require "open3"
 require "pathname"
+require "fileutils"
 
 module JekyllImgFlow
   module Providers
@@ -10,6 +11,15 @@ module JekyllImgFlow
       # Valid smartcrop position values
       SMARTCROP_POSITIONS = %w[attention entropy center centre].freeze
 
+      # Short compass → provider position mapping used by HTTP providers.
+      COMPASS_TO_SHORT = {
+        "northwest" => "tl",
+        "northeast" => "tr",
+        "southwest" => "bl",
+        "southeast" => "br",
+        "center" => "c"
+      }.freeze
+
       attr_accessor :config
 
       def initialize(config = {})
@@ -17,6 +27,91 @@ module JekyllImgFlow
         @operations = []
       end
 
+      # Operation lookup helpers — used by all providers to avoid
+      # repeating `@operations.find { |op| op[:type] == :xxx }`.
+      def find_op(type)
+        @operations.find { |op| op[:type] == type }
+      end
+
+      def op?(type)
+        @operations.any? { |op| op[:type] == type }
+      end
+
+      # Normalize a crop operation into a geometry hash.
+      # Returns { smartcrop:, keep:, x:, y:, width:, height: } where
+      # smartcrop is true when ratio + keep + valid smartcrop position.
+      def crop_geometry(operation)
+        opts = operation[:options] || {}
+        params = operation[:params] || {}
+        keep = opts[:keep] || params[:keep] || params[:position]
+        smartcrop = operation[:ratio] && keep && SMARTCROP_POSITIONS.include?(keep.to_s)
+        crop_coords(operation, opts).merge(smartcrop: smartcrop, keep: keep)
+      end
+
+      # Coordinates for a crop operation: ratio crops use calculated values,
+      # explicit crops use x/y/width/height options (defaulting x/y to 0).
+      def crop_coords(operation, opts)
+        if operation[:ratio]
+          { x: opts[:calculated_x], y: opts[:calculated_y],
+            width: opts[:calculated_width], height: opts[:calculated_height] }
+        else
+          { x: opts[:x] || 0, y: opts[:y] || 0,
+            width: opts[:width], height: opts[:height] }
+        end
+      end
+
+      # Extract watermark operation parts into a hash.
+      def watermark_parts(operation)
+        {
+          watermark_path: operation[:watermark_path],
+          position: operation[:options][:position],
+          opacity: operation[:options][:opacity]
+        }
+      end
+
+      # Shared compass → short position mapping (tl/tr/bl/br/c).
+      # HTTP providers (imgproxy, weserv, flyimg) all use this mapping.
+      def compass_to_short(position)
+        COMPASS_TO_SHORT[position.to_s] || position.to_s
+      end
+
+      # Input format extension (lowercased, no dot) for format preservation.
+      def input_format_ext(input_path)
+        File.extname(input_path).delete(".").downcase
+      end
+
+      # Convert a 0..1 opacity float to a 0..255 integer (used by all
+      # providers that encode alpha as an 8-bit value).
+      def alpha_byte_value(opacity)
+        (opacity * 255).round
+      end
+
+      # Generate a temporary file path by replacing the extension of
+      # +input_path+ with +suffix+ (e.g. temp_path("a.jpg", "tmp_base.jpg")
+      # → "a.tmp_base.jpg").
+      def temp_path(input_path, suffix)
+        input_path.gsub(/\.[^.]+$/, ".#{suffix}")
+      end
+
+      # Map a smartcrop +keep+ value to the libvips interestingness string
+      # used by Sharp and LibVips smartcrop/thumbnail --crop operations.
+      def smartcrop_interestingness(keep)
+        case keep.to_s
+        when "entropy" then "entropy"
+        when "center", "centre" then "centre"
+        else "attention"
+        end
+      end
+
+      # Check whether any of the given CLI commands is available on PATH.
+      # Used by CLI providers (sharp, libvips, imagemagick).
+      def cli_available?(*commands)
+        commands.any? do |cmd|
+          _, _, status = Open3.capture3("which", cmd)
+          status.success?
+        end
+      end
+
       # Check if this provider is available (must be implemented by subclasses)
       def available?
         # Default: not available unless subclass implements actual check
@@ -55,17 +150,7 @@ module JekyllImgFlow
 
         # For HTTP providers, construct proper HTTP URL
         site = @config.site
-
-        # Get the relative path from site source using Pathname
-        source_path = Pathname.new(site.source)
-        file_pathname = Pathname.new(file_path)
-        relative_path = if file_pathname.absolute? && file_path.to_s.start_with?(site.source)
-                          file_pathname.relative_path_from(source_path).to_s
-                        elsif file_path.start_with?("/")
-                          file_path[1..]
-                        else
-                          file_path
-                        end
+        relative_path = relative_file_path(file_path, site)
 
         # URL-encode each path segment to handle spaces and special characters
         encoded_path = relative_path.split("/").map do |segment|
@@ -81,6 +166,18 @@ module JekyllImgFlow
         "#{base_url}#{baseurl}/#{encoded_path}"
       end
 
+      # Get the relative path from site source using Pathname
+      def relative_file_path(file_path, site)
+        file_pathname = Pathname.new(file_path)
+        if file_pathname.absolute? && file_path.to_s.start_with?(site.source)
+          file_pathname.relative_path_from(Pathname.new(site.source)).to_s
+        elsif file_path.start_with?("/")
+          file_path[1..]
+        else
+          file_path
+        end
+      end
+
       # Operation collection methods - these should NOT execute immediately
       def resize(width, height, options = {})
         @operations << { type: :resize, width: width, height: height,
@@ -206,5 +303,113 @@ module JekyllImgFlow
         end
       end
     end
+
+    # Shared base for HTTP-based providers (imgproxy, weserv, flyimg).
+    # Subclasses must implement `service_url`, `build_combined_url`, and
+    # define a `TIMEOUT` constant. They may optionally override
+    # `provider_label` for error messages.
+    class HttpBase < BaseProvider
+      def available?
+        url = service_url
+        return false unless url
+
+        check_http_service(url)
+      end
+
+      def execute(input_path, output_path)
+        return if @operations.empty?
+
+        url = build_combined_url(input_path)
+        fetch_and_save(url, output_path)
+        output_path
+      ensure
+        reset_operations
+      end
+
+      protected
+
+      # Subclasses override to return the configured service URL or nil.
+      def service_url
+        raise NotImplementedError
+      end
+
+      # Subclasses override to build the full request URL.
+      def build_combined_url(_input_path)
+        raise NotImplementedError
+      end
+
+      # Label used in error messages (defaults to class name).
+      def provider_label
+        self.class.name.split("::").last
+      end
+
+      def timeout
+        self.class::TIMEOUT
+      end
+
+      def fetch_and_save(url, output_path)
+        response = fetch_with_timeout(url)
+        raise "#{provider_label} 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 "#{provider_label} request failed: #{e.message}"
+      end
+    end
+
+    # Shared base for CLI-based providers (sharp, imagemagick, libvips).
+    # Subclasses implement `build_commands(input_path, output_path)` to
+    # return an array of command entries (strings or arrays), and
+    # `run_command(cmd)` to execute a single entry.
+    class CliBase < BaseProvider
+      def execute(input_path, output_path)
+        return if @operations.empty?
+
+        before_execute(input_path)
+        commands = build_commands(input_path, output_path)
+        Array(commands).each { |cmd| run_command(cmd) }
+        output_path
+      ensure
+        reset_operations
+      end
+
+      protected
+
+      # Hook for subclasses to perform pre-execution work (e.g. SVG warnings).
+      def before_execute(_input_path); end
+
+      # Subclasses override to return command(s) to execute.
+      # May return a single command or an array of commands.
+      def build_commands(_input_path, _output_path)
+        raise NotImplementedError
+      end
+
+      # Execute a single command. Default uses the shell-based
+      # `execute_command` from BaseProvider. Subclasses that use
+      # argument arrays (no shell) should override this.
+      def run_command(cmd)
+        if cmd.is_a?(Array) && cmd.first == :cleanup
+          FileUtils.rm_f(cmd[1])
+          return
+        end
+        execute_command(cmd)
+      end
+    end
   end
 end

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