feat: Loading external stylesheets

Ref: #8

Author: Stranger6667

.github/workflows/build.yml

@@ -58,6 +58,12 @@ jobs:
         with:
           python-version: 3.7
 
+      - name: Start background server
+        run: |
+          python -m pip install flask
+          # Starts the server in background
+          python ./tests/server.py &
+
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal

CHANGELOG.md

@@ -9,14 +9,17 @@
 - `CSSInliner::compact()` constructor for producing smaller HTML output.
 - `CSSInliner.inline_to` that writes the output to a generic writer. [#24](https://github.com/Stranger6667/css-inline/issues/24)
 - Implement `Error` for `InlineError`.
+- Loading external stylesheets. [#8](https://github.com/Stranger6667/css-inline/issues/8)
 
 ### Changed
 
 - Improved error messages. [#27](https://github.com/Stranger6667/css-inline/issues/27)
+- Skip selectors, that can't be parsed.
 
 ### Fixed
 
 - Ignore `@media` queries, since they can not be inlined. [#7](https://github.com/Stranger6667/css-inline/issues/7)
+- Panic in cases when styles are applied to the currently processed "link" tags.
 
 ### Performance
 

Cargo.toml

@@ -16,6 +16,7 @@ categories = ["web-programming"]
 [dependencies]
 cssparser = "0"
 kuchiki = "0.8"
+attohttpc = "0"
 
 [dev-dependencies]
 criterion = ">= 0.1"

python/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+### Added
+
+- Loading external stylesheets. [#8](https://github.com/Stranger6667/css-inline/issues/8)
+
+### Changed
+
+- Skip selectors, that can't be parsed.
+
+### Fixed
+
+- Panic in cases when styles are applied to the currently processed "link" tags.
+
 ## 0.1.0 - 2020-06-24
 
 - Initial public release

python/README.rst

@@ -8,6 +8,7 @@ Fast CSS inlining for Python implemented in Rust.
 Features:
 
 - Removing ``style`` tags after inlining;
+- Resolving external stylesheets (including local files);
 - ... more features will be available soon
 
 **NOTE**. This library is in active development and provides a small number of features at the moment, see ``Limitations`` sections below for more information.
@@ -89,7 +90,6 @@ Limitations
 
 Currently (as of ``0.1.0``) there are the following notable limitations:
 
-- External stylesheets are not resolved (`#8 <https://github.com/Stranger6667/css-inline/issues/8>`_)
 - Inlined CSS is not minimized (`#12 <https://github.com/Stranger6667/css-inline/issues/12>`_)
 - `class` and `id` attributes are not removed (`#13 <https://github.com/Stranger6667/css-inline/issues/13>`_)
 

python/src/lib.rs

@@ -10,23 +10,25 @@ create_exception!(css_inline, InlineError, exceptions::ValueError);
 fn to_pyerr(error: rust_inline::InlineError) -> PyErr {
     match error {
         rust_inline::InlineError::IO(error) => InlineError::py_err(format!("{}", error)),
+        rust_inline::InlineError::Network(error) => InlineError::py_err(format!("{}", error)),
         rust_inline::InlineError::ParseError(message) => InlineError::py_err(message),
     }
 }
 
 /// Customizable CSS inliner.
 #[pyclass]
-#[text_signature = "(remove_style_tags=False)"]
+#[text_signature = "(remove_style_tags=False, base_url=None)"]
 struct CSSInliner {
     inner: rust_inline::CSSInliner,
 }
 
 #[pymethods]
 impl CSSInliner {
     #[new]
-    fn new(remove_style_tags: Option<bool>) -> Self {
+    fn new(remove_style_tags: Option<bool>, base_url: Option<String>) -> Self {
         let options = rust_inline::InlineOptions {
             remove_style_tags: remove_style_tags.unwrap_or(false),
+            base_url,
         };
         CSSInliner {
             inner: rust_inline::CSSInliner::new(options),
@@ -50,27 +52,37 @@ impl CSSInliner {
     }
 }
 
-/// inline(html, remove_style_tags=False)
+/// inline(html, remove_style_tags=False, base_url=None)
 ///
 /// Inline CSS in the given HTML document
 #[pyfunction]
-#[text_signature = "(html, remove_style_tags=False)"]
-fn inline(html: &str, remove_style_tags: Option<bool>) -> PyResult<String> {
+#[text_signature = "(html, remove_style_tags=False, base_url=None)"]
+fn inline(
+    html: &str,
+    remove_style_tags: Option<bool>,
+    base_url: Option<String>,
+) -> PyResult<String> {
     let options = rust_inline::InlineOptions {
         remove_style_tags: remove_style_tags.unwrap_or(false),
+        base_url,
     };
     let inliner = rust_inline::CSSInliner::new(options);
     Ok(inliner.inline(html).map_err(to_pyerr)?)
 }
 
-/// inline_many(htmls, remove_style_tags=False)
+/// inline_many(htmls, remove_style_tags=False, base_url=None)
 ///
 /// Inline CSS in multiple HTML documents
 #[pyfunction]
-#[text_signature = "(htmls, remove_style_tags=False)"]
-fn inline_many(htmls: &PyList, remove_style_tags: Option<bool>) -> PyResult<Vec<String>> {
+#[text_signature = "(htmls, remove_style_tags=False, base_url=None)"]
+fn inline_many(
+    htmls: &PyList,
+    remove_style_tags: Option<bool>,
+    base_url: Option<String>,
+) -> PyResult<Vec<String>> {
     let options = rust_inline::InlineOptions {
         remove_style_tags: remove_style_tags.unwrap_or(false),
+        base_url,
     };
     let inliner = rust_inline::CSSInliner::new(options);
     inline_many_impl(&inliner, htmls)

src/error.rs

@@ -9,6 +9,8 @@ use std::{fmt, io};
 pub enum InlineError {
     /// Input-output error. May happen during writing the resulting HTML.
     IO(io::Error),
+    /// Network-related problem. E.g. resource is not available.
+    Network(attohttpc::Error),
     /// Syntax errors or unsupported selectors.
     ParseError(String),
 }
@@ -18,13 +20,19 @@ impl From<io::Error> for InlineError {
         InlineError::IO(error)
     }
 }
+impl From<attohttpc::Error> for InlineError {
+    fn from(error: attohttpc::Error) -> Self {
+        InlineError::Network(error)
+    }
+}
 
 impl Error for InlineError {}
 
 impl Display for InlineError {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self {
             InlineError::IO(error) => write!(f, "{}", error),
+            InlineError::Network(error) => write!(f, "{}", error),
             InlineError::ParseError(error) => write!(f, "{}", error),
         }
     }

src/lib.rs

@@ -127,14 +127,15 @@
     variant_size_differences
 )]
 use kuchiki::traits::TendrilSink;
-use kuchiki::{parse_html, Selectors};
+use kuchiki::{parse_html, NodeRef, Selectors};
 
 pub mod error;
 mod parser;
 
 pub use error::InlineError;
 use std::collections::HashMap;
-use std::io::Write;
+use std::fs::File;
+use std::io::{Read, Write};
 
 #[derive(Debug)]
 struct Rule<'i> {
@@ -159,6 +160,8 @@ impl<'i> Rule<'i> {
 pub struct InlineOptions {
     /// Remove "style" tags after inlining
     pub remove_style_tags: bool,
+    /// Used for loading external stylesheets via relative URLs
+    pub base_url: Option<String>,
 }
 
 impl InlineOptions {
@@ -167,6 +170,7 @@ impl InlineOptions {
     pub fn compact() -> Self {
         InlineOptions {
             remove_style_tags: true,
+            base_url: None,
         }
     }
 }
@@ -176,6 +180,7 @@ impl Default for InlineOptions {
     fn default() -> Self {
         InlineOptions {
             remove_style_tags: false,
+            base_url: None,
         }
     }
 }
@@ -222,43 +227,88 @@ impl CSSInliner {
         {
             if let Some(first_child) = style_tag.as_node().first_child() {
                 if let Some(css_cell) = first_child.as_text() {
-                    let css = css_cell.borrow();
-                    let mut parse_input = cssparser::ParserInput::new(css.as_str());
-                    let mut parser = parser::CSSParser::new(&mut parse_input);
-                    for parsed in parser.parse() {
-                        if let Ok((selector, declarations)) = parsed {
-                            let rule = Rule::new(selector, declarations).map_err(|_| {
-                                error::InlineError::ParseError("Unknown error".to_string())
-                            })?;
-                            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 mut attributes = matching_element.attributes.borrow_mut();
-                                let style = if let Some(existing_style) = attributes.get("style") {
-                                    merge_styles(existing_style, &rule.declarations)?
-                                } else {
-                                    rule.declarations
-                                        .iter()
-                                        .map(|&(ref key, value)| format!("{}:{};", key, value))
-                                        .collect()
-                                };
-                                attributes.insert("style", style);
-                            }
-                        }
-                        // Ignore not parsable entries. E.g. there is no parser for @media queries
-                        // Which means that they will fall into this category and will be ignored
-                    }
+                    process_css(&document, css_cell.borrow().as_str())?;
                 }
             }
             if self.options.remove_style_tags {
                 style_tag.as_node().detach()
             }
         }
+        for link_tag in document
+            .select("link[rel~=stylesheet]")
+            .map_err(|_| error::InlineError::ParseError("Unknown error".to_string()))?
+        {
+            if let Some(href) = &link_tag.attributes.borrow().get("href") {
+                let url = self.get_full_url(href);
+                let css = self.load_external(url.as_str())?;
+                process_css(&document, css.as_str())?;
+            }
+        }
         document.serialize(target)?;
         Ok(())
     }
+
+    fn get_full_url(&self, href: &str) -> String {
+        if href.starts_with("//") {
+            if let Some(base_url) = &self.options.base_url {
+                if base_url.starts_with("https://") {
+                    format!("https:{}", href)
+                } else {
+                    format!("http:{}", href)
+                }
+            } else {
+                format!("http:{}", href)
+            }
+        } else {
+            href.to_string()
+        }
+    }
+
+    fn load_external(&self, url: &str) -> Result<String, InlineError> {
+        if url.starts_with("http") | url.starts_with("https") {
+            let response = attohttpc::get(url).send()?;
+            Ok(response.text()?)
+        } else {
+            let mut file = File::open(url)?;
+            let mut css = String::new();
+            file.read_to_string(&mut css)?;
+            Ok(css)
+        }
+    }
+}
+
+fn process_css(document: &NodeRef, css: &str) -> Result<(), InlineError> {
+    let mut parse_input = cssparser::ParserInput::new(css);
+    let mut parser = parser::CSSParser::new(&mut parse_input);
+    for parsed in parser.parse() {
+        if let Ok((selector, declarations)) = parsed {
+            if let Ok(rule) = Rule::new(selector, declarations) {
+                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 {
+                    // It can be borrowed if the current selector matches <link> tag, that is
+                    // already borrowed in `inline_to`. We can ignore such matches
+                    if let Ok(mut attributes) = matching_element.attributes.try_borrow_mut() {
+                        let style = if let Some(existing_style) = attributes.get("style") {
+                            merge_styles(existing_style, &rule.declarations)?
+                        } else {
+                            rule.declarations
+                                .iter()
+                                .map(|&(ref key, value)| format!("{}:{};", key, value))
+                                .collect()
+                        };
+                        attributes.insert("style", style);
+                    }
+                }
+            }
+            // Skip selectors that can't be parsed
+        }
+        // Ignore not parsable entries. E.g. there is no parser for @media queries
+        // Which means that they will fall into this category and will be ignored
+    }
+    Ok(())
 }
 
 impl Default for CSSInliner {

tests/external.css

@@ -0,0 +1 @@
+h1 { color: blue; }

tests/server.py

@@ -0,0 +1,15 @@
+from flask import Flask
+
+app = Flask(__name__)
+
+with open("tests/external.css") as fd:
+    STYLESHEET = fd.read()
+
+
+@app.route("/external.css")
+def stylesheet():
+    return STYLESHEET
+
+
+if __name__ == "__main__":
+    app.run()