hexapdf 0.35.0 → 0.36.0

data/lib/hexapdf/type/page.rb

@@ -62,41 +62,41 @@ module HexaPDF
       # * ISO sizes: A0x4, A0x2, A0-A10, B0-B10, C0-C10
       # * Letter, Legal, Ledger, Tabloid, Executive
       PAPER_SIZE = {
-        A0x4: [0, 0, 4768, 6741].freeze,
-        A0x2: [0, 0, 3370, 4768].freeze,
-        A0: [0, 0, 2384, 3370].freeze,
-        A1: [0, 0, 1684, 2384].freeze,
-        A2: [0, 0, 1191, 1684].freeze,
-        A3: [0, 0, 842, 1191].freeze,
-        A4: [0, 0, 595, 842].freeze,
-        A5: [0, 0, 420, 595].freeze,
-        A6: [0, 0, 298, 420].freeze,
-        A7: [0, 0, 210, 298].freeze,
-        A8: [0, 0, 147, 210].freeze,
-        A9: [0, 0, 105, 147].freeze,
-        A10: [0, 0, 74, 105].freeze,
-        B0: [0, 0, 2835, 4008].freeze,
-        B1: [0, 0, 2004, 2835].freeze,
-        B2: [0, 0, 1417, 2004].freeze,
-        B3: [0, 0, 1001, 1417].freeze,
-        B4: [0, 0, 709, 1001].freeze,
-        B5: [0, 0, 499, 709].freeze,
-        B6: [0, 0, 354, 499].freeze,
-        B7: [0, 0, 249, 354].freeze,
-        B8: [0, 0, 176, 249].freeze,
-        B9: [0, 0, 125, 176].freeze,
-        B10: [0, 0, 88, 125].freeze,
-        C0: [0, 0, 2599, 3677].freeze,
-        C1: [0, 0, 1837, 2599].freeze,
-        C2: [0, 0, 1298, 1837].freeze,
-        C3: [0, 0, 918, 1298].freeze,
-        C4: [0, 0, 649, 918].freeze,
-        C5: [0, 0, 459, 649].freeze,
-        C6: [0, 0, 323, 459].freeze,
-        C7: [0, 0, 230, 323].freeze,
-        C8: [0, 0, 162, 230].freeze,
-        C9: [0, 0, 113, 162].freeze,
-        C10: [0, 0, 79, 113].freeze,
+        A0x4: [0, 0, 4767.874016, 6740.787402].freeze,
+        A0x2: [0, 0, 3370.393701, 4767.874016].freeze,
+        A0: [0, 0, 2383.937008, 3370.393701].freeze,
+        A1: [0, 0, 1683.779528, 2383.937008].freeze,
+        A2: [0, 0, 1190.551181, 1683.779528].freeze,
+        A3: [0, 0, 841.889764, 1190.551181].freeze,
+        A4: [0, 0, 595.275591, 841.889764].freeze,
+        A5: [0, 0, 419.527559, 595.275591].freeze,
+        A6: [0, 0, 297.637795, 419.527559].freeze,
+        A7: [0, 0, 209.76378, 297.637795].freeze,
+        A8: [0, 0, 147.401575, 209.76378].freeze,
+        A9: [0, 0, 104.88189, 147.401575].freeze,
+        A10: [0, 0, 73.700787, 104.88189].freeze,
+        B0: [0, 0, 2834.645669, 4008.188976].freeze,
+        B1: [0, 0, 2004.094488, 2834.645669].freeze,
+        B2: [0, 0, 1417.322835, 2004.094488].freeze,
+        B3: [0, 0, 1000.629921, 1417.322835].freeze,
+        B4: [0, 0, 708.661417, 1000.629921].freeze,
+        B5: [0, 0, 498.897638, 708.661417].freeze,
+        B6: [0, 0, 354.330709, 498.897638].freeze,
+        B7: [0, 0, 249.448819, 354.330709].freeze,
+        B8: [0, 0, 175.748031, 249.448819].freeze,
+        B9: [0, 0, 124.724409, 175.748031].freeze,
+        B10: [0, 0, 87.874016, 124.724409].freeze,
+        C0: [0, 0, 2599.370079, 3676.535433].freeze,
+        C1: [0, 0, 1836.850394, 2599.370079].freeze,
+        C2: [0, 0, 1298.267717, 1836.850394].freeze,
+        C3: [0, 0, 918.425197, 1298.267717].freeze,
+        C4: [0, 0, 649.133858, 918.425197].freeze,
+        C5: [0, 0, 459.212598, 649.133858].freeze,
+        C6: [0, 0, 323.149606, 459.212598].freeze,
+        C7: [0, 0, 229.606299, 323.149606].freeze,
+        C8: [0, 0, 161.574803, 229.606299].freeze,
+        C9: [0, 0, 113.385827, 161.574803].freeze,
+        C10: [0, 0, 79.370079, 113.385827].freeze,
         Letter: [0, 0, 612, 792].freeze,
         Legal: [0, 0, 612, 1008].freeze,
         Ledger: [0, 0, 792, 1224].freeze,

data/lib/hexapdf/utils.rb

@@ -0,0 +1,66 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2023 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'geom2d/utils'
+
+module HexaPDF
+  module Utils
+
+    # The precision with which to compare floating point numbers.
+    #
+    # This is chosen with respect to precision that is used for serializing floating point numbers.
+    EPSILON = 1e-6
+
+    # Best effort of setting Geom2D's precision to the one used by HexaPDF.
+    ::Geom2D::Utils.precision = EPSILON
+
+    module_function
+
+    private
+
+    # Compares two floats whether they are equal using the FLOAT_EPSILON precision.
+    def float_equal(a, b)
+      (a - b).abs < EPSILON
+    end
+
+    # Compares two floats like the <=> operator but using the FLOAT_EPSILON precision for detecting
+    # whether they are equal.
+    def float_compare(a, b)
+      (a - b).abs < EPSILON ? 0 : a <=> b
+    end
+
+  end
+end

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.35.0'
+  VERSION = '0.36.0'
 
 end

data/test/hexapdf/content/test_canvas_composer.rb

@@ -39,7 +39,7 @@ describe HexaPDF::Content::CanvasComposer do
       @composer.draw_box(create_box)
       assert_operators(@composer.canvas.contents,
                        [[:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 0, 742]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 741.889764]],
                         [:restore_graphics_state],
                         [:save_graphics_state],
                         [:concatenate_matrix, [1, 0, 0, 1, 0, 0]],
@@ -58,10 +58,10 @@ describe HexaPDF::Content::CanvasComposer do
                         [:concatenate_matrix, [1, 0, 0, 1, 0, 0]],
                         [:restore_graphics_state],
                         [:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 400, 742]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 400, 741.889764]],
                         [:restore_graphics_state],
                         [:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 400, 642]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 400, 641.889764]],
                         [:restore_graphics_state]])
     end
 
@@ -70,10 +70,10 @@ describe HexaPDF::Content::CanvasComposer do
       @composer.draw_box(create_box(width: 400, height: 100))
       assert_operators(@composer.canvas.contents,
                        [[:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 0, 742]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 741.889764]],
                         [:restore_graphics_state],
                         [:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 0, 642]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 0, 641.889764]],
                         [:restore_graphics_state]])
     end
 

data/test/hexapdf/document/test_layout.rb

@@ -175,6 +175,12 @@ describe HexaPDF::Document::Layout do
       assert_equal(2, box.children.size)
     end
 
+    it "uses the provided block as drawing block for the base box class if name=:base" do
+      block = proc {}
+      box = @layout.box(width: 100, &block)
+      assert_equal(block, box.instance_variable_get(:@draw_block))
+    end
+
     it "fails if the name is not registered" do
       assert_raises(HexaPDF::Error) { @layout.box(:unknown) }
     end

data/test/hexapdf/document/test_pages.rb

@@ -17,20 +17,20 @@ describe HexaPDF::Document::Pages do
   describe "create" do
     it "uses the defaults from the configuration for missing arguments" do
       page = @doc.pages.create
-      assert_equal([0, 0, 595, 842], page.box(:media).value)
+      assert_equal([0, 0, 595.275591, 841.889764], page.box(:media).value)
     end
 
     it "allows specifying a reference to a predefined page size" do
       page = @doc.pages.create(media_box: :A3)
-      assert_equal([0, 0, 842, 1191], page.box(:media).value)
+      assert_equal([0, 0, 841.889764, 1190.551181], page.box(:media).value)
     end
 
     it "allows specifying the orientation for a predefined page size" do
       page = @doc.pages.create(media_box: :A4, orientation: :landscape)
-      assert_equal([0, 0, 842, 595], page.box(:media).value)
+      assert_equal([0, 0, 841.889764, 595.275591], page.box(:media).value)
 
       page = @doc.pages.create(orientation: :landscape)
-      assert_equal([0, 0, 842, 595], page.box(:media).value)
+      assert_equal([0, 0, 841.889764, 595.275591], page.box(:media).value)
     end
 
     it "allows using a media box array" do
@@ -54,7 +54,7 @@ describe HexaPDF::Document::Pages do
     it "adds a new empty page with the given page format" do
       page = @doc.pages.add(:A4, orientation: :landscape)
       assert_same(page, @doc.pages[0])
-      assert_equal([0, 0, 842, 595], @doc.pages[0].box(:media).value)
+      assert_equal([0, 0, 841.889764, 595.275591], @doc.pages[0].box(:media).value)
     end
 
     it "adds the given page to the end" do

data/test/hexapdf/layout/test_box.rb

@@ -5,6 +5,12 @@ require 'hexapdf/document'
 require 'hexapdf/layout/box'
 
 describe HexaPDF::Layout::Box do
+  before do
+    @frame = Object.new
+    def @frame.x; 0; end
+    def @frame.y; 100; end
+  end
+
   def create_box(**args, &block)
     HexaPDF::Layout::Box.new(**args, &block)
   end
@@ -70,15 +76,13 @@ describe HexaPDF::Layout::Box do
   end
 
   describe "fit" do
-    before do
-      @frame = Object.new
-    end
-
     it "fits a fixed sized box" do
-      box = create_box(width: 50, height: 50)
+      box = create_box(width: 50, height: 50, style: {padding: 5})
       assert(box.fit(100, 100, @frame))
       assert_equal(50, box.width)
       assert_equal(50, box.height)
+      assert_equal(5, box.instance_variable_get(:@fit_x))
+      assert_equal(55, box.instance_variable_get(:@fit_y))
     end
 
     it "uses the maximum available width" do
@@ -95,53 +99,82 @@ describe HexaPDF::Layout::Box do
       assert_equal(100, box.height)
     end
 
+    it "uses float comparison" do
+      box = create_box(width: 50.0000002, height: 49.9999996)
+      assert(box.fit(50, 50, @frame))
+      assert_equal(50.0000002, box.width)
+      assert_equal(49.9999996, box.height)
+    end
+
     it "returns false if the box doesn't fit" do
       box = create_box(width: 101)
       refute(box.fit(100, 100, @frame))
     end
+
+    it "can use the #content_width/#content_height helper methods" do
+      box = create_box
+      box.define_singleton_method(:fit_content) do |aw, ah, frame|
+        update_content_width { 10 }
+        update_content_height { 20 }
+        true
+      end
+      assert(box.fit(100, 100, @frame))
+      assert_equal(10, box.width)
+      assert_equal(20, box.height)
+
+      box = create_box(width: 30, height: 50)
+      box.define_singleton_method(:fit_content) do |aw, ah, frame|
+        update_content_width { 10 }
+        update_content_height { 20 }
+        true
+      end
+      assert(box.fit(100, 100, @frame))
+      assert_equal(30, box.width)
+      assert_equal(50, box.height)
+    end
   end
 
   describe "split" do
     before do
       @box = create_box(width: 100, height: 100)
-      @box.fit(100, 100, nil)
+      @box.fit(100, 100, @frame)
     end
 
     it "doesn't need to be split if it completely fits" do
-      assert_equal([@box, nil], @box.split(100, 100, nil))
+      assert_equal([@box, nil], @box.split(100, 100, @frame))
     end
 
     it "can't be split if it doesn't (completely) fit and its width is greater than the available width" do
       @box.fit(90, 100, nil)
-      assert_equal([nil, @box], @box.split(50, 150, nil))
+      assert_equal([nil, @box], @box.split(50, 150, @frame))
     end
 
     it "can't be split if it doesn't (completely) fit and its height is greater than the available height" do
       @box.fit(90, 100, nil)
-      assert_equal([nil, @box], @box.split(150, 50, nil))
+      assert_equal([nil, @box], @box.split(150, 50, @frame))
     end
 
     it "can't be split if it doesn't (completely) fit and its content width is zero" do
       box = create_box(width: 0, height: 100)
-      assert_equal([nil, box], box.split(150, 150, nil))
+      assert_equal([nil, box], box.split(150, 150, @frame))
     end
 
     it "can't be split if it doesn't (completely) fit and its content height is zero" do
       box = create_box(width: 100, height: 0)
-      assert_equal([nil, box], box.split(150, 150, nil))
+      assert_equal([nil, box], box.split(150, 150, @frame))
     end
 
     it "can't be split if it doesn't (completely) fit as the default implementation " \
       "knows nothing about the content" do
       @box.style.position = :flow # make sure we would generally be splitable
       @box.fit(90, 100, nil)
-      assert_equal([nil, @box], @box.split(150, 150, nil))
+      assert_equal([nil, @box], @box.split(150, 150, @frame))
     end
   end
 
   it "can create a cloned box for splitting" do
     box = create_box
-    box.fit(100, 100, nil)
+    box.fit(100, 100, @frame)
     cloned_box = box.send(:create_split_box)
     assert(cloned_box.split_box?)
     refute(cloned_box.instance_variable_get(:@fit_successful))

data/test/hexapdf/layout/test_column_box.rb

@@ -192,19 +192,19 @@ describe HexaPDF::Layout::ColumnBox do
     end
 
     it "takes a different final location into account" do
-      box = create_box(children: @fixed_size_boxes[0, 2])
+      box = create_box(children: @fixed_size_boxes[0, 2], style: {padding: [2, 4, 6, 8]})
       box.fit(100, 100, @frame)
       box.draw(@canvas, 20, 10)
       operators = [
         [:save_graphics_state],
-        [:concatenate_matrix, [1, 0, 0, 1, 20, -80]],
+        [:concatenate_matrix, [1, 0, 0, 1, 20, -72]],
         [:save_graphics_state],
-        [:concatenate_matrix, [1, 0, 0, 1, 0, 90]],
+        [:concatenate_matrix, [1, 0, 0, 1, 8, 88]],
         [:move_to, [0, 0]],
         [:end_path],
         [:restore_graphics_state],
         [:save_graphics_state],
-        [:concatenate_matrix, [1, 0, 0, 1, 55, 90]],
+        [:concatenate_matrix, [1, 0, 0, 1, 57, 88]],
         [:move_to, [0, 0]],
         [:end_path],
         [:restore_graphics_state],

data/test/hexapdf/layout/test_container_box.rb

@@ -0,0 +1,84 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/layout/container_box'
+
+describe HexaPDF::Layout::ContainerBox do
+  before do
+    @doc = HexaPDF::Document.new
+    @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
+  end
+
+  def create_box(children, **kwargs)
+    HexaPDF::Layout::ContainerBox.new(children: Array(children), **kwargs)
+  end
+
+  def check_box(box, width, height, fit_pos = nil)
+    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box didn't fit")
+    assert_equal(width, box.width, "box width")
+    assert_equal(height, box.height, "box height")
+    if fit_pos
+      box_fitter = box.instance_variable_get(:@box_fitter)
+      assert_equal(fit_pos.size, box_fitter.fit_results.size)
+      fit_pos.each_with_index do |(x, y), index|
+        assert_equal(x, box_fitter.fit_results[index].x, "result[#{index}].x")
+        assert_equal(y, box_fitter.fit_results[index].y, "result[#{index}].y")
+      end
+    end
+  end
+
+  describe "empty?" do
+    it "is empty if nothing is fit yet" do
+      assert(create_box([]).empty?)
+    end
+
+    it "is empty if no box fits" do
+      box = create_box(@doc.layout.box(width: 110))
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.empty?)
+    end
+
+    it "is not empty if at least one box fits" do
+      box = create_box(@doc.layout.box(width: 50, height: 20))
+      check_box(box, 100, 20)
+      refute(box.empty?)
+    end
+  end
+
+  describe "fit_content" do
+    it "fits the children according to their mask_mode, valign, and align style properties" do
+      box = create_box([@doc.layout.box(height: 20),
+                        @doc.layout.box(height: 20, style: {valign: :bottom, mask_mode: :fill_horizontal}),
+                        @doc.layout.box(width: 20, style: {align: :right, mask_mode: :fill_vertical})])
+      check_box(box, 100, 100, [[0, 80], [0, 0], [80, 20]])
+    end
+
+    it "respects the initially set width/height as well as border/padding" do
+      box = create_box(@doc.layout.box(height: 20), height: 50, width: 40,
+                       style: {padding: 2, border: {width: 3}})
+      check_box(box, 40, 50, [[5, 75]])
+    end
+  end
+
+  describe "draw_content" do
+    before do
+      @canvas = @doc.pages.add.canvas
+    end
+
+    it "draws the result onto the canvas" do
+      child_box = @doc.layout.box(height: 20) do |canvas, b|
+        canvas.line(0, 0, b.content_width, b.content_height).end_path
+      end
+      box = create_box(child_box)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 50)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:concatenate_matrix, [1, 0, 0, 1, 0, 50]],
+                                          [:move_to, [0, 0]],
+                                          [:line_to, [100, 20]],
+                                          [:end_path],
+                                          [:restore_graphics_state]])
+    end
+  end
+end

data/test/hexapdf/layout/test_frame.rb

@@ -13,10 +13,11 @@ describe HexaPDF::Layout::Frame::FitResult do
     result = HexaPDF::Layout::Frame::FitResult.new(box)
     result.mask = Geom2D::Rectangle(0, 0, 20, 20)
     result.x = result.y = 0
-    result.draw(canvas)
+    result.draw(canvas, dx: 10, dy: 15)
     assert_equal(<<~CONTENTS, canvas.contents)
       /OC /P1 BDC
       q
+      1 0 0 1 10 15 cm
       0.0 0.501961 0.0 rg
       0.0 0.392157 0.0 RG
       /GS1 gs
@@ -25,7 +26,7 @@ describe HexaPDF::Layout::Frame::FitResult do
       Q
       EMC
       q
-      1 0 0 1 0 0 cm
+      1 0 0 1 10 15 cm
       Q
     CONTENTS
     ocg = doc.optional_content.ocgs.first

data/test/hexapdf/layout/test_page_style.rb

@@ -35,7 +35,7 @@ describe HexaPDF::Layout::PageStyle do
         istyle.next_style = :other
       end
       page = style.create_page(@doc)
-      assert_equal([0, 0, 595, 842], page.box(:media))
+      assert_equal([0, 0, 595.275591, 841.889764], page.box(:media))
       assert_equal("0 0 10 10 re\nS\n", page.contents)
       assert_equal(:frame, style.frame)
       assert_equal(:other, style.next_style)
@@ -54,8 +54,8 @@ describe HexaPDF::Layout::PageStyle do
       assert_kind_of(HexaPDF::Layout::Frame, style.frame)
       assert_equal(36, style.frame.left)
       assert_equal(36, style.frame.bottom)
-      assert_equal(523, style.frame.width)
-      assert_equal(770, style.frame.height)
+      assert_equal(523.275591, style.frame.width)
+      assert_equal(769.889764, style.frame.height)
     end
   end
 
@@ -65,7 +65,7 @@ describe HexaPDF::Layout::PageStyle do
     frame = style.create_frame(style.create_page(doc), [15, 10])
     assert_equal(10, frame.left)
     assert_equal(15, frame.bottom)
-    assert_equal(575, frame.width)
-    assert_equal(812, frame.height)
+    assert_equal(575.275591, frame.width)
+    assert_equal(811.889764, frame.height)
   end
 end

data/test/hexapdf/test_composer.rb

@@ -16,8 +16,8 @@ describe HexaPDF::Composer do
       assert_kind_of(HexaPDF::Type::Page, @composer.page)
       assert_equal(36, @composer.frame.left)
       assert_equal(36, @composer.frame.bottom)
-      assert_equal(523, @composer.frame.width)
-      assert_equal(770, @composer.frame.height)
+      assert_equal(523.275591, @composer.frame.width)
+      assert_equal(769.889764, @composer.frame.height)
       assert_kind_of(HexaPDF::Layout::Style, @composer.style(:base))
     end
 
@@ -28,15 +28,15 @@ describe HexaPDF::Composer do
 
     it "allows the customization of the page orientation" do
       composer = HexaPDF::Composer.new(page_orientation: :landscape)
-      assert_equal([0, 0, 842, 595], composer.page.box.value)
+      assert_equal([0, 0, 841.889764, 595.275591], composer.page.box.value)
     end
 
     it "allows the customization of the margin" do
       composer = HexaPDF::Composer.new(margin: [100, 80, 60, 40])
       assert_equal(40, composer.frame.left)
       assert_equal(60, composer.frame.bottom)
-      assert_equal(475, composer.frame.width)
-      assert_equal(682, composer.frame.height)
+      assert_in_delta(475.275591, composer.frame.width)
+      assert_equal(681.889764, composer.frame.height)
     end
 
     it "allows skipping the initial page creation" do
@@ -107,7 +107,7 @@ describe HexaPDF::Composer do
   end
 
   it "returns the current y-position" do
-    assert_equal(806, @composer.y)
+    assert_equal(805.889764, @composer.y)
   end
 
   describe "style" do
@@ -203,7 +203,7 @@ describe HexaPDF::Composer do
       @composer.draw_box(create_box)
       assert_operators(@composer.canvas.contents,
                        [[:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 36, 706]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 705.889764]],
                         [:restore_graphics_state],
                         [:save_graphics_state],
                         [:concatenate_matrix, [1, 0, 0, 1, 36, 36]],
@@ -232,14 +232,14 @@ describe HexaPDF::Composer do
       @composer.draw_box(box)
       assert_operators(first_page_contents,
                        [[:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 36, 406]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 405.889764]],
                         [:restore_graphics_state],
                         [:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 36, 6]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 5.889764]],
                         [:restore_graphics_state]])
       assert_operators(@composer.canvas.contents,
                        [[:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 36, 706]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 705.889764]],
                         [:restore_graphics_state]])
     end
 
@@ -252,14 +252,14 @@ describe HexaPDF::Composer do
       @composer.draw_box(box)
       assert_operators(first_page_contents,
                        [[:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 36, 406]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 405.889764]],
                         [:restore_graphics_state],
                         [:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 36, 306]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 305.889764]],
                         [:restore_graphics_state]])
       assert_operators(@composer.canvas.contents,
                        [[:save_graphics_state],
-                        [:concatenate_matrix, [1, 0, 0, 1, 36, 406]],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 405.889764]],
                         [:restore_graphics_state]])
     end
 

data/test/hexapdf/test_utils.rb

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/utils.rb'
+
+describe HexaPDF::Utils do
+  include HexaPDF::Utils
+
+  it "checks floats for equality with a certain precision" do
+    assert(float_equal(1.0, 1))
+    assert(float_equal(1.0, 1.0000003))
+  end
+
+  it "compares floats like the <=> operator" do
+    assert_equal(0, float_compare(1.0, 1))
+    assert_equal(0, float_compare(1.0, 1.0000003))
+    assert_equal(-1, float_compare(1.0, 1.03))
+    assert_equal(1, float_compare(1.0, 0.9997))
+  end
+end

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.35.0)>>
+      <</Producer(HexaPDF version 0.36.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.35.0)>>
+      <</Producer(HexaPDF version 0.36.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -214,7 +214,7 @@ describe HexaPDF::Writer do
       <</Type/Page/MediaBox[0 0 595 842]/Parent 2 0 R/Resources<<>>>>
       endobj
       5 0 obj
-      <</Producer(HexaPDF version 0.35.0)>>
+      <</Producer(HexaPDF version 0.35.1)>>
       endobj
       4 0 obj
       <</Root 1 0 R/Info 5 0 R/Size 6/Type/XRef/W[1 1 2]/Index[0 6]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 33>>stream