module ImageProcessing::Chainable

Implements a chainable interface for building processing options.

Constants

DEFAULT_OPTIONS

Empty options which the builder starts with.

Public Instance Methods

apply(operations) click to toggle source

Add multiple operations as a hash or an array.

.apply(resize_to_limit: [400, 400], strip: true)
# or
.apply([[:resize_to_limit, [400, 400]], [:strip, true])
# File lib/image_processing/chainable.rb, line 34
def apply(operations)
  operations.inject(self) do |builder, (name, argument)|
    if argument == true || argument == nil
      builder.public_send(name)
    elsif argument.is_a?(Array)
      builder.public_send(name, *argument)
    elsif argument.is_a?(Hash)
      builder.public_send(name, **argument)
    else
      builder.public_send(name, argument)
    end
  end
end
branch(**new_options) click to toggle source

Creates a new builder object, merging current options with new options.

# File lib/image_processing/chainable.rb, line 64
def branch(**new_options)
  if self.is_a?(Builder)
    options = self.options
  else
    options = DEFAULT_OPTIONS.merge(processor: self::Processor)
  end

  options = options.merge(new_options) do |key, old_value, new_value|
    case key
    when :loader, :saver then old_value.merge(new_value)
    when :operations     then old_value + new_value
    else                      new_value
    end
  end

  Builder.new(options.freeze)
end
call(file = nil, destination: nil, **call_options) click to toggle source

Call the defined processing and get the result. Allows specifying the source file and destination.

# File lib/image_processing/chainable.rb, line 55
def call(file = nil, destination: nil, **call_options)
  options = {}
  options[:source] = file if file
  options[:destination] = destination if destination

  branch(**options).call!(**call_options)
end
convert(format) click to toggle source

Specify the output format.

# File lib/image_processing/chainable.rb, line 10
def convert(format)
  branch format: format
end
instrumenter(&block) click to toggle source

Register instrumentation block that will be called around the pipeline.

# File lib/image_processing/chainable.rb, line 25
def instrumenter(&block)
  branch instrumenter: block
end
loader(**options) click to toggle source

Specify processor options applied when loading the image.

# File lib/image_processing/chainable.rb, line 15
def loader(**options)
  branch loader: options
end
operation(name, *args, &block) click to toggle source

Add an operation defined by the processor.

# File lib/image_processing/chainable.rb, line 49
def operation(name, *args, &block)
  branch operations: [[name, args, *block]]
end
saver(**options) click to toggle source

Specify processor options applied when saving the image.

# File lib/image_processing/chainable.rb, line 20
def saver(**options)
  branch saver: options
end
source(file) click to toggle source

Specify the source image file.

# File lib/image_processing/chainable.rb, line 5
def source(file)
  branch source: file
end

Private Instance Methods

method_missing(name, *args, &block) click to toggle source

Assume that any unknown method names an operation supported by the processor. Add a bang (“!”) if you want processing to be performed.

Calls superclass method
# File lib/image_processing/chainable.rb, line 86
def method_missing(name, *args, &block)
  return super if name.to_s.end_with?("?")
  return send(name.to_s.chomp("!"), *args, &block).call if name.to_s.end_with?("!")

  operation(name, *args, &block)
end