feat: padding, scaling customization, better tracing & encoder handling

Author: Xevion

src/cli.rs

@@ -9,7 +9,10 @@ use std::io::BufWriter;
 use std::path::PathBuf;
 use tracing::Level;
 
-use crate::{github, image};
+use crate::{
+    encode::{create_encoder, Encoder, ImageFormat},
+    github,
+};
 
 /// Command-line arguments for livecards.
 #[derive(Parser)]
@@ -41,6 +44,41 @@ pub struct Cli {
     pub log_level: Level,
 }
 
+/// Formats the SVG template with repository data.
+///
+/// # Arguments
+/// * `name` - Repository name
+/// * `description` - Repository description
+/// * `language` - Primary programming language
+/// * `stars` - Star count as string
+/// * `forks` - Fork count as string
+///
+/// # Returns
+/// Formatted SVG string
+fn format_svg_template(
+    name: &str,
+    description: &str,
+    language: &str,
+    stars: &str,
+    forks: &str,
+) -> String {
+    let svg_template = include_str!("../card.svg");
+    let wrapped_description = crate::image::wrap_text(description, 65);
+    let language_color =
+        crate::colors::get_color(language).unwrap_or_else(|| "#f1e05a".to_string());
+
+    let formatted_stars = crate::image::format_count(stars);
+    let formatted_forks = crate::image::format_count(forks);
+
+    svg_template
+        .replace("{{name}}", name)
+        .replace("{{description}}", &wrapped_description)
+        .replace("{{language}}", language)
+        .replace("{{language_color}}", &language_color)
+        .replace("{{stars}}", &formatted_stars)
+        .replace("{{forks}}", &formatted_forks)
+}
+
 /// Executes the CLI command to generate a repository card.
 ///
 /// # Arguments
@@ -61,16 +99,41 @@ pub async fn run(cli: Cli) -> Result<()> {
     };
 
     let file = File::create(&output_path)?;
-    let writer = BufWriter::new(file);
+    let mut writer = BufWriter::new(file);
+
+    // Start timing for image generation
+    let start_time = std::time::Instant::now();
 
-    image::generate_image(
+    // Format the SVG template
+    let formatted_svg = format_svg_template(
         &repo.name,
         &repo.description.unwrap_or_default(),
         &repo.language.unwrap_or_default(),
         &repo.stargazers_count.to_string(),
         &repo.forks_count.to_string(),
-        writer,
-    )?;
+    );
+
+    // Create encoder and encode
+    let encoder = create_encoder(ImageFormat::Png);
+    encoder.encode(&formatted_svg, &mut writer, None)?;
+
+    // Calculate timing
+    let duration = start_time.elapsed();
+    let duration_ms = duration.as_millis();
+
+    tracing::debug!(
+        "CLI image generation completed in {}ms for {}",
+        duration_ms,
+        repo_path
+    );
+
+    if duration_ms > 1000 {
+        tracing::warn!(
+            "CLI image generation took {}ms (>1000ms) for {}",
+            duration_ms,
+            repo_path
+        );
+    }
 
     tracing::info!("Successfully generated {}.", output_path.to_string_lossy());
 

src/encode.rs

@@ -10,9 +10,12 @@ use tracing::instrument;
 
 /// Helper function to rasterize SVG and convert to RgbaImage.
 /// This eliminates code duplication across encoders.
-fn rasterize_svg_to_rgba(svg_data: &str) -> Result<RgbaImage> {
-    let rasterizer = crate::image::Rasterizer::new();
-    let pixmap = rasterizer.render(svg_data)?;
+fn rasterize_svg_to_rgba(
+    rasterizer: &crate::image::Rasterizer,
+    svg_data: &str,
+    scale: Option<f64>,
+) -> Result<RgbaImage> {
+    let pixmap = rasterizer.render_with_scale(svg_data, scale)?;
 
     let width = pixmap.width();
     let height = pixmap.height();
@@ -82,10 +85,11 @@ pub trait Encoder {
     /// # Arguments
     /// * `svg_data` - The SVG data to encode
     /// * `writer` - Output writer for the encoded data
+    /// * `scale` - Optional scale factor for the image
     ///
     /// # Returns
     /// Result indicating success or failure
-    fn encode(&self, svg_data: &str, writer: &mut dyn Write) -> Result<()>;
+    fn encode(&self, svg_data: &str, writer: &mut dyn Write, scale: Option<f64>) -> Result<()>;
 }
 
 /// PNG encoder using the resvg library.
@@ -103,9 +107,11 @@ impl PngEncoder {
 }
 
 impl Encoder for PngEncoder {
-    #[instrument(skip(self, writer))]
-    fn encode(&self, svg_data: &str, writer: &mut dyn Write) -> Result<()> {
-        let pixmap = self.rasterizer.render(svg_data)?;
+    #[instrument(skip(self, writer, svg_data))]
+    fn encode(&self, svg_data: &str, writer: &mut dyn Write, scale: Option<f64>) -> Result<()> {
+        let start_time = std::time::Instant::now();
+
+        let pixmap = self.rasterizer.render_with_scale(svg_data, scale)?;
 
         let mut png_encoder = png::Encoder::new(writer, pixmap.width(), pixmap.height());
         png_encoder.set_color(png::ColorType::Rgba);
@@ -123,6 +129,27 @@ impl Encoder for PngEncoder {
             .finish()
             .map_err(|e| LivecardsError::Image(ImageError::PngWrite(e.to_string())))?;
 
+        let duration = start_time.elapsed();
+        let duration_ms = duration.as_millis();
+
+        tracing::debug!(
+            "PNG encoding completed in {}ms (scale: {:?}, size: {}x{})",
+            duration_ms,
+            scale,
+            pixmap.width(),
+            pixmap.height()
+        );
+
+        if duration_ms > 1000 {
+            tracing::warn!(
+                "PNG encoding took {}ms (>1000ms) (scale: {:?}, size: {}x{})",
+                duration_ms,
+                scale,
+                pixmap.width(),
+                pixmap.height()
+            );
+        }
+
         Ok(())
     }
 }
@@ -144,9 +171,9 @@ impl WebPEncoder {
 }
 
 impl Encoder for WebPEncoder {
-    #[instrument(skip(writer))]
-    fn encode(&self, svg_data: &str, writer: &mut dyn Write) -> Result<()> {
-        let img = rasterize_svg_to_rgba(svg_data)?;
+    #[instrument(skip(writer, svg_data))]
+    fn encode(&self, svg_data: &str, writer: &mut dyn Write, scale: Option<f64>) -> Result<()> {
+        let img = rasterize_svg_to_rgba(&crate::image::Rasterizer::new(), svg_data, scale)?;
 
         // Encode as WebP
         img.write_with_encoder(image::codecs::webp::WebPEncoder::new_lossless(writer))
@@ -173,9 +200,9 @@ impl JpegEncoder {
 }
 
 impl Encoder for JpegEncoder {
-    #[instrument(skip(writer))]
-    fn encode(&self, svg_data: &str, writer: &mut dyn Write) -> Result<()> {
-        let img = rasterize_svg_to_rgba(svg_data)?;
+    #[instrument(skip(writer, svg_data))]
+    fn encode(&self, svg_data: &str, writer: &mut dyn Write, scale: Option<f64>) -> Result<()> {
+        let img = rasterize_svg_to_rgba(&crate::image::Rasterizer::new(), svg_data, scale)?;
 
         // Convert RGBA to RGB for JPEG encoding
         let rgb_img = image::DynamicImage::ImageRgba8(img).into_rgb8();
@@ -206,11 +233,12 @@ impl SvgEncoder {
 }
 
 impl Encoder for SvgEncoder {
-    #[instrument(skip(writer))]
-    fn encode(&self, svg_data: &str, writer: &mut dyn Write) -> Result<()> {
+    #[instrument(skip(writer, svg_data))]
+    fn encode(&self, svg_data: &str, writer: &mut dyn Write, _scale: Option<f64>) -> Result<()> {
         writer
             .write_all(svg_data.as_bytes())
             .map_err(|e| LivecardsError::Image(ImageError::SvgWrite(e.to_string())))?;
+
         Ok(())
     }
 }
@@ -232,9 +260,9 @@ impl AvifEncoder {
 }
 
 impl Encoder for AvifEncoder {
-    #[instrument(skip(writer))]
-    fn encode(&self, svg_data: &str, writer: &mut dyn Write) -> Result<()> {
-        let img = rasterize_svg_to_rgba(svg_data)?;
+    #[instrument(skip(writer, svg_data))]
+    fn encode(&self, svg_data: &str, writer: &mut dyn Write, scale: Option<f64>) -> Result<()> {
+        let img = rasterize_svg_to_rgba(&crate::image::Rasterizer::new(), svg_data, scale)?;
 
         // Encode as AVIF with maximum speed settings (speed 10, quality 60)
         img.write_with_encoder(image::codecs::avif::AvifEncoder::new_with_speed_quality(
@@ -265,10 +293,10 @@ impl GifEncoder {
 
 impl Encoder for GifEncoder {
     #[instrument(skip(_svg_data, _writer))]
-    fn encode(&self, _svg_data: &str, _writer: &mut dyn Write) -> Result<()> {
+    fn encode(&self, _svg_data: &str, _writer: &mut dyn Write, _scale: Option<f64>) -> Result<()> {
         // GIF encoding is not currently supported
         Err(LivecardsError::Image(ImageError::GifWrite(
-            "GIF encoding not supported".to_string(),
+            "GIF encoding is not implemented".to_string(),
         )))
     }
 }
@@ -290,9 +318,9 @@ impl IcoEncoder {
 }
 
 impl Encoder for IcoEncoder {
-    #[instrument(skip(writer))]
-    fn encode(&self, svg_data: &str, writer: &mut dyn Write) -> Result<()> {
-        let img = rasterize_svg_to_rgba(svg_data)?;
+    #[instrument(skip(writer, svg_data))]
+    fn encode(&self, svg_data: &str, writer: &mut dyn Write, scale: Option<f64>) -> Result<()> {
+        let img = rasterize_svg_to_rgba(&crate::image::Rasterizer::new(), svg_data, scale)?;
 
         // Resize image to fit ICO requirements (max 256x256)
         let width = img.width();
@@ -339,15 +367,15 @@ pub enum EncoderType {
 }
 
 impl Encoder for EncoderType {
-    fn encode(&self, svg_data: &str, writer: &mut dyn Write) -> Result<()> {
+    fn encode(&self, svg_data: &str, writer: &mut dyn Write, scale: Option<f64>) -> Result<()> {
         match self {
-            EncoderType::Png(encoder) => encoder.encode(svg_data, writer),
-            EncoderType::WebP(encoder) => encoder.encode(svg_data, writer),
-            EncoderType::Jpeg(encoder) => encoder.encode(svg_data, writer),
-            EncoderType::Svg(encoder) => encoder.encode(svg_data, writer),
-            EncoderType::Avif(encoder) => encoder.encode(svg_data, writer),
-            EncoderType::Gif(encoder) => encoder.encode(svg_data, writer),
-            EncoderType::Ico(encoder) => encoder.encode(svg_data, writer),
+            EncoderType::Png(encoder) => encoder.encode(svg_data, writer, scale),
+            EncoderType::WebP(encoder) => encoder.encode(svg_data, writer, scale),
+            EncoderType::Jpeg(encoder) => encoder.encode(svg_data, writer, scale),
+            EncoderType::Svg(encoder) => encoder.encode(svg_data, writer, scale),
+            EncoderType::Avif(encoder) => encoder.encode(svg_data, writer, scale),
+            EncoderType::Gif(encoder) => encoder.encode(svg_data, writer, scale),
+            EncoderType::Ico(encoder) => encoder.encode(svg_data, writer, scale),
         }
     }
 }
@@ -364,46 +392,3 @@ pub fn create_encoder(format: ImageFormat) -> EncoderType {
         ImageFormat::Ico => EncoderType::Ico(IcoEncoder::new()),
     }
 }
-
-/// Generate an image in the specified format.
-///
-/// # Arguments
-/// * `name` - Repository name
-/// * `description` - Repository description
-/// * `language` - Primary programming language
-/// * `stars` - Star count as string
-/// * `forks` - Fork count as string
-/// * `format` - Target image format
-/// * `writer` - Output writer for the encoded data
-///
-/// # Returns
-/// Result indicating success or failure
-#[instrument(skip(writer))]
-pub fn generate_image<W: Write>(
-    name: &str,
-    description: &str,
-    language: &str,
-    stars: &str,
-    forks: &str,
-    format: ImageFormat,
-    mut writer: W,
-) -> Result<()> {
-    let svg_template = include_str!("../card.svg");
-    let wrapped_description = crate::image::wrap_text(description, 65);
-    let language_color =
-        crate::colors::get_color(language).unwrap_or_else(|| "#f1e05a".to_string());
-
-    let formatted_stars = crate::image::format_count(stars);
-    let formatted_forks = crate::image::format_count(forks);
-
-    let svg_filled = svg_template
-        .replace("{{name}}", name)
-        .replace("{{description}}", &wrapped_description)
-        .replace("{{language}}", language)
-        .replace("{{language_color}}", &language_color)
-        .replace("{{stars}}", &formatted_stars)
-        .replace("{{forks}}", &formatted_forks);
-
-    let encoder = create_encoder(format);
-    encoder.encode(&svg_filled, &mut writer)
-}

src/errors.rs

@@ -74,8 +74,8 @@ pub enum GitHubError {
 #[derive(Error, Debug)]
 pub enum ImageError {
     /// Failed to create pixmap
-    #[error("Failed to create pixmap")]
-    PixmapCreation,
+    #[error("Failed to create pixmap: {0}")]
+    PixmapCreation(String),
 
     /// Failed to render SVG
     #[error("Failed to render SVG: {0}")]