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
391#[must_use]
399pub fn auto_format(image: &image::DynamicImage, source_mime: &str) -> EncodeFormat {
400 if !has_transparency(image) {
401 EncodeFormat::Jpeg
402 } else if source_mime == "image/webp" {
403 EncodeFormat::Webp
404 } else {
405 EncodeFormat::Png
406 }
407}
408
409fn has_transparency(image: &image::DynamicImage) -> bool {
411 if !image.color().has_alpha() {
412 return false;
413 }
414 match image.as_rgba8() {
415 Some(buf) => buf.pixels().any(|p| p[3] < u8::MAX),
416 None => image.to_rgba8().pixels().any(|p| p[3] < u8::MAX),
417 }
418}
419
420pub fn encode(
428 image: &image::DynamicImage,
429 encoding: &EncodingOps,
430 source_mime: &str,
431) -> Result<(Vec<u8>, String, String), String> {
432 use image::codecs::jpeg::JpegEncoder;
433 let format = match encoding.format {
434 None | Some(EncodeFormat::Auto) => auto_format(image, source_mime),
435 Some(explicit) => explicit,
436 };
437
438 let needs_flatten = matches!(format, EncodeFormat::Jpeg) || encoding.background.is_some();
441 let prepared: image::DynamicImage = if needs_flatten && encoding.background.is_some() {
442 let (r, g, b) = encoding.background.unwrap();
443 flatten_onto_background(image, r, g, b)
444 } else if matches!(format, EncodeFormat::Jpeg) && image.color().has_alpha() {
445 flatten_onto_background(image, 255, 255, 255)
448 } else {
449 image.clone()
450 };
451
452 let mut out: Vec<u8> = Vec::new();
453 match format {
454 EncodeFormat::Jpeg => {
455 let quality = encoding.quality.unwrap_or(85);
456 let mut cur = std::io::Cursor::new(&mut out);
457 let mut enc = JpegEncoder::new_with_quality(&mut cur, quality);
458 enc.encode_image(&prepared)
459 .map_err(|e| format!("encode jpeg: {e}"))?;
460 }
461 EncodeFormat::Png => {
462 let mut cur = std::io::Cursor::new(&mut out);
464 prepared
465 .write_to(&mut cur, image::ImageFormat::Png)
466 .map_err(|e| format!("encode png: {e}"))?;
467 }
468 EncodeFormat::Webp | EncodeFormat::Auto => {
469 let mut cur = std::io::Cursor::new(&mut out);
474 prepared
475 .write_to(&mut cur, image::ImageFormat::WebP)
476 .map_err(|e| format!("encode webp: {e}"))?;
477 }
478 EncodeFormat::Avif => {
479 #[cfg(feature = "avif")]
482 {
483 let quality = encoding.quality.unwrap_or(61);
486 let mut cur = std::io::Cursor::new(&mut out);
487 let enc =
488 image::codecs::avif::AvifEncoder::new_with_speed_quality(&mut cur, 4, quality);
489 prepared
490 .write_with_encoder(enc)
491 .map_err(|e| format!("encode avif: {e}"))?;
492 }
493 #[cfg(not(feature = "avif"))]
494 {
495 let _ = &prepared;
496 return Err(
497 "AVIF output requires building rustango-cms with the `avif` feature".to_owned(),
498 );
499 }
500 }
501 }
502 Ok((out, format.mime().to_owned(), format.ext().to_owned()))
503}
504
505fn flatten_onto_background(src: &image::DynamicImage, r: u8, g: u8, b: u8) -> image::DynamicImage {
508 use image::GenericImageView;
509 let (w, h) = src.dimensions();
510 let mut buf = image::RgbaImage::from_pixel(w, h, image::Rgba([r, g, b, 255]));
511 let rgba = src.to_rgba8();
512 image::imageops::overlay(&mut buf, &rgba, 0, 0);
513 image::DynamicImage::ImageRgba8(buf)
514}
515
516pub async fn crop_image_off_runtime(
525 bytes: Vec<u8>,
526 source_mime: String,
527 (x, y, w, h): (u32, u32, u32, u32),
528) -> Result<(Vec<u8>, String), String> {
529 rustango::__private_runtime::tokio::task::spawn_blocking(move || {
530 crop_image(&bytes, &source_mime, x, y, w, h)
531 })
532 .await
533 .map_err(|e| format!("crop worker failed: {e}"))?
534}
535
536pub async fn strip_exif_off_runtime(bytes: Vec<u8>, mime: String) -> (Vec<u8>, Option<(u32, u32)>) {
540 if !mime.starts_with("image/") || mime == "image/svg+xml" {
541 return (bytes, None);
542 }
543 rustango::__private_runtime::tokio::task::spawn_blocking(move || {
544 let (stripped, dims) = strip_exif_if_image(&bytes, &mime);
545 (stripped.unwrap_or(bytes), dims)
546 })
547 .await
548 .unwrap_or_else(|e| std::panic::resume_unwind(e.into_panic()))
549}
550
551pub fn crop_image(
560 bytes: &[u8],
561 source_mime: &str,
562 x: u32,
563 y: u32,
564 w: u32,
565 h: u32,
566) -> Result<(Vec<u8>, String), String> {
567 if source_mime == "image/svg+xml" {
568 return Err(
569 "Cropping SVG sources isn't supported — clone first, edit the markup directly."
570 .to_owned(),
571 );
572 }
573 let img = image::load_from_memory(bytes).map_err(|e| format!("decode source: {e}"))?;
574 let (sw, sh) = (img.width(), img.height());
575 if w == 0 || h == 0 {
576 return Err("Crop rectangle must have non-zero width + height.".to_owned());
577 }
578 if x.saturating_add(w) > sw || y.saturating_add(h) > sh {
579 return Err(format!(
580 "Crop rectangle ({x},{y},{w},{h}) is outside the source ({sw}×{sh})."
581 ));
582 }
583 let cropped = img.crop_imm(x, y, w, h);
584 let mut out: Vec<u8> = Vec::new();
585 let out_mime = if source_mime == "image/jpeg" || source_mime == "image/jpg" {
586 let mut cur = std::io::Cursor::new(&mut out);
587 cropped
588 .write_to(&mut cur, image::ImageFormat::Jpeg)
589 .map_err(|e| format!("encode jpeg: {e}"))?;
590 "image/jpeg".to_owned()
591 } else if source_mime == "image/webp" {
592 let mut cur = std::io::Cursor::new(&mut out);
593 cropped
594 .write_to(&mut cur, image::ImageFormat::WebP)
595 .map_err(|e| format!("encode webp: {e}"))?;
596 "image/webp".to_owned()
597 } else {
598 let mut cur = std::io::Cursor::new(&mut out);
602 cropped
603 .write_to(&mut cur, image::ImageFormat::Png)
604 .map_err(|e| format!("encode png: {e}"))?;
605 "image/png".to_owned()
606 };
607 Ok((out, out_mime))
608}
609
610#[must_use]
619pub fn strip_exif_if_image(bytes: &[u8], mime: &str) -> (Option<Vec<u8>>, Option<(u32, u32)>) {
620 if !mime.starts_with("image/") || mime == "image/svg+xml" {
621 return (None, None);
622 }
623 let img = match image::load_from_memory(bytes) {
624 Ok(img) => img,
625 Err(e) => {
626 tracing::warn!(
627 target: "rustango_cms::rendition",
628 mime, error = %e,
629 "EXIF strip: decode failed, keeping original bytes"
630 );
631 return (None, None);
632 }
633 };
634 let dims = (img.width(), img.height());
635 let format = match mime {
636 "image/jpeg" | "image/jpg" => image::ImageFormat::Jpeg,
637 "image/png" => image::ImageFormat::Png,
638 "image/webp" => image::ImageFormat::WebP,
639 "image/gif" => image::ImageFormat::Gif,
640 "image/avif" => image::ImageFormat::Avif,
641 _ => image::ImageFormat::Png,
643 };
644 let mut out: Vec<u8> = Vec::with_capacity(bytes.len());
645 {
646 let mut cur = std::io::Cursor::new(&mut out);
647 if let Err(e) = img.write_to(&mut cur, format) {
648 tracing::warn!(
649 target: "rustango_cms::rendition",
650 mime, error = %e,
651 "EXIF strip: re-encode failed, keeping original bytes"
652 );
653 return (None, Some(dims));
654 }
655 }
656 (Some(out), Some(dims))
657}
658
659pub fn register_tera_function(tera: &mut tera::Tera) {
672 tera.register_function("rcms_image_url", RcmsImageUrlFn);
673 tera.register_function("rcms_image_srcset", RcmsImageSrcsetFn);
676 tera.register_function("rcms_image_srcset_dpi", RcmsImageSrcsetDpiFn);
677 tera.register_function("rcms_picture", RcmsPictureFn);
678}
679
680struct RcmsImageUrlFn;
685
686impl tera::Function for RcmsImageUrlFn {
687 fn call(
688 &self,
689 args: &std::collections::HashMap<String, tera::Value>,
690 ) -> tera::Result<tera::Value> {
691 rcms_image_url(args)
692 }
693 fn is_safe(&self) -> bool {
694 true
695 }
696}
697
698fn rcms_image_url(
699 args: &std::collections::HashMap<String, tera::Value>,
700) -> tera::Result<tera::Value> {
701 let media_id = parse_media_id_arg(args)
702 .ok_or_else(|| tera::Error::msg("rcms_image_url: `media_id` (i64) is required"))?;
703 let filter = args
704 .get("filter")
705 .and_then(tera::Value::as_str)
706 .ok_or_else(|| tera::Error::msg("rcms_image_url: `filter` (string) is required"))?;
707 let pipeline = FilterPipeline::parse(filter)
710 .map_err(|e| tera::Error::msg(format!("rcms_image_url: {e}")))?;
711 let v = args.get("v").and_then(tera::Value::as_str);
718 Ok(tera::Value::String(rendition_url(
719 media_id,
720 &pipeline.canonical(),
721 v,
722 )))
723}
724
725impl FilterOp {
728 fn nominal_width(self) -> Option<u32> {
731 match self {
732 Self::Fill { w, .. } | Self::Max { w, .. } | Self::Width(w) => Some(w),
733 Self::Height(_) => None,
734 }
735 }
736
737 fn scaled(self, factor: u32) -> Self {
741 let cap = |n: u32| n.saturating_mul(factor).min(8192);
742 match self {
743 Self::Fill { w, h } => Self::Fill {
744 w: cap(w),
745 h: cap(h),
746 },
747 Self::Max { w, h } => Self::Max {
748 w: cap(w),
749 h: cap(h),
750 },
751 Self::Width(w) => Self::Width(cap(w)),
752 Self::Height(h) => Self::Height(cap(h)),
753 }
754 }
755}
756
757fn parse_media_id_arg(args: &std::collections::HashMap<String, tera::Value>) -> Option<i64> {
760 args.get("media_id").and_then(|v| {
761 v.as_i64().or_else(|| {
762 v.as_str()
763 .map(str::trim)
764 .filter(|s| !s.is_empty())
765 .and_then(|s| s.parse::<i64>().ok())
766 })
767 })
768}
769
770fn parse_filters_arg(
773 args: &std::collections::HashMap<String, tera::Value>,
774 fn_name: &str,
775) -> tera::Result<Vec<FilterPipeline>> {
776 let arr = args
777 .get("filters")
778 .and_then(|v| v.as_array())
779 .ok_or_else(|| {
780 tera::Error::msg(format!(
781 "{fn_name}: `filters` (array of spec strings) is required"
782 ))
783 })?;
784 arr.iter()
785 .map(|v| {
786 let s = v.as_str().ok_or_else(|| {
787 tera::Error::msg(format!("{fn_name}: each filter must be a string"))
788 })?;
789 FilterPipeline::parse(s).map_err(|e| tera::Error::msg(format!("{fn_name}: {e}")))
790 })
791 .collect()
792}
793
794#[must_use]
800pub fn rendition_url_for(media_id: i64, spec: &str, content_hash: Option<&str>) -> Option<String> {
801 let pipeline = FilterPipeline::parse(spec).ok()?;
802 Some(rendition_url(media_id, &pipeline.canonical(), content_hash))
803}
804
805fn rendition_url(media_id: i64, canonical_spec: &str, v: Option<&str>) -> String {
808 let base = match v {
809 Some(v) if !v.is_empty() => format!(
810 "/__media__/{canonical_spec}/{media_id}?v={}",
811 &v[..12.min(v.len())]
812 ),
813 _ => format!("/__media__/{canonical_spec}/{media_id}"),
814 };
815 maybe_sign(base, canonical_spec, media_id)
816}
817
818#[derive(PartialEq, Eq)]
822struct SigningKey {
823 bytes: Vec<u8>,
824 strict: bool,
828}
829
830static SIGNING_KEY: std::sync::OnceLock<SigningKey> = std::sync::OnceLock::new();
831
832pub fn set_signing_key(key: impl Into<Vec<u8>>) {
850 let key = SigningKey { bytes: key.into(), strict: true };
851 if let Err(rejected) = SIGNING_KEY.set(key) {
852 if SIGNING_KEY.get() != Some(&rejected) {
853 tracing::error!(
854 target: "rustango_cms::rendition",
855 "set_signing_key called after the key was already fixed (set earlier, or read \
856 from RCMS_RENDITION_SIGNING_KEY); this call has no effect — set it before serving"
857 );
858 }
859 }
860}
861
862pub fn init_signing() {
866 let _ = signing_key();
867}
868
869fn signing_key() -> &'static SigningKey {
872 SIGNING_KEY.get_or_init(|| match crate::config::var("RENDITION_SIGNING_KEY") {
873 Some(k) => SigningKey { bytes: k.into_bytes(), strict: true },
874 None => {
875 tracing::info!(
876 target: "rustango_cms::rendition",
877 max_variants = max_unsigned_variants(),
878 "image URLs the CMS renders are signed; unsigned ones (API clients) are capped per \
879 image — set RCMS_RENDITION_SIGNING_KEY to require a signature on every request"
880 );
881 SigningKey { bytes: crate::signing::derived_key("rendition-url"), strict: false }
882 }
883 })
884}
885
886pub const DEFAULT_MAX_UNSIGNED_VARIANTS: usize = 128;
888
889#[must_use]
897pub fn max_unsigned_variants() -> usize {
898 static MAX: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
899 *MAX.get_or_init(|| parse_max_unsigned(crate::config::var("RENDITION_MAX_UNSIGNED").as_deref()))
900}
901
902fn parse_max_unsigned(raw: Option<&str>) -> usize {
903 raw.and_then(|v| v.trim().parse::<usize>().ok())
904 .filter(|n| *n > 0)
905 .unwrap_or(DEFAULT_MAX_UNSIGNED_VARIANTS)
906}
907
908fn rendition_sig(key: &[u8], canonical_spec: &str, media_id: i64) -> String {
911 let msg = format!("{canonical_spec}:{media_id}");
912 let full = crate::signing::hmac_sha256_hex(key, msg.as_bytes());
913 full[..16].to_owned()
914}
915
916fn sig_ok(key: &[u8], canonical_spec: &str, media_id: i64, supplied: Option<&str>) -> bool {
919 let expected = rendition_sig(key, canonical_spec, media_id);
920 supplied.is_some_and(|s| crate::signing::constant_time_eq(s.as_bytes(), expected.as_bytes()))
921}
922
923fn maybe_sign(url: String, canonical_spec: &str, media_id: i64) -> String {
925 sign_with(&signing_key().bytes, url, canonical_spec, media_id)
926}
927
928fn sign_with(key: &[u8], url: String, canonical_spec: &str, media_id: i64) -> String {
929 let sig = rendition_sig(key, canonical_spec, media_id);
930 let sep = if url.contains('?') { '&' } else { '?' };
931 format!("{url}{sep}s={sig}")
932}
933
934#[derive(Debug, Clone, Copy, PartialEq, Eq)]
936pub enum RenditionSig {
937 Valid,
939 Unsigned,
942 Rejected,
944}
945
946#[must_use]
949pub fn check_rendition_sig(canonical_spec: &str, media_id: i64, sig: Option<&str>) -> RenditionSig {
950 let key = signing_key();
951 classify_sig(&key.bytes, key.strict, canonical_spec, media_id, sig)
952}
953
954fn classify_sig(key: &[u8], strict: bool, canonical_spec: &str, media_id: i64, sig: Option<&str>) -> RenditionSig {
959 if sig_ok(key, canonical_spec, media_id, sig) {
960 RenditionSig::Valid
961 } else if strict {
962 RenditionSig::Rejected
963 } else {
964 RenditionSig::Unsigned
965 }
966}
967
968fn build_srcset(media_id: i64, specs: &[FilterPipeline], v: Option<&str>) -> String {
971 specs
972 .iter()
973 .filter_map(|sp| {
974 sp.geometric
975 .nominal_width()
976 .map(|w| format!("{} {w}w", rendition_url(media_id, &sp.canonical(), v)))
977 })
978 .collect::<Vec<_>>()
979 .join(", ")
980}
981
982fn build_dpi_srcset(
987 media_id: i64,
988 base: &FilterPipeline,
989 densities: &[u32],
990 v: Option<&str>,
991) -> String {
992 let mut ds: Vec<u32> = densities.iter().copied().filter(|d| *d > 0).collect();
993 ds.sort_unstable();
994 ds.dedup();
995 ds.iter()
996 .map(|d| {
997 let spec = FilterPipeline {
998 geometric: base.geometric.scaled(*d),
999 encoding: base.encoding,
1000 };
1001 format!("{} {d}x", rendition_url(media_id, &spec.canonical(), v))
1002 })
1003 .collect::<Vec<_>>()
1004 .join(", ")
1005}
1006
1007fn attr_escape(s: &str) -> String {
1008 s.replace('&', "&")
1009 .replace('<', "<")
1010 .replace('>', ">")
1011 .replace('"', """)
1012}
1013
1014fn format_mime(fmt: &str) -> Option<&'static str> {
1017 Some(match fmt {
1018 "avif" => "image/avif",
1019 "webp" => "image/webp",
1020 "jpeg" | "jpg" => "image/jpeg",
1021 "png" => "image/png",
1022 _ => return None,
1023 })
1024}
1025
1026fn build_picture(
1030 media_id: i64,
1031 specs: &[FilterPipeline],
1032 formats: &[String],
1033 alt: &str,
1034 sizes: Option<&str>,
1035 v: Option<&str>,
1036) -> String {
1037 let sizes_attr = sizes
1038 .filter(|s| !s.is_empty())
1039 .map(|s| format!(" sizes=\"{}\"", attr_escape(s)))
1040 .unwrap_or_default();
1041 let mut out = String::from("<picture>");
1042 for fmt in formats {
1043 let (Some(mime), Some(parsed)) = (format_mime(fmt), EncodeFormat::parse(fmt)) else {
1044 continue;
1045 };
1046 let variant: Vec<FilterPipeline> = specs
1047 .iter()
1048 .map(|sp| {
1049 let mut s = *sp;
1050 s.encoding.format = Some(parsed);
1051 s
1052 })
1053 .collect();
1054 let srcset = build_srcset(media_id, &variant, v);
1055 if !srcset.is_empty() {
1056 out.push_str(&format!(
1057 "<source type=\"{mime}\" srcset=\"{srcset}\"{sizes_attr}>"
1058 ));
1059 }
1060 }
1061 let base_srcset = build_srcset(media_id, specs, v);
1062 let fallback = specs
1063 .iter()
1064 .max_by_key(|sp| sp.geometric.nominal_width().unwrap_or(0))
1065 .map(|sp| rendition_url(media_id, &sp.canonical(), v))
1066 .unwrap_or_default();
1067 let srcset_attr = if base_srcset.is_empty() {
1068 String::new()
1069 } else {
1070 format!(" srcset=\"{base_srcset}\"")
1071 };
1072 out.push_str(&format!(
1073 "<img src=\"{fallback}\"{srcset_attr}{sizes_attr} alt=\"{}\" loading=\"lazy\" decoding=\"async\"></picture>",
1074 attr_escape(alt),
1075 ));
1076 out
1077}
1078
1079struct RcmsImageSrcsetFn;
1082impl tera::Function for RcmsImageSrcsetFn {
1083 fn call(
1084 &self,
1085 args: &std::collections::HashMap<String, tera::Value>,
1086 ) -> tera::Result<tera::Value> {
1087 let media_id = parse_media_id_arg(args)
1088 .ok_or_else(|| tera::Error::msg("rcms_image_srcset: `media_id` (i64) is required"))?;
1089 let specs = parse_filters_arg(args, "rcms_image_srcset")?;
1090 let v = args.get("v").and_then(tera::Value::as_str);
1091 Ok(tera::Value::String(build_srcset(media_id, &specs, v)))
1092 }
1093 fn is_safe(&self) -> bool {
1094 true
1095 }
1096}
1097
1098struct RcmsImageSrcsetDpiFn;
1102impl tera::Function for RcmsImageSrcsetDpiFn {
1103 fn call(
1104 &self,
1105 args: &std::collections::HashMap<String, tera::Value>,
1106 ) -> tera::Result<tera::Value> {
1107 let media_id = parse_media_id_arg(args).ok_or_else(|| {
1108 tera::Error::msg("rcms_image_srcset_dpi: `media_id` (i64) is required")
1109 })?;
1110 let filter = args
1111 .get("filter")
1112 .and_then(tera::Value::as_str)
1113 .ok_or_else(|| {
1114 tera::Error::msg("rcms_image_srcset_dpi: `filter` (string) is required")
1115 })?;
1116 let base = FilterPipeline::parse(filter)
1117 .map_err(|e| tera::Error::msg(format!("rcms_image_srcset_dpi: {e}")))?;
1118 let densities: Vec<u32> = args
1119 .get("densities")
1120 .and_then(|v| v.as_array())
1121 .map(|a| {
1122 a.iter()
1123 .filter_map(|x| x.as_u64().map(|n| n as u32))
1124 .collect()
1125 })
1126 .unwrap_or_else(|| vec![1, 2]);
1127 let v = args.get("v").and_then(tera::Value::as_str);
1128 Ok(tera::Value::String(build_dpi_srcset(
1129 media_id, &base, &densities, v,
1130 )))
1131 }
1132 fn is_safe(&self) -> bool {
1133 true
1134 }
1135}
1136
1137struct RcmsPictureFn;
1141impl tera::Function for RcmsPictureFn {
1142 fn call(
1143 &self,
1144 args: &std::collections::HashMap<String, tera::Value>,
1145 ) -> tera::Result<tera::Value> {
1146 let media_id = parse_media_id_arg(args)
1147 .ok_or_else(|| tera::Error::msg("rcms_picture: `media_id` (i64) is required"))?;
1148 let specs = parse_filters_arg(args, "rcms_picture")?;
1149 let formats: Vec<String> = args
1150 .get("formats")
1151 .and_then(|v| v.as_array())
1152 .map(|a| {
1153 a.iter()
1154 .filter_map(|x| x.as_str().map(str::to_owned))
1155 .collect()
1156 })
1157 .unwrap_or_else(|| vec!["avif".to_owned(), "webp".to_owned()]);
1158 let alt = args.get("alt").and_then(tera::Value::as_str).unwrap_or("");
1159 let sizes = args.get("sizes").and_then(tera::Value::as_str);
1160 let v = args.get("v").and_then(tera::Value::as_str);
1161 Ok(tera::Value::String(build_picture(
1162 media_id, &specs, &formats, alt, sizes, v,
1163 )))
1164 }
1165 fn is_safe(&self) -> bool {
1166 true
1167 }
1168}
1169
1170#[cfg(test)]
1171mod tests {
1172 use super::*;
1173
1174 #[rustango::__private_runtime::tokio::test(flavor = "current_thread")]
1176 async fn image_work_runs_off_the_runtime() {
1177 use rustango::__private_runtime::tokio;
1178 use std::sync::atomic::{AtomicUsize, Ordering};
1179 let img = image::RgbImage::from_fn(1200, 900, |x, y| image::Rgb([(x % 251) as u8, (y % 241) as u8, 90]));
1180 let mut jpeg = Vec::new();
1181 image::DynamicImage::ImageRgb8(img)
1182 .write_to(&mut std::io::Cursor::new(&mut jpeg), image::ImageFormat::Jpeg)
1183 .expect("encode");
1184
1185 let ticks = std::sync::Arc::new(AtomicUsize::new(0));
1186 let t = std::sync::Arc::clone(&ticks);
1187 let ticker = tokio::spawn(async move {
1188 loop {
1189 tokio::time::sleep(std::time::Duration::from_millis(1)).await;
1190 t.fetch_add(1, Ordering::Relaxed);
1191 }
1192 });
1193 let (stored, dims) = strip_exif_off_runtime(jpeg, "image/jpeg".into()).await;
1194 let after_strip = ticks.load(Ordering::Relaxed);
1195 let (cropped, _) = crop_image_off_runtime(stored, "image/jpeg".into(), (0, 0, 600, 450))
1196 .await
1197 .expect("crop");
1198 let after_crop = ticks.load(Ordering::Relaxed);
1199 ticker.abort();
1200 assert_eq!(dims, Some((1200, 900)));
1201 assert!(!cropped.is_empty());
1202 assert!(after_strip >= 2, "strip stalled the runtime ({after_strip} ticks)");
1203 assert!(after_crop >= after_strip + 2, "crop stalled the runtime");
1204 }
1205
1206 #[test]
1207 fn bgcolor_with_non_ascii_bytes_is_an_error_not_a_panic() {
1208 assert!(FilterPipeline::parse("width-10|bgcolor-a\u{e9}\u{20ac}").is_err());
1209 assert!(FilterPipeline::parse("width-10|bgcolor-a\u{e9}").is_err());
1210 assert!(FilterPipeline::parse("width-10|bgcolor-fff").is_ok());
1211 }
1212
1213 #[test]
1214 fn parses_fill() {
1215 assert_eq!(
1216 FilterOp::parse("fill-300x200").unwrap(),
1217 FilterOp::Fill { w: 300, h: 200 }
1218 );
1219 }
1220
1221 #[test]
1222 fn parses_max() {
1223 assert_eq!(
1224 FilterOp::parse("max-1200x900").unwrap(),
1225 FilterOp::Max { w: 1200, h: 900 }
1226 );
1227 }
1228
1229 #[test]
1230 fn parses_width() {
1231 assert_eq!(FilterOp::parse("width-800").unwrap(), FilterOp::Width(800));
1232 }
1233
1234 #[test]
1235 fn parses_height() {
1236 assert_eq!(
1237 FilterOp::parse("height-600").unwrap(),
1238 FilterOp::Height(600)
1239 );
1240 }
1241
1242 #[test]
1243 fn rejects_garbage() {
1244 assert!(FilterOp::parse("nope").is_err());
1245 assert!(FilterOp::parse("fill-30000x30000").is_err()); assert!(FilterOp::parse("fill-0x0").is_err());
1247 assert!(FilterOp::parse("fill-300").is_err());
1248 }
1249
1250 #[test]
1251 fn canonical_roundtrips() {
1252 for raw in ["fill-300x200", "max-1200x900", "width-800", "height-600"] {
1253 let parsed = FilterOp::parse(raw).unwrap();
1254 assert_eq!(parsed.canonical(), raw);
1255 }
1256 }
1257
1258 fn fresh_tera() -> tera::Tera {
1261 let mut tera = tera::Tera::default();
1262 register_tera_function(&mut tera);
1263 tera
1264 }
1265
1266 fn render_one(src: &str, ctx_values: &[(&str, tera::Value)]) -> tera::Result<String> {
1267 let mut tera = fresh_tera();
1268 tera.add_raw_template("t.html", src)?;
1269 let mut ctx = tera::Context::new();
1270 for (k, v) in ctx_values {
1271 ctx.insert(*k, v);
1272 }
1273 tera.render("t.html", &ctx)
1274 }
1275
1276 #[test]
1277 fn image_url_accepts_int_id() {
1278 let out = render_one(
1279 r#"{{ rcms_image_url(media_id=42, filter="width-1600") }}"#,
1280 &[],
1281 )
1282 .unwrap();
1283 assert_eq!(crate::rendition::strip_sig(&out), "/__media__/width-1600/42");
1284 }
1285
1286 #[test]
1287 fn image_url_accepts_stringified_id() {
1288 let out = render_one(
1291 r#"{{ rcms_image_url(media_id=v, filter="width-1600") }}"#,
1292 &[("v", tera::Value::String("99".to_owned()))],
1293 )
1294 .unwrap();
1295 assert_eq!(crate::rendition::strip_sig(&out), "/__media__/width-1600/99");
1296 }
1297
1298 #[test]
1299 fn image_url_trims_whitespace_around_string_id() {
1300 let out = render_one(
1301 r#"{{ rcms_image_url(media_id=v, filter="max-1200x900") }}"#,
1302 &[("v", tera::Value::String(" 17 ".to_owned()))],
1303 )
1304 .unwrap();
1305 assert_eq!(crate::rendition::strip_sig(&out), "/__media__/max-1200x900/17");
1306 }
1307
1308 #[test]
1309 fn image_url_empty_string_id_errors() {
1310 let err = render_one(
1311 r#"{{ rcms_image_url(media_id=v, filter="width-1600") }}"#,
1312 &[("v", tera::Value::String("".to_owned()))],
1313 )
1314 .unwrap_err();
1315 assert!(
1316 format!("{err:?}").contains("media_id"),
1317 "expected media_id error, got `{err:?}`"
1318 );
1319 }
1320
1321 #[test]
1322 fn image_url_missing_filter_errors() {
1323 let err = render_one(r#"{{ rcms_image_url(media_id=42) }}"#, &[]).unwrap_err();
1324 assert!(
1325 format!("{err:?}").contains("filter"),
1326 "expected filter error, got `{err:?}`"
1327 );
1328 }
1329
1330 #[test]
1331 fn image_url_with_content_hash_buster() {
1332 let out = render_one(
1333 r#"{{ rcms_image_url(media_id=42, filter="width-800", v="abc123def456hash") }}"#,
1334 &[],
1335 )
1336 .unwrap();
1337 assert_eq!(crate::rendition::strip_sig(&out), "/__media__/width-800/42?v=abc123def456");
1338 }
1339
1340 #[test]
1343 fn pipeline_parses_bare_resize() {
1344 let p = FilterPipeline::parse("fill-300x200").unwrap();
1345 assert_eq!(p.geometric, FilterOp::Fill { w: 300, h: 200 });
1346 assert_eq!(p.encoding, EncodingOps::default());
1347 }
1348
1349 #[test]
1350 fn pipeline_parses_chained_encoding() {
1351 let p = FilterPipeline::parse("fill-300x200|format-webp|quality-75|bgcolor-fff").unwrap();
1352 assert_eq!(p.geometric, FilterOp::Fill { w: 300, h: 200 });
1353 assert_eq!(p.encoding.format, Some(EncodeFormat::Webp));
1354 assert_eq!(p.encoding.quality, Some(75));
1355 assert_eq!(p.encoding.background, Some((255, 255, 255)));
1356 }
1357
1358 #[test]
1359 fn pipeline_canonical_roundtrips() {
1360 let raw = "max-1200x900|format-avif|quality-80";
1363 let parsed = FilterPipeline::parse(raw).unwrap();
1364 assert_eq!(parsed.encoding.format, Some(EncodeFormat::Avif));
1365 assert_eq!(parsed.canonical(), raw);
1366 let raw = "fill-300x200|format-webp|quality-75|bgcolor-ffffff";
1367 let parsed = FilterPipeline::parse(raw).unwrap();
1368 assert_eq!(parsed.canonical(), raw);
1369 }
1370
1371 #[test]
1372 #[cfg(not(feature = "avif"))]
1373 fn avif_encode_errors_clearly_without_feature() {
1374 let img = image::DynamicImage::new_rgb8(2, 2);
1375 let ops = EncodingOps {
1376 format: Some(EncodeFormat::Avif),
1377 quality: None,
1378 background: None,
1379 };
1380 let err = encode(&img, &ops, "image/png").unwrap_err();
1381 assert!(err.contains("avif"), "got: {err}");
1382 }
1383
1384 #[test]
1385 #[cfg(feature = "avif")]
1386 fn avif_encode_produces_avif_bytes() {
1387 let img = image::DynamicImage::new_rgb8(8, 8);
1388 let ops = EncodingOps {
1389 format: Some(EncodeFormat::Avif),
1390 quality: Some(50),
1391 background: None,
1392 };
1393 let (bytes, mime, ext) = encode(&img, &ops, "image/png").unwrap();
1394 assert!(!bytes.is_empty());
1395 assert_eq!(mime, "image/avif");
1396 assert_eq!(ext, "avif");
1397 }
1398
1399 #[test]
1400 fn pipeline_rejects_garbage_segments() {
1401 assert!(FilterPipeline::parse("fill-300x200|format-jpegxl").is_err());
1402 assert!(FilterPipeline::parse("fill-300x200|quality-0").is_err());
1403 assert!(FilterPipeline::parse("fill-300x200|quality-101").is_err());
1404 assert!(FilterPipeline::parse("fill-300x200|bgcolor-xxxx").is_err());
1405 assert!(FilterPipeline::parse("fill-300x200|nonsense").is_err());
1406 }
1407
1408 #[test]
1409 fn parse_hex_rgb_three_and_six_digit() {
1410 assert_eq!(super::parse_hex_rgb("fff"), Some((255, 255, 255)));
1411 assert_eq!(super::parse_hex_rgb("ff0000"), Some((255, 0, 0)));
1412 assert_eq!(super::parse_hex_rgb("#abcdef"), Some((171, 205, 239)));
1413 assert_eq!(super::parse_hex_rgb("ff"), None);
1414 assert_eq!(super::parse_hex_rgb("ffffff00"), None); }
1416
1417 #[test]
1420 fn image_url_accepts_a_pipeline() {
1421 let out = render_one(
1422 r#"{{ rcms_image_url(media_id=42, filter="width-800|format-jpeg|quality-80") }}"#,
1423 &[],
1424 )
1425 .unwrap();
1426 assert_eq!(crate::rendition::strip_sig(&out), "/__media__/width-800|format-jpeg|quality-80/42");
1427 }
1428
1429 fn rgba(px: [u8; 4]) -> image::DynamicImage {
1430 image::DynamicImage::ImageRgba8(image::RgbaImage::from_pixel(4, 4, image::Rgba(px)))
1431 }
1432
1433 #[test]
1434 fn auto_format_picks_jpeg_for_opaque_and_keeps_transparency() {
1435 let opaque_rgb = image::DynamicImage::new_rgb8(4, 4);
1436 assert_eq!(auto_format(&opaque_rgb, "image/png"), EncodeFormat::Jpeg);
1437 assert_eq!(auto_format(&rgba([9, 9, 9, 255]), "image/png"), EncodeFormat::Jpeg);
1439 let mut one_clear = image::RgbaImage::from_pixel(4, 4, image::Rgba([9, 9, 9, 255]));
1440 one_clear.put_pixel(3, 3, image::Rgba([0, 0, 0, 0]));
1441 let one_clear = image::DynamicImage::ImageRgba8(one_clear);
1442 assert_eq!(auto_format(&one_clear, "image/png"), EncodeFormat::Png);
1443 assert_eq!(auto_format(&one_clear, "image/webp"), EncodeFormat::Webp);
1444 assert_eq!(auto_format(&opaque_rgb, "image/jpeg"), EncodeFormat::Jpeg);
1445 }
1446
1447 #[test]
1451 fn encode_without_a_format_follows_auto_format() {
1452 let none = EncodingOps { format: None, quality: None, background: None };
1453 let (_, mime, ext) = encode(&rgba([200, 90, 40, 255]), &none, "image/png").unwrap();
1454 assert_eq!((mime.as_str(), ext.as_str()), ("image/jpeg", "jpg"));
1455 let (_, mime, _) = encode(&rgba([200, 90, 40, 0]), &none, "image/png").unwrap();
1456 assert_eq!(mime, "image/png");
1457 let auto = EncodingOps { format: Some(EncodeFormat::Auto), ..none };
1458 let (_, mime, _) = encode(&rgba([200, 90, 40, 255]), &auto, "image/png").unwrap();
1459 assert_eq!(mime, "image/jpeg");
1460 let png = EncodingOps { format: Some(EncodeFormat::Png), ..none };
1461 let (_, mime, _) = encode(&rgba([200, 90, 40, 255]), &png, "image/png").unwrap();
1462 assert_eq!(mime, "image/png");
1463 }
1464}
1465
1466#[cfg(test)]
1467mod responsive_tests {
1468 use super::{build_picture, FilterPipeline};
1469
1470 fn build_srcset(id: i64, specs: &[FilterPipeline], v: Option<&str>) -> String {
1472 crate::rendition::strip_sig(&super::build_srcset(id, specs, v))
1473 }
1474 fn build_dpi_srcset(id: i64, base: &FilterPipeline, densities: &[u32], v: Option<&str>) -> String {
1475 crate::rendition::strip_sig(&super::build_dpi_srcset(id, base, densities, v))
1476 }
1477
1478 fn specs(raw: &[&str]) -> Vec<FilterPipeline> {
1479 raw.iter()
1480 .map(|s| FilterPipeline::parse(s).unwrap())
1481 .collect()
1482 }
1483
1484 #[test]
1485 fn srcset_emits_url_and_width_descriptor() {
1486 let out = build_srcset(42, &specs(&["fill-400x300", "fill-800x600"]), None);
1487 assert_eq!(
1488 out,
1489 "/__media__/fill-400x300/42 400w, /__media__/fill-800x600/42 800w"
1490 );
1491 }
1492
1493 #[test]
1494 fn srcset_skips_height_only_specs() {
1495 let out = build_srcset(7, &specs(&["height-200", "width-600"]), None);
1497 assert_eq!(out, "/__media__/width-600/7 600w");
1498 }
1499
1500 #[test]
1501 fn srcset_appends_cache_buster_truncated() {
1502 let out = build_srcset(1, &specs(&["width-300"]), Some("0123456789abcdef"));
1503 assert_eq!(out, "/__media__/width-300/1?v=0123456789ab 300w");
1504 }
1505
1506 #[test]
1507 fn dpi_srcset_scales_width_per_density() {
1508 let base = FilterPipeline::parse("width-400").unwrap();
1509 assert_eq!(
1510 build_dpi_srcset(42, &base, &[1, 2], None),
1511 "/__media__/width-400/42 1x, /__media__/width-800/42 2x"
1512 );
1513 }
1514
1515 #[test]
1516 fn dpi_srcset_scales_both_fill_dims_and_dedups_densities() {
1517 let base = FilterPipeline::parse("fill-200x100").unwrap();
1518 let out = build_dpi_srcset(7, &base, &[2, 1, 2, 0], None);
1520 assert_eq!(
1521 out,
1522 "/__media__/fill-200x100/7 1x, /__media__/fill-400x200/7 2x"
1523 );
1524 }
1525
1526 #[test]
1527 fn dpi_srcset_caps_at_8192() {
1528 let base = FilterPipeline::parse("width-5000").unwrap();
1529 assert_eq!(
1531 build_dpi_srcset(1, &base, &[2], None),
1532 "/__media__/width-8192/1 2x"
1533 );
1534 }
1535
1536 #[test]
1537 fn rendition_url_for_parses_and_rejects_bad_spec() {
1538 assert_eq!(
1541 super::rendition_url_for(42, "width-800", Some("abc123def456ZZ")).map(|u| crate::rendition::strip_sig(&u)),
1542 Some("/__media__/width-800/42?v=abc123def456".to_owned())
1543 );
1544 assert_eq!(super::rendition_url_for(42, "not-a-spec", None), None);
1545 }
1546
1547 #[test]
1548 fn picture_has_source_per_format_and_img_fallback() {
1549 let html = build_picture(
1550 42,
1551 &specs(&["width-400", "width-800"]),
1552 &["avif".to_owned(), "webp".to_owned()],
1553 "A <photo> & more",
1554 Some("100vw"),
1555 None,
1556 );
1557 let html = crate::rendition::strip_sig(&html);
1558 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}");
1560 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}");
1561 assert!(
1563 html.contains(r#"<img src="/__media__/width-800/42""#),
1564 "{html}"
1565 );
1566 assert!(
1567 html.contains(r#"alt="A <photo> & more""#),
1568 "{html}"
1569 );
1570 assert!(
1571 html.starts_with("<picture>") && html.ends_with("</picture>"),
1572 "{html}"
1573 );
1574 }
1575
1576 #[test]
1579 fn picture_does_not_declare_auto_as_a_source_type() {
1580 let html = crate::rendition::strip_sig(&build_picture(5, &specs(&["width-500"]), &["auto".to_owned()], "", None, None));
1581 assert!(!html.contains("<source"), "{html}");
1582 assert!(html.contains(r#"<img src="/__media__/width-500/5""#), "{html}");
1583 }
1584
1585 #[test]
1586 fn picture_skips_unknown_format_token() {
1587 let html = build_picture(
1588 5,
1589 &specs(&["width-500"]),
1590 &["bogus".to_owned(), "webp".to_owned()],
1591 "",
1592 None,
1593 None,
1594 );
1595 assert!(!html.contains("bogus"), "{html}");
1596 assert!(html.contains(r#"type="image/webp""#), "{html}");
1597 }
1598
1599 #[test]
1600 fn tera_functions_render_end_to_end() {
1601 let mut tera = tera::Tera::default();
1604 super::register_tera_function(&mut tera);
1605 tera.add_raw_template(
1606 "s.html",
1607 r#"{{ rcms_image_srcset(media_id=42, filters=["width-400", "width-800"]) }}"#,
1608 )
1609 .unwrap();
1610 assert_eq!(
1611 crate::rendition::strip_sig(&tera.render("s.html", &tera::Context::new()).unwrap()),
1612 "/__media__/width-400/42 400w, /__media__/width-800/42 800w"
1613 );
1614 tera.add_raw_template(
1615 "p.html",
1616 r#"{{ rcms_picture(media_id=7, filters=["width-600"], formats=["webp"], alt="hi") }}"#,
1617 )
1618 .unwrap();
1619 let p = tera.render("p.html", &tera::Context::new()).unwrap();
1620 assert!(p.contains(r#"type="image/webp""#), "{p}");
1621 assert!(p.contains(r#"alt="hi""#), "{p}");
1622 assert!(p.starts_with("<picture>"), "{p}");
1623 }
1624}
1625
1626#[cfg(test)]
1629pub(crate) fn strip_sig(url: &str) -> String {
1630 let re = regex::Regex::new(r"[?&]s=[0-9a-f]{16}").expect("regex");
1631 re.replace_all(url, "").into_owned()
1632}
1633
1634#[cfg(test)]
1635mod sign_tests {
1636 use super::{classify_sig, parse_max_unsigned, rendition_sig, sig_ok, sign_with, RenditionSig, DEFAULT_MAX_UNSIGNED_VARIANTS};
1637
1638 #[test]
1639 fn sig_is_deterministic_16_hex_and_input_sensitive() {
1640 let k = b"secret";
1641 let a = rendition_sig(k, "fill-400x300", 42);
1642 assert_eq!(a.len(), 16);
1643 assert!(a.chars().all(|c| c.is_ascii_hexdigit()), "{a}");
1644 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)); }
1649
1650 #[test]
1651 fn sig_ok_accepts_correct_rejects_forged_or_missing() {
1652 let k = b"secret";
1653 let good = rendition_sig(k, "width-800", 7);
1654 assert!(sig_ok(k, "width-800", 7, Some(&good)));
1655 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))); }
1659
1660 #[test]
1661 fn the_unsigned_variant_cap_reads_a_positive_number() {
1662 assert_eq!(parse_max_unsigned(None), DEFAULT_MAX_UNSIGNED_VARIANTS);
1663 assert_eq!(parse_max_unsigned(Some(" 64 ")), 64);
1664 assert_eq!(parse_max_unsigned(Some("0")), DEFAULT_MAX_UNSIGNED_VARIANTS);
1665 assert_eq!(parse_max_unsigned(Some("lots")), DEFAULT_MAX_UNSIGNED_VARIANTS);
1666 }
1667
1668 #[test]
1669 fn a_lenient_key_serves_signed_free_and_unsigned_capped() {
1670 let k = b"derived";
1671 let good = rendition_sig(k, "width-800", 7);
1672 assert_eq!(classify_sig(k, false, "width-800", 7, Some(&good)), RenditionSig::Valid);
1673 assert_eq!(classify_sig(k, false, "width-800", 7, None), RenditionSig::Unsigned);
1675 assert_eq!(classify_sig(k, false, "width-800", 7, Some("deadbeefdeadbeef")), RenditionSig::Unsigned);
1678 assert_eq!(classify_sig(k, false, "width-800", 7, Some("")), RenditionSig::Unsigned);
1679 }
1680
1681 #[test]
1682 fn a_strict_key_requires_a_signature() {
1683 let k = b"explicit";
1684 let good = rendition_sig(k, "width-800", 7);
1685 assert_eq!(classify_sig(k, true, "width-800", 7, Some(&good)), RenditionSig::Valid);
1686 assert_eq!(classify_sig(k, true, "width-800", 7, None), RenditionSig::Rejected);
1687 assert_eq!(classify_sig(k, true, "width-800", 7, Some("deadbeefdeadbeef")), RenditionSig::Rejected);
1688 }
1689
1690 #[test]
1691 fn signing_appends_s_after_any_query() {
1692 let k = b"k";
1693 let sig = rendition_sig(k, "width-800", 7);
1694 assert_eq!(sign_with(k, "/__media__/width-800/7".into(), "width-800", 7), format!("/__media__/width-800/7?s={sig}"));
1695 assert_eq!(sign_with(k, "/__media__/width-800/7?v=ab".into(), "width-800", 7), format!("/__media__/width-800/7?v=ab&s={sig}"));
1696 }
1697}