hexapdf 0.8.0 → 0.9.0

data/test/hexapdf/layout/test_inline_box.rb

@@ -60,4 +60,12 @@ describe HexaPDF::Layout::InlineBox do
   it "returns width for x_max" do
     assert_equal(@box.width, @box.x_max)
   end
+
+  it "returns 0 for y_min" do
+    assert_equal(0, @box.y_min)
+  end
+
+  it "returns height for y_max" do
+    assert_equal(@box.height, @box.y_max)
+  end
 end

data/test/hexapdf/layout/test_line.rb

@@ -12,7 +12,7 @@ describe HexaPDF::Layout::Line::HeightCalculator do
     @calc << HexaPDF::Layout::InlineBox.create(width: 10, height: 20, valign: :baseline) {}
     assert_equal([0, 20, 0, 0], @calc.result)
     new_item = HexaPDF::Layout::InlineBox.create(width: 10, height: 30, valign: :top) {}
-    assert_equal(30, @calc.simulate_height(new_item))
+    assert_equal([-10, 20, 30], @calc.simulate_height(new_item))
     assert_equal([0, 20, 0, 0], @calc.result)
   end
 end

data/test/hexapdf/layout/test_style.rb

@@ -18,7 +18,7 @@ describe HexaPDF::Layout::Style::LineSpacing do
   end
 
   def line_spacing(type, value = nil)
-    HexaPDF::Layout::Style::LineSpacing.new(type, value: value)
+    HexaPDF::Layout::Style::LineSpacing.new(type: type, value: value)
   end
 
   it "allows single line spacing" do
@@ -147,6 +147,17 @@ describe HexaPDF::Layout::Style::Border do
     assert_kind_of(HexaPDF::Layout::Style::Quad, border.style)
   end
 
+  it "can be duplicated" do
+    border = create_border
+    copy = border.dup
+    border.width.top = 10
+    border.color.top = :red
+    border.style.top = :dotted
+    assert_equal(0, copy.width.top)
+    assert_equal(0, copy.color.top)
+    assert_equal(:solid, copy.style.top)
+  end
+
   it "can be asked whether a border is defined" do
     assert(create_border.none?)
     refute(create_border(width: 5).none?)
@@ -436,6 +447,12 @@ describe HexaPDF::Layout::Style::Layers do
     assert_equal(data, layers.enum_for(:each, {}).to_a)
   end
 
+  it "can be duplicated" do
+    copy = @layers.dup
+    @layers.add(lambda {})
+    assert(copy.none?)
+  end
+
   describe "add and each" do
     it "can use a given block" do
       block = proc { true }
@@ -577,6 +594,45 @@ describe HexaPDF::Layout::Style do
     assert_equal(10, style.font_size)
   end
 
+  describe "initialize_copy" do
+    it "can be duplicated" do
+      @style.font_features[:kerning] = true
+      @style.padding.top = 10
+      @style.margin.top = 10
+      @style.border.width.top = 10
+      @style.overlays.add(lambda {})
+      @style.underlays.add(lambda {})
+
+      copy = @style.dup
+      @style.font_features[:kerning] = false
+      @style.padding.top = 5
+      @style.margin.top = 5
+      @style.border.width.top = 5
+      @style.overlays.add(lambda {})
+      @style.underlays.add(lambda {})
+
+      assert_equal({kerning: true}, copy.font_features)
+      assert_equal(10, copy.padding.top)
+      assert_equal(10, copy.margin.top)
+      assert_equal(10, copy.border.width.top)
+      assert_equal(1, copy.underlays.instance_variable_get(:@layers).size)
+      assert_equal(1, copy.overlays.instance_variable_get(:@layers).size)
+    end
+
+    it "resets the cache" do
+      @style.horizontal_scaling(200)
+      assert_equal(2.0, @style.scaled_horizontal_scaling)
+      assert_equal(-1.06, @style.scaled_item_width(53))
+
+      style = @style.dup
+      style.horizontal_scaling(100)
+      assert_equal(2.0, @style.scaled_horizontal_scaling)
+      assert_equal(-1.06, @style.scaled_item_width(53))
+      assert_equal(1.0, style.scaled_horizontal_scaling)
+      assert_equal(-0.53, style.scaled_item_width(53))
+    end
+  end
+
   it "has several simple and dynamically generated properties with default values" do
     assert_raises(HexaPDF::Error) { @style.font }
     assert_equal(10, @style.font_size)
@@ -607,6 +663,7 @@ describe HexaPDF::Layout::Style do
     assert_equal([:proportional, 1], [@style.line_spacing.type, @style.line_spacing.value])
     refute(@style.subscript)
     refute(@style.superscript)
+    refute(@style.last_line_gap)
     assert_kind_of(HexaPDF::Layout::Style::Layers, @style.underlays)
     assert_kind_of(HexaPDF::Layout::Style::Layers, @style.overlays)
   end

data/test/hexapdf/layout/test_text_box.rb

@@ -8,6 +8,7 @@ require 'hexapdf/layout/text_box'
 describe HexaPDF::Layout::TextBox do
   before do
     @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
+    @inline_box = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) {}
   end
 
   def create_box(items, **kwargs)
@@ -22,15 +23,19 @@ describe HexaPDF::Layout::TextBox do
   end
 
   describe "fit" do
-    before do
-      @inline_box = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) {}
+    it "fits into a rectangular area" do
+      box = create_box([@inline_box] * 5, style: {padding: 10})
+      assert(box.fit(100, 100, @frame))
+      assert_equal(70, box.width)
+      assert_equal(30, box.height)
     end
 
-    it "fits into a rectangular area" do
-      box = create_box([@inline_box] * 5)
+    it "respects the set width and height" do
+      box = create_box([@inline_box] * 5, width: 40, height: 50, style: {padding: 10})
       assert(box.fit(100, 100, @frame))
-      assert_equal(50, box.width)
-      assert_equal(10, box.height)
+      assert_equal(40, box.width)
+      assert_equal(50, box.height)
+      assert_equal([20, 20, 10], box.instance_variable_get(:@result).lines.map(&:width))
     end
 
     it "fits into the frame's outline" do
@@ -40,30 +45,59 @@ describe HexaPDF::Layout::TextBox do
       assert_equal(100, box.width)
       assert_equal(20, box.height)
     end
+
+    it "takes the style option last_line_gap into account" do
+      box = create_box([@inline_box] * 5, style: {last_line_gap: true, line_spacing: :double})
+      assert(box.fit(100, 100, @frame))
+      assert_equal(50, box.width)
+      assert_equal(20, box.height)
+    end
+  end
+
+  describe "split" do
+    it "works for an empty text box" do
+      box = create_box([])
+      assert_equal([box], box.split(100, 100, @frame))
+    end
+
+    it "doesn't need to split the box if it completely fits" do
+      box = create_box([@inline_box] * 5)
+      assert_equal([box], box.split(50, 100, @frame))
+    end
+
+    it "works if no item of the text box fits" do
+      box = create_box([@inline_box])
+      assert_equal([nil, box], box.split(5, 20, @frame))
+    end
+
+    it "splits the box if necessary" do
+      box = create_box([@inline_box] * 10)
+      boxes = box.split(50, 10, @frame)
+      assert_equal(2, boxes.length)
+      assert_equal(box, boxes[0])
+      assert_equal(5, boxes[1].instance_variable_get(:@items).length)
+    end
   end
 
   describe "draw" do
     it "draws the layed out inline items onto the canvas" do
       inline_box = HexaPDF::Layout::InlineBox.create(width: 10, height: 10,
                                                      border: {width: 1})
-      box = create_box([inline_box], width: 100, height: 10)
+      box = create_box([inline_box], width: 100, height: 30, style: {padding: [10, 5]})
       box.fit(100, 100, nil)
 
       @canvas = HexaPDF::Document.new.pages.add.canvas
       box.draw(@canvas, 0, 0)
       assert_operators(@canvas.contents, [[:save_graphics_state],
-                                          [:concatenate_matrix, [1, 0, 0, 1, 0, 0]],
-                                          [:save_graphics_state],
                                           [:restore_graphics_state],
                                           [:save_graphics_state],
-                                          [:append_rectangle, [0, 0, 10, 10]],
+                                          [:append_rectangle, [5, 10, 10, 10]],
                                           [:clip_path_non_zero],
                                           [:end_path],
-                                          [:append_rectangle, [0.5, 0.5, 9, 9]],
+                                          [:append_rectangle, [5.5, 10.5, 9, 9]],
                                           [:stroke_path],
                                           [:restore_graphics_state],
                                           [:save_graphics_state],
-                                          [:restore_graphics_state],
                                           [:restore_graphics_state]])
     end
 
@@ -74,4 +108,15 @@ describe HexaPDF::Layout::TextBox do
       assert_operators(@canvas.contents, [])
     end
   end
+
+  it "is empty if there is a result without any text lines" do
+    box = create_box([])
+    assert(box.empty?)
+    box.fit(100, 100, @frame)
+    assert(box.empty?)
+
+    box = create_box([@inline_box])
+    box.fit(100, 100, @frame)
+    refute(box.empty?)
+  end
 end

data/test/hexapdf/layout/test_text_layouter.rb

@@ -308,8 +308,8 @@ describe HexaPDF::Layout::TextLayouter::SimpleLineWrapping do
 
     it "handles changing widths" do
       height = 0
-      width_block = lambda do |line_height|
-        case height + line_height
+      width_block = lambda do |line|
+        case height + line.height
         when 0..10 then 60
         when 11..20 then 40
         when 21..30 then 20
@@ -331,8 +331,8 @@ describe HexaPDF::Layout::TextLayouter::SimpleLineWrapping do
 
     it "handles changing widths when breaking on a penalty" do
       height = 0
-      width_block = lambda do |line_height|
-        case height + line_height
+      width_block = lambda do |line|
+        case height + line.height
         when 0..10 then 80
         else 50
         end
@@ -419,6 +419,16 @@ describe HexaPDF::Layout::TextLayouter do
       assert_equal(20 * (5 + 4), result.height)
     end
 
+    it "takes line spacing into account with variable width" do
+      @style.line_spacing = :double
+      width_block = lambda {|l, h| l + h <= 90 ? 40 : 20 }
+      result = @layouter.fit(boxes(*([[20, 20]] * 6)), width_block, 170)
+      assert(result.remaining_items.empty?)
+      assert_equal(:success, result.status)
+      assert_line_wrapping([[], result.lines], [40, 40, 20, 20])
+      assert_equal(140, result.height)
+    end
+
     it "handles empty lines" do
       items = boxes([20, 20]) + [penalty(-5000)] + boxes([30, 20]) + [penalty(-5000)] * 2 +
         boxes([20, 20]) + [penalty(-5000)] * 2

data/test/hexapdf/task/test_optimize.rb

@@ -32,11 +32,11 @@ describe HexaPDF::Task::Optimize do
   end
 
   def assert_no_objstms
-    assert(@doc.each(current: false).all? {|obj| obj.type != :ObjStm })
+    assert(@doc.each(only_current: false).all? {|obj| obj.type != :ObjStm })
   end
 
   def assert_no_xrefstms
-    assert(@doc.each(current: false).all? {|obj| obj.type != :XRef })
+    assert(@doc.each(only_current: false).all? {|obj| obj.type != :XRef })
   end
 
   def assert_default_deleted
@@ -47,7 +47,7 @@ describe HexaPDF::Task::Optimize do
     it "compacts the document" do
       @doc.task(:optimize, compact: true)
       assert_equal(1, @doc.revisions.size)
-      assert_equal(2, @doc.each(current: false).to_a.size)
+      assert_equal(2, @doc.each(only_current: false).to_a.size)
       refute_equal(@obj2, @doc.object(@obj2))
       refute_equal(@obj3, @doc.object(@obj3))
       assert_default_deleted

data/test/hexapdf/test_composer.rb

@@ -0,0 +1,258 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'content/common'
+require 'hexapdf/document'
+require 'hexapdf/composer'
+require 'stringio'
+
+describe HexaPDF::Composer do
+  before do
+    @composer = HexaPDF::Composer.new
+  end
+
+  describe "initialize" do
+    it "creates a composer object with default values" do
+      assert_kind_of(HexaPDF::Document, @composer.document)
+      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("Times", @composer.base_style.font)
+    end
+
+    it "allows the customization of the page size" do
+      composer = HexaPDF::Composer.new(page_size: [0, 0, 100, 100])
+      assert_equal([0, 0, 100, 100], composer.page.box.value)
+    end
+
+    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)
+    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)
+    end
+
+    it "yields itself" do
+      yielded = nil
+      composer = HexaPDF::Composer.new {|c| yielded = c }
+      assert_same(composer, yielded)
+    end
+  end
+
+  describe "::create" do
+    it "creates, yields, and writes a document" do
+      io = StringIO.new
+      HexaPDF::Composer.create(io, &:new_page)
+      io.rewind
+      assert_equal(2, HexaPDF::Document.new(io: io).pages.count)
+    end
+  end
+
+  describe "new_page" do
+    it "creates a new page with the stored information" do
+      c = HexaPDF::Composer.new(page_size: [0, 0, 50, 100], margin: 10)
+      c.new_page
+      assert_equal([0, 0, 50, 100], c.page.box.value)
+      assert_equal(10, c.frame.left)
+      assert_equal(10, c.frame.bottom)
+    end
+
+    it "uses the provided information for the new and all following pages" do
+      @composer.new_page(page_size: [0, 0, 50, 100], margin: 10)
+      assert_equal([0, 0, 50, 100], @composer.page.box.value)
+      assert_equal(10, @composer.frame.left)
+      assert_equal(10, @composer.frame.bottom)
+      @composer.new_page
+      assert_same(@composer.document.pages[2], @composer.page)
+      assert_equal([0, 0, 50, 100], @composer.page.box.value)
+      assert_equal(10, @composer.frame.left)
+      assert_equal(10, @composer.frame.bottom)
+    end
+  end
+
+  it "returns the current x-position" do
+    assert_equal(36, @composer.x)
+  end
+
+  it "returns the current y-position" do
+    assert_equal(806, @composer.y)
+  end
+
+  describe "text" do
+    it "creates a text box and draws it on the canvas" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.text("Test", width: 10, height: 15)
+      assert_equal(10, box.width)
+      assert_equal(15, box.height)
+      assert_same(@composer.document.fonts.add("Times"), box.style.font)
+      items = box.instance_variable_get(:@items)
+      assert_equal(1, items.length)
+      assert_same(box.style, items.first.style)
+    end
+
+    it "allows setting of a custom style" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.text("Test", style: HexaPDF::Layout::Style.new(font_size: 20))
+      assert_same(@composer.document.fonts.add("Times"), box.style.font)
+      assert_equal(20, box.style.font_size)
+    end
+
+    it "updates the used style with the provided options" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.text("Test", style: HexaPDF::Layout::Style.new, font_size: 20)
+      assert_equal(20, box.style.font_size)
+    end
+  end
+
+  describe "formatted_text" do
+    it "creates a text box with the formatted text and draws it on the canvas" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.formatted_text(["Test"], width: 10, height: 15)
+      assert_equal(10, box.width)
+      assert_equal(15, box.height)
+      assert_equal(1, box.instance_variable_get(:@items).length)
+    end
+
+    it "a hash can be used for custom style properties" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.formatted_text([{text: "Test", font_size: 20}], align: :center)
+      items = box.instance_variable_get(:@items)
+      assert_equal(1, items.length)
+      assert_equal(20, items.first.style.font_size)
+      assert_equal(:center, items.first.style.align)
+      assert_equal(10, box.style.font_size)
+    end
+
+    it "a hash can be used to provide a custom style" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.formatted_text([{text: "Test", style: HexaPDF::Layout::Style.new(fill_color: 128),
+                                 font_size: 20}], align: :center)
+      items = box.instance_variable_get(:@items)
+      assert_equal(20, items.first.style.font_size)
+      assert_equal(128, items.first.style.fill_color)
+      assert_equal(:center, items.first.style.align)
+    end
+
+    it "a hash can be used to link to an URL" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+
+      @composer.formatted_text([{text: "Test", link: "URI"}, {link: "URI"}])
+      items = box.instance_variable_get(:@items)
+      assert_equal(2, items.length)
+      assert_equal(4, items[0].items.length)
+      assert_equal(3, items[1].items.length)
+      assert_equal([:link, {uri: 'URI'}], items[0].style.overlays.instance_variable_get(:@layers)[0])
+    end
+  end
+
+  describe "image" do
+    it "creates an image box and draws it on the canvas" do
+      box = nil
+      @composer.define_singleton_method(:draw_box) {|arg| box = arg }
+      image_path = File.join(TEST_DATA_DIR, 'images', 'gray.jpg')
+
+      @composer.image(image_path, width: 10, height: 15)
+      assert_equal(10, box.width)
+      assert_equal(15, box.height)
+      assert_same(@composer.document.images.add(image_path), box.image)
+    end
+  end
+
+  describe "draw_box" do
+    def create_box(**kwargs)
+      HexaPDF::Layout::Box.new(kwargs) {}
+    end
+
+    it "draws the box if it completely fits" do
+      @composer.draw_box(create_box(height: 100))
+      @composer.draw_box(create_box)
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 706]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 36]],
+                        [:restore_graphics_state]])
+    end
+
+    it "draws the box on a new page if the frame is already full" do
+      first_page_canvas = @composer.canvas
+      @composer.draw_box(create_box)
+      @composer.draw_box(create_box)
+      refute_same(first_page_canvas, @composer.canvas)
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 36]],
+                        [:restore_graphics_state]])
+    end
+
+    it "splits the box across two pages" do
+      first_page_contents = @composer.canvas.contents
+      @composer.draw_box(create_box(height: 400))
+
+      box = create_box(height: 400)
+      box.define_singleton_method(:split) do |*|
+        [box, HexaPDF::Layout::Box.new(height: 100) {}]
+      end
+      @composer.draw_box(box)
+      assert_operators(first_page_contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 406]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 6]],
+                        [:restore_graphics_state]])
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 706]],
+                        [:restore_graphics_state]])
+    end
+
+    it "finds a new region if splitting didn't work" do
+      first_page_contents = @composer.canvas.contents
+      @composer.draw_box(create_box(height: 400))
+      @composer.draw_box(create_box(height: 100, width: 300, style: {position: :float}))
+
+      box = create_box(width: 400, height: 400)
+      @composer.draw_box(box)
+      assert_operators(first_page_contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 406]],
+                        [:restore_graphics_state],
+                        [:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 306]],
+                        [:restore_graphics_state]])
+      assert_operators(@composer.canvas.contents,
+                       [[:save_graphics_state],
+                        [:concatenate_matrix, [1, 0, 0, 1, 36, 406]],
+                        [:restore_graphics_state]])
+    end
+
+    it "raises an error if a box doesn't fit onto an empty page" do
+      assert_raises(HexaPDF::Error) do
+        @composer.draw_box(create_box(height: 800))
+      end
+    end
+  end
+end