path: root/crates/mozart-core/src/package/archiver.rs

use anyhow::Context as _;
use regex::Regex;
use sha1::{Digest as _, Sha1};
use std::fs;
use std::io::Write as _;
use std::path::{Path, PathBuf};

mod archive_manager;
pub use archive_manager::*;

/// A compiled exclude pattern derived from a gitignore-style rule.
pub struct ExcludePattern {
    regex: Regex,
    /// If true, matching files are *re-included* (negation rule).
    negate: bool,
}

/// Convert a glob pattern string to a regex string.
///
/// Mapping:
/// - `**`  → `.*`   (matches any path segment sequence)
/// - `*`   → `[^/]*` (matches within a single path segment)
/// - `?`   → `[^/]`  (matches a single non-separator char)
/// - `[…]` → `[…]`   (character class, passed through)
/// - all other characters are regex-escaped
fn glob_to_regex(glob: &str) -> String {
    let mut result = String::new();
    let chars: Vec<char> = glob.chars().collect();
    let mut i = 0;
    while i < chars.len() {
        match chars[i] {
            '*' if i + 1 < chars.len() && chars[i + 1] == '*' => {
                result.push_str(".*");
                i += 2;
            }
            '*' => {
                result.push_str("[^/]*");
                i += 1;
            }
            '?' => {
                result.push_str("[^/]");
                i += 1;
            }
            '[' => {
                // Pass character classes through as-is until the closing `]`
                result.push('[');
                i += 1;
                while i < chars.len() && chars[i] != ']' {
                    result.push(chars[i]);
                    i += 1;
                }
                if i < chars.len() {
                    result.push(']');
                    i += 1;
                }
            }
            c => {
                // Regex-escape special characters
                if r"\.+^$|{}()?".contains(c) {
                    result.push('\\');
                }
                result.push(c);
                i += 1;
            }
        }
    }
    result
}

/// Convert a single gitignore-style rule into an `ExcludePattern`.
///
/// Returns `None` if the rule is empty or a comment.
pub fn parse_gitignore_pattern(rule: &str) -> Option<ExcludePattern> {
    let rule = rule.trim();
    if rule.is_empty() || rule.starts_with('#') {
        return None;
    }

    // Leading `!` negates the pattern
    let (negate, rule) = if let Some(rest) = rule.strip_prefix('!') {
        (true, rest)
    } else {
        (false, rule)
    };

    // Strip trailing `/` before globbing
    let rule = rule.trim_end_matches('/');
    if rule.is_empty() {
        return None;
    }

    // Determine anchor prefix:
    // - leading `/` → anchored at root: `^/<glob_regex>`
    // - no `/` inside pattern → matches anywhere: `/<glob_regex>`
    // - `/` somewhere in middle → anchored at root: `^/<glob_regex>`
    let (prefix, glob) = if let Some(without_leading_slash) = rule.strip_prefix('/') {
        // Root-anchored
        ("^/", without_leading_slash)
    } else if rule.contains('/') {
        // Slash in middle: treat as root-anchored
        ("^/", rule)
    } else {
        // No slash: matches anywhere
        ("/", rule)
    };

    let glob_regex = glob_to_regex(glob);
    // The final regex: `<prefix><glob_regex>(/|$)`
    // This matches the path component exactly (followed by a `/` or end-of-string).
    let pattern = format!("{prefix}{glob_regex}(/|$)");
    let regex = Regex::new(&pattern).ok()?;

    Some(ExcludePattern { regex, negate })
}

/// Apply a chain of exclude patterns to a relative path (as a `/`-prefixed string).
///
/// Patterns are applied in order; later patterns override earlier ones.
/// Returns `true` if the file is excluded by the final matching pattern
/// (or by `initially_excluded` if no pattern matches).
fn apply_filters(
    path_with_slash: &str,
    patterns: &[ExcludePattern],
    initially_excluded: bool,
) -> bool {
    let mut excluded = initially_excluded;
    for pat in patterns {
        if pat.regex.is_match(path_with_slash) {
            // A negate pattern re-includes; a normal pattern excludes
            excluded = !pat.negate;
        }
    }
    excluded
}

/// Parse `.gitattributes` from the source directory.
///
/// Returns exclude patterns for lines containing `export-ignore` or
/// `-export-ignore`.
pub fn parse_gitattributes(source_dir: &Path) -> Vec<ExcludePattern> {
    let path = source_dir.join(".gitattributes");
    let content = match fs::read_to_string(&path) {
        Ok(c) => c,
        Err(_) => return vec![],
    };

    let mut patterns = Vec::new();
    for line in content.lines() {
        let line = line.trim();
        if line.is_empty() || line.starts_with('#') {
            continue;
        }
        let parts: Vec<&str> = line.split_whitespace().collect();
        if parts.len() < 2 {
            continue;
        }
        let file_pattern = parts[0];
        // Check each attribute token for export-ignore / -export-ignore
        for attr in &parts[1..] {
            if *attr == "export-ignore" {
                if let Some(p) = parse_gitignore_pattern(file_pattern) {
                    patterns.push(p);
                }
            } else if *attr == "-export-ignore" {
                // Negation: re-include files that would otherwise be excluded
                let negated = format!("!{}", file_pattern);
                if let Some(p) = parse_gitignore_pattern(&negated) {
                    patterns.push(p);
                }
            }
        }
    }
    patterns
}

/// Convert `composer.json` `archive.exclude` rules into exclude patterns.
pub fn parse_composer_excludes(excludes: &[String]) -> Vec<ExcludePattern> {
    excludes
        .iter()
        .filter_map(|rule| parse_gitignore_pattern(rule))
        .collect()
}

const VCS_DIRS: &[&str] = &[".git", ".svn", ".hg", "CVS", ".bzr"];

/// Collect all archivable files from the source directory.
///
/// Returns paths relative to `source_dir`, sorted for deterministic output.
/// Applies `exclude_patterns` to filter files. VCS directories are always
/// skipped. Symlinks pointing outside `source_dir` are excluded.
pub fn collect_archivable_files(
    source_dir: &Path,
    exclude_patterns: &[ExcludePattern],
) -> anyhow::Result<Vec<PathBuf>> {
    let source_dir = source_dir
        .canonicalize()
        .unwrap_or_else(|_| source_dir.to_path_buf());
    let mut files = Vec::new();
    collect_recursive(&source_dir, &source_dir, exclude_patterns, &mut files)?;
    files.sort();
    Ok(files)
}

fn collect_recursive(
    source_dir: &Path,
    current_dir: &Path,
    exclude_patterns: &[ExcludePattern],
    out: &mut Vec<PathBuf>,
) -> anyhow::Result<()> {
    let entries = fs::read_dir(current_dir)
        .with_context(|| format!("Failed to read directory: {}", current_dir.display()))?;

    let mut items: Vec<_> = entries.filter_map(|e| e.ok()).collect();
    // Sort for determinism
    items.sort_by_key(|e| e.file_name());

    for entry in items {
        let path = entry.path();
        let file_name = entry.file_name();
        let name_str = file_name.to_string_lossy();

        // Skip VCS directories
        if VCS_DIRS.contains(&name_str.as_ref()) {
            continue;
        }

        // Compute the relative path (forward-slash, prefixed with `/` for filter matching)
        let relative = path
            .strip_prefix(source_dir)
            .unwrap_or(&path)
            .to_string_lossy()
            .replace('\\', "/");
        let path_with_slash = format!("/{}", relative);

        // Check if this entry is excluded
        if apply_filters(&path_with_slash, exclude_patterns, false) {
            continue;
        }

        let metadata = match entry.metadata() {
            Ok(m) => m,
            Err(_) => continue,
        };

        if metadata.is_symlink() {
            // Resolve the symlink; skip if it points outside source_dir
            if let Ok(resolved) = fs::canonicalize(&path) {
                if !resolved.starts_with(source_dir) {
                    continue;
                }
                out.push(PathBuf::from(&relative));
            }
            // If canonicalize fails, skip the symlink
        } else if metadata.is_dir() {
            // Collect children recursively
            let mut children = Vec::new();
            collect_recursive(source_dir, &path, exclude_patterns, &mut children)?;
            if children.is_empty() {
                // Include empty directory
                out.push(PathBuf::from(&relative));
            } else {
                out.extend(children);
            }
        } else {
            out.push(PathBuf::from(&relative));
        }
    }

    Ok(())
}

/// Supported archive formats.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ArchiveFormat {
    Zip,
    Tar,
    TarGz,
    TarBz2,
}

impl ArchiveFormat {
    /// Parse a format string (case-insensitive). Returns `None` for unsupported formats.
    pub fn parse(s: &str) -> Option<Self> {
        match s.to_lowercase().as_str() {
            "zip" => Some(Self::Zip),
            "tar" => Some(Self::Tar),
            "tar.gz" | "tgz" => Some(Self::TarGz),
            "tar.bz2" => Some(Self::TarBz2),
            _ => None,
        }
    }

    /// File extension for this format.
    pub fn extension(&self) -> &str {
        match self {
            Self::Zip => "zip",
            Self::Tar => "tar",
            Self::TarGz => "tar.gz",
            Self::TarBz2 => "tar.bz2",
        }
    }
}

/// Create an archive of the given files.
///
/// - `source_dir`: the root of the source tree
/// - `files`: relative paths (as returned by `collect_archivable_files`)
/// - `target`: full output path including extension
/// - `format`: the archive format to create
pub fn create_archive(
    source_dir: &Path,
    files: &[PathBuf],
    target: &Path,
    format: &ArchiveFormat,
) -> anyhow::Result<()> {
    match format {
        ArchiveFormat::Zip => create_zip(source_dir, files, target),
        ArchiveFormat::Tar => create_tar(source_dir, files, target),
        ArchiveFormat::TarGz => create_tar_gz(source_dir, files, target),
        ArchiveFormat::TarBz2 => create_tar_bz2(source_dir, files, target),
    }
}

fn create_zip(source_dir: &Path, files: &[PathBuf], target: &Path) -> anyhow::Result<()> {
    use zip::write::SimpleFileOptions;

    let file = fs::File::create(target)
        .with_context(|| format!("Failed to create archive: {}", target.display()))?;
    let mut writer = zip::ZipWriter::new(file);

    for rel in files {
        let abs = source_dir.join(rel);
        let rel_str = rel.to_string_lossy().replace('\\', "/");

        if abs.is_dir() {
            let opts = SimpleFileOptions::default();
            writer.add_directory(&rel_str, opts)?;
        } else {
            let metadata = fs::metadata(&abs)?;

            #[cfg(unix)]
            let opts = {
                use std::os::unix::fs::MetadataExt as _;
                let mode = metadata.mode();
                SimpleFileOptions::default()
                    .compression_method(zip::CompressionMethod::Deflated)
                    .unix_permissions(mode)
            };

            #[cfg(not(unix))]
            let opts =
                SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);

            let _ = metadata; // suppress unused warning on non-unix

            writer.start_file(&rel_str, opts)?;
            let content = fs::read(&abs)?;
            writer.write_all(&content)?;
        }
    }

    writer.finish()?;
    Ok(())
}

fn create_tar(source_dir: &Path, files: &[PathBuf], target: &Path) -> anyhow::Result<()> {
    let file = fs::File::create(target)
        .with_context(|| format!("Failed to create archive: {}", target.display()))?;
    let mut builder = tar::Builder::new(file);

    for rel in files {
        let abs = source_dir.join(rel);
        if abs.is_dir() {
            builder.append_dir(rel, &abs)?;
        } else {
            builder.append_path_with_name(&abs, rel)?;
        }
    }

    builder.finish()?;
    Ok(())
}

fn create_tar_gz(source_dir: &Path, files: &[PathBuf], target: &Path) -> anyhow::Result<()> {
    let file = fs::File::create(target)
        .with_context(|| format!("Failed to create archive: {}", target.display()))?;
    let encoder = flate2::write::GzEncoder::new(file, flate2::Compression::default());
    let mut builder = tar::Builder::new(encoder);

    for rel in files {
        let abs = source_dir.join(rel);
        if abs.is_dir() {
            builder.append_dir(rel, &abs)?;
        } else {
            builder.append_path_with_name(&abs, rel)?;
        }
    }

    builder.into_inner()?.finish()?;
    Ok(())
}

fn create_tar_bz2(source_dir: &Path, files: &[PathBuf], target: &Path) -> anyhow::Result<()> {
    let file = fs::File::create(target)
        .with_context(|| format!("Failed to create archive: {}", target.display()))?;
    let encoder = bzip2::write::BzEncoder::new(file, bzip2::Compression::default());
    let mut builder = tar::Builder::new(encoder);

    for rel in files {
        let abs = source_dir.join(rel);
        if abs.is_dir() {
            builder.append_dir(rel, &abs)?;
        } else {
            builder.append_path_with_name(&abs, rel)?;
        }
    }

    builder.into_inner()?.finish()?;
    Ok(())
}

/// Generate an archive filename (without extension) for a package.
///
/// Mirrors Composer's `ArchiveManager::getPackageFilenameParts()`.
pub fn generate_archive_filename(
    name: &str,
    archive_name: Option<&str>,
    version: Option<&str>,
    dist_reference: Option<&str>,
    dist_type: Option<&str>,
    source_reference: Option<&str>,
) -> String {
    // Base: archive_name if set, otherwise replace non-alphanumeric chars with `-`
    let base = if let Some(an) = archive_name {
        an.to_string()
    } else {
        let re = Regex::new(r"[^a-zA-Z0-9_\-]").unwrap();
        re.replace_all(name, "-").to_string()
    };

    let mut parts: Vec<String> = vec![base];

    // Determine if dist_reference is a 40-char hex (SHA-1 commit hash)
    let is_sha_dist_ref = dist_reference
        .map(|r| r.len() == 40 && r.chars().all(|c| c.is_ascii_hexdigit()))
        .unwrap_or(false);

    if is_sha_dist_ref {
        // Append dist_reference and dist_type
        if let Some(dr) = dist_reference {
            parts.push(dr.to_string());
        }
        if let Some(dt) = dist_type {
            parts.push(dt.to_string());
        }
    } else {
        // Append version (if any), then dist_reference (if any)
        if let Some(v) = version {
            parts.push(v.to_string());
        }
        if let Some(dr) = dist_reference {
            parts.push(dr.to_string());
        }
    }

    // Append first 6 chars of SHA-1 of source_reference (if any)
    if let Some(sr) = source_reference {
        let mut hasher = Sha1::new();
        hasher.update(sr.as_bytes());
        let hash = format!("{:x}", hasher.finalize());
        parts.push(hash[..6.min(hash.len())].to_string());
    }

    // Replace `/` with `-` in each part, then join
    parts
        .iter()
        .map(|p| p.replace('/', "-"))
        .collect::<Vec<_>>()
        .join("-")
}

/// The set of archive extensions we support.
const ARCHIVE_EXTENSIONS: &[&str] = &["zip", "tar", "tar.gz", "tar.bz2"];

/// Generate patterns to exclude previous archives of this package from the archive.
///
/// If `has_extra_parts` is true (version/ref was appended), the pattern is
/// `<base>-*.<ext>`. Otherwise it's `<base>.<ext>`.
pub fn self_exclusion_patterns(base_name: &str, has_extra_parts: bool) -> Vec<String> {
    ARCHIVE_EXTENSIONS
        .iter()
        .map(|ext| {
            if has_extra_parts {
                format!("/{}-*.{}", base_name, ext)
            } else {
                format!("/{}.{}", base_name, ext)
            }
        })
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::tempdir;

    // Note: glob_to_regex produces a *fragment* for use inside a larger pattern.
    // We test it by embedding it in a full anchored regex.

    fn full_pattern(glob: &str) -> Regex {
        // Simulate the unanchored pattern: `/fragment(/|$)`
        Regex::new(&format!("/{glob_re}(/|$)", glob_re = glob_to_regex(glob))).unwrap()
    }

    #[test]
    fn test_glob_to_regex_star() {
        let re = full_pattern("*.txt");
        // Unanchored pattern: matches any .txt file at any depth
        assert!(re.is_match("/foo.txt"));
        // Also matches nested .txt files (unanchored `/` prefix)
        assert!(re.is_match("/a/b.txt"));
        // Does NOT match non-.txt files
        assert!(!re.is_match("/foo.php"));
    }

    #[test]
    fn test_glob_to_regex_double_star() {
        // Double star matches across path separators
        let frag = glob_to_regex("**/*.txt");
        let re = Regex::new(&format!("/{frag}(/|$)")).unwrap();
        assert!(re.is_match("/a/b/c.txt"));
    }

    #[test]
    fn test_glob_to_regex_question() {
        let frag = glob_to_regex("?.txt");
        let re = Regex::new(&format!("/{frag}(/|$)")).unwrap();
        assert!(re.is_match("/a.txt"));
        assert!(!re.is_match("/ab.txt"));
    }

    #[test]
    fn test_glob_to_regex_bracket() {
        let frag = glob_to_regex("[abc].txt");
        let re = Regex::new(&format!("/{frag}(/|$)")).unwrap();
        assert!(re.is_match("/a.txt"));
        assert!(re.is_match("/b.txt"));
        assert!(!re.is_match("/d.txt"));
    }

    #[test]
    fn test_parse_gitignore_simple() {
        let pat = parse_gitignore_pattern("docs/").unwrap();
        assert!(!pat.negate);
        // "/docs" should match
        assert!(pat.regex.is_match("/docs"));
    }

    #[test]
    fn test_parse_gitignore_negated() {
        let pat = parse_gitignore_pattern("!important.txt").unwrap();
        assert!(pat.negate);
    }

    #[test]
    fn test_parse_gitignore_rooted() {
        let pat = parse_gitignore_pattern("/build").unwrap();
        assert!(!pat.negate);
        // Should match at root
        assert!(pat.regex.is_match("/build"));
        // Should NOT match in subdirectory (rooted pattern)
        assert!(!pat.regex.is_match("/src/build"));
    }

    #[test]
    fn test_parse_gitignore_unrooted() {
        let pat = parse_gitignore_pattern("*.log").unwrap();
        assert!(!pat.negate);
        // Should match anywhere
        assert!(pat.regex.is_match("/app.log"));
        assert!(pat.regex.is_match("/sub/dir/foo.log"));
    }

    #[test]
    fn test_parse_gitattributes_export_ignore() {
        let dir = tempdir().unwrap();
        fs::write(dir.path().join(".gitattributes"), "tests/ export-ignore\n").unwrap();
        let patterns = parse_gitattributes(dir.path());
        assert_eq!(patterns.len(), 1);
        assert!(!patterns[0].negate);
        assert!(patterns[0].regex.is_match("/tests"));
    }

    #[test]
    fn test_parse_gitattributes_neg_export_ignore() {
        let dir = tempdir().unwrap();
        fs::write(dir.path().join(".gitattributes"), "tests/ -export-ignore\n").unwrap();
        let patterns = parse_gitattributes(dir.path());
        assert_eq!(patterns.len(), 1);
        assert!(patterns[0].negate);
    }

    #[test]
    fn test_parse_gitattributes_comment() {
        let dir = tempdir().unwrap();
        fs::write(
            dir.path().join(".gitattributes"),
            "# comment\ntests/ export-ignore\n",
        )
        .unwrap();
        let patterns = parse_gitattributes(dir.path());
        assert_eq!(patterns.len(), 1);
    }

    #[test]
    fn test_parse_gitattributes_non_export() {
        let dir = tempdir().unwrap();
        fs::write(dir.path().join(".gitattributes"), "*.php text\n").unwrap();
        let patterns = parse_gitattributes(dir.path());
        assert!(patterns.is_empty());
    }

    #[test]
    fn test_parse_gitattributes_missing_file() {
        let dir = tempdir().unwrap();
        let patterns = parse_gitattributes(dir.path());
        assert!(patterns.is_empty());
    }

    #[test]
    fn test_collect_files_basic() {
        let dir = tempdir().unwrap();
        fs::write(dir.path().join("a.php"), b"<?php").unwrap();
        fs::write(dir.path().join("b.php"), b"<?php").unwrap();
        fs::create_dir(dir.path().join("src")).unwrap();
        fs::write(dir.path().join("src").join("c.php"), b"<?php").unwrap();

        let files = collect_archivable_files(dir.path(), &[]).unwrap();
        let strs: Vec<String> = files
            .iter()
            .map(|p| p.to_string_lossy().to_string())
            .collect();
        assert!(strs.contains(&"a.php".to_string()));
        assert!(strs.contains(&"b.php".to_string()));
        assert!(strs.contains(&"src/c.php".to_string()));
    }

    #[test]
    fn test_collect_files_excludes() {
        let dir = tempdir().unwrap();
        fs::write(dir.path().join("main.php"), b"<?php").unwrap();
        fs::create_dir(dir.path().join("tests")).unwrap();
        fs::write(dir.path().join("tests").join("test.php"), b"<?php").unwrap();

        let patterns = vec![parse_gitignore_pattern("tests/").unwrap()];
        let files = collect_archivable_files(dir.path(), &patterns).unwrap();
        let strs: Vec<String> = files
            .iter()
            .map(|p| p.to_string_lossy().to_string())
            .collect();
        assert!(strs.contains(&"main.php".to_string()));
        assert!(!strs.iter().any(|s| s.starts_with("tests")));
    }

    #[test]
    fn test_collect_files_skips_vcs() {
        let dir = tempdir().unwrap();
        fs::write(dir.path().join("main.php"), b"<?php").unwrap();
        fs::create_dir(dir.path().join(".git")).unwrap();
        fs::write(
            dir.path().join(".git").join("HEAD"),
            b"ref: refs/heads/main",
        )
        .unwrap();

        let files = collect_archivable_files(dir.path(), &[]).unwrap();
        let strs: Vec<String> = files
            .iter()
            .map(|p| p.to_string_lossy().to_string())
            .collect();
        assert!(strs.contains(&"main.php".to_string()));
        assert!(!strs.iter().any(|s| s.starts_with(".git")));
    }

    #[test]
    fn test_collect_files_empty_dir() {
        let dir = tempdir().unwrap();
        fs::write(dir.path().join("main.php"), b"<?php").unwrap();
        fs::create_dir(dir.path().join("empty_dir")).unwrap();

        let files = collect_archivable_files(dir.path(), &[]).unwrap();
        let strs: Vec<String> = files
            .iter()
            .map(|p| p.to_string_lossy().to_string())
            .collect();
        assert!(strs.contains(&"main.php".to_string()));
        assert!(strs.contains(&"empty_dir".to_string()));
    }

    fn make_source_tree(dir: &Path) {
        fs::write(dir.join("main.php"), b"<?php echo 'hello';").unwrap();
        fs::create_dir(dir.join("src")).unwrap();
        fs::write(dir.join("src").join("Foo.php"), b"<?php class Foo {}").unwrap();
    }

    #[test]
    fn test_create_zip_archive() {
        let src = tempdir().unwrap();
        make_source_tree(src.path());
        let out = tempdir().unwrap();
        let target = out.path().join("test.zip");

        let files = collect_archivable_files(src.path(), &[]).unwrap();
        create_archive(src.path(), &files, &target, &ArchiveFormat::Zip).unwrap();
        assert!(target.exists());

        // Verify contents
        let zip_data = fs::read(&target).unwrap();
        let cursor = std::io::Cursor::new(zip_data);
        let mut archive = zip::ZipArchive::new(cursor).unwrap();
        let names: Vec<String> = (0..archive.len())
            .map(|i| archive.by_index(i).unwrap().name().to_string())
            .collect();
        assert!(names.contains(&"main.php".to_string()));
        assert!(names.contains(&"src/Foo.php".to_string()));
    }

    #[test]
    fn test_create_tar_archive() {
        let src = tempdir().unwrap();
        make_source_tree(src.path());
        let out = tempdir().unwrap();
        let target = out.path().join("test.tar");

        let files = collect_archivable_files(src.path(), &[]).unwrap();
        create_archive(src.path(), &files, &target, &ArchiveFormat::Tar).unwrap();
        assert!(target.exists());

        // Verify contents
        let tar_data = fs::read(&target).unwrap();
        let cursor = std::io::Cursor::new(tar_data);
        let mut archive = tar::Archive::new(cursor);
        let names: Vec<String> = archive
            .entries()
            .unwrap()
            .filter_map(|e| e.ok())
            .filter_map(|e| e.path().ok().map(|p| p.to_string_lossy().to_string()))
            .collect();
        assert!(names.contains(&"main.php".to_string()));
        assert!(names.contains(&"src/Foo.php".to_string()));
    }

    #[test]
    fn test_create_tar_gz_archive() {
        let src = tempdir().unwrap();
        make_source_tree(src.path());
        let out = tempdir().unwrap();
        let target = out.path().join("test.tar.gz");

        let files = collect_archivable_files(src.path(), &[]).unwrap();
        create_archive(src.path(), &files, &target, &ArchiveFormat::TarGz).unwrap();
        assert!(target.exists());

        let gz_data = fs::read(&target).unwrap();
        let cursor = std::io::Cursor::new(gz_data);
        let decoder = flate2::read::GzDecoder::new(cursor);
        let mut archive = tar::Archive::new(decoder);
        let names: Vec<String> = archive
            .entries()
            .unwrap()
            .filter_map(|e| e.ok())
            .filter_map(|e| e.path().ok().map(|p| p.to_string_lossy().to_string()))
            .collect();
        assert!(names.contains(&"main.php".to_string()));
    }

    #[test]
    fn test_create_tar_bz2_archive() {
        let src = tempdir().unwrap();
        make_source_tree(src.path());
        let out = tempdir().unwrap();
        let target = out.path().join("test.tar.bz2");

        let files = collect_archivable_files(src.path(), &[]).unwrap();
        create_archive(src.path(), &files, &target, &ArchiveFormat::TarBz2).unwrap();
        assert!(target.exists());

        let bz_data = fs::read(&target).unwrap();
        let cursor = std::io::Cursor::new(bz_data);
        let decoder = bzip2::read::BzDecoder::new(cursor);
        let mut archive = tar::Archive::new(decoder);
        let names: Vec<String> = archive
            .entries()
            .unwrap()
            .filter_map(|e| e.ok())
            .filter_map(|e| e.path().ok().map(|p| p.to_string_lossy().to_string()))
            .collect();
        assert!(names.contains(&"main.php".to_string()));
    }

    #[cfg(unix)]
    #[test]
    fn test_zip_preserves_permissions() {
        use std::os::unix::fs::PermissionsExt;

        let src = tempdir().unwrap();
        let script = src.path().join("run.sh");
        fs::write(&script, b"#!/bin/sh\necho hello").unwrap();
        fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();

        let out = tempdir().unwrap();
        let target = out.path().join("test.zip");
        let files = collect_archivable_files(src.path(), &[]).unwrap();
        create_archive(src.path(), &files, &target, &ArchiveFormat::Zip).unwrap();

        let zip_data = fs::read(&target).unwrap();
        let cursor = std::io::Cursor::new(zip_data);
        let mut archive = zip::ZipArchive::new(cursor).unwrap();
        let entry = archive.by_name("run.sh").unwrap();
        let mode = entry.unix_mode().unwrap_or(0);
        // Lower 9 bits should be 0o755
        assert_eq!(mode & 0o777, 0o755);
    }

    #[test]
    fn test_filename_simple_package() {
        let name = generate_archive_filename("vendor/pkg", None, Some("1.2.3"), None, None, None);
        assert_eq!(name, "vendor-pkg-1.2.3");
    }

    #[test]
    fn test_filename_with_archive_name() {
        let name = generate_archive_filename(
            "vendor/pkg",
            Some("my-package"),
            Some("1.0.0"),
            None,
            None,
            None,
        );
        assert_eq!(name, "my-package-1.0.0");
    }

    #[test]
    fn test_filename_with_sha_dist_ref() {
        let sha = "a".repeat(40);
        let name = generate_archive_filename(
            "vendor/pkg",
            None,
            Some("1.0.0"),
            Some(&sha),
            Some("zip"),
            None,
        );
        // 40-char hex → append dist_ref and dist_type, not version
        assert_eq!(name, format!("vendor-pkg-{}-zip", sha));
    }

    #[test]
    fn test_filename_with_source_ref() {
        let name = generate_archive_filename(
            "vendor/pkg",
            None,
            Some("1.0.0"),
            None,
            None,
            Some("abc123"),
        );
        // Appends first 6 chars of SHA-1 of "abc123"
        let mut hasher = Sha1::new();
        hasher.update(b"abc123");
        let hash = format!("{:x}", hasher.finalize());
        let expected = format!("vendor-pkg-1.0.0-{}", &hash[..6]);
        assert_eq!(name, expected);
    }

    #[test]
    fn test_filename_slashes_replaced() {
        let name =
            generate_archive_filename("vendor/my-pkg", None, Some("1.0/beta"), None, None, None);
        assert_eq!(name, "vendor-my-pkg-1.0-beta");
    }

    #[test]
    fn test_self_exclusion_patterns_with_extra_parts() {
        let patterns = self_exclusion_patterns("vendor-pkg", true);
        assert!(patterns.contains(&"/vendor-pkg-*.zip".to_string()));
        assert!(patterns.contains(&"/vendor-pkg-*.tar".to_string()));
        assert!(patterns.contains(&"/vendor-pkg-*.tar.gz".to_string()));
        assert!(patterns.contains(&"/vendor-pkg-*.tar.bz2".to_string()));
    }

    #[test]
    fn test_self_exclusion_patterns_no_extra_parts() {
        let patterns = self_exclusion_patterns("vendor-pkg", false);
        assert!(patterns.contains(&"/vendor-pkg.zip".to_string()));
        assert!(patterns.contains(&"/vendor-pkg.tar".to_string()));
    }
}