files_diff/

patch.rs

use rkyv::Archive;

use crate::{compress::CompressAlgorithm, hash, Error};

/// Algorithms available for generating binary diffs.
///
/// Each algorithm offers different tradeoffs between patch size, generation
/// speed, and application speed.
///
/// # Example
/// ```rust
/// use files_diff::{diff, DiffAlgorithm, CompressAlgorithm};
///
/// // Use rsync for fast differing of similar files
/// let rsync_patch = diff(
///     b"original",
///     b"modified",
///     DiffAlgorithm::Rsync020,
///     CompressAlgorithm::None
/// )?;
///
/// // Use bidiff for potentially smaller patches
/// let bidiff_patch = diff(
///     b"original",
///     b"modified",
///     DiffAlgorithm::Bidiff1,
///     CompressAlgorithm::Zstd
/// )?;
/// # Ok::<(), files_diff::Error>(())
/// ```
#[derive(Archive, rkyv::Deserialize, rkyv::Serialize, Debug, PartialEq, Clone, Copy, Eq, Hash)]
#[rkyv(derive(Debug, PartialEq))]
pub enum DiffAlgorithm {
    /// Fast-rsync algorithm version 0.2.0.
    /// Optimized for files that are mostly similar.
    Rsync020,

    /// Bidirectional diff algorithm version 1.
    /// May produce smaller patches for very different files.
    Bidiff1,
}

impl std::fmt::Display for DiffAlgorithm {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

/// A patch that can transform one file into another.
///
/// Contains all the information needed to verify and apply a patch,
/// including source and target file hashes for integrity validation.
///
/// # Example
/// ```rust
/// use files_diff::{diff, apply, DiffAlgorithm, CompressAlgorithm};
///
/// let source = b"original content";
/// let target = b"modified content";
///
/// // Generate a patch
/// let patch = diff(
///     source,
///     target,
///     DiffAlgorithm::Rsync020,
///     CompressAlgorithm::Zstd
/// )?;
///
/// // Verify source hash matches
/// assert_eq!(files_diff::hash(source), patch.before_hash);
///
/// // Apply patch and verify result
/// let result = apply(source, &patch)?;
/// assert_eq!(files_diff::hash(&result), patch.after_hash);
/// # Ok::<(), files_diff::Error>(())
/// ```
#[derive(Archive, rkyv::Deserialize, rkyv::Serialize, Debug, PartialEq)]
#[rkyv(derive(Debug))]
pub struct Patch {
    /// Algorithm used to generate this patch
    pub diff_algorithm: DiffAlgorithm,
    /// Compression method used for the patch data
    pub compress_algorithm: CompressAlgorithm,
    /// MD5 hash of the source file
    pub before_hash: String,
    /// MD5 hash of the target file
    pub after_hash: String,
    /// The actual patch data
    pub patch: Vec<u8>,
}

impl Patch {
    /// Returns the total size in bytes of this patch.
    pub fn get_size(&self) -> usize {
        self.patch.len()
            + self.before_hash.len()
            + self.after_hash.len()
            + std::mem::size_of::<CompressAlgorithm>()
            + std::mem::size_of::<DiffAlgorithm>()
    }

    /// Serializes this patch to a byte vector.
    pub fn to_bytes(&self) -> Result<Vec<u8>, Error> {
        Ok(rkyv::to_bytes::<rkyv::rancor::Error>(self)
            .map_err(Error::SerializeError)?
            .to_vec())
    }

    /// Deserializes a patch from a byte vector.
    pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
        rkyv::from_bytes::<_, rkyv::rancor::Error>(bytes).map_err(Error::DeserializeError)
    }
}

/// Type alias for filenames in patch sets
pub type Filename = String;

/// Operations that can be performed on a file in a patch set.
///
/// Used primarily for zip archive differing to track changes to individual files
/// within the archive.
///
/// # Example
/// ```no_run
/// use files_diff::{diff_zip, DiffAlgorithm, CompressAlgorithm};
///
/// let patch_set = diff_zip(
///     "before.zip".to_string(),
///     "after.zip".to_string(),
///     DiffAlgorithm::Rsync020,
///     CompressAlgorithm::Zstd
/// )?;
///
/// # Ok::<(), files_diff::Error>(())
/// ```
#[derive(Archive, rkyv::Deserialize, rkyv::Serialize, Debug, PartialEq)]
#[rkyv(derive(Debug))]
pub enum Operation {
    /// File was modified - contains patch to transform it
    Patch(Patch),
    /// File is new or completely different - contains full file contents
    PutFile(Vec<u8>),
    /// File was removed in the target
    DeleteFile,
    /// File is identical in source and target
    FileStaysSame,
}

impl Operation {
    /// Returns the size in bytes of this operation's data.
    pub fn get_size(&self) -> usize {
        match self {
            Operation::Patch(patch) => patch.get_size(),
            Operation::PutFile(file) => file.len(),
            Operation::DeleteFile => 0,
            Operation::FileStaysSame => 0,
        }
    }
}

#[derive(Archive, rkyv::Deserialize, rkyv::Serialize, Debug, PartialEq)]
#[rkyv(derive(Debug))]
pub struct Operations(pub(crate) Vec<(Filename, Operation)>);

impl Operations {
    pub(crate) fn to_bytes(&self) -> Result<Vec<u8>, Error> {
        Ok(rkyv::to_bytes::<rkyv::rancor::Error>(self)
            .map_err(Error::SerializeError)?
            .to_vec())
    }

    pub(crate) fn hash(&self) -> Result<String, Error> {
        Ok(hash(&self.to_bytes()?))
    }
}

/// A collection of file operations that transform one archive into another.
///
/// Contains all the operations needed to transform a zip archive into a
/// target version, tracking changes to individual files within the archive.
///
/// # Example
/// ```no_run
/// use files_diff::{diff_zip, apply_zip, DiffAlgorithm, CompressAlgorithm};
///
/// // Generate patches for all files in the zip
/// let patch_set = diff_zip(
///     "source.zip".to_string(),
///     "target.zip".to_string(),
///     DiffAlgorithm::Rsync020,
///     CompressAlgorithm::Zstd
/// )?;
///
/// // Apply all patches to transform the zip
/// apply_zip("source.zip", patch_set, "result.zip".to_string())?;
/// # Ok::<(), files_diff::Error>(())
/// ```
#[derive(Archive, rkyv::Deserialize, rkyv::Serialize, Debug, PartialEq)]
#[rkyv(derive(Debug))]
pub struct PatchSet {
    /// The operations that transform the source zip into the target zip
    pub operations: Operations,
    /// The hash of the source zip
    pub hash_before: String,
    /// The hash of the operations
    pub operations_hash: String,
}

impl PatchSet {
    /// Returns the total size in bytes of all operations in this patch set.
    pub fn get_size(&self) -> usize {
        self.operations
            .0
            .iter()
            .map(|(filename, op)| filename.len() + op.get_size())
            .sum::<usize>()
            + self.hash_before.len()
            + self.operations_hash.len()
    }

    /// Serializes this patch set to a byte vector.
    pub fn to_bytes(&self) -> Result<Vec<u8>, Error> {
        Ok(rkyv::to_bytes::<rkyv::rancor::Error>(self)
            .map_err(Error::SerializeError)?
            .to_vec())
    }

    /// Deserializes a patch set from a byte vector.
    pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
        rkyv::from_bytes::<_, rkyv::rancor::Error>(bytes).map_err(Error::DeserializeError)
    }
}