hexapdf 0.1.0 → 0.2.0

data/test/hexapdf/font/true_type/table/test_head.rb

@@ -33,22 +33,6 @@ describe HexaPDF::Font::TrueType::Table::Head do
       assert_equal(0, table.index_to_loc_format)
     end
 
-    it "loads some default values if no entry is given" do
-      table = HexaPDF::Font::TrueType::Table::Head.new(@file)
-      assert_equal(1.0, table.version.to_f)
-      assert_equal(1.0, table.font_revision.to_f)
-      assert_equal(0, table.checksum_adjustment)
-      assert_equal(0, table.flags)
-      assert_equal(64, table.units_per_em)
-      assert(Time.now - table.created < 2)
-      assert(Time.now - table.created < 2)
-      assert_equal([0, 0, 0, 0], table.bbox)
-      assert_equal(0, table.mac_style)
-      assert_equal(0, table.smallest_readable_size)
-      assert_equal(0, table.font_direction_hint)
-      assert_equal(0, table.index_to_loc_format)
-    end
-
     it "raises an error if the magic number is false when reading from a file" do
       @file.io.string[12, 1] = '\x5e'
       assert_raises(HexaPDF::Error) { HexaPDF::Font::TrueType::Table::Head.new(@file, @entry) }
@@ -68,9 +52,5 @@ describe HexaPDF::Font::TrueType::Table::Head do
       table = HexaPDF::Font::TrueType::Table::Head.new(@file, @entry)
       assert(table.checksum_valid?)
     end
-
-    it "raises an error if the checksum can't be verified because none is available" do
-      assert_raises(HexaPDF::Error) { HexaPDF::Font::TrueType::Table::Head.new(@file).checksum_valid? }
-    end
   end
 end

data/test/hexapdf/font/true_type/table/test_hhea.rb

@@ -29,12 +29,5 @@ describe HexaPDF::Font::TrueType::Table::Hhea do
       assert_equal(0, table.caret_offset)
       assert_equal(10, table.num_of_long_hor_metrics)
     end
-
-    it "loads some default values if no entry is given" do
-      table = HexaPDF::Font::TrueType::Table::Hhea.new(@file)
-      assert_equal(1, table.version)
-      assert_equal(0, table.ascent)
-      assert_equal(0, table.descent)
-    end
   end
 end

data/test/hexapdf/font/true_type/table/test_hmtx.rb

@@ -11,8 +11,8 @@ describe HexaPDF::Font::TrueType::Table::Hhea do
     io = StringIO.new(data)
     @file = Object.new
     @file.define_singleton_method(:io) { io }
-    hhea = HexaPDF::Font::TrueType::Table::Hhea.new(@file)
-    hhea.num_of_long_hor_metrics = 2
+    hhea = Object.new
+    hhea.define_singleton_method(:num_of_long_hor_metrics) { 2 }
     @file.define_singleton_method(:[]) {|_arg| hhea }
     @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('hmtx', 0, 0, io.length)
   end
@@ -29,10 +29,5 @@ describe HexaPDF::Font::TrueType::Table::Hhea do
       assert_equal(3, table[3].advance_width)
       assert_equal(-6, table[3].left_side_bearing)
     end
-
-    it "loads some default values if no entry is given" do
-      table = HexaPDF::Font::TrueType::Table::Hmtx.new(@file)
-      assert_equal([], table.horizontal_metrics)
-    end
   end
 end

data/test/hexapdf/font/true_type/table/test_loca.rb

@@ -9,8 +9,8 @@ describe HexaPDF::Font::TrueType::Table::Loca do
   before do
     @file = Object.new
     @file.define_singleton_method(:io) { @io ||= StringIO.new('') }
-    head = HexaPDF::Font::TrueType::Table::Head.new(@file)
-    head.index_to_loc_format = 0
+    head = Object.new
+    head.define_singleton_method(:index_to_loc_format) { 0 }
     @file.define_singleton_method(:[]) {|_arg| head }
     @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('loca', 0, 0, @file.io.length)
   end
@@ -29,15 +29,11 @@ describe HexaPDF::Font::TrueType::Table::Loca do
 
     it "reads the data in long format from the associated file" do
       @file.io.string = [0, 10, 30, 50, 90].pack('N*')
-      @file[:head].index_to_loc_format = 1
+      @file[:head].singleton_class.send(:remove_method, :index_to_loc_format)
+      @file[:head].define_singleton_method(:index_to_loc_format) { 1 }
       @entry.length = @file.io.length
       table = HexaPDF::Font::TrueType::Table::Loca.new(@file, @entry)
       assert_equal([0, 10, 30, 50, 90], table.offsets)
     end
-
-    it "loads some default values if no entry is given" do
-      table = HexaPDF::Font::TrueType::Table::Loca.new(@file)
-      assert_equal([], table.offsets)
-    end
   end
 end

data/test/hexapdf/font/true_type/table/test_maxp.rb

@@ -51,12 +51,5 @@ describe HexaPDF::Font::TrueType::Table::Maxp do
       assert_nil(table.max_component_elements)
       assert_nil(table.max_component_depth)
     end
-
-    it "loads some default values if no entry is given" do
-      table = HexaPDF::Font::TrueType::Table::Maxp.new(@file)
-      assert_equal(1, table.version)
-      assert_equal(0, table.num_glyphs)
-      assert_equal(0, table.max_points)
-    end
   end
 end

data/test/hexapdf/font/true_type/table/test_name.rb

@@ -47,25 +47,6 @@ describe HexaPDF::Font::TrueType::Table::Name do
       assert_equal(1, table.format)
       assert_equal({0x8000 => 'en', 0x8001 => 'de'}, table.language_tags)
     end
-
-    it "loads some default values if no entry is given" do
-      table = HexaPDF::Font::TrueType::Table::Name.new(@file)
-      assert_equal(0, table.format)
-      assert_equal({}, table.records)
-      assert_equal({}, table.language_tags)
-    end
-  end
-
-  describe "add" do
-    it "adds a new record for a name" do
-      table = HexaPDF::Font::TrueType::Table::Name.new(@file)
-      table.add(:postscript_name, "test")
-      record = table[:postscript_name][0]
-      assert_equal("test", record)
-      assert_equal(HexaPDF::Font::TrueType::Table::Name::Record::PLATFORM_MACINTOSH, record.platform_id)
-      assert_equal(0, record.encoding_id)
-      assert_equal(0, record.language_id)
-    end
   end
 
   describe "NameRecord" do

data/test/hexapdf/font/true_type/table/test_os2.rb

@@ -53,13 +53,5 @@ describe HexaPDF::Font::TrueType::Table::OS2 do
       assert_equal(30, table.lower_point_size)
       assert_equal(31, table.upper_point_size)
     end
-
-    it "loads some default values if no entry is given" do
-      table = HexaPDF::Font::TrueType::Table::OS2.new(@file)
-      assert_equal(5, table.version)
-      assert_equal(''.b, table.panose)
-      assert_equal('    '.b, table.vendor_id)
-      assert_equal(0, table.default_char)
-    end
   end
 end

data/test/hexapdf/font/true_type/table/test_post.rb

@@ -68,19 +68,6 @@ describe HexaPDF::Font::TrueType::Table::Post do
       assert_equal(0xFFFF, table[1_000_000])
     end
 
-    it "loads some default values if no entry is given" do
-      table = HexaPDF::Font::TrueType::Table::Post.new(@file)
-      assert_equal(1, table.format)
-      assert_equal(0, table.italic_angle)
-      assert_equal(0, table.underline_position)
-      assert_equal(0, table.underline_thickness)
-      assert_equal(0, table.is_fixed_pitch)
-      assert_equal(0, table.min_mem_type42)
-      assert_equal(0, table.max_mem_type42)
-      assert_equal(0, table.min_mem_type1)
-      assert_equal(0, table.max_mem_type1)
-    end
-
     it "raises an error if an unsupported format is given" do
       @file.io.string[0, 2] = [5].pack('n')
       assert_raises(HexaPDF::Error) { HexaPDF::Font::TrueType::Table::Post.new(@file, @entry) }

data/test/hexapdf/font/true_type/test_font.rb

@@ -9,7 +9,7 @@ describe HexaPDF::Font::TrueType::Font do
   before do
     @io = StringIO.new("TEST\x00\x01\x00\x00\x00\x00\x00\x00" \
                        "TEST----\x00\x00\x00\x1C\x00\x00\x00\x05ENTRY".b)
-    @font = HexaPDF::Font::TrueType::Font.new(io: @io)
+    @font = HexaPDF::Font::TrueType::Font.new(@io)
     @font.config['font.true_type.table_mapping'][:TEST] = TestHelper::TrueTypeTestTable.name
   end
 
@@ -33,83 +33,59 @@ describe HexaPDF::Font::TrueType::Font do
     end
   end
 
-  describe "add_table" do
-    it "returns the existing table if one exists" do
-      assert_same(@font[:TEST], @font.add_table(:TEST))
-    end
-
-    it "creates a new table instance if needed" do
-      assert_kind_of(HexaPDF::Font::TrueType::Table::Head, @font.add_table(:head))
-    end
-  end
-
   describe "getter methods" do
     before do
-      @font.add_table(:name)
-      @font.add_table(:post)
-      @font.add_table(:head)
-      @font.add_table(:hhea)
-      @font.add_table(:"OS/2")
+      font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
+      @font = HexaPDF::Font::TrueType::Font.new(File.open(font_file))
     end
 
     it "returns the postscript name" do
-      @font[:name].add(:postscript_name, "name")
-      assert_equal("name", @font.font_name)
+      assert_equal("Ubuntu-Title", @font.font_name)
     end
 
     it "returns the full name" do
-      @font[:name].add(:font_name, "name")
-      assert_equal("name", @font.full_name)
+      assert_equal("Ubuntu-Title", @font.full_name)
     end
 
     it "returns the family name" do
-      @font[:name].add(:font_family, "name")
-      assert_equal("name", @font.family_name)
+      assert_equal("Ubuntu-Title", @font.family_name)
     end
 
     it "returns the font's weight" do
-      @font[:"OS/2"].weight_class = 400
       assert_equal(400, @font.weight)
     end
 
     it "returns the font's bounding box" do
-      @font[:head].bbox = [0, 1, 2, 3]
-      assert_equal([0, 1, 2, 3], @font.bounding_box)
+      assert_equal([-35, -187, 876, 801], @font.bounding_box)
     end
 
     it "returns the font's cap height" do
-      @font[:"OS/2"].cap_height = 832
+      @font[:'OS/2'].cap_height = 832
       assert_equal(832, @font.cap_height)
     end
 
     it "returns the font's x height" do
-      @font[:"OS/2"].x_height = 642
+      @font[:'OS/2'].x_height = 642
       assert_equal(642, @font.x_height)
     end
 
     it "returns the font's ascender" do
-      @font[:"OS/2"].typo_ascender = 800
-      @font[:hhea].ascent = 790
       assert_equal(800, @font.ascender)
-      @font.instance_eval { @tables.delete(:"OS/2") }
-      assert_equal(790, @font.ascender)
+      @font[:'OS/2'].typo_ascender = nil
+      assert_equal(801, @font.ascender)
     end
 
     it "returns the font's descender" do
-      @font[:"OS/2"].typo_descender = -200
-      @font[:hhea].descent = -180
       assert_equal(-200, @font.descender)
-      @font.instance_eval { @tables.delete(:"OS/2") }
-      assert_equal(-180, @font.descender)
+      @font[:'OS/2'].typo_descender = nil
+      assert_equal(-187, @font.descender)
     end
 
     it "returns the font's italic angle" do
-      @font[:post].italic_angle = Rational(325, 10)
-      assert_equal(32.5, @font.italic_angle)
+      assert_equal(0.0, @font.italic_angle)
     end
 
     it "returns the font's dominant vertical stem width" do
-      @font[:"OS/2"].weight_class = 400
       assert_equal(80, @font.dominant_vertical_stem_width)
     end
   end

data/test/hexapdf/font/true_type/test_table.rb

@@ -18,11 +18,6 @@ describe HexaPDF::Font::TrueType::Table do
       table = TestHelper::TrueTypeTestTable.new(@file, @entry)
       assert_equal(@file.io.string, table.data)
     end
-
-    it "loads some default values if no entry is given" do
-      table = TestHelper::TrueTypeTestTable.new(@file)
-      assert_equal('default', table.data)
-    end
   end
 
   describe "checksum_valid?" do
@@ -33,9 +28,5 @@ describe HexaPDF::Font::TrueType::Table do
       table = TestHelper::TrueTypeTestTable.new(@file, @entry)
       assert(table.checksum_valid?)
     end
-
-    it "raises an error if the checksum can't be verified because none is available" do
-      assert_raises(HexaPDF::Error) { TestHelper::TrueTypeTestTable.new(@file).checksum_valid? }
-    end
   end
 end

data/test/hexapdf/font/type1/test_font_metrics.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/type1'
+
+describe HexaPDF::Font::Type1::FontMetrics do
+  before do
+    @metrics = HexaPDF::Font::Type1::FontMetrics.new
+  end
+
+  describe "weight_class" do
+    it "converts known weight names" do
+      @metrics.weight = 'Bold'
+      assert_equal(700, @metrics.weight_class)
+    end
+
+    it "returns 0 for unknown weight names" do
+      @metrics.weight = 'Unknown'
+      assert_equal(0, @metrics.weight_class)
+    end
+  end
+end

data/test/hexapdf/task/test_dereference.rb

@@ -14,6 +14,10 @@ describe HexaPDF::Task::Dereference do
     len = @doc.add(5)
     str = @doc.add(@doc.wrap({Length: len}, stream: ''))
     @doc.trailer[:Test] = str
+    pages = @doc.wrap(Type: :Pages)
+    pages.add_page(@doc.wrap(Type: :Page))
+    @doc.trailer[:Test2] = pages
+
     checker = lambda do |val, done = {}|
       case val
       when Array then val.all? {|v| checker.call(v, done)}
@@ -24,7 +28,7 @@ describe HexaPDF::Task::Dereference do
         if done.key?(val)
           true
         else
-          done[val] = true if val.oid != 0
+          done[val] = true
           checker.call(val.value, done)
         end
       else

data/test/hexapdf/task/test_optimize.rb

@@ -128,7 +128,7 @@ describe HexaPDF::Task::Optimize do
 
   describe "compress_pages" do
     it "compresses pages streams" do
-      page = @doc.pages.add_page
+      page = @doc.pages.add
       page.contents = "   10  10   m    q            Q    BI /Name   5 ID dataEI   "
       @doc.task(:optimize, compress_pages: true)
       assert_equal("10 10 m\nq\nQ\nBI\n/Name 5 ID\ndataEI\n", page.contents)

data/test/hexapdf/test_dictionary.rb

@@ -123,6 +123,10 @@ describe HexaPDF::Dictionary do
       assert_equal(Encoding::BINARY, result.encoding)
       assert_kind_of(HexaPDF::Object, @dict.value[:Binary])
       assert_same(result, @dict.value[:Binary].value)
+
+      @dict[:Test] = HexaPDF::Dictionary.new({})
+      @dict[:Test].data.value = nil
+      assert_nil(@dict[:Test])
     end
   end
 

data/test/hexapdf/test_document.rb

@@ -554,13 +554,6 @@ EOF
     end
   end
 
-  describe "pages" do
-    it "returns the root node of the page tree" do
-      pages = @doc.pages
-      assert_equal(:Pages, pages.type)
-    end
-  end
-
   describe "listener interface" do
     it "allows registering and dispatching messages" do
       args = []

data/test/hexapdf/test_importer.rb

@@ -11,8 +11,8 @@ describe HexaPDF::Importer do
     @obj = @source.add(hash: {key: "value"}, array: ["one", "two"],
                        ref: HexaPDF::Reference.new(obj.oid, obj.gen),
                        others: [:symbol, 5, 5.5, nil, true, false])
-    @source.pages.add_page
-    @source.pages[:Rotate] = 90
+    @source.pages.add
+    @source.pages.root[:Rotate] = 90
     @dest = HexaPDF::Document.new
     @importer = HexaPDF::Importer.for(source: @source, destination: @dest)
   end
@@ -57,7 +57,7 @@ describe HexaPDF::Importer do
 
     it "does not import objects of type Catalog or Pages" do
       @obj[:catalog] = @source.catalog
-      @obj[:pages] = @source.pages
+      @obj[:pages] = @source.catalog.pages
       obj = @importer.import(@obj)
 
       assert_nil(obj[:catalog])
@@ -65,7 +65,7 @@ describe HexaPDF::Importer do
     end
 
     it "imports Page objects correctly by copying the inherited values" do
-      page = @importer.import(@source.pages.page(0))
+      page = @importer.import(@source.pages[0])
       assert_equal(90, page[:Rotate])
     end
 

data/test/hexapdf/test_object.rb

@@ -43,6 +43,11 @@ describe HexaPDF::Object do
     it "handles PDF objects" do
       x = HexaPDF::Object.new("test")
       assert_equal("test", HexaPDF::Object.deep_copy(x))
+
+      x.must_be_indirect = true
+      assert_same(x, HexaPDF::Object.deep_copy(x))
+
+      x.must_be_indirect = false
       x.oid = 1
       assert_same(x, HexaPDF::Object.deep_copy(x))
     end
@@ -162,16 +167,33 @@ describe HexaPDF::Object do
     end
   end
 
-  it "validates that the object is indirect if it must be indirect" do
-    doc = Object.new
-    def doc.add(obj) obj.oid = 1 end
-    obj = HexaPDF::Object.new(6, document: doc)
+  describe "validation" do
+    before do
+      @doc = Object.new
+      @doc.define_singleton_method(:add) {|obj| obj.oid = 1}
+    end
+
+    it "validates that the object is indirect if it must be indirect" do
+      obj = HexaPDF::Object.new(6, document: @doc)
+
+      obj.validate
+      assert_equal(0, obj.oid)
 
-    obj.validate
-    assert_equal(0, obj.oid)
+      obj.must_be_indirect = true
+      obj.validate
+      assert_equal(1, obj.oid)
+    end
 
-    obj.must_be_indirect = true
-    obj.validate
-    assert_equal(1, obj.oid)
+    it "validates collection values" do
+      x = HexaPDF::Object.new(:x, document: @doc)
+      x.must_be_indirect = true
+      y = HexaPDF::Object.new(:y, document: @doc)
+      y.must_be_indirect = true
+
+      obj = HexaPDF::Object.new([1, 2, 3, [4, x], {X: [y, 5]}])
+      obj.validate
+      assert_equal(1, x.oid)
+      assert_equal(1, y.oid)
+    end
   end
 end