hexapdf 0.1.0

data/test/hexapdf/type/test_file_specification.rb

@@ -0,0 +1,148 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'tempfile'
+require 'stringio'
+require 'hexapdf/type/file_specification'
+require 'hexapdf/document'
+
+describe HexaPDF::Type::FileSpecification::EFDictionary do
+  it "uses a custom type" do
+    obj = HexaPDF::Type::FileSpecification::EFDictionary.new({})
+    assert_equal(:XXFilespecEFDictionary, obj.type)
+  end
+end
+
+describe HexaPDF::Type::FileSpecification do
+  before do
+    @doc = HexaPDF::Document.new
+    @obj = HexaPDF::Type::FileSpecification.new({}, document: @doc)
+  end
+
+  it "can be asked whether it is a URL or a file" do
+    refute(@obj.url?)
+    @obj[:FS] = :URL
+    assert(@obj.url?)
+  end
+
+  describe "path" do
+    it "returns the first useable file spec string" do
+      @obj[:DOS] = 'hälo'.b
+      assert_equal('hälo'.b, @obj.path)
+
+      @obj[:UF] = 'hälo'
+      assert_equal('hälo', @obj.path)
+    end
+
+    it "unescapes the path string according to the PDF spec" do
+      @obj[:F] = "dir/in\\/out\\too"
+      assert_equal('dir/in/out/too', @obj.path)
+    end
+  end
+
+  describe "path=" do
+    it "only sets /UF and /F, deleting /Mac, /Unix, /DOS entries if they exist" do
+      @obj[:Unix] = @obj[:Mac] = @obj[:DOS] = 'a'
+      @obj.path = 'file/test'
+      assert_equal('file/test', @obj[:UF])
+      assert_equal('file/test', @obj[:F])
+      refute(@obj.key?(:Unix))
+      refute(@obj.key?(:Mac))
+      refute(@obj.key?(:DOS))
+    end
+
+    it 'resets the /FS value' do
+      @obj[:FS] = :Something
+      @obj.path = 'file'
+      refute(@obj.key?(:FS))
+    end
+  end
+
+  describe "url=" do
+    it "sets the path and the file system entry" do
+      url = 'http://example.com/some?test=ing#done'
+      @obj.url = url
+      assert_equal(url, @obj.path)
+      assert(@obj.url?)
+    end
+
+    it "fails if the provided string is not a valid URL" do
+      assert_raises(HexaPDF::Error) { @obj.url = "a false \\ URL" }
+    end
+  end
+
+  describe "embedded_file?" do
+    it "checks whether the specification has an embedded file" do
+      refute(@obj.embedded_file?)
+      @obj[:EF] = {UF: {}}
+      assert(@obj.embedded_file?)
+    end
+  end
+
+  describe "embedded_file_stream" do
+    it "returns the associated embedded file stream" do
+      assert_nil(@obj.embedded_file_stream)
+      @obj[:EF] = {F: 'data'}
+      assert_equal('data', @obj.embedded_file_stream)
+    end
+  end
+
+  describe "embed/unembed" do
+    before do
+      @file = Tempfile.new('file-embed-test')
+      @file.write("embed-test")
+      @file.close
+    end
+
+    after do
+      @file.unlink
+    end
+
+    it "requires the name argument when given an IO object" do
+      assert_raises(ArgumentError) { @obj.embed(StringIO.new) }
+    end
+
+    it "embeds the given file and registers it with the global name registry" do
+      stream = @obj.embed(@file.path)
+      assert_equal(stream, @obj[:EF][:UF])
+      assert_equal(stream, @obj[:EF][:F])
+      assert_equal(File.basename(@file.path), @obj.path)
+      assert_equal(@obj, @doc.catalog[:Names][:EmbeddedFiles].find_entry(@obj.path))
+      assert_equal(:FlateDecode, stream[:Filter])
+      assert_equal('embed-test', stream.stream)
+    end
+
+    it "embeds the given IO object" do
+      @file.open
+      stream = @obj.embed(@file, name: 'test')
+      assert_equal('embed-test', stream.stream)
+
+      stream = @obj.embed(StringIO.new('test'), name: 'test')
+      assert_equal('test', stream.stream)
+    end
+
+    it "allows overriding the name" do
+      @obj.embed(@file.path, name: 'test')
+      assert_equal('test', @obj.path)
+      assert_equal(@obj, @doc.catalog[:Names][:EmbeddedFiles].find_entry('test'))
+    end
+
+    it "doesn't register the embedded file if instructed to do so" do
+      @obj.embed(@file.path, name: 'test', register: false)
+      assert_nil(@doc.catalog[:Names])
+    end
+
+    it "replaces the value of an already registered name" do
+      (@doc.catalog[:Names] ||= {})[:EmbeddedFiles] = {}
+      @doc.catalog[:Names][:EmbeddedFiles].add_entry('test', 'data')
+      @obj.embed(@file.path, name: 'test')
+      assert_equal(@obj, @doc.catalog[:Names][:EmbeddedFiles].find_entry('test'))
+    end
+
+    it "unembeds an already embedded file before embedding the new one" do
+      @obj.embed(@file.path, name: 'test1')
+      @obj.embed(@file.path, name: 'test2')
+      assert_equal([['test2', @obj]], @doc.catalog[:Names][:EmbeddedFiles].each_entry.to_a)
+    end
+  end
+end

data/test/hexapdf/type/test_font.rb

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/font'
+
+describe HexaPDF::Type::Font do
+  before do
+    @doc = HexaPDF::Document.new
+    cmap = @doc.add({}, stream: <<-EOF)
+      2 beginbfchar
+      <20> <0041>
+      <22> <0042>
+      endbfchar
+    EOF
+    @font = @doc.add({Type: :Font, BaseFont: :TestFont, ToUnicode: cmap})
+  end
+
+  it "must always be an indirect" do
+    assert(@font.must_be_indirect?)
+  end
+
+  describe "to_utf" do
+    it "uses the /ToUnicode CMap if it is available" do
+      assert_equal("A", @font.to_utf8(32))
+      assert_equal("B", @font.to_utf8(34))
+      assert_equal("", @font.to_utf8(0))
+    end
+
+    it "returns an empty string if no /ToUnicode CMap is available" do
+      @font.delete(:ToUnicode)
+      assert_equal("", @font.to_utf8(32))
+    end
+  end
+end

data/test/hexapdf/type/test_font_descriptor.rb

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/font_descriptor'
+
+describe HexaPDF::Type::FontDescriptor do
+  before do
+    @doc = HexaPDF::Document.new
+    @font_desc = @doc.add(Type: :FontDescriptor, FontName: :Test, Flags: 0b1001001, ItalicAngle: 10)
+  end
+
+  describe "flags" do
+    it "returns all flags" do
+      assert_equal([:fixed_pitch, :script, :italic], @font_desc.flags)
+    end
+  end
+
+  describe "flagged?" do
+    it "returns true if the given flag is set" do
+      assert(@font_desc.flagged?(:fixed_pitch))
+      refute(@font_desc.flagged?(:serif))
+    end
+
+    it "raises an error if an unknown flag name is provided" do
+      assert_raises(ArgumentError) { @font_desc.flagged?(:unknown) }
+    end
+  end
+
+  describe "flag" do
+    it "sets the given flag bits" do
+      @font_desc.flag(:serif)
+      assert_equal([:fixed_pitch, :serif, :script, :italic], @font_desc.flags)
+      @font_desc.flag(:symbolic, clear_existing: true)
+      assert_equal([:symbolic], @font_desc.flags)
+    end
+  end
+
+  describe "validation" do
+    it "fails if more than one of /FontFile{,2,3} are set" do
+      assert(@font_desc.validate {|*args| p args})
+      @font_desc[:FontFile] = @font_desc[:FontFile2] = @doc.add({}, stream: 'test')
+      refute(@font_desc.validate)
+    end
+
+    it "fails if /Descent is not a negative number" do
+      @font_desc[:Descent] = 5
+      refute(@font_desc.validate)
+    end
+  end
+end

data/test/hexapdf/type/test_font_simple.rb

@@ -0,0 +1,190 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/font_simple'
+
+describe HexaPDF::Type::FontSimple do
+  before do
+    @doc = HexaPDF::Document.new
+    cmap = @doc.add({}, stream: <<-EOF)
+      2 beginbfchar
+      <20> <0041>
+      <22> <0042>
+      endbfchar
+    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)
+    @font = @doc.add({Type: :Font, Encoding: :WinAnsiEncoding,
+                      BaseFont: :Embedded, FontDescriptor: font_descriptor, ToUnicode: cmap,
+                      FirstChar: 32, LastChar: 34, Widths: [600, 0, 700]
+                     }, type: HexaPDF::Type::FontSimple)
+  end
+
+  describe "encoding" do
+    it "fails if /Encoding is absent because encoding_from_font is not implemented" do
+      @font.delete(:Encoding)
+      assert_raises(NotImplementedError) { @font.encoding }
+    end
+
+    describe "/Encoding is a name" do
+      it "returns a predefined encoding if /Encoding specifies one" do
+        assert_equal(HexaPDF::Font::Encoding.for_name(:WinAnsiEncoding), @font.encoding)
+      end
+
+      it "fails if /Encoding is an invalid name because encoding_from_font is not implemented" do
+        @font[:Encoding] = :SomethingUnknown
+        assert_raises(NotImplementedError) { @font.encoding }
+      end
+    end
+
+    describe "/Encoding is a dictionary" do
+      before do
+        @font[:Encoding] = {}
+      end
+
+      describe "no /BaseEncoding is specified" do
+        it "fails if the font is embedded because encoding_from_font is not implemented" do
+          @font[:FontDescriptor][:FontFile] = 5
+          assert_raises(NotImplementedError) { @font.encoding }
+        end
+
+        it "fails for a symbolic non-embedded font because encoding_from_font is not implemented" do
+          @font[:FontDescriptor].flag(:symbolic, clear_existing: true)
+          assert_raises(NotImplementedError) { @font.encoding }
+        end
+
+        it "returns the StandardEncoding for a non-symbolic non-embedded font" do
+          @font[:FontDescriptor].flag(clear_existing: true)
+          assert_equal(HexaPDF::Font::Encoding.for_name(:StandardEncoding), @font.encoding)
+        end
+      end
+
+      it "returns the encoding specified by /BaseEncoding" do
+        @font[:Encoding] = {BaseEncoding: :WinAnsiEncoding}
+        assert_equal(HexaPDF::Font::Encoding.for_name(:WinAnsiEncoding), @font.encoding)
+      end
+
+      it "fails if /BaseEncoding is invalid because encoding_from_font is not implemented" do
+        @font[:Encoding] = {BaseEncoding: :SomethingUnknown}
+        assert_raises(NotImplementedError) { @font.encoding }
+      end
+
+      it "returns a difference encoding if /Differences is specified" do
+        @font[:FontDescriptor].flag(clear_existing: true)
+        @font[:Encoding][:Differences] = [32, :A, :B, 34, :Z]
+        refute_equal(HexaPDF::Font::Encoding.for_name(:StandardEncoding), @font.encoding)
+        assert_equal(:A, @font.encoding.name(32))
+        assert_equal(:B, @font.encoding.name(33))
+        assert_equal(:Z, @font.encoding.name(34))
+      end
+
+      it "fails if the /Differences array contains invalid data" do
+        @font[:Encoding][:BaseEncoding] = :WinAnsiEncoding
+        @font[:Encoding][:Differences] = [:B, 32, :A, :B, 34, :Z]
+        assert_raises(HexaPDF::Error) { @font.encoding }
+
+        @font[:Encoding][:Differences] = [32, "data", :A, :B, 34, :Z]
+        assert_raises(HexaPDF::Error) { @font.encoding }
+      end
+    end
+
+    it "fails if /Encoding contains an invalid value" do
+      @font[:Encoding] = 5
+      assert_raises(HexaPDF::Error) { @font.encoding }
+    end
+  end
+
+  describe "decode" do
+    it "just returns the bytes of the string since this is a simple 1-byte-per-code font" do
+      assert_equal([65, 66], @font.decode("AB"))
+    end
+  end
+
+  describe "to_utf" do
+    it "uses a /ToUnicode CMap if it is available" do
+      assert_equal("A", @font.to_utf8(32))
+    end
+
+    it "uses the font's encoding to map the code to an UTF-8 string if the /ToUnicode is missing" do
+      @font.delete(:ToUnicode)
+      assert_equal(" ", @font.to_utf8(32))
+    end
+
+    it "returns an empty string if no correct mapping could be found" do
+      @font.delete(:ToUnicode)
+      assert_equal("", @font.to_utf8(0))
+    end
+  end
+
+  describe "writing_mode" do
+    it "is always horizontal" do
+      assert_equal(:horizontal, @font.writing_mode)
+    end
+  end
+
+  describe "width" do
+    it "returns the glyph width for a valid code point" do
+      assert_equal(600, @font.width(32))
+    end
+
+    it "returns the /MissingWidth of a /FontDescriptor if available and the width was not found" do
+      assert_equal(0, @font.width(0))
+      @font[:FontDescriptor][:MissingWidth] = 99
+      assert_equal(99, @font.width(0))
+    end
+
+    it "returns 0 for a missing code point when FontDescriptor is not available" do
+      @font.delete(:FontDescriptor)
+      assert_equal(0, @font.width(0))
+    end
+  end
+
+  describe "bounding_box" do
+    it "returns the bounding box" do
+      assert_equal([0, 1, 2, 3], @font.bounding_box)
+    end
+
+    it "returns nil if no bounding box information can be found" do
+      @font[:FontDescriptor].delete(:FontBBox)
+      assert_nil(@font.bounding_box)
+    end
+  end
+
+  describe "embedded" do
+    it "returns true if the font is embedded" do
+      refute(@font.embedded?)
+      @font[:FontDescriptor][:FontFile] = 5
+      assert(@font.embedded?)
+    end
+  end
+
+  describe "symbolic?" do
+    it "return true if the font is symbolic" do
+      @font[:FontDescriptor].flag(clear_existing: true)
+      refute(@font.symbolic?)
+
+      @font[:FontDescriptor].flag(:symbolic)
+      assert(@font.symbolic?)
+    end
+
+    it "returns nil if it cannot be determined whether the font is symbolic" do
+      @font.delete(:FontDescriptor)
+      assert_nil(@font.symbolic?)
+    end
+  end
+
+  describe "validation" do
+    it "validates the existence of required keys" do
+      assert(@font.validate)
+      @font.delete(:FirstChar)
+      refute(@font.validate)
+    end
+
+    it "validates the lengths of the /Widths field" do
+      @font[:Widths] = [65]
+      refute(@font.validate)
+    end
+  end
+end

data/test/hexapdf/type/test_font_type1.rb

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

data/test/hexapdf/type/test_form.rb

@@ -0,0 +1,60 @@
+# -*- 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({}, subtype: :Form)
+  end
+
+  describe "box" do
+    it "returns the /BBox entry" do
+      @form[:BBox] = :media
+      assert_equal(:media, @form.box)
+    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
+  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({}, 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)
+    end
+  end
+end

data/test/hexapdf/type/test_info.rb

@@ -0,0 +1,14 @@
+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
+
+  it "uses a custom type" do
+    obj = HexaPDF::Type::Info.new({})
+    assert_equal(:XXInfo, obj.type)
+  end
+end

data/test/hexapdf/type/test_names.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'hexapdf/type/names'
+
+describe HexaPDF::Type::Names do
+  it "uses a custom type" do
+    obj = HexaPDF::Type::Names.new({})
+    assert_equal(:XXNames, obj.type)
+  end
+end