use std::fmt;
use std::path::Path;
use std::str::FromStr;
use crate::compression::Compression;
use crate::error::WasmCheckError;
const KIB: u64 = 1024;
const MIB: u64 = 1024 * 1024;
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Size(u64);
impl Size {
#[must_use]
pub const fn from_bytes(bytes: u64) -> Self {
Self(bytes)
}
#[must_use]
pub const fn bytes(self) -> u64 {
self.0
}
#[must_use]
pub const fn from_kib_ceil(bytes: u64) -> Self {
let rem = bytes % KIB;
if rem == 0 {
Self(bytes)
} else {
Self(bytes - rem + KIB)
}
}
}
impl From<u64> for Size {
fn from(bytes: u64) -> Self {
Self(bytes)
}
}
impl From<Size> for u64 {
fn from(size: Size) -> Self {
size.0
}
}
impl fmt::Display for Size {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let bytes = self.0;
if bytes != 0 && bytes.is_multiple_of(MIB) {
write!(f, "{} MB", bytes / MIB)
} else if bytes != 0 && bytes.is_multiple_of(KIB) {
write!(f, "{} KB", bytes / KIB)
} else {
write!(f, "{bytes} B")
}
}
}
impl FromStr for Size {
type Err = WasmCheckError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let invalid = || WasmCheckError::InvalidSize(s.trim().to_string());
let upper = s.trim().to_ascii_uppercase();
let (number, unit) = match upper.find(|c: char| c.is_ascii_alphabetic()) {
Some(pos) => (upper[..pos].trim(), upper[pos..].trim()),
None => (upper.as_str(), ""),
};
let value: f64 = number.parse().map_err(|_| invalid())?;
if !value.is_finite() || value < 0.0 {
return Err(invalid());
}
let multiplier = match unit {
"" | "B" => 1.0,
"KB" | "KIB" => KIB as f64,
"MB" | "MIB" => MIB as f64,
_ => return Err(invalid()),
};
let bytes = value * multiplier;
if bytes > u64::MAX as f64 {
return Err(invalid());
}
Ok(Self(bytes as u64))
}
}
impl serde::Serialize for Size {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.collect_str(self)
}
}
impl<'de> serde::Deserialize<'de> for Size {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
crate::deserialize::string_or_number(
deserializer,
"a byte count or a size string such as \"280 KB\"",
)
}
}
#[must_use]
pub fn format_size(bytes: u64) -> String {
if bytes >= MIB {
format!("{:.2} MB", bytes as f64 / MIB as f64)
} else if bytes >= KIB {
format!("{:.2} KB", bytes as f64 / KIB as f64)
} else {
format!("{bytes} B")
}
}
#[must_use]
pub fn delta_str(value: u64, baseline: u64) -> String {
match value.cmp(&baseline) {
std::cmp::Ordering::Greater => format!("+{}", format_size(value - baseline)),
std::cmp::Ordering::Less => format!("-{}", format_size(baseline - value)),
std::cmp::Ordering::Equal => "±0 B".to_string(),
}
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct SizeReport {
file: String,
raw: u64,
gzip: u64,
brotli: u64,
}
impl SizeReport {
pub fn new(file: impl Into<String>, raw: u64, gzip: u64, brotli: u64) -> Self {
Self {
file: file.into(),
raw,
gzip,
brotli,
}
}
pub fn measure(path: impl AsRef<Path>) -> Result<Self, WasmCheckError> {
Self::measure_with(path, Compression::default())
}
pub fn measure_with(
path: impl AsRef<Path>,
compression: Compression,
) -> Result<Self, WasmCheckError> {
let path = path.as_ref();
let data = std::fs::read(path).map_err(|e| {
if e.kind() == std::io::ErrorKind::NotFound {
WasmCheckError::FileNotFound(path.to_path_buf())
} else {
WasmCheckError::Io(e)
}
})?;
Ok(Self {
file: path.display().to_string(),
raw: data.len() as u64,
gzip: compress_gzip(&data, compression.gzip_level())?,
brotli: compress_brotli(&data, compression.brotli_quality())?,
})
}
#[must_use]
pub fn file(&self) -> &str {
&self.file
}
#[must_use]
pub const fn raw(&self) -> u64 {
self.raw
}
#[must_use]
pub const fn gzip(&self) -> u64 {
self.gzip
}
#[must_use]
pub const fn brotli(&self) -> u64 {
self.brotli
}
#[must_use]
pub fn value(&self, metric: crate::Metric) -> u64 {
metric.value(self)
}
#[must_use]
pub fn delta(&self, baseline: &Self) -> SizeDelta {
SizeDelta {
raw: self.raw as i64 - baseline.raw as i64,
gzip: self.gzip as i64 - baseline.gzip as i64,
brotli: self.brotli as i64 - baseline.brotli as i64,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct SizeDelta {
raw: i64,
gzip: i64,
brotli: i64,
}
impl SizeDelta {
#[must_use]
pub const fn get(&self, metric: crate::Metric) -> i64 {
match metric {
crate::Metric::Raw => self.raw,
crate::Metric::Gzip => self.gzip,
crate::Metric::Brotli => self.brotli,
}
}
}
fn compress_gzip(data: &[u8], level: u32) -> Result<u64, WasmCheckError> {
use std::io::Write;
let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::new(level));
encoder.write_all(data)?;
Ok(encoder.finish()?.len() as u64)
}
fn compress_brotli(data: &[u8], quality: i32) -> Result<u64, WasmCheckError> {
let params = brotli::enc::BrotliEncoderParams {
quality,
..brotli::enc::BrotliEncoderParams::default()
};
let mut output = Vec::new();
let mut input = data;
brotli::BrotliCompress(&mut input, &mut output, ¶ms)?;
Ok(output.len() as u64)
}