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

// ┌───────────────────────────────────────────────────────────────────────────┐
// │                                                                           │
// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
// │                                                                           │
// └───────────────────────────────────────────────────────────────────────────┘

use std::collections::HashMap;

use super::filter_refs;
use crate::ast::Ruleset::{self};
use crate::ast::*;

pub fn apply_import<'a, 'b>(assets: &'b HashMap<&str, Tree<'a>>) -> impl Fn(&mut Tree<'a>) + 'b {
    |tree| {
        tree.transform(|ruleset| {
            let mut replace = None;
            if let Ruleset::QualRule(QualRule(name, val)) = ruleset {
                if *name == "import" {
                    if let Some(val) = val {
                        if val.starts_with('\"') {
                            replace = assets.get(&val[1..val.len() - 1]).cloned();
                            if replace.is_none() {
                                panic!("File not found: '{}'", &val[1..val.len() - 1])
                            }
                        } else if val.starts_with("url(\"ref://") {
                            replace = assets.get(&val[11..val.len() - 2]).cloned().map(|mut x| {
                                filter_refs(&mut x);
                                x
                            });

                            if replace.is_none() {
                                panic!("File not found: '{}'", &val[1..val.len() - 1])
                            }
                        }
                    }
                }
            }

            if let Some(replace) = replace {
                let rules: Vec<TreeRule<'a>> =
                    replace.iter().cloned().map(TreeRule::Ruleset).collect();

                *ruleset =
                    Ruleset::SelectorRuleset(SelectorRuleset(Selector::default(), rules.clone()))
            }
        });
    }
}