hexapdf 0.11.9 → 0.13.0

data/test/hexapdf/content/test_operator.rb

@@ -254,89 +254,89 @@ end
 
 describe_operator :SetStrokingColor, :SC do
   it "sets the stroking color" do
-    invoke(128)
-    assert_equal(@processor.resources.color_space(:DeviceGray).color(128),
+    invoke(0.2)
+    assert_equal(@processor.resources.color_space(:DeviceGray).color(51),
                  @processor.graphics_state.stroke_color)
   end
 
   it "serializes correctly" do
-    assert_serialized(128, 129, 130)
+    assert_serialized(0.2, 0.5, 0.8)
   end
 end
 
 describe_operator :SetNonStrokingColor, :sc do
   it "sets the non stroking color" do
-    invoke(128)
-    assert_equal(@processor.resources.color_space(:DeviceGray).color(128),
+    invoke(0.2)
+    assert_equal(@processor.resources.color_space(:DeviceGray).color(51),
                  @processor.graphics_state.fill_color)
   end
 
   it "serializes correctly" do
-    assert_serialized(128, 129, 130)
+    assert_serialized(0.2, 0.5, 0.8)
   end
 end
 
 describe_operator :SetDeviceGrayStrokingColor, :G do
   it "sets the DeviceGray stroking color" do
-    invoke(128)
-    assert_equal(@processor.resources.color_space(:DeviceGray).color(128),
+    invoke(0.2)
+    assert_equal(@processor.resources.color_space(:DeviceGray).color(51),
                  @processor.graphics_state.stroke_color)
   end
 end
 
 describe_operator :SetDeviceGrayNonStrokingColor, :g do
   it "sets the DeviceGray non stroking color" do
-    invoke(128)
-    assert_equal(@processor.resources.color_space(:DeviceGray).color(128),
+    invoke(0.2)
+    assert_equal(@processor.resources.color_space(:DeviceGray).color(51),
                  @processor.graphics_state.fill_color)
   end
 end
 
 describe_operator :SetDeviceRGBStrokingColor, :RG do
   it "sets the DeviceRGB stroking color" do
-    invoke(128, 0, 128)
-    assert_equal(@processor.resources.color_space(:DeviceRGB).color(128, 0, 128),
+    invoke(0.2, 0, 0.2)
+    assert_equal(@processor.resources.color_space(:DeviceRGB).color(51, 0, 51),
                  @processor.graphics_state.stroke_color)
   end
 
   it "serializes correctly" do
-    assert_serialized(128, 129, 130)
+    assert_serialized(0.2, 0.3, 0.4)
   end
 end
 
 describe_operator :SetDeviceRGBNonStrokingColor, :rg do
   it "sets the DeviceRGB non stroking color" do
-    invoke(128, 0, 128)
-    assert_equal(@processor.resources.color_space(:DeviceRGB).color(128, 0, 128),
+    invoke(0.2, 0, 0.2)
+    assert_equal(@processor.resources.color_space(:DeviceRGB).color(51, 0, 51),
                  @processor.graphics_state.fill_color)
   end
 
   it "serializes correctly" do
-    assert_serialized(128, 129, 130)
+    assert_serialized(0.2, 0.3, 0.4)
   end
 end
 
 describe_operator :SetDeviceCMYKStrokingColor, :K do
   it "sets the DeviceCMYK stroking color" do
-    invoke(128, 0, 128, 128)
-    assert_equal(@processor.resources.color_space(:DeviceCMYK).color(128, 0, 128, 128),
+    invoke(0.51, 0, 0.51, 0.51)
+    assert_equal(@processor.resources.color_space(:DeviceCMYK).color(51, 0, 51, 51),
                  @processor.graphics_state.stroke_color)
   end
 
   it "serializes correctly" do
-    assert_serialized(128, 129, 130, 131)
+    assert_serialized(0.2, 0.3, 0.4, 0.5)
   end
 end
 
 describe_operator :SetDeviceCMYKNonStrokingColor, :k do
   it "sets the DeviceCMYK non stroking color" do
-    invoke(128, 0, 128, 128)
-    assert_equal(@processor.resources.color_space(:DeviceCMYK).color(128, 0, 128, 128),
+    invoke(0.51, 0, 0.51, 0.51)
+    assert_equal(@processor.resources.color_space(:DeviceCMYK).color(51, 0, 51, 51),
                  @processor.graphics_state.fill_color)
   end
 
   it "serializes correctly" do
-    assert_serialized(128, 129, 130, 131)
+    assert_serialized(0.2, 0.3, 0.4, 0.5)
   end
 end
 

data/test/hexapdf/content/test_parser.rb

@@ -81,5 +81,19 @@ describe HexaPDF::Content::Parser do
       end
       assert_match(/EI not found/, exp.message)
     end
+
+    it "can use a block instead of the processor object" do
+      called = 0
+      @parser.parse("/F1 5 Tf") do |obj, params|
+        called += 1
+        assert_equal(:Tf, obj)
+        assert_equal([:F1, 5], params)
+      end
+      assert_equal(1, called)
+    end
+
+    it "fails if neither a processor object or a block is provided" do
+      assert_raises(ArgumentError) { @parser.parse("test") }
+    end
   end
 end

data/test/hexapdf/document/test_fonts.rb

@@ -36,7 +36,7 @@ describe HexaPDF::Document::Fonts do
       assert_same(font, @doc.fonts.add(:TestFont, variant: :none))
     end
 
-    it "fails if the requested font is not found"  do
+    it "fails if the requested font is not found" do
       @doc.config['font_loader'] << 'HexaPDF::FontLoader::Standard14'
       error = assert_raises(HexaPDF::Error) { @doc.fonts.add("Unknown") }
       assert_match(/Times \(none/, error.message)

data/test/hexapdf/document/test_pages.rb

@@ -74,20 +74,20 @@ describe HexaPDF::Document::Pages do
 
   describe "delete" do
     it "deletes a given page" do
-      page = @doc.pages.add
-      @doc.pages.add
+      page1 = @doc.pages.add
+      page2 = @doc.pages.add
 
-      assert_same(page, @doc.pages.delete(page))
-      assert_nil(@doc.pages.delete(page))
+      @doc.pages.delete(page1)
+      assert_equal([page2], @doc.pages.root[:Kids].value)
     end
   end
 
   describe "delete_at" do
     it "deletes a page at a given index" do
       page1 = @doc.pages.add
-      page2 = @doc.pages.add
+      @doc.pages.add
       page3 = @doc.pages.add
-      assert_same(page2, @doc.pages.delete_at(1))
+      @doc.pages.delete_at(1)
       assert_equal([page1, page3], @doc.pages.root[:Kids].value)
     end
   end

data/test/hexapdf/encryption/test_aes.rb

@@ -101,13 +101,13 @@ describe HexaPDF::Encryption::AES do
       result = TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, f))
       assert_equal('a' * 16, result)
 
-      f = Fiber.new { 'a' * 31 + "\x00" }
+      f = Fiber.new { 'a' * 31 << "\x00" }
       result = TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, f))
-      assert_equal('a' * 15 + "\x00", result)
+      assert_equal('a' * 15 << "\x00", result)
 
-      f = Fiber.new { 'a' * 29 + "\x00\x01\x03" }
+      f = Fiber.new { 'a' * 29 << "\x00\x01\x03" }
       result = TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, f))
-      assert_equal('a' * 13 + "\x00\x01\x03", result)
+      assert_equal('a' * 13 << "\x00\x01\x03", result)
     end
 
     it "fails on decryption if not enough bytes are provided" do

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -53,24 +53,24 @@ describe HexaPDF::Encryption::StandardEncryptionDictionary do
 end
 
 describe HexaPDF::Encryption::StandardSecurityHandler do
-  TEST_FILES = Dir[File.join(TEST_DATA_DIR, 'standard-security-handler', '*.pdf')].sort
-  USER_PASSWORD = 'uhexapdf'
-  OWNER_PASSWORD = 'ohexapdf'
+  test_files = Dir[File.join(TEST_DATA_DIR, 'standard-security-handler', '*.pdf')].sort
+  user_password = 'uhexapdf'
+  owner_password = 'ohexapdf'
 
-  MINIMAL_DOC = HexaPDF::Document.new(io: StringIO.new(MINIMAL_PDF))
+  minimal_doc = HexaPDF::Document.new(io: StringIO.new(MINIMAL_PDF))
 
-  TEST_FILES.each do |file|
+  test_files.each do |file|
     basename = File.basename(file)
     it "can decrypt, encrypt and decrypt the encrypted file #{basename} with the user password" do
       begin
         doc = HexaPDF::Document.new(io: StringIO.new(File.binread(file)),
-                                    decryption_opts: {password: USER_PASSWORD})
-        assert_equal(MINIMAL_DOC.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
+                                    decryption_opts: {password: user_password})
+        assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
 
         out = StringIO.new(''.b)
         HexaPDF::Writer.new(doc, out).write
-        doc = HexaPDF::Document.new(io: out, decryption_opts: {password: USER_PASSWORD})
-        assert_equal(MINIMAL_DOC.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
+        doc = HexaPDF::Document.new(io: out, decryption_opts: {password: user_password})
+        assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
       rescue HexaPDF::EncryptionError => e
         flunk("Error processing #{basename}: #{e}")
       end
@@ -80,8 +80,8 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
       it "can decrypt the encrypted file #{basename} with the owner password" do
         begin
           doc = HexaPDF::Document.new(io: StringIO.new(File.binread(file)),
-                                      decryption_opts: {password: OWNER_PASSWORD})
-          assert_equal(MINIMAL_DOC.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
+                                      decryption_opts: {password: owner_password})
+          assert_equal(minimal_doc.trailer[:Info][:ModDate], doc.trailer[:Info][:ModDate])
         rescue HexaPDF::EncryptionError => e
           flunk("Error processing #{basename}: #{e}")
         end

data/test/hexapdf/filter/test_ascii85_decode.rb

@@ -33,7 +33,7 @@ describe HexaPDF::Filter::ASCII85Decode do
     end
 
     it "ignores data after the EOD marker" do
-      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded.dup + "~>abcdefg"))))
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded << "~>abcdefg"))))
     end
 
     it "fails if the input contains invalid characters" do

data/test/hexapdf/filter/test_ascii_hex_decode.rb

@@ -24,7 +24,7 @@ describe HexaPDF::Filter::ASCIIHexDecode do
     end
 
     it "ignores data after the EOD marker" do
-      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded + '4e6f7gzz'))))
+      assert_equal(@decoded, collector(@obj.decoder(feeder(@encoded << '4e6f7gzz'))))
     end
 
     it "assumes the missing char is '0' if the input length is odd" do

data/test/hexapdf/font/encoding/test_base.rb

@@ -32,4 +32,14 @@ describe HexaPDF::Font::Encoding::Base do
       assert_nil(@base.unicode(66))
     end
   end
+
+  describe "code" do
+    it "returns the code for an existing glyph name" do
+      assert_equal(65, @base.code(:A))
+    end
+
+    it "returns nil if the glyph name is not referenced" do
+      assert_nil(@base.code(:Unknown))
+    end
+  end
 end

data/test/hexapdf/font/encoding/test_difference_encoding.rb

@@ -18,4 +18,12 @@ describe HexaPDF::Font::Encoding::DifferenceEncoding do
       assert_equal(:B, @enc.name(66))
     end
   end
+
+  describe "code" do
+    it "takes the encoding differences into account" do
+      assert_equal(65, @enc.code(:A))
+      @enc.code_to_name[65] = :Known
+      assert_equal(65, @enc.code(:Known))
+    end
+  end
 end

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -94,7 +94,10 @@ describe HexaPDF::Font::TrueTypeWrapper do
       @font_wrapper.encode(glyph)
       @doc.dispatch_message(:complete_objects)
 
-      dict = @font_wrapper.dict
+      dict = @font_wrapper.pdf_object
+
+      # Checking the circular reference
+      assert_same(@font_wrapper, dict.font_wrapper)
 
       # Checking Type 0 font dictionary
       assert_equal(:Font, dict[:Type])
@@ -129,7 +132,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
         @font[:'OS/2'].typo_ascender = 1000
         font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(@doc, @font)
         font_wrapper.encode(glyph)
-        fd = font_wrapper.dict[:DescendantFonts][0][:FontDescriptor]
+        fd = font_wrapper.pdf_object[:DescendantFonts][0][:FontDescriptor]
         assert_equal(800, fd[:CapHeight])
         assert_equal(500, fd[:XHeight])
       end
@@ -139,7 +142,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
       @font[:'OS/2'].cap_height = 1000 * @font[:head].units_per_em / 1000
       font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(@doc, @font)
       font_wrapper.encode(glyph)
-      fd = font_wrapper.dict[:DescendantFonts][0][:FontDescriptor]
+      fd = font_wrapper.pdf_object[:DescendantFonts][0][:FontDescriptor]
       assert_equal(1000, fd[:CapHeight])
       assert_equal(500, fd[:XHeight])
     end
@@ -151,7 +154,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
       @font_wrapper.encode(glyph)
       @doc.dispatch_message(:complete_objects)
 
-      dict = @font_wrapper.dict
+      dict = @font_wrapper.pdf_object
 
       assert_equal(HexaPDF::Font::CMap.create_to_unicode_cmap([[3, ' '.ord], [glyph.id, 'H'.ord]]),
                    dict[:ToUnicode].stream)
@@ -164,7 +167,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
       @font_wrapper.encode(@font_wrapper.glyph(10))
       @doc.dispatch_message(:complete_objects)
 
-      font_data = @font_wrapper.dict[:DescendantFonts][0][:FontDescriptor][:FontFile2].stream
+      font_data = @font_wrapper.pdf_object[:DescendantFonts][0][:FontDescriptor][:FontFile2].stream
       font = HexaPDF::Font::TrueType::Font.new(StringIO.new(font_data))
       assert_equal(@font[:glyf][0].raw_data, font[:glyf][0].raw_data)
       assert_equal(@font[:glyf][10].raw_data, font[:glyf][1].raw_data)
@@ -175,9 +178,9 @@ describe HexaPDF::Font::TrueTypeWrapper do
       @doc.dispatch_message(:complete_objects)
 
       assert_equal(File.size(@font_file),
-                   @font_wrapper.dict[:DescendantFonts][0][:FontDescriptor][:FontFile2][:Length1])
+                   @font_wrapper.pdf_object[:DescendantFonts][0][:FontDescriptor][:FontFile2][:Length1])
       assert_equal(File.binread(@font_file),
-                   @font_wrapper.dict[:DescendantFonts][0][:FontDescriptor][:FontFile2].stream)
+                   @font_wrapper.pdf_object[:DescendantFonts][0][:FontDescriptor][:FontFile2].stream)
     end
   end
 end

data/test/hexapdf/font/test_type1_wrapper.rb

@@ -12,6 +12,15 @@ describe HexaPDF::Font::Type1Wrapper do
     @symbol_wrapper = HexaPDF::Font::Type1Wrapper.new(@doc, FONT_SYMBOL)
   end
 
+  it "can be used with an existing PDF object" do
+    font = @doc.add({Type: :Font, Subtype: :Type1, Encoding: {Differences: [65, :B]},
+                     BaseFont: :"Times-Roman"})
+    wrapper = HexaPDF::Font::Type1Wrapper.new(@doc, FONT_TIMES, pdf_object: font)
+    assert_equal([:B, :E, :A, :S, :T], wrapper.decode_utf8("BEAST").map(&:name))
+    assert_equal("A", wrapper.encode(wrapper.glyph(:A)))
+    assert_equal("A", wrapper.encode(wrapper.glyph(:B)))
+  end
+
   it "returns 1 for the scaling factor" do
     assert_equal(1, @times_wrapper.scaling_factor)
   end
@@ -21,6 +30,10 @@ describe HexaPDF::Font::Type1Wrapper do
       assert_equal([:T, :e, :s, :t], @times_wrapper.decode_utf8("Test").map(&:name))
     end
 
+    it "falls back to the internal font encoding if the Unicode codepoint is not mapped" do
+      assert_equal([:Delta, :Delta], @symbol_wrapper.decode_utf8("D∆").map(&:name))
+    end
+
     it "UTF-8 characters for which no glyph name exists, are mapped to InvalidGlyph objects" do
       glyphs = @times_wrapper.decode_utf8("😁")
       assert_equal(1, glyphs.length)
@@ -58,7 +71,7 @@ describe HexaPDF::Font::Type1Wrapper do
         code = @times_wrapper.encode(@times_wrapper.glyph(:a))
         @doc.dispatch_message(:complete_objects)
         assert_equal("a", code)
-        assert_equal(:WinAnsiEncoding, @times_wrapper.dict[:Encoding])
+        assert_equal(:WinAnsiEncoding, @times_wrapper.pdf_object[:Encoding])
       end
 
       it "fails if an InvalidGlyph is encoded" do
@@ -70,13 +83,25 @@ describe HexaPDF::Font::Type1Wrapper do
       end
     end
 
-    describe "uses an empty encoding as initial encoding for symbolic fonts" do
-      it "returns the PDF font dictionary and encoded glyph" do
-        code = @symbol_wrapper.encode(@symbol_wrapper.glyph(:plus))
-        @doc.dispatch_message(:complete_objects)
-        assert_equal("\x21", code)
-        assert_equal({Differences: [32, :space, :plus]}, @symbol_wrapper.dict[:Encoding].value)
-      end
+    it "uses the font's internal encoding for fonts with the Special character set" do
+      code = @symbol_wrapper.encode(@symbol_wrapper.glyph(:plus))
+      @doc.dispatch_message(:complete_objects)
+      assert_equal("+", code)
+      assert_nil(@symbol_wrapper.pdf_object[:Encoding])
+    end
+
+    it "uses an empty encoding as initial encoding if a custom encoding is needed" do
+      wrapper = HexaPDF::Font::Type1Wrapper.new(@doc, FONT_TIMES, custom_encoding: true)
+      code = wrapper.encode(wrapper.glyph(:plus))
+      @doc.dispatch_message(:complete_objects)
+      assert_equal("\x21", code)
+      assert_equal({Differences: [32, :space, :plus]}, wrapper.pdf_object[:Encoding].value)
+    end
+  end
+
+  describe "creates the necessary PDF dictionaries" do
+    it "sets the circular reference" do
+      assert_same(@times_wrapper, @times_wrapper.pdf_object.font_wrapper)
     end
   end
 end

data/test/hexapdf/layout/test_style.rb

@@ -537,7 +537,7 @@ describe HexaPDF::Layout::Style::LinkLayer do
     end
 
     it "does nothing if the context is not a page object" do
-      @canvas = HexaPDF::Document.new.add({Type: :XObject, Subtype: :Form}).canvas
+      @canvas = HexaPDF::Document.new.add({Type: :XObject, Subtype: :Form, BBox: [0, 0, 1, 1]}).canvas
       assert_nil(call_link(dest: true))
     end
 

data/test/hexapdf/layout/test_text_layouter.rb

@@ -674,10 +674,9 @@ describe HexaPDF::Layout::TextLayouter do
       pos = [0, 0]
       result.select! {|name, _| name == :set_text_matrix || name == :move_text_next_line }.
         map! do |name, ops|
-        if name == :set_text_matrix
-          pos = ops[-2, 2]
-        elsif name == :move_text_next_line
-          pos[1] -= leading
+        case name
+        when :set_text_matrix then pos = ops[-2, 2]
+        when :move_text_next_line then pos[1] -= leading
         end
         pos.dup
       end

data/test/hexapdf/test_configuration.rb

@@ -66,8 +66,8 @@ describe HexaPDF::Configuration do
       assert_equal(HexaPDF, @config.constantize('test', 1))
     end
 
-    def assert_constantize_error # :nodoc:
-      exp = assert_raises(HexaPDF::Error) { yield }
+    def assert_constantize_error(&block) # :nodoc:
+      exp = assert_raises(HexaPDF::Error, &block)
       assert_match(/Error getting constant for configuration option/, exp.message)
     end
 

data/test/hexapdf/test_dictionary.rb

@@ -14,7 +14,9 @@ describe HexaPDF::Dictionary do
   end
 
   def add(obj)
-    HexaPDF::Object.new(obj, oid: 1)
+    klass = HexaPDF::Object
+    klass = HexaPDF::Dictionary if obj.kind_of?(HexaPDF::Dictionary) || obj.kind_of?(Hash)
+    klass.new(obj, oid: 1)
   end
 
   def delete(_obj)