feat: Command Line Interface

Author: Stranger6667

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased]
 
+### Added
+
+- Command Line Interface. [#33](https://github.com/Stranger6667/css-inline/issues/33)
+
 ## [0.2.0] - 2020-06-25
 
 ### Added

Cargo.toml

@@ -11,13 +11,20 @@ keywords = ["html", "css", "css-inline"]
 exclude = [".github", ".pre-commit-config.yaml", ".yamllint", ".gitignore", "tests"]
 categories = ["web-programming"]
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[[bin]]
+name = "css-inline"
+
+[features]
+default = ["cli"]
+cli = ["pico-args", "rayon"]
 
 [dependencies]
 cssparser = "0"
 kuchiki = "0.8"
 attohttpc = "0"
 url = "2"
+pico-args = { version = "0.3.2", optional = true }
+rayon = { version = "1.3.1", optional = true }
 
 [dev-dependencies]
 criterion = ">= 0.1"

README.md

@@ -90,3 +90,36 @@ fn main() -> Result<(), css_inline::InlineError> {
 - `remove_style_tags`. Remove "style" tags after inlining.
 - `base_url`. Base URL to resolve relative URLs
 - `load_remote_stylesheets`. Whether remote stylesheets should be loaded or not
+
+## Command Line Interface
+
+`css-inline` provides a command-line interface:
+
+```bash
+$ css-inline --help
+
+css-inline inlines CSS into HTML documents.
+
+USAGE:
+   css-inline [OPTIONS] [PATH ...]
+   command | css-inline [OPTIONS]
+
+ARGS:
+    <PATH>...
+        An HTML document to process. In each specified document "css-inline" will look for
+        all relevant "style" and "link" tags, will load CSS from them and then will inline it
+        to the HTML tags, according to the relevant CSS selectors.
+        When multiple documents are specified, they will be processed in parallel and each inlined
+        file will be saved with "inlined." prefix. E.g. for "example.html", there will be
+        "inlined.example.html".
+
+OPTIONS:
+    --remove-style-tags
+        Remove "style" tags after inlining.
+
+    --base-url
+        Used for loading external stylesheets via relative URLs.
+
+    --load-remote-stylesheets
+        Whether remote stylesheets should be loaded or not.
+```

python/Cargo.toml

@@ -13,8 +13,12 @@ crate-type = ["cdylib"]
 [build-dependencies]
 built = { version = "0.4", features = ["chrono"] }
 
+[dependencies.css-inline]
+path = ".."
+version = "= 0.2.0"
+default-features = false
+
 [dependencies]
-css-inline = { path = "..", version = "= 0.2.0" }
 url = "2"
 rayon = "1"
 pyo3 = { version = ">= 0.10", features = ["extension-module"] }

src/main.rs

@@ -0,0 +1,117 @@
+use css_inline::{CSSInliner, InlineOptions};
+use rayon::prelude::*;
+use std::error::Error;
+use std::fs::File;
+use std::io::{self, Read};
+
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+const HELP_MESSAGE: &str = concat!(
+    "css-inline ",
+    env!("CARGO_PKG_VERSION"),
+    r#"
+Dmitry Dygalo <[email protected]>
+
+css-inline inlines CSS into HTML documents.
+
+USAGE:
+   css-inline [OPTIONS] [PATH ...]
+   command | css-inline [OPTIONS]
+
+ARGS:
+    <PATH>...
+        An HTML document to process. In each specified document "css-inline" will look for
+        all relevant "style" and "link" tags, will load CSS from them and then will inline it
+        to the HTML tags, according to the relevant CSS selectors.
+        When multiple documents are specified, they will be processed in parallel and each inlined
+        file will be saved with "inlined." prefix. E.g. for "example.html", there will be
+        "inlined.example.html".
+
+OPTIONS:
+    --remove-style-tags
+        Remove "style" tags after inlining.
+
+    --base-url
+        Used for loading external stylesheets via relative URLs.
+
+    --load-remote-stylesheets
+        Whether remote stylesheets should be loaded or not."#
+);
+
+struct Args {
+    help: bool,
+    version: bool,
+    remove_style_tags: bool,
+    base_url: Option<String>,
+    load_remote_stylesheets: bool,
+    files: Vec<String>,
+}
+
+fn parse_url(url: Option<String>) -> Result<Option<url::Url>, url::ParseError> {
+    Ok(if let Some(url) = url {
+        Some(url::Url::parse(url.as_str())?)
+    } else {
+        None
+    })
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let mut args = pico_args::Arguments::from_env();
+    let args = Args {
+        help: args.contains(["-h", "--help"]),
+        version: args.contains(["-v", "--version"]),
+        remove_style_tags: args.contains("--remove-style-tags"),
+        base_url: args.opt_value_from_str("--base-url")?,
+        load_remote_stylesheets: args.contains("--load-remote-stylesheets"),
+        files: args.free()?,
+    };
+
+    if args.help {
+        println!("{}", HELP_MESSAGE)
+    } else if args.version {
+        println!("css-inline {}", VERSION)
+    } else {
+        let options = InlineOptions {
+            remove_style_tags: args.remove_style_tags,
+            base_url: parse_url(args.base_url)?,
+            load_remote_stylesheets: args.load_remote_stylesheets,
+        };
+        let inliner = CSSInliner::new(options);
+        if args.files.is_empty() {
+            let mut buffer = String::new();
+            io::stdin().read_to_string(&mut buffer)?;
+            inliner.inline_to(buffer.as_str().trim(), &mut io::stdout())?;
+        } else {
+            let results: Vec<_> = args
+                .files
+                .par_iter()
+                .map(|filename| {
+                    File::open(filename)
+                        .and_then(read_file)
+                        .and_then(|contents| {
+                            let new_filename = format!("inlined.{}", filename);
+                            File::create(new_filename).and_then(|file| Ok((file, contents)))
+                        })
+                        .and_then(|(mut file, contents)| {
+                            Ok((filename, inliner.inline_to(contents.as_str(), &mut file)))
+                        })
+                        .map_err(|error| (filename, error))
+                })
+                .collect();
+            for result in results {
+                match result {
+                    Ok((filename, result)) => match result {
+                        Ok(_) => println!("{}: SUCCESS", filename),
+                        Err(error) => println!("{}: FAILURE ({})", filename, error),
+                    },
+                    Err((filename, error)) => println!("{}: FAILURE ({})", filename, error),
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn read_file(mut file: File) -> io::Result<String> {
+    let mut contents = String::new();
+    file.read_to_string(&mut contents).and(Ok(contents))
+}