Initial commit

Author: Stranger6667

.gitignore

@@ -0,0 +1,12 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+.idea

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "css-inline"
+version = "0.1.0"
+authors = ["Dmitry Dygalo <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+html5ever = "*"
+cssparser = "*"
+kuchiki = "0.8"

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dmitry Dygalo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,2 @@
+# css-inline
+Inline CSS into style attributes

src/lib.rs

@@ -0,0 +1,122 @@
+use crate::parse::Declaration;
+use kuchiki::traits::TendrilSink;
+use kuchiki::{parse_html, ElementData, NodeDataRef, Selectors};
+use std::io;
+
+mod parse;
+
+#[derive(Debug)]
+struct Rule {
+    selectors: kuchiki::Selectors,
+    declarations: Vec<Declaration>,
+}
+
+impl Rule {
+    pub fn new(selectors: &str, declarations: Vec<Declaration>) -> Result<Rule, ()> {
+        Ok(Rule {
+            selectors: Selectors::compile(selectors)?,
+            declarations,
+        })
+    }
+}
+
+fn process_style_node(node: NodeDataRef<ElementData>) -> Vec<Rule> {
+    let css = node.text_contents();
+    let mut parse_input = cssparser::ParserInput::new(css.as_str());
+    let mut parser = parse::CSSParser::new(&mut parse_input);
+    parser
+        .parse()
+        .filter_map(|r| {
+            r.map(|(selector, declarations)| Rule::new(&selector, declarations))
+                .ok()
+        })
+        .collect::<Result<Vec<_>, _>>()
+        .unwrap()
+}
+
+/// Inline CSS styles from <style> tags to matching elements in the HTML tree.
+pub fn inline(html: &str) -> Result<String, io::Error> {
+    let document = parse_html().one(html);
+    let rules = document
+        .select("style")
+        .unwrap()
+        .map(process_style_node)
+        .flatten();
+
+    for rule in rules {
+        let matching_elements = document
+            .inclusive_descendants()
+            .filter_map(|node| node.into_element_ref())
+            .filter(|element| rule.selectors.matches(element));
+        for matching_element in matching_elements {
+            let style = rule
+                .declarations
+                .iter()
+                .map(|&(ref key, ref value)| format!("{}:{};", key, value));
+            matching_element
+                .attributes
+                .borrow_mut()
+                .insert("style", style.collect());
+        }
+    }
+
+    let mut out = vec![];
+    document
+        .select("html")
+        .unwrap()
+        .next()
+        .unwrap()
+        .as_node()
+        .serialize(&mut out)?;
+    Ok(String::from_utf8_lossy(&out).to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::*;
+
+    const HTML: &str = r#"<html>
+<head>
+<title>Test</title>
+<style>
+h1, h2 { color:red; }
+strong {
+  text-decoration:none
+  }
+p { font-size:2px }
+p.footer { font-size: 1px}
+</style>
+</head>
+<body>
+<h1>Hi!</h1>
+<p><strong>Yes!</strong></p>
+<p class="footer">Feetnuts</p>
+</body>
+</html>"#;
+
+    #[test]
+    fn test_inline() {
+        let inlined = inline(HTML).unwrap();
+        assert_eq!(
+            inlined,
+            r#"<html><head>
+<title>Test</title>
+<style>
+h1, h2 { color:red; }
+strong {
+  text-decoration:none
+  }
+p { font-size:2px }
+p.footer { font-size: 1px}
+</style>
+</head>
+<body>
+<h1 style="color:red;">Hi!</h1>
+<p style="font-size:2px ;"><strong style="text-decoration:none
+  ;">Yes!</strong></p>
+<p class="footer" style="font-size: 1px;">Feetnuts</p>
+
+</body></html>"#
+        )
+    }
+}

src/main.rs

@@ -0,0 +1,26 @@
+use css_inline::inline;
+
+const HTML: &str = r#"<html>
+<head>
+<title>Test</title>
+<style>
+h1, h2 { color:red; }
+strong {
+  text-decoration:none
+  }
+p { font-size:2px }
+p.footer { font-size: 1px}
+</style>
+</head>
+<body>
+<h1>Hi!</h1>
+<p><strong>Yes!</strong></p>
+<p class="footer">Feetnuts</p>
+</body>
+</html>"#;
+
+fn main() {
+    for _ in 0..1000 {
+        let _ = inline(HTML);
+    }
+}

src/parse.rs

@@ -0,0 +1,86 @@
+pub struct CSSRuleListParser;
+struct CSSDeclarationListParser;
+
+pub type Declaration = (String, String);
+pub type QualifiedRule = (String, Vec<Declaration>);
+
+fn exhaust(input: &mut cssparser::Parser) -> String {
+    let start = input.position();
+    while input.next().is_ok() {}
+    input.slice_from(start).to_string()
+}
+
+impl<'i> cssparser::QualifiedRuleParser<'i> for CSSRuleListParser {
+    type Prelude = String;
+    type QualifiedRule = QualifiedRule;
+    type Error = ();
+
+    fn parse_prelude<'t>(
+        &mut self,
+        input: &mut cssparser::Parser<'i, 't>,
+    ) -> Result<Self::Prelude, cssparser::ParseError<'i, Self::Error>> {
+        let _ = input;
+        Ok(exhaust(input))
+    }
+
+    fn parse_block<'t>(
+        &mut self,
+        prelude: Self::Prelude,
+        _: cssparser::SourceLocation,
+        input: &mut cssparser::Parser<'i, 't>,
+    ) -> Result<Self::QualifiedRule, cssparser::ParseError<'i, Self::Error>> {
+        let parser = cssparser::DeclarationListParser::new(input, CSSDeclarationListParser);
+        let mut declarations = vec![];
+
+        for item in parser {
+            if let Ok(declaration) = item {
+                declarations.push(declaration);
+            }
+        }
+
+        Ok((prelude, declarations))
+    }
+}
+
+impl<'i> cssparser::DeclarationParser<'i> for CSSDeclarationListParser {
+    type Declaration = Declaration;
+    type Error = ();
+
+    fn parse_value<'t>(
+        &mut self,
+        name: cssparser::CowRcStr<'i>,
+        input: &mut cssparser::Parser<'i, 't>,
+    ) -> Result<Self::Declaration, cssparser::ParseError<'i, Self::Error>> {
+        Ok((name.to_string(), exhaust(input)))
+    }
+}
+
+impl cssparser::AtRuleParser<'_> for CSSRuleListParser {
+    type PreludeNoBlock = String;
+    type PreludeBlock = String;
+    type AtRule = QualifiedRule;
+    type Error = ();
+}
+
+impl cssparser::AtRuleParser<'_> for CSSDeclarationListParser {
+    type PreludeNoBlock = String;
+    type PreludeBlock = String;
+    type AtRule = Declaration;
+    type Error = ();
+}
+
+pub struct CSSParser<'i, 't> {
+    input: cssparser::Parser<'i, 't>,
+}
+
+impl<'i: 't, 't> CSSParser<'i, 't> {
+    pub fn new(css: &'t mut cssparser::ParserInput<'i>) -> CSSParser<'i, 't> {
+        CSSParser {
+            input: cssparser::Parser::new(css),
+        }
+    }
+
+    pub fn parse<'a>(&'a mut self) -> cssparser::RuleListParser<'i, 't, 'a, CSSRuleListParser> {
+        cssparser::RuleListParser::new_for_stylesheet(&mut self.input, CSSRuleListParser)
+    }
+}