cafkafk/nixpkgs
cafkafk/nixpkgs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 2

tests.nixpkgs-check-by-name: Make structural check a global function

Browse source
This commit is contained in:
Silvan Mosberger 2023-10-20 01:58:23 +02:00
parent 83b887504c
commit 0475238ec0
2 changed files with 116 additions and 136 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
pkgs/test/nixpkgs-check-by-name/src/main.rs
View file

@ -4,6 +4,7 @@ mod references;
mod structure; mod structure;
mod utils; mod utils;
use crate::structure::check_structure;
use anyhow::Context; use anyhow::Context;
use check_result::{flatten_check_results, write_check_result}; use check_result::{flatten_check_results, write_check_result};
use clap::{Parser, ValueEnum}; use clap::{Parser, ValueEnum};
@ -11,7 +12,6 @@ use colored::Colorize;
use std::io; use std::io;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use std::process::ExitCode; use std::process::ExitCode;
use structure::Nixpkgs;
use utils::ErrorWriter; use utils::ErrorWriter;
/// Program to check the validity of pkgs/by-name /// Program to check the validity of pkgs/by-name
@ -88,9 +88,9 @@ pub fn check_nixpkgs<W: io::Write>(
utils::BASE_SUBPATH utils::BASE_SUBPATH
); );
} else { } else {
let nixpkgs = Nixpkgs::new(&nixpkgs_path, &mut error_writer)?; let check_result = check_structure(&nixpkgs_path);
if error_writer.empty { if let Some(nixpkgs) = write_check_result(&mut error_writer, check_result)? {
// Only if we could successfully parse the structure, we do the semantic checks // Only if we could successfully parse the structure, we do the semantic checks
let check_result = flatten_check_results( let check_result = flatten_check_results(
[ [

246
pkgs/test/nixpkgs-check-by-name/src/structure.rs
View file

@ -1,11 +1,10 @@
use crate::check_result::{ use crate::check_result::{
flatten_check_results, pass, sequence_check_results, write_check_result, CheckError, flatten_check_results, pass, sequence_check_results, CheckError, CheckResult,
}; };
use crate::utils; use crate::utils;
use crate::utils::{ErrorWriter, BASE_SUBPATH, PACKAGE_NIX_FILENAME}; use crate::utils::{BASE_SUBPATH, PACKAGE_NIX_FILENAME};
use lazy_static::lazy_static; use lazy_static::lazy_static;
use regex::Regex; use regex::Regex;
use std::io;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
lazy_static! { lazy_static! {
@ -42,155 +41,136 @@ impl Nixpkgs {
} }
} }
impl Nixpkgs { /// Read the structure of a Nixpkgs directory, displaying errors on the writer.
/// Read the structure of a Nixpkgs directory, displaying errors on the writer. /// May return early with I/O errors.
/// May return early with I/O errors. pub fn check_structure(path: &Path) -> CheckResult<Nixpkgs> {
pub fn new<W: io::Write>( let base_dir = path.join(BASE_SUBPATH);
path: &Path,
error_writer: &mut ErrorWriter<W>,
) -> anyhow::Result<Nixpkgs> {
let base_dir = path.join(BASE_SUBPATH);
let check_results = utils::read_dir_sorted(&base_dir)? let check_results = utils::read_dir_sorted(&base_dir)?
.into_iter() .into_iter()
.map(|shard_entry| { .map(|shard_entry| {
let shard_path = shard_entry.path(); let shard_path = shard_entry.path();
let shard_name = shard_entry.file_name().to_string_lossy().into_owned(); let shard_name = shard_entry.file_name().to_string_lossy().into_owned();
let relative_shard_path = Nixpkgs::relative_dir_for_shard(&shard_name); let relative_shard_path = Nixpkgs::relative_dir_for_shard(&shard_name);
if shard_name == "README.md" { if shard_name == "README.md" {
// README.md is allowed to be a file and not checked // README.md is allowed to be a file and not checked
pass(vec![]) pass(vec![])
} else if !shard_path.is_dir() { } else if !shard_path.is_dir() {
CheckError::ShardNonDir { CheckError::ShardNonDir {
relative_shard_path: relative_shard_path.clone(),
}
.into_result()
// we can't check for any other errors if it's a file, since there's no subdirectories to check
} else {
let shard_name_valid = SHARD_NAME_REGEX.is_match(&shard_name);
let check_result = if !shard_name_valid {
CheckError::InvalidShardName {
relative_shard_path: relative_shard_path.clone(), relative_shard_path: relative_shard_path.clone(),
shard_name: shard_name.clone(),
} }
.into_result() .into_result()
// we can't check for any other errors if it's a file, since there's no subdirectories to check
} else { } else {
let shard_name_valid = SHARD_NAME_REGEX.is_match(&shard_name); pass(())
let check_result = if !shard_name_valid { };
CheckError::InvalidShardName {
let entries = utils::read_dir_sorted(&shard_path)?;
let duplicate_check_results = entries
.iter()
.zip(entries.iter().skip(1))
.filter(|(l, r)| {
l.file_name().to_ascii_lowercase() == r.file_name().to_ascii_lowercase()
})
.map(|(l, r)| {
CheckError::CaseSensitiveDuplicate {
relative_shard_path: relative_shard_path.clone(), relative_shard_path: relative_shard_path.clone(),
shard_name: shard_name.clone(), first: l.file_name(),
second: r.file_name(),
}
.into_result::<()>()
});
let check_result = sequence_check_results(
check_result,
flatten_check_results(duplicate_check_results, |_| ()),
);
let check_results = entries.into_iter().map(|package_entry| {
let package_path = package_entry.path();
let package_name = package_entry.file_name().to_string_lossy().into_owned();
let relative_package_dir =
PathBuf::from(format!("{BASE_SUBPATH}/{shard_name}/{package_name}"));
if !package_path.is_dir() {
CheckError::PackageNonDir {
relative_package_dir: relative_package_dir.clone(),
} }
.into_result() .into_result()
} else { } else {
pass(()) let package_name_valid = PACKAGE_NAME_REGEX.is_match(&package_name);
}; let name_check_result = if !package_name_valid {
CheckError::InvalidPackageName {
let entries = utils::read_dir_sorted(&shard_path)?; relative_package_dir: relative_package_dir.clone(),
package_name: package_name.clone(),
let duplicate_check_results = entries
.iter()
.zip(entries.iter().skip(1))
.filter(|(l, r)| {
l.file_name().to_ascii_lowercase() == r.file_name().to_ascii_lowercase()
})
.map(|(l, r)| {
CheckError::CaseSensitiveDuplicate {
relative_shard_path: relative_shard_path.clone(),
first: l.file_name(),
second: r.file_name(),
} }
.into_result::<()>() .into_result()
}); } else {
pass(())
};
let check_result = sequence_check_results( let correct_relative_package_dir =
check_result, Nixpkgs::relative_dir_for_package(&package_name);
flatten_check_results(duplicate_check_results, |_| ()), let shard_check_result =
); if relative_package_dir != correct_relative_package_dir {
// Only show this error if we have a valid shard and package name
// Because if one of those is wrong, you should fix that first
if shard_name_valid && package_name_valid {
CheckError::IncorrectShard {
relative_package_dir: relative_package_dir.clone(),
correct_relative_package_dir: correct_relative_package_dir
.clone(),
}
.into_result()
} else {
pass(())
}
} else {
pass(())
};
let check_results = entries.into_iter().map(|package_entry| { let package_nix_path = package_path.join(PACKAGE_NIX_FILENAME);
let package_path = package_entry.path(); let package_nix_check_result = if !package_nix_path.exists() {
let package_name = package_entry.file_name().to_string_lossy().into_owned(); CheckError::PackageNixNonExistent {
let relative_package_dir = relative_package_dir: relative_package_dir.clone(),
PathBuf::from(format!("{BASE_SUBPATH}/{shard_name}/{package_name}")); }
.into_result()
if !package_path.is_dir() { } else if package_nix_path.is_dir() {
CheckError::PackageNonDir { CheckError::PackageNixDir {
relative_package_dir: relative_package_dir.clone(), relative_package_dir: relative_package_dir.clone(),
} }
.into_result() .into_result()
} else { } else {
let package_name_valid = PACKAGE_NAME_REGEX.is_match(&package_name); pass(())
let name_check_result = if !package_name_valid { };
CheckError::InvalidPackageName {
relative_package_dir: relative_package_dir.clone(),
package_name: package_name.clone(),
}
.into_result()
} else {
pass(())
};
let correct_relative_package_dir = flatten_check_results(
Nixpkgs::relative_dir_for_package(&package_name); [
let shard_check_result = name_check_result,
if relative_package_dir != correct_relative_package_dir { shard_check_result,
// Only show this error if we have a valid shard and package name package_nix_check_result,
// Because if one of those is wrong, you should fix that first ],
if shard_name_valid && package_name_valid { |_| package_name.clone(),
CheckError::IncorrectShard { )
relative_package_dir: relative_package_dir.clone(), }
correct_relative_package_dir: });
correct_relative_package_dir.clone(),
}
.into_result()
} else {
pass(())
}
} else {
pass(())
};
let package_nix_path = package_path.join(PACKAGE_NIX_FILENAME); sequence_check_results(check_result, flatten_check_results(check_results, |x| x))
let package_nix_check_result = if !package_nix_path.exists() { }
CheckError::PackageNixNonExistent {
relative_package_dir: relative_package_dir.clone(),
}
.into_result()
} else if package_nix_path.is_dir() {
CheckError::PackageNixDir {
relative_package_dir: relative_package_dir.clone(),
}
.into_result()
} else {
pass(())
};
flatten_check_results(
[
name_check_result,
shard_check_result,
package_nix_check_result,
],
|_| package_name.clone(),
)
}
});
sequence_check_results(
check_result,
flatten_check_results(check_results, |x| x),
)
}
});
let check_result = flatten_check_results(check_results, |x| {
x.into_iter().flatten().collect::<Vec<_>>()
}); });
if let Some(package_names) = write_check_result(error_writer, check_result)? { flatten_check_results(check_results, |x| Nixpkgs {
Ok(Nixpkgs { path: path.to_owned(),
path: path.to_owned(), package_names: x.into_iter().flatten().collect::<Vec<_>>(),
package_names, })
})
} else {
Ok(Nixpkgs {
path: path.to_owned(),
package_names: vec![],
})
}
}
} }