jekyll-imgflow 0.3.2 → 0.4.0

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

@@ -7,37 +7,23 @@ require_relative "base_provider"
 module JekyllImgFlow
   module Providers
     # Sharp provider implementation using the standardized tag interface
-    class Sharp < BaseProvider
+    class Sharp < CliBase
       def available?
-        # Check if sharp CLI is available
-        _, _, status = Open3.capture3("which", "sharp")
-        status.success?
+        cli_available?("sharp")
       end
 
-      def execute(input_path, output_path)
-        return if @operations.empty?
-
-        # Build Sharp command
-        command = build_sharp_command(input_path, output_path)
-        execute_command(command)
-
-        output_path
-      ensure
-        reset_operations
+      def build_commands(input_path, output_path)
+        build_sharp_command(input_path, output_path)
       end
 
       def build_sharp_command(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 }
-
-        if has_watermark
-          build_watermark_pipeline(input_path, output_path, has_crop, has_resize)
-        elsif has_crop && has_resize
+        if op?(:watermark)
+          build_watermark_pipeline(input_path, output_path, op?(:crop), op?(:resize))
+        elsif op?(:crop) && op?(:resize)
           build_sequential_crop_resize(input_path, output_path)
-        elsif has_resize
+        elsif op?(:resize)
           build_resize_command(input_path, output_path)
-        elsif has_crop
+        elsif op?(:crop)
           build_crop_command(input_path, output_path)
         else
           build_copy_command(input_path, output_path)
@@ -45,47 +31,41 @@ module JekyllImgFlow
       end
 
       def build_watermark_pipeline(input_path, output_path, has_crop, has_resize)
-        temp_path = input_path.gsub(/\.[^.]+$/, ".tmp_base.jpg")
+        temp = temp_path(input_path, "tmp_base.jpg")
         commands = []
 
         if has_crop && has_resize
-          commands << build_sequential_crop_resize(input_path, temp_path)
-          base_path = temp_path
+          commands << build_sequential_crop_resize(input_path, temp)
+          base_path = temp
         elsif has_resize
-          commands << build_resize_command(input_path, temp_path)
-          base_path = temp_path
+          commands << build_resize_command(input_path, temp)
+          base_path = temp
         elsif has_crop
-          commands << build_crop_command(input_path, temp_path)
-          base_path = temp_path
+          commands << build_crop_command(input_path, temp)
+          base_path = temp
         else
           base_path = input_path
         end
 
         commands << build_composite_command(base_path, output_path)
-        commands << "rm -f #{temp_path.shellescape}" unless base_path == input_path
+        commands << "rm -f #{temp.shellescape}" unless base_path == input_path
         commands.join(" && ")
       end
 
       def build_composite_command(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]
-
-        gravity = translate_position(position)
+        wm_op = find_op(:watermark)
+        parts = watermark_parts(wm_op)
+        gravity = translate_position(parts[:position])
 
         command_parts = ["sharp", "-i", base_path.shellescape,
                          "-o", output_path.shellescape]
 
-        format_op = @operations.find { |op| op[:type] == :format }
-        quality_op = @operations.find { |op| op[:type] == :quality }
-        command_parts += ["-f", sharp_format(format_op[:format])] if format_op
-        command_parts += ["-q#{quality_op[:quality]}"] if quality_op
+        add_format_quality(command_parts)
 
-        if opacity && opacity < 1.0
-          wm_temp = watermark_path.gsub(/\.[^.]+$/, ".tmp_wm.png")
-          alpha_value = (opacity * 255).round
-          temp_cmd = ["sharp", "-i", watermark_path.shellescape,
+        if parts[:opacity] && parts[:opacity] < 1.0
+          wm_temp = temp_path(parts[:watermark_path], "tmp_wm.png")
+          alpha_value = alpha_byte_value(parts[:opacity])
+          temp_cmd = ["sharp", "-i", parts[:watermark_path].shellescape,
                       "-o", wm_temp.shellescape,
                       "ensureAlpha", alpha_value.to_s].join(" ")
           command_parts += ["composite", wm_temp.shellescape,
@@ -93,7 +73,7 @@ module JekyllImgFlow
           "#{temp_cmd} && #{command_parts.join(' ')} " \
             "&& rm -f #{wm_temp.shellescape}"
         else
-          command_parts += ["composite", watermark_path.shellescape,
+          command_parts += ["composite", parts[:watermark_path].shellescape,
                             "--gravity", gravity, "--blend", "over"]
           command_parts.join(" ")
         end
@@ -112,20 +92,20 @@ module JekyllImgFlow
 
       def build_sequential_crop_resize(input_path, output_path)
         # Build temp file path for intermediate crop result
-        temp_path = input_path.gsub(/\.[^.]+$/, ".tmp_crop.jpg")
+        temp = temp_path(input_path, "tmp_crop.jpg")
 
         # First command: crop only
-        crop_cmd = build_crop_command(input_path, temp_path)
+        crop_cmd = build_crop_command(input_path, temp)
 
         # Second command: resize + format + quality + alpha (all together)
-        resize_cmd = build_resize_command(temp_path, output_path)
+        resize_cmd = build_resize_command(temp, output_path)
 
         # Combine with && and cleanup temp file
-        "#{crop_cmd} && #{resize_cmd} && rm -f #{temp_path.shellescape}"
+        "#{crop_cmd} && #{resize_cmd} && rm -f #{temp.shellescape}"
       end
 
       def build_resize_command(input_path, output_path)
-        resize_op = @operations.find { |op| op[:type] == :resize }
+        resize_op = find_op(:resize)
 
         # sharp -i input.jpg -o output.jpg resize width [height] -f format -q quality
         command_parts = ["sharp", "-i", input_path.shellescape, "-o", output_path.shellescape]
@@ -137,58 +117,28 @@ module JekyllImgFlow
                            ["resize", resize_op[:width].to_s]
                          end
 
-        # Add format, quality, alpha
-        format_op = @operations.find { |op| op[:type] == :format }
-        quality_op = @operations.find { |op| op[:type] == :quality }
-        alpha_op = @operations.find { |op| op[:type] == :alpha_opacity }
-
-        command_parts += ["-f", sharp_format(format_op[:format])] if format_op
-        command_parts += ["-q#{quality_op[:quality]}"] if quality_op
-        if alpha_op
-          alpha_value = (alpha_op[:opacity] * 255).round
-          command_parts += ["alpha", "{alpha:#{alpha_value}}"]
-        end
-
+        add_format_quality_alpha(command_parts)
         command_parts.join(" ")
       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] || {}
+        crop_op = find_op(:crop)
+        geo = crop_geometry(crop_op)
 
-        # Check if we should use smartcrop (when keep parameter is specified)
-        # JPT keep options: attention (default), entropy, center
-        # Check both options (from CropTag) and params (from OperationProcessor)
-        keep = opts[:keep] || params[:keep] || params[:position]
-
-        if crop_op[:ratio] && keep && %w[attention entropy center
-                                         centre].include?(keep.to_s)
+        if geo[:smartcrop]
           # Use smartcrop for intelligent cropping (Sharp uses libvips backend)
-          crop_width = opts[:calculated_width]
-          crop_height = opts[:calculated_height]
-
-          # Map keep parameter to libvips interestingness
-          interestingness = case keep.to_s
-                            when "entropy" then "entropy"
-                            when "center", "centre" then "centre"
-                            else "attention" # default
-                            end
+          interestingness = smartcrop_interestingness(geo[:keep])
 
           # sharp -i input.jpg -o output.jpg smartcrop width height --interesting=attention
           ["sharp", "-i", input_path.shellescape, "-o", output_path.shellescape,
-           "smartcrop", crop_width.to_s, crop_height.to_s,
+           "smartcrop", geo[:width].to_s, geo[:height].to_s,
            "--interesting=#{interestingness}"].join(" ")
         else
           # Use basic extract for manual cropping or when no keep parameter
-          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]
-
           # sharp -i input.jpg -o output.jpg extract top left width height
           ["sharp", "-i", input_path.shellescape, "-o", output_path.shellescape,
-           "extract", crop_y.to_s, crop_x.to_s, crop_width.to_s, crop_height.to_s].join(" ")
+           "extract", geo[:y].to_s, geo[:x].to_s, geo[:width].to_s,
+           geo[:height].to_s].join(" ")
         end
       end
 
@@ -196,17 +146,7 @@ module JekyllImgFlow
         # sharp -i input.jpg -o output.jpg -f format -q quality
         command_parts = ["sharp", "-i", input_path.shellescape, "-o", output_path.shellescape]
 
-        format_op = @operations.find { |op| op[:type] == :format }
-        quality_op = @operations.find { |op| op[:type] == :quality }
-        alpha_op = @operations.find { |op| op[:type] == :alpha_opacity }
-
-        command_parts += ["-f", sharp_format(format_op[:format])] if format_op
-        command_parts += ["-q#{quality_op[:quality]}"] if quality_op
-        if alpha_op
-          alpha_value = (alpha_op[:opacity] * 255).round
-          command_parts += ["alpha", "{alpha:#{alpha_value}}"]
-        end
-
+        add_format_quality_alpha(command_parts)
         command_parts.join(" ")
       end
 
@@ -215,6 +155,23 @@ module JekyllImgFlow
       def sharp_format(format)
         format.to_s == "jpg" ? "jpeg" : format
       end
+
+      private
+
+      def add_format_quality(command_parts)
+        format_op = find_op(:format)
+        quality_op = find_op(:quality)
+        command_parts.push("-f", sharp_format(format_op[:format])) if format_op
+        command_parts.push("-q#{quality_op[:quality]}") if quality_op
+      end
+
+      def add_format_quality_alpha(command_parts)
+        add_format_quality(command_parts)
+        alpha_op = find_op(:alpha_opacity)
+        return unless alpha_op
+
+        command_parts.push("alpha", "{alpha:#{alpha_byte_value(alpha_op[:opacity])}}")
+      end
     end
   end
 end

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