hexapdf 0.11.6 → 0.12.1

data/lib/hexapdf/writer.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2019 Thomas Leitner
+# Copyright (C) 2014-2020 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

data/lib/hexapdf/xref_section.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2019 Thomas Leitner
+# Copyright (C) 2014-2020 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

data/test/hexapdf/content/common.rb

@@ -29,10 +29,10 @@ module TestHelper
   end
 
   # Asserts that the content string contains the operators.
-  def assert_operators(content, operators, only_names: false)
+  def assert_operators(content, operators, only_names: false, range: 0..-1)
     processor = TestHelper::OperatorRecorder.new
     HexaPDF::Content::Parser.new.parse(content, processor)
-    result = processor.recorded_ops
+    result = processor.recorded_ops[range]
     result.map!(&:first) if only_names
     assert_equal(operators, result)
   end

data/test/hexapdf/content/test_color_space.rb

@@ -27,6 +27,10 @@ module CommonColorSpaceTests
     assert_equal(@color_space_family, @color_space.family)
   end
 
+  it "the color space returns the correct color space definition" do
+    assert_equal(@color_space_definition, @color_space.definition)
+  end
+
   it "the color responds to :components" do
     assert(@color.respond_to?(:components))
   end
@@ -43,14 +47,70 @@ module CommonColorSpaceTests
     assert_equal(@components, @color_space.color(*@components).components)
   end
 
+  it "normalizes the colors when using the #color method" do
+    return unless defined?(@colors)
+    assert_equal(@components, @color_space.color(*@colors).components)
+  end
+
+  it "doesn't normalize the colors when using the #prenormalized_color method" do
+    return unless defined?(@colors)
+    assert_equal(@colors, @color_space.prenormalized_color(*@colors).components)
+  end
+
+end
+
+describe HexaPDF::Content::ColorSpace do
+  before do
+    @class = HexaPDF::Content::ColorSpace
+  end
+
+  describe "self.device_color_from_specification" do
+    it "works for gray values" do
+      assert_equal([0.2], @class.device_color_from_specification(51).components)
+    end
+
+    it "works for RGB values" do
+      assert_equal([0.2, 1, 0], @class.device_color_from_specification(51, 255, 0).components)
+    end
+
+    it "works for RGB values given as string" do
+      assert_equal([0.2, 1, 0], @class.device_color_from_specification("33FF00").components)
+    end
+
+    it "works for CMYK values" do
+      assert_equal([0.51, 0.9, 1, 0.5],
+                   @class.device_color_from_specification(51, 90, 100, 50).components)
+    end
+
+    it "works when an array is given" do
+      assert_equal([0.2], @class.device_color_from_specification([51]).components)
+    end
+  end
+
+  it "returns a device color object for prenormalized color values" do
+    assert_equal([5, 6, 7], @class.prenormalized_device_color([5, 6, 7]).components)
+  end
+
+  describe "self.for_components" do
+    it "returns the correct device color space name" do
+      assert_equal(:DeviceGray, @class.for_components([1]))
+      assert_equal(:DeviceRGB, @class.for_components([1, 2, 3]))
+      assert_equal(:DeviceCMYK, @class.for_components([1, 2, 3, 4]))
+    end
+
+    it "fails if an array with an invalid length is passed" do
+      assert_raises(ArgumentError) { @class.for_components([]) }
+    end
+  end
 end
 
 describe HexaPDF::Content::ColorSpace::Universal do
   include CommonColorSpaceTests
 
   before do
-    @color_space = HexaPDF::Content::ColorSpace::Universal.new([:test])
+    @color_space = HexaPDF::Content::ColorSpace::Universal.new([:test, :value])
     @color_space_family = :test
+    @color_space_definition = [:test, :value]
     @color = @color_space.default_color
     @other_color = @color_space.color(128, 5, 6, 7, 8)
     @components = [5, 6, 7, 8]
@@ -58,7 +118,7 @@ describe HexaPDF::Content::ColorSpace::Universal do
 
   it "can be compared to another universal color space" do
     other = HexaPDF::Content::ColorSpace::Universal.new([:other])
-    same = HexaPDF::Content::ColorSpace::Universal.new([:test])
+    same = HexaPDF::Content::ColorSpace::Universal.new([:test, :value])
     assert_equal(same, @color_space)
     refute_equal(other, @color_space)
   end
@@ -69,10 +129,11 @@ describe HexaPDF::Content::ColorSpace::DeviceRGB do
 
   before do
     @color_space = HexaPDF::Content::ColorSpace::DeviceRGB.new
-    @color_space_family = :DeviceRGB
+    @color_space_family = @color_space_definition = :DeviceRGB
     @color = @color_space.default_color
     @other_color = @color_space.color(128, 0, 0)
-    @components = [0.5, 0.2, 0.3]
+    @colors = [128, 0, 255]
+    @components = @colors.map {|c| c.to_f / 255 }
   end
 end
 
@@ -81,10 +142,11 @@ describe HexaPDF::Content::ColorSpace::DeviceCMYK do
 
   before do
     @color_space = HexaPDF::Content::ColorSpace::DeviceCMYK.new
-    @color_space_family = :DeviceCMYK
+    @color_space_family = @color_space_definition = :DeviceCMYK
     @color = @color_space.default_color
     @other_color = @color_space.color(128, 0, 0, 128)
-    @components = [0.1, 0.2, 0.3, 0.4]
+    @colors = [0, 20, 40, 80]
+    @components = [0.0, 0.2, 0.4, 0.8]
   end
 end
 
@@ -93,9 +155,10 @@ describe HexaPDF::Content::ColorSpace::DeviceGray do
 
   before do
     @color_space = HexaPDF::Content::ColorSpace::DeviceGray.new
-    @color_space_family = :DeviceGray
+    @color_space_family = @color_space_definition =  :DeviceGray
     @color = @color_space.default_color
     @other_color = @color_space.color(128)
-    @components = [0.1]
+    @colors = [128]
+    @components = [128.0 / 255]
   end
 end

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_security_handler.rb

@@ -13,6 +13,10 @@ describe HexaPDF::Encryption::EncryptionDictionary do
     @dict[:V] = 1
   end
 
+  it "must be an indirect object" do
+    assert(@dict.must_be_indirect?)
+  end
+
   it "validates the /V value" do
     @dict[:V] = 1
     assert(@dict.validate)

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