wip: allowing to ignore Kaleido download at compile time

Signed-off-by: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>

Author: andrei-ng

README.md

@@ -124,7 +124,7 @@ plot.write_image("out.png", ImageFormat::PNG, 800, 600, 1.0);
 
 On your host, when building this project with the `kaleido` feature enabled the Kaleido binary is downloaded automatically for your system's architecture at compile time from the official Kaleido [release page](https://github.com/plotly/Kaleido/releases). This library currently supports `x86_64` on Linux and Windows, and both `x86_64` and `aarch64` on macOS.
 
-When building application for other targets that depend on this feature, the `Kaleido` binary will need to be installed manually on the target machine. Currently, the location where the binary is expected is hardcoded depending on the target OS. E.g., on Linux this defaults to `~/.config/kaleido`. This is defined in source code at [here](https://github.com/plotly/plotly.rs/blob/1405731b5121c1343b491e307222a21ef4becc5e/plotly_kaleido/src/lib.rs#L89)
+When building application for other targets that depend on this feature, the `Kaleido` binary will need to be installed manually on the target machine. Currently, the location where the binary is expected is hardcoded depending on the target OS. E.g., on Linux this defaults to `~/.config/kaleido`. This is defined in source code [here](https://github.com/plotly/plotly.rs/blob/1405731b5121c1343b491e307222a21ef4becc5e/plotly_kaleido/src/lib.rs#L89)
 
 ## Usage Within a Wasm Environment
 

examples/kaleido/Cargo.toml

@@ -1,8 +1,12 @@
 [package]
 name = "kaleido"
 version = "0.1.0"
-authors = ["Michael Freeborn <michaelfreeborn1@gmail.com>"]
+authors = [
+    "Michael Freeborn <michaelfreeborn1@gmail.com>",
+    "Andrei Gherghescu andrei-ng@protonmail.com",
+]
 edition = "2021"
 
 [dependencies]
-plotly = { path = "../../plotly", features = ["kaleido"] }
+plotly = { path = "../../plotly", features = ["kaleido", "kaleido_fetch"] }
+# plotly = { path = "../../plotly", features = ["kaleido"] }

plotly/Cargo.toml

@@ -15,10 +15,12 @@ exclude = ["target/*"]
 
 [features]
 kaleido = ["plotly_kaleido"]
+kaleido_fetch = ["plotly_kaleido/download"]
+
 plotly_ndarray = ["ndarray"]
 plotly_image = ["image"]
-# Embed JavaScript into library and templates for offline use
 plotly_embed_js = []
+
 wasm = ["getrandom", "js-sys", "wasm-bindgen", "wasm-bindgen-futures"]
 with-axum = ["rinja/with-axum", "rinja_axum"]
 
@@ -48,6 +50,8 @@ image = "0.25"
 itertools = ">=0.10, <0.14"
 itertools-num = "0.1"
 ndarray = "0.16"
-plotly_kaleido = { version = "0.11", path = "../plotly_kaleido" }
+plotly_kaleido = { version = "0.11", path = "../plotly_kaleido", features = [
+    "download",
+] }
 rand_distr = "0.4"
 base64 = "0.22"

plotly_kaleido/Cargo.toml

@@ -2,7 +2,10 @@
 name = "plotly_kaleido"
 version = "0.11.0"
 description = "Additional output format support for plotly using Kaleido"
-authors = ["Ioannis Giagkiozis <i.giagkiozis@gmail.com>"]
+authors = [
+    "Ioannis Giagkiozis <i.giagkiozis@gmail.com>",
+    "Andrei Gherghescu andrei-ng@protonmail.com",
+]
 license = "MIT"
 readme = "README.md"
 workspace = ".."
@@ -14,13 +17,19 @@ keywords = ["plot", "chart", "plotly", "ndarray"]
 
 exclude = ["target/*", "kaleido/*", "examples/*"]
 
+[features]
+download = []
+
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 base64 = "0.22"
 dunce = "1.0"
 directories = ">=4, <6"
 
+[dev-dependencies]
+plotly_kaleido = { version = "0.11", path = ".", features = ["download"] }
+
 [build-dependencies]
 zip = "2.1"
 directories = ">=4, <6"

plotly_kaleido/build.rs

@@ -30,15 +30,12 @@ const KALEIDO_URL: &str =
 const KALEIDO_URL: &str =
     "https://github.com/plotly/Kaleido/releases/download/v0.2.1/kaleido_mac_arm64.zip";
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 const KALEIDO_BIN: &str = "kaleido";
 
 #[cfg(target_os = "windows")]
 const KALEIDO_BIN: &str = "kaleido.exe";
 
-#[cfg(target_os = "macos")]
-const KALEIDO_BIN: &str = "kaleido";
-
 fn extract_zip(p: &Path, zip_file: &Path) -> Result<()> {
     let file = fs::File::open(zip_file).unwrap();
     let mut archive = zip::ZipArchive::new(file).unwrap();
@@ -95,35 +92,56 @@ fn extract_zip(p: &Path, zip_file: &Path) -> Result<()> {
 }
 
 fn main() -> Result<()> {
-    let project_dirs = ProjectDirs::from("org", "plotly", "kaleido")
-        .expect("Could not create plotly_kaleido config directory.");
-    let dst: PathBuf = project_dirs.config_dir().into();
+    if cfg!(feature = "download") {
+        let project_dirs = ProjectDirs::from("org", "plotly", "kaleido")
+            .expect("Could not create Kaleido config directory path.");
+        let dst: PathBuf = project_dirs.config_dir().into();
+
+        let kaleido_binary = dst.join("bin").join(KALEIDO_BIN);
+
+        println!("cargo:rerun-if-changed=src/lib.rs");
+        println!(
+            "cargo::rerun-if-changed={}",
+            kaleido_binary.to_string_lossy()
+        );
+
+        println!(
+            "cargo:rustc-env=KALEIDO_BUILD_DL_PATH={}",
+            kaleido_binary.to_string_lossy()
+        );
+
+        if kaleido_binary.exists() {
+            return Ok(());
+        }
 
-    let kaleido_binary = dst.join("bin").join(KALEIDO_BIN);
-    if kaleido_binary.exists() {
-        return Ok(());
+        let msg = format!(
+            "Downloaded Plotly Kaleido from {KALEIDO_URL} to '{}'",
+            dst.to_string_lossy()
+        );
+        println!("cargo::warning={msg}");
+
+        let p = PathBuf::from(env::var("OUT_DIR").unwrap());
+        let kaleido_zip_file = p.join("kaleido.zip");
+
+        let mut cmd = Command::new("cargo")
+            .args(["install", "ruget"])
+            .spawn()
+            .unwrap();
+        cmd.wait()?;
+
+        let mut cmd = Command::new("ruget")
+            .args([
+                KALEIDO_URL,
+                "-o",
+                kaleido_zip_file.as_path().to_str().unwrap(),
+            ])
+            .spawn()
+            .unwrap();
+        cmd.wait()?;
+
+        extract_zip(&dst, &kaleido_zip_file)?;
+    } else {
+        println!("'download' feature disabled. Kaleido binary won't be downloaded and must be installed manually.")
     }
-
-    let p = PathBuf::from(env::var("OUT_DIR").unwrap());
-    let kaleido_zip_file = p.join("kaleido.zip");
-
-    let mut cmd = Command::new("cargo")
-        .args(["install", "ruget"])
-        .spawn()
-        .unwrap();
-    cmd.wait()?;
-
-    let mut cmd = Command::new("ruget")
-        .args([
-            KALEIDO_URL,
-            "-o",
-            kaleido_zip_file.as_path().to_str().unwrap(),
-        ])
-        .spawn()
-        .unwrap();
-    cmd.wait()?;
-
-    extract_zip(&dst, &kaleido_zip_file)?;
-    println!("cargo:rerun-if-changed=src/lib.rs");
     Ok(())
 }

plotly_kaleido/src/lib.rs

@@ -17,7 +17,6 @@ use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 
 use base64::{engine::general_purpose, Engine as _};
-use directories::ProjectDirs;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
@@ -77,32 +76,56 @@ pub struct Kaleido {
 }
 
 impl Kaleido {
+    const KALEIDO_BIN_PATH_ENV: &str = "KALEIDO_BIN_PATH";
+
     pub fn new() -> Kaleido {
-        let path = match Kaleido::binary_path() {
-            Ok(path) => path,
-            Err(msg) => panic!("{}", msg),
+        use std::env;
+        use std::str::FromStr;
+
+        let compile_time_download_path: Option<&'static str> = option_env!("KALEIDO_BUILD_DL_PATH");
+
+        let path = match env::var(Self::KALEIDO_BIN_PATH_ENV) {
+            Ok(val) => {
+                println!(
+                    "Using Kaleido from environment variable {}: {val:?}",
+                    Self::KALEIDO_BIN_PATH_ENV
+                );
+                PathBuf::from_str(&val).unwrap()
+            }
+            Err(runtime_var_err) => match compile_time_download_path {
+                Some(_) => match Kaleido::binary_path() {
+                    Ok(path) => {
+                        println!(
+                            "Using compile time downloaded Kaleido binary from {}",
+                            path.to_string_lossy()
+                        );
+                        path
+                    }
+                    Err(msg) => panic!("Failed tu use local Kaleido binrary: {}", msg),
+                },
+                None => {
+                    println!("{}: {runtime_var_err}.", Self::KALEIDO_BIN_PATH_ENV);
+                    println!(
+                        "Install Kaleido and point {} to the installation path of the binary.",
+                        Self::KALEIDO_BIN_PATH_ENV
+                    );
+                    println!("When compiling the crate for usage on the same host, use `kaleido_fetch` feature to automatically download and use the local version.");
+                    std::process::exit(1);
+                }
+            },
         };
 
         Kaleido { cmd_path: path }
     }
 
     fn root_dir() -> Result<PathBuf, &'static str> {
+        use directories::ProjectDirs;
         let project_dirs = ProjectDirs::from("org", "plotly", "kaleido")
-            .expect("Could not create plotly_kaleido config directory.");
+            .expect("Could not create Kaleido config directory path.");
         Ok(project_dirs.config_dir().into())
     }
 
-    #[cfg(target_os = "linux")]
-    fn binary_path() -> Result<PathBuf, &'static str> {
-        let mut p = Kaleido::root_dir()?;
-        p = p.join("kaleido").canonicalize().unwrap();
-        if !p.exists() {
-            return Err("could not find kaleido executable in path");
-        }
-        Ok(p)
-    }
-
-    #[cfg(target_os = "macos")]
+    #[cfg(any(target_os = "linux", target_os = "macos"))]
     fn binary_path() -> Result<PathBuf, &'static str> {
         let mut p = Kaleido::root_dir()?;
         p = p.join("kaleido").canonicalize().unwrap();