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
77
78
79
80
81
82
83
84
85
86
87
88
89
90

pub mod packs;

#[cfg(test)]
mod test_util {
    use configuration::Configuration;
    use packs::parsing::ruby::zeitwerk::get_zeitwerk_constant_resolver;
    use std::collections::{HashMap, HashSet};
    use std::path::PathBuf;

    use packs::configuration;

    use crate::packs::configuration::from_raw;
    use crate::packs::constant_resolver::ConstantResolver;
    use crate::packs::pack::Pack;
    use crate::packs::raw_configuration::RawConfiguration;
    use crate::packs::walk_directory::WalkDirectoryResult;
    use crate::packs::{self};

    pub const SIMPLE_APP: &str = "tests/fixtures/simple_app";

    pub fn get_absolute_root(fixture_name: &str) -> PathBuf {
        PathBuf::from(fixture_name).canonicalize().unwrap()
    }

    pub fn get_zeitwerk_constant_resolver_for_fixture(
        fixture_name: &str,
    ) -> Box<dyn ConstantResolver> {
        let absolute_root = get_absolute_root(fixture_name);
        let configuration = configuration::get(&absolute_root);

        get_zeitwerk_constant_resolver(
            &configuration.pack_set,
            &absolute_root,
            &configuration.cache_directory,
            true,
        )
    }

    // Note that instead, we could derive the `Default` trait on `Pack`
    // However, there should be no reason the "production" code ever initializes
    // a default Pack directly, so this implementation is test only.
    #[allow(clippy::derivable_impls)]
    impl Default for Pack {
        fn default() -> Self {
            Self {
                yml: Default::default(),
                name: Default::default(),
                relative_path: Default::default(),
                dependencies: Default::default(),
                ignored_dependencies: Default::default(),
                ignored_private_constants: Default::default(),
                private_constants: Default::default(),
                package_todo: Default::default(),
                visible_to: Default::default(),
                public_folder: Default::default(),
                layer: Default::default(),
                enforce_dependencies: Default::default(),
                enforce_privacy: Default::default(),
                enforce_visibility: Default::default(),
                enforce_architecture: Default::default(),
                client_keys: Default::default(),
                owner: Default::default(),
            }
        }
    }

    impl Default for Configuration {
        fn default() -> Self {
            let default_absolute_root = std::env::current_dir().unwrap();
            let root_pack = Pack {
                name: ".".to_owned(),
                ..Pack::default()
            };

            let included_packs: HashSet<Pack> =
                vec![root_pack].into_iter().collect();

            let walk_directory_result = WalkDirectoryResult {
                included_files: HashSet::new(),
                included_packs,
                owning_package_yml_for_file: HashMap::new(),
            };
            from_raw(
                &default_absolute_root,
                RawConfiguration::default(),
                walk_directory_result,
            )
        }
    }
}