css-minify 0.5.2

CSS parser and minificator based on nom
Documentation 
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::optimizations::transformer::Transform;
use crate::structure::{CssEntities, CssEntity, Media, Parameters, Supports};
use indexmap::map::IndexMap;

#[derive(Default, Debug, Clone)]
pub struct MergeMedia;

impl Transform for MergeMedia {
    fn transform_parameters(&self, parameters: Parameters) -> Parameters {
        parameters
    }

    fn transform(&self, entity: CssEntity) -> CssEntity {
        match entity {
            CssEntity::Media(mut m) => {
                m.screen = m.screen.replace(": ", ":");
                CssEntity::Media(m)
            }
            e => e,
        }
    }

    fn transform_many(&self, entities: CssEntities) -> CssEntities {
        let mut media = IndexMap::new();
        entities
            .0
            .iter()
            .filter_map(|e| match e {
                CssEntity::Media(m) => Some(m),
                _ => None,
            })
            .for_each(|m| {
                media
                    .entry(m.screen.clone())
                    .and_modify(|media: &mut Media| {
                        media
                            .entities
                            .0
                            .append(&mut self.transform_many(m.entities.clone()).0);
                    })
                    .or_insert(m.clone());
            });
        let mut non_media_entities = CssEntities(
            entities
                .0
                .into_iter()
                .filter(|e| !matches!(e, CssEntity::Media(_)))
                .map(|e| match e {
                    CssEntity::Supports(Supports {
                        conditions,
                        entities,
                    }) => Supports {
                        conditions,
                        entities: self.transform_many(entities),
                    }
                    .into(),
                    entity => entity,
                })
                .collect(),
        );
        non_media_entities.0.append(
            &mut media
                .into_iter()
                .map(|(_, m)| m)
                .map(|m| self.transform(m.into()))
                .collect(),
        );
        non_media_entities
    }
}

#[cfg(test)]
mod test {
    use crate::optimizations::merge_media::MergeMedia;
    use crate::optimizations::transformer::Transform;
    use crate::structure::{
        Block, CssEntities, CssEntity, Media, Selector, SelectorWithPseudoClasses, Value,
    };

    #[test]
    fn test_media() {
        assert_eq!(
            MergeMedia::default().transform_many(CssEntities(vec![
                CssEntity::Media(Media {
                    screen: Value::from("only screen and (max-width: 992px)"),
                    entities: vec![CssEntity::Block(Block {
                        selectors: vec![SelectorWithPseudoClasses(
                            Some(Selector::Class("test".into())),
                            vec![]
                        )]
                        .into(),
                        parameters: Default::default()
                    })]
                    .into()
                }),
                CssEntity::Media(Media {
                    screen: Value::from("only screen and (max-width: 992px)"),
                    entities: vec![CssEntity::Block(Block {
                        selectors: vec![SelectorWithPseudoClasses(
                            Some(Selector::Class("test2".into())),
                            vec![]
                        )]
                        .into(),
                        parameters: Default::default()
                    })]
                    .into()
                })
            ])),
            CssEntities(vec![CssEntity::Media(Media {
                screen: Value::from("only screen and (max-width:992px)"),
                entities: vec![
                    CssEntity::Block(Block {
                        selectors: vec![SelectorWithPseudoClasses(
                            Some(Selector::Class("test".into())),
                            vec![]
                        )]
                        .into(),
                        parameters: Default::default()
                    }),
                    CssEntity::Block(Block {
                        selectors: vec![SelectorWithPseudoClasses(
                            Some(Selector::Class("test2".into())),
                            vec![]
                        )]
                        .into(),
                        parameters: Default::default()
                    })
                ]
                .into()
            })])
        )
    }
}