css-autoprefix 0.0.5

Provides a library similar to [autoprefixer](https://github.com/postcss/autoprefixer) to prefix your CSS depending on the versions of web browsers, but in Rust. Currently needs nightly rust as a dependency (phf) needs nightly. Makes use of caniuse.com's database via caniuse-serde (ie offline).
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

// This file is part of css-autoprefix. 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-autoprefix/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-autoprefix. See the COPYRIGHT file in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/css-autoprefix/master/COPYRIGHT.


/// This autoprefixer will only work for simple, 'whole-value' properties, eg those that have a CSS ident token as a value.
/// It does not work when a property-name also needs to be vendor-prefixed, although that is currently an unnecessary requirement.
#[derive(Debug, Clone)]
pub struct SimplePropertyValuePropertyDeclarationAutoprefixer
{
	propertyName: &'static str,
	propertyValue: &'static str,
	removeUnprefixedProperty: bool,
	vendorPrefixes: BTreeSet<VendorPrefix>,
}

impl PropertyDeclarationAutoprefixer for SimplePropertyValuePropertyDeclarationAutoprefixer
{
	fn autoprefix<H: HasPropertyDeclarations<I>, I: HasImportance>(&self, property_declarations: &mut H, parent_vendor_prefix: Option<&VendorPrefix>)
	{
		let list = property_declarations.property_declarations_vec_mut();
		
		let mut index = 0;
		while index != list.len()
		{
			// This ghastly code is because of Rust's borrow checker not allowing simultaneous immutable and mutable references to list via an index in the list, even though we know full well there isn't a real problem in this code
			let vendorPrefixed =
			{
				let propertyDeclaration = list.get(index).unwrap();
				
				if propertyDeclaration.hasAsciiNameIgnoringCase(&self.propertyName)
				{
					let mut vendorPrefixed = Vec::with_capacity(self.vendorPrefixes.len());
					
					for vendorPrefix in self.vendorPrefixes.iter().rev()
					{
						// TODO: Be more efficient and do this outside of the loop
						// This logic 'filters' out vendor prefixes that would be ignored because we are evaluating a property inside, say, @-moz-document, where a prefixed property, such as -webkit-appearance, would make no sense
						let include = if let Some(parentVendorPrefix) = parent_vendor_prefix
						{
							parentVendorPrefix == vendorPrefix
						}
						else
						{
							true
						};
						
						if include
						{
							vendorPrefixed.push(PropertyDeclaration
							{
								vendor_prefix: Some(vendorPrefix.clone()),
								name: propertyDeclaration.name.clone(),
								value: match &propertyDeclaration.value
								{
									value @ &UnparsedPropertyValue::CssWideKeyword(_) => value.clone(),
									&UnparsedPropertyValue::SpecifiedValue(ref specifiedValue) => if &specifiedValue.originalCss == self.propertyValue
									{
										UnparsedPropertyValue::SpecifiedValue(SpecifiedValue
										{
											originalCss: vendorPrefix.prefix(&specifiedValue.originalCss)
										})
									}
									else
									{
										UnparsedPropertyValue::SpecifiedValue(SpecifiedValue
										{
											originalCss: specifiedValue.originalCss.clone()
										})
									},
								},
								importance: propertyDeclaration.importance,
							});
						}
					}
					
					Some(vendorPrefixed)
				}
				else
				{
					None
				}
			};
			
			// TODO: Inefficient
			index += if let Some(mut vendorPrefixed) = vendorPrefixed
			{
				let indexIncrement = vendorPrefixed.len();
				
				for propertyDeclaration in vendorPrefixed.drain(..)
				{
					list.insert(index, propertyDeclaration);
				}
				
				if self.removeUnprefixedProperty
				{
					list.remove(index + indexIncrement);
					indexIncrement
				}
				else
				{
					indexIncrement + 1
				}
			}
			else
			{
				1
			};
		}
	}
}