jekyll-imgflow 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d59e73749066617a2c71322c3c80c5161ea847872a7864cf65c9133a8a315e24
-  data.tar.gz: 861a4df0428da9bdd3221b89838ebb4d85d598172465569b5cdc28e14f243ede
+  metadata.gz: 8400a4bc3d213b557802452b3af0816098443aa5542f27e81bf690dd2ee3f7a8
+  data.tar.gz: 1f8562de9d69d7451603623ab2e63741f4889a4d04d35d9ae01a561878e8d539
 SHA512:
-  metadata.gz: aae0d3bb14c346d432881a29844b1221225599dd77767d087faccc14023f0d527fcc36c4eeb0e5a1df4fa9a87f86276ea42388e2364f7158f12af8ba0512d459
-  data.tar.gz: ba868a71465128a9f6f7259ad2852b7b16093b30496fd9a2e9d9f259e811908b2541b3f14a002475201a26576236921f76dbd52782797facb2d4a27e496c81de
+  metadata.gz: cbd0f3c0d194bd7acfdc199c9c1eb78dcb69d09c4cc9f213ceb48d1c1c5cb4402518a87a14f44f234df1487ae6eba4495f92aae2b31bb602b199bcaaab4438ef
+  data.tar.gz: 7c07124101bf734ebedce868d1329900c79acde6d90463d5fbd680fe49f02517e743ba4d7d37ebf3e26454e3e9dd4df80ada8265874bb96b1659767a33a8306f

data/README.md

@@ -98,6 +98,28 @@ ImgFlow has two processing flows: **Build-Time** (pre-generation) and **Runtime*
 
 **See:** [providers.md](docs/providers.md) for detailed provider comparison and setup
 
+### SVG File Handling
+
+SVG files are supported as input by all providers. Since SVGs are vector
+graphics, they are rasterized before format conversion (WebP, AVIF, JPG, PNG).
+
+- **Weserv** (via librsvg): When an SVG has no explicit pixel dimensions
+  (e.g. `width="100%"` with a large `viewBox`), ImgFlow automatically
+  caps the rasterization at 2000px wide to prevent memory exhaustion.
+  If a resize or crop operation is present, the target dimensions are used
+  directly.
+- **Sharp, LibVips, Imgproxy, Flyimg**: Handle SVGs via their respective
+  rasterization backends. SVGs with very large viewBox dimensions may be
+  slow or fail depending on the provider's memory limits.
+- **ImageMagick**: SVG processing is slower than other providers without
+  the `librsvg` delegate installed. Set `FULL_SVG_TEST=true` to include
+  SVGs in ImageMagick test runs.
+
+SVGs with explicit `width` and `height` attributes (in pixels, not
+percentages) are always processed at the specified size first, then resized
+to the target dimensions — this is the recommended way to author SVGs for
+image processing.
+
 ## 🚀 Quick Commands
 
 ```bash

data/lib/jekyll-imgflow/parser.rb

@@ -110,44 +110,51 @@ module JekyllImgFlow
       operations = []
       operation_options = options.slice(*OPERATION_PARAMS)
 
-      # Handle crop+resize combination (needs sequential processing)
-      has_crop = operation_options[:ratio] || operation_options[:aspect_ratio]
-      has_resize = operation_options[:width] || operation_options[:height]
+      add_crop_resize_operations(operations, operation_options)
+      add_simple_operations(operations, operation_options)
+      add_format_operation(operations, operation_options)
+      add_optimize_operation(operations, operation_options)
+
+      operations
+    end
+
+    def self.add_crop_resize_operations(operations, opts)
+      has_crop = opts[:ratio] || opts[:aspect_ratio]
+      has_resize = opts[:width] || opts[:height]
+      crop_params = opts.slice(:ratio, :aspect_ratio, :keep, :position)
 
       if has_crop && has_resize
-        crop_params = operation_options.slice(:ratio, :aspect_ratio, :keep, :position)
-        resize_params = operation_options.except(:ratio, :aspect_ratio, :keep, :position)
         operations << { type: :crop, params: crop_params }
-        operations << { type: :resize, params: resize_params }
+        operations << { type: :resize, params: opts.except(:ratio, :aspect_ratio, :keep, :position) }
       elsif has_crop
-        crop_params = operation_options.slice(:ratio, :aspect_ratio, :keep, :position)
         operations << { type: :crop, params: crop_params }
       elsif has_resize
-        operations << { type: :resize, params: operation_options }
+        operations << { type: :resize, params: opts }
       end
+    end
 
-      # Add simple operations using mappings
+    def self.add_simple_operations(operations, opts)
       SIMPLE_OPERATIONS.each do |key, builder|
-        operations << builder.call(operation_options[key]) if operation_options[key]
+        operations << builder.call(opts[key]) if opts[key]
       end
+    end
 
-      # Handle format operation (can be array or single value)
-      if operation_options[:format] || operation_options[:formats]
-        format_value = operation_options[:format] || operation_options[:formats]
-        operations << if format_value.is_a?(Array)
-                        { type: :format, params: { formats: format_value } }
-                      else
-                        { type: :format, params: { format: format_value } }
-                      end
-      end
+    def self.add_format_operation(operations, opts)
+      return unless opts[:format] || opts[:formats]
 
-      # Handle optimize operation
-      if operation_options[:optimize] || operation_options[:level]
-        operations << { type: :optimize,
-                        params: { level: operation_options[:level] || :medium } }
-      end
+      format_value = opts[:format] || opts[:formats]
+      operations << if format_value.is_a?(Array)
+                      { type: :format, params: { formats: format_value } }
+                    else
+                      { type: :format, params: { format: format_value } }
+                    end
+    end
 
-      operations
+    def self.add_optimize_operation(operations, opts)
+      return unless opts[:optimize] || opts[:level]
+
+      operations << { type: :optimize,
+                      params: { level: opts[:level] || :medium } }
     end
 
     def self.extract_html_attributes(options)

data/lib/jekyll-imgflow/picture_tag_preset_migrator.rb

@@ -99,61 +99,11 @@ module JekyllImgFlow
     # @return [Hash, nil] ImgFlow preset data or nil if not convertible
     def convert_preset_to_imgflow(preset_name, preset_data)
       operations = []
-
-      # Handle multi-width presets - use the largest width as primary
-      if preset_data["widths"]
-        max_width = Array(preset_data["widths"]).max
-        operations << { "resize" => { "width" => max_width } }
-      elsif preset_data["base_width"]
-        # For pixel-ratio presets, use base_width
-        operations << { "resize" => { "width" => preset_data["base_width"] } }
-      elsif preset_data["width"]
-        # Direct width setting
-        operations << { "resize" => { "width" => preset_data["width"] } }
-      end
-
-      # Handle height (less common in Picture Tag)
-      if preset_data["height"]
-        if operations.any? && operations.last["resize"]
-          # Add height to existing resize operation
-          operations.last["resize"]["height"] = preset_data["height"]
-        else
-          operations << { "resize" => { "height" => preset_data["height"] } }
-        end
-      end
-
-      # Convert quality (if specified)
-      operations << { "quality" => { "quality" => preset_data["quality"] } } if preset_data["quality"]
-
-      # Convert formats - Picture Tag uses 'original', ImgFlow uses actual format
-      if preset_data["formats"]
-        formats = Array(preset_data["formats"]).map do |format|
-          case format
-          when "original"
-            "jpg" # Default to jpg for 'original'
-          else
-            format
-          end
-        end
-        operations << { "format" => { "formats" => formats } }
-      end
-
-      # Convert crop (aspect ratio) - handle both ratio and aspect_ratio with precedence
-      ratio_value = preset_data["ratio"] || preset_data["aspect_ratio"] || preset_data["crop"]
-      operations << { "crop" => { "ratio" => ratio_value } } if ratio_value
-
-      # Convert gravity/position - handle both position and gravity with precedence
-      position_value = preset_data["position"] || preset_data["gravity"]
-      if position_value
-        if operations.any? { |op| op["crop"] }
-          # Add to existing crop operation
-          crop_op = operations.find { |op| op["crop"] }
-          crop_op["crop"]["position"] = position_value
-        else
-          # Create new crop operation
-          operations << { "crop" => { "position" => position_value } }
-        end
-      end
+      add_resize_operation(operations, preset_data)
+      add_quality_operation(operations, preset_data)
+      add_format_operation(operations, preset_data)
+      add_crop_operation(operations, preset_data)
+      add_position_operation(operations, preset_data)
 
       return if operations.empty?
 
@@ -171,30 +121,84 @@ module JekyllImgFlow
       }
     end
 
+    def add_resize_operation(operations, preset_data)
+      width = preset_width(preset_data)
+      operations << { "resize" => { "width" => width } } if width
+
+      return unless preset_data["height"]
+
+      if operations.any? && operations.last["resize"]
+        operations.last["resize"]["height"] = preset_data["height"]
+      else
+        operations << { "resize" => { "height" => preset_data["height"] } }
+      end
+    end
+
+    def preset_width(preset_data)
+      return Array(preset_data["widths"]).max if preset_data["widths"]
+      return preset_data["base_width"] if preset_data["base_width"]
+
+      preset_data["width"] if preset_data["width"]
+    end
+
+    def add_quality_operation(operations, preset_data)
+      return unless preset_data["quality"]
+
+      operations << { "quality" => { "quality" => preset_data["quality"] } }
+    end
+
+    def add_format_operation(operations, preset_data)
+      return unless preset_data["formats"]
+
+      formats = Array(preset_data["formats"]).map do |format|
+        format == "original" ? "jpg" : format
+      end
+      operations << { "format" => { "formats" => formats } }
+    end
+
+    def add_crop_operation(operations, preset_data)
+      ratio_value = preset_data["ratio"] || preset_data["aspect_ratio"] || preset_data["crop"]
+      operations << { "crop" => { "ratio" => ratio_value } } if ratio_value
+    end
+
+    def add_position_operation(operations, preset_data)
+      position_value = preset_data["position"] || preset_data["gravity"]
+      return unless position_value
+
+      crop_op = operations.find { |op| op["crop"] }
+      if crop_op
+        crop_op["crop"]["position"] = position_value
+      else
+        operations << { "crop" => { "position" => position_value } }
+      end
+    end
+
     # Generate description for ImgFlow preset
     # @param preset_name [String] Preset name
     # @param preset_data [Hash] Original preset data
     # @return [String] Description
     def generate_description(preset_name, preset_data)
-      operations = []
+      parts = []
+      add_width_description(parts, preset_data)
+      parts << "height: #{preset_data['height']}" if preset_data["height"]
+      parts << "quality: #{preset_data['quality']}" if preset_data["quality"]
+      parts << "formats: #{Array(preset_data['formats']).join(',')}" if preset_data["formats"]
+      parts << "crop: #{preset_data['crop']}" if preset_data["crop"]
+      parts << "gravity: #{preset_data['gravity']}" if preset_data["gravity"]
+
+      "Migrated from Picture Tag preset '#{preset_name}'. #{parts.join(', ')}"
+    end
 
+    def add_width_description(parts, preset_data)
       if preset_data["widths"]
-        operations << "widths: #{Array(preset_data['widths']).join(',')}"
-        operations << "using max width: #{Array(preset_data['widths']).max}"
+        parts << "widths: #{Array(preset_data['widths']).join(',')}"
+        parts << "using max width: #{Array(preset_data['widths']).max}"
       elsif preset_data["base_width"]
-        operations << "base_width: #{preset_data['base_width']}"
-        operations << "pixel_ratios: #{Array(preset_data['pixel_ratios']).join(',')}"
+        parts << "base_width: #{preset_data['base_width']}"
+        parts << "pixel_ratios: #{Array(preset_data['pixel_ratios']).join(',')}"
       elsif preset_data["width"]
-        operations << "width: #{preset_data['width']}"
+        parts << "width: #{preset_data['width']}"
       end
-
-      operations << "height: #{preset_data['height']}" if preset_data["height"]
-      operations << "quality: #{preset_data['quality']}" if preset_data["quality"]
-      operations << "formats: #{Array(preset_data['formats']).join(',')}" if preset_data["formats"]
-      operations << "crop: #{preset_data['crop']}" if preset_data["crop"]
-      operations << "gravity: #{preset_data['gravity']}" if preset_data["gravity"]
-
-      "Migrated from Picture Tag preset '#{preset_name}'. #{operations.join(', ')}"
     end
 
     # Save ImgFlow preset to YAML file

data/lib/jekyll-imgflow/preset_manager.rb

@@ -132,55 +132,59 @@ module JekyllImgFlow
     # @return [Hash] Tags in key => value format
     def yaml_to_tags(preset)
       tags = {}
-      preset_operations = preset["operations"] || []
-
-      preset_operations.each do |op|
+      (preset["operations"] || []).each do |op|
         next unless op.is_a?(Hash)
 
         op.each do |op_type, params|
           next unless params.is_a?(Hash)
 
-          # Store operation type for operations that don't have specific params
-          # This allows Parser to detect the operation type
-          case op_type.to_s
-          when "resize"
-            # Resize params: width, height (both optional, at least one required)
-            tags[:width] = params["width"] if params["width"]
-            tags[:height] = params["height"] if params["height"]
-          when "crop"
-            # Crop params: ratio or width/height
-            tags[:ratio] = params["ratio"] if params["ratio"]
-            tags[:aspect_ratio] = params["aspect_ratio"] if params["aspect_ratio"]
-            tags[:width] = params["width"] if params["width"] && !tags[:width]
-            tags[:height] = params["height"] if params["height"] && !tags[:height]
-          when "format"
-            # Format params: format or formats
-            if params["formats"]
-              tag_value = params["formats"].is_a?(Array) ? params["formats"].join(",") : params["formats"]
-              tags[:formats] = tag_value
-            elsif params["format"]
-              tags[:format] = params["format"]
-            end
-          when "quality"
-            tags[:quality] = params["quality"] if params["quality"]
-          when "optimize"
-            tags[:optimize] = true
-            tags[:level] = params["level"] if params["level"]
-          when "opacity"
-            tags[:opacity] = params["opacity"] if params["opacity"]
-          else
-            # Generic handling for unknown operations
-            params.each do |key, value|
-              tag_value = value.is_a?(Array) ? value.join(",") : value
-              tags[key.to_sym] = tag_value
-            end
-          end
+          merge_operation_tags(tags, op_type.to_s, params)
         end
       end
 
       tags
     end
 
+    def merge_operation_tags(tags, op_type, params)
+      case op_type
+      when "resize"
+        tags[:width] = params["width"] if params["width"]
+        tags[:height] = params["height"] if params["height"]
+      when "crop"
+        tags[:ratio] = params["ratio"] if params["ratio"]
+        tags[:aspect_ratio] = params["aspect_ratio"] if params["aspect_ratio"]
+        tags[:width] = params["width"] if params["width"] && !tags[:width]
+        tags[:height] = params["height"] if params["height"] && !tags[:height]
+      when "format"
+        merge_format_tag(tags, params)
+      when "quality"
+        tags[:quality] = params["quality"] if params["quality"]
+      when "optimize"
+        tags[:optimize] = true
+        tags[:level] = params["level"] if params["level"]
+      when "opacity"
+        tags[:opacity] = params["opacity"] if params["opacity"]
+      else
+        merge_generic_tags(tags, params)
+      end
+    end
+
+    def merge_format_tag(tags, params)
+      if params["formats"]
+        tag_value = params["formats"].is_a?(Array) ? params["formats"].join(",") : params["formats"]
+        tags[:formats] = tag_value
+      elsif params["format"]
+        tags[:format] = params["format"]
+      end
+    end
+
+    def merge_generic_tags(tags, params)
+      params.each do |key, value|
+        tag_value = value.is_a?(Array) ? value.join(",") : value
+        tags[key.to_sym] = tag_value
+      end
+    end
+
     # Merge preset tags with user options (user options override)
     # @param preset_tags [Hash] Tags from preset
     # @param user_options [Hash] User-provided options

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,86 @@ 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)
+        coords = 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
+        coords.merge(smartcrop: smartcrop, keep: keep)
+      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
@@ -206,5 +296,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