jekyll-imgflow 0.3.2 → 0.4.0

data/lib/jekyll-imgflow/parser.rb

@@ -110,44 +110,51 @@ module JekyllImgFlow
       operations = []
       operation_options = options.slice(*OPERATION_PARAMS)
 
-      # Handle crop+resize combination (needs sequential processing)
-      has_crop = operation_options[:ratio] || operation_options[:aspect_ratio]
-      has_resize = operation_options[:width] || operation_options[:height]
+      add_crop_resize_operations(operations, operation_options)
+      add_simple_operations(operations, operation_options)
+      add_format_operation(operations, operation_options)
+      add_optimize_operation(operations, operation_options)
+
+      operations
+    end
+
+    def self.add_crop_resize_operations(operations, opts)
+      has_crop = opts[:ratio] || opts[:aspect_ratio]
+      has_resize = opts[:width] || opts[:height]
+      crop_params = opts.slice(:ratio, :aspect_ratio, :keep, :position)
 
       if has_crop && has_resize
-        crop_params = operation_options.slice(:ratio, :aspect_ratio, :keep, :position)
-        resize_params = operation_options.except(:ratio, :aspect_ratio, :keep, :position)
         operations << { type: :crop, params: crop_params }
-        operations << { type: :resize, params: resize_params }
+        operations << { type: :resize, params: opts.except(:ratio, :aspect_ratio, :keep, :position) }
       elsif has_crop
-        crop_params = operation_options.slice(:ratio, :aspect_ratio, :keep, :position)
         operations << { type: :crop, params: crop_params }
       elsif has_resize
-        operations << { type: :resize, params: operation_options }
+        operations << { type: :resize, params: opts }
       end
+    end
 
-      # Add simple operations using mappings
+    def self.add_simple_operations(operations, opts)
       SIMPLE_OPERATIONS.each do |key, builder|
-        operations << builder.call(operation_options[key]) if operation_options[key]
+        operations << builder.call(opts[key]) if opts[key]
       end
+    end
 
-      # Handle format operation (can be array or single value)
-      if operation_options[:format] || operation_options[:formats]
-        format_value = operation_options[:format] || operation_options[:formats]
-        operations << if format_value.is_a?(Array)
-                        { type: :format, params: { formats: format_value } }
-                      else
-                        { type: :format, params: { format: format_value } }
-                      end
-      end
+    def self.add_format_operation(operations, opts)
+      return unless opts[:format] || opts[:formats]
 
-      # Handle optimize operation
-      if operation_options[:optimize] || operation_options[:level]
-        operations << { type: :optimize,
-                        params: { level: operation_options[:level] || :medium } }
-      end
+      format_value = opts[:format] || opts[:formats]
+      operations << if format_value.is_a?(Array)
+                      { type: :format, params: { formats: format_value } }
+                    else
+                      { type: :format, params: { format: format_value } }
+                    end
+    end
 
-      operations
+    def self.add_optimize_operation(operations, opts)
+      return unless opts[:optimize] || opts[:level]
+
+      operations << { type: :optimize,
+                      params: { level: opts[:level] || :medium } }
     end
 
     def self.extract_html_attributes(options)

data/lib/jekyll-imgflow/picture_tag_adaptor.rb

@@ -16,26 +16,19 @@ module JekyllImgFlow
       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
+      "{% imgflow #{[result[:markup], *translated_attributes(result[:attributes]), '%}'].join(' ')}"
+    end
 
-      if result[:attributes][:picture]&.any?
-        result[:attributes][:picture].each do |name, value|
-          tag_parts << "picture-#{name}:\"#{value}\""
-        end
-      end
+    def translated_attributes(attributes)
+      parts = []
+      parts << "alt:\"#{attributes[:alt]}\"" if attributes[:alt]
+      parts.concat(prefixed_attributes(attributes[:img], "img"))
+      parts.concat(prefixed_attributes(attributes[:picture], "picture"))
+      parts
+    end
 
-      tag_parts << "%}"
-      tag_parts.join(" ")
+    def prefixed_attributes(attributes, prefix)
+      attributes.to_h.map { |name, value| "#{prefix}-#{name}:\"#{value}\"" }
     end
 
     # Convert Picture Tag markup to ImgFlow markup with HTML attributes
@@ -57,17 +50,9 @@ module JekyllImgFlow
       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
+      imgflow_parts = translated_parts(categorized)
       {
-        markup: imgflow_parts.compact.join(" "),
+        markup: imgflow_parts.join(" "),
         attributes: categorized[:html_attributes],
         markup_format: categorized[:markup_format]
       }
@@ -75,6 +60,16 @@ module JekyllImgFlow
 
     private
 
+    def translated_parts(categorized)
+      parts = [categorized[:image]]
+      parts.concat(translate_media_queries(categorized[:media_queries]))
+      parts.concat(translate_operations(categorized[:operations]))
+      parts << "formats:webp,jpg" unless formats?(parts)
+      format = categorized[:markup_format]
+      parts << "markup:#{format}" if format && format != "auto"
+      parts.compact
+    end
+
     def extract_picture_content(markup)
       offset = 0
       while (opening = markup.index("{%", offset))
@@ -105,37 +100,43 @@ module JekyllImgFlow
     # @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
+      state = { args: [], current: +"", in_quotes: false, quote_char: nil }
+      content.each_char { |char| consume_argument_character(state, char) }
+      state[:args] << state[:current].dup unless state[:current].empty?
+      state[:args]
+    end
+
+    def consume_argument_character(state, char)
+      if quote_character?(char)
+        consume_quote(state, char)
+      elsif char == " " && !state[:in_quotes]
+        append_argument(state)
+      else
+        state[:current] << char
+      end
+    end
+
+    def quote_character?(char)
+      ["\"", "'"].include?(char)
+    end
+
+    def consume_quote(state, char)
+      if !state[:in_quotes]
+        state[:in_quotes] = true
+        state[:quote_char] = char
+      elsif char == state[:quote_char]
+        state[:in_quotes] = false
+        state[:quote_char] = nil
+      else
+        state[:current] << char
       end
+    end
+
+    def append_argument(state)
+      return if state[:current].empty?
 
-      args << current.dup unless current.empty?
-      args
+      state[:args] << state[:current].dup
+      state[:current] = +""
     end
 
     # Categorize arguments into types
@@ -149,59 +150,65 @@ module JekyllImgFlow
         html_attributes: default_html_attributes,
         markup_format: nil
       }
+      index = 0
+      index = categorize_argument(args, result, index) while index < args.length
+      result
+    end
 
-      i = 0
-      while i < args.length
-        arg = args[i]
+    def categorize_argument(args, result, index)
+      arg = args[index]
+      return parse_alt_argument(args, result, index) if arg == "--alt"
+      return parse_link_argument(args, result, index) if arg == "--link"
+      return parse_element_arguments(args, result, index) if arg.match?(/^--(img|picture|source|a|parent)$/)
+      return parse_media_argument(args, result, index) if arg.match?(/(mobile|tablet|desktop):/)
 
-        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
+      categorize_simple_argument(arg, result)
+      index + 1
+    end
 
-        i += 1
-      end
+    def parse_alt_argument(args, result, index)
+      values, next_index = values_until_option(args, index + 1)
+      result[:html_attributes][:alt] = strip_quotes(values.join(" "))
+      next_index
+    end
 
-      result
+    def parse_link_argument(args, result, index)
+      result[:html_attributes][:link] = strip_quotes(args[index + 1]) if args[index + 1]
+      index + 2
+    end
+
+    def parse_element_arguments(args, result, index)
+      element = args[index].match(/^--(img|picture|source|a|parent)$/)[1].to_sym
+      values, next_index = values_until_option(args, index + 1)
+      values.each { |value| parse_element_attribute(value, result[:html_attributes][element]) }
+      next_index
+    end
+
+    def values_until_option(args, index)
+      start = index
+      index += 1 while index < args.length && !args[index].start_with?("--")
+      [args[start...index], index]
+    end
+
+    def parse_media_argument(args, result, index)
+      device = args[index].match(/(mobile|tablet|desktop):/)[1]
+      image = args[index + 1]
+      return index + 1 unless image&.include?(".")
+
+      crop = parse_crop_from_arg(args[index + 2])
+      result[:media_queries][device] = { image: image, crop: crop }
+      index + 2 + (crop ? 1 : 0)
+    end
+
+    def categorize_simple_argument(arg, result)
+      case arg
+      when /^(auto|data_auto|picture|img)$/
+        result[:markup_format] = arg
+      when /\./
+        result[:image] ||= arg unless arg.include?(":")
+      else
+        result[:operations] << arg unless arg.start_with?("--")
+      end
     end
 
     # Translate media queries to ImgFlow crop syntax

data/lib/jekyll-imgflow/picture_tag_preset_migrator.rb

@@ -99,61 +99,11 @@ module JekyllImgFlow
     # @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
+      add_resize_operation(operations, preset_data)
+      add_quality_operation(operations, preset_data)
+      add_format_operation(operations, preset_data)
+      add_crop_operation(operations, preset_data)
+      add_position_operation(operations, preset_data)
 
       return if operations.empty?
 
@@ -171,30 +121,84 @@ module JekyllImgFlow
       }
     end
 
+    def add_resize_operation(operations, preset_data)
+      width = preset_width(preset_data)
+      operations << { "resize" => { "width" => width } } if width
+
+      return unless preset_data["height"]
+
+      if operations.any? && operations.last["resize"]
+        operations.last["resize"]["height"] = preset_data["height"]
+      else
+        operations << { "resize" => { "height" => preset_data["height"] } }
+      end
+    end
+
+    def preset_width(preset_data)
+      return Array(preset_data["widths"]).max if preset_data["widths"]
+      return preset_data["base_width"] if preset_data["base_width"]
+
+      preset_data["width"] if preset_data["width"]
+    end
+
+    def add_quality_operation(operations, preset_data)
+      return unless preset_data["quality"]
+
+      operations << { "quality" => { "quality" => preset_data["quality"] } }
+    end
+
+    def add_format_operation(operations, preset_data)
+      return unless preset_data["formats"]
+
+      formats = Array(preset_data["formats"]).map do |format|
+        format == "original" ? "jpg" : format
+      end
+      operations << { "format" => { "formats" => formats } }
+    end
+
+    def add_crop_operation(operations, preset_data)
+      ratio_value = preset_data["ratio"] || preset_data["aspect_ratio"] || preset_data["crop"]
+      operations << { "crop" => { "ratio" => ratio_value } } if ratio_value
+    end
+
+    def add_position_operation(operations, preset_data)
+      position_value = preset_data["position"] || preset_data["gravity"]
+      return unless position_value
+
+      crop_op = operations.find { |op| op["crop"] }
+      if crop_op
+        crop_op["crop"]["position"] = position_value
+      else
+        operations << { "crop" => { "position" => position_value } }
+      end
+    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 = []
+      parts = []
+      add_width_description(parts, preset_data)
+      parts << "height: #{preset_data['height']}" if preset_data["height"]
+      parts << "quality: #{preset_data['quality']}" if preset_data["quality"]
+      parts << "formats: #{Array(preset_data['formats']).join(',')}" if preset_data["formats"]
+      parts << "crop: #{preset_data['crop']}" if preset_data["crop"]
+      parts << "gravity: #{preset_data['gravity']}" if preset_data["gravity"]
+
+      "Migrated from Picture Tag preset '#{preset_name}'. #{parts.join(', ')}"
+    end
 
+    def add_width_description(parts, preset_data)
       if preset_data["widths"]
-        operations << "widths: #{Array(preset_data['widths']).join(',')}"
-        operations << "using max width: #{Array(preset_data['widths']).max}"
+        parts << "widths: #{Array(preset_data['widths']).join(',')}"
+        parts << "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(',')}"
+        parts << "base_width: #{preset_data['base_width']}"
+        parts << "pixel_ratios: #{Array(preset_data['pixel_ratios']).join(',')}"
       elsif preset_data["width"]
-        operations << "width: #{preset_data['width']}"
+        parts << "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

data/lib/jekyll-imgflow/preset_manager.rb

@@ -132,55 +132,59 @@ module JekyllImgFlow
     # @return [Hash] Tags in key => value format
     def yaml_to_tags(preset)
       tags = {}
-      preset_operations = preset["operations"] || []
-
-      preset_operations.each do |op|
+      (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
+          merge_operation_tags(tags, op_type.to_s, params)
         end
       end
 
       tags
     end
 
+    def merge_operation_tags(tags, op_type, params)
+      case op_type
+      when "resize"
+        tags[:width] = params["width"] if params["width"]
+        tags[:height] = params["height"] if params["height"]
+      when "crop"
+        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"
+        merge_format_tag(tags, params)
+      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
+        merge_generic_tags(tags, params)
+      end
+    end
+
+    def merge_format_tag(tags, params)
+      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
+    end
+
+    def merge_generic_tags(tags, params)
+      params.each do |key, value|
+        tag_value = value.is_a?(Array) ? value.join(",") : value
+        tags[key.to_sym] = tag_value
+      end
+    end
+
     # Merge preset tags with user options (user options override)
     # @param preset_tags [Hash] Tags from preset
     # @param user_options [Hash] User-provided options