aboutsummaryrefslogtreecommitdiffhomepage
path: root/crates/shirabe/src/repository/repository_utils.rs
blob: 0f4f6a8b36438b3c715970c3be633864e65d1ee3 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
//! ref: composer/src/Composer/Repository/RepositoryUtils.php

use crate::package::link::Link;
use crate::package::package_interface::PackageInterface;
use crate::repository::composite_repository::CompositeRepository;
use crate::repository::filter_repository::FilterRepository;
use crate::repository::repository_interface::RepositoryInterface;
use indexmap::IndexMap;
use std::any::Any;

pub struct RepositoryUtils;

impl RepositoryUtils {
    pub fn filter_required_packages(
        packages: &[Box<dyn crate::package::base_package::BasePackage>],
        requirer: &dyn PackageInterface,
        include_require_dev: bool,
        mut bucket: Vec<Box<dyn crate::package::base_package::BasePackage>>,
    ) -> Vec<Box<dyn crate::package::base_package::BasePackage>> {
        let mut requires: IndexMap<String, Link> = requirer.get_requires();
        if include_require_dev {
            requires.extend(requirer.get_dev_requires());
        }

        for candidate in packages {
            for name in candidate.get_names(true) {
                if requires.contains_key(&name) {
                    let already_in_bucket = bucket.iter().any(|b| {
                        std::ptr::eq(
                            b.as_ref() as *const dyn crate::package::base_package::BasePackage
                                as *const (),
                            candidate.as_ref()
                                as *const dyn crate::package::base_package::BasePackage
                                as *const (),
                        )
                    });
                    if !already_in_bucket {
                        bucket.push(candidate.clone_box());
                        // TODO(phase-b): recursion requires &dyn PackageInterface; cast pending.
                        let _ = (requires.contains_key("dummy"),);
                    }
                    break;
                }
            }
        }

        bucket
    }

    pub fn flatten_repositories(
        repo: Box<dyn RepositoryInterface>,
        unwrap_filter_repos: bool,
    ) -> Vec<Box<dyn RepositoryInterface>> {
        let repo: Box<dyn RepositoryInterface> = if unwrap_filter_repos {
            if let Some(filter_repo) = repo.as_any().downcast_ref::<FilterRepository>() {
                filter_repo.get_repository().clone_box()
            } else {
                repo
            }
        } else {
            repo
        };

        if let Some(composite_repo) = repo.as_any().downcast_ref::<CompositeRepository>() {
            let mut repos = Vec::new();
            for r in composite_repo.get_repositories() {
                for r2 in Self::flatten_repositories(r.clone_box(), unwrap_filter_repos) {
                    repos.push(r2);
                }
            }
            repos
        } else {
            vec![repo]
        }
    }
}