lewp-css 0.2.0

Domain model for CSS Stylesheets. Allowing effective minification and transformations such as autoprefixing and removal by other crates. Updated and maintained version for lewp.
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

// This file is part of css. It is subject to the license terms in the COPYRIGHT file found in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/css/master/COPYRIGHT. No part of predicator, including this file, may be copied, modified, propagated, or distributed except according to the terms contained in the COPYRIGHT file.
// Copyright © 2017 The developers of css. See the COPYRIGHT file in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/css/master/COPYRIGHT.

use {
    crate::{
        domain::{
            at_rules::namespace::{NamespacePrefix, NamespaceUrl, Namespaces},
            selectors::{
                NonTreeStructuralPseudoClass,
                OurSelector,
                PseudoElement,
                VendorPrefixablePseudoClassName,
                VendorPrefixablePseudoElementName,
            },
            Atom,
            VendorPrefix,
        },
        parsers::OurSelectorParser,
        CustomParseError,
    },
    cssparser::{ParseError, Parser, ParserInput, ToCss},
    selectors::SelectorImpl,
    std::collections::HashMap,
};

#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
pub struct OurSelectorImpl;

impl SelectorImpl for OurSelectorImpl {
    type ExtraMatchingData = String;

    type AttrValue = Atom;

    type Identifier = Atom;

    type LocalName = Atom;

    type NamespacePrefix = NamespacePrefix;

    type NamespaceUrl = NamespaceUrl;

    type BorrowedNamespaceUrl = str;

    type BorrowedLocalName = str;

    type NonTSPseudoClass = NonTreeStructuralPseudoClass;

    type PseudoElement = PseudoElement;
}

impl OurSelectorImpl {
    /// Parses a selector
    pub fn parse_selector(
        selector_css: &str,
    ) -> Result<OurSelector, ParseError<CustomParseError>> {
        const LineNumberingIsZeroBased: u32 = 0;

        let mut parserInput = ParserInput::new_with_line_number_offset(
            selector_css,
            LineNumberingIsZeroBased,
        );
        let mut input = Parser::new(&mut parserInput);

        let applyVendorPrefixToPseudoClasses = HashMap::default();
        let applyVendorPrefixToPseudoElements = HashMap::default();
        let ourSelectorParser = OurSelectorParser {
            namespaces: Namespaces::empty(),
            applyVendorPrefixToPseudoClasses: &applyVendorPrefixToPseudoClasses,
            applyVendorPrefixToPseudoElements:
                &applyVendorPrefixToPseudoElements,
        };

        match ourSelectorParser.parse(&mut input) {
            Err(error) => Err(error),
            Ok(mut selectors) => {
                let newSelector = selectors.0.drain(..).next().unwrap();
                Ok(newSelector)
            }
        }
    }

    /// Applies a vendor prefix to a CSS selector
    #[inline(always)]
    pub fn reparse_with_vendor_prefix<'a>(
        selector: &OurSelector,
        applyVendorPrefixToPseudoClasses: &'a HashMap<
            VendorPrefixablePseudoClassName,
            VendorPrefix,
        >,
        applyVendorPrefixToPseudoElements: &'a HashMap<
            VendorPrefixablePseudoElementName,
            VendorPrefix,
        >,
    ) -> Option<OurSelector> {
        const LineNumberingIsZeroBased: u32 = 0;

        let originalCss = selector.to_css_string();

        let mut parserInput = ParserInput::new_with_line_number_offset(
            &originalCss,
            LineNumberingIsZeroBased,
        );
        let mut input = Parser::new(&mut parserInput);

        let ourSelectorParser = OurSelectorParser {
            namespaces: Namespaces::empty(),
            applyVendorPrefixToPseudoClasses,
            applyVendorPrefixToPseudoElements,
        };

        let mut selectors = ourSelectorParser.parse(&mut input).unwrap();
        let newSelector = selectors.0.drain(..).next().unwrap();

        if newSelector.to_css_string() != originalCss {
            Some(newSelector)
        } else {
            None
        }
    }
}