hexapdf 0.15.7 → 0.17.0

data/test/hexapdf/type/test_font_type0.rb

@@ -1,120 +0,0 @@
-# -*- 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

@@ -1,142 +0,0 @@
-# -*- 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

@@ -1,26 +0,0 @@
-# -*- 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

@@ -1,120 +0,0 @@
-# -*- 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

@@ -1,261 +0,0 @@
-# -*- 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

@@ -1,9 +0,0 @@
-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