hexapdf-extras 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c7f4718bb802b0d1dd228a9fa22fb44ed10dd95402d72c664d937dc8368c5c2
-  data.tar.gz: 7a8111bdb4d323ae5ca910bb215c6aacdbb0799ea05a264a5d4d459a7b21c67c
+  metadata.gz: 33a96708a4a5370678eefced16946538c63b6a078631d0f5c6b431a997874ff1
+  data.tar.gz: 82dadc4117398db36f731c1aeb0fe2a360f299a1d4cc19ae039297ec39129efa
 SHA512:
-  metadata.gz: bdf857f06fc000adb0a716bcb4d039b314a0acd3f424a2e39f370bf61851741467f4b3e6319b02d7d0f86d95179ab399ad88cdf0ba95f2202efbae9e422c3ef1
-  data.tar.gz: a9ba5813153564d05eff9c10e538a1793c3c6f469025969d50e17ffeb2755e64c7b2c57d88f4a0acb18ef1dfdc853f22d8238fb559e665261134bae5c44ff850
+  metadata.gz: 7182df01f81a1712c18e8145ca27f0a2b33fc05b7c1dedc6f725be302029938afb76d35d2d3c08d15145bdf240963b20dcf1e4e641aed450327d704a3f765e45
+  data.tar.gz: 6473c0cbf68559279f377fdfc2862050d7ebb2ab0521d97c8fe1660321a7636a1a9aed992bc669afac25c8d15f5fbaa9b4b7092a4fff9369afde4bf2ab0fe2aa

data/README.rdoc

@@ -38,6 +38,29 @@ Note: There was a {bug in poppler}[https://gitlab.freedesktop.org/poppler/popple
 (already fixed) which leads to invalid rendering in Okular (as of 2022-08-06).
 
 
+=== Barcode Generator
+
+This extensions provides access to generating nearly any kind of barcode. It taps into the graphic
+objects and boxes system of HexaPDF to easily allow creating barcodes:
+
+  require 'hexapdf'
+  require 'hexapdf-extras'
+
+  doc = HexaPDF::Document.new
+  canvas = doc.pages.add.canvas
+  canvas.draw(:barcode, at: [100, 100], width: 300, symbology: :code128, value: "Hello HexaPDF!")
+  doc.write('zint.pdf')
+
+Underneath the +ruby-zint+ library is used which relies on the libzint library via FFI. This means
+that you need to install the +ruby-zint+ library for this extension to work.
+
+See
+{HexaPDF::Extras::GraphicObject::Zint}[https://hexapdf-extras.gettalong.org/api/HexaPDF/Extras/GraphicObject/Zint.html]
+and
+{HexaPDF::Extras::Layout::ZintBox}[https://hexapdf-extras.gettalong.org/api/HexaPDF/Extras/Layout/ZintBox.html]
+for details.
+
+
 === Swiss QR-bill generator
 
 This extension provides a box class for the document layouting facilities of HexaPDF to easily

data/lib/hexapdf/extras/graphic_object/zint.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require 'zint'
+
+module HexaPDF
+  module Extras
+    module GraphicObject
+
+      # Generates a barcode using the {ruby-zint}[https://github.com/eliasfroehner/ruby-zint]
+      # library that uses the libzint barcode generation library.
+      #
+      # It implements the {HexaPDF graphic object
+      # interface}[https://hexapdf.gettalong.org/documentation/api/HexaPDF/Content/GraphicObject/index.html]
+      # and can therefore easily be used via the +:barcode+ name:
+      #
+      #   canvas.draw(:barcode, width: 50, at: [10, 40], value: 'Hello!', symbology: :code128)
+      #
+      # Except for a few keyword arguments all are passed through to ruby-zint, so everything that
+      # is supported by Zint::Barcode can be used. To make specifying symbologies easier, it is
+      # possible to use symbolic names instead of the constants, see #configure.
+      #
+      # == Examples
+      #
+      # * Linear barcode
+      #
+      #     #>pdf-canvas100
+      #     canvas.draw(:barcode, width: 60, at: [20, 45], value: '1123456', symbology: :upce)
+      #     canvas.draw(:barcode, width: 60, at: [20, 5], value: 'Hello!', symbology: :code128)
+      #
+      # * Stacked barcode
+      #
+      #     #>pdf-canvas100
+      #     canvas.draw(:barcode, width: 80, at: [10, 40], symbology: :codablockf,
+      #                 value: 'Hello HexaPDF!', option_1: 3)
+      #
+      # * Composite barcode
+      #
+      #     #>pdf-canvas100
+      #     canvas.draw(:barcode, width: 80, at: [10, 20], symbology: :gs1_128_cc,
+      #                 value: '[99]1234-abcd', primary: "[01]03312345678903", option_1: 3)
+      #
+      # * 2D barcode
+      #
+      #     #>pdf-canvas100
+      #     canvas.draw(:barcode, width: 80, at: [10, 10], symbology: :datamatrix,
+      #                 value: 'Hello HexaPDF!', option_3: 100, output_options: 0x0100)
+      class Zint
+
+        # Creates and configures a new Zint drawing support object.
+        #
+        # See #configure for the allowed keyword arguments.
+        def self.configure(**kwargs)
+          new.configure(**kwargs)
+        end
+
+        # The position of the bottom-left corner of the barcode.
+        #
+        # Default: [0, 0].
+        #
+        # Examples:
+        #
+        #   #>pdf-canvas100
+        #   canvas.draw(:barcode, height: 50, value: 'test', symbology: :code128)
+        #   canvas.draw(:barcode, height: 50, value: 'test', symbology: :code128, at: [20, 50])
+        attr_accessor :at
+
+        # The width of resulting barcode.
+        #
+        # The resulting size of the barcode depends on whether width and #height are set:
+        #
+        # * If neither width nor height are set, the barcode uses the size returned by ruby-zint.
+        #
+        # * If both are set, the barcode is fit exactly into the given rectangle.
+        #
+        # * If either width or height is set, the other dimension is based on the set dimension so
+        #   that the original aspect ratio is maintained.
+        #
+        # Default: nil.
+        #
+        # Examples:
+        #
+        # * No dimension set
+        #
+        #     #>pdf-canvas100
+        #     canvas.draw(:barcode, value: 'test', symbology: :code128)
+        #
+        # * One dimension set
+        #
+        #     #>pdf-canvas100
+        #     canvas.draw(:barcode, width: 60, value: 'test', symbology: :code128)
+        #     canvas.draw(:barcode, height: 50, value: 'test', symbology: :code128, at: [0, 50])
+        #
+        # * Both dimensions set
+        #
+        #     #>pdf-canvas100
+        #     canvas.draw(:barcode, width: 60, height: 60, value: 'test', symbology: :code128)
+        attr_accessor :width
+
+        # The height of the barcode.
+        #
+        # For details and examples see #width.
+        #
+        # Default: nil.
+        attr_accessor :height
+
+        # The font used when outputting strings.
+        #
+        # Any font that is supported by the HexaPDF::Document::Layout module is supported.
+        #
+        # Default: 'Helvetica'.
+        #
+        # Examples:
+        #
+        #   #>pdf-canvas100
+        #   canvas.draw(:barcode, height: 50, font: 'Courier', value: 'test', symbology: :code128)
+        attr_accessor :font
+
+        # The keyword arguments that are passed on to Zint::Barcode.new.
+        #
+        # Default: {}.
+        attr_accessor :zint_kws
+
+        # Creates a Zint graphic object.
+        def initialize
+          @at = [0, 0]
+          @width = nil
+          @height = nil
+          @font = 'Helvetica'
+          @zint_kws = {}
+        end
+
+        # Configures the Zint graphic object and returns self.
+        #
+        # The following arguments are allowed:
+        #
+        # :at::
+        #     The position of the bottom-left corner (see #at).
+        #
+        # :width::
+        #     The width of the barcode (see #width).
+        #
+        # :height::
+        #     The height of the barcode (see #height).
+        #
+        # :font::
+        #     The font to use when outputting strings (see #font).
+        #
+        # :symbology::
+        #     The type of barcode. Supports using symbols instead of constants, e.g. +:code128+
+        #     instead of Zint::BARCODE_CODE128.
+        #
+        # :zint_kws::
+        #     Keyword arguments that are passed on to ruby-zint.
+        #
+        # Any arguments not specified are not modified and retain their old value, see the attribute
+        # methods for the inital default values.
+        def configure(at: nil, width: nil, height: nil, font: nil, symbology: nil, **zint_kws)
+          @at = at if at
+          @width = width if width
+          @height = height if height
+          @font = font if font
+          @zint_kws = zint_kws unless zint_kws.empty?
+          @zint_kws[:symbology] = if symbology && symbology.kind_of?(Symbol)
+                                    ::Zint.const_get("BARCODE_#{symbology.upcase}")
+                                  elsif symbology
+                                    symbology
+                                  end
+          self
+        end
+
+        # Maps the Zint color codes to HexaPDF color names.
+        COLOR_CODES = {
+          1 => "cyan",
+          2 => "blue",
+          3 => "magenta",
+          4 => "red",
+          5 => "yellow",
+          6 => "green",
+          7 => "black",
+          8 => "white",
+        }
+
+        # Draws the Zint::Barcode object onto the given canvas, with the bottom-left corner at the
+        # position specified by #at and the size specified by #width and #height.
+        def draw(canvas)
+          form = form_xobject(canvas.context.document)
+          canvas.xobject(form, at: @at, width: @width, height: @height)
+        end
+
+        # Creates a Form XObject for the given HexaPDF::Document that contains the visual
+        # representation of the barcode.
+        def form_xobject(document)
+          barcode = ::Zint::Barcode.new(**@zint_kws)
+          vector = barcode.to_vector
+
+          height = vector.height
+          form = document.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, vector.width, height]})
+          canvas = form.canvas
+
+          canvas.fill_color(barcode.bgcolour).rectangle(0, 0, vector.width, height).fill
+          vector.each_rectangle.group_by {|rect| rect.colour }.each do |color, rects|
+            canvas.fill_color(COLOR_CODES.fetch(color, barcode.fgcolour))
+            rects.each {|rect| canvas.rectangle(rect.x, height - rect.y, rect.width, -rect.height) }
+            canvas.fill
+          end
+          vector.each_circle.group_by {|circle| circle.colour }.each do |color, circles|
+            canvas.fill_color(COLOR_CODES.fetch(color, barcode.fgcolour))
+            circles.each {|circle| canvas.circle(circle.x, height - circle.y, circle.diameter / 2.0) }
+            canvas.fill
+          end
+          layout = canvas.context.document.layout
+          vector.each_string do |string|
+            fragment = layout.text_fragments(string.text, font: @font, font_size: string.fsize)[0]
+            x = string.x + case string.halign
+                           when 0 then -fragment.width / 2.0
+                           when 1 then 0
+                           when 2 then -fragment.width
+                           end
+            fragment.draw(canvas, x, height - string.y)
+          end
+
+          form
+        end
+      end
+
+    end
+  end
+end

data/lib/hexapdf/extras/graphic_object.rb

@@ -4,6 +4,7 @@ module HexaPDF
   module Extras
     module GraphicObject
       autoload(:QRCode, 'hexapdf/extras/graphic_object/qr_code')
+      autoload(:Zint, 'hexapdf/extras/graphic_object/zint')
     end
   end
 end

data/lib/hexapdf/extras/layout/swiss_qr_bill.rb

@@ -4,15 +4,7 @@ require 'hexapdf/error'
 require 'hexapdf/layout/box'
 require 'hexapdf/extras/layout'
 
-module HexaPDF::Extras::Layout::NumericMeasurementHelper #:nodoc:
-  refine Numeric do
-    def mm
-      self * 72 / 25.4
-    end
-  end
-end
-
-using HexaPDF::Extras::Layout::NumericMeasurementHelper
+using HexaPDF::Utils
 
 module HexaPDF
   module Extras

data/lib/hexapdf/extras/layout/zint_box.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'hexapdf/layout/box'
+require 'hexapdf/extras/graphic_object/zint'
+
+module HexaPDF
+  module Extras
+    module Layout
+
+      # A ZintBox object is used for displaying a barcode.
+      #
+      # Internally, GraphicObject::Zint is used, so any option except +at+, +width+ and +height+
+      # supported there can be used here.
+      #
+      # The size of the barcode is determined by the width and height of the box. For details on how
+      # this works see GraphicObject::Zint#width.
+      #
+      # Example:
+      #
+      #   #>pdf-composer100
+      #   composer.box(:barcode, height: 30, style: {position: :float},
+      #                data: {value: 'Test', symbology: :qrcode})
+      #   composer.box(:barcode, width: 60, style: {position: :float},
+      #                data: {value: 'Test', symbology: :code128, bgcolour: 'ff0000',
+      #                       fgcolour: '00ffff'})
+      #   composer.box(:barcode, width: 30, height: 50, style: {position: :float},
+      #                data: {value: 'Test', symbology: :code128})
+      #   composer.box(:barcode, data: {value: 'Test', symbology: :code128})
+      class ZintBox < HexaPDF::Layout::ImageBox
+
+        # The HexaPDF::Extras::GraphicObject::Zint object that will be drawn.
+        attr_reader :barcode
+
+        # Creates a new ZintBox object with the given arguments.
+        #
+        # The argument +data+ needs to contain a hash with the arguments that are passed on to
+        # GraphicObject::Zint.
+        #
+        # Note: Although this box derives from ImageBox, the #image method will only return the
+        # correct object after #fit was called.
+        def initialize(data:, **kwargs)
+          super(image: nil, **kwargs)
+          @barcode = GraphicObject::Zint.configure(**data)
+        end
+
+        # Fits the barcode into the given area.
+        def fit(available_width, available_height, frame)
+          @image ||= @barcode.form_xobject(frame.document)
+          super
+        end
+
+      end
+
+    end
+  end
+end

data/lib/hexapdf/extras/layout.rb

@@ -5,6 +5,7 @@ module HexaPDF
     module Layout
       autoload(:QRCodeBox, 'hexapdf/extras/layout/qr_code_box')
       autoload(:SwissQRBill, 'hexapdf/extras/layout/swiss_qr_bill')
+      autoload(:ZintBox, 'hexapdf/extras/layout/zint_box')
     end
   end
 end

data/lib/hexapdf/extras/version.rb

@@ -2,6 +2,6 @@
 
 module HexaPDF
   module Extras
-    VERSION = '1.1.2'
+    VERSION = '1.2.0'
   end
 end

data/lib/hexapdf/extras.rb

@@ -11,10 +11,13 @@ end
 
 HexaPDF::DefaultDocumentConfiguration['graphic_object.map'][:qrcode] =
   'HexaPDF::Extras::GraphicObject::QRCode'
+HexaPDF::DefaultDocumentConfiguration['graphic_object.map'][:barcode] =
+  'HexaPDF::Extras::GraphicObject::Zint'
 
 HexaPDF::DefaultDocumentConfiguration['layout.boxes.map'][:qrcode] =
   'HexaPDF::Extras::Layout::QRCodeBox'
-
+HexaPDF::DefaultDocumentConfiguration['layout.boxes.map'][:barcode] =
+  'HexaPDF::Extras::Layout::ZintBox'
 HexaPDF::DefaultDocumentConfiguration['layout.boxes.map'][:swiss_qr_bill] =
   'HexaPDF::Extras::Layout::SwissQRBill'
 

data/test/hexapdf/extras/graphic_object/test_zint.rb

@@ -0,0 +1,152 @@
+require 'test_helper'
+require 'hexapdf'
+require 'hexapdf/extras/graphic_object/zint'
+
+describe HexaPDF::Extras::GraphicObject::Zint do
+  before do
+    @obj = HexaPDF::Extras::GraphicObject::Zint.new
+  end
+
+  it "allows creation via the ::configure method" do
+    obj = HexaPDF::Extras::GraphicObject::Zint.configure(value: 'test')
+    assert_equal('test', obj.zint_kws[:value])
+  end
+
+  it "creates a default drawing support object" do
+    assert_equal([0, 0], @obj.at)
+    assert_nil(@obj.width)
+    assert_nil(@obj.height)
+    assert_equal('Helvetica', @obj.font)
+    assert_equal({}, @obj.zint_kws)
+  end
+
+  it "allows configuration of the object" do
+    assert_same(@obj, @obj.configure(value: 'test', width: 30, symbology: :code128))
+    assert_equal('test', @obj.zint_kws[:value])
+    assert_equal(::Zint::BARCODE_CODE128, @obj.zint_kws[:symbology])
+    assert_equal(30, @obj.width)
+    @obj.configure(symbology: ::Zint::BARCODE_DATAMATRIX)
+    assert_equal(::Zint::BARCODE_DATAMATRIX, @obj.zint_kws[:symbology])
+  end
+
+  describe "draw" do
+    before do
+      doc = HexaPDF::Document.new
+      @canvas = doc.pages.add.canvas
+    end
+
+    it "draws a barcode onto the canvas" do
+      @obj.configure(value: 'test', width: 50, symbology: :code128)
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [0.316456, 0, 0, 0.316456, 0, 0]],
+                        [:paint_xobject, [:XO1]],
+                        [:restore_graphics_state]])
+      assert_operators(@canvas.context.resources.xobject(:XO1).contents,
+                       [[:set_device_rgb_non_stroking_color, [1.0, 1.0, 1.0]],
+                        [:append_rectangle, [0, 0, 158.0, 118.900002]],
+                        [:fill_path_non_zero],
+                        [:set_device_rgb_non_stroking_color, [0.0, 0.0, 0.0]],
+                        [:append_rectangle, [0.0, 118.900002, 4.0, -100.0]],
+                        [:append_rectangle, [6.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [12.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [22.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [28.0, 118.900002, 8.0, -100.0]],
+                        [:append_rectangle, [38.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [44.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [48.0, 118.900002, 4.0, -100.0]],
+                        [:append_rectangle, [56.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [66.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [70.0, 118.900002, 8.0, -100.0]],
+                        [:append_rectangle, [82.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [88.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [94.0, 118.900002, 8.0, -100.0]],
+                        [:append_rectangle, [104.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [110.0, 118.900002, 8.0, -100.0]],
+                        [:append_rectangle, [122.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [126.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [132.0, 118.900002, 4.0, -100.0]],
+                        [:append_rectangle, [142.0, 118.900002, 6.0, -100.0]],
+                        [:append_rectangle, [150.0, 118.900002, 2.0, -100.0]],
+                        [:append_rectangle, [154.0, 118.900002, 4.0, -100.0]],
+                        [:fill_path_non_zero],
+                        [:set_font_and_size, [:F1, 14.0]],
+                        [:set_device_gray_non_stroking_color, [0.0]],
+                        [:begin_text],
+                        [:set_text_matrix, [1, 0, 0, 1, 67.716, 3.5]],
+                        [:show_text, ["test"]],
+                        [:end_text]])
+    end
+
+    it "supports all string alignments" do
+      @obj.configure(value: '1123456', width: 50, symbology: :upce)
+      @obj.draw(@canvas)
+      assert_operators(@canvas.context.resources.xobject(:XO1).contents,
+                       [[:set_device_rgb_non_stroking_color, [1.0, 1.0, 1.0]],
+                        [:append_rectangle, [0, 0, 134.0, 116.400002]],
+                        [:fill_path_non_zero],
+                        [:set_device_rgb_non_stroking_color, [0.0, 0.0, 0.0]],
+                        [:append_rectangle, [18.0, 116.400002, 2.0, -110.0]],
+                        [:append_rectangle, [22.0, 116.400002, 2.0, -110.0]],
+                        [:append_rectangle, [28.0, 116.400002, 4.0, -100.0]],
+                        [:append_rectangle, [36.0, 116.400002, 2.0, -100.0]],
+                        [:append_rectangle, [42.0, 116.400002, 2.0, -100.0]],
+                        [:append_rectangle, [48.0, 116.400002, 4.0, -100.0]],
+                        [:append_rectangle, [54.0, 116.400002, 2.0, -100.0]],
+                        [:append_rectangle, [64.0, 116.400002, 2.0, -100.0]],
+                        [:append_rectangle, [70.0, 116.400002, 6.0, -100.0]],
+                        [:append_rectangle, [78.0, 116.400002, 2.0, -100.0]],
+                        [:append_rectangle, [82.0, 116.400002, 4.0, -100.0]],
+                        [:append_rectangle, [92.0, 116.400002, 2.0, -100.0]],
+                        [:append_rectangle, [102.0, 116.400002, 2.0, -100.0]],
+                        [:append_rectangle, [106.0, 116.400002, 2.0, -100.0]],
+                        [:append_rectangle, [110.0, 116.400002, 2.0, -110.0]],
+                        [:append_rectangle, [114.0, 116.400002, 2.0, -110.0]],
+                        [:append_rectangle, [118.0, 116.400002, 2.0, -110.0]],
+                        [:fill_path_non_zero],
+                        [:set_font_and_size, [:F1, 14.0]],
+                        [:set_device_gray_non_stroking_color, [0.0]],
+                        [:begin_text],
+                        [:set_text_matrix, [1, 0, 0, 1, 0.216, 0.400002]],
+                        [:show_text, ["1"]],
+                        [:set_font_and_size, [:F1, 20.0]],
+                        [:move_text, [32.424, 0]],
+                        [:show_text, ["123456"]],
+                        [:set_font_and_size, [:F1, 14.0]],
+                        [:move_text, [93.36, 0]],
+                        [:show_text, ["2"]],
+                        [:end_text]])
+    end
+
+    it "supports dotty mode" do
+      @obj.configure(value: 't', width: 50, symbology: :datamatrix, output_options: 0x0100)
+      @obj.draw(@canvas)
+      form_contents = @canvas.context.resources.xobject(:XO1).contents
+      assert_operators(form_contents,
+                       [[:set_device_rgb_non_stroking_color, [1.0, 1.0, 1.0]],
+                        [:append_rectangle, [0, 0, 20, 20]],
+                        [:fill_path_non_zero],
+                        [:set_device_rgb_non_stroking_color, [0.0, 0.0, 0.0]],
+                        [:move_to, [1.8, 19.0]],
+                        [:curve_to, [1.8, 19.285458, 1.647214, 19.550091, 1.4, 19.69282]],
+                        [:curve_to, [1.152786, 19.835549, 0.847214, 19.835549, 0.6, 19.69282]],
+                        [:curve_to, [0.352786, 19.550091, 0.2, 19.285458, 0.2, 19.0]],
+                        [:curve_to, [0.2, 18.714542, 0.352786, 18.449909, 0.6, 18.30718]],
+                        [:curve_to, [0.847214, 18.164451, 1.152786, 18.164451, 1.4, 18.30718]],
+                        [:curve_to, [1.647214, 18.449909, 1.8, 18.714542, 1.8, 19.0]],
+                        [:close_subpath],
+                        [:move_to, [5.8, 19]]], range: 0..12)
+      assert_operators(form_contents,
+                       [[:move_to, [19.8, 1.0]],
+                        [:curve_to, [19.8, 1.285458, 19.647214, 1.550091, 19.4, 1.69282]],
+                        [:curve_to, [19.152786, 1.835549, 18.847214, 1.835549, 18.6, 1.69282]],
+                        [:curve_to, [18.352786, 1.550091, 18.2, 1.285458, 18.2, 1.0]],
+                        [:curve_to, [18.2, 0.714542, 18.352786, 0.449909, 18.6, 0.30718]],
+                        [:curve_to, [18.847214, 0.164451, 19.152786, 0.164451, 19.4, 0.30718]],
+                        [:curve_to, [19.647214, 0.449909, 19.8, 0.714542, 19.8, 1.0]],
+                        [:close_subpath],
+                        [:fill_path_non_zero]], range: -9..-1)
+    end
+  end
+end

data/test/hexapdf/extras/layout/test_swiss_qr_bill.rb

@@ -3,7 +3,7 @@ require 'hexapdf'
 require 'hexapdf/extras'
 require 'hexapdf/extras/layout/swiss_qr_bill'
 
-using HexaPDF::Extras::Layout::NumericMeasurementHelper
+using HexaPDF::Utils
 
 describe HexaPDF::Extras::Layout::SwissQRBill do
   def create_box(data, **kwargs)

data/test/hexapdf/extras/layout/test_zint_box.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+require 'hexapdf'
+require 'hexapdf/extras/layout/zint_box'
+
+describe HexaPDF::Extras::Layout::ZintBox do
+  def create_box(**kwargs)
+    HexaPDF::Extras::Layout::ZintBox.new(**kwargs)
+  end
+
+  describe "initialize" do
+    it "takes the common box arguments" do
+      box = create_box(width: 10, height: 15, data: {})
+      assert_equal(10, box.width)
+      assert_equal(15, box.height)
+    end
+
+    it "creates the zint barcode graphic object" do
+      box = create_box(data: {value: 'test', symbology: :code128})
+      assert_equal({value: 'test', symbology: 20}, box.barcode.zint_kws)
+    end
+  end
+
+  describe "fit" do
+    it "creates the form xobject and uses that as image for its superclass" do
+      doc = HexaPDF::Document.new
+      frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100, context: doc.pages.add)
+
+      box = create_box(data: {value: 'test', symbology: :code128})
+      assert_nil(box.image)
+      box.fit(100, 100, frame)
+      assert_equal(:Form, box.image[:Subtype])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf-extras
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-20 00:00:00.000000000 Z
+date: 2024-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hexapdf
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.36'
+        version: '0.42'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.36'
+        version: '0.42'
 - !ruby/object:Gem::Dependency
   name: rqrcode_core
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: ruby-zint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description:
 email: t_leitner@gmx.at
 executables: []
@@ -51,13 +65,17 @@ files:
 - lib/hexapdf/extras.rb
 - lib/hexapdf/extras/graphic_object.rb
 - lib/hexapdf/extras/graphic_object/qr_code.rb
+- lib/hexapdf/extras/graphic_object/zint.rb
 - lib/hexapdf/extras/layout.rb
 - lib/hexapdf/extras/layout/qr_code_box.rb
 - lib/hexapdf/extras/layout/swiss_qr_bill.rb
+- lib/hexapdf/extras/layout/zint_box.rb
 - lib/hexapdf/extras/version.rb
 - test/hexapdf/extras/graphic_object/test_qr_code.rb
+- test/hexapdf/extras/graphic_object/test_zint.rb
 - test/hexapdf/extras/layout/test_qr_code_box.rb
 - test/hexapdf/extras/layout/test_swiss_qr_bill.rb
+- test/hexapdf/extras/layout/test_zint_box.rb
 - test/test_helper.rb
 homepage: https://hexapdf-extras.gettalong.org
 licenses:
@@ -71,7 +89,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="