jekyll-imgflow 0.1.5

data/lib/jekyll-imgflow/picture_tag_adaptor.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+module JekyllImgFlow
+  # Adaptor that translates Jekyll Picture Tag syntax to ImgFlow syntax
+  # Simple tag-to-tag translation with values
+  class PictureTagAdaptor
+    def initialize(site, config)
+      @site = site
+      @config = config
+    end
+
+    # Convert Picture Tag to ImgFlow tag markup that can be used in templates
+    # @param picture_markup [String] Picture Tag markup
+    # @return [String] ImgFlow tag markup with attributes
+    def to_imgflow_tag(picture_markup)
+      result = translate_to_imgflow(picture_markup)
+      return "" if result[:markup].empty?
+
+      # Build ImgFlow tag with attributes
+      tag_parts = ["{% imgflow", result[:markup]]
+
+      # Add HTML attributes
+      tag_parts << "alt:\"#{result[:attributes][:alt]}\"" if result[:attributes][:alt]
+
+      if result[:attributes][:img]&.any?
+        result[:attributes][:img].each do |name, value|
+          tag_parts << "img-#{name}:\"#{value}\""
+        end
+      end
+
+      if result[:attributes][:picture]&.any?
+        result[:attributes][:picture].each do |name, value|
+          tag_parts << "picture-#{name}:\"#{value}\""
+        end
+      end
+
+      tag_parts << "%}"
+      tag_parts.join(" ")
+    end
+
+    # Convert Picture Tag markup to ImgFlow markup with HTML attributes
+    # @param picture_markup [String] Picture Tag markup like "{% picture hero image.jpg 16:9 --alt Text %}"
+    # @return [Hash] Translation result with markup and attributes
+    def translate_to_imgflow(picture_markup)
+      # Extract content between {% picture ... %}
+      match = picture_markup.match(/\{%\s*picture\s+(.+?)\s*%}/)
+      return { markup: "", attributes: {} } unless match
+
+      content = match[1].strip
+      return { markup: "", attributes: {} } if content.empty?
+
+      # Parse arguments
+      args = parse_arguments(content)
+      return { markup: "", attributes: {} } if args.empty?
+
+      # Step 1: Categorize arguments by type
+      categorized = categorize_arguments(args)
+      return { markup: "", attributes: {} } unless categorized[:image]
+
+      # Step 2: Translate each category to ImgFlow syntax
+      imgflow_parts = []
+      imgflow_parts << categorized[:image]
+      imgflow_parts += translate_media_queries(categorized[:media_queries])
+      imgflow_parts += translate_operations(categorized[:operations])
+      imgflow_parts << "formats:webp,jpg" unless formats?(imgflow_parts)
+      imgflow_parts << "markup:#{categorized[:markup_format]}" if categorized[:markup_format] && categorized[:markup_format] != "auto"
+
+      # Step 3: Assemble result
+      {
+        markup: imgflow_parts.compact.join(" "),
+        attributes: categorized[:html_attributes],
+        markup_format: categorized[:markup_format]
+      }
+    end
+
+    private
+
+    # Parse arguments handling quoted paths and attributes
+    # @param content [String] Raw content
+    # @return [Array] Parsed arguments
+    def parse_arguments(content)
+      args = []
+      current = +"" # Create unfrozen string
+      in_quotes = false
+      quote_char = nil
+
+      content.dup.each_char do |char|
+        case char
+        when '"', "'"
+          if !in_quotes
+            in_quotes = true
+            quote_char = char
+          elsif char == quote_char
+            in_quotes = false
+            quote_char = nil
+          else
+            current << char
+          end
+        when " "
+          if in_quotes
+            current << char
+          elsif !current.empty?
+            args << current.dup
+            current = +""
+          end
+        else
+          current << char
+        end
+      end
+
+      args << current.dup unless current.empty?
+      args
+    end
+
+    # Categorize arguments into types
+    # @param args [Array] All parsed arguments
+    # @return [Hash] Categorized arguments
+    def categorize_arguments(args)
+      result = {
+        image: nil,
+        media_queries: {},
+        operations: [],
+        html_attributes: default_html_attributes,
+        markup_format: nil
+      }
+
+      i = 0
+      while i < args.length
+        arg = args[i]
+
+        case arg
+        when /^--alt$/
+          # Collect alt text until next --
+          i += 1
+          alt_parts = []
+          while i < args.length && !args[i].start_with?("--")
+            alt_parts << args[i]
+            i += 1
+          end
+          result[:html_attributes][:alt] = strip_quotes(alt_parts.join(" "))
+          next
+        when /^--link$/
+          result[:html_attributes][:link] = strip_quotes(args[i + 1]) if i + 1 < args.length
+          i += 2
+          next
+        when /^--(img|picture|source|a|parent)$/
+          element = ::Regexp.last_match(1).to_sym
+          i += 1
+          while i < args.length && !args[i].start_with?("--")
+            parse_element_attribute(args[i], result[:html_attributes][element])
+            i += 1
+          end
+          next
+        when /(mobile|tablet|desktop):/
+          device = ::Regexp.last_match(1)
+          i += 1
+          if i < args.length && args[i].include?(".")
+            image = args[i]
+            i += 1
+            crop = parse_crop_from_arg(args[i]) if i < args.length && args[i] =~ /^\d+:\d+/
+            i += 1 if crop
+            result[:media_queries][device] = { image: image, crop: crop }
+          end
+          next
+        when /^(auto|data_auto|picture|img)$/
+          result[:markup_format] = arg
+        when /\./
+          # Image path (has extension, no colon)
+          result[:image] ||= arg unless arg.include?(":")
+        else
+          # Operation argument
+          result[:operations] << arg unless arg.start_with?("--")
+        end
+
+        i += 1
+      end
+
+      result
+    end
+
+    # Translate media queries to ImgFlow crop syntax
+    # @param media_queries [Hash] Media queries by device
+    # @return [Array<String>] Translated crop operations
+    def translate_media_queries(media_queries)
+      return [] if media_queries.empty?
+
+      # Use mobile crop as primary (most important for responsive)
+      primary = media_queries["mobile"] || media_queries.values.first
+      return [] unless primary && primary[:crop]
+
+      parts = []
+      parts << "ratio:#{primary[:crop][:ratio]}" if primary[:crop][:ratio]
+      parts << "keep:#{primary[:crop][:keep]}" if primary[:crop][:keep]
+      parts
+    end
+
+    # Default HTML attributes structure
+    def default_html_attributes
+      {
+        img: {},
+        picture: {},
+        source: {},
+        a: {},
+        parent: {},
+        alt: nil,
+        link: nil
+      }
+    end
+
+    # Parse element attribute (class=value or boolean)
+    # @param attr_string [String] Attribute string
+    # @param attrs_hash [Hash] Hash to store parsed attributes
+    def parse_element_attribute(attr_string, attrs_hash)
+      case attr_string
+      when /^(\w+(?:-\w+)*)=(["'])(.+?)\2$/
+        attrs_hash[::Regexp.last_match(1)] = ::Regexp.last_match(3)
+      when /^(\w+(?:-\w+)*)=([^"\s]+)$/
+        attrs_hash[::Regexp.last_match(1)] = ::Regexp.last_match(2)
+      when /^(\w+(?:-\w+)*)$/
+        attrs_hash[::Regexp.last_match(1)] = true
+      end
+    end
+
+    # Translate operation arguments to ImgFlow syntax
+    # @param operations [Array<String>] Operation arguments
+    # @return [Array<String>] Translated operations
+    def translate_operations(operations)
+      operations.map do |arg|
+        case arg
+        when /^\d+:\d+\s+(center|entropy|top|bottom|left|right|smart)$/
+          parts = arg.split
+          ["ratio:#{parts[0]}", "keep:#{parts[1]}"]
+        when /^\d+:\d+$/
+          "ratio:#{arg}"
+        when /^(center|entropy|top|bottom|left|right|smart)$/
+          "keep:#{arg}"
+        when /^[a-zA-Z][a-zA-Z0-9_-]*$/
+          "preset:#{arg}"
+        when /^\d+$/
+          "width:#{arg}"
+        end
+      end.flatten.compact
+    end
+
+    # Parse crop from argument string
+    # @param arg [String] Argument like "16:9" or "16:9 center" or "16:9 attention"
+    # @return [Hash, nil] Crop info with ratio and keep parameter
+    def parse_crop_from_arg(arg)
+      return unless arg
+
+      parts = arg.split
+      crop = {}
+
+      if /^\d+:\d+$/.match?(parts[0])
+        crop[:ratio] = parts[0]
+        # Default keep to center if not specified
+        crop[:keep] = parts[1] || "center"
+      end
+
+      crop.empty? ? nil : crop
+    end
+
+    # Parse crop information from crop string (for tests)
+    # @param crop_string [String] Crop string like "16:9" or "16:9 center"
+    # @return [Hash] Parsed crop info with ratio and keep
+    def parse_crop(crop_string)
+      parse_crop_from_arg(crop_string) || {}
+    end
+
+    # Strip quotes from string
+    # @param str [String] String that may have quotes
+    # @return [String] String without surrounding quotes
+    def strip_quotes(str)
+      return "" if str.nil? || str.empty?
+
+      str = str[1..-2] if str.start_with?('"') && str.end_with?('"')
+      str = str[1..-2] if str.start_with?("'") && str.end_with?("'")
+      str
+    end
+
+    # Check if formats are already specified
+    # @param parts [Array<String>] ImgFlow parts
+    # @return [Boolean] True if formats already specified
+    def formats?(parts)
+      parts.any? { |part| part&.include?("formats:") }
+    end
+
+    # Determine primary crop from multiple crop options (for tests)
+    # @param crops [Hash] Hash of crops by breakpoint
+    # @return [Hash] Primary crop info
+    def determine_primary_crop(crops)
+      return crops["mobile"] if crops["mobile"]
+      return crops["tablet"] if crops["tablet"]
+      return crops["default"] if crops["default"]
+
+      crops.values.first
+    end
+  end
+end

data/lib/jekyll-imgflow/picture_tag_preset_migrator.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module JekyllImgFlow
+  # Migrates Jekyll Picture Tag presets to ImgFlow YAML preset format
+  class PictureTagPresetMigrator
+    PICTURE_TAG_CONFIG = "_data/picture.yml"
+    IMGFLOW_PRESETS_DIR = "_data/imgflow/presets"
+
+    def initialize(site_source)
+      @site_source = site_source
+      @picture_config_path = File.join(site_source, PICTURE_TAG_CONFIG)
+      @imgflow_presets_dir = File.join(site_source, IMGFLOW_PRESETS_DIR)
+    end
+
+    # Migrate all Picture Tag presets to ImgFlow format
+    # @return [Hash] Migration results
+    def migrate_presets
+      results = {
+        migrated: [],
+        skipped: [],
+        errors: []
+      }
+
+      return results unless File.exist?(@picture_config_path)
+
+      picture_config = load_picture_config
+      return results unless picture_config["presets"]
+
+      # Ensure ImgFlow presets directory exists
+      FileUtils.mkdir_p(@imgflow_presets_dir)
+
+      picture_config["presets"].each do |preset_name, preset_data|
+        imgflow_preset = convert_preset_to_imgflow(preset_name, preset_data)
+
+        if imgflow_preset
+          save_imgflow_preset(preset_name, imgflow_preset)
+          results[:migrated] << preset_name
+        else
+          results[:skipped] << { name: preset_name, reason: "No convertible operations" }
+        end
+      rescue StandardError => e
+        results[:errors] << { name: preset_name, error: e.message }
+      end
+
+      results
+    end
+
+    # Get migration summary without actually migrating
+    # @return [Hash] Preview of what would be migrated
+    def preview_migration
+      results = {
+        found: [],
+        convertible: [],
+        non_convertible: []
+      }
+
+      return results unless File.exist?(@picture_config_path)
+
+      picture_config = load_picture_config
+      return results unless picture_config["presets"]
+
+      picture_config["presets"].each do |preset_name, preset_data|
+        results[:found] << preset_name
+
+        if convertible_operations?(preset_data)
+          imgflow_preset = convert_preset_to_imgflow(preset_name, preset_data)
+          results[:convertible] << { name: preset_name, preview: imgflow_preset }
+        else
+          results[:non_convertible] << { name: preset_name,
+                                         reason: "No convertible operations" }
+        end
+      end
+
+      results
+    end
+
+    private
+
+    # Load Picture Tag configuration
+    # @return [Hash] Picture Tag config
+    def load_picture_config
+      YAML.safe_load_file(@picture_config_path) || {}
+    end
+
+    # Check if preset has operations that can be converted
+    # @param preset_data [Hash] Picture Tag preset data
+    # @return [Boolean] True if convertible
+    def convertible_operations?(preset_data)
+      convertible_keys = %w[widths base_width width height quality formats crop gravity]
+      convertible_keys.any? { |key| preset_data[key] }
+    end
+
+    # Convert Picture Tag preset to ImgFlow YAML format
+    # @param preset_name [String] Preset name
+    # @param preset_data [Hash] Picture Tag preset data
+    # @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
+
+      return if operations.empty?
+
+      {
+        "name" => preset_name,
+        "description" => generate_description(preset_name, preset_data),
+        "operations" => operations,
+        "picture_tag_metadata" => {
+          "original_widths" => preset_data["widths"],
+          "original_base_width" => preset_data["base_width"],
+          "original_pixel_ratios" => preset_data["pixel_ratios"],
+          "original_sizes" => preset_data["sizes"],
+          "dimension_attributes" => preset_data["dimension_attributes"]
+        }.compact
+      }
+    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 = []
+
+      if preset_data["widths"]
+        operations << "widths: #{Array(preset_data['widths']).join(',')}"
+        operations << "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(',')}"
+      elsif preset_data["width"]
+        operations << "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
+    # @param preset_name [String] Preset name
+    # @param preset_data [Hash] ImgFlow preset data
+    def save_imgflow_preset(preset_name, preset_data)
+      filename = "#{preset_name}.yml"
+      filepath = File.join(@imgflow_presets_dir, filename)
+
+      File.write(filepath, YAML.dump(preset_data))
+    end
+  end
+end

data/lib/jekyll-imgflow/preset_manager.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module JekyllImgFlow
+  # PresetManager - translates YAML presets to tags:value format
+  # Handles tag overrides (user tags override preset tags)
+  # Passes combined markup to Parser for uniform validation flow
+  class PresetManager
+    def initialize(site, config)
+      @site = site
+      @config = config
+      @presets = load_presets
+    end
+
+    # Load presets from _data/imgflow/presets/
+    def load_presets
+      presets = {}
+      presets_dir = File.join(@site.source, "_data", "imgflow", "presets")
+
+      return presets unless Dir.exist?(presets_dir)
+
+      Dir.glob(File.join(presets_dir, "*.yml")).each do |preset_file|
+        preset_name = File.basename(preset_file, ".yml")
+        begin
+          preset_data = YAML.safe_load_file(preset_file)
+          presets[preset_name] = preset_data
+        rescue Psych::SyntaxError => e
+          Jekyll.logger.warn "ImgFlow: Invalid YAML in preset file #{preset_file}: #{e.message}"
+          # Skip invalid preset files
+        end
+      end
+
+      presets
+    end
+
+    # Get a preset by name
+    # @param name [String] Preset name
+    # @return [Hash, nil] Preset data or nil if not found
+    def get_preset(name)
+      @presets[name.to_s]
+    end
+
+    # Check if a preset exists
+    # @param name [String] Preset name
+    # @return [Boolean] True if preset exists
+    def preset_exists?(name)
+      @presets.key?(name.to_s)
+    end
+
+    # Get all available preset names
+    # @return [Array<String>] Array of preset names
+    def available_presets
+      @presets.keys
+    end
+
+    # Build markup from preset (tags:value format)
+    # @param preset_name [String] Name of preset
+    # @param user_options [Hash] User-provided options that override preset values
+    # @return [String] Markup string in tags:value format
+    def build_markup_from_preset(preset_name, user_options = {})
+      preset = get_preset(preset_name)
+      return "" unless preset
+
+      # Convert YAML operations to tags:value format
+      preset_tags = yaml_to_tags(preset)
+
+      # Merge with user options (user options override preset)
+      merged_tags = merge_tags(preset_tags, user_options)
+
+      # Convert to markup string
+      tags_to_markup(merged_tags)
+    end
+
+    private
+
+    # Convert YAML operations to tags hash
+    # Note: Multiple operations of same type will have last one's values
+    # This matches the override behavior where user tags override preset tags
+    # @param preset [Hash] Preset data from YAML
+    # @return [Hash] Tags in key => value format
+    def yaml_to_tags(preset)
+      tags = {}
+      preset_operations = preset["operations"] || []
+
+      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
+        end
+      end
+
+      tags
+    end
+
+    # Merge preset tags with user options (user options override)
+    # @param preset_tags [Hash] Tags from preset
+    # @param user_options [Hash] User-provided options
+    # @return [Hash] Merged tags
+    def merge_tags(preset_tags, user_options)
+      # User options override preset tags
+      preset_tags.merge(user_options)
+    end
+
+    # Convert tags hash to markup string
+    # @param tags [Hash] Tags in key => value format
+    # @return [String] Markup string
+    def tags_to_markup(tags)
+      tags.map { |key, value| "#{key}:#{value}" }.join(" ")
+    end
+  end
+end