hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/type/test_font_type0.rb

@@ -0,0 +1,120 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/font_type0'
+
+describe HexaPDF::Type::FontType0 do
+  before do
+    @doc = HexaPDF::Document.new
+    fd = @doc.add({Type: :FontDescriptor, FontBBox: [0, 1, 2, 3]})
+    @cid_font = @doc.wrap({Type: :Font, Subtype: :CIDFontType2, W: [633, [100]], FontDescriptor: fd,
+                           CIDSystemInfo: {Registry: 'Adobe', Ordering: 'Japan1', Supplement: 1}})
+    @font = @doc.wrap({Type: :Font, Subtype: :Type0, Encoding: :H, DescendantFonts: [@cid_font]})
+  end
+
+  it "returns the correct writing mode" do
+    assert_equal(:horizontal, @font.writing_mode)
+    font = @doc.wrap({Type: :Font, Subtype: :Type0, Encoding: :V})
+    assert_equal(:vertical, font.writing_mode)
+  end
+
+  it "resolves the descendant font object correctly" do
+    assert_equal(@cid_font, @font.descendant_font)
+    @doc.clear_cache
+    @font[:DescendantFonts] = [@cid_font.value]
+    assert_equal(@cid_font.value, @font.descendant_font.value)
+  end
+
+  it "uses the descendant font for getting the width of a code point" do
+    assert_equal(100, @font.width(0x2121))
+  end
+
+  it "uses the descendant font for getting the bounding box" do
+    assert_equal([0, 1, 2, 3], @font.bounding_box)
+  end
+
+  it "uses the descendant font for determining whether the font is embedded" do
+    refute(@font.embedded?)
+    @cid_font[:FontDescriptor][:FontFile2] = 5
+    assert(@font.embedded?)
+  end
+
+  it "uses the descendant font for returning the embedded font file" do
+    @cid_font[:FontDescriptor][:FontFile2] = 5
+    assert_equal(5, @font.font_file)
+  end
+
+  describe "word_spacing_applicable?" do
+    it "returns false if code point 32 is not a single-byte code point" do
+      refute(@font.word_spacing_applicable?)
+    end
+
+    it "returns true if code point 32 is a single-byte code point" do
+      @font[:Encoding] = @doc.wrap({}, stream: <<-EOF)
+        begincodespacerange
+        <00> <ff>
+        endcodespacerange
+      EOF
+      assert(@font.word_spacing_applicable?)
+    end
+  end
+
+  describe "handling of /Encoding value" do
+    it "can use predefined CMaps" do
+      assert_equal([0x2121], @font.decode("\x21\x21"))
+    end
+
+    it "can use custom CMaps" do
+      @font[:Encoding] = @doc.wrap({}, stream: <<-EOF)
+      begincodespacerange
+      <00> <ff>
+      endcodespacerange
+      EOF
+      assert_equal([0x41], @font.decode("\x41"))
+    end
+
+    it "raises an error if the /Encoding value is invalid" do
+      @font.delete(:Encoding)
+      assert_raises(HexaPDF::Error) { @font.decode("a") }
+    end
+  end
+
+  describe "decode" do
+    it "allows reading CIDs from string using the encoding CMap" do
+      assert_equal([0x2121, 0x7e7e], @font.decode("\x21\x21\x7e\x7e"))
+    end
+
+    it "fails if the string contains invalid codes" do
+      assert_raises(HexaPDF::Error) { @font.decode("a") }
+    end
+  end
+
+  describe "to_utf" do
+    it "uses the /ToUnicode CMap if it is available" do
+      @font[:ToUnicode] = @doc.add({}, stream: <<-EOF)
+      2 beginbfchar
+      <20> <0041>
+      endbfchar
+      EOF
+      assert_equal("A", @font.to_utf8(32))
+    end
+
+    describe "it uses a predefined UCS2 CMap" do
+      it "for predefined CMaps except Identity-H/-V" do
+        assert_equal("?", @font.to_utf8(32))
+      end
+
+      it "for CMaps with predefined character collections" do
+        @font[:Encoding] = @doc.add({}, stream: "")
+        assert_equal("?", @font.to_utf8(32))
+      end
+    end
+
+    it "calls the configured proc if no mapping is available" do
+      @font[:Encoding] = :"Identity-H"
+      @cid_font[:CIDSystemInfo][:Registry] = :Unknown
+      assert_raises(HexaPDF::Error) { @font.to_utf8(32) }
+    end
+  end
+end

data/test/hexapdf/type/test_font_type1.rb

@@ -0,0 +1,142 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/font_type1'
+
+describe HexaPDF::Type::FontType1::StandardFonts do
+  before do
+    @obj = HexaPDF::Type::FontType1::StandardFonts
+  end
+
+  it "checks whether a given name corresponds to a standard font via #standard_font?" do
+    assert(@obj.standard_font?(:"Times-Roman"))
+    assert(@obj.standard_font?(:TimesNewRoman))
+    refute(@obj.standard_font?(:LibreSans))
+  end
+
+  it "returns the standard PDF name for an alias via #standard_name" do
+    assert_equal(:"Times-Roman", @obj.standard_name(:TimesNewRoman))
+  end
+
+  describe "font" do
+    it "returns the Type1 font object for a given standard name" do
+      font = @obj.font(:"Times-Roman")
+      assert_equal("Times Roman", font.full_name)
+    end
+
+    it "caches the font for reuse" do
+      font = @obj.font(:"Times-Roman")
+      assert_same(font, @obj.font(:"Times-Roman"))
+    end
+
+    it "returns nil if the given name doesn't belong to a standard font" do
+      refute_nil(@obj.font(:TimesNewRoman))
+    end
+  end
+end
+
+describe HexaPDF::Type::FontType1 do
+  before do
+    @doc = HexaPDF::Document.new
+    @font = @doc.add({Type: :Font, Subtype: :Type1, Encoding: :WinAnsiEncoding,
+                      BaseFont: :"Times-Roman"})
+
+    font_file = @doc.add({}, stream: <<-EOF)
+      /Encoding 256 array
+      0 1 255 {1 index exch /.notdef put} for
+      dup 32 /A put
+      dup 34 /B put
+      readonly def
+    EOF
+    font_descriptor = @doc.add({Type: :FontDescriptor, FontName: :Embedded, Flags: 0b100,
+                                FontBBox: [0, 1, 2, 3], ItalicAngle: 0, Ascent: 900,
+                                Descent: -100, CapHeight: 800, StemV: 20, FontFile: font_file})
+    @embedded_font = @doc.add({Type: :Font, Subtype: :Type1, Encoding: :WinAnsiEncoding,
+                               BaseFont: :Embedded, FontDescriptor: font_descriptor,
+                               FirstChar: 32, LastChar: 34, Widths: [600, 0, 700]})
+  end
+
+  it "can create a usable font wrapper for the standard fonts" do
+    wrapper = @font.font_wrapper
+    assert(wrapper)
+    assert_same(@font, wrapper.pdf_object)
+    assert_equal(@font[:BaseFont], wrapper.wrapped_font.font_name.intern)
+    assert_same(wrapper, @font.font_wrapper)
+  end
+
+  describe "encoding" do
+    it "returns the the standard font's encoding" do
+      @font.delete(:Encoding)
+      assert_equal(HexaPDF::Font::Encoding.for_name(:StandardEncoding), @font.encoding)
+    end
+
+    it "uses the encoding of the embedded font when necessary" do
+      @embedded_font.delete(:Encoding)
+      assert_equal({32 => :A, 34 => :B}, @embedded_font.encoding.code_to_name)
+    end
+
+    it "fails if the encoding needs to be read from the font but is is not embedded" do
+      @embedded_font.delete(:Encoding)
+      @embedded_font[:FontDescriptor].delete(:FontFile)
+      assert_raises(HexaPDF::Error) { @embedded_font.encoding }
+    end
+  end
+
+  describe "width" do
+    it "returns the glyph width when using a standard font" do
+      assert_equal(250, @font.width(32))
+    end
+
+    it "defers to its superclass for all other cases" do
+      assert_equal(600, @embedded_font.width(32))
+    end
+  end
+
+  describe "bounding_box" do
+    it "returns the bounding box for a standard font" do
+      font = HexaPDF::Type::FontType1::StandardFonts.font(:"Times-Roman")
+      assert_equal(font.bounding_box, @font.bounding_box)
+    end
+
+    it "defers to its superclass for all other cases" do
+      assert_equal([0, 1, 2, 3], @embedded_font.bounding_box)
+    end
+
+    it "returns nil for non-standard fonts without bounding box information" do
+      @embedded_font[:FontDescriptor].delete(:FontBBox)
+      assert_nil(@embedded_font.bounding_box)
+    end
+  end
+
+  describe "symbolic?" do
+    it "return true for the standard fonts Symbol and ZapfDingbats" do
+      @font[:BaseFont] = :Symbol
+      assert(@font.symbolic?)
+
+      @font[:BaseFont] = :ZapfDingbats
+      assert(@font.symbolic?)
+    end
+
+    it "defers to its superclass for all other cases" do
+      assert(@embedded_font.symbolic?)
+    end
+
+    it "returns nil if it cannot be determined whether the font is symbolic" do
+      @embedded_font.delete(:FontDescriptor)
+      assert_nil(@embedded_font.symbolic?)
+    end
+  end
+
+  describe "validation" do
+    it "allows empty fields for standard fonts" do
+      assert(@font.validate)
+    end
+
+    it "requires that the FontDescriptor key is set for non-standard fonts" do
+      assert(@embedded_font.validate)
+      @embedded_font.delete(:FontDescriptor)
+      refute(@embedded_font.validate)
+    end
+  end
+end

data/test/hexapdf/type/test_font_type3.rb

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/font_type3'
+
+describe HexaPDF::Type::FontType3 do
+  before do
+    @doc = HexaPDF::Document.new
+    @font = @doc.add({Type: :Font, Subtype: :Type3, Encoding: :WinAnsiEncoding,
+                      FirstChar: 32, LastChar: 34, Widths: [600, 0, 700],
+                      FontBBox: [0, 0, 100, 100], FontMatrix: [1, 0, 0, 1, 0, 0],
+                      CharProcs: {}})
+  end
+
+  describe "validation" do
+    it "works for valid objects" do
+      assert(@font.validate)
+    end
+
+    it "fails if the Encoding key is missing" do
+      @font.delete(:Encoding)
+      refute(@font.validate)
+    end
+  end
+end

data/test/hexapdf/type/test_form.rb

@@ -0,0 +1,120 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../content/common'
+require 'hexapdf/document'
+require 'hexapdf/type/form'
+
+describe HexaPDF::Type::Form do
+  before do
+    @doc = HexaPDF::Document.new
+    @form = @doc.wrap({}, type: :XObject, subtype: :Form)
+  end
+
+  describe "box" do
+    before do
+      @form[:BBox] = [10, 10, 110, 60]
+    end
+
+    it "returns the /BBox entry" do
+      assert_equal([10, 10, 110, 60], @form.box.value)
+    end
+
+    it "returns the box's width" do
+      assert_equal(100, @form.width)
+    end
+
+    it "returns the box's height" do
+      assert_equal(50, @form.height)
+    end
+  end
+
+  describe "contents" do
+    it "returns a duplicate of the stream" do
+      @form.stream = 'test'
+      assert_equal(@form.stream, @form.contents)
+      @form.contents.gsub!(/test/, 'other')
+      assert_equal(@form.stream, @form.contents)
+    end
+  end
+
+  describe "contents=" do
+    it "set the stream contents" do
+      @form.contents = 'test'
+      assert_equal('test', @form.stream)
+    end
+
+    it "clears the cache to make sure that a new canvas can be created" do
+      @form[:BBox] = [0, 0, 100, 100]
+      canvas = @form.canvas
+      @form.contents = ''
+      refute_same(canvas, @form.canvas)
+    end
+  end
+
+  describe "resources" do
+    it "creates the resource dictionary if it is not found" do
+      resources = @form.resources
+      assert_equal(:XXResources, resources.type)
+      assert_equal({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]}, resources.value)
+    end
+
+    it "returns the already used resource dictionary" do
+      @form[:Resources] = {Font: nil}
+      resources = @form.resources
+      assert_equal(:XXResources, resources.type)
+      assert_equal(@form[:Resources], resources)
+    end
+  end
+
+  describe "process_contents" do
+    it "parses the contents and processes it" do
+      @form.stream = '10 w'
+      processor = TestHelper::OperatorRecorder.new
+      @form.process_contents(processor)
+      assert_equal([[:set_line_width, [10]]], processor.recorded_ops)
+      assert_nil(@form[:Resources])
+
+      resources = @form.resources
+      @form.process_contents(processor)
+      assert_same(resources, processor.resources)
+    end
+
+    it "uses the provided resources if it has no resources itself" do
+      resources = @doc.wrap({}, type: :XXResources)
+      processor = TestHelper::OperatorRecorder.new
+      @form.process_contents(processor, original_resources: resources)
+      assert_same(resources, processor.resources)
+    end
+  end
+
+  describe "canvas" do
+    # Asserts that the form's contents contains the operators.
+    def assert_operators(form, operators)
+      processor = TestHelper::OperatorRecorder.new
+      form.process_contents(processor)
+      assert_equal(operators, processor.recorded_ops)
+    end
+
+    it "always returns the same Canvas instance" do
+      @form[:BBox] = [0, 0, 100, 100]
+      canvas = @form.canvas
+      assert_same(canvas, @form.canvas)
+      assert_operators(@form, [])
+    end
+
+    it "always moves the origin to the bottom left corner of the bounding box" do
+      @form[:BBox] = [-10, -5, 100, 300]
+      @form.canvas.line_width = 5
+      assert_operators(@form, [[:save_graphics_state],
+                               [:concatenate_matrix, [1, 0, 0, 1, -10, -5]],
+                               [:set_line_width, [5]],
+                               [:restore_graphics_state]])
+    end
+
+    it "fails if the form XObject already has data" do
+      @form.stream = '10 w'
+      assert_raises(HexaPDF::Error) { @form.canvas }
+    end
+  end
+end

data/test/hexapdf/type/test_image.rb

@@ -0,0 +1,261 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'tempfile'
+require 'hexapdf/document'
+
+describe HexaPDF::Type::Image do
+  before do
+    @jpg = File.join(TEST_DATA_DIR, 'images', 'rgb.jpg')
+    @doc = HexaPDF::Document.new
+  end
+
+  it "returns the width of the image" do
+    @image = @doc.wrap({Type: :XObject, Subtype: :Image, Width: 10})
+    assert_equal(10, @image.width)
+  end
+
+  it "returns the height of the image" do
+    @image = @doc.wrap({Type: :XObject, Subtype: :Image, Height: 10})
+    assert_equal(10, @image.height)
+  end
+
+  describe "info" do
+    before do
+      @image = @doc.wrap({Type: :XObject, Subtype: :Image, Width: 10, Height: 5,
+                          ColorSpace: :DeviceRGB, BitsPerComponent: 4})
+    end
+
+    it "uses the Width, Height and BitsPerComponent values" do
+      assert_equal(10, @image.info.width)
+      assert_equal(5, @image.info.height)
+      assert_equal(4, @image.info.bits_per_component)
+    end
+
+    it "determines the type and extension based on the stream filter" do
+      @image.set_filter(:DCTDecode)
+      info = @image.info
+      assert_equal(:jpeg, info.type)
+      assert_equal('jpg', info.extension)
+      assert(info.writable)
+
+      @image.set_filter(:JPXDecode)
+      info = @image.info
+      assert_equal(:jp2, info.type)
+      assert_equal('jpx', info.extension)
+      assert(info.writable)
+
+      @image.set_filter(:JBIG2Decode)
+      info = @image.info
+      assert_equal(:jbig2, info.type)
+      refute(info.writable)
+
+      @image.set_filter(:CCITTFaxDecode)
+      info = @image.info
+      assert_equal(:ccitt, info.type)
+      refute(info.writable)
+
+      @image.set_filter(nil)
+      info = @image.info
+      assert_equal(:png, @image.info.type)
+      assert_equal('png', info.extension)
+      assert(info.writable)
+    end
+
+    it "determines the color space, indexed and components values using the ColorSpace value" do
+      @image[:ColorSpace] = :DeviceGray
+      info = @image.info
+      assert_equal(:gray, info.color_space)
+      assert_equal(1, info.components)
+      refute(info.indexed)
+      assert(info.writable)
+
+      @image[:ColorSpace] = [:CalGray, {WhitePoint: [1, 1, 1]}]
+      info = @image.info
+      assert_equal(:gray, info.color_space)
+      assert_equal(1, info.components)
+      refute(info.indexed)
+      assert(info.writable)
+
+      @image[:ColorSpace] = :DeviceRGB
+      info = @image.info
+      assert_equal(:rgb, info.color_space)
+      assert_equal(3, info.components)
+      refute(info.indexed)
+      assert(info.writable)
+
+      @image[:ColorSpace] = [:CalRGB, {WhitePoint: [1, 1, 1]}]
+      info = @image.info
+      assert_equal(:rgb, info.color_space)
+      assert_equal(3, info.components)
+      refute(info.indexed)
+      assert(info.writable)
+
+      @image[:ColorSpace] = :DeviceCMYK
+      @image[:Filter] = :DCTDecode
+      info = @image.info
+      assert_equal(:cmyk, info.color_space)
+      assert_equal(4, info.components)
+      refute(info.indexed)
+      assert(info.writable)
+
+      @image[:ColorSpace] = :DeviceCMYK
+      @image[:Filter] = :FlateDecode
+      info = @image.info
+      assert_equal(:cmyk, info.color_space)
+      assert_equal(4, info.components)
+      refute(info.indexed)
+      refute(info.writable)
+
+      @image[:ColorSpace] = [:Indexed, :DeviceRGB, 1, "\x80".b * 6]
+      info = @image.info
+      assert_equal(:rgb, info.color_space)
+      assert_equal(3, info.components)
+      assert(info.indexed)
+      assert(info.writable)
+
+      @image[:ColorSpace] = :ICCBased
+      info = @image.info
+      assert_equal(:other, info.color_space)
+      assert_equal(-1, info.components)
+    end
+
+    it "processes the SMask entry" do
+      @image[:SMask] = :something
+      info = @image.info
+      refute(info.writable)
+    end
+  end
+
+  describe "write" do
+    before do
+      @file = Tempfile.new(['hexapdf-image-write-test', '.png'])
+    end
+
+    after do
+      @file.unlink
+    end
+
+    `which pngcheck 2>&1`
+    PNG_CHECK_AVAILABLE = $?.exitstatus == 0
+
+    `which pngtopnm 2>&1`
+    PNG_COMPARE_AVAILABLE = $?.exitstatus == 0
+
+    def assert_valid_png(filename, original = nil)
+      if PNG_CHECK_AVAILABLE
+        result = `pngcheck -q #{filename}`
+        assert(result.empty?, "pngcheck error: #{result}")
+      else
+        skip("Skipping PNG output validity check because pngcheck executable is missing")
+      end
+      if PNG_COMPARE_AVAILABLE
+        assert_equal(`pngtopnm #{original}`, `pngtopnm #{filename}`) if original
+      else
+        skip("Skipping PNG output comparison check because pngtopnm executable is missing")
+      end
+    end
+
+    it "can write to an IO" do
+      io = StringIO.new(''.b)
+      image = @doc.images.add(@jpg)
+      image.write(io)
+      assert_equal(File.binread(@jpg), io.string)
+    end
+
+    it "writes JPEG images to a file with .jpg extension" do
+      begin
+        file = Tempfile.new(['hexapdf-image-write-test', '.jpg'])
+        image = @doc.images.add(@jpg)
+        image.write(file.path)
+        assert_equal(File.binread(@jpg), File.binread(file.path))
+      ensure
+        file.unlink
+      end
+    end
+
+    it "writes JPEG2000 images to a file with .jpx extension" do
+      begin
+        file = Tempfile.new(['hexapdf-image-write-test', '.jpx'])
+        image = @doc.images.add(@jpg)
+        image.set_filter(:JPXDecode) # fake it
+        image.write(file.path)
+        assert_equal(File.binread(@jpg), File.binread(file.path))
+      ensure
+        file.unlink
+      end
+    end
+
+    Dir.glob(File.join(TEST_DATA_DIR, 'images', '*.png')).each do |png_file|
+      next if png_file =~ /alpha/
+      it "writes #{File.basename(png_file)} correctly as PNG file" do
+        image = @doc.images.add(png_file)
+        if png_file =~ /greyscale-1bit.png/ # force use of arrays for one image
+          image[:DecodeParms] = [image[:DecodeParms]]
+          image[:Filter] = [image[:Filter]]
+        end
+        image.write(@file.path)
+        assert_valid_png(@file.path, png_file)
+
+        image.delete(:DecodeParms) # force re-encoding of stream
+        image.write(@file.path)
+        assert_valid_png(@file.path, png_file)
+
+        new_image = @doc.images.add(@file.path)
+
+        assert_equal(image[:Width], new_image[:Width], "file: #{png_file}")
+        assert_equal(image[:Height], new_image[:Height], "file: #{png_file}")
+        assert_equal(image[:BitsPerComponent], new_image[:BitsPerComponent], "file: #{png_file}")
+        if image[:Mask]
+          assert_equal(image[:Mask].value, new_image[:Mask].value, "file: #{png_file}")
+        else
+          assert_nil(new_image[:Mask], "file: #{png_file}")
+        end
+        assert_equal(image.stream, new_image.stream, "file: #{png_file}")
+
+        # ColorSpace is currently not always preserved, e.g. with CalRGB
+        if Array(image[:ColorSpace]).first == :Indexed
+          assert_equal(image[:ColorSpace][2], new_image[:ColorSpace][2], "file: #{png_file}")
+
+          img_palette = image[:ColorSpace][3]
+          img_palette = img_palette.stream if img_palette.respond_to?(:stream)
+          new_img_palette = new_image[:ColorSpace][3]
+          new_img_palette = new_img_palette.stream if new_img_palette.respond_to?(:stream)
+          assert_equal(img_palette, new_img_palette, "file: #{png_file}")
+        end
+      end
+    end
+
+    it "works for greyscale indexed images" do
+      image = @doc.add({Type: :XObject, Subtype: :Image, Width: 2, Height: 2, BitsPerComponent: 2,
+                        ColorSpace: [:Indexed, :DeviceGray, 3, "\x00\x40\x80\xFF".b]})
+      image.stream = HexaPDF::StreamData.new(filter: :ASCIIHexDecode) { "10 B0".b }
+      image.write(@file.path)
+      assert_valid_png(@file.path)
+
+      new_image = @doc.images.add(@file.path)
+      assert_equal([:Indexed, :DeviceRGB, 3, "\x00\x00\x00\x40\x40\x40\x80\x80\x80\xFF\xFF\xFF".b],
+                   new_image[:ColorSpace].value)
+      assert_equal(image.stream, new_image.stream)
+    end
+
+    it "fails if an unsupported stream filter is used" do
+      image = @doc.images.add(@jpg)
+      image.set_filter([:DCTDecode, :ASCIIHexDecode])
+      assert_raises(HexaPDF::Error) { image.write(@file) }
+    end
+
+    it "fails if an unsupported colorspace is used" do
+      image = @doc.add({Type: :XObject, Subtype: :Image, Width: 1, Height: 1, BitsPerComponent: 8,
+                        ColorSpace: :ICCBased})
+      assert_raises(HexaPDF::Error) { image.write(@file) }
+    end
+
+    it "fails if an indexed image with an unsupported colorspace is used" do
+      image = @doc.add({Type: :XObject, Subtype: :Image, Width: 1, Height: 1, BitsPerComponent: 8,
+                        ColorSpace: [:Indexed, :ICCBased, 0, "0"]})
+      assert_raises(HexaPDF::Error) { image.write(@file) }
+    end
+  end
+end

data/test/hexapdf/type/test_info.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'hexapdf/type/info'
+
+describe HexaPDF::Type::Info do
+  it "must always be indirect" do
+    obj = HexaPDF::Type::Info.new({})
+    assert(obj.must_be_indirect?)
+  end
+end