rack_resize 0.1.3 → 0.1.6

data/lib/rack_resize/color_utils.rb

@@ -0,0 +1,200 @@
+module RackResize::ColorUtils
+  extend self
+
+  CSS_COLORS = {
+    'aliceblue'            => [240, 248, 255],
+    'antiquewhite'         => [250, 235, 215],
+    'aqua'                 => [0, 255, 255],
+    'aquamarine'           => [127, 255, 212],
+    'azure'                => [240, 255, 255],
+    'beige'                => [245, 245, 220],
+    'bisque'               => [255, 228, 196],
+    'black'                => [0, 0, 0],
+    'blanchedalmond'       => [255, 235, 205],
+    'blue'                 => [0, 0, 255],
+    'blueviolet'           => [138, 43, 226],
+    'brown'                => [165, 42, 42],
+    'burlywood'            => [222, 184, 135],
+    'cadetblue'            => [95, 158, 160],
+    'chartreuse'           => [127, 255, 0],
+    'chocolate'            => [210, 105, 30],
+    'coral'                => [255, 127, 80],
+    'cornflowerblue'       => [100, 149, 237],
+    'cornsilk'             => [255, 248, 220],
+    'crimson'              => [220, 20, 60],
+    'cyan'                 => [0, 255, 255],
+    'darkblue'             => [0, 0, 139],
+    'darkcyan'             => [0, 139, 139],
+    'darkgoldenrod'        => [184, 134, 11],
+    'darkgray'             => [169, 169, 169],
+    'darkgreen'            => [0, 100, 0],
+    'darkgrey'             => [169, 169, 169],
+    'darkkhaki'            => [189, 183, 107],
+    'darkmagenta'          => [139, 0, 139],
+    'darkolivegreen'       => [85, 107, 47],
+    'darkorange'           => [255, 140, 0],
+    'darkorchid'           => [153, 50, 204],
+    'darkred'              => [139, 0, 0],
+    'darksalmon'           => [233, 150, 122],
+    'darkseagreen'         => [143, 188, 143],
+    'darkslateblue'        => [72, 61, 139],
+    'darkslategray'        => [47, 79, 79],
+    'darkslategrey'        => [47, 79, 79],
+    'darkturquoise'        => [0, 206, 209],
+    'darkviolet'           => [148, 0, 211],
+    'deeppink'             => [255, 20, 147],
+    'deepskyblue'          => [0, 191, 255],
+    'dimgray'              => [105, 105, 105],
+    'dimgrey'              => [105, 105, 105],
+    'dodgerblue'           => [30, 144, 255],
+    'firebrick'            => [178, 34, 34],
+    'floralwhite'          => [255, 250, 240],
+    'forestgreen'          => [34, 139, 34],
+    'fuchsia'              => [255, 0, 255],
+    'gainsboro'            => [220, 220, 220],
+    'ghostwhite'           => [248, 248, 255],
+    'gold'                 => [255, 215, 0],
+    'goldenrod'            => [218, 165, 32],
+    'gray'                 => [128, 128, 128],
+    'green'                => [0, 128, 0],
+    'greenyellow'          => [173, 255, 47],
+    'grey'                 => [128, 128, 128],
+    'honeydew'             => [240, 255, 240],
+    'hotpink'              => [255, 105, 180],
+    'indianred'            => [205, 92, 92],
+    'indigo'               => [75, 0, 130],
+    'ivory'                => [255, 255, 240],
+    'khaki'                => [240, 230, 140],
+    'lavender'             => [230, 230, 250],
+    'lavenderblush'        => [255, 240, 245],
+    'lawngreen'            => [124, 252, 0],
+    'lemonchiffon'         => [255, 250, 205],
+    'lightblue'            => [173, 216, 230],
+    'lightcoral'           => [240, 128, 128],
+    'lightcyan'            => [224, 255, 255],
+    'lightgoldenrodyellow' => [250, 250, 210],
+    'lightgray'            => [211, 211, 211],
+    'lightgreen'           => [144, 238, 144],
+    'lightgrey'            => [211, 211, 211],
+    'lightpink'            => [255, 182, 193],
+    'lightsalmon'          => [255, 160, 122],
+    'lightseagreen'        => [32, 178, 170],
+    'lightskyblue'         => [135, 206, 250],
+    'lightslategray'       => [119, 136, 153],
+    'lightslategrey'       => [119, 136, 153],
+    'lightsteelblue'       => [176, 196, 222],
+    'lightyellow'          => [255, 255, 224],
+    'lime'                 => [0, 255, 0],
+    'limegreen'            => [50, 205, 50],
+    'linen'                => [250, 240, 230],
+    'magenta'              => [255, 0, 255],
+    'maroon'               => [128, 0, 0],
+    'mediumaquamarine'     => [102, 205, 170],
+    'mediumblue'           => [0, 0, 205],
+    'mediumorchid'         => [186, 85, 211],
+    'mediumpurple'         => [147, 112, 219],
+    'mediumseagreen'       => [60, 179, 113],
+    'mediumslateblue'      => [123, 104, 238],
+    'mediumspringgreen'    => [0, 250, 154],
+    'mediumturquoise'      => [72, 209, 204],
+    'mediumvioletred'      => [199, 21, 133],
+    'midnightblue'         => [25, 25, 112],
+    'mintcream'            => [245, 255, 250],
+    'mistyrose'            => [255, 228, 225],
+    'moccasin'             => [255, 228, 181],
+    'navajowhite'          => [255, 222, 173],
+    'navy'                 => [0, 0, 128],
+    'oldlace'              => [253, 245, 230],
+    'olive'                => [128, 128, 0],
+    'olivedrab'            => [107, 142, 35],
+    'orange'               => [255, 165, 0],
+    'orangered'            => [255, 69, 0],
+    'orchid'               => [218, 112, 214],
+    'palegoldenrod'        => [238, 232, 170],
+    'palegreen'            => [152, 251, 152],
+    'paleturquoise'        => [175, 238, 238],
+    'palevioletred'        => [219, 112, 147],
+    'papayawhip'           => [255, 239, 213],
+    'peachpuff'            => [255, 218, 185],
+    'peru'                 => [205, 133, 63],
+    'pink'                 => [255, 192, 203],
+    'plum'                 => [221, 160, 221],
+    'powderblue'           => [176, 224, 230],
+    'purple'               => [128, 0, 128],
+    'rebeccapurple'        => [102, 51, 153],
+    'red'                  => [255, 0, 0],
+    'rosybrown'            => [188, 143, 143],
+    'royalblue'            => [65, 105, 225],
+    'saddlebrown'          => [139, 69, 19],
+    'salmon'               => [250, 128, 114],
+    'sandybrown'           => [244, 164, 96],
+    'seagreen'             => [46, 139, 87],
+    'seashell'             => [255, 245, 238],
+    'sienna'               => [160, 82, 45],
+    'silver'               => [192, 192, 192],
+    'skyblue'              => [135, 206, 235],
+    'slateblue'            => [106, 90, 205],
+    'slategray'            => [112, 128, 144],
+    'slategrey'            => [112, 128, 144],
+    'snow'                 => [255, 250, 250],
+    'springgreen'          => [0, 255, 127],
+    'steelblue'            => [70, 130, 180],
+    'tan'                  => [210, 180, 140],
+    'teal'                 => [0, 128, 128],
+    'thistle'              => [216, 191, 216],
+    'tomato'               => [255, 99, 71],
+    'turquoise'            => [64, 224, 208],
+    'violet'               => [238, 130, 238],
+    'wheat'                => [245, 222, 179],
+    'white'                => [255, 255, 255],
+    'whitesmoke'           => [248, 248, 248],
+    'yellow'               => [255, 255, 0],
+    'yellowgreen'          => [154, 205, 50],
+  }.freeze
+
+  # Returns [r, g, b, a] where r/g/b are 0-255 integers and a is a 0.0-1.0 float.
+  # Returns nil if the value cannot be parsed.
+  # Supported formats:
+  #   CSS named color: "red", "white", "cornflowerblue"
+  #   3-digit hex:     "#a84"
+  #   6-digit hex:     "#aa8844"
+  #   8-digit hex:     "#aa884480"  (last two digits = alpha 0-255)
+  #   decimal RGB:     "0,255,0"
+  #   decimal RGBA:    "0,255,0,0.5"  (alpha 0.0-1.0)
+  def parse_color(value)
+    return nil if value.nil?
+    v = value.to_s.strip.downcase
+    return nil if v.empty?
+
+    if (m = v.match(/\A#([0-9a-f])([0-9a-f])([0-9a-f])\z/))
+      return [m[1].hex * 17, m[2].hex * 17, m[3].hex * 17, 1.0]
+    end
+
+    if (m = v.match(/\A#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})\z/))
+      return [m[1].to_i(16), m[2].to_i(16), m[3].to_i(16), 1.0]
+    end
+
+    if (m = v.match(/\A#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})\z/))
+      return [m[1].to_i(16), m[2].to_i(16), m[3].to_i(16), m[4].to_i(16) / 255.0]
+    end
+
+    if CSS_COLORS.key?(v)
+      return CSS_COLORS[v] + [1.0]
+    end
+
+    if (m = v.match(/\A(\d+),(\d+),(\d+)(?:,(\d*\.?\d+))?\z/))
+      r = m[1].to_i.clamp(0, 255)
+      g = m[2].to_i.clamp(0, 255)
+      b = m[3].to_i.clamp(0, 255)
+      a = m[4] ? m[4].to_f.clamp(0.0, 1.0) : 1.0
+      return [r, g, b, a]
+    end
+
+    nil
+  end
+
+  def to_hex(bg_color)
+    r, g, b, _a = bg_color
+    "#%02x%02x%02x" % [r, g, b]
+  end
+end

data/lib/rack_resize/configuration.rb

@@ -1,7 +1,7 @@
 require 'pathname'
 
 class RackResize::Configuration
-  PROCESSORS = %i[sips vips mini_magick imlib2].freeze
+  PROCESSORS = %i[sips vips mini_magick imlib2 bun_image].freeze
 
   attr_reader :processor, :assets_folders
   attr_accessor :save_resized, :default_quality, :cache_folder, :http_cache_max_age, :max_dimension, :logger
@@ -63,8 +63,9 @@ class RackResize::Configuration
                             when :vips        then RackResize::Processors::Vips.new
                             when :sips        then RackResize::Processors::Sips.new
                             when :imlib2      then RackResize::Processors::Imlib2.new
+                            when :bun_image   then RackResize::Processors::BunImage.new
                             else
-                              raise "RackResize - Unknow image processor #{@processor.inspect}"
+                              raise "RackResize - Unknown image processor #{@processor.inspect}"
                             end
   end
 

data/lib/rack_resize/input_parsers/cloudflare.rb

@@ -9,7 +9,7 @@ module RackResize::InputParsers::Cloudflare
       return { route_matched: false, req_params: nil, asset_path: nil }
     end
 
-    fullpath = fullpath.delete_prefix("/cdn-cgi").delete_prefix("/image").delete_prefix("/")
+    fullpath = fullpath.delete_prefix(cf_path_prefix).delete_prefix("/")
     file_path_match = fullpath.match(%r{(?<params>[^\/]+)(?<file>\/.+?)(-[\da-f]{8})?(?<ext>\.\w{2,})$})
 
     return { route_matched: true, req_params: nil, asset_path: nil } unless file_path_match

data/lib/rack_resize/input_parsers/imgproxy.rb

@@ -0,0 +1,71 @@
+module RackResize::InputParsers::Imgproxy
+  extend self
+
+  # Supports imgproxy URL formats:
+  # /insecure/rs:fill:400:300/q:85/f:webp/plain/local:///assets/photo.jpg
+  # /insecure/rs:fit:200:150/plain/local:///assets/banner.jpg@webp
+  # /my-sig-123/w:400/h:300/q:80/plain/assets/photo.png
+  # /insecure/plain/local:///assets/photo.jpg@avif
+
+  REGEX = %r{\A/(?<signature>[^/]+)/(?:(?<options>(?:[a-z_]+:[^/]+/)*))plain/(?:local:///?|https?://[^/]+/)?(?<path>[^@\s]+?)(?:@(?<format>\w+))?\z}i
+
+  def parse_input(fullpath)
+    match = fullpath.to_s.match(REGEX)
+    return { route_matched: false, req_params: nil, asset_path: nil } unless match
+
+    req_params = {}
+
+    if match[:options]
+      match[:options].split("/").each do |part|
+        next if part.empty?
+        type, *args = part.split(":")
+        case type.downcase
+        when "rs", "resize"
+          # rs:<type>:<width>:<height>:<enlarge>:<extend>
+          req_params[:fit]    = map_fit(args[0]) if args[0] && !args[0].empty?
+          req_params[:width]  = args[1] if args[1] && !args[1].empty? && args[1] != "0"
+          req_params[:height] = args[2] if args[2] && !args[2].empty? && args[2] != "0"
+        when "w", "width"
+          req_params[:width] = args[0] if args[0] && !args[0].empty?
+        when "h", "height"
+          req_params[:height] = args[0] if args[0] && !args[0].empty?
+        when "dpr"
+          req_params[:dpr] = args[0] if args[0] && !args[0].empty?
+        when "q", "quality"
+          req_params[:quality] = args[0] if args[0] && !args[0].empty?
+        when "f", "format", "ext"
+          req_params[:format] = args[0] if args[0] && !args[0].empty?
+        when "bg", "background"
+          req_params[:background] = args.join(":") if args.any?
+        when "fit"
+          req_params[:fit] = map_fit(args[0]) if args[0] && !args[0].empty?
+        end
+      end
+    end
+
+    if match[:format]
+      req_params[:format] = match[:format]
+    end
+
+    raw_path = match[:path]
+    raw_path = "/" + raw_path unless raw_path.start_with?("/")
+    asset_path = raw_path.sub(/-[\da-f]{8}(?=\.\w{2,}$)/, "")
+
+    { route_matched: true, req_params: req_params, asset_path: asset_path }
+  end
+
+  private
+
+  def map_fit(val)
+    case val.to_s.downcase
+    when "fill", "fill-down", "cover"
+      "cover"
+    when "fit", "contain"
+      "contain"
+    when "force"
+      "fill"
+    else
+      val
+    end
+  end
+end

data/lib/rack_resize/input_parsers/query_string.rb

@@ -0,0 +1,30 @@
+module RackResize::InputParsers::QueryString
+  extend self
+
+  # Supports Fastly and bunny.net style query params:
+  # /assets/photo.jpg?width=200&height=100&quality=85&fit=cover
+  # /assets/photo.jpg?w=200&h=100&dpr=2&format=webp
+  # /assets/photo.jpg?w=200&f=webp&q=80&fit=contain
+  #
+  # Shortcuts: f=format, q=quality
+
+  CANONICAL_PARAMS = %w[width height quality dpr format fit bg-color background].freeze
+  PARAM_ALIASES    = { 'f' => :format, 'q' => :quality, 'h' => :height, 'w' => :width, 'bg' => :'bg-color' }.freeze
+  RESIZE_PARAMS    = (CANONICAL_PARAMS + PARAM_ALIASES.keys).freeze
+
+  def parse_input(fullpath, query_string)
+    params = Rack::Utils.parse_query(query_string.to_s)
+
+    unless params.keys.any? { |k| RESIZE_PARAMS.include?(k) }
+      return { route_matched: false, req_params: nil, asset_path: nil }
+    end
+
+    # Aliases are applied first; canonical names overwrite them if both are present.
+    aliased   = params.slice(*PARAM_ALIASES.keys).transform_keys { |k| PARAM_ALIASES[k] }
+    canonical = params.slice(*CANONICAL_PARAMS).transform_keys(&:to_sym)
+    req_params = aliased.merge(canonical)
+    asset_path = fullpath.sub(/-[\da-f]{8}(?=\.\w{2,}$)/, '')
+
+    { route_matched: true, req_params:, asset_path: }
+  end
+end

data/lib/rack_resize/processing.rb

@@ -1,4 +1,5 @@
 require 'digest'
+require 'fileutils'
 
 class RackResize::Processing
   attr_reader :config
@@ -9,7 +10,9 @@ class RackResize::Processing
 
   def process!(source_file:, req_params:)
     if config.save_resized?
-      tmp_file_name = config.cache_folder.join(Digest::MD5.hexdigest(source_file.to_s) + File.extname(source_file))
+      cache_key = Digest::MD5.hexdigest("#{source_file}:#{req_params.to_a.sort.to_s}")
+      output_ext = output_extension(source_file, req_params[:format])
+      tmp_file_name = config.cache_folder.join(cache_key + output_ext)
       FileUtils.mkdir_p(tmp_file_name.dirname)
 
       unless tmp_file_name.exist?
@@ -17,7 +20,12 @@ class RackResize::Processing
       end
 
       logger.info("Serving cached file #{tmp_file_name}")
-      return StringIO.new(File.open(tmp_file_name.to_s, "rb", &:read))
+      begin
+        return StringIO.new(File.open(tmp_file_name.to_s, "rb", &:read))
+      rescue Errno::ENOENT
+        process_file(req_params:, source_file:, target_file: tmp_file_name.to_s)
+        return StringIO.new(File.open(tmp_file_name.to_s, "rb", &:read))
+      end
     else
       file_content = process_file(req_params:, source_file:, target_file: nil)
       return StringIO.new(file_content)
@@ -26,15 +34,20 @@ class RackResize::Processing
 
   def process_file(source_file:, req_params:, target_file: nil)
     dpr = req_params[:dpr]&.to_f || 1.0
-    dpr = [[dpr, 0.1].max, 10.0].min
+    dpr = dpr.clamp(0.1, 10.0)
 
     max = config.max_dimension.to_f
     target_width  = (req_params[:w]&.to_i || req_params[:width]&.to_i)&.*(dpr)&.clamp(1, max)
     target_height = (req_params[:h]&.to_i || req_params[:height]&.to_i)&.*(dpr)&.clamp(1, max)
 
+    fit      = req_params[:fit]
+    format   = req_params[:format].then { |f| f == 'auto' ? nil : f }
+    quality  = req_params[:quality]&.to_i&.clamp(1, 100)
+    bg_color = RackResize::ColorUtils.parse_color(req_params[:"bg-color"] || req_params[:background])
+
     start_time = Time.now
     begin
-      return config.processor_instance.resize(source_file:, target_file:, target_width:, target_height:)
+      return config.processor_instance.resize(source_file:, target_file:, target_width:, target_height:, fit:, format:, quality:, bg_color:)
     ensure
       processing_time = (Time.now.to_f - start_time.to_f).round(3)
       logger.info("RESIZE IMAGE #{config.processor} #{source_file} - #{req_params} - #{processing_time}s")
@@ -44,6 +57,13 @@ class RackResize::Processing
   def logger
     config.logger ||
       (defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger) ||
-      (require('logger') && Logger.new(STDOUT))
+      (@_logger ||= (require 'logger'; Logger.new($stdout)))
+  end
+
+  private
+
+  def output_extension(source_file, format)
+    return File.extname(source_file) if format.nil?
+    ".#{format.to_s.downcase}"
   end
 end

data/lib/rack_resize/processors/bun_image.js

@@ -0,0 +1,34 @@
+const opts = JSON.parse(Bun.argv[2]);
+const { source, target, width, height, format, quality, fit } = opts;
+
+let img = Bun.file(source).image();
+
+if (width && height) {
+  img = img.resize(width, height, { fit: fit === "fill" ? "fill" : "inside" });
+} else if (width) {
+  img = img.resize(width);
+} else if (height) {
+  // Bun.Image lacks height-only resize; derive width from source aspect ratio.
+  const meta = await img.metadata();
+  const w = Math.max(1, Math.round((meta.width * height) / meta.height));
+  img = new Bun.Image(source).resize(w, height, { fit: "inside" });
+}
+
+const q = quality ?? 85;
+const outFmt = (format || source.split(".").pop()).toLowerCase();
+
+switch (outFmt) {
+  case "jpg":
+  case "jpeg": img = img.jpeg({ quality: q }); break;
+  case "png":  img = img.png(); break;
+  case "webp": img = img.webp({ quality: q }); break;
+  case "avif": img = img.avif({ quality: q }); break;
+  case "heic": img = img.heic({ quality: q }); break;
+  default: throw new Error(`unsupported format: ${outFmt}`);
+}
+
+if (target) {
+  await img.write(target);
+} else {
+  process.stdout.write(await img.bytes());
+}

data/lib/rack_resize/processors/bun_image.rb

@@ -0,0 +1,42 @@
+require "open3"
+require "json"
+require "tempfile"
+
+class RackResize::Processors::BunImage
+  SCRIPT = File.expand_path("bun_image.js", __dir__)
+
+  def resize(source_file:, target_width:, target_height:, target_file: nil, fit: nil, format: nil, quality: nil, bg_color: nil)
+    quality ||= RackResize.config.default_quality
+    cover = (fit == 'cover' || fit == 'crop') && target_width && target_height
+
+    # ponytail: Bun.Image has no crop/extract yet, so `cover` falls back to `fill`
+    # (stretches to exact dims). Upgrade when Bun ships extract() or fit:"cover".
+    bun_fit = cover ? 'fill' : 'inside'
+
+    payload = {
+      source:  source_file.to_s,
+      target:  target_file&.to_s,
+      width:   target_width&.to_i,
+      height:  target_height&.to_i,
+      format:  format && (format.to_s.downcase == 'jpg' ? 'jpeg' : format.to_s.downcase),
+      quality: quality&.to_i,
+      fit:     bun_fit,
+    }
+
+    if target_file
+      run_bun(payload)
+      nil
+    else
+      out, err, status = Open3.capture3("bun", SCRIPT, JSON.generate(payload))
+      raise "bun_image failed: #{err}" unless status.success?
+      out
+    end
+  end
+
+  private
+
+  def run_bun(payload)
+    _, err, status = Open3.capture3("bun", SCRIPT, JSON.generate(payload))
+    raise "bun_image failed: #{err}" unless status.success?
+  end
+end

data/lib/rack_resize/processors/imlib2.rb

@@ -6,14 +6,51 @@ end
 
 class RackResize::Processors::Imlib2
 
-  def resize(source_file:, target_file:, target_width:, target_height:)
+  def resize(source_file:, target_file:, target_width:, target_height:, fit: nil, format: nil, quality: nil, bg_color: nil)
+    quality ||= RackResize.config.default_quality
+    cover = (fit == 'cover' || fit == 'crop') && target_width && target_height
+
     image = Rszr::Image.load(source_file)
-    image.resize!(target_width || :auto, target_height || :auto) if target_width || target_height
+
+    if target_width || target_height
+      if cover
+        target_w = target_width.to_i
+        target_h = target_height.to_i
+        src_w    = image.width
+        src_h    = image.height
+
+        if target_w.to_f / src_w >= target_h.to_f / src_h
+          image.resize!(target_w, :auto)
+          crop_y = [(image.height - target_h) / 2, 0].max
+          image.crop!(0, crop_y, target_w, target_h)
+        else
+          image.resize!(:auto, target_h)
+          crop_x = [(image.width - target_w) / 2, 0].max
+          image.crop!(crop_x, 0, target_w, target_h)
+        end
+      else
+        image.resize!(target_width || :auto, target_height || :auto)
+      end
+    end
+
+    out_format = rszr_format(format || source_file.to_s)
 
     if target_file
       image.save(target_file)
+      nil
     else
-      image.save_data(format: source_file.to_s =~ /\.png$/ ? :png : :jpeg)
+      image.save_data(format: out_format, quality: quality)
+    end
+  end
+
+  private
+
+  def rszr_format(format_or_path)
+    case format_or_path.to_s.downcase
+    when /\.png$/, 'png'   then :png
+    when /\.webp$/, 'webp' then :webp
+    when /\.gif$/, 'gif'   then :gif
+    else :jpeg
     end
   end
 end

data/lib/rack_resize/processors/mini_magick.rb

@@ -4,18 +4,29 @@ rescue LoadError
   raise LoadError, "RackResize::Processors::MiniMagick requires the image_processing gem. Please add `gem \"image_processing\"` to your Gemfile."
 end
 
-# require 'mini_magick'
-# MiniMagick.logger.level = :debug
-
 class RackResize::Processors::MiniMagick
 
-  def resize(source_file:, target_width:, target_height:, target_file: nil)
+  def resize(source_file:, target_width:, target_height:, target_file: nil, fit: nil, format: nil, quality: nil, bg_color: nil)
+    quality ||= RackResize.config.default_quality
+    cover = (fit == 'cover' || fit == 'crop') && target_width && target_height
+
     image = ImageProcessing::MiniMagick.source(source_file)
-    image = image.resize_to_limit(target_width, target_height) if target_width || target_height
-    image = image.saver(quality: RackResize.config.default_quality)
+    image = image.convert(format) if format
+
+    if target_width || target_height
+      image = cover ? image.resize_to_fill(target_width, target_height)
+                    : image.resize_to_limit(target_width, target_height)
+    end
+
+    if bg_color
+      image = image.background(RackResize::ColorUtils.to_hex(bg_color)).flatten
+    end
+
+    image = image.saver(quality: quality)
 
     if target_file
       image.call(destination: target_file)
+      nil
     else
       begin
         tmp_file = image.call
@@ -25,23 +36,4 @@ class RackResize::Processors::MiniMagick
       end
     end
   end
-
-  def resize_mm(source_file:, target_width:, target_height:, target_file: nil)
-    image = MiniMagick::Image.open(source_file)
-    image.combine_options do |img|
-      img.resize("#{target_width}x#{target_height}>") if target_width || target_height
-      img.quality(RackResize.config.default_quality)
-
-      if target_file
-        img.write(target_file)
-      end
-    end
-
-    unless target_file
-      return File.open(image.path, 'rb', &:read)
-    end
-
-  ensure
-    image&.destroy!
-  end
 end