cleanup

Signed-off-by: Andrei Gherghescu <[email protected]>

Author: andrei-ng

plotly/src/plot.rs

@@ -755,8 +755,8 @@ impl Plot {
     pub fn offline_js_sources() -> String {
         // Note that since 'tex-mml-chtml' conflicts with 'tex-svg' when generating
         // Latex Titles we no longer include it.
-        let local_tex_svg_js = include_str!("../templates/tex-svg-3.2.2.js");
-        let local_plotly_js = include_str!("../templates/plotly.min.js");
+        let local_tex_svg_js = include_str!("../resource/tex-svg-3.2.2.js");
+        let local_plotly_js = include_str!("../resource/plotly.min.js");
 
         format!(
             "<script type=\"text/javascript\">{local_plotly_js}</script>\n

plotly_static/src/lib.rs

@@ -522,10 +522,6 @@ impl Default for StaticExporterBuilder {
 impl StaticExporterBuilder {
     /// Sets the WebDriver port number.
     ///
-    /// # Arguments
-    ///
-    /// * `port` - The port number for the WebDriver server
-    ///
     /// # Examples
     ///
     /// ```rust
@@ -541,10 +537,6 @@ impl StaticExporterBuilder {
 
     /// Sets the WebDriver URL.
     ///
-    /// # Arguments
-    ///
-    /// * `url` - The base URL for the WebDriver server (e.g., "http://localhost")
-    ///
     /// # Examples
     ///
     /// ```rust
@@ -560,10 +552,8 @@ impl StaticExporterBuilder {
 
     /// Controls whether to automatically spawn a WebDriver process.
     ///
-    /// # Arguments
-    ///
-    /// * `yes` - If `true`, automatically spawns a WebDriver process. If
-    ///   `false`, expects an existing WebDriver server to be running.
+    /// If `true`, automatically spawns a WebDriver process. If `false`,
+    /// expects an existing WebDriver server to be running.
     ///
     /// # Examples
     ///
@@ -585,10 +575,8 @@ impl StaticExporterBuilder {
 
     /// Controls whether to use offline mode with bundled JavaScript libraries.
     ///
-    /// # Arguments
-    ///
-    /// * `yes` - If `true`, uses bundled JavaScript libraries instead of CDN.
-    ///   If `false`, downloads libraries from CDN.
+    /// If `true`, uses bundled JavaScript libraries instead of CDN. If `false`,
+    /// downloads libraries from CDN.
     ///
     /// # Examples
     ///
@@ -610,11 +598,6 @@ impl StaticExporterBuilder {
 
     /// Sets custom browser capabilities for the WebDriver.
     ///
-    /// # Arguments
-    ///
-    /// * `caps` - Vector of browser capability strings (e.g., ["--headless",
-    ///   "--no-sandbox"])
-    ///
     /// # Examples
     ///
     /// ```rust
@@ -645,8 +628,6 @@ impl StaticExporterBuilder {
     /// - If `spawn_webdriver` is disabled, it creates a connection to an
     ///   existing WebDriver without spawning
     ///
-    /// # Returns
-    ///
     /// Returns a `Result<StaticExporter>` where:
     /// - `Ok(exporter)` - Successfully created the StaticExporter instance
     /// - `Err(e)` - Failed to create the instance (e.g., WebDriver not
@@ -800,18 +781,6 @@ impl StaticExporter {
     /// browser and saves the result as an image file in the specified
     /// format.
     ///
-    /// # Arguments
-    ///
-    /// * `dst` - The destination path for the output file (extension will be
-    ///   added automatically)
-    /// * `plot` - The Plotly plot data as a JSON value
-    /// * `format` - The desired output image format
-    /// * `width` - The width of the output image in pixels
-    /// * `height` - The height of the output image in pixels
-    /// * `scale` - The scale factor for the image (1.0 = normal size)
-    ///
-    /// # Returns
-    ///
     /// Returns `Ok(())` on success, or an error if the export fails.
     ///
     /// # Examples
@@ -885,16 +854,6 @@ impl StaticExporter {
     /// - SVG: Returns plain SVG text
     /// - PNG/JPEG/WEBP/PDF: Returns base64-encoded data
     ///
-    /// # Arguments
-    ///
-    /// * `plot` - The Plotly plot data as a JSON value
-    /// * `format` - The desired output image format
-    /// * `width` - The width of the output image in pixels
-    /// * `height` - The height of the output image in pixels
-    /// * `scale` - The scale factor for the image (1.0 = normal size)
-    ///
-    /// # Returns
-    ///
     /// Returns the image data as a string on success, or an error if the export
     /// fails.
     ///
@@ -1120,15 +1079,24 @@ impl StaticExporter {
         Ok(caps)
     }
 
-    /// Get diagnostic information about the underlying WebDriver process
+    /// Get diagnostic information about the underlying WebDriver process.
     ///
     /// This method provides detailed information about the WebDriver process
     /// for debugging purposes, including process status, port information,
     /// and connection details.
     ///
-    /// # Returns
+    /// Returns a string with diagnostic information.
+    ///
+    /// # Examples
     ///
-    /// Returns a string with diagnostic information
+    /// ```rust
+    /// use plotly_static::StaticExporterBuilder;
+    ///
+    /// let exporter = StaticExporterBuilder::default().build()?;
+    /// let diagnostics = exporter.get_webdriver_diagnostics();
+    /// println!("{}", diagnostics);
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
     pub fn get_webdriver_diagnostics(&self) -> String {
         self.webdriver.get_diagnostics()
     }
@@ -1348,8 +1316,12 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "chromedriver")]
+    // Skip this test for geckodriver as it doesn't support multiple concurrent
+    // sessions on the same process as gracefully as chromedriver
     fn test_webdriver_process_reuse() {
         init();
+
         let test_plot = create_test_plot();
 
         // Use a unique port to test actual WebDriver process reuse

plotly_static/src/template.rs

@@ -91,7 +91,7 @@ pub(crate) const PDF_EXPORT_JS_SCRIPT: &str = r##"
         return new Promise(function(resolve) {
             img.onload = function() {
                 // Brief delay to ensure image is fully rendered
-                setTimeout(resolve, 150);
+                setTimeout(resolve, 250);
             };
             img.onerror = function() {
                 cleanup();

plotly_static/src/webdriver.rs

@@ -59,7 +59,7 @@ pub struct WebDriver {
 }
 
 impl WebDriver {
-    /// Creates a new WebDriver instance for spawning
+    /// Creates a new WebDriver instance for spawning.
     ///
     /// This method creates a WebDriver instance that will later spawn a new
     /// process. It looks for the WebDriver binary in the following order:
@@ -68,12 +68,6 @@ impl WebDriver {
     /// 2. Build-time downloaded path (if `webdriver_download` feature is
     ///    enabled)
     ///
-    /// # Arguments
-    ///
-    /// * `port` - The port number for the WebDriver server
-    ///
-    /// # Returns
-    ///
     /// Returns a `Result<WebDriver>` where:
     /// - `Ok(webdriver)` - Successfully created the WebDriver instance
     /// - `Err(e)` - Failed to create the instance (e.g., binary not found)
@@ -90,7 +84,7 @@ impl WebDriver {
         })
     }
 
-    /// Spawn a new WebDriver instance, connecting to existing if available
+    /// Spawn a new WebDriver instance, connecting to existing if available.
     ///
     /// This method provides WebDriver management:
     /// 1. First checks if a WebDriver is already running on the specified port
@@ -100,18 +94,12 @@ impl WebDriver {
     /// This approach allows for efficient resource usage and supports both
     /// scenarios where WebDriver is managed externally or needs to be spawned.
     ///
-    /// # Arguments
-    ///
-    /// * `port` - The port number to check/use for WebDriver
-    ///
-    /// # Returns
-    ///
     /// Returns a `Result<WebDriver>` where:
     /// - `Ok(webdriver)` - Successfully created or connected to WebDriver
     /// - `Err(e)` - Failed to create or connect to WebDriver
     pub(crate) fn connect_or_spawn(port: u32) -> Result<Self> {
         match Self::try_connect(port) {
-            Some(external_instance) => Ok(external_instance),
+            Some(active_instance) => Ok(active_instance),
             None => Self::spawn(port)
                 .map_err(|e| anyhow!("Failed to spawn new WebDriver on port {}: {}", port, e)),
         }
@@ -153,6 +141,7 @@ impl WebDriver {
 
         let mut wd = Self::new(port)?;
         wd.spawn_webdriver()?;
+
         if Self::is_webdriver_running(port) {
             info!("Successfully created and started WebDriver on port {port}");
             Ok(wd)
@@ -382,15 +371,13 @@ impl WebDriver {
         ))
     }
 
-    /// Stops the WebDriver process
+    /// Stops the WebDriver process.
     ///
     /// This method manages WebDriver process termination:
     /// - Only terminates processes that were spawned by this instance
     /// - Leaves externally managed WebDriver sessions running
     /// - Logs warnings when attempting to stop external sessions
     ///
-    /// # Returns
-    ///
     /// Returns `Ok(())` on success, or an error if the process termination
     /// fails.
     pub fn stop(&mut self) -> Result<()> {
@@ -415,15 +402,13 @@ impl WebDriver {
         Ok(())
     }
 
-    /// Get diagnostic information about the WebDriver process
+    /// Get diagnostic information about the WebDriver process.
     ///
     /// This method provides detailed information about the WebDriver process
     /// for debugging purposes.
     ///
-    /// # Returns
-    ///
-    /// Returns a string with diagnostic information
-    pub fn get_diagnostics(&self) -> String {
+    /// Returns a string with diagnostic information.
+    pub(crate) fn get_diagnostics(&self) -> String {
         let mut inner = self.inner.lock().unwrap();
         let mut diagnostics = String::new();
 
@@ -528,20 +513,14 @@ impl WebDriver {
         diagnostics
     }
 
-    /// Check if a WebDriver is already running on the specified port
+    /// Check if a WebDriver is already running on the specified port.
     ///
     /// This method performs a WebDriver standard-compliant check by:
     /// 1. Making an HTTP GET request to `/status` endpoint
     /// 2. Checking for HTTP 200 response
     /// 3. Verifying the response contains "ready" indicating the service is
     ///    ready
     ///
-    /// # Arguments
-    ///
-    /// * `port` - The port number to check
-    ///
-    /// # Returns
-    ///
     /// Returns `true` if WebDriver is running and ready, `false` otherwise.
     pub(crate) fn is_webdriver_running(port: u32) -> bool {
         let url = format!("{WEBDRIVER_URL}:{port}/status");