Class: JekyllImgFlow::OperationProcessor

Inherits:
Object
  • Object
show all
Defined in:
lib/jekyll-imgflow/operation_processor.rb

Overview

OperationProcessor - processes image operations using providers Handles both single operations and batch operations

Instance Method Summary collapse

Constructor Details

#initialize(provider, path_resolver, manifest = nil, config = nil) ⇒ OperationProcessor

Returns a new instance of OperationProcessor.



9
10
11
12
13
14
15
 
# File 'lib/jekyll-imgflow/operation_processor.rb', line 9

def initialize(provider, path_resolver, manifest = nil, config = nil)
  @provider = provider
  @path_resolver = path_resolver
  @filename_generator = FilenameGenerator.new
  @manifest = manifest
  @config = config
end

Instance Method Details

#build_operation_from_params(params) ⇒ Hash

Build operation structure from params hash Combines all params into a single operation with flat params

Parameters:

  • params (Hash) —

    Parameters hash

Returns:

  • (Hash) —

    Operation structure { type: :resize, params: { ... } }



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/jekyll-imgflow/operation_processor.rb', line 150

def build_operation_from_params(params)
  # Determine primary operation type
  type = if params[:width] || params[:height]
           :resize
         elsif params[:crop]
           :crop
         elsif params[:watermark]
           :watermark
         else
           :format
         end

  # Return unified operation structure with all params flattened
  {
    type: type,
    params: params.compact
  }
end

#build_operations_from_params(tag_params) ⇒ Array<Hash>

Build operations array from tag parameters

Parameters:

  • tag_params (Hash) —

    Parameters from tag

Returns:

  • (Array<Hash>) —

    Array of operation hashes



172
173
174
 
# File 'lib/jekyll-imgflow/operation_processor.rb', line 172

def build_operations_from_params(tag_params)
  [build_operation_from_params(tag_params)]
end

#determine_version_type(params) ⇒ Symbol

Determine if operations represent default or specialized version

Parameters:

  • params (Hash) —

    Operation parameters

Returns:

  • (Symbol) —

    :default or :specialized



179
180
181
 
# File 'lib/jekyll-imgflow/operation_processor.rb', line 179

def determine_version_type(params)
  @config&.determine_version_type(params) || :specialized
end

#needs_processing?(input_path, output_path, operations) ⇒ Boolean

Check if operation needs to be processed (cache check)

Parameters:

  • input_path (String) —

    Path to input image

  • output_path (String) —

    Path to output image

  • operations (Hash) —

    Operations to apply

Returns:

  • (Boolean) —

    True if processing needed



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/jekyll-imgflow/operation_processor.rb', line 124

def needs_processing?(input_path, output_path, operations)
  # If output doesn't exist, needs processing
  return true unless File.exist?(output_path)

  # If input is newer than output, needs processing
  return true if File.mtime(input_path) > File.mtime(output_path)

  # Check if operations changed by comparing cache key
  # stored alongside the output file
  cache_key = @filename_generator.generate_cache_key(operations)
  cache_file = "#{output_path}.cache_key"

  return true unless File.exist?(cache_file)

  stored_key = File.read(cache_file).strip
  return true if stored_key != cache_key

  # No cache key file - needs processing to create it

  false
end

#process_batch_operations(operations, input_path, final_output_path) ⇒ String

Process multiple operations on an image in sequence (batch)

Parameters:

  • operations (Array<Hash>) —

    Array of operations to process

  • input_path (String) —

    Path to input image

  • final_output_path (String) —

    Path to final output image

Returns:

  • (String) —

    Path to final processed image



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/jekyll-imgflow/operation_processor.rb', line 84

def process_batch_operations(operations, input_path, final_output_path)
  return input_path if operations.empty?

  current_input = input_path
  temp_files = []

  begin
    # Process each operation in sequence
    operations.each_with_index do |operation, index|
      operation_type = operation[:type]
      params = operation[:params] || {}

      # Determine output path
      if index == operations.length - 1
        # Last operation - use final output path
        output_path = final_output_path
      else
        # Intermediate operation - use temp file
        format = params[:format] || File.extname(input_path).delete(".")
        output_path = @path_resolver.temp_output_path(format)
        temp_files << output_path
      end

      # Process the operation
      current_input = process_single_operation(operation_type, current_input,
                                               output_path, params)
    end

    current_input
  ensure
    # Cleanup temp files even on failure
    temp_files.each { |f| FileUtils.rm_f(f) }
  end
end

#process_operation(original_name, operation, input_path, page_path = nil) ⇒ String

Process an operation and return the output path

Parameters:

  • original_name (String) —

    Original image filename

  • operation (Hash) —

    Operation structure { type: :resize, params: { width: 800 } }

  • input_path (String) —

    Path to input image

  • page_path (String) (defaults to: nil) —

    Optional page path for manifest tracking

Returns:

  • (String) —

    Path to processed image



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/jekyll-imgflow/operation_processor.rb', line 41

def process_operation(original_name, operation, input_path, page_path = nil)
  type = operation[:type]
  params = operation[:params]

  # Generate filename using FilenameGenerator (JPT compatible)
  filename = @filename_generator.generate_filename(input_path, params)
  # Write to _site during build (after Jekyll copies assets)
  actual_output_path = @path_resolver.resolve_output_path(filename)

  # Determine version type
  version_type = determine_version_type(params)

  # Ensure output directory exists before processing
  FileUtils.mkdir_p(File.dirname(actual_output_path))

  # Process the operation (create the image)
  process_single_operation(type, input_path, actual_output_path, params)

  # Register in manifest
  if @manifest
    # Convert absolute path to relative for manifest storage
    relative_path = actual_output_path.sub(@path_resolver.site_dest, "")

    provider_name = @provider.class.provider_name
    @manifest.register_version(
      original_name,
      relative_path,
      params,
      version_type,
      page_path,
      nil, # file_digest
      provider_name
    )
  end

  actual_output_path
end

#process_single_operation(operation_type, input_path, output_path, params) ⇒ String

Process a single operation on an image

Parameters:

  • operation_type (Symbol) —

    Type of operation (:resize, :crop, :quality, etc.)

  • input_path (String) —

    Path to input image

  • output_path (String) —

    Path to output image

  • params (Hash) —

    Operation parameters

Returns:

  • (String) —

    Path to processed image



23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/jekyll-imgflow/operation_processor.rb', line 23

def process_single_operation(operation_type, input_path, output_path, params)
  # Get the appropriate tag class for validation
  tag_class = JekyllImgFlow::Tags::TagRegistry.get_tag(operation_type)
  raise "Unknown operation: #{operation_type}" unless tag_class

  # Create tag instance and process
  tag = tag_class.new(@provider)
  tag.process(input_path, output_path, params)

  output_path
end