rack_resize 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b93d3745135960f5c03fdec90f2104d5cf399d1bd67c248f16c8dd3061429c15
-  data.tar.gz: c228aa468fce0696ec89889b616b326a28d92e0e411937167f94578de242e802
+  metadata.gz: aaecfcc4b1f54da6b128ae9fe7939db1676ab6069a0c15bbedaab5545c74a413
+  data.tar.gz: f7c136233b7a6bbed40c40fca10399139f30ab3393857851690f05593d2b44b4
 SHA512:
-  metadata.gz: 4dfbd29c0d898694cb4f239a03a812d937dce5fd76b829faaea9587b12acb5c6406f926ec310bc9c26a2b8fc123e7bb3c2a5fa788132a21f3d84253a6165f0e4
-  data.tar.gz: fa392a88e4dd71fc7b4d9f07e200adc67dea702c944d914f4c6808d871a5c785b73509f967dbe76eed0b00f3ca4d4a5c20f86591d9ec381bcbe17482317225c7
+  metadata.gz: 66afe23035cedbf3b32723375b16c75351e1b9d2c6907fa7989b80452181d102b76c719cea27261587e67331739ece84c68c62682791769d4a2c053c36e7d404
+  data.tar.gz: 0b6a7229f59709ca20b55ebeb0efd17cbf9ef8269410a1ae25a6479edb43e90a35294a5930c9d748aba4e5bc8f1bafb313e5a35fc3fd9dd2ce51544ba4a71bef

data/.github/workflows/test.yml

@@ -19,7 +19,7 @@ jobs:
       - name: Install package
         run: |
           sudo apt-get update
-          sudo apt-get install -y libvips42 libvips-tools imagemagick libimlib2 libimlib2-dev
+          sudo apt-get install -y libvips42 libvips-tools imagemagick libimlib2 libimlib2-dev libheif-plugin-aomenc libavif-dev
 
       - uses: ruby/setup-ruby@v1
         with:

data/.ruby-version

@@ -1 +1 @@
-4.0.5
+4.0.6

data/Gemfile

@@ -12,3 +12,6 @@ gem 'railties'
 gem 'minitest'
 gem 'minitest-reporters'
 gem 'rake'
+
+gem 'benchmark-ips'
+gem 'webrick'

data/README.md

@@ -13,7 +13,7 @@ end
 How to use with Rack
 
 ```ruby
-use RackResize::RackApp, processor: :imlib2, assets_folder: "samples"
+use RackResize::RackApp, processor: :mini_magick, assets_folders: ["samples"]
 use Rack::Static, urls: [""], root: "samples", index: "index.html" # optional
 ```
 
@@ -23,16 +23,77 @@ Cloudflare format: (can be used with helpers from `carrierwave-cloudflare` gem)
 ```
 /cdn-cgi/image/width=426,format=auto/assets/pets/dog.jpg
 ```
-Fastly and bunny.net: (tbd)
+Fastly / bunny.net format (query string params):
 ```
-/assets/pets/dog.jpg?width=300
+/assets/pets/dog.jpg?width=300&height=200&fit=cover&format=webp&quality=85
+```
+
+### Supported Parameters:
+
+| Parameter  | Shortcut | Type | Description |
+|------------|----------|------|-------------|
+| `width`    | `w`      | integer | Target width in pixels. Scales proportionally if `height` is omitted. |
+| `height`   | `h`      | integer | Target height in pixels. Scales proportionally if `width` is omitted. |
+| `fit`      | —        | string  | Resize mode: `contain` (default), `cover`, `crop`. See below. |
+| `format`   | `f`      | string  | Output format: `jpeg`, `png`, `webp`, `avif`, `gif`. Use `auto` to keep original. |
+| `quality`  | `q`      | integer (1–100) | Compression quality. Defaults to `default_quality` config value (95). |
+| `dpr`      | —        | float (0.1–10) | Device pixel ratio. Multiplies `width` and `height` before processing. |
+| `bg-color` | `bg`     | color   | Background color for flattening transparency. Also aliased as `background`. See formats below. |
+
+**Background color formats:**
+- CSS named color: `white`, `red`, `cornflowerblue` (all 148 CSS colors supported)
+- 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)
+
+Supported by: `vips`, `mini_magick`. Accepted but ignored by `sips` and `imlib2`.
+
+**Fit modes:**
+- `contain` — resizes to fit within the given box, preserving aspect ratio (default)
+- `cover` / `crop` — resizes and center-crops to fill the exact box
+
+**Example URLs (query string format):**
+```
+# Resize to width only
+/samples/image_1.jpeg?w=400
+
+# Resize to fit within 400×300 box
+/samples/image_1.jpeg?width=400&height=300
+
+# Cover-crop to exact 400×300
+/samples/image_1.jpeg?width=400&height=300&fit=cover
+
+# Convert to WebP at 80% quality
+/samples/image_1.jpeg?w=400&f=webp&q=80
+
+# Retina (2×) resize
+/samples/image_1.jpeg?w=200&dpr=2
+
+# Flatten transparency with a background color
+/samples/image.png?w=400&f=jpeg&bg-color=white
+/samples/image.png?w=400&f=jpeg&bg=%23ff0000
+/samples/image.png?w=400&f=jpeg&background=0,255,0,0.5
+```
+
+**Example URLs (Cloudflare format):**
+```
+# Resize to width
+/cdn-cgi/image/width=400/samples/image_1.jpeg
+
+# Cover-crop with format conversion
+/cdn-cgi/image/width=400,height=300,fit=cover,format=webp/samples/image_1.jpeg
+
+# Quality + format
+/cdn-cgi/image/width=400,format=avif,quality=80/samples/image_1.jpeg
 ```
 
 ### Configuration:
 
 ```ruby
 RackResize.configure do |config|
-  config.assets_folders     = { "assets" => Rails.root.join('app', 'assets', 'images') }
+  config.assets_folders     = { assets: Rails.root.join('app', 'assets', 'images') }
   config.processor          = :sips / :vips / :mini_magick / :imlib2
   config.default_quality    = 95
   config.save_resized       = false
@@ -45,12 +106,25 @@ end
 
 <table>
 <tr>
-<th>libaray</th>
-<th>dependency</th>
+<th>processor</th>
 <th>config</th>
+<th>system library</th>
+<th>gems</th>
+</tr>
+<tr>
+<td>sips (macOS only)</td>
+<td><code>processor: :sips</code></td>
+<td>built-in on macOS</td>
+<td>none</td>
 </tr>
 <tr>
 <td>mini_magick</td>
+<td><code>processor: :mini_magick</code></td>
+<td>
+
+ImageMagick — `brew install imagemagick`
+
+</td>
 <td>
 
 ```ruby
@@ -59,14 +133,15 @@ gem "mini_magick"
 ```
 
 </td>
+</tr>
+<tr>
+<td>vips</td>
+<td><code>processor: :vips</code></td>
 <td>
 
-`processor: :mini_magick`
+libvips — `brew install vips`
 
 </td>
-</tr>
-<tr>
-<td>vips</td>
 <td>
 
 ```ruby
@@ -74,35 +149,64 @@ gem "image_processing"
 gem "ruby-vips"
 ```
 
-</td>
-<td>
-
-`processor: :vips`
-
 </td>
 </tr>
 <tr>
-<td>sips (MacOS only)</td>
-<td>none</td>
+<td>imlib2</td>
+<td><code>processor: :imlib2</code></td>
 <td>
 
-`processor: :sips`
+Imlib2 — `brew install imlib2`
 
 </td>
-</tr>
-<tr>
-<td>imlib2</td>
 <td>
 
 ```ruby
-gem  "rszr"
+gem "rszr"
 ```
 
-</td>
-<td>
-
-`processor: :imlib2`
-
 </td>
 </tr>
 </table>
+
+### Supported Image Formats:
+
+| Format | sips | mini_magick | vips | imlib2 |
+|--------|:----:|:-----------:|:----:|:------:|
+| JPEG   | ✅   | ✅          | ✅   | ✅     |
+| PNG    | ✅   | ✅          | ✅   | ✅     |
+| GIF    | ✅   | ✅          | ✅   | ✅     |
+| WebP   | ❌   | ✅ ¹        | ✅ ¹ | ❌     |
+| AVIF   | ✅ ² | ✅ ³        | ✅ ⁴ | ❌     |
+| HEIC   | ✅   | ✅ ³        | ✅ ⁴ | ❌     |
+| SVG    | ❌   | ✅ ⁵        | ✅ ⁶ | ❌     |
+
+¹ Requires ImageMagick / libvips built with **libwebp** support (`brew install webp`)
+² macOS 13 (Ventura) or later
+³ Requires ImageMagick built with **libheif** support (`brew install libheif`)
+⁴ Requires libvips built with **libheif** support (`brew install libheif`)
+⁵ Requires **Inkscape** or **librsvg** (`brew install librsvg`)
+⁶ Requires libvips built with **librsvg** support (`brew install librsvg`)
+
+### Performance Benchmarks:
+
+Measured on an Apple M1 Pro with Ruby 4.0.5. Output size: 300×200 px.
+Run with `ruby benchmark/processor_benchmark.rb`
+
+**JPEG — image_1.jpeg (51 KB)**
+
+| Processor   | i/s   | ms/i  | vs fastest |
+|-------------|------:|------:|:----------:|
+| imlib2      | 613.0 | 1.63  | —          |
+| vips        | 216.9 | 4.61  | 2.83×      |
+| mini_magick |  36.4 | 27.49 | 16.85×     |
+| sips        |  20.1 | 49.68 | 30.45×     |
+
+**PNG — sample.png (2 KB)**
+
+| Processor   | i/s   | ms/i | vs fastest |
+|-------------|------:|-----:|:----------:|
+| vips        | 431.1 | 2.32 | —          |
+| imlib2      | 221.7 | 4.51 | 1.94×      |
+| mini_magick |  36.9 | 27.12| 11.69×     |
+| sips        |  19.4 | 51.62| 22.25×     |

data/benchmark/http_benchmark.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+#
+# HTTP benchmark: starts a WEBrick server in a background thread, mounts one
+# RackResize::RackApp per available processor at a distinct path prefix, then
+# measures throughput with benchmark-ips over persistent HTTP connections.
+#
+# Usage:
+#   bundle exec ruby benchmark/http_benchmark.rb
+
+require 'bundler/setup'
+require 'rack'
+require 'webrick'
+require 'net/http'
+require 'benchmark/ips'
+require 'logger'
+require 'stringio'
+require 'timeout'
+require_relative '../lib/rack_resize'
+
+SAMPLES_DIR  = File.expand_path('../samples', __dir__)
+BENCH_PORT   = 14_569
+BENCH_IMAGE  = 'image_1.jpeg'
+BENCH_PARAMS = 'width=300&height=200'
+NULL_LOGGER  = Logger.new(IO::NULL)
+
+# ── One RackApp per available processor ──────────────────────────────────────
+
+available_apps = {}
+
+puts "Loading processors..."
+%i[sips vips mini_magick imlib2].each do |name|
+  begin
+    app = RackResize::RackApp.new(
+      processor:      name,
+      assets_folders: { '/' => SAMPLES_DIR },
+      save_resized:   false,
+      logger:         NULL_LOGGER,
+    )
+    available_apps[name] = app
+    puts "  ✓ #{name}"
+  rescue => e
+    puts "  ✗ #{name}: #{e.message}"
+  end
+end
+
+abort "\nNo processors available." if available_apps.empty?
+
+# ── URLMap: /sips → sips_app, /vips → vips_app, etc. ────────────────────────
+
+rack_app = Rack::Builder.new do
+  available_apps.each do |name, app|
+    map("/#{name}") { run app }
+  end
+end.to_app
+
+# ── WEBrick with a minimal Rack env bridge ───────────────────────────────────
+
+webrick = WEBrick::HTTPServer.new(
+  Port:      BENCH_PORT,
+  Logger:    WEBrick::Log.new(IO::NULL),
+  AccessLog: [],
+)
+
+webrick.mount_proc('/') do |req, res|
+  env = {
+    'REQUEST_METHOD'    => req.request_method,
+    'PATH_INFO'         => req.path,
+    'QUERY_STRING'      => req.query_string.to_s,
+    'SERVER_NAME'       => 'localhost',
+    'SERVER_PORT'       => BENCH_PORT.to_s,
+    'HTTP_HOST'         => "localhost:#{BENCH_PORT}",
+    'SCRIPT_NAME'       => '',
+    'rack.version'      => Rack::VERSION,
+    'rack.input'        => StringIO.new(''),
+    'rack.errors'       => $stderr,
+    'rack.multithread'  => true,
+    'rack.multiprocess' => false,
+    'rack.run_once'     => false,
+    'rack.url_scheme'   => 'http',
+  }
+  req.header.each do |key, values|
+    env["HTTP_#{key.upcase.tr('-', '_')}"] = values.join(', ')
+  end
+
+  status, headers, body = rack_app.call(env)
+
+  res.status = status
+  headers.each { |k, v| res[k] = v }
+  body_str = +''
+  body.each { |chunk| body_str << chunk }
+  res.body = body_str
+end
+
+server_thread = Thread.new { webrick.start }
+
+Timeout.timeout(10) do
+  loop do
+    TCPSocket.new('localhost', BENCH_PORT).close
+    break
+  rescue Errno::ECONNREFUSED
+    sleep 0.05
+  end
+end
+
+puts "\nServer listening on port #{BENCH_PORT}"
+
+# ── Smoke-test each endpoint before benchmarking ─────────────────────────────
+
+puts "\nVerifying endpoints..."
+available_apps.keys.each do |name|
+  uri  = URI("http://localhost:#{BENCH_PORT}/#{name}/#{BENCH_IMAGE}?#{BENCH_PARAMS}")
+  resp = Net::HTTP.get_response(uri)
+  if resp.is_a?(Net::HTTPOK)
+    puts "  ✓ /#{name}/#{BENCH_IMAGE} → 200 (#{resp.body.bytesize} B)"
+  else
+    warn "  ✗ /#{name}/#{BENCH_IMAGE} → #{resp.code}: #{resp.body}"
+    available_apps.delete(name)
+  end
+end
+
+abort "\nNo processors passed smoke test." if available_apps.empty?
+
+# ── Persistent HTTP connections, one per processor ───────────────────────────
+
+connections = available_apps.keys.to_h do |name|
+  http = Net::HTTP.new('localhost', BENCH_PORT)
+  http.start
+  [name, http]
+end
+
+puts "\n── HTTP rack server benchmark ───────────────────────────────────────────────"
+puts "   image : #{BENCH_IMAGE}"
+puts "   params: #{BENCH_PARAMS}"
+puts
+
+Benchmark.ips do |x|
+  x.config(time: 10, warmup: 3)
+
+  connections.each do |name, http|
+    path = "/#{name}/#{BENCH_IMAGE}?#{BENCH_PARAMS}"
+    x.report(name.to_s) { http.get(path) }
+  end
+
+  x.compare!
+end
+
+# ── Cleanup ───────────────────────────────────────────────────────────────────
+
+connections.each_value(&:finish)
+webrick.shutdown
+server_thread.join

data/benchmark/processor_benchmark.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+#
+# Direct processor benchmark: instantiates each available RackResize processor
+# and calls resize() directly on images from the samples/ folder.
+#
+# Usage:
+#   bundle exec ruby benchmark/processor_benchmark.rb
+
+require 'bundler/setup'
+require 'benchmark/ips'
+require_relative '../lib/rack_resize'
+
+SAMPLES_DIR   = File.expand_path('../samples', __dir__)
+BENCH_IMAGES  = Dir[File.join(SAMPLES_DIR, '{image_1,sample}.{jpg,jpeg,png,webp,heic,avif}')].sort
+BENCH_WIDTH   = 300
+BENCH_HEIGHT  = 200
+
+abort 'No sample images found in samples/.' if BENCH_IMAGES.empty?
+
+# ── Collect available processor instances ────────────────────────────────────
+
+PROCESSOR_CLASSES = {
+  sips:        RackResize::Processors::Sips,
+  vips:        RackResize::Processors::Vips,
+  mini_magick: RackResize::Processors::MiniMagick,
+  imlib2:      RackResize::Processors::Imlib2,
+}.freeze
+
+puts "Loading processors..."
+processors = {}
+
+PROCESSOR_CLASSES.each do |name, klass|
+  begin
+    instance = klass.new
+    # Verify the processor actually works before including it
+    instance.resize(
+      source_file:   BENCH_IMAGES.first,
+      target_file:   nil,
+      target_width:  BENCH_WIDTH,
+      target_height: BENCH_HEIGHT,
+    )
+    processors[name] = instance
+    puts "  ✓ #{name}"
+  rescue => e
+    puts "  ✗ #{name}: #{e.message}"
+  end
+end
+
+abort "\nNo processors available." if processors.empty?
+
+puts "\nSample images: #{BENCH_IMAGES.map { |f| File.basename(f) }.join(', ')}"
+
+# ── Benchmark each sample image independently ─────────────────────────────────
+
+BENCH_IMAGES.each do |image_path|
+  image_name = File.basename(image_path)
+  image_size = File.size(image_path)
+
+  puts "\n── Direct processor benchmark ───────────────────────────────────────────────"
+  puts "   image : #{image_name} (#{image_size / 1024} KB)"
+  puts "   output: #{BENCH_WIDTH}x#{BENCH_HEIGHT}"
+  puts
+
+  Benchmark.ips do |x|
+    x.config(time: 5, warmup: 2)
+
+    processors.each do |name, processor|
+      next if name.to_s == "imlib2" && image_name =~ /heic|webp|avif/
+      next if name.to_s == "sips" && image_name =~ /webp/
+
+      x.report(name.to_s) do
+        processor.resize(
+          source_file:   image_path,
+          target_file:   nil,
+          target_width:  BENCH_WIDTH,
+          target_height: BENCH_HEIGHT,
+        )
+      end
+    end
+
+    x.compare!
+  end
+end

data/config.ru

@@ -7,7 +7,7 @@
 require_relative "lib/rack_resize"
 require "rack/static"
 
-use RackResize::RackApp, processor: :imlib2, assets_folder: "samples"
+use RackResize::RackApp, processor: :vips, assets_folders: ["samples"]
 
 use Rack::Static, urls: [""], root: "samples", index: "index.html"
 

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

@@ -64,7 +64,7 @@ class RackResize::Configuration
                             when :sips        then RackResize::Processors::Sips.new
                             when :imlib2      then RackResize::Processors::Imlib2.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/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/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

data/lib/rack_resize/processors/sips.rb

@@ -1,20 +1,32 @@
 require "open3"
+require "tempfile"
 
 class RackResize::Processors::Sips
 
-  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
+
     args = %w[sips --deleteColorManagementProperties]
-    args += ["-s", "formatOptions", RackResize.config.default_quality.to_s]
+    args += ["-s", "format", sips_format(format)] if format
+    args += ["-s", "formatOptions", quality.to_s]
 
     if target_width && target_height
-      info, status = Open3.capture2("sips", "-g", "pixelWidth", "-g", "pixelHeight", source_file.to_s)
-      raise "sips failed to read dimensions for #{source_file}" unless status.success?
-      src_w = info[/pixelWidth: (\d+)/, 1]&.to_f
-      src_h = info[/pixelHeight: (\d+)/, 1]&.to_f
-      if src_w && src_h && (target_width.to_f / src_w) <= (target_height.to_f / src_h)
-        args += ["--resampleWidth", target_width.to_i.to_s]
-      else
-        args += ["--resampleHeight", target_height.to_i.to_s]
+      src_w, src_h = sips_dimensions(source_file)
+      if cover
+        if src_w.nil? || src_h.nil?
+          args += ["--resampleWidth", target_width.to_i.to_s]
+        elsif target_width.to_f / src_w >= target_height.to_f / src_h
+          args += ["--resampleWidth", target_width.to_i.to_s]
+        else
+          args += ["--resampleHeight", target_height.to_i.to_s]
+        end
+      elsif src_w && src_h
+        if (target_width.to_f / src_w) <= (target_height.to_f / src_h)
+          args += ["--resampleWidth", target_width.to_i.to_s]
+        else
+          args += ["--resampleHeight", target_height.to_i.to_s]
+        end
       end
     else
       args += ["--resampleWidth",  target_width.to_i.to_s]  if target_width
@@ -22,20 +34,40 @@ class RackResize::Processors::Sips
     end
 
     if target_file
-      _, status = Open3.capture2(*args, "-o", target_file.to_s, source_file.to_s)
-      raise "sips failed (exit #{status.exitstatus}) for #{source_file}" unless status.success?
-      return nil
+      run_sips(*args, "-o", target_file.to_s, source_file.to_s)
+      sips_crop!(target_file.to_s, target_width, target_height) if cover
+      nil
+    else
+      tmp = Tempfile.new(["result", File.extname(source_file)])
+      begin
+        run_sips(*args, "-o", tmp.path, source_file.to_s)
+        sips_crop!(tmp.path, target_width, target_height) if cover
+        File.binread(tmp.path)
+      ensure
+        tmp.close
+        tmp.unlink
+      end
     end
+  end
 
-    tmp = Tempfile.new(["result", File.extname(source_file)])
-    tmp_path = tmp.path || raise("tempfile has no path")
-    begin
-      _, status = Open3.capture2(*args, "-o", tmp_path, source_file.to_s)
-      raise "sips failed (exit #{status.exitstatus}) for #{source_file}" unless status.success?
-      File.binread(tmp_path)
-    ensure
-      tmp.close
-      tmp.unlink
-    end
+  private
+
+  def sips_dimensions(source_file)
+    info, status = Open3.capture2("sips", "-g", "pixelWidth", "-g", "pixelHeight", source_file.to_s)
+    raise "sips failed to read dimensions for #{source_file}" unless status.success?
+    [info[/pixelWidth: (\d+)/, 1]&.to_f, info[/pixelHeight: (\d+)/, 1]&.to_f]
+  end
+
+  def run_sips(*args)
+    _, status = Open3.capture2(*args)
+    raise "sips failed (exit #{status.exitstatus}): #{args.join(' ')}" unless status.success?
+  end
+
+  def sips_crop!(path, width, height)
+    run_sips("sips", "--cropToHeightWidth", height.to_i.to_s, width.to_i.to_s, path)
+  end
+
+  def sips_format(format)
+    format.to_s.downcase == 'jpg' ? 'jpeg' : format.to_s.downcase
   end
 end

data/lib/rack_resize/processors/vips.rb

@@ -6,13 +6,28 @@ end
 
 class RackResize::Processors::Vips
 
-  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 = ImageProcessing::Vips.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
+      r, g, b, _a = bg_color
+      image = image.flatten(background: [r, g, b])
+    end
+
+    image = image.saver(quality: quality)
 
     if target_file
       image.call(destination: target_file)
+      nil
     else
       begin
         tmp_file = image.call

data/lib/rack_resize/rack_app.rb

@@ -18,8 +18,9 @@ class RackResize::RackApp
     request = Rack::Request.new(env)
     fullpath = request.path_info
 
-    RackResize::InputParsers::Cloudflare.parse_input(fullpath, cf_path_prefix: @cf_path_prefix) =>
-      {route_matched:, req_params:, asset_path:}
+    result = RackResize::InputParsers::Cloudflare.parse_input(fullpath, cf_path_prefix: @cf_path_prefix)
+    result = RackResize::InputParsers::QueryString.parse_input(fullpath, request.query_string) unless result[:route_matched]
+    result => {route_matched:, req_params:, asset_path:}
 
     return @app.call(env) unless route_matched
     return error_resp("can't parse file path") unless asset_path
@@ -31,7 +32,7 @@ class RackResize::RackApp
     config.assets_folders.each do |prefix, folder|
       if asset_path.start_with?(prefix)
         asset_file = folder.join(asset_path.delete_prefix(prefix + (prefix.end_with?("/") ? "" : "/")))
-        if asset_file.expand_path.to_s.start_with?(folder.to_s)
+        if asset_file.expand_path.to_s.start_with?(folder.expand_path.to_s)
           has_matched = true
         end
         break
@@ -47,20 +48,22 @@ class RackResize::RackApp
       return error_resp("invalid file path")
     end
     unless asset_file.exist?
-      @processing.logger.info("RackResize::RackApp - File path fond #{asset_path} => #{asset_file}")
+      @processing.logger.info("RackResize::RackApp - File path not found #{asset_path} => #{asset_file}")
       return error_resp("file not exists on a server")
     end
 
     file_content = @processing.process!(source_file: asset_file, req_params:)
-    return send_file(asset_file:, file_content:)
+    output_format = req_params[:format].then { |f| (f && f != 'auto') ? f : nil }
+    return send_file(asset_file:, file_content:, output_format:)
   end
 
   def error_resp(message, http_code: 404)
     [http_code, {}, [message]]
   end
 
-  def send_file(asset_file:, file_content: nil)
-    content_type = Rack::Mime.mime_type(File.extname(asset_file), "application/octet-stream")
+  def send_file(asset_file:, file_content: nil, output_format: nil)
+    ext = (output_format && output_format != 'auto') ? ".#{output_format}" : File.extname(asset_file)
+    content_type = Rack::Mime.mime_type(ext, "application/octet-stream")
 
     [
       200,

data/lib/rack_resize.rb

@@ -2,17 +2,18 @@ module RackResize
   autoload :Configuration, "#{__dir__}/rack_resize/configuration"
   autoload :RackApp,       "#{__dir__}/rack_resize/rack_app"
   autoload :Processing,    "#{__dir__}/rack_resize/processing"
-  # autoload :ImageController,    "#{__dir__}/rack_resize/image_controller"
+  autoload :ColorUtils,    "#{__dir__}/rack_resize/color_utils"
 
   module Processors
-    autoload :Sips,      "#{__dir__}/rack_resize/processors/sips"
-    autoload :Vips,      "#{__dir__}/rack_resize/processors/vips"
+    autoload :Sips,       "#{__dir__}/rack_resize/processors/sips"
+    autoload :Vips,       "#{__dir__}/rack_resize/processors/vips"
     autoload :MiniMagick, "#{__dir__}/rack_resize/processors/mini_magick"
-    autoload :Imlib2,    "#{__dir__}/rack_resize/processors/imlib2"
+    autoload :Imlib2,     "#{__dir__}/rack_resize/processors/imlib2"
   end
 
   module InputParsers
-    autoload :Cloudflare, "#{__dir__}/rack_resize/input_parsers/cloudflare"
+    autoload :Cloudflare,  "#{__dir__}/rack_resize/input_parsers/cloudflare"
+    autoload :QueryString, "#{__dir__}/rack_resize/input_parsers/query_string"
   end
 
   class << self

data/rack_resize.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = "rack_resize"
-  s.version     = "0.1.3"
+  s.version     = "0.1.4"
   s.author      = ["Pavel Evstigneev"]
   s.email       = ["pavel.evst@gmail.com"]
   s.homepage    = "https://github.com/paxa/rack_resize"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack_resize
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Pavel Evstigneev
@@ -41,10 +41,14 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- benchmark/http_benchmark.rb
+- benchmark/processor_benchmark.rb
 - config.ru
 - lib/rack_resize.rb
+- lib/rack_resize/color_utils.rb
 - lib/rack_resize/configuration.rb
 - lib/rack_resize/input_parsers/cloudflare.rb
+- lib/rack_resize/input_parsers/query_string.rb
 - lib/rack_resize/processing.rb
 - lib/rack_resize/processors/imlib2.rb
 - lib/rack_resize/processors/mini_magick.rb
@@ -71,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Image resizing on a fly
 test_files: []