1use chrono::{DateTime, Utc};
20use rustango::sql::Auto;
21use rustango::Model;
22use serde::{Deserialize, Serialize};
23
24#[derive(Model, Debug, Clone, Serialize, Deserialize)]
29#[rustango(
30 table = "cms_media_rendition",
31 app = "cms",
32 admin(
33 list_display = "media_id, filter_spec, width, height, last_used_at",
34 ordering = "-last_used_at",
35 list_filter = "filter_spec",
36 )
37)]
38pub struct MediaRendition {
39 #[rustango(primary_key)]
40 pub id: Auto<i64>,
41
42 #[rustango(fk = "cms_media", on = "id", index)]
45 pub media_id: i64,
46
47 #[rustango(max_length = 64, index)]
51 pub content_hash: String,
52
53 #[rustango(max_length = 64, index)]
57 pub filter_spec: String,
58
59 pub width: i32,
61 pub height: i32,
62
63 #[rustango(max_length = 128)]
67 pub mime: String,
68
69 #[rustango(max_length = 512)]
74 pub storage_key: String,
75
76 pub size: i64,
79
80 pub last_used_at: chrono::DateTime<chrono::Utc>,
83
84 #[rustango(auto_now_add)]
85 pub created_at: Auto<DateTime<Utc>>,
86}
87
88#[derive(Debug, Clone, Copy, PartialEq)]
93pub enum FilterOp {
94 Fill { w: u32, h: u32 },
96 Max { w: u32, h: u32 },
98 Width(u32),
100 Height(u32),
102}
103
104#[derive(Debug, Clone, Copy, PartialEq, Default)]
112pub struct EncodingOps {
113 pub format: Option<EncodeFormat>,
114 pub quality: Option<u8>,
116 pub background: Option<(u8, u8, u8)>,
120}
121
122#[derive(Debug, Clone, Copy, PartialEq)]
123pub enum EncodeFormat {
124 Jpeg,
125 Png,
126 Webp,
127 Avif,
131 Auto,
135}
136
137impl EncodeFormat {
138 fn parse(s: &str) -> Option<Self> {
139 Some(match s {
140 "jpeg" | "jpg" => Self::Jpeg,
141 "png" => Self::Png,
142 "webp" => Self::Webp,
143 "avif" => Self::Avif,
144 "auto" => Self::Auto,
145 _ => return None,
146 })
147 }
148 fn canonical(self) -> &'static str {
149 match self {
150 Self::Jpeg => "jpeg",
151 Self::Png => "png",
152 Self::Webp => "webp",
153 Self::Avif => "avif",
154 Self::Auto => "auto",
155 }
156 }
157 fn mime(self) -> &'static str {
158 match self {
159 Self::Jpeg => "image/jpeg",
160 Self::Png => "image/png",
161 Self::Avif => "image/avif",
162 Self::Webp | Self::Auto => "image/webp",
163 }
164 }
165 fn ext(self) -> &'static str {
166 match self {
167 Self::Jpeg => "jpg",
168 Self::Png => "png",
169 Self::Avif => "avif",
170 Self::Webp | Self::Auto => "webp",
171 }
172 }
173}
174
175#[derive(Debug, Clone, Copy, PartialEq)]
185pub struct FilterPipeline {
186 pub geometric: FilterOp,
187 pub encoding: EncodingOps,
188}
189
190#[derive(Debug, thiserror::Error)]
191pub enum FilterError {
192 #[error("unknown filter spec `{0}` — expected fill-WxH | max-WxH | width-W | height-H")]
193 Unknown(String),
194 #[error("invalid dimensions in `{0}`")]
195 BadDimensions(String),
196 #[error("invalid encoding op `{0}` — expected format-X | quality-N | bgcolor-XYZ")]
197 BadEncoding(String),
198}
199
200impl FilterPipeline {
201 pub fn parse(raw: &str) -> Result<Self, FilterError> {
205 let mut parts = raw.split('|');
206 let head = parts.next().unwrap_or("");
207 let geometric = FilterOp::parse(head)?;
208 let mut encoding = EncodingOps::default();
209 for seg in parts {
210 let seg = seg.trim();
211 if seg.is_empty() {
212 continue;
213 }
214 if let Some(rest) = seg.strip_prefix("format-") {
215 encoding.format = Some(
216 EncodeFormat::parse(rest)
217 .ok_or_else(|| FilterError::BadEncoding(seg.to_owned()))?,
218 );
219 } else if let Some(rest) = seg.strip_prefix("quality-") {
220 let n: u8 = rest
221 .parse()
222 .map_err(|_| FilterError::BadEncoding(seg.to_owned()))?;
223 if !(1..=100).contains(&n) {
224 return Err(FilterError::BadEncoding(seg.to_owned()));
225 }
226 encoding.quality = Some(n);
227 } else if let Some(rest) = seg.strip_prefix("bgcolor-") {
228 encoding.background = Some(
229 parse_hex_rgb(rest).ok_or_else(|| FilterError::BadEncoding(seg.to_owned()))?,
230 );
231 } else {
232 return Err(FilterError::BadEncoding(seg.to_owned()));
233 }
234 }
235 Ok(Self {
236 geometric,
237 encoding,
238 })
239 }
240
241 pub fn canonical(&self) -> String {
244 let mut out = self.geometric.canonical();
245 if let Some(fmt) = self.encoding.format {
246 out.push('|');
247 out.push_str("format-");
248 out.push_str(fmt.canonical());
249 }
250 if let Some(q) = self.encoding.quality {
251 out.push_str(&format!("|quality-{q}"));
252 }
253 if let Some((r, g, b)) = self.encoding.background {
254 out.push_str(&format!("|bgcolor-{r:02x}{g:02x}{b:02x}"));
255 }
256 out
257 }
258}
259
260fn parse_hex_rgb(s: &str) -> Option<(u8, u8, u8)> {
264 let s = s.trim_start_matches('#');
265 let hex = match s.len() {
266 3 => {
267 let mut out = String::with_capacity(6);
269 for c in s.chars() {
270 out.push(c);
271 out.push(c);
272 }
273 out
274 }
275 6 => s.to_owned(),
276 _ => return None,
277 };
278 crate::theme::parse_rgb6(&hex)
279}
280
281impl FilterOp {
282 pub fn parse(raw: &str) -> Result<Self, FilterError> {
285 let raw = raw.trim();
286 let parse_pair = |s: &str| -> Result<(u32, u32), FilterError> {
288 let (w, h) = s
289 .split_once('x')
290 .ok_or_else(|| FilterError::BadDimensions(raw.to_owned()))?;
291 let w: u32 = w
292 .parse()
293 .map_err(|_| FilterError::BadDimensions(raw.to_owned()))?;
294 let h: u32 = h
295 .parse()
296 .map_err(|_| FilterError::BadDimensions(raw.to_owned()))?;
297 if w == 0 || h == 0 || w > 8192 || h > 8192 {
298 return Err(FilterError::BadDimensions(raw.to_owned()));
299 }
300 Ok((w, h))
301 };
302 if let Some(rest) = raw.strip_prefix("fill-") {
303 let (w, h) = parse_pair(rest)?;
304 return Ok(Self::Fill { w, h });
305 }
306 if let Some(rest) = raw.strip_prefix("max-") {
307 let (w, h) = parse_pair(rest)?;
308 return Ok(Self::Max { w, h });
309 }
310 if let Some(rest) = raw.strip_prefix("width-") {
311 let n: u32 = rest
312 .parse()
313 .map_err(|_| FilterError::BadDimensions(raw.to_owned()))?;
314 if n == 0 || n > 8192 {
315 return Err(FilterError::BadDimensions(raw.to_owned()));
316 }
317 return Ok(Self::Width(n));
318 }
319 if let Some(rest) = raw.strip_prefix("height-") {
320 let n: u32 = rest
321 .parse()
322 .map_err(|_| FilterError::BadDimensions(raw.to_owned()))?;
323 if n == 0 || n > 8192 {
324 return Err(FilterError::BadDimensions(raw.to_owned()));
325 }
326 return Ok(Self::Height(n));
327 }
328 Err(FilterError::Unknown(raw.to_owned()))
329 }
330
331 pub fn canonical(&self) -> String {
333 match self {
334 Self::Fill { w, h } => format!("fill-{w}x{h}"),
335 Self::Max { w, h } => format!("max-{w}x{h}"),
336 Self::Width(n) => format!("width-{n}"),
337 Self::Height(n) => format!("height-{n}"),
338 }
339 }
340}
341
342pub fn apply(
348 original: &image::DynamicImage,
349 op: FilterOp,
350 focal: Option<(f32, f32)>,
351) -> image::DynamicImage {
352 use image::imageops::FilterType;
353 let (sw, sh) = (original.width(), original.height());
354 match op {
355 FilterOp::Fill { w, h } => {
356 let scale_w = w as f32 / sw as f32;
361 let scale_h = h as f32 / sh as f32;
362 let scale = scale_w.max(scale_h);
363 let new_w = (sw as f32 * scale).round() as u32;
364 let new_h = (sh as f32 * scale).round() as u32;
365 let resized = original.resize_exact(new_w, new_h, FilterType::Lanczos3);
366 let (fx, fy) = focal.unwrap_or((0.5, 0.5));
367 let fx = fx.clamp(0.0, 1.0);
368 let fy = fy.clamp(0.0, 1.0);
369 let max_x = new_w.saturating_sub(w);
372 let max_y = new_h.saturating_sub(h);
373 let target_x = (fx * new_w as f32) - (w as f32 / 2.0);
374 let target_y = (fy * new_h as f32) - (h as f32 / 2.0);
375 let x_off = target_x.clamp(0.0, max_x as f32) as u32;
376 let y_off = target_y.clamp(0.0, max_y as f32) as u32;
377 resized.crop_imm(x_off, y_off, w.min(new_w), h.min(new_h))
378 }
379 FilterOp::Max { w, h } => original.resize(w, h, FilterType::Lanczos3),
380 FilterOp::Width(n) => {
381 let h = (sh as f32 * (n as f32 / sw as f32)).round() as u32;
382 original.resize_exact(n, h.max(1), FilterType::Lanczos3)
383 }
384 FilterOp::Height(n) => {
385 let w = (sw as f32 * (n as f32 / sh as f32)).round() as u32;
386 original.resize_exact(w.max(1), n, FilterType::Lanczos3)
387 }
388 }
389}
390
391pub fn encode(
400 image: &image::DynamicImage,
401 encoding: &EncodingOps,
402 source_mime: &str,
403) -> Result<(Vec<u8>, String, String), String> {
404 use image::codecs::jpeg::JpegEncoder;
405 let format = encoding.format.unwrap_or_else(|| {
406 if source_mime == "image/jpeg" || source_mime == "image/jpg" {
407 EncodeFormat::Jpeg
408 } else if source_mime == "image/webp" {
409 EncodeFormat::Webp
410 } else {
411 EncodeFormat::Png
412 }
413 });
414
415 let needs_flatten = matches!(format, EncodeFormat::Jpeg) || encoding.background.is_some();
418 let prepared: image::DynamicImage = if needs_flatten && encoding.background.is_some() {
419 let (r, g, b) = encoding.background.unwrap();
420 flatten_onto_background(image, r, g, b)
421 } else if matches!(format, EncodeFormat::Jpeg) && image.color().has_alpha() {
422 flatten_onto_background(image, 255, 255, 255)
425 } else {
426 image.clone()
427 };
428
429 let mut out: Vec<u8> = Vec::new();
430 match format {
431 EncodeFormat::Jpeg => {
432 let quality = encoding.quality.unwrap_or(85);
433 let mut cur = std::io::Cursor::new(&mut out);
434 let mut enc = JpegEncoder::new_with_quality(&mut cur, quality);
435 enc.encode_image(&prepared)
436 .map_err(|e| format!("encode jpeg: {e}"))?;
437 }
438 EncodeFormat::Png => {
439 let mut cur = std::io::Cursor::new(&mut out);
441 prepared
442 .write_to(&mut cur, image::ImageFormat::Png)
443 .map_err(|e| format!("encode png: {e}"))?;
444 }
445 EncodeFormat::Webp | EncodeFormat::Auto => {
446 let mut cur = std::io::Cursor::new(&mut out);
451 prepared
452 .write_to(&mut cur, image::ImageFormat::WebP)
453 .map_err(|e| format!("encode webp: {e}"))?;
454 }
455 EncodeFormat::Avif => {
456 #[cfg(feature = "avif")]
459 {
460 let quality = encoding.quality.unwrap_or(61);
463 let mut cur = std::io::Cursor::new(&mut out);
464 let enc =
465 image::codecs::avif::AvifEncoder::new_with_speed_quality(&mut cur, 4, quality);
466 prepared
467 .write_with_encoder(enc)
468 .map_err(|e| format!("encode avif: {e}"))?;
469 }
470 #[cfg(not(feature = "avif"))]
471 {
472 let _ = &prepared;
473 return Err(
474 "AVIF output requires building rustango-cms with the `avif` feature".to_owned(),
475 );
476 }
477 }
478 }
479 Ok((out, format.mime().to_owned(), format.ext().to_owned()))
480}
481
482fn flatten_onto_background(src: &image::DynamicImage, r: u8, g: u8, b: u8) -> image::DynamicImage {
485 use image::GenericImageView;
486 let (w, h) = src.dimensions();
487 let mut buf = image::RgbaImage::from_pixel(w, h, image::Rgba([r, g, b, 255]));
488 let rgba = src.to_rgba8();
489 image::imageops::overlay(&mut buf, &rgba, 0, 0);
490 image::DynamicImage::ImageRgba8(buf)
491}
492
493pub async fn crop_image_off_runtime(
502 bytes: Vec<u8>,
503 source_mime: String,
504 (x, y, w, h): (u32, u32, u32, u32),
505) -> Result<(Vec<u8>, String), String> {
506 rustango::__private_runtime::tokio::task::spawn_blocking(move || {
507 crop_image(&bytes, &source_mime, x, y, w, h)
508 })
509 .await
510 .map_err(|e| format!("crop worker failed: {e}"))?
511}
512
513pub async fn strip_exif_off_runtime(bytes: Vec<u8>, mime: String) -> (Vec<u8>, Option<(u32, u32)>) {
517 if !mime.starts_with("image/") || mime == "image/svg+xml" {
518 return (bytes, None);
519 }
520 rustango::__private_runtime::tokio::task::spawn_blocking(move || {
521 let (stripped, dims) = strip_exif_if_image(&bytes, &mime);
522 (stripped.unwrap_or(bytes), dims)
523 })
524 .await
525 .unwrap_or_else(|e| std::panic::resume_unwind(e.into_panic()))
526}
527
528pub fn crop_image(
537 bytes: &[u8],
538 source_mime: &str,
539 x: u32,
540 y: u32,
541 w: u32,
542 h: u32,
543) -> Result<(Vec<u8>, String), String> {
544 if source_mime == "image/svg+xml" {
545 return Err(
546 "Cropping SVG sources isn't supported — clone first, edit the markup directly."
547 .to_owned(),
548 );
549 }
550 let img = image::load_from_memory(bytes).map_err(|e| format!("decode source: {e}"))?;
551 let (sw, sh) = (img.width(), img.height());
552 if w == 0 || h == 0 {
553 return Err("Crop rectangle must have non-zero width + height.".to_owned());
554 }
555 if x.saturating_add(w) > sw || y.saturating_add(h) > sh {
556 return Err(format!(
557 "Crop rectangle ({x},{y},{w},{h}) is outside the source ({sw}×{sh})."
558 ));
559 }
560 let cropped = img.crop_imm(x, y, w, h);
561 let mut out: Vec<u8> = Vec::new();
562 let out_mime = if source_mime == "image/jpeg" || source_mime == "image/jpg" {
563 let mut cur = std::io::Cursor::new(&mut out);
564 cropped
565 .write_to(&mut cur, image::ImageFormat::Jpeg)
566 .map_err(|e| format!("encode jpeg: {e}"))?;
567 "image/jpeg".to_owned()
568 } else if source_mime == "image/webp" {
569 let mut cur = std::io::Cursor::new(&mut out);
570 cropped
571 .write_to(&mut cur, image::ImageFormat::WebP)
572 .map_err(|e| format!("encode webp: {e}"))?;
573 "image/webp".to_owned()
574 } else {
575 let mut cur = std::io::Cursor::new(&mut out);
579 cropped
580 .write_to(&mut cur, image::ImageFormat::Png)
581 .map_err(|e| format!("encode png: {e}"))?;
582 "image/png".to_owned()
583 };
584 Ok((out, out_mime))
585}
586
587#[must_use]
596pub fn strip_exif_if_image(bytes: &[u8], mime: &str) -> (Option<Vec<u8>>, Option<(u32, u32)>) {
597 if !mime.starts_with("image/") || mime == "image/svg+xml" {
598 return (None, None);
599 }
600 let img = match image::load_from_memory(bytes) {
601 Ok(img) => img,
602 Err(e) => {
603 tracing::warn!(
604 target: "rustango_cms::rendition",
605 mime, error = %e,
606 "EXIF strip: decode failed, keeping original bytes"
607 );
608 return (None, None);
609 }
610 };
611 let dims = (img.width(), img.height());
612 let format = match mime {
613 "image/jpeg" | "image/jpg" => image::ImageFormat::Jpeg,
614 "image/png" => image::ImageFormat::Png,
615 "image/webp" => image::ImageFormat::WebP,
616 "image/gif" => image::ImageFormat::Gif,
617 "image/avif" => image::ImageFormat::Avif,
618 _ => image::ImageFormat::Png,
620 };
621 let mut out: Vec<u8> = Vec::with_capacity(bytes.len());
622 {
623 let mut cur = std::io::Cursor::new(&mut out);
624 if let Err(e) = img.write_to(&mut cur, format) {
625 tracing::warn!(
626 target: "rustango_cms::rendition",
627 mime, error = %e,
628 "EXIF strip: re-encode failed, keeping original bytes"
629 );
630 return (None, Some(dims));
631 }
632 }
633 (Some(out), Some(dims))
634}
635
636pub fn register_tera_function(tera: &mut tera::Tera) {
649 tera.register_function("rcms_image_url", RcmsImageUrlFn);
650 tera.register_function("rcms_image_srcset", RcmsImageSrcsetFn);
653 tera.register_function("rcms_image_srcset_dpi", RcmsImageSrcsetDpiFn);
654 tera.register_function("rcms_picture", RcmsPictureFn);
655}
656
657struct RcmsImageUrlFn;
662
663impl tera::Function for RcmsImageUrlFn {
664 fn call(
665 &self,
666 args: &std::collections::HashMap<String, tera::Value>,
667 ) -> tera::Result<tera::Value> {
668 rcms_image_url(args)
669 }
670 fn is_safe(&self) -> bool {
671 true
672 }
673}
674
675fn rcms_image_url(
676 args: &std::collections::HashMap<String, tera::Value>,
677) -> tera::Result<tera::Value> {
678 let media_id = parse_media_id_arg(args)
679 .ok_or_else(|| tera::Error::msg("rcms_image_url: `media_id` (i64) is required"))?;
680 let filter = args
681 .get("filter")
682 .and_then(tera::Value::as_str)
683 .ok_or_else(|| tera::Error::msg("rcms_image_url: `filter` (string) is required"))?;
684 let op =
685 FilterOp::parse(filter).map_err(|e| tera::Error::msg(format!("rcms_image_url: {e}")))?;
686 let v = args.get("v").and_then(tera::Value::as_str);
693 Ok(tera::Value::String(rendition_url(
694 media_id,
695 &op.canonical(),
696 v,
697 )))
698}
699
700impl FilterOp {
703 fn nominal_width(self) -> Option<u32> {
706 match self {
707 Self::Fill { w, .. } | Self::Max { w, .. } | Self::Width(w) => Some(w),
708 Self::Height(_) => None,
709 }
710 }
711
712 fn scaled(self, factor: u32) -> Self {
716 let cap = |n: u32| n.saturating_mul(factor).min(8192);
717 match self {
718 Self::Fill { w, h } => Self::Fill {
719 w: cap(w),
720 h: cap(h),
721 },
722 Self::Max { w, h } => Self::Max {
723 w: cap(w),
724 h: cap(h),
725 },
726 Self::Width(w) => Self::Width(cap(w)),
727 Self::Height(h) => Self::Height(cap(h)),
728 }
729 }
730}
731
732fn parse_media_id_arg(args: &std::collections::HashMap<String, tera::Value>) -> Option<i64> {
735 args.get("media_id").and_then(|v| {
736 v.as_i64().or_else(|| {
737 v.as_str()
738 .map(str::trim)
739 .filter(|s| !s.is_empty())
740 .and_then(|s| s.parse::<i64>().ok())
741 })
742 })
743}
744
745fn parse_filters_arg(
748 args: &std::collections::HashMap<String, tera::Value>,
749 fn_name: &str,
750) -> tera::Result<Vec<FilterPipeline>> {
751 let arr = args
752 .get("filters")
753 .and_then(|v| v.as_array())
754 .ok_or_else(|| {
755 tera::Error::msg(format!(
756 "{fn_name}: `filters` (array of spec strings) is required"
757 ))
758 })?;
759 arr.iter()
760 .map(|v| {
761 let s = v.as_str().ok_or_else(|| {
762 tera::Error::msg(format!("{fn_name}: each filter must be a string"))
763 })?;
764 FilterPipeline::parse(s).map_err(|e| tera::Error::msg(format!("{fn_name}: {e}")))
765 })
766 .collect()
767}
768
769#[must_use]
775pub fn rendition_url_for(media_id: i64, spec: &str, content_hash: Option<&str>) -> Option<String> {
776 let pipeline = FilterPipeline::parse(spec).ok()?;
777 Some(rendition_url(media_id, &pipeline.canonical(), content_hash))
778}
779
780fn rendition_url(media_id: i64, canonical_spec: &str, v: Option<&str>) -> String {
783 let base = match v {
784 Some(v) if !v.is_empty() => format!(
785 "/__media__/{canonical_spec}/{media_id}?v={}",
786 &v[..12.min(v.len())]
787 ),
788 _ => format!("/__media__/{canonical_spec}/{media_id}"),
789 };
790 maybe_sign(base, canonical_spec, media_id)
791}
792
793static SIGNING_KEY: std::sync::OnceLock<Option<Vec<u8>>> = std::sync::OnceLock::new();
797
798pub fn set_signing_key(key: impl Into<Vec<u8>>) {
817 let key = key.into();
818 if let Err(rejected) = SIGNING_KEY.set(Some(key)) {
819 if SIGNING_KEY.get() != Some(&rejected) {
820 tracing::error!(
821 target: "rustango_cms::rendition",
822 "set_signing_key called after the key was already fixed (set earlier, or read \
823 from RCMS_RENDITION_SIGNING_KEY); this call has no effect — set it before serving"
824 );
825 }
826 }
827}
828
829fn signing_key() -> Option<&'static [u8]> {
832 SIGNING_KEY
833 .get_or_init(|| {
834 crate::config::var("RENDITION_SIGNING_KEY").map(String::into_bytes)
835 })
836 .as_deref()
837}
838
839fn rendition_sig(key: &[u8], canonical_spec: &str, media_id: i64) -> String {
842 let msg = format!("{canonical_spec}:{media_id}");
843 let full = crate::signing::hmac_sha256_hex(key, msg.as_bytes());
844 full[..16].to_owned()
845}
846
847fn sig_ok(key: &[u8], canonical_spec: &str, media_id: i64, supplied: Option<&str>) -> bool {
850 let expected = rendition_sig(key, canonical_spec, media_id);
851 supplied.is_some_and(|s| crate::signing::constant_time_eq(s.as_bytes(), expected.as_bytes()))
852}
853
854fn maybe_sign(url: String, canonical_spec: &str, media_id: i64) -> String {
857 match signing_key() {
858 Some(key) => {
859 let sig = rendition_sig(key, canonical_spec, media_id);
860 let sep = if url.contains('?') { '&' } else { '?' };
861 format!("{url}{sep}s={sig}")
862 }
863 None => url,
864 }
865}
866
867#[must_use]
872pub fn verify_rendition_sig(canonical_spec: &str, media_id: i64, sig: Option<&str>) -> bool {
873 match signing_key() {
874 None => true,
875 Some(key) => sig_ok(key, canonical_spec, media_id, sig),
876 }
877}
878
879fn build_srcset(media_id: i64, specs: &[FilterPipeline], v: Option<&str>) -> String {
882 specs
883 .iter()
884 .filter_map(|sp| {
885 sp.geometric
886 .nominal_width()
887 .map(|w| format!("{} {w}w", rendition_url(media_id, &sp.canonical(), v)))
888 })
889 .collect::<Vec<_>>()
890 .join(", ")
891}
892
893fn build_dpi_srcset(
898 media_id: i64,
899 base: &FilterPipeline,
900 densities: &[u32],
901 v: Option<&str>,
902) -> String {
903 let mut ds: Vec<u32> = densities.iter().copied().filter(|d| *d > 0).collect();
904 ds.sort_unstable();
905 ds.dedup();
906 ds.iter()
907 .map(|d| {
908 let spec = FilterPipeline {
909 geometric: base.geometric.scaled(*d),
910 encoding: base.encoding,
911 };
912 format!("{} {d}x", rendition_url(media_id, &spec.canonical(), v))
913 })
914 .collect::<Vec<_>>()
915 .join(", ")
916}
917
918fn attr_escape(s: &str) -> String {
919 s.replace('&', "&")
920 .replace('<', "<")
921 .replace('>', ">")
922 .replace('"', """)
923}
924
925fn format_mime(fmt: &str) -> Option<&'static str> {
928 Some(match fmt {
929 "avif" => "image/avif",
930 "webp" | "auto" => "image/webp",
931 "jpeg" | "jpg" => "image/jpeg",
932 "png" => "image/png",
933 _ => return None,
934 })
935}
936
937fn build_picture(
941 media_id: i64,
942 specs: &[FilterPipeline],
943 formats: &[String],
944 alt: &str,
945 sizes: Option<&str>,
946 v: Option<&str>,
947) -> String {
948 let sizes_attr = sizes
949 .filter(|s| !s.is_empty())
950 .map(|s| format!(" sizes=\"{}\"", attr_escape(s)))
951 .unwrap_or_default();
952 let mut out = String::from("<picture>");
953 for fmt in formats {
954 let (Some(mime), Some(parsed)) = (format_mime(fmt), EncodeFormat::parse(fmt)) else {
955 continue;
956 };
957 let variant: Vec<FilterPipeline> = specs
958 .iter()
959 .map(|sp| {
960 let mut s = *sp;
961 s.encoding.format = Some(parsed);
962 s
963 })
964 .collect();
965 let srcset = build_srcset(media_id, &variant, v);
966 if !srcset.is_empty() {
967 out.push_str(&format!(
968 "<source type=\"{mime}\" srcset=\"{srcset}\"{sizes_attr}>"
969 ));
970 }
971 }
972 let base_srcset = build_srcset(media_id, specs, v);
973 let fallback = specs
974 .iter()
975 .max_by_key(|sp| sp.geometric.nominal_width().unwrap_or(0))
976 .map(|sp| rendition_url(media_id, &sp.canonical(), v))
977 .unwrap_or_default();
978 let srcset_attr = if base_srcset.is_empty() {
979 String::new()
980 } else {
981 format!(" srcset=\"{base_srcset}\"")
982 };
983 out.push_str(&format!(
984 "<img src=\"{fallback}\"{srcset_attr}{sizes_attr} alt=\"{}\" loading=\"lazy\" decoding=\"async\"></picture>",
985 attr_escape(alt),
986 ));
987 out
988}
989
990struct RcmsImageSrcsetFn;
993impl tera::Function for RcmsImageSrcsetFn {
994 fn call(
995 &self,
996 args: &std::collections::HashMap<String, tera::Value>,
997 ) -> tera::Result<tera::Value> {
998 let media_id = parse_media_id_arg(args)
999 .ok_or_else(|| tera::Error::msg("rcms_image_srcset: `media_id` (i64) is required"))?;
1000 let specs = parse_filters_arg(args, "rcms_image_srcset")?;
1001 let v = args.get("v").and_then(tera::Value::as_str);
1002 Ok(tera::Value::String(build_srcset(media_id, &specs, v)))
1003 }
1004 fn is_safe(&self) -> bool {
1005 true
1006 }
1007}
1008
1009struct RcmsImageSrcsetDpiFn;
1013impl tera::Function for RcmsImageSrcsetDpiFn {
1014 fn call(
1015 &self,
1016 args: &std::collections::HashMap<String, tera::Value>,
1017 ) -> tera::Result<tera::Value> {
1018 let media_id = parse_media_id_arg(args).ok_or_else(|| {
1019 tera::Error::msg("rcms_image_srcset_dpi: `media_id` (i64) is required")
1020 })?;
1021 let filter = args
1022 .get("filter")
1023 .and_then(tera::Value::as_str)
1024 .ok_or_else(|| {
1025 tera::Error::msg("rcms_image_srcset_dpi: `filter` (string) is required")
1026 })?;
1027 let base = FilterPipeline::parse(filter)
1028 .map_err(|e| tera::Error::msg(format!("rcms_image_srcset_dpi: {e}")))?;
1029 let densities: Vec<u32> = args
1030 .get("densities")
1031 .and_then(|v| v.as_array())
1032 .map(|a| {
1033 a.iter()
1034 .filter_map(|x| x.as_u64().map(|n| n as u32))
1035 .collect()
1036 })
1037 .unwrap_or_else(|| vec![1, 2]);
1038 let v = args.get("v").and_then(tera::Value::as_str);
1039 Ok(tera::Value::String(build_dpi_srcset(
1040 media_id, &base, &densities, v,
1041 )))
1042 }
1043 fn is_safe(&self) -> bool {
1044 true
1045 }
1046}
1047
1048struct RcmsPictureFn;
1052impl tera::Function for RcmsPictureFn {
1053 fn call(
1054 &self,
1055 args: &std::collections::HashMap<String, tera::Value>,
1056 ) -> tera::Result<tera::Value> {
1057 let media_id = parse_media_id_arg(args)
1058 .ok_or_else(|| tera::Error::msg("rcms_picture: `media_id` (i64) is required"))?;
1059 let specs = parse_filters_arg(args, "rcms_picture")?;
1060 let formats: Vec<String> = args
1061 .get("formats")
1062 .and_then(|v| v.as_array())
1063 .map(|a| {
1064 a.iter()
1065 .filter_map(|x| x.as_str().map(str::to_owned))
1066 .collect()
1067 })
1068 .unwrap_or_else(|| vec!["avif".to_owned(), "webp".to_owned()]);
1069 let alt = args.get("alt").and_then(tera::Value::as_str).unwrap_or("");
1070 let sizes = args.get("sizes").and_then(tera::Value::as_str);
1071 let v = args.get("v").and_then(tera::Value::as_str);
1072 Ok(tera::Value::String(build_picture(
1073 media_id, &specs, &formats, alt, sizes, v,
1074 )))
1075 }
1076 fn is_safe(&self) -> bool {
1077 true
1078 }
1079}
1080
1081#[cfg(test)]
1082mod tests {
1083 use super::*;
1084
1085 #[rustango::__private_runtime::tokio::test(flavor = "current_thread")]
1087 async fn image_work_runs_off_the_runtime() {
1088 use rustango::__private_runtime::tokio;
1089 use std::sync::atomic::{AtomicUsize, Ordering};
1090 let img = image::RgbImage::from_fn(1200, 900, |x, y| image::Rgb([(x % 251) as u8, (y % 241) as u8, 90]));
1091 let mut jpeg = Vec::new();
1092 image::DynamicImage::ImageRgb8(img)
1093 .write_to(&mut std::io::Cursor::new(&mut jpeg), image::ImageFormat::Jpeg)
1094 .expect("encode");
1095
1096 let ticks = std::sync::Arc::new(AtomicUsize::new(0));
1097 let t = std::sync::Arc::clone(&ticks);
1098 let ticker = tokio::spawn(async move {
1099 loop {
1100 tokio::time::sleep(std::time::Duration::from_millis(1)).await;
1101 t.fetch_add(1, Ordering::Relaxed);
1102 }
1103 });
1104 let (stored, dims) = strip_exif_off_runtime(jpeg, "image/jpeg".into()).await;
1105 let after_strip = ticks.load(Ordering::Relaxed);
1106 let (cropped, _) = crop_image_off_runtime(stored, "image/jpeg".into(), (0, 0, 600, 450))
1107 .await
1108 .expect("crop");
1109 let after_crop = ticks.load(Ordering::Relaxed);
1110 ticker.abort();
1111 assert_eq!(dims, Some((1200, 900)));
1112 assert!(!cropped.is_empty());
1113 assert!(after_strip >= 2, "strip stalled the runtime ({after_strip} ticks)");
1114 assert!(after_crop >= after_strip + 2, "crop stalled the runtime");
1115 }
1116
1117 #[test]
1118 fn bgcolor_with_non_ascii_bytes_is_an_error_not_a_panic() {
1119 assert!(FilterPipeline::parse("width-10|bgcolor-a\u{e9}\u{20ac}").is_err());
1120 assert!(FilterPipeline::parse("width-10|bgcolor-a\u{e9}").is_err());
1121 assert!(FilterPipeline::parse("width-10|bgcolor-fff").is_ok());
1122 }
1123
1124 #[test]
1125 fn parses_fill() {
1126 assert_eq!(
1127 FilterOp::parse("fill-300x200").unwrap(),
1128 FilterOp::Fill { w: 300, h: 200 }
1129 );
1130 }
1131
1132 #[test]
1133 fn parses_max() {
1134 assert_eq!(
1135 FilterOp::parse("max-1200x900").unwrap(),
1136 FilterOp::Max { w: 1200, h: 900 }
1137 );
1138 }
1139
1140 #[test]
1141 fn parses_width() {
1142 assert_eq!(FilterOp::parse("width-800").unwrap(), FilterOp::Width(800));
1143 }
1144
1145 #[test]
1146 fn parses_height() {
1147 assert_eq!(
1148 FilterOp::parse("height-600").unwrap(),
1149 FilterOp::Height(600)
1150 );
1151 }
1152
1153 #[test]
1154 fn rejects_garbage() {
1155 assert!(FilterOp::parse("nope").is_err());
1156 assert!(FilterOp::parse("fill-30000x30000").is_err()); assert!(FilterOp::parse("fill-0x0").is_err());
1158 assert!(FilterOp::parse("fill-300").is_err());
1159 }
1160
1161 #[test]
1162 fn canonical_roundtrips() {
1163 for raw in ["fill-300x200", "max-1200x900", "width-800", "height-600"] {
1164 let parsed = FilterOp::parse(raw).unwrap();
1165 assert_eq!(parsed.canonical(), raw);
1166 }
1167 }
1168
1169 fn fresh_tera() -> tera::Tera {
1172 let mut tera = tera::Tera::default();
1173 register_tera_function(&mut tera);
1174 tera
1175 }
1176
1177 fn render_one(src: &str, ctx_values: &[(&str, tera::Value)]) -> tera::Result<String> {
1178 let mut tera = fresh_tera();
1179 tera.add_raw_template("t.html", src)?;
1180 let mut ctx = tera::Context::new();
1181 for (k, v) in ctx_values {
1182 ctx.insert(*k, v);
1183 }
1184 tera.render("t.html", &ctx)
1185 }
1186
1187 #[test]
1188 fn image_url_accepts_int_id() {
1189 let out = render_one(
1190 r#"{{ rcms_image_url(media_id=42, filter="width-1600") }}"#,
1191 &[],
1192 )
1193 .unwrap();
1194 assert_eq!(out, "/__media__/width-1600/42");
1195 }
1196
1197 #[test]
1198 fn image_url_accepts_stringified_id() {
1199 let out = render_one(
1202 r#"{{ rcms_image_url(media_id=v, filter="width-1600") }}"#,
1203 &[("v", tera::Value::String("99".to_owned()))],
1204 )
1205 .unwrap();
1206 assert_eq!(out, "/__media__/width-1600/99");
1207 }
1208
1209 #[test]
1210 fn image_url_trims_whitespace_around_string_id() {
1211 let out = render_one(
1212 r#"{{ rcms_image_url(media_id=v, filter="max-1200x900") }}"#,
1213 &[("v", tera::Value::String(" 17 ".to_owned()))],
1214 )
1215 .unwrap();
1216 assert_eq!(out, "/__media__/max-1200x900/17");
1217 }
1218
1219 #[test]
1220 fn image_url_empty_string_id_errors() {
1221 let err = render_one(
1222 r#"{{ rcms_image_url(media_id=v, filter="width-1600") }}"#,
1223 &[("v", tera::Value::String("".to_owned()))],
1224 )
1225 .unwrap_err();
1226 assert!(
1227 format!("{err:?}").contains("media_id"),
1228 "expected media_id error, got `{err:?}`"
1229 );
1230 }
1231
1232 #[test]
1233 fn image_url_missing_filter_errors() {
1234 let err = render_one(r#"{{ rcms_image_url(media_id=42) }}"#, &[]).unwrap_err();
1235 assert!(
1236 format!("{err:?}").contains("filter"),
1237 "expected filter error, got `{err:?}`"
1238 );
1239 }
1240
1241 #[test]
1242 fn image_url_with_content_hash_buster() {
1243 let out = render_one(
1244 r#"{{ rcms_image_url(media_id=42, filter="width-800", v="abc123def456hash") }}"#,
1245 &[],
1246 )
1247 .unwrap();
1248 assert_eq!(out, "/__media__/width-800/42?v=abc123def456");
1249 }
1250
1251 #[test]
1254 fn pipeline_parses_bare_resize() {
1255 let p = FilterPipeline::parse("fill-300x200").unwrap();
1256 assert_eq!(p.geometric, FilterOp::Fill { w: 300, h: 200 });
1257 assert_eq!(p.encoding, EncodingOps::default());
1258 }
1259
1260 #[test]
1261 fn pipeline_parses_chained_encoding() {
1262 let p = FilterPipeline::parse("fill-300x200|format-webp|quality-75|bgcolor-fff").unwrap();
1263 assert_eq!(p.geometric, FilterOp::Fill { w: 300, h: 200 });
1264 assert_eq!(p.encoding.format, Some(EncodeFormat::Webp));
1265 assert_eq!(p.encoding.quality, Some(75));
1266 assert_eq!(p.encoding.background, Some((255, 255, 255)));
1267 }
1268
1269 #[test]
1270 fn pipeline_canonical_roundtrips() {
1271 let raw = "max-1200x900|format-avif|quality-80";
1274 let parsed = FilterPipeline::parse(raw).unwrap();
1275 assert_eq!(parsed.encoding.format, Some(EncodeFormat::Avif));
1276 assert_eq!(parsed.canonical(), raw);
1277 let raw = "fill-300x200|format-webp|quality-75|bgcolor-ffffff";
1278 let parsed = FilterPipeline::parse(raw).unwrap();
1279 assert_eq!(parsed.canonical(), raw);
1280 }
1281
1282 #[test]
1283 #[cfg(not(feature = "avif"))]
1284 fn avif_encode_errors_clearly_without_feature() {
1285 let img = image::DynamicImage::new_rgb8(2, 2);
1286 let ops = EncodingOps {
1287 format: Some(EncodeFormat::Avif),
1288 quality: None,
1289 background: None,
1290 };
1291 let err = encode(&img, &ops, "image/png").unwrap_err();
1292 assert!(err.contains("avif"), "got: {err}");
1293 }
1294
1295 #[test]
1296 #[cfg(feature = "avif")]
1297 fn avif_encode_produces_avif_bytes() {
1298 let img = image::DynamicImage::new_rgb8(8, 8);
1299 let ops = EncodingOps {
1300 format: Some(EncodeFormat::Avif),
1301 quality: Some(50),
1302 background: None,
1303 };
1304 let (bytes, mime, ext) = encode(&img, &ops, "image/png").unwrap();
1305 assert!(!bytes.is_empty());
1306 assert_eq!(mime, "image/avif");
1307 assert_eq!(ext, "avif");
1308 }
1309
1310 #[test]
1311 fn pipeline_rejects_garbage_segments() {
1312 assert!(FilterPipeline::parse("fill-300x200|format-jpegxl").is_err());
1313 assert!(FilterPipeline::parse("fill-300x200|quality-0").is_err());
1314 assert!(FilterPipeline::parse("fill-300x200|quality-101").is_err());
1315 assert!(FilterPipeline::parse("fill-300x200|bgcolor-xxxx").is_err());
1316 assert!(FilterPipeline::parse("fill-300x200|nonsense").is_err());
1317 }
1318
1319 #[test]
1320 fn parse_hex_rgb_three_and_six_digit() {
1321 assert_eq!(super::parse_hex_rgb("fff"), Some((255, 255, 255)));
1322 assert_eq!(super::parse_hex_rgb("ff0000"), Some((255, 0, 0)));
1323 assert_eq!(super::parse_hex_rgb("#abcdef"), Some((171, 205, 239)));
1324 assert_eq!(super::parse_hex_rgb("ff"), None);
1325 assert_eq!(super::parse_hex_rgb("ffffff00"), None); }
1327}
1328
1329#[cfg(test)]
1330mod responsive_tests {
1331 use super::{build_dpi_srcset, build_picture, build_srcset, FilterPipeline};
1332
1333 fn specs(raw: &[&str]) -> Vec<FilterPipeline> {
1334 raw.iter()
1335 .map(|s| FilterPipeline::parse(s).unwrap())
1336 .collect()
1337 }
1338
1339 #[test]
1340 fn srcset_emits_url_and_width_descriptor() {
1341 let out = build_srcset(42, &specs(&["fill-400x300", "fill-800x600"]), None);
1342 assert_eq!(
1343 out,
1344 "/__media__/fill-400x300/42 400w, /__media__/fill-800x600/42 800w"
1345 );
1346 }
1347
1348 #[test]
1349 fn srcset_skips_height_only_specs() {
1350 let out = build_srcset(7, &specs(&["height-200", "width-600"]), None);
1352 assert_eq!(out, "/__media__/width-600/7 600w");
1353 }
1354
1355 #[test]
1356 fn srcset_appends_cache_buster_truncated() {
1357 let out = build_srcset(1, &specs(&["width-300"]), Some("0123456789abcdef"));
1358 assert_eq!(out, "/__media__/width-300/1?v=0123456789ab 300w");
1359 }
1360
1361 #[test]
1362 fn dpi_srcset_scales_width_per_density() {
1363 let base = FilterPipeline::parse("width-400").unwrap();
1364 assert_eq!(
1365 build_dpi_srcset(42, &base, &[1, 2], None),
1366 "/__media__/width-400/42 1x, /__media__/width-800/42 2x"
1367 );
1368 }
1369
1370 #[test]
1371 fn dpi_srcset_scales_both_fill_dims_and_dedups_densities() {
1372 let base = FilterPipeline::parse("fill-200x100").unwrap();
1373 let out = build_dpi_srcset(7, &base, &[2, 1, 2, 0], None);
1375 assert_eq!(
1376 out,
1377 "/__media__/fill-200x100/7 1x, /__media__/fill-400x200/7 2x"
1378 );
1379 }
1380
1381 #[test]
1382 fn dpi_srcset_caps_at_8192() {
1383 let base = FilterPipeline::parse("width-5000").unwrap();
1384 assert_eq!(
1386 build_dpi_srcset(1, &base, &[2], None),
1387 "/__media__/width-8192/1 2x"
1388 );
1389 }
1390
1391 #[test]
1392 fn rendition_url_for_parses_and_rejects_bad_spec() {
1393 assert_eq!(
1396 super::rendition_url_for(42, "width-800", Some("abc123def456ZZ")),
1397 Some("/__media__/width-800/42?v=abc123def456".to_owned())
1398 );
1399 assert_eq!(super::rendition_url_for(42, "not-a-spec", None), None);
1400 }
1401
1402 #[test]
1403 fn picture_has_source_per_format_and_img_fallback() {
1404 let html = build_picture(
1405 42,
1406 &specs(&["width-400", "width-800"]),
1407 &["avif".to_owned(), "webp".to_owned()],
1408 "A <photo> & more",
1409 Some("100vw"),
1410 None,
1411 );
1412 assert!(html.contains(r#"<source type="image/avif" srcset="/__media__/width-400|format-avif/42 400w, /__media__/width-800|format-avif/42 800w" sizes="100vw">"#), "{html}");
1414 assert!(html.contains(r#"<source type="image/webp" srcset="/__media__/width-400|format-webp/42 400w, /__media__/width-800|format-webp/42 800w" sizes="100vw">"#), "{html}");
1415 assert!(
1417 html.contains(r#"<img src="/__media__/width-800/42""#),
1418 "{html}"
1419 );
1420 assert!(
1421 html.contains(r#"alt="A <photo> & more""#),
1422 "{html}"
1423 );
1424 assert!(
1425 html.starts_with("<picture>") && html.ends_with("</picture>"),
1426 "{html}"
1427 );
1428 }
1429
1430 #[test]
1431 fn picture_skips_unknown_format_token() {
1432 let html = build_picture(
1433 5,
1434 &specs(&["width-500"]),
1435 &["bogus".to_owned(), "webp".to_owned()],
1436 "",
1437 None,
1438 None,
1439 );
1440 assert!(!html.contains("bogus"), "{html}");
1441 assert!(html.contains(r#"type="image/webp""#), "{html}");
1442 }
1443
1444 #[test]
1445 fn tera_functions_render_end_to_end() {
1446 let mut tera = tera::Tera::default();
1449 super::register_tera_function(&mut tera);
1450 tera.add_raw_template(
1451 "s.html",
1452 r#"{{ rcms_image_srcset(media_id=42, filters=["width-400", "width-800"]) }}"#,
1453 )
1454 .unwrap();
1455 assert_eq!(
1456 tera.render("s.html", &tera::Context::new()).unwrap(),
1457 "/__media__/width-400/42 400w, /__media__/width-800/42 800w"
1458 );
1459 tera.add_raw_template(
1460 "p.html",
1461 r#"{{ rcms_picture(media_id=7, filters=["width-600"], formats=["webp"], alt="hi") }}"#,
1462 )
1463 .unwrap();
1464 let p = tera.render("p.html", &tera::Context::new()).unwrap();
1465 assert!(p.contains(r#"type="image/webp""#), "{p}");
1466 assert!(p.contains(r#"alt="hi""#), "{p}");
1467 assert!(p.starts_with("<picture>"), "{p}");
1468 }
1469}
1470
1471#[cfg(test)]
1472mod sign_tests {
1473 use super::{maybe_sign, rendition_sig, sig_ok, verify_rendition_sig};
1474
1475 #[test]
1476 fn sig_is_deterministic_16_hex_and_input_sensitive() {
1477 let k = b"secret";
1478 let a = rendition_sig(k, "fill-400x300", 42);
1479 assert_eq!(a.len(), 16);
1480 assert!(a.chars().all(|c| c.is_ascii_hexdigit()), "{a}");
1481 assert_eq!(a, rendition_sig(k, "fill-400x300", 42)); assert_ne!(a, rendition_sig(k, "fill-400x300", 43)); assert_ne!(a, rendition_sig(k, "fill-401x300", 42)); assert_ne!(a, rendition_sig(b"other-key", "fill-400x300", 42)); }
1486
1487 #[test]
1488 fn sig_ok_accepts_correct_rejects_forged_or_missing() {
1489 let k = b"secret";
1490 let good = rendition_sig(k, "width-800", 7);
1491 assert!(sig_ok(k, "width-800", 7, Some(&good)));
1492 assert!(!sig_ok(k, "width-800", 7, Some("deadbeefdeadbeef"))); assert!(!sig_ok(k, "width-800", 7, None)); assert!(!sig_ok(k, "width-800", 8, Some(&good))); }
1496
1497 #[test]
1498 fn disabled_signing_is_open_and_unsigned() {
1499 assert_eq!(
1503 maybe_sign("/__media__/width-800/7".to_owned(), "width-800", 7),
1504 "/__media__/width-800/7"
1505 );
1506 assert!(verify_rendition_sig("width-800", 7, None));
1507 }
1508}