jekyll-imgflow 0.1.5

data/lib/jekyll-imgflow/provider_registry.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "providers/base_provider"
+
+module JekyllImgFlow
+  class ProviderRegistry
+    # Providers that don't work programmatically (manual use only)
+    MANUAL_ONLY_PROVIDERS = [].freeze
+
+    def initialize(config)
+      @config = config
+      self.class.discover_providers unless self.class.providers_discovered?
+    end
+
+    # Dynamic provider discovery
+    def self.discover_providers
+      return if @providers_discovered
+
+      @provider_registry ||= {}
+      providers_dir = File.join(File.dirname(__FILE__), "providers")
+
+      Dir.glob(File.join(providers_dir, "*.rb")).each do |file|
+        next if File.basename(file) == "base_provider.rb"
+
+        provider_name = File.basename(file, ".rb")
+        register_provider(provider_name)
+      end
+
+      @providers_discovered = true
+      Jekyll.logger.debug "ImgFlow:", "Discovered #{@provider_registry.size} providers"
+    end
+
+    def self.register_provider(name)
+      class_name = name.split("_").map(&:capitalize).join
+
+      begin
+        require_relative "providers/#{name}"
+        provider_class = JekyllImgFlow::Providers.const_get(class_name)
+        @provider_registry[name.to_sym] = provider_class
+        Jekyll.logger.debug "ImgFlow:", "Registered provider: #{class_name}"
+      rescue NameError => e
+        Jekyll.logger.warn "ImgFlow:", "Failed to load provider #{name}: #{e.message}"
+      rescue LoadError => e
+        Jekyll.logger.warn "ImgFlow:", "Failed to require provider #{name}: #{e.message}"
+      end
+    end
+
+    def self.provider_registry
+      @provider_registry ||= {}
+    end
+
+    def self.providers_discovered?
+      @providers_discovered ||= false
+    end
+
+    # Get all providers that are currently available (running/installed)
+    def self.get_available_providers(config)
+      registry = new(config)
+      registry.providers.select(&:available?)
+    end
+
+    # Get all providers with their availability status
+    def self.get_all_providers_with_status(config)
+      registry = new(config)
+      registry.providers.map do |provider|
+        {
+          name: provider.class.name.split("::").last,
+          class: provider.class,
+          instance: provider,
+          available: provider.available?
+        }
+      end
+    end
+
+    # Get current provider (first available from priority list)
+    def current_provider
+      providers.find(&:available?)
+    end
+
+    # Get list of available provider names
+    def available_providers
+      available = providers.select(&:available?)
+      available.map! { |p| p.class.name.split("::").last }
+    end
+
+    def providers
+      @providers ||= @config.backend_priority.filter_map do |name|
+        # Skip manual-only providers (they don't have programmatic APIs)
+        if MANUAL_ONLY_PROVIDERS.include?(name)
+          Jekyll.logger.debug "ImgFlow:",
+                              "Skipping '#{name}' - manual use only (no programmatic API)"
+          next
+        end
+
+        # Dynamic provider loading from registry
+        provider_class = self.class.provider_registry[name.to_sym]
+        if provider_class
+          provider_class.new(@config)
+        else
+          Jekyll.logger.warn "ImgFlow:", "Unknown provider '#{name}' - not found in registry"
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "English"
+require "open3"
+require "pathname"
+
+module JekyllImgFlow
+  module Providers
+    # Base provider class - all providers must inherit from this
+    class BaseProvider
+      # Valid smartcrop position values
+      SMARTCROP_POSITIONS = %w[attention entropy center centre].freeze
+
+      attr_accessor :config
+
+      def initialize(config = {})
+        @config = config
+        @operations = []
+      end
+
+      # Check if this provider is available (must be implemented by subclasses)
+      def available?
+        # Default: not available unless subclass implements actual check
+        # This ensures providers explicitly check their availability
+        false
+      end
+
+      # Helper method for HTTP providers to check service availability
+      def check_http_service(url)
+        return false unless url
+
+        begin
+          require "net/http"
+          require "uri"
+
+          uri = URI(url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          http.read_timeout = 2
+          http.open_timeout = 2
+
+          request = Net::HTTP::Get.new(uri)
+          http.request(request)
+
+          # Consider available if we get any response (even 404 means service is running)
+          true
+        rescue StandardError
+          false
+        end
+      end
+
+      # Helper method for HTTP providers to construct HTTP URLs from file paths
+      def encode_file_url(file_path)
+        # If already a URL, return as-is
+        return file_path if file_path.start_with?("http://", "https://")
+
+        # For HTTP providers, construct proper HTTP URL
+        site = @config.site
+
+        # Get the relative path from site source using Pathname
+        source_path = Pathname.new(site.source)
+        file_pathname = Pathname.new(file_path)
+        relative_path = if file_pathname.absolute? && file_path.to_s.start_with?(site.source)
+                          file_pathname.relative_path_from(source_path).to_s
+                        elsif file_path.start_with?("/")
+                          file_path[1..]
+                        else
+                          file_path
+                        end
+
+        # URL-encode each path segment to handle spaces and special characters
+        encoded_path = relative_path.split("/").map do |segment|
+          URI.encode_www_form_component(segment)
+        end.join("/")
+
+        # Construct HTTP URL for the file
+        # Use Jekyll server URL (localhost:4000 by default for development)
+        # In production, this would be the actual site URL from config
+        base_url = site.config["url"] || "http://localhost:4000"
+        baseurl = site.config["baseurl"] || ""
+
+        "#{base_url}#{baseurl}/#{encoded_path}"
+      end
+
+      # Operation collection methods - these should NOT execute immediately
+      def resize(width, height, options = {})
+        @operations << { type: :resize, width: width, height: height,
+                         options: options }
+      end
+
+      def crop(ratio_or_width, height_val = nil, x_val = nil, y_val = nil)
+        if height_val.is_a?(Hash)
+          @operations << { type: :crop, ratio: ratio_or_width, options: height_val }
+        elsif height_val
+          options = { width: ratio_or_width, height: height_val, x: x_val, y: y_val }
+          @operations << options.merge(type: :crop, ratio: nil, options: options)
+        else
+          @operations << { type: :crop, ratio: ratio_or_width, options: {} }
+        end
+      end
+
+      def quality=(quality)
+        @operations << { type: :quality, quality: quality }
+      end
+
+      def convert_format(format)
+        @operations << { type: :format, format: format }
+      end
+
+      def quality(value)
+        self.quality = value
+      end
+
+      def format(value)
+        convert_format(value)
+      end
+
+      def optimize(level = :medium)
+        @operations << { type: :optimize, level: level }
+      end
+
+      def opacity(value)
+        self.alpha_opacity = value
+      end
+
+      def add_watermark(watermark_path, options = {})
+        @operations << { type: :watermark, watermark_path: watermark_path,
+                         options: options }
+      end
+
+      def alpha_opacity=(opacity)
+        @operations << { type: :alpha_opacity, opacity: opacity }
+      end
+
+      def watermark(watermark_path, options = {})
+        add_watermark(watermark_path, options)
+      end
+
+      def supports_operation?(operation)
+        self.class.supports_operation?(operation)
+      end
+
+      # Final execution method - providers must implement this
+      def execute(input_path, output_path)
+        raise NotImplementedError, "Provider must implement execute method"
+      end
+
+      # Reset operations for next processing
+      def reset_operations
+        @operations = []
+      end
+
+      # Get current operations (for testing/debugging)
+      def operations
+        @operations.dup
+      end
+
+      # Helper methods
+      protected
+
+      def execute_command(command)
+        stdout, stderr, status = Open3.capture3(command)
+        raise "Command failed: #{command}\nError: #{stderr.strip}" unless status.success?
+
+        stdout.strip
+      end
+
+      def get_image_dimensions(image_path)
+        # Use FastImage for better performance and reliability
+        require "fastimage"
+        dimensions = FastImage.size(image_path)
+
+        unless dimensions
+          raise ArgumentError,
+                "Unable to read image dimensions for #{image_path}. The file may be corrupted, empty, or in an unsupported format."
+        end
+
+        dimensions
+      end
+
+      class << self
+        # Provider name for identification (override in subclasses)
+        def provider_name
+          name.split("::").last.downcase
+        end
+
+        # Provider capability methods
+        def unsupported_operations
+          [] # Default: no unsupported operations
+        end
+
+        def supports_operation?(operation)
+          !unsupported_operations.include?(operation)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "tempfile"
+require_relative "base_provider"
+
+module JekyllImgFlow
+  module Providers
+    # Flyimg provider implementation using the standardized tag interface
+    class Flyimg < BaseProvider
+      TIMEOUT = 10
+
+      def available?
+        # Check if flyimg service is running
+        return false unless @config.respond_to?(:flyimg_url) && @config.flyimg_url
+
+        check_http_service(@config.flyimg_url)
+      end
+
+      def execute(input_path, output_path)
+        return if @operations.empty?
+
+        # Build single Flyimg URL with all operations combined
+        url = build_combined_flyimg_url(input_path)
+
+        # Fetch the result in one request
+        fetch_and_save(url, output_path)
+        reset_operations
+        output_path
+      end
+
+      def build_combined_flyimg_url(input_path)
+        raise "flyimg_url not set" unless @config.flyimg_url
+
+        encoded_url = encode_file_url(input_path)
+        options = []
+
+        # Add all operations to single options string
+        @operations.each do |operation|
+          case operation[:type]
+          when :resize
+            # Tags now provide complete calculated values.
+            # c_1 forces the image to fill the exact width x height area.
+            # pns_0 allows upscaling when the source is smaller than the target
+            # (Flyimg's pns/preserve-natural-size defaults to 1, blocking enlarge).
+            options << "w_#{operation[:width]}"
+            options << "pns_0"
+            if operation[:height]
+              options << "h_#{operation[:height]}"
+              options << "c_1"
+            end
+
+          when :crop
+            opts = operation[:options]
+            params = operation[:params] || {}
+
+            # Check for keep parameter (smartcrop support)
+            keep = opts[:keep] || params[:keep] || params[:position]
+
+            if operation[:ratio] && keep && SMARTCROP_POSITIONS.include?(keep.to_s)
+              # Use smartcrop (Flyimg's smc option picks the best crop area)
+              crop_width = opts[:calculated_width]
+              crop_height = opts[:calculated_height]
+
+              options << "w_#{crop_width}"
+              options << "h_#{crop_height}"
+              options << "c_1"
+              options << "smc_1"
+            else
+              # Use basic cropping via extract (top-left / bottom-right coordinates)
+              if operation[:ratio]
+                crop_x = opts[:calculated_x]
+                crop_y = opts[:calculated_y]
+                crop_width = opts[:calculated_width]
+                crop_height = opts[:calculated_height]
+              else
+                crop_x = opts[:x]
+                crop_y = opts[:y]
+                crop_width = opts[:width]
+                crop_height = opts[:height]
+              end
+              options << "e_1"
+              options << "p1x_#{crop_x}"
+              options << "p1y_#{crop_y}"
+              options << "p2x_#{crop_x + crop_width}"
+              options << "p2y_#{crop_y + crop_height}"
+            end
+
+          when :quality
+            flyimg_quality = translate_quality_to_flyimg(operation[:quality])
+            options << "q_#{flyimg_quality}"
+
+          when :format
+            # Assume validated input from tags
+            options << "o_#{operation[:format]}"
+
+          when :watermark
+            watermark_path = operation[:watermark_path]
+            position = operation[:options][:position]
+            opacity = operation[:options][:opacity]
+
+            # Flyimg watermark parameters
+            encoded_watermark = encode_file_url(watermark_path)
+            position_param = translate_flyimg_position(position)
+            opacity_param = (opacity * 100).round
+            options << "wm_#{encoded_watermark}_#{position_param}_#{opacity_param}"
+
+          when :alpha_opacity
+            opacity = operation[:opacity]
+            options << "a_#{(opacity * 255).round}"
+          end
+        end
+
+        # Preserve format when no explicit format operation is requested.
+        # Without this, chained HTTP requests (e.g. quality-only steps after a
+        # prior format conversion) would lose the previously converted format.
+        unless @operations.any? { |op| op[:type] == :format }
+          input_ext = File.extname(input_path).delete(".").downcase
+          options << "o_#{map_format(input_ext)}" unless input_ext.empty?
+        end
+
+        # Build combined URL: base/upload/options/options,.../encoded_url
+        options_string = options.join(",")
+        "#{@config.flyimg_url}/upload/#{options_string}/#{encoded_url}"
+      end
+
+      private
+
+      def translate_flyimg_position(position)
+        # Translate compass directions to Flyimg position format
+        case position
+        when "northwest" then "tl"
+        when "northeast" then "tr"
+        when "southwest" then "bl"
+        when "southeast" then "br"
+        when "center" then "c"
+        else position
+        end
+      end
+
+      def map_format(format)
+        case format&.downcase
+        when "jpeg", "jpg"
+          "jpg"
+        when "png"
+          "png"
+        when "webp"
+          "webp"
+        when "gif"
+          "gif"
+        else
+          format&.downcase || format
+        end
+      end
+
+      def fetch_and_save(url, output_path)
+        response = fetch_with_timeout(url)
+        raise "Flyimg request failed" if response.empty?
+
+        FileUtils.mkdir_p(File.dirname(output_path))
+        File.write(output_path, response)
+      end
+
+      def fetch_with_timeout(url)
+        uri = URI(url)
+        Net::HTTP.start(uri.host, uri.port,
+                        use_ssl: uri.scheme == "https",
+                        open_timeout: TIMEOUT,
+                        read_timeout: TIMEOUT) do |http|
+          request = Net::HTTP::Get.new(uri)
+          response = http.request(request)
+
+          raise "HTTP #{response.code}: #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+          response.body
+        end
+      rescue StandardError => e
+        raise "Flyimg request failed: #{e.message}"
+      end
+
+      def translate_quality_to_flyimg(quality)
+        quality
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "open3"
+require_relative "base_provider"
+
+module JekyllImgFlow
+  module Providers
+    # ImageMagick provider implementation using the standardized tag interface
+    class Imagemagick < BaseProvider
+      def available?
+        # Check if magick or convert CLI is available
+        _, _, status1 = Open3.capture3("which", "magick")
+        _, _, status2 = Open3.capture3("which", "convert")
+        status1.success? || status2.success?
+      end
+
+      def execute(input_path, output_path)
+        return if @operations.empty?
+
+        # Build single ImageMagick command with all operations combined
+        command = build_combined_imagemagick_command(input_path, output_path)
+        execute_command(command)
+
+        reset_operations
+        output_path
+      end
+
+      def build_combined_imagemagick_command(input_path, output_path)
+        # Start with base command
+        command_parts = ["magick", input_path.shellescape]
+
+        # Add all operations
+        @operations.each do |operation|
+          case operation[:type]
+          when :resize
+            # Tags now provide complete calculated values
+            command_parts << "-resize" << if operation[:height]
+                                            "#{operation[:width]}x#{operation[:height]}!"
+                                          else
+                                            operation[:width].to_s
+                                          end
+
+          when :crop
+            opts = operation[:options]
+            params = operation[:params] || {}
+
+            # Check for keep parameter (ImageMagick doesn't support smartcrop, but we handle it gracefully)
+            keep = opts[:keep] || params[:keep] || params[:position]
+
+            if operation[:ratio] && keep && SMARTCROP_POSITIONS.include?(keep.to_s)
+              # ImageMagick doesn't support smartcrop, but we handle the keep parameter
+              # Use center gravity as a reasonable fallback for smartcrop requests
+              crop_width = opts[:calculated_width]
+              crop_height = opts[:calculated_height]
+              crop_x = opts[:calculated_x]
+              crop_y = opts[:calculated_y]
+
+              # Use gravity center for smartcrop-like behavior
+              crop_spec = "#{crop_width}x#{crop_height}+#{crop_x}+#{crop_y}"
+              command_parts << "-gravity" << "center"
+            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
+              crop_spec = "#{crop_width}x#{crop_height}+#{crop_x}+#{crop_y}"
+            end
+            command_parts << "-crop" << crop_spec
+
+          when :quality
+            magick_quality = translate_quality_to_imagemagick(operation[:quality])
+            command_parts << "-quality" << magick_quality.to_s
+
+          when :format
+            # Assume validated input from tags
+            # Format is handled by output filename extension
+            # Quality is set separately if needed
+            unless @operations.any? { |op| op[:type] == :quality }
+              default_quality = @config&.quality || raise("No quality configured")
+              command_parts << "-quality" << default_quality.to_s
+            end
+
+          when :watermark
+            watermark_path = operation[:watermark_path]
+            position = operation[:options][:position]
+
+            # Translate compass directions to ImageMagick gravity format
+            gravity = translate_position(position)
+
+            # Add watermark as composite operation
+            command_parts << watermark_path.shellescape
+            command_parts << "-gravity" << gravity
+            command_parts << "-composite"
+
+          when :alpha_opacity
+            opacity = operation[:opacity]
+            alpha_value = (opacity * 100).round
+            command_parts << "-alpha" << "set"
+            command_parts << "-channel" << "A"
+            command_parts << "-evaluate" << "multiply" << "#{alpha_value}%"
+          end
+        end
+
+        # Add output filename
+        command_parts << output_path.shellescape
+
+        command_parts.join(" ")
+      end
+
+      def translate_position(position)
+        case position
+        when "northwest" then "NorthWest"
+        when "northeast" then "NorthEast"
+        when "southwest" then "SouthWest"
+        when "southeast" then "SouthEast"
+        when "center" then "Center"
+        else position
+        end
+      end
+
+      private
+
+      def translate_quality_to_imagemagick(quality)
+        # ImageMagick uses 1-100 directly, no translation needed
+        quality
+      end
+    end
+  end
+end