zpl_renderer 0.1.2

data/renderer/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "zpl-renderer"
+version = "0.1.0"
+edition = "2021"
+description = "Offline ZPL renderer bridge for the zpl_renderer Ruby gem"
+license = "MIT"
+publish = false
+
+[[bin]]
+name = "zpl-renderer"
+path = "src/main.rs"
+
+[dependencies]
+labelize = "1.3.0"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+image = { version = "0.25", default-features = false, features = ["png"] }
+clap = { version = "4", features = ["derive"] }
+rxing = { version = "0.8", default-features = false, features = ["encoding_rs"] }
+
+[profile.release]
+lto = true
+codegen-units = 1
+opt-level = 3
+strip = true

data/renderer/src/main.rs

@@ -0,0 +1,310 @@
+use std::io::{self, Cursor, Read, Write};
+use std::process::ExitCode;
+
+use clap::Parser;
+use image::RgbaImage;
+use labelize::{DrawerOptions, Renderer, ZplParser};
+use serde::{Deserialize, Serialize};
+
+#[derive(Parser, Debug)]
+#[command(
+    name = "zpl-renderer",
+    about = "Offline ZPL to PNG/PDF bridge used by the zpl_renderer Ruby gem"
+)]
+struct Cli {
+    /// Read a JSON render request from stdin and write binary output to stdout.
+    #[arg(long)]
+    json: bool,
+
+    /// Decode barcodes/QR from a PNG on stdin; print JSON results.
+    #[arg(long)]
+    decode: bool,
+
+    /// Output format when not using --json (png|pdf).
+    #[arg(long, default_value = "png")]
+    format: String,
+
+    /// Label width in millimeters.
+    #[arg(long, default_value_t = 101.6)]
+    width_mm: f64,
+
+    /// Label height in millimeters.
+    #[arg(long, default_value_t = 152.4)]
+    height_mm: f64,
+
+    /// Dots per millimeter (8=203dpi, 12=300dpi, 24=600dpi).
+    #[arg(long, default_value_t = 8)]
+    dpmm: i32,
+
+    /// Label index for multi-label ZPL.
+    #[arg(long, default_value_t = 0)]
+    index: usize,
+}
+
+#[derive(Debug, Deserialize)]
+struct RenderRequest {
+    protocol: u32,
+    zpl: String,
+    format: String,
+    width_mm: f64,
+    height_mm: f64,
+    dpmm: i32,
+    #[serde(default)]
+    index: usize,
+}
+
+#[derive(Debug, Serialize)]
+struct DecodeHit {
+    format: String,
+    text: String,
+}
+
+fn main() -> ExitCode {
+    let cli = Cli::parse();
+
+    let result = if cli.decode {
+        run_decode()
+    } else if cli.json {
+        run_json()
+    } else {
+        run_raw(&cli)
+    };
+
+    match result {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(message) => {
+            let _ = writeln!(io::stderr(), "{message}");
+            ExitCode::from(1)
+        }
+    }
+}
+
+fn run_json() -> Result<(), String> {
+    let mut input = String::new();
+    io::stdin()
+        .read_to_string(&mut input)
+        .map_err(|e| format!("failed to read stdin: {e}"))?;
+
+    let request: RenderRequest =
+        serde_json::from_str(&input).map_err(|e| format!("invalid JSON request: {e}"))?;
+
+    if request.protocol != 1 {
+        return Err(format!(
+            "unsupported protocol {}; expected 1",
+            request.protocol
+        ));
+    }
+
+    let bytes = render_zpl(
+        &request.zpl,
+        &request.format,
+        request.width_mm,
+        request.height_mm,
+        request.dpmm,
+        request.index,
+    )?;
+
+    let mut stdout = io::stdout().lock();
+    stdout
+        .write_all(&bytes)
+        .map_err(|e| format!("failed to write stdout: {e}"))?;
+    Ok(())
+}
+
+fn run_raw(cli: &Cli) -> Result<(), String> {
+    let mut input = Vec::new();
+    io::stdin()
+        .read_to_end(&mut input)
+        .map_err(|e| format!("failed to read stdin: {e}"))?;
+
+    let zpl = String::from_utf8_lossy(&input);
+    let bytes = render_zpl(
+        &zpl,
+        &cli.format,
+        cli.width_mm,
+        cli.height_mm,
+        cli.dpmm,
+        cli.index,
+    )?;
+
+    let mut stdout = io::stdout().lock();
+    stdout
+        .write_all(&bytes)
+        .map_err(|e| format!("failed to write stdout: {e}"))?;
+    Ok(())
+}
+
+fn run_decode() -> Result<(), String> {
+    let mut input = Vec::new();
+    io::stdin()
+        .read_to_end(&mut input)
+        .map_err(|e| format!("failed to read stdin: {e}"))?;
+
+    let hits = decode_png(&input)?;
+    let json = serde_json::to_string_pretty(&hits).map_err(|e| e.to_string())?;
+    let mut stdout = io::stdout().lock();
+    stdout
+        .write_all(json.as_bytes())
+        .map_err(|e| format!("failed to write stdout: {e}"))?;
+    stdout
+        .write_all(b"\n")
+        .map_err(|e| format!("failed to write stdout: {e}"))?;
+    Ok(())
+}
+
+fn render_zpl(
+    zpl: &str,
+    format: &str,
+    width_mm: f64,
+    height_mm: f64,
+    dpmm: i32,
+    index: usize,
+) -> Result<Vec<u8>, String> {
+    validate_geometry(width_mm, height_mm, dpmm)?;
+
+    let format = format.to_ascii_lowercase();
+    if format != "png" && format != "pdf" {
+        return Err(format!("unsupported format '{format}'; use png or pdf"));
+    }
+
+    let mut parser = ZplParser::new();
+    let labels = parser
+        .parse(zpl.as_bytes())
+        .map_err(|e| format!("ZPL parse error: {e}"))?;
+
+    if labels.is_empty() {
+        return Err("no labels found in ZPL input".to_string());
+    }
+    if index >= labels.len() {
+        return Err(format!(
+            "index out of range: {index} (label count: {})",
+            labels.len()
+        ));
+    }
+
+    let options = DrawerOptions {
+        label_width_mm: width_mm,
+        label_height_mm: height_mm,
+        dpmm,
+        ..DrawerOptions::default()
+    }
+    .with_defaults();
+
+    let renderer = Renderer::new();
+    let mut png_buf = Cursor::new(Vec::new());
+    renderer
+        .draw_label_as_png(&labels[index], &mut png_buf, options.clone())
+        .map_err(|e| format!("render error: {e}"))?;
+
+    let png_bytes = png_buf.into_inner();
+    if format == "png" {
+        return Ok(png_bytes);
+    }
+
+    let img: RgbaImage = image::load_from_memory(&png_bytes)
+        .map_err(|e| format!("failed to decode rendered PNG: {e}"))?
+        .to_rgba8();
+
+    let mut pdf_buf = Cursor::new(Vec::new());
+    labelize::encode_pdf(&img, &options, &mut pdf_buf)
+        .map_err(|e| format!("PDF encode error: {e}"))?;
+    Ok(pdf_buf.into_inner())
+}
+
+fn decode_png(png_bytes: &[u8]) -> Result<Vec<DecodeHit>, String> {
+    use rxing::{BarcodeFormat, DecodeHints};
+    use std::collections::HashSet;
+
+    let img = image::load_from_memory(png_bytes)
+        .map_err(|e| format!("failed to decode PNG: {e}"))?
+        .to_luma8();
+    let width = img.width();
+    let height = img.height();
+    let luma = img.into_raw();
+
+    let mut hints = DecodeHints {
+        TryHarder: Some(true),
+        PossibleFormats: Some(HashSet::from([
+            BarcodeFormat::CODE_128,
+            BarcodeFormat::CODE_39,
+            BarcodeFormat::EAN_13,
+            BarcodeFormat::ITF,
+            BarcodeFormat::QR_CODE,
+            BarcodeFormat::DATA_MATRIX,
+            BarcodeFormat::PDF_417,
+            BarcodeFormat::AZTEC,
+        ])),
+        ..DecodeHints::default()
+    };
+
+    let results =
+        rxing::helpers::detect_multiple_in_luma_with_hints(luma, width, height, &mut hints)
+            .unwrap_or_default();
+
+    Ok(results
+        .into_iter()
+        .map(|r| DecodeHit {
+            format: format!("{:?}", r.getBarcodeFormat()),
+            text: r.getText().to_string(),
+        })
+        .collect())
+}
+
+fn validate_geometry(width_mm: f64, height_mm: f64, dpmm: i32) -> Result<(), String> {
+    if !(width_mm.is_finite() && height_mm.is_finite()) || width_mm <= 0.0 || height_mm <= 0.0 {
+        return Err("width_mm and height_mm must be positive finite numbers".to_string());
+    }
+    if width_mm > 609.6 || height_mm > 609.6 {
+        return Err("label dimensions exceed 24x24 inches".to_string());
+    }
+    match dpmm {
+        8 | 12 | 24 => Ok(()),
+        other => Err(format!("unsupported dpmm={other}; use 8, 12, or 24")),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn renders_simple_png() {
+        let zpl = "^XA^FO50,50^A0N,40,40^FDHello^FS^XZ";
+        let bytes = render_zpl(zpl, "png", 101.6, 152.4, 8, 0).expect("render");
+        assert!(bytes.starts_with(b"\x89PNG"));
+        assert!(bytes.len() > 100);
+    }
+
+    #[test]
+    fn renders_barcode_and_qr_and_decodes() {
+        let zpl = r#"
+^XA
+^FO50,50^BY3
+^BCN,120,Y,N,N
+^FDHELLO123^FS
+^FO50,250^BQN,2,6
+^FDQA,SCAN-ME-12345^FS
+^XZ
+"#;
+        let bytes = render_zpl(zpl, "png", 101.6, 152.4, 8, 0).expect("render");
+        assert!(bytes.starts_with(b"\x89PNG"));
+
+        let hits = decode_png(&bytes).expect("decode");
+        let texts: Vec<_> = hits.iter().map(|h| h.text.as_str()).collect();
+        assert!(
+            texts.iter().any(|t| t.contains("HELLO123")),
+            "expected Code 128 payload, got {texts:?}"
+        );
+        assert!(
+            texts.iter().any(|t| t.contains("SCAN-ME-12345")),
+            "expected QR payload, got {texts:?}"
+        );
+    }
+
+    #[test]
+    fn rejects_bad_index() {
+        let zpl = "^XA^FO50,50^A0N,40,40^FDHello^FS^XZ";
+        let err = render_zpl(zpl, "png", 101.6, 152.4, 8, 3).unwrap_err();
+        assert!(err.contains("index out of range"));
+    }
+}

data/vendor/bin/SHA256SUMS

@@ -0,0 +1 @@
+470f9834e85da9454f6074775b316fa61053391f0790659cf61a5b7c47aff4bf  ./x86_64-unknown-linux-gnu/zpl-renderer

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: zpl_renderer
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Waqas
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-07-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.65'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.65'
+description: |
+  Convert Zebra Programming Language (ZPL) labels to PNG or PDF entirely offline.
+  Ships a bundled Rust renderer for printer-dot-accurate output with Code 128,
+  QR, GS1, and other common shipping-label barcodes that scanners can decode.
+email:
+- waqas@example.com
+executables:
+- zpl-render
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- COMPATIBILITY.md
+- LICENSE.txt
+- README.md
+- exe/zpl-render
+- lib/zpl_renderer.rb
+- lib/zpl_renderer/binary.rb
+- lib/zpl_renderer/decoder.rb
+- lib/zpl_renderer/engine.rb
+- lib/zpl_renderer/errors.rb
+- lib/zpl_renderer/options.rb
+- lib/zpl_renderer/renderer.rb
+- lib/zpl_renderer/sanitizer.rb
+- lib/zpl_renderer/validation.rb
+- lib/zpl_renderer/version.rb
+- renderer/Cargo.lock
+- renderer/Cargo.toml
+- renderer/src/main.rs
+- vendor/bin/SHA256SUMS
+- vendor/bin/x86_64-unknown-linux-gnu/zpl-renderer
+homepage: https://github.com/waqas/zpl_renderer
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/waqas/zpl_renderer
+  source_code_uri: https://github.com/waqas/zpl_renderer
+  changelog_uri: https://github.com/waqas/zpl_renderer/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Offline ZPL to PNG/PDF renderer with scannable barcodes
+test_files: []