equi_ty/

utils_misc.rs

#![allow(unused)]

use std::io::{IsTerminal as _, Write as _};
use std::sync::LazyLock;
use std::{env, fmt, fs, io, path};

use color_eyre::eyre::{self, ContextCompat};
use rustc_hir::def_id::DefId;
use rustc_middle::ty::TyCtxt;
use serde::Serialize;
use tracing::{debug, instrument};
use tracing_subscriber::EnvFilter;
use walkdir::WalkDir;

use crate::consts;

static TRACING_INIT: LazyLock<()> = LazyLock::new(|| {
    let no_color = env::var("NO_ANSI").ok().is_some_and(|val| val == "1");
    let enable_ansi = !no_color || io::stdout().is_terminal();

    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .with_writer(io::stderr)
        .with_ansi(enable_ansi)
        .init();
});

pub fn init_tracing() {
    let () = &*TRACING_INIT;
}

pub fn expect_one<T: fmt::Debug>(vs: Vec<T>) -> eyre::Result<T> {
    eyre::ensure!(
        vs.len() == 1,
        "expected one item, found either none or multiple (vs: {vs:?})"
    );

    let fst = vs.into_iter().next().expect("already checked");
    Ok(fst)
}

pub fn is_bin_on_path(bin: &str) -> eyre::Result<bool> {
    if let Ok(paths) = env::var("PATH") {
        for dir in paths.split(':') {
            let full_path = path::Path::new(dir).join(bin);
            if full_path.try_exists()? {
                return Ok(true);
            }
        }
    }
    Ok(false)
}

#[instrument]
pub(crate) fn copy_dir<P, Q>(from: P, to: Q) -> eyre::Result<()>
where
    P: AsRef<path::Path> + fmt::Debug,
    Q: AsRef<path::Path> + fmt::Debug,
{
    let to = to.as_ref();
    if to.exists() {
        debug!("Removing existing {}", to.display());
        fs::remove_dir_all(to)?;
    }

    for entry in WalkDir::new(&from) {
        let entry = entry?;
        let f = entry.path();
        let t = to.join(f.strip_prefix(&from)?);

        if entry.file_type().is_dir() {
            // dirs
            fs::create_dir(t)?;
        } else if entry.file_type().is_file() {
            // files
            fs::copy(f, t)?;
        } else {
            // symlinks
            let target = entry.path().read_link()?;
            std::os::unix::fs::symlink(target, t)?;
        }
    }

    Ok(())
}

pub fn should_save_intermediates() -> bool {
    *consts::SAVE_INTERMEDIATES
}

pub fn save_intermediate<T: Serialize>(data: T, fname: &str) {
    let intermediates_dir = env::current_dir()
        .expect("failed to get current_dir")
        .join(&*consts::INTERMEDIATES_DIR);
    fs::create_dir_all(&intermediates_dir).expect("failed to create intermediates dir");

    let fpath = intermediates_dir.join(fname);

    save_to_json_file(&data, fpath).expect("failed to write to json file");
}

pub fn save_to_json_file<T>(value: &T, filename: impl AsRef<path::Path>) -> eyre::Result<()>
where
    T: ?Sized + Serialize,
{
    let file = fs::File::create(filename.as_ref())?;
    // trace!(">> saving json to : {:?}", file);
    let mut writer = io::BufWriter::new(file);
    serde_json::to_writer_pretty(&mut writer, value)?;
    writer.flush()?;
    Ok(())
}

pub fn intermediates_dir() -> Option<impl AsRef<path::Path>> {
    let intermediates_dir = env::current_dir()
        .expect("failed to get current_dir")
        .join(&*consts::INTERMEDIATES_DIR);

    if intermediates_dir.is_dir() {
        Some(intermediates_dir)
    } else {
        debug!(
            "[!] intermediates_dir ({}) is not a dir",
            intermediates_dir.display()
        );
        None
    }
}

pub fn def_kind_descr(tcx: TyCtxt<'_>, def_id: DefId) -> &'static str {
    let def_kind = tcx.def_kind(def_id);
    tcx.def_kind_descr(def_kind, def_id)
}

pub fn remove_cratenum(path: &str) -> eyre::Result<String> {
    if !path.contains('[') && !path.contains(']') {
        return Ok(path.to_string());
    }

    let (crate_, rest) = path
        .split_once('[')
        .wrap_err_with(|| "'[' not found in path")?;

    let (_, rest_path) = rest
        .split_once(']')
        .wrap_err_with(|| "']' not found in path")?;

    let path = format!("{crate_}{rest_path}");
    Ok(path)
}

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

    #[test]
    fn test_remove_cratenum_prim_ty() {
        let input = "u32";
        let result = remove_cratenum(input).unwrap();
        assert_eq!(result, "u32");
    }

    #[test]
    fn test_remove_cratenum_valid_path() {
        let input = "my_crate[123]::module::function";
        let result = remove_cratenum(input).unwrap();
        assert_eq!(result, "my_crate::module::function");
    }

    #[test]
    fn test_remove_cratenum_with_zero() {
        let input = "std[0]::collections::HashMap";
        let result = remove_cratenum(input).unwrap();
        assert_eq!(result, "std::collections::HashMap");
    }

    #[test]
    fn test_remove_cratenum_missing_opening_bracket() {
        let input = "my_crate123]::module::function";
        let result = remove_cratenum(input);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("'[' not found in path")
        );
    }

    #[test]
    fn test_remove_cratenum_missing_closing_bracket() {
        let input = "my_crate[123::module::function";
        let result = remove_cratenum(input);
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("']' not found in path")
        );
    }

    #[test]
    fn test_remove_cratenum_empty_brackets() {
        let input = "my_crate[]::module::function";
        let result = remove_cratenum(input).unwrap();
        assert_eq!(result, "my_crate::module::function");
    }
}