Method validate_paths

alpm-mtree/src/mtree/mod.rs:79–146

Validates an [`InputPaths`]. With `input_paths`a set of relative paths and a common base directory is provided. Each member of [`InputPaths::paths`] is compared with the data available in `self` by retrieving metadata from the on-disk files below [`InputPaths::base_dir`]. For this, [`MTREE_PATH_PREFIX`] is stripped from each [`Path`][`crate::mtree::v2::Path`] tracked by the [`Mtree`] and afterwa

(&self, input_paths: &InputPaths)

    ///
    /// [ALPM-MTREE]: https://alpm.archlinux.page/specifications/ALPM-MTREE.5.html
    pub fn validate_paths(&self, input_paths: &InputPaths) -> Result<(), Error> {
        let base_dir = input_paths.base_dir();
        // Use paths in a HashSet for easier handling later.
        let mut hashed_paths = HashSet::new();
        let mut duplicates = HashSet::new();
        for path in input_paths.paths() {
            if hashed_paths.contains(path.as_path()) {
                duplicates.insert(path.to_path_buf());
            }
            hashed_paths.insert(path.as_path());
        }
        // If there are duplicate paths, return early.
        if !duplicates.is_empty() {
            return Err(Error::DuplicatePaths { paths: duplicates });
        }

        let mtree_paths = match self {
            Mtree::V1(mtree) | Mtree::V2(mtree) => mtree,
        };
        let mut errors = PathValidationErrors::new(base_dir.to_path_buf());
        let mut unmatched_paths = Vec::new();

        for mtree_path in mtree_paths.iter() {
            // Normalize the ALPM-MTREE path.
            let normalized_path = match mtree_path.as_normalized_path() {
                Ok(mtree_path) => mtree_path,
                Err(source) => {
                    let mut normalize_errors: Vec<PathValidationError> = vec![source.into()];
                    errors.append(&mut normalize_errors);
                    // Continue, as the ALPM-MTREE data is not as it should be.
                    continue;
                }
            };

            // If the normalized path exists in the hashed input paths, compare.
            if hashed_paths.remove(normalized_path) {
                if let Err(mut comparison_errors) =
                    mtree_path.equals_path(&InputPath::new(base_dir, normalized_path)?)
                {
                    errors.append(&mut comparison_errors);
                }
            } else {
                unmatched_paths.push(mtree_path);
            }
        }

        // Add dedicated error, if some file system paths are not covered by ALPM-MTREE data.
        if !hashed_paths.is_empty() {
            errors.append(&mut vec![PathValidationError::UnmatchedFileSystemPaths {
                paths: hashed_paths.iter().map(|path| path.to_path_buf()).collect(),
            }])
        }

        // Add dedicated error, if some ALPM-MTREE paths have no matching file system paths.
        if !unmatched_paths.is_empty() {
            errors.append(&mut vec![PathValidationError::UnmatchedMtreePaths {
                paths: unmatched_paths
                    .iter()