himg 0.0.5 → 0.0.7

data/ext/himg/src/lib.rs

@@ -4,6 +4,7 @@ pub mod image_size;
 pub mod options;
 pub mod writer;
 pub mod logger;
+pub mod net_fetcher;
 
 pub use renderer::render_blocking;
 pub use image_size::ImageSize;
@@ -11,28 +12,29 @@ pub use options::Options;
 pub use html_to_image::html_to_image;
 pub use writer::write_png;
 
-use blitz_traits::ColorScheme;
 use magnus::{function, prelude::*, ExceptionClass, Error, Ruby, RString, RHash};
 
 impl Options {
-    fn get_option<V: magnus::TryConvert + magnus::IntoValue>(optional_hash: Option<RHash>, key: &str, default: V) -> Result<V, Error> {
-        match optional_hash {
-            Some(hash) => hash.lookup2::<&str, V, V>(key, default),
-            None => Ok(default),
-        }
-    }
-
     pub fn from_ruby(hash: Option<RHash>) -> Result<Self, Error> {
+        let defaults = Options::default();
+
+        let hash = match hash {
+            None => return Ok(defaults),
+            Some(r) => r,
+        };
+
         let options = Options {
             image_size: ImageSize {
-                width: Self::get_option(hash, "width", 720)?,
-                height: Self::get_option(hash, "height", 405)?,
-                hidpi_scale: 1.0,
+                width: hash.lookup2("width", defaults.image_size.width)?,
+                height: hash.lookup2("height", defaults.image_size.height)?,
+                hidpi_scale: defaults.image_size.hidpi_scale,
             },
-            truncate: Self::get_option(hash, "truncate", true)?,
-            verbose: Self::get_option(hash, "verbose", false)?,
-            color_scheme: ColorScheme::Light,
-            allow_net_requests: true, //TODO: Implement using this
+            truncate: hash.lookup2("truncate", defaults.truncate)?,
+            verbose: hash.lookup2("verbose", defaults.verbose)?,
+            base_url: hash.lookup("base_url")?,
+            disable_fetch: hash.lookup2("disable_fetch", defaults.disable_fetch)?,
+            fetch_timeout: hash.lookup2("fetch_timeout", defaults.fetch_timeout)?,
+            color_scheme: defaults.color_scheme,
         };
 
         Ok(options)
@@ -53,7 +55,6 @@ pub fn render_blocking_rb(ruby: &Ruby, html: String, options: Option<RHash>) ->
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("Himg")?;
 
-    //TODO: Allow optional base_url for resolving linked resources (stylesheets, images, fonts, etc)
     module.define_singleton_method("render_to_string", function!(render_blocking_rb, 2))?;
 
     Ok(())

data/ext/himg/src/net_fetcher.rs

@@ -0,0 +1,139 @@
+use blitz_html::HtmlDocument;
+use blitz_net::Provider;
+use blitz_dom::net::Resource;
+use blitz_traits::net::{NetCallback, NetProvider, BoxedHandler, Request};
+use std::sync::Arc;
+use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel};
+
+#[derive(Clone)]
+struct PendingCount {
+    count: Arc<std::sync::atomic::AtomicUsize>,
+}
+
+impl PendingCount {
+    fn new() -> Self {
+        Self {
+            count: Arc::new(std::sync::atomic::AtomicUsize::new(0)),
+        }
+    }
+
+    fn current(&self) -> usize {
+        self.count.load(std::sync::atomic::Ordering::SeqCst)
+    }
+
+    fn increment(&self) {
+        self.count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+    }
+
+    fn decrement(&self) {
+        self.count.fetch_sub(1, std::sync::atomic::Ordering::SeqCst);
+    }
+
+    fn is_empty(&self) -> bool {
+        self.current() == 0
+    }
+}
+
+pub struct ErrorHandlingCallback<T>(UnboundedSender<(usize, Result<T, Option<String>>)>);
+impl<T> ErrorHandlingCallback<T> {
+    pub fn new() -> (UnboundedReceiver<(usize, Result<T, Option<String>>)>, Self) {
+        let (send, recv) = unbounded_channel();
+        (recv, Self(send))
+    }
+}
+impl<T: Send + Sync + 'static> NetCallback<T> for ErrorHandlingCallback<T> {
+    fn call(&self, doc_id: usize, result: Result<T, Option<String>>) {
+        let _ = self.0.send((doc_id, result));
+    }
+}
+
+pub struct ErrorHandlingProvider<D> {
+    inner: Arc<Provider<D>>,
+    callback: Arc<dyn NetCallback<D>>,
+    pending_requests: PendingCount,
+}
+
+impl<D: Send + Sync + 'static> ErrorHandlingProvider<D> {
+    pub fn new(callback: Arc<dyn NetCallback<D>>) -> Self {
+        let inner = Arc::new(Provider::new(callback.clone()));
+        Self {
+            inner,
+            callback,
+            pending_requests: PendingCount::new(),
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.pending_requests.is_empty()
+    }
+}
+
+impl<D: Send + Sync + 'static> NetProvider<D> for ErrorHandlingProvider<D> {
+    fn fetch(&self, doc_id: usize, request: Request, handler: BoxedHandler<D>) {
+        self.pending_requests.increment();
+
+        let callback = self.callback.clone();
+        let request_url = request.url.to_string();
+        let pending_counter = self.pending_requests.clone();
+
+        self.inner.fetch_with_callback(request, Box::new(move |fetch_result| {
+            pending_counter.decrement();
+
+            match fetch_result {
+                Ok((_url, bytes)) => {
+                    println!("Fetched {}", request_url);
+                    handler.bytes(doc_id, bytes, callback);
+                }
+                Err(e) => {
+                    let error_msg = Some(format!("Failed to fetch {}: {:?}", request_url, e));
+                    callback.call(doc_id, Err(error_msg));
+                }
+            }
+        }));
+    }
+}
+
+pub struct NetFetcher {
+    provider: Arc<ErrorHandlingProvider<Resource>>,
+    receiver: UnboundedReceiver<(usize, Result<Resource, Option<String>>)>,
+}
+
+impl NetFetcher {
+    pub fn new() -> Self {
+        let (receiver, callback) = ErrorHandlingCallback::new();
+        let callback = Arc::new(callback);
+        let provider = Arc::new(ErrorHandlingProvider::new(callback));
+
+        Self { provider, receiver }
+    }
+
+    pub fn get_provider(&self) -> Arc<dyn NetProvider<Resource>> {
+        Arc::clone(&self.provider) as Arc<dyn NetProvider<Resource>>
+    }
+
+    pub async fn fetch_resources(&mut self, document: &mut HtmlDocument) {
+        loop {
+            // Synchronous fetch before checking is_empty to avoid race condition
+            // where is_empty's reference counting thinks there is nothing to
+            // process. This happens when the fetch fails very early.
+            let res = match self.receiver.try_recv() {
+                Ok((_, res)) => res,
+                Err(_) => {
+                    if self.provider.is_empty() {
+                        break;
+                    }
+
+                    match self.receiver.recv().await {
+                        Some((_, res)) => res,
+                        None => break,
+                    }
+                }
+            };
+
+            match res {
+                Ok(res) => document.as_mut().load_resource(res),
+                Err(_) => {}
+            }
+        }
+    }
+}

data/ext/himg/src/options.rs

@@ -1,12 +1,32 @@
 use crate::image_size::ImageSize;
 
-use blitz_traits::ColorScheme;
+use blitz_traits::shell::ColorScheme;
 
-#[derive(Clone, Copy)]
+#[derive(Clone)]
 pub struct Options {
     pub image_size: ImageSize,
     pub color_scheme: ColorScheme,
-    pub allow_net_requests: bool,
+    pub disable_fetch: bool,
+    pub fetch_timeout: f64,
+    pub base_url: Option<String>,
     pub truncate: bool,
     pub verbose: bool,
 }
+
+impl Options {
+    pub fn default() -> Self {
+        Self {
+            image_size: ImageSize {
+                width: 720,
+                height: 405,
+                hidpi_scale: 1.0,
+            },
+            truncate:  true,
+            verbose:  false,
+            base_url: None,
+            disable_fetch:  false,
+            fetch_timeout: 10.0,
+            color_scheme: ColorScheme::Light,
+        }
+    }
+}

data/ext/himg/src/renderer.rs

@@ -18,9 +18,7 @@ pub async fn render(html: String, options: Options) -> Result<Vec<u8>, std::io::
     };
 
     // Render to Image
-    //let base_url = format!("file://{}", path_string.clone());
-    let base_url = None;
-    let render_output = html_to_image(&html, base_url, options, &mut *logger).await;
+    let render_output = html_to_image(&html, options, &mut *logger).await;
 
     // Determine output path, and open a file at that path.
     let mut output_buffer: Vec<u8> = Vec::new();

data/gemfiles/plain_ruby.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    himg (0.0.4)
+    himg (0.0.6)
       rb_sys (~> 0.9)
 
 GEM

data/gemfiles/rails_6.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    himg (0.0.4)
+    himg (0.0.6)
       rb_sys (~> 0.9)
 
 GEM

data/gemfiles/rails_7_0.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    himg (0.0.4)
+    himg (0.0.6)
       rb_sys (~> 0.9)
 
 GEM

data/gemfiles/rails_7_1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    himg (0.0.4)
+    himg (0.0.6)
       rb_sys (~> 0.9)
 
 GEM

data/gemfiles/rails_7_2.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    himg (0.0.4)
+    himg (0.0.6)
       rb_sys (~> 0.9)
 
 GEM

data/gemfiles/rails_8.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    himg (0.0.4)
+    himg (0.0.6)
       rb_sys (~> 0.9)
 
 GEM

data/lib/himg/base_url.rb

@@ -0,0 +1,21 @@
+require "uri"
+
+module Himg
+  class BaseUrl
+    def initialize(path_or_url)
+      path_or_url = path_or_url.to_s.strip
+      return if path_or_url&.empty?
+
+      @url = URI.parse(path_or_url)
+      @url.scheme = "file" unless @url.scheme
+
+      raise Himg::Error, "Invalid base_url #{path_or_url}" if @url.path.empty?
+
+      @url.path += "/" unless @url.path.end_with?("/")
+    end
+
+    def to_s
+      @url&.to_s
+    end
+  end
+end

data/lib/himg/cli.rb

@@ -0,0 +1,65 @@
+require "thor"
+require "himg"
+require "open-uri"
+
+module Himg
+  class CLI < Thor
+    desc "screenshot SOURCE_HTML DESTINATION_PNG [OPTIONS]", "Render HTML to a png screenshot"
+
+    option :width, type: :numeric, desc: "Sets the width of the rendered content.", default: 720
+    option :height, type: :numeric, desc: "Sets the desired height of the rendered output.", default: 405
+    option :truncate, type: :boolean, desc: "Keeps the image height fixed instead of expanding to include the full page.", default: true
+    option :verbose, type: :boolean, desc: "Enables detailed logging for debugging and profiling.", default: false
+    option :disable_fetch, type: :boolean, desc: "Skip fetching file/http resources (stylesheets, images, fonts, etc)", default: false
+    option :fetch_timeout, type: :numeric, desc: "Timeout in seconds for fetching resources", default: 10
+    option :http_headers, desc: "HTTP Headers to use when fetching remote resource"
+    option :base_url, desc: "Base URL used to resolve relative URLs"
+
+    long_desc <<-LONGDESC
+      `himg screenshot` takes a path to an HTML file and will render a png image with the output.
+
+      It takes a SOURCE, which can be a file path or a URL to fetch.
+
+      The DESTINATION_PNG must be a local file path.
+
+      CAVEATS: This uses a lightweight HTML parser instead of a full browser, so does not support all features.
+      Additionally it does not use a JavaScript engine, so will screenshot the page as-is and would not work for all webpages.
+    LONGDESC
+    def screenshot(url, destination)
+      Document.new(url, options).load do |content|
+        png = Himg.render(content, **options.transform_keys(&:to_sym))
+
+        File.open(destination, "wb") { |f| f.write(png) }
+      end
+    end
+
+    private
+
+    def self.exit_on_failure?
+      true
+    end
+
+    class Document
+      def initialize(source, options)
+        @source = source
+        @options = options
+      end
+
+      def http_url?
+        @source =~ %r{\Ahttps?\://}
+      end
+
+      def load(&block)
+        if http_url?
+          URI.send(:open, @source) do |input|
+            yield(input.binmode.read)
+          end
+        else
+          File.open(@source) do |f|
+            yield(f.read)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/himg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Himg
-  VERSION = "0.0.5"
+  VERSION = "0.0.7"
 end

data/lib/himg.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "himg/version"
+require_relative "himg/base_url"
 require "himg/railtie" if defined?(Rails::Railtie)
 
 # Attempt to load a versioned extension based on the Ruby version.
@@ -19,7 +20,7 @@ module Himg
   RENDER_OPTIONS = %i[width height truncate verbose].freeze
   class Error < StandardError; end
 
-  def self.render(html, width: 720, height: 405, truncate: true, verbose: false)
-    render_to_string(html, "width" => width.to_i, "height" => height.to_i, "truncate" => truncate, "verbose" => verbose)
+  def self.render(html, width: 720, height: 405, truncate: true, verbose: false, base_url: nil, disable_fetch: false, fetch_timeout: 10)
+    render_to_string(html, "width" => width.to_i, "height" => height.to_i, "truncate" => truncate, "verbose" => verbose, "base_url" => BaseUrl.new(base_url).to_s, "disable_fetch" => disable_fetch, "fetch_timeout" => fetch_timeout.to_f)
   end
 end