jekyll-imgflow 0.3.3 → 0.4.0

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

@@ -2,159 +2,104 @@
 
 require "net/http"
 require "uri"
-require "tempfile"
 require_relative "base_provider"
 
 module JekyllImgFlow
   module Providers
     # Weserv provider implementation using the standardized tag interface
-    class Weserv < BaseProvider
+    class Weserv < HttpBase
       TIMEOUT = 30
-
-      def available?
-        # Check if weserv service is running
-        return false unless @config.respond_to?(:weserv_url) && @config.weserv_url
-
-        check_http_service(@config.weserv_url)
+      # SVGs without explicit pixel dimensions (e.g. width="100%") are valid
+      # but cause librsvg to rasterize at the viewBox size, which can be huge.
+      # When no resize operation is present, cap the rasterization at 2000px
+      # on the longest edge so weserv processes the SVG at a reasonable size.
+      SVG_DEFAULT_MAX_SIZE = 2000
+
+      def service_url
+        @config.respond_to?(:weserv_url) ? @config.weserv_url : nil
       end
 
-      def execute(input_path, output_path)
-        return if @operations.empty?
-
-        # Build single Weserv URL with all operations combined
-        url = build_combined_weserv_url(input_path)
-
-        # Fetch the result in one request
-        fetch_and_save(url, output_path)
-        output_path
-      ensure
-        reset_operations
+      def build_combined_weserv_url(input_path)
+        build_combined_url(input_path)
       end
 
-      def build_combined_weserv_url(input_path)
-        raise "weserv_url not set" unless @config.weserv_url
+      def build_combined_url(input_path)
+        raise "weserv_url not set" unless service_url
 
         encoded_url = encode_file_url(input_path)
         params = ["url=#{URI.encode_www_form_component(encoded_url)}"]
 
-        # Add all operations to single URL
-        @operations.each do |operation|
-          case operation[:type]
-          when :resize
-            # Tags now provide complete calculated values
-            params << if operation[:height]
-                        "w=#{operation[:width]}&h=#{operation[:height]}&fit=fill"
-                      else
-                        "w=#{operation[:width]}"
-                      end
-
-          when :crop
-            opts = operation[:options]
-            op_params = operation[:params] || {}
-
-            # Check for keep parameter (smartcrop support)
-            keep = opts[:keep] || op_params[:keep] || op_params[:position]
-
-            if operation[:ratio] && keep && SMARTCROP_POSITIONS.include?(keep.to_s)
-              # Use smartcrop (WeServ supports smartcrop)
-              crop_width = opts[:calculated_width]
-              crop_height = opts[:calculated_height]
-
-              # Add smartcrop parameters according to WeServ docs
-              params << "crop=#{crop_width}x#{crop_height}"
-              params << "a=smart" # smart attention
-
-              # Map keep parameter to WeServ attention type
-              case keep.to_s
-              when "attention" then params << "a=attention"
-              when "entropy" then params << "a=entropy"
-              when "center", "centre" then params << "a=center"
-              end
-            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
-              params << "cx=#{crop_x}&cy=#{crop_y}&cw=#{crop_width}&ch=#{crop_height}"
-            end
-
-          when :quality
-            weserv_quality = translate_quality_to_weserv(operation[:quality])
-            params << "q=#{weserv_quality}"
-
-          when :format
-            # Assume validated input from tags
-            params << "output=#{operation[:format]}"
-
-          when :watermark
-            watermark_path = operation[:watermark_path]
-            position = operation[:options][:position]
-            opacity = operation[:options][:opacity]
-
-            # Weserv watermark parameters
-            params << "wm=#{encode_file_url(watermark_path)}"
-            params << "wmpos=#{translate_weserv_position(position)}"
-            params << "wmo=#{opacity}" if opacity
-
-          when :alpha_opacity
-            opacity = operation[:opacity]
-            params << "alpha=#{(opacity * 255).round}"
-          end
-        end
+        @operations.each { |operation| append_weserv_operation(operation, params) }
 
-        query_string = params.join("&")
-        "#{@config.weserv_url}/?#{query_string}"
+        ensure_svg_size_limit(input_path, params)
+
+        "#{service_url}/?#{params.join('&')}"
       end
 
       private
 
-      def translate_weserv_position(position)
-        # Translate compass directions to Weserv 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
-        end
+      def ensure_svg_size_limit(input_path, params)
+        return unless svg_file?(input_path)
+        return if params.any? { |p| p.start_with?("w=", "h=", "crop=") || p.include?("cw=") }
+
+        params << "w=#{SVG_DEFAULT_MAX_SIZE}"
       end
 
-      def fetch_and_save(url, output_path)
-        response = fetch_with_timeout(url)
-        raise "Weserv request failed" if response.empty?
+      def svg_file?(input_path)
+        File.extname(input_path).downcase == ".svg"
+      end
 
-        FileUtils.mkdir_p(File.dirname(output_path))
-        File.write(output_path, response)
+      def append_weserv_operation(operation, params)
+        case operation[:type]
+        when :resize
+          params << if operation[:height]
+                      "w=#{operation[:width]}&h=#{operation[:height]}&fit=fill"
+                    else
+                      "w=#{operation[:width]}"
+                    end
+        when :crop
+          append_weserv_crop(operation, params)
+        when :quality
+          params << "q=#{operation[:quality]}"
+        when :format
+          params << "output=#{operation[:format]}"
+        when :watermark
+          append_weserv_watermark(operation, params)
+        when :alpha_opacity
+          params << "alpha=#{alpha_byte_value(operation[:opacity])}"
+        end
       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_weserv_crop(operation, params)
+        geo = crop_geometry(operation)
 
-          raise "HTTP #{response.code}: #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+        if geo[:smartcrop]
+          params << "crop=#{geo[:width]}x#{geo[:height]}"
+          params << "a=smart"
+          params << weserv_attention(geo[:keep])
+        else
+          params << "cx=#{geo[:x]}&cy=#{geo[:y]}&cw=#{geo[:width]}&ch=#{geo[:height]}"
+        end
+      end
 
-          response.body
+      def weserv_attention(keep)
+        case keep.to_s
+        when "attention" then "a=attention"
+        when "entropy" then "a=entropy"
+        when "center", "centre" then "a=center"
         end
-      rescue StandardError => e
-        raise "Weserv request failed: #{e.message}"
       end
 
-      def translate_quality_to_weserv(quality)
-        quality
+      def append_weserv_watermark(operation, params)
+        parts = watermark_parts(operation)
+        params << "wm=#{encode_file_url(parts[:watermark_path])}"
+        params << "wmpos=#{compass_to_short(parts[:position])}"
+        params << "wmo=#{parts[:opacity]}" if parts[:opacity]
+      end
+
+      # Thin wrapper kept for test compatibility.
+      def translate_weserv_position(position)
+        compass_to_short(position)
       end
     end
   end

data/lib/jekyll-imgflow/tag_scanner.rb

@@ -127,34 +127,14 @@ module JekyllImgFlow
       image_path = parts.shift
 
       # Parse operations as key:value pairs separated by commas or spaces
-      operations = []
       remaining = parts.join(" ")
+      operation_pairs = split_operation_pairs(remaining)
 
-      # Handle comma-separated: key:value,key:value
-      operation_pairs = if remaining.include?(",")
-                          remaining.split(",")
-                        else
-                          # Handle space-separated: key:value key:value
-                          remaining.split(/\s+/)
-                        end
-
-      operation_pairs.each do |pair|
-        next if pair.empty?
-
-        next unless pair.include?(":")
+      operations = operation_pairs.filter_map do |pair|
+        next if pair.empty? || !pair.include?(":")
 
         key, value = pair.split(":", 2)
-        # Convert numeric values using simple string methods
-        value_stripped = value.strip
-        converted_value = if value_stripped.match?(/^\d+$/)
-                            value_stripped.to_i
-                          elsif value_stripped.match?(/^\d+\.\d+$/)
-                            value_stripped.to_f
-                          else
-                            value_stripped
-                          end
-        # Store with converted value for downstream type correctness
-        operations << "#{key.strip}:#{converted_value}"
+        "#{key.strip}:#{convert_value(value.strip)}"
       end
 
       {
@@ -163,6 +143,21 @@ module JekyllImgFlow
       }
     end
 
+    def split_operation_pairs(remaining)
+      # Handle comma-separated: key:value,key:value
+      return remaining.split(",") if remaining.include?(",")
+
+      # Handle space-separated: key:value key:value
+      remaining.split(/\s+/)
+    end
+
+    def convert_value(value)
+      return value.to_i if value.match?(/^\d+$/)
+      return value.to_f if value.match?(/^\d+\.\d+$/)
+
+      value
+    end
+
     private
 
     # Get all scannable content from site

data/lib/jekyll-imgflow/tags/base_tag.rb

@@ -33,6 +33,14 @@ module JekyllImgFlow
         end
       end
 
+      # Like get_image_dimensions but raises if dimensions cannot be read.
+      def get_original_dimensions(image_path)
+        width, height = get_image_dimensions(image_path)
+        raise ArgumentError, "Unable to determine original image dimensions" unless width && height
+
+        [width, height]
+      end
+
       def validate_positive_integer(value, name)
         return if value.nil?
 
@@ -47,6 +55,31 @@ module JekyllImgFlow
         # Config class already handles the fallback (cfg["quality"] || 85)
         @provider.config&.quality
       end
+
+      def validate_quality(value)
+        return @default_quality if value.nil?
+
+        quality = value.to_i
+        raise ArgumentError, "Invalid quality: '#{value}'. Must be between 1 and 100." unless quality.between?(1, 100)
+
+        quality
+      end
+
+      def validate_opacity(value, min: 0.0, max: 1.0)
+        raise ArgumentError, "Invalid opacity: '#{value}'. Must be between #{min} and #{max}." unless valid_numeric?(value)
+
+        opacity = value.to_f
+        raise ArgumentError, "Invalid opacity: '#{value}'. Must be between #{min} and #{max}." unless opacity.between?(min, max)
+
+        opacity
+      end
+
+      def valid_numeric?(value)
+        Float(value)
+        true
+      rescue ArgumentError, TypeError
+        false
+      end
     end
   end
 end

data/lib/jekyll-imgflow/tags/crop_tag.rb

@@ -9,25 +9,16 @@ module JekyllImgFlow
       def process(input_path, output_path, options = {})
         ensure_output_dir(output_path)
 
-        # Validate that crop information is provided
         ratio = options[:ratio] || options[:aspect_ratio]
         has_pixel_crop = options[:width] || options[:height]
 
-        unless ratio || has_pixel_crop
-          raise ArgumentError,
-                "Crop operation requires ratio or at least one dimension (width or height)"
-        end
+        validate_crop_request(ratio, has_pixel_crop)
 
         if ratio
-          # Handle aspect ratio cropping (e.g., "16:9", "4:3")
           validate_ratio(ratio)
           handle_aspect_ratio_crop(input_path, output_path, ratio, options)
         else
-          # Handle pixel-based cropping with flexible dimensions
-          validate_positive_integer(options[:width], "width") if options[:width]
-          validate_positive_integer(options[:height], "height") if options[:height]
-          validate_positive_integer(options[:x], "x") if options[:x]
-          validate_positive_integer(options[:y], "y") if options[:y]
+          validate_pixel_dimensions(options)
           handle_pixel_crop(input_path, output_path, options)
         end
 
@@ -36,16 +27,25 @@ module JekyllImgFlow
 
       private
 
+      def validate_crop_request(ratio, has_pixel_crop)
+        return if ratio || has_pixel_crop
+
+        raise ArgumentError,
+              "Crop operation requires ratio or at least one dimension (width or height)"
+      end
+
+      def validate_pixel_dimensions(options)
+        validate_positive_integer(options[:width], "width") if options[:width]
+        validate_positive_integer(options[:height], "height") if options[:height]
+        validate_positive_integer(options[:x], "x") if options[:x]
+        validate_positive_integer(options[:y], "y") if options[:y]
+      end
+
       # Handle aspect ratio cropping
       def handle_aspect_ratio_crop(input_path, _output_path, ratio, options)
         # Calculate optimal crop dimensions for the aspect ratio
         calculated_options = calculate_aspect_ratio_dimensions(input_path, ratio, options)
-
-        # Add keep parameter for smartcrop (JPT compatibility)
-        if options[:keep] && %w[attention entropy center
-                                centre].include?(options[:keep].to_s)
-          calculated_options[:keep] = options[:keep]
-        end
+        add_keep_option(calculated_options, options[:keep])
 
         # Pass ratio and calculated options to provider (uniform interface)
         @provider.crop(ratio, calculated_options)
@@ -53,57 +53,34 @@ module JekyllImgFlow
 
       # Handle flexible pixel-based cropping
       def handle_pixel_crop(input_path, _output_path, options)
-        # Get original image dimensions
         original_width, original_height = get_original_dimensions(input_path)
 
-        # Parse dimensions (support pixels and percentages)
         crop_width = parse_dimension(options[:width], original_width)
         crop_height = parse_dimension(options[:height], original_height)
 
-        # At least one dimension must be specified
         raise ArgumentError, "At least width or height must be specified for cropping" unless crop_width || crop_height
 
         # Calculate missing dimension if only one provided
-        if crop_width && !crop_height
-          crop_height = original_height  # Keep original height
-        elsif crop_height && !crop_width
-          crop_width = original_width    # Keep original width
-        end
+        crop_width ||= original_width # Keep original width
+        crop_height ||= original_height # Keep original height
 
         # Parse positions with smart defaults - always provide values
         crop_x = parse_position_with_default(options[:x], crop_width, original_width)
         crop_y = parse_position_with_default(options[:y], crop_height, original_height)
 
-        # Validate crop area is not bigger than original
         validate_crop_dimensions(crop_x, crop_y, crop_width, crop_height, original_width,
                                  original_height)
 
-        # Build crop options with keep parameter support
-        crop_options = {
-          x: crop_x,
-          y: crop_y,
-          width: crop_width,
-          height: crop_height
-        }
+        crop_options = { x: crop_x, y: crop_y, width: crop_width, height: crop_height }
+        add_keep_option(crop_options, options[:keep])
 
-        # Add keep parameter for smartcrop (JPT compatibility)
-        if options[:keep] && %w[attention entropy center
-                                centre].include?(options[:keep].to_s)
-          crop_options[:keep] = options[:keep]
-        end
-
-        # Execute crop with calculated dimensions
         @provider.crop(nil, crop_options)
       end
 
-      # Get original image dimensions using FastImage
-      def get_original_dimensions(input_path)
-        require "fastimage"
-        original_width, original_height = FastImage.size(input_path)
-
-        raise ArgumentError, "Unable to determine original image dimensions" unless original_width && original_height
+      def add_keep_option(crop_options, keep)
+        return unless keep && %w[attention entropy center centre].include?(keep.to_s)
 
-        [original_width, original_height]
+        crop_options[:keep] = keep
       end
 
       # Parse dimension (supports pixels and percentages)

data/lib/jekyll-imgflow/tags/opacity_tag.rb

@@ -13,31 +13,12 @@ module JekyllImgFlow
         opacity = options[:opacity]
         raise ArgumentError, "Opacity parameter is required" if opacity.nil?
 
-        validated_opacity = validate_opacity(opacity)
+        validated_opacity = validate_opacity(opacity, min: 0.01, max: 0.99)
 
         @provider.alpha_opacity = validated_opacity
         @provider.execute(input_path, output_path)
         output_path
       end
-
-      private
-
-      def validate_opacity(value)
-        # Check if value is numeric before converting
-        raise ArgumentError, "Invalid opacity: '#{value}'. Must be between 0.01 and 0.99." unless valid_numeric?(value)
-
-        opacity = value.to_f
-        raise ArgumentError, "Invalid opacity: '#{value}'. Must be between 0.01 and 0.99." unless opacity.between?(0.01, 0.99)
-
-        opacity
-      end
-
-      def valid_numeric?(value)
-        Float(value)
-        true
-      rescue ArgumentError, TypeError
-        false
-      end
     end
   end
 end

data/lib/jekyll-imgflow/tags/optimize_tag.rb

@@ -38,15 +38,6 @@ module JekyllImgFlow
 
         quality
       end
-
-      def validate_quality(value)
-        return @default_quality if value.nil?
-
-        quality = value.to_i
-        raise ArgumentError, "Invalid quality: '#{value}'. Must be between 1 and 100." unless quality.between?(1, 100)
-
-        quality
-      end
     end
   end
 end

data/lib/jekyll-imgflow/tags/quality_tag.rb

@@ -15,17 +15,6 @@ module JekyllImgFlow
         @provider.quality = quality
         @provider.execute(input_path, output_path)
       end
-
-      private
-
-      def validate_quality(value)
-        return @default_quality if value.nil?
-
-        quality = value.to_i
-        raise ArgumentError, "Invalid quality: '#{value}'. Must be between 1 and 100." unless quality.between?(1, 100)
-
-        quality
-      end
     end
   end
 end

data/lib/jekyll-imgflow/tags/resize_tag.rb

@@ -13,23 +13,13 @@ module JekyllImgFlow
         width = validate_positive_integer(options[:width], "width")
         height = validate_positive_integer(options[:height], "height")
 
-        # At least one dimension must be specified
         raise ArgumentError, "Either width or height must be specified for resize operation." if width.nil? && height.nil?
 
         # Get original dimensions
         original_width, original_height = get_image_dimensions(input_path)
 
         # Calculate missing dimension to maintain aspect ratio ONLY when one dimension is missing
-        if width.nil? && height
-          # Only height provided - calculate width to maintain aspect ratio
-          aspect_ratio = original_width.to_f / original_height
-          width = (height * aspect_ratio).round
-        elsif height.nil? && width
-          # Only width provided - calculate height to maintain aspect ratio
-          aspect_ratio = original_height.to_f / original_width
-          height = (width * aspect_ratio).round
-        end
-        # If both width and height are provided, use them as-is (allows aspect ratio changes)
+        width, height = calculate_missing_dimension(width, height, original_width, original_height)
 
         # Calculate scale factors for provider
         scale_x = width && original_width ? width.to_f / original_width : nil
@@ -54,6 +44,23 @@ module JekyllImgFlow
         result
       end
 
+      private
+
+      def calculate_missing_dimension(width, height, original_width, original_height)
+        if width.nil? && height
+          # Only height provided - calculate width to maintain aspect ratio
+          aspect_ratio = original_width.to_f / original_height
+          [(height * aspect_ratio).round, height]
+        elsif height.nil? && width
+          # Only width provided - calculate height to maintain aspect ratio
+          aspect_ratio = original_height.to_f / original_width
+          [width, (width * aspect_ratio).round]
+        else
+          # If both width and height are provided, use them as-is (allows aspect ratio changes)
+          [width, height]
+        end
+      end
+
       # validate_positive_integer inherited from BaseTag
     end
   end

data/lib/jekyll-imgflow/tags/watermark_tag.rb

@@ -36,23 +36,6 @@ module JekyllImgFlow
         else position.to_s
         end
       end
-
-      def validate_opacity(value)
-        # Check if value is numeric before converting
-        raise ArgumentError, "Invalid opacity: '#{value}'. Must be between 0.0 and 1.0." unless valid_numeric?(value)
-
-        opacity = value.to_f
-        raise ArgumentError, "Invalid opacity: '#{value}'. Must be between 0.0 and 1.0." unless opacity.between?(0.0, 1.0)
-
-        opacity
-      end
-
-      def valid_numeric?(value)
-        Float(value)
-        true
-      rescue ArgumentError, TypeError
-        false
-      end
     end
   end
 end

data/lib/jekyll-imgflow/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JekyllImgFlow
-  VERSION = "0.3.3"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-imgflow
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Svend Gundestrup