himg 0.0.4 → 0.0.6

data/ext/himg/src/html_to_image.rs

@@ -1,15 +1,14 @@
-use blitz_dom::net::Resource;
 use blitz_html::HtmlDocument;
-use blitz_net::{MpscCallback, Provider};
-use blitz_renderer_vello::render_to_buffer;
-use blitz_traits::navigation::DummyNavigationProvider;
-use blitz_traits::net::SharedProvider;
-use blitz_traits::{ColorScheme, Viewport};
-use std::sync::Arc;
+use blitz_dom::DocumentConfig;
+use anyrender_vello_cpu::VelloCpuImageRenderer;
+use anyrender::render_to_buffer;
+use blitz_paint::paint_scene;
+use blitz_traits::shell::{Viewport};
 
 use crate::image_size::ImageSize;
 use crate::logger::Logger;
 use crate::options::Options;
+use crate::net_fetcher::NetFetcher;
 
 pub struct RenderOutput {
     pub buffer: Vec<u8>,
@@ -18,47 +17,43 @@ pub struct RenderOutput {
 
 pub async fn html_to_image(
     html: &str,
-    base_url: Option<String>,
     options: Options,
     logger: &mut dyn Logger,
 ) -> RenderOutput {
-    let (mut recv, callback) = MpscCallback::new();
-    logger.log("Initial config");
+    let mut net_fetcher = if options.disable_fetch {
+        logger.log("Disabled fetching resources");
 
-    let callback = Arc::new(callback);
-    let net = Arc::new(Provider::new(callback));
-    logger.log("Setup blitz-net Provider");
+        None
+    } else {
+        let fetcher = NetFetcher::new();
+        logger.log("Setup remote resource fetcher");
 
-    let navigation_provider = Arc::new(DummyNavigationProvider);
-    logger.log("Setup dummy navigation provider");
+        Some(fetcher)
+    };
 
     // Create HtmlDocument
     let mut document = HtmlDocument::from_html(
         &html,
-        base_url,
-        Vec::new(),
-        Arc::clone(&net) as SharedProvider<Resource>,
-        None,
-        navigation_provider,
+        DocumentConfig {
+            base_url: options.base_url,
+            net_provider: net_fetcher.as_ref().map(|fetcher| fetcher.get_provider() as _),
+            ..Default::default()
+        },
     );
     logger.log("Parsed document");
 
     document.as_mut().set_viewport(Viewport::new(
         options.image_size.scaled_width(),
         options.image_size.scaled_height(),
-        options.image_size.hidpi_scale,
+        options.image_size.hidpi_scale as f32,
         options.color_scheme,
     ));
 
-    while !net.is_empty() {
-        let Some((_, res)) = recv.recv().await else {
-            break;
-        };
-        document.as_mut().load_resource(res);
+    if let Some(ref mut net_fetcher) = net_fetcher {
+        net_fetcher.fetch_resources(&mut document).await;
+        logger.log("Fetched assets");
     }
 
-    logger.log("Fetched assets");
-
     // Compute style, layout, etc for HtmlDocument
     document.as_mut().resolve();
     logger.log("Resolved styles and layout");
@@ -76,19 +71,22 @@ pub async fn html_to_image(
     };
     logger.log("Calculated render dimensions from document");
 
-    println!("Screenshot is ({}x{})",render_size.scaled_width(), render_size.scaled_height());
+    if options.verbose {
+        println!("Screenshot is ({}x{})",render_size.scaled_width(), render_size.scaled_height());
+    }
 
     // Render document to RGBA buffer
-    let buffer = render_to_buffer(
-        document.as_ref(),
-        Viewport::new(
+    let buffer = render_to_buffer::<VelloCpuImageRenderer, _>(
+        |scene| paint_scene(
+            scene,
+            document.as_ref(),
+            render_size.hidpi_scale,
             render_size.scaled_width(),
             render_size.scaled_height(),
-            render_size.hidpi_scale,
-            ColorScheme::Light,
         ),
-    )
-    .await;
+        render_size.scaled_width(),
+        render_size.scaled_height(),
+    );
 
     logger.log("Rendered to buffer");
 

data/ext/himg/src/image_size.rs

@@ -2,7 +2,7 @@
 pub struct ImageSize {
     pub width: u32,
     pub height: u32,
-    pub hidpi_scale: f32,
+    pub hidpi_scale: f64,
 }
 
 impl ImageSize {

data/ext/himg/src/lib.rs

@@ -4,32 +4,37 @@ 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;
+pub use options::Options;
+pub use html_to_image::html_to_image;
+pub use writer::write_png;
 
-use crate::image_size::ImageSize;
-use crate::options::Options;
-use blitz_traits::ColorScheme;
+use blitz_traits::shell::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)?,
+                width: hash.lookup2("width", 720)?,
+                height: hash.lookup2("height", 405)?,
                 hidpi_scale: 1.0,
             },
-            truncate: Self::get_option(hash, "truncate", true)?,
+            truncate: hash.lookup2("truncate", true)?,
+            verbose: hash.lookup2("verbose", false)?,
+            base_url: hash.lookup("base_url")?,
+            disable_fetch: hash.lookup2("disable_fetch", false)?,
             color_scheme: ColorScheme::Light,
-            allow_net_requests: true, //TODO: Implement using this
         };
 
         Ok(options)
@@ -50,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,11 +1,30 @@
 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 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,
+            color_scheme: ColorScheme::Light,
+        }
+    }
 }

data/ext/himg/src/renderer.rs

@@ -1,7 +1,7 @@
 use crate::html_to_image::html_to_image;
 use crate::options::Options;
 use crate::writer::write_png;
-use crate::logger::{TimedLogger};
+use crate::logger::{Logger, NullLogger, TimedLogger};
 
 pub fn render_blocking(html: String, options: Options) -> Result<Vec<u8>, std::io::Error> {
     let runtime = tokio::runtime::Runtime::new()?;
@@ -11,12 +11,14 @@ pub fn render_blocking(html: String, options: Options) -> Result<Vec<u8>, std::i
 
 // render_to_bytes, render_to_string, render_to_file, render_to_io
 pub async fn render(html: String, options: Options) -> Result<Vec<u8>, std::io::Error> {
-    let mut logger = TimedLogger::init();
+    let mut logger: Box<dyn Logger> = if options.verbose {
+        Box::new(TimedLogger::init())
+    } else {
+        Box::new(NullLogger{})
+    };
 
     // 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.5)
       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.5)
       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.5)
       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.5)
       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.5)
       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.5)
       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,64 @@
+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 :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/railtie/controller_config.rb

@@ -0,0 +1,31 @@
+module Himg
+  class Railtie
+    module ControllerConfig
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :_apply_himg_config
+      end
+
+      class_methods do
+        def himg_config(options = {})
+          @_himg_global_config ||= {}
+          @_himg_global_config.merge!(options)
+        end
+
+        def _himg_global_config
+          @_himg_global_config&.dup || {}
+        end
+      end
+
+      def himg_config(options = {})
+        @_himg_config.merge!(options)
+        @_himg_config
+      end
+
+      def _apply_himg_config
+        @_himg_config = self.class._himg_global_config
+      end
+    end
+  end
+end

data/lib/himg/railtie/template_handler.rb

@@ -4,7 +4,7 @@ module Himg
     class TemplateHandler
       def self.call(_template, source)
         <<-CODE
-          Himg.render(#{source.inspect})
+          Himg.render(#{source.inspect}, **@_himg_config)
         CODE
       end
     end
@@ -21,7 +21,7 @@ module Himg
           output = begin
             #{preprocessed_view_code}
           end
-          Himg.render(output)
+          Himg.render(output, **@_himg_config)
         CODE
       end
     end

data/lib/himg/railtie.rb

@@ -29,10 +29,21 @@ module Himg
     end
 
     initializer "himg.controller_renderer" do
-      ActionController::Renderers.add :himg do |obj, _options|
-        png_data = Himg.render(obj)
+      ActionController::Renderers.add :himg do |obj, options = {}|
+        configured_options = options[:config] || {}
+        direct_options = options.symbolize_keys.slice(*Himg::RENDER_OPTIONS)
+        merged_options = configured_options.merge(direct_options)
+
+        png_data = Himg.render(obj, **merged_options)
         send_data png_data, type: "image/png", disposition: "inline"
       end
     end
+
+    initializer 'himg.controller_config' do
+      require "himg/railtie/controller_config"
+      ActiveSupport.on_load(:action_controller) do
+        include Himg::Railtie::ControllerConfig
+      end
+    end
   end
 end

data/lib/himg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Himg
-  VERSION = "0.0.4"
+  VERSION = "0.0.6"
 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.
@@ -16,9 +17,10 @@ end
 #
 # Converts HTML to an Image for a minimal subset of HTML and CSS
 module Himg
+  RENDER_OPTIONS = %i[width height truncate verbose].freeze
   class Error < StandardError; end
 
-  def self.render(html, width: 720, height: 405, truncate: true)
-    render_to_string(html, "width" => width, "height" => height, "truncate" => truncate)
+  def self.render(html, width: 720, height: 405, truncate: true, verbose: false, base_url: nil, disable_fetch: false)
+    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)
   end
 end