hexapdf 0.5.0 → 0.6.0

data/test/hexapdf/document/test_images.rb

@@ -18,11 +18,7 @@ describe HexaPDF::Document::Images do
           s = HexaPDF::StreamData.new(s) if s.kind_of?(IO)
           doc.add({Subtype: :Image}, stream: s)
         end
-        HexaPDF::GlobalConfiguration['image_loader'].unshift(@loader)
-      end
-
-      after do
-        HexaPDF::GlobalConfiguration['image_loader'].delete(@loader)
+        @doc.config['image_loader'].unshift(@loader)
       end
 
       it "adds an image using a filename" do
@@ -49,13 +45,9 @@ describe HexaPDF::Document::Images do
     end
 
     it "fails if the needed image loader can't be resolved" do
-      begin
-        HexaPDF::GlobalConfiguration['image_loader'].unshift('SomeUnknownConstantHere')
-        exp = assert_raises(HexaPDF::Error) { @doc.images.add(StringIO.new('test')) }
-        assert_match(/image loader from configuration/, exp.message)
-      ensure
-        HexaPDF::GlobalConfiguration['image_loader'].shift
-      end
+      @doc.config['image_loader'].unshift('SomeUnknownConstantHere')
+      exp = assert_raises(HexaPDF::Error) { @doc.images.add(StringIO.new('test')) }
+      assert_match(/image loader from configuration/, exp.message)
     end
 
     it "fails if no image loader is found" do

data/test/hexapdf/document/test_pages.rb

@@ -27,21 +27,21 @@ describe HexaPDF::Document::Pages do
     end
 
     it "adds a new empty page with the given page format" do
-      page = @doc.pages.add(:A4)
+      page = @doc.pages.add(:A4, orientation: :landscape)
       assert_same(page, @doc.pages[0])
-      assert_equal([0, 0, 595, 842], @doc.pages[0].box(:media).value)
+      assert_equal([0, 0, 842, 595], @doc.pages[0].box(:media).value)
     end
 
-    it "fails if an unknown page format is given" do
-      assert_raises(HexaPDF::Error) { @doc.pages.add(:A953) }
-    end
-
-    it "adds a given page to the end" do
+    it "adds the given page to the end" do
       page = @doc.pages.add
       new_page = @doc.add(Type: :Page)
       assert_same(new_page, @doc.pages.add(new_page))
       assert_equal([page, new_page], @doc.pages.root[:Kids])
     end
+
+    it "fails if an unknown page format is given" do
+      assert_raises(HexaPDF::Error) { @doc.pages.add(:A953) }
+    end
   end
 
   describe "<<" do

data/test/hexapdf/encryption/test_security_handler.rb

@@ -67,11 +67,7 @@ describe HexaPDF::Encryption::SecurityHandler do
 
   describe "class methods" do
     before do
-      HexaPDF::GlobalConfiguration['encryption.filter_map'][:Test] = TestHandler
-    end
-
-    after do
-      HexaPDF::GlobalConfiguration['encryption.filter_map'].delete(:Test)
+      @document.config['encryption.filter_map'][:Test] = TestHandler
     end
 
     describe "class set_up_encryption" do

data/test/hexapdf/filter/test_predictor.rb

@@ -88,12 +88,26 @@ describe HexaPDF::Filter::Predictor do
         end
       end
 
-      it "fails if data is missing" do
-        assert_raises(HexaPDF::FilterError) do
-          data = @testcases['up']
-          encoder = @obj.png_execute(:encoder, feeder(data[:source][0..-2], 1), data[:Predictor],
-                                     data[:Colors], data[:BitsPerComponent], data[:Columns])
-          collector(encoder)
+      it "handles a short last row if 'filter.predictor.strict' is false" do
+        data = @testcases['up']
+        encoder = @obj.png_execute(:encoder, feeder(data[:source][0..-3], 1), data[:Predictor],
+                                   data[:Colors], data[:BitsPerComponent], data[:Columns])
+        result = collector(encoder)
+        assert_equal(1 + 5 + 1 + 3, result.length)
+        assert_equal(data[:result][0..-3], result)
+      end
+
+      it "fails if the last row is missing data and 'filter.predictor.strict' is true " do
+        begin
+          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = true
+          assert_raises(HexaPDF::FilterError) do
+            data = @testcases['up']
+            encoder = @obj.png_execute(:encoder, feeder(data[:source][0..-2], 1), data[:Predictor],
+                                       data[:Colors], data[:BitsPerComponent], data[:Columns])
+            collector(encoder)
+          end
+        ensure
+          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = false
         end
       end
     end
@@ -107,12 +121,26 @@ describe HexaPDF::Filter::Predictor do
         end
       end
 
-      it "fails if data is missing" do
-        assert_raises(HexaPDF::FilterError) do
-          data = @testcases['up']
-          encoder = @obj.png_execute(:decoder, feeder(data[:result][0..-2], 1), data[:Predictor], data[:Colors],
-                                     data[:BitsPerComponent], data[:Columns])
-          collector(encoder)
+      it "handles a short last row if 'filter.predictor.strict' is false" do
+        data = @testcases['up']
+        encoder = @obj.png_execute(:decoder, feeder(data[:result][0..-3], 1), data[:Predictor],
+                                   data[:Colors], data[:BitsPerComponent], data[:Columns])
+        result = collector(encoder)
+        assert_equal(5 + 3, result.length)
+        assert_equal(data[:source][0..-3], result)
+      end
+
+      it "fails if the last row is missing data and 'filter.predictor.strict' is true " do
+        begin
+          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = true
+          assert_raises(HexaPDF::FilterError) do
+            data = @testcases['up']
+            encoder = @obj.png_execute(:decoder, feeder(data[:result][0..-2], 1), data[:Predictor],
+                                       data[:Colors], data[:BitsPerComponent], data[:Columns])
+            collector(encoder)
+          end
+        ensure
+          HexaPDF::GlobalConfiguration['filter.predictor.strict'] = false
         end
       end
     end

data/test/hexapdf/font/true_type/test_font.rb

@@ -88,6 +88,22 @@ describe HexaPDF::Font::TrueType::Font do
     it "returns the font's dominant vertical stem width" do
       assert_equal(80, @font.dominant_vertical_stem_width)
     end
+
+    it "returns the underline position" do
+      assert_equal(-125, @font.underline_position)
+    end
+
+    it "returns the underline thickness" do
+      assert_equal(50, @font.underline_thickness)
+    end
+
+    it "returns the strikeout position" do
+      assert_equal(256, @font.strikeout_position)
+    end
+
+    it "returns the strikeout thickness" do
+      assert_equal(48, @font.strikeout_thickness)
+    end
   end
 
   it "is able to return the ID of the missing glyph" do

data/test/hexapdf/font/type1/test_font.rb

@@ -71,4 +71,34 @@ describe HexaPDF::Font::Type1::Font do
     assert_equal([:kern, :liga].to_set, FONT_TIMES.features)
     assert(FONT_SYMBOL.features.empty?)
   end
+
+  describe "underline properties" do
+    before do
+      @font.metrics.underline_position = -100
+      @font.metrics.underline_thickness = 50
+    end
+
+    it "returns the underline position" do
+      assert_equal(-75, @font.underline_position)
+    end
+
+    it "returns the underline thickness" do
+      assert_equal(50, @font.underline_thickness)
+    end
+  end
+
+  describe "strikeout properties" do
+    it "returns the strikeout position" do
+      assert_equal(225, @font.strikeout_position)
+    end
+
+    it "returns the strikeout thickness" do
+      assert_equal(50, @font.strikeout_thickness)
+
+      emdash = HexaPDF::Font::Type1::CharacterMetrics.new
+      emdash.bbox = [0, 200, 1000, 240]
+      @font.metrics.character_metrics[:emdash] = emdash
+      assert_equal(40, @font.strikeout_thickness)
+    end
+  end
 end

data/test/hexapdf/font_loader/test_from_file.rb

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font_loader'
+require 'hexapdf/document'
+
+describe HexaPDF::FontLoader::FromFile do
+  before do
+    @doc = HexaPDF::Document.new
+    @font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
+    @klass = HexaPDF::FontLoader::FromFile
+  end
+
+  it "loads the specified font file" do
+    wrapper = @klass.call(@doc, @font_file)
+    assert_equal("Ubuntu-Title", wrapper.wrapped_font.font_name)
+  end
+
+  it "passes the subset value to the wrapper" do
+    wrapper = @klass.call(@doc, @font_file)
+    assert(wrapper.subset?)
+    wrapper = @klass.call(@doc, @font_file, subset: false)
+    refute(wrapper.subset?)
+  end
+
+  it "returns nil if the given name doesn't represent a file" do
+    assert_nil(@klass.call(@doc, "Unknown"))
+  end
+end

data/test/hexapdf/font_loader/test_standard14.rb

@@ -7,16 +7,17 @@ require 'hexapdf/document'
 describe HexaPDF::FontLoader::Standard14 do
   before do
     @doc = HexaPDF::Document.new
+    @obj = HexaPDF::FontLoader::Standard14
   end
 
   it "loads the font if it is a standard PDF built-in font" do
-    wrapper = @doc.fonts.load("Times")
+    wrapper = @obj.call(@doc, "Times")
     assert_equal("Times-Roman", wrapper.wrapped_font.font_name)
-    wrapper = @doc.fonts.load("Helvetica", variant: :bold)
+    wrapper = @obj.call(@doc, "Helvetica", variant: :bold)
     assert_equal("Helvetica-Bold", wrapper.wrapped_font.font_name)
   end
 
   it "returns nil for unknown fonts" do
-    assert_nil(HexaPDF::FontLoader::Standard14.call(@doc, "Unknown"))
+    assert_nil(@obj.call(@doc, "Unknown"))
   end
 end

data/test/hexapdf/layout/test_box.rb

@@ -0,0 +1,104 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../content/common'
+require 'hexapdf/document'
+require 'hexapdf/layout/box'
+
+describe HexaPDF::Layout::Box do
+  def create_box(*args, &block)
+    HexaPDF::Layout::Box.new(*args, &block)
+  end
+
+  describe "initialize" do
+    it "takes content width and height" do
+      box = create_box(content_width: 100, content_height: 200)
+      assert_equal(100, box.content_width)
+      assert_equal(200, box.content_height)
+    end
+
+    it "takes box width and height" do
+      box = create_box(width: 100, height: 200)
+      assert_equal(100, box.content_width)
+      assert_equal(200, box.content_height)
+
+      box = create_box(width: 100, height: 200, style: {padding: [20, 10], border: {width: [10, 5]}})
+      assert_equal(70, box.content_width)
+      assert_equal(140, box.content_height)
+    end
+
+    it "allows passing a Style object or a hash" do
+      box = create_box(style: {padding: 20})
+      assert_equal(20, box.style.padding.top)
+
+      box = create_box(style: HexaPDF::Layout::Style.new(padding: 20))
+      assert_equal(20, box.style.padding.top)
+    end
+  end
+
+  it "returns the full width and height of the box" do
+    box = create_box(content_width: 100, content_height: 200,
+                     style: {padding: [20, 10], border: {width: [10, 5]}})
+    assert_equal(130, box.width)
+    assert_equal(260, box.height)
+  end
+
+  describe "draw" do
+    it "draws the box onto the canvas" do
+      box = create_box(content_width: 100, content_height: 100) do |canvas, _|
+        canvas.line_width(15)
+      end
+      box.style.background_color = 0.5
+      box.style.border(width: 5)
+      box.style.padding([10, 20])
+      box.style.underlays.add {|canvas, _| canvas.line_width(10) }
+      box.style.overlays.add {|canvas, _| canvas.line_width(20) }
+
+      @canvas = HexaPDF::Document.new.pages.add.canvas
+      box.draw(@canvas, 5, 5)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:set_device_gray_non_stroking_color, [0.5]],
+                                          [:append_rectangle, [5, 5, 150, 130]],
+                                          [:fill_path_non_zero],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1, 0, 0, 1, 5, 5]],
+                                          [:save_graphics_state],
+                                          [:set_line_width, [10]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:set_line_width, [5]],
+                                          [:append_rectangle, [7.5, 7.5, 145, 125]],
+                                          [:stroke_path],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1, 0, 0, 1, 30, 20]],
+                                          [:set_line_width, [15]],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1, 0, 0, 1, 5, 5]],
+                                          [:save_graphics_state],
+                                          [:set_line_width, [20]],
+                                          [:restore_graphics_state],
+                                          [:restore_graphics_state]])
+    end
+
+    it "draws nothing onto the canvas if the box is empty" do
+      @canvas = HexaPDF::Document.new.pages.add.canvas
+      create_box.draw(@canvas, 5, 5)
+      assert_operators(@canvas.contents, [])
+    end
+  end
+
+  describe "empty?" do
+    it "is only empty when no drawing operation is specified" do
+      assert(create_box.empty?)
+      refute(create_box {}.empty?)
+      refute(create_box(style: {background_color: [5]}).empty?)
+      refute(create_box(style: {border: {width: 1}}).empty?)
+      refute(create_box(style: {underlays: [proc {}]}).empty?)
+      refute(create_box(style: {overlays: [proc {}]}).empty?)
+    end
+  end
+end

data/test/hexapdf/layout/test_inline_box.rb

@@ -5,36 +5,50 @@ require 'hexapdf/layout/inline_box'
 
 describe HexaPDF::Layout::InlineBox do
   before do
-    @box = HexaPDF::Layout::InlineBox.new(10, 15) {|box, canvas| [box, canvas]}
+    @box = HexaPDF::Layout::InlineBox.create(width: 10, height: 15, style: {margin: [15, 10]})
   end
 
-  describe "draw" do
-    before do
-      @canvas = Object.new
-      @canvas.define_singleton_method(:translate) {|x, y, &block| [x, y, block.call] }
+  it "draws the wrapped box at the correct position" do
+    canvas = Object.new
+    block = ->(c, x, y) do
+      assert_equal(canvas, c)
+      assert_equal(10, x)
+      assert_equal(15, y)
     end
-
-    it "returns the value of the drawing block" do
-      assert_equal([1, 2, [@box, @canvas]], @box.draw(@canvas, 1, 2))
+    @box.box.stub(:draw, block) do
+      @box.draw(canvas, 0, 0)
     end
   end
 
+  it "returns true if the inline box is empty with no drawing operations" do
+    assert(@box.empty?)
+    refute(HexaPDF::Layout::InlineBox.create(width: 10, height: 15) {}.empty?)
+  end
+
   describe "valign" do
     it "has a default value of :baseline" do
       assert_equal(:baseline, @box.valign)
     end
 
     it "can be changed on creation" do
-      box = HexaPDF::Layout::InlineBox.new(10, 15, valign: :test) {}
+      box = HexaPDF::Layout::InlineBox.create(width: 10, height: 15, valign: :test)
       assert_equal(:test, box.valign)
     end
   end
 
+  it "returns the width including margins" do
+    assert_equal(30, @box.width)
+  end
+
+  it "returns the height including margins" do
+    assert_equal(45, @box.height)
+  end
+
   it "returns 0 for x_min" do
     assert_equal(0, @box.x_min)
   end
 
   it "returns width for x_max" do
-    assert_equal(10, @box.x_max)
+    assert_equal(@box.width, @box.x_max)
   end
 end

data/test/hexapdf/layout/{test_line_fragment.rb → test_line.rb}

@@ -3,25 +3,25 @@
 require 'test_helper'
 require 'hexapdf/document'
 
-describe HexaPDF::Layout::LineFragment::HeightCalculator do
+describe HexaPDF::Layout::Line::HeightCalculator do
   before do
-    @calc = HexaPDF::Layout::LineFragment::HeightCalculator.new
+    @calc = HexaPDF::Layout::Line::HeightCalculator.new
   end
 
   it "simulate the height as if an item was added" do
-    @calc << HexaPDF::Layout::InlineBox.new(10, 20, valign: :baseline) {}
+    @calc << HexaPDF::Layout::InlineBox.create(width: 10, height: 20, valign: :baseline) {}
     assert_equal([0, 20, 0, 0], @calc.result)
-    new_item = HexaPDF::Layout::InlineBox.new(10, 30, valign: :top) {}
+    new_item = HexaPDF::Layout::InlineBox.create(width: 10, height: 30, valign: :top) {}
     assert_equal(30, @calc.simulate_height(new_item))
     assert_equal([0, 20, 0, 0], @calc.result)
   end
 end
 
-describe HexaPDF::Layout::LineFragment do
+describe HexaPDF::Layout::Line do
   before do
     @doc = HexaPDF::Document.new
-    @font = @doc.fonts.load("Times", custom_encoding: true)
-    @line = HexaPDF::Layout::LineFragment.new
+    @font = @doc.fonts.add("Times", custom_encoding: true)
+    @line = HexaPDF::Layout::Line.new
   end
 
   def setup_fragment(text)
@@ -29,14 +29,14 @@ describe HexaPDF::Layout::LineFragment do
   end
 
   def setup_box(width, height, valign = :baseline)
-    HexaPDF::Layout::InlineBox.new(width, height, valign: valign) {}
+    HexaPDF::Layout::InlineBox.create(width: width, height: height, valign: valign) {}
   end
 
   describe "initialize" do
     it "allows setting the items of the line fragment" do
       frag1 = setup_fragment("Hello")
       frag2 = HexaPDF::Layout::TextFragment.new(items: frag1.items.slice!(3, 2), style: frag1.style)
-      line = HexaPDF::Layout::LineFragment.new([frag1, frag2])
+      line = HexaPDF::Layout::Line.new([frag1, frag2])
       assert_equal(1, line.items.count)
       assert_equal(5, line.items[0].items.count)
     end