zpl_render 0.1.0

data/lib/zpl_render/helvetica_metrics.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ZplRender
+  # Helvetica advance widths (1/1000 em) for ASCII 32-126, from the
+  # Adobe Core 14 AFM metrics. Used to approximate Zebra's scalable
+  # CG Triumvirate (font 0), which shares Helvetica's metrics closely.
+  HELVETICA_WIDTHS = [
+    278, 278, 355, 556, 556, 889, 667, 222, 333, 333, 389, 584,
+    278, 333, 278, 278, 556, 556, 556, 556, 556, 556, 556, 556,
+    556, 556, 278, 278, 584, 584, 584, 556, 1015, 667, 667, 722,
+    722, 667, 611, 778, 722, 278, 500, 667, 556, 833, 722, 778,
+    667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 278,
+    278, 278, 469, 556, 222, 556, 556, 500, 556, 556, 278, 556,
+    556, 222, 222, 500, 222, 833, 556, 556, 556, 556, 333, 500,
+    278, 556, 500, 722, 500, 500, 500, 334, 260, 334, 584
+  ].freeze
+end

data/lib/zpl_render/output/pdf.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "prawn"
+require "stringio"
+
+module ZplRender
+  module Output
+    module Pdf
+      module_function
+
+      # Encode one page per label Canvas. Each page has the label's exact
+      # physical size (canvas dots / dpmm), and the label raster is placed
+      # 1:1 so barcode modules stay sharp when printed.
+      def encode(canvases, dpmm:)
+        raise ArgumentError, "no labels to render" if canvases.empty?
+
+        first = canvases.first
+        doc = Prawn::Document.new(
+          page_size: page_size(first, dpmm),
+          margin: 0,
+          skip_page_creation: false,
+          info: { Creator: "zpl_render #{ZplRender::VERSION}" }
+        )
+        canvases.each_with_index do |canvas, i|
+          doc.start_new_page(size: page_size(canvas, dpmm), margin: 0) if i.positive?
+          png = Png.encode(canvas)
+          doc.image StringIO.new(png), at: [0, doc.bounds.top],
+                                       width: doc.bounds.width, height: doc.bounds.height
+        end
+        doc.render
+      end
+
+      def page_size(canvas, dpmm)
+        # dots -> mm -> points (72 pt / inch, 25.4 mm / inch)
+        [canvas.width / dpmm.to_f / 25.4 * 72.0, canvas.height / dpmm.to_f / 25.4 * 72.0]
+      end
+    end
+  end
+end

data/lib/zpl_render/output/png.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "chunky_png"
+
+module ZplRender
+  module Output
+    module Png
+      module_function
+
+      # Encode a Canvas as a PNG binary string. +scale+ is an integer
+      # nearest-neighbor upscale (keeps barcode modules pixel-exact).
+      def encode(canvas, scale: 1)
+        scale = [scale.to_i, 1].max
+        image = ChunkyPNG::Image.new(canvas.width * scale, canvas.height * scale, ChunkyPNG::Color::WHITE)
+        black = ChunkyPNG::Color::BLACK
+        (0...canvas.height).each do |y|
+          (0...canvas.width).each do |x|
+            next unless canvas.get(x, y)
+
+            if scale == 1
+              image[x, y] = black
+            else
+              (0...scale).each do |dy|
+                (0...scale).each do |dx|
+                  image[x * scale + dx, y * scale + dy] = black
+                end
+              end
+            end
+          end
+        end
+        image.to_blob(:fast_rgb)
+      end
+    end
+  end
+end

data/lib/zpl_render/parser.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ZplRender
+  # Tokenizes a ZPL II stream into [command, params] pairs.
+  #
+  # Commands are introduced by the format prefix (^, changeable via ^CC/~CC)
+  # or the control prefix (~, changeable via ^CT/~CT). The command code is
+  # two characters, except ^A<f> where the second character is the font
+  # designator (^A@ remains its own command). Parameters run until the next
+  # prefix character.
+  class Parser
+    Command = Struct.new(:name, :params, :prefix, keyword_init: true) do
+      # Split comma-separated parameters, preserving empty slots.
+      def args
+        @args ||= params.split(",", -1).map(&:strip)
+      end
+    end
+
+    def self.parse(zpl)
+      new(zpl).parse
+    end
+
+    def initialize(zpl)
+      @zpl = zpl.to_s
+    end
+
+    def parse
+      commands = []
+      caret = "^"
+      tilde = "~"
+      i = 0
+      len = @zpl.length
+
+      while i < len
+        ch = @zpl[i]
+        unless ch == caret || ch == tilde
+          i += 1
+          next
+        end
+
+        prefix = ch == caret ? :caret : :tilde
+        code = @zpl[i + 1, 2].to_s
+        if code.empty?
+          i += 1
+          next
+        end
+
+        name = nil
+        font = nil
+        if code[0]&.upcase == "A" && code != "A@" && prefix == :caret
+          name = "A"
+          font = code[1]
+        else
+          name = code.upcase
+        end
+        i += 3 # prefix + two command characters (^A consumes its font char)
+
+        # ^CC/~CC and ^CT/~CT take effect immediately: their parameter is a
+        # single character that becomes the new prefix.
+        if name == "CC" || name == "CT"
+          new_prefix = @zpl[i]
+          if new_prefix
+            caret = new_prefix if name == "CC"
+            tilde = new_prefix if name == "CT"
+            i += 1
+          end
+          next
+        end
+
+        # parameters: everything until the next prefix character
+        j = i
+        j += 1 while j < len && @zpl[j] != caret && @zpl[j] != tilde
+        params = @zpl[i...j].to_s
+
+        if name == "A"
+          params = "#{font}#{params}"
+        end
+
+        # CR/LF are ignorable in ZPL streams
+        params = params.delete("\r\n") unless %w[GF DG DB].include?(name)
+        params = params.strip if %w[GF DG DB].include?(name)
+
+        commands << Command.new(name: name, params: params, prefix: prefix)
+        i = j
+      end
+
+      commands
+    end
+  end
+end