jekyll-imgflow 0.1.5

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+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
+      TIMEOUT = 10
+
+      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)
+      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)
+        reset_operations
+        output_path
+      end
+
+      def build_combined_weserv_url(input_path)
+        raise "weserv_url not set" unless @config.weserv_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
+
+        query_string = params.join("&")
+        "#{@config.weserv_url}/?#{query_string}"
+      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
+      end
+
+      def fetch_and_save(url, output_path)
+        response = fetch_with_timeout(url)
+        raise "Weserv 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 "Weserv request failed: #{e.message}"
+      end
+
+      def translate_quality_to_weserv(quality)
+        quality
+      end
+    end
+  end
+end

data/lib/jekyll-imgflow/tag_scanner.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module JekyllImgFlow
+  # Scans Jekyll content for {% imgflow %} and {% picture %} tags
+  # Uses ManifestManager as single source of truth
+  class TagScanner
+    def initialize(site, config, manifest = nil)
+      @site = site
+      @config = config
+      @manifest = manifest
+    end
+
+    # Scan all content files for image tags
+    # Returns summary from ManifestManager instead of building own hash
+    def scan_all_content
+      # Scan posts, pages, and documents
+      scannable_content.each do |item|
+        scan_content_item(item)
+      end
+
+      # Return manifest summary if available, otherwise empty hash
+      @manifest ? @manifest.get_all_versions : {}
+    end
+
+    # Scan a single content item
+    # Note: With ManifestManager as single source of truth, this just discovers tags
+    # Actual tracking happens in ManifestManager during ImgflowTag rendering
+    def scan_content_item(item)
+      content = item.content
+
+      # Define tag patterns to scan for
+      tag_patterns = {
+        "imgflow" => "{% imgflow",
+        "picture" => "{% picture"
+      }
+
+      # Use reusable scanner - just for discovery/validation
+      scan_tags_from_content(content, tag_patterns) do |_tag_name, markup|
+        # Tags are discovered but not tracked here
+        # ManifestManager handles all tracking during actual rendering
+      end
+
+      nil # No longer returns requirements hash
+    end
+
+    # Scan raw content string and return array of tag info (for testing/direct use)
+    def scan_content(content)
+      tags = []
+
+      # Define tag patterns to scan for
+      tag_patterns = {
+        "imgflow" => "{% imgflow"
+      }
+
+      # Use reusable scanner
+      scan_tags_from_content(content, tag_patterns) do |_tag_name, markup|
+        parsed = parse_tag_markup_simple(markup)
+        tags << parsed
+      end
+
+      tags
+    end
+
+    # Find all imgflow tags in content
+    def find_imgflow_tags(content)
+      scan_content(content)
+    end
+
+    # Find all picture tags in content
+    def find_picture_tags(content)
+      tags = []
+
+      # Define tag patterns to scan for
+      tag_patterns = {
+        "picture" => "{% picture"
+      }
+
+      # Use reusable scanner
+      scan_tags_from_content(content, tag_patterns) do |_tag_name, markup|
+        parsed = parse_tag_markup_simple(markup)
+        tags << parsed
+      end
+
+      tags
+    end
+
+    # Extract operations from tag markup - returns raw strings only
+    def extract_operations(markup)
+      parsed = parse_tag_markup_simple(markup)
+      parsed[:operations] # Just return array of ["width:800", "quality:90"]
+    end
+
+    # Determine if operations represent default or specialized version
+    def determine_version_type(operations)
+      determine_type(operations)
+    end
+
+    # Generic tag scanner - eliminates duplication
+    def scan_tags_from_content(content, tag_patterns)
+      content_lines = content.split("\n")
+      content_lines.each do |line|
+        tag_patterns.each do |tag_name, tag_prefix|
+          next unless line.include?(tag_prefix)
+
+          markup = extract_markup_from_line(line, tag_prefix)
+          yield tag_name, markup if markup
+        end
+      end
+    end
+
+    # Extract markup from line - reusable method
+    def extract_markup_from_line(line, tag_prefix)
+      start_idx = line.index(tag_prefix)
+      return unless start_idx
+
+      start_idx += tag_prefix.length
+      end_idx = line.index("%}", start_idx)
+      return unless start_idx && end_idx
+
+      line[start_idx..(end_idx - 1)].strip
+    end
+
+    # Simple parsing without regex gymnastics
+    def parse_tag_markup_simple(markup)
+      # Split by whitespace first to get image path
+      parts = markup.split(/\s+/)
+      image_path = parts.shift
+
+      # Parse operations as key:value pairs separated by commas or spaces
+      operations = []
+      remaining = parts.join(" ")
+
+      # 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?(":")
+
+        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}"
+      end
+
+      {
+        image: image_path, # Use :image key for test compatibility
+        operations: operations # Return as array of strings
+      }
+    end
+
+    private
+
+    # Get all scannable content from site
+    def scannable_content
+      items = []
+      items.concat(@site.posts.docs) if @site.posts
+      items.concat(@site.pages)
+
+      # Add documents from collections
+      @site.collections.each_value do |collection|
+        items.concat(collection.docs)
+      end
+
+      items
+    end
+
+    # NOTE: process_tag removed - ManifestManager handles all tracking
+    # Tags are discovered during scanning but tracking happens during rendering
+
+    def parse_tag_markup(markup)
+      parts = markup.split(/\s+/)
+      image_path = parts.shift
+      operations = {}
+
+      parts.each do |part|
+        next unless part.include?(":")
+
+        key, value = part.split(":", 2)
+        operations[key.to_sym] = parse_value(value)
+      end
+
+      {
+        image_path: image_path,
+        operations: operations
+      }
+    end
+
+    def parse_value(value)
+      value = value.tr("'\"", "")
+      return value.to_i if value.match?(/^\d+$/)
+      return value.to_f if value.match?(/^\d+\.\d+$/)
+
+      value
+    end
+
+    # Determine if operations match default configuration
+    def determine_type(operations)
+      # Check if operations match any default size + format combination
+      default_sizes = @config.sizes.values
+      default_formats = @config.formats
+
+      # If width matches a default size and format is default, it's default type
+      return "default" if operations[:width] && default_sizes.include?(operations[:width]) && (operations[:format].nil? || default_formats.include?(operations[:format]))
+
+      # If only format is specified and it's a default format, it's default
+      return "default" if operations.keys == [:format] && default_formats.include?(operations[:format])
+
+      # Otherwise, it's specialized
+      "specialized"
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "fastimage"
+
+module JekyllImgFlow
+  module Tags
+    # Base class for all ImgFlow tags
+    class BaseTag
+      def initialize(provider)
+        @provider = provider
+        @config = provider.config
+        @default_quality = default_quality_from_config
+      end
+
+      def process(input_path, output_path, options = {})
+        raise NotImplementedError, "Provider must implement #{self.class.name}#process"
+      end
+
+      protected
+
+      def ensure_output_dir(output_path)
+        dir = File.dirname(output_path)
+        FileUtils.mkdir_p(dir)
+      end
+
+      def get_image_dimensions(image_path)
+        return [nil, nil] unless File.exist?(image_path)
+
+        begin
+          FastImage.size(image_path)
+        rescue FastImage::UnknownImageType, FastImage::ImageFetchError
+          [nil, nil]
+        end
+      end
+
+      def validate_positive_integer(value, name)
+        return if value.nil?
+
+        integer_value = value.to_i
+        raise ArgumentError, "Invalid #{name}: '#{value}'. Must be a positive integer." if integer_value <= 0 || value.to_s != integer_value.to_s
+
+        integer_value
+      end
+
+      def default_quality_from_config
+        # Get default quality from provider's config
+        # Config class already handles the fallback (cfg["quality"] || 85)
+        @provider.config&.quality
+      end
+    end
+  end
+end

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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require_relative "base_tag"
+
+module JekyllImgFlow
+  module Tags
+    # Crop tag - processes image cropping (validation handled by Parser)
+    class CropTag < BaseTag
+      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
+
+        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]
+          handle_pixel_crop(input_path, output_path, options)
+        end
+
+        @provider.execute(input_path, output_path)
+      end
+
+      private
+
+      # 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
+
+        # Pass ratio and calculated options to provider (uniform interface)
+        @provider.crop(ratio, calculated_options)
+      end
+
+      # 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
+
+        # 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
+        }
+
+        # 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
+
+        [original_width, original_height]
+      end
+
+      # Parse dimension (supports pixels and percentages)
+      def parse_dimension(value, original_size)
+        return if value.nil?
+
+        if value.to_s.end_with?("%")
+          # Percentage-based: "50%" → original_size * 0.5
+          percentage = value.to_f / 100
+          (original_size * percentage).round
+        else
+          # Absolute pixels: "800" → 800
+          value.to_i
+        end
+      end
+
+      # Parse position with smart defaults
+      def parse_position(value, crop_size, original_size)
+        return if value.nil?
+
+        if value.to_s == "center"
+          # Center the crop
+          ((original_size - crop_size) / 2).round
+        else
+          # Absolute position
+          value.to_i
+        end
+      end
+
+      # Parse position with default to center if not specified
+      def parse_position_with_default(value, crop_size, original_size)
+        return ((original_size - crop_size) / 2).round if value.nil?
+
+        if value.to_s == "center"
+          # Center the crop
+          ((original_size - crop_size) / 2).round
+        else
+          # Absolute position
+          value.to_i
+        end
+      end
+
+      # Validate crop dimensions don't exceed original image
+      def validate_crop_dimensions(crop_x, crop_y, crop_width, crop_height, original_width,
+                                   original_height)
+        if crop_x.negative? || crop_y.negative?
+          raise ArgumentError,
+                "Crop position cannot be negative"
+        end
+
+        return if crop_x + crop_width <= original_width && crop_y + crop_height <= original_height
+
+        raise ArgumentError, "Crop area exceeds original image dimensions"
+      end
+
+      # Calculate optimal dimensions for aspect ratio cropping
+      def calculate_aspect_ratio_dimensions(input_path, ratio, _options)
+        original_width, original_height = get_original_dimensions(input_path)
+
+        # Parse ratio like "16:9"
+        ratio_width, ratio_height = ratio.split(":").map(&:to_f)
+        target_ratio = ratio_width / ratio_height
+        original_ratio = original_width.to_f / original_height
+
+        # Calculate crop dimensions
+        if original_ratio > target_ratio
+          # Image is wider than target ratio - crop width
+          calculated_height = original_height
+          calculated_width = (calculated_height * target_ratio).round
+          calculated_x = ((original_width - calculated_width) / 2).round
+          calculated_y = 0
+        else
+          # Image is taller than target ratio - crop height
+          calculated_width = original_width
+          calculated_height = (calculated_width / target_ratio).round
+          calculated_x = 0
+          calculated_y = ((original_height - calculated_height) / 2).round
+        end
+
+        {
+          calculated_width: calculated_width,
+          calculated_height: calculated_height,
+          calculated_x: calculated_x,
+          calculated_y: calculated_y
+        }
+      end
+
+      # Validate ratio format (e.g., "16:9")
+      def validate_ratio(ratio)
+        return ratio if ratio.nil?
+
+        # Convert symbol to string
+        ratio_str = ratio.to_s
+
+        # Validate format
+        unless ratio_str.match?(/\A\d+:\d+\z/)
+          raise ArgumentError,
+                "Invalid ratio: '#{ratio}'. Must be in format 'width:height' (e.g., '16:9')."
+        end
+
+        # Validate numeric values
+        width, height = ratio_str.split(":").map(&:to_i)
+        if width <= 0 || height <= 0
+          raise ArgumentError,
+                "Invalid ratio: '#{ratio}'. Width and height must be positive numbers."
+        end
+
+        ratio_str
+      end
+
+      # validate_positive_integer inherited from BaseTag
+    end
+  end
+end