versions.rs

#![allow(unused)]
use anyhow::*;
use rayon::prelude::*;
use semver::{Version, VersionReq};
use std::fs;
use std::process::*;
use std::sync;

fn doit() -> Result<(), Error> {
    walkdir::WalkDir::new("/Users/eric/Proj/rust/crates-fetch/crates-src")
        .into_iter()
        .par_bridge()
        .filter(|entry| {
            matches!(
                entry.as_ref().unwrap().file_name().to_str().unwrap(),
                "Cargo.toml" | "Cargo.toml.orig"
            )
        })
        .for_each(|entry| {
            let e = entry.unwrap();
            let path = e.path();
            let contents = fs::read_to_string(&path).unwrap();
            let man: toml::Value = match toml::from_str(&contents) {
                Ok(x) => x,
                Err(e) => {
                    eprintln!("cannot read {:?}: {}", path, e);
                    return;
                }
            };
            let vers = match man
                .get("package")
                .or_else(|| man.get("project"))
                .and_then(|p| p.get("version"))
            {
                Some(v) => v,
                None => {
                    eprintln!("cannot find vers in {:?}", path);
                    return;
                }
            };
            if let Err(e) = Version::parse(vers.as_str().unwrap()) {
                println!("failed on {:?}: {}", path, vers);
                println!("    error: {}", e);
            }
            let check_req = |req: &str| {
                if let Err(e) = VersionReq::parse(req) {
                    println!("req failed on {:?} {} -> {}", path, vers, req);
                    println!("    error: {}", e);
                }
            };
            let check_dep = |dep: &toml::Value| match dep {
                toml::Value::String(s) => {
                    check_req(s);
                }
                toml::Value::Table(t) => {
                    if let Some(version) = t.get("version") {
                        check_req(version.as_str().unwrap());
                    }
                }
                _ => unimplemented!(),
            };
            let check_deps = |deps: Option<&toml::Value>| {
                let deps = match deps {
                    Some(d) => d,
                    None => return,
                };
                for (k, v) in deps.as_table().unwrap().iter() {
                    check_dep(v);
                }
            };
            check_deps(man.get("dependencies"));
            check_deps(man.get("dev-dependencies"));
            check_deps(man.get("dev_dependencies"));
            check_deps(man.get("build-dependencies"));
            check_deps(man.get("build_dependencies"));
            if let Some(t) = man.get("target") {
                for (_k, v) in t.as_table().unwrap().iter() {
                    check_deps(v.get("dependencies"));
                    check_deps(v.get("dev-dependencies"));
                    check_deps(v.get("dev_dependencies"));
                    check_deps(v.get("build-dependencies"));
                    check_deps(v.get("build_dependencies"));
                }
            }
            if let Some(p) = man.get("patch") {
                for (_k, v) in p.as_table().unwrap().iter() {
                    for (_k, v) in v.as_table().unwrap().iter() {
                        check_dep(v);
                    }
                }
            }
            if let Some(r) = man.get("replace") {
                for (_k, v) in r.as_table().unwrap().iter() {
                    check_dep(v);
                }
            }
        });
    Ok(())
}

fn main() {
    if let Err(e) = doit() {
        println!("{:?}", e);
    }
}