spritore 0.3.0

Generate MapLibre sprite sheets from SVG icons in Rust or from the command line
Documentation
use std::fs;
use std::path::{Path, PathBuf};
use std::process::{Command, Output};
use std::sync::atomic::{AtomicUsize, Ordering};

static NEXT_TEMP_DIRECTORY: AtomicUsize = AtomicUsize::new(0);

struct TempDirectory(PathBuf);

impl TempDirectory {
	fn new(label: &str) -> Self {
		let sequence = NEXT_TEMP_DIRECTORY.fetch_add(1, Ordering::Relaxed);
		let path = std::env::temp_dir().join(format!(
			"spritore-cli-{label}-{}-{sequence}",
			std::process::id(),
		));
		fs::create_dir_all(&path).unwrap();
		Self(path)
	}

	fn path(&self) -> &Path {
		&self.0
	}
}

impl Drop for TempDirectory {
	fn drop(&mut self) {
		let _ = fs::remove_dir_all(&self.0);
	}
}

fn fixture_directory() -> PathBuf {
	Path::new(env!("CARGO_MANIFEST_DIR")).join("../spritore-core/tests/fixtures")
}

fn golden_directory() -> PathBuf {
	Path::new(env!("CARGO_MANIFEST_DIR")).join("../spritore-core/tests/golden")
}

fn run_cli(arguments: &[&str]) -> Output {
	Command::new(env!("CARGO_BIN_EXE_spritore"))
		.args(arguments)
		.output()
		.unwrap()
}

fn assert_success(output: &Output) {
	assert!(
		output.status.success(),
		"CLI failed:\nstdout:\n{}\nstderr:\n{}",
		String::from_utf8_lossy(&output.stdout),
		String::from_utf8_lossy(&output.stderr),
	);
}

fn assert_golden_output(directory: &Path, fast: bool) {
	let mut names: Vec<_> = fs::read_dir(directory)
		.unwrap()
		.map(|entry| entry.unwrap().file_name().into_string().unwrap())
		.collect();
	names.sort();
	assert_eq!(
		names,
		[
			"sprite.json",
			"sprite.png",
			"sprite@2x.json",
			"sprite@2x.png",
		],
	);

	for ratio in [1, 2] {
		let suffix = if ratio == 1 { "" } else { "@2x" };
		let kind = if fast { ".fast" } else { "" };
		assert_eq!(
			fs::read(directory.join(format!("sprite{suffix}.png"))).unwrap(),
			fs::read(golden_directory().join(format!("sprite{suffix}{kind}.png"))).unwrap(),
		);
		assert_eq!(
			fs::read(directory.join(format!("sprite{suffix}.json"))).unwrap(),
			fs::read(golden_directory().join(format!("sprite{suffix}.json"))).unwrap(),
		);
	}
}

#[test]
fn matches_zopfli_and_fast_golden_files() {
	let zopfli = TempDirectory::new("zopfli");
	let fixtures = fixture_directory();
	let output = run_cli(&[
		"build",
		fixtures.to_str().unwrap(),
		"-o",
		zopfli.path().to_str().unwrap(),
	]);
	assert_success(&output);
	assert_golden_output(zopfli.path(), false);

	let fast = TempDirectory::new("fast");
	let output = run_cli(&[
		"build",
		fixtures.to_str().unwrap(),
		"-o",
		fast.path().to_str().unwrap(),
		"--fast",
	]);
	assert_success(&output);
	assert_golden_output(fast.path(), true);
}

#[test]
fn invalid_svgs_fail_without_output_and_can_be_skipped() {
	let temporary = TempDirectory::new("invalid");
	let input = temporary.path().join("input");
	fs::create_dir(&input).unwrap();
	fs::copy(fixture_directory().join("dot.svg"), input.join("dot.svg")).unwrap();
	fs::write(input.join("broken.svg"), "not svg").unwrap();

	let failed_output = temporary.path().join("failed-output");
	let result = run_cli(&[
		"build",
		input.to_str().unwrap(),
		"-o",
		failed_output.to_str().unwrap(),
	]);
	assert_eq!(result.status.code(), Some(1));
	assert!(String::from_utf8_lossy(&result.stderr).contains("broken.svg"));
	assert!(!failed_output.exists());

	let skipped_output = temporary.path().join("skipped-output");
	let result = run_cli(&[
		"build",
		input.to_str().unwrap(),
		"-o",
		skipped_output.to_str().unwrap(),
		"--skip-invalid",
	]);
	assert_success(&result);
	assert!(String::from_utf8_lossy(&result.stderr).contains("skipping `broken.svg`"));
	let index = fs::read_to_string(skipped_output.join("sprite.json")).unwrap();
	assert!(index.contains("\"dot\""));
	assert!(!index.contains("\"broken\""));
}

#[test]
fn sanitized_id_collisions_are_errors() {
	let temporary = TempDirectory::new("collision");
	let input = temporary.path().join("input");
	fs::create_dir(&input).unwrap();
	fs::copy(fixture_directory().join("dot.svg"), input.join("a b.svg")).unwrap();
	fs::copy(fixture_directory().join("pin.svg"), input.join("a-b.svg")).unwrap();

	let output = temporary.path().join("output");
	let result = run_cli(&[
		"build",
		input.to_str().unwrap(),
		"-o",
		output.to_str().unwrap(),
	]);
	assert_eq!(result.status.code(), Some(1));
	assert!(String::from_utf8_lossy(&result.stderr).contains("icon id collision `a-b`"));
	assert!(!output.exists());
}

#[test]
fn missing_input_directory_is_a_usage_error() {
	let temporary = TempDirectory::new("usage");
	let missing = temporary.path().join("does-not-exist");
	let output = temporary.path().join("output");
	let result = run_cli(&[
		"build",
		missing.to_str().unwrap(),
		"-o",
		output.to_str().unwrap(),
	]);
	assert_eq!(result.status.code(), Some(1));
	assert!(String::from_utf8_lossy(&result.stderr).contains("Usage: spritore build"));
	assert!(!output.exists());
}

#[test]
fn sdf_flag_marks_every_icon_as_sdf() {
	let output_directory = TempDirectory::new("sdf");
	let fixtures = fixture_directory();
	let output = run_cli(&[
		"build",
		fixtures.to_str().unwrap(),
		"-o",
		output_directory.path().to_str().unwrap(),
		"--fast",
		"--sdf",
	]);
	assert_success(&output);

	for name in ["sprite.json", "sprite@2x.json"] {
		let json = fs::read_to_string(output_directory.path().join(name)).unwrap();
		let entries = json.matches("\"pixelRatio\"").count();
		assert!(entries > 0);
		assert_eq!(json.matches("\"sdf\": true").count(), entries, "{name}");
	}
}