hexapdf 0.1.0 → 0.2.0

data/lib/hexapdf/document/pages.rb

@@ -0,0 +1,125 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2016 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
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#++
+
+module HexaPDF
+  class Document
+
+    # This class provides methods for managing the pages of a PDF file.
+    #
+    # It uses the methods of HexaPDF::Type::PageTreeNode underneath but provides a more convenient
+    # interface.
+    class Pages
+
+      include Enumerable
+
+      # Creates a new Pages object for the given PDF document.
+      def initialize(document)
+        @document = document
+      end
+
+      # Returns the root of the page tree, a HexaPDF::Type::PageTreeNode object.
+      def root
+        @document.catalog.pages
+      end
+
+      # Adds the page or a new empty page at the end and returns it.
+      def add(page = nil)
+        @document.catalog.pages.add_page(page)
+      end
+
+      # :call-seq:
+      #   pages << page            -> pages
+      #
+      # Appends the given page at the end and returns the pages object itself to allow chaining.
+      def <<(page)
+        add(page)
+        self
+      end
+
+      # Inserts the page or a new empty page at the zero-based index and returns it.
+      #
+      # Negative indices count backwards from the end, i.e. -1 is the last page. When using
+      # negative indices, the page will be inserted after that element. So using an index of -1
+      # will insert the page after the last page.
+      def insert(index, page = nil)
+        @document.catalog.pages.insert_page(index, page)
+      end
+
+      # :call-seq:
+      #   pages.delete(page)       -> page or nil
+      #
+      # Deletes the given page object from the document's page tree (but *not* from the document).
+      #
+      # Returns the page object, or +nil+ if the page object was not in the page tree.
+      def delete(page)
+        @document.catalog.pages.delete_page(page)
+      end
+
+      # :call-seq:
+      #   pages.delete_at(index)       -> page or nil
+      #
+      # Deletes the page object at the given index from the document's page tree (but *not* from the
+      # document).
+      #
+      # Returns the page object, or +nil+ if the index was invalid.
+      def delete_at(index)
+        @document.catalog.pages.delete_page(index)
+      end
+
+      # Returns the page for the zero-based index, or +nil+ if no such page exists.
+      #
+      # Negative indices count backwards from the end, i.e. -1 is the last page.
+      def [](index)
+        @document.catalog.pages.page(index)
+      end
+
+      # :call-seq:
+      #   pages.each {|page| block }   -> pages
+      #   pages.each                   -> Enumerator
+      #
+      # Iterates over all pages inorder.
+      def each(&block)
+        @document.catalog.pages.each_page(&block)
+      end
+
+      # Returns the number of pages in the PDF document. May be zero if the document has no pages.
+      def count
+        @document.catalog.pages.page_count
+      end
+      alias :size :count
+      alias :length :count
+
+    end
+
+  end
+end

data/lib/hexapdf/encryption/aes.rb

@@ -59,7 +59,7 @@ module HexaPDF
     module AES
 
       # Valid AES key lengths
-      VALID_KEY_LENGTH = [16, 24, 32]
+      VALID_KEY_LENGTH = [16, 24, 32].freeze
 
       # The AES block size
       BLOCK_SIZE = 16

data/lib/hexapdf/encryption/ruby_aes.rb

@@ -107,7 +107,7 @@ module HexaPDF
          0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
          0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
          0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
-         0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16]
+         0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16].freeze
 
       # :nodoc:
       # Inverse of the Rijndael S-box
@@ -127,10 +127,10 @@ module HexaPDF
          0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
          0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
          0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
-         0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d]
+         0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d].freeze
 
       # :nodoc:
-      RCON = [0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c]
+      RCON = [0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c].freeze
 
       # :nodoc:
       # Precomputed Galois multiplication table for multiplication with 2 in GF(2^8)
@@ -150,7 +150,7 @@ module HexaPDF
          0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d, 0x83, 0x81, 0x87, 0x85,
          0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5, 0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5,
          0xdb, 0xd9, 0xdf, 0xdd, 0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5,
-         0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed, 0xe3, 0xe1, 0xe7, 0xe5]
+         0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed, 0xe3, 0xe1, 0xe7, 0xe5].freeze
 
       # :nodoc:
       # Precomputed Galois multiplication table for multiplication with 3 in GF(2^8)
@@ -170,7 +170,7 @@ module HexaPDF
          0x5b, 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46, 0x4f, 0x4c, 0x49, 0x4a,
          0x6b, 0x68, 0x6d, 0x6e, 0x67, 0x64, 0x61, 0x62, 0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a,
          0x3b, 0x38, 0x3d, 0x3e, 0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a,
-         0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16, 0x1f, 0x1c, 0x19, 0x1a]
+         0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16, 0x1f, 0x1c, 0x19, 0x1a].freeze
 
       # :nodoc:
       # Precomputed Galois multiplication table for multiplication with 9 in GF(2^8)
@@ -190,7 +190,7 @@ module HexaPDF
          0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9, 0xf6, 0xff, 0xe4, 0xed,
          0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35, 0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d,
          0xa1, 0xa8, 0xb3, 0xba, 0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6,
-         0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62, 0x5d, 0x54, 0x4f, 0x46]
+         0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62, 0x5d, 0x54, 0x4f, 0x46].freeze
 
       # :nodoc:
       # Precomputed Galois multiplication table for multiplication with 11 in GF(2^8)
@@ -210,7 +210,7 @@ module HexaPDF
          0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44, 0x75, 0x7e, 0x63, 0x68,
          0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80, 0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8,
          0x7a, 0x71, 0x6c, 0x67, 0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13,
-         0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f, 0xbe, 0xb5, 0xa8, 0xa3]
+         0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f, 0xbe, 0xb5, 0xa8, 0xa3].freeze
 
       # :nodoc:
       # Precomputed Galois multiplication table for multiplication with 13 in GF(2^8)
@@ -230,7 +230,7 @@ module HexaPDF
          0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8, 0xeb, 0xe6, 0xf1, 0xfc,
          0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44, 0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c,
          0x0c, 0x01, 0x16, 0x1b, 0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47,
-         0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3, 0x80, 0x8d, 0x9a, 0x97]
+         0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3, 0x80, 0x8d, 0x9a, 0x97].freeze
 
       # :nodoc:
       # Precomputed Galois multiplication table for multiplication with 14 in GF(2^8)
@@ -250,11 +250,11 @@ module HexaPDF
          0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e, 0xa4, 0xaa, 0xb8, 0xb6,
          0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26, 0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56,
          0x37, 0x39, 0x2b, 0x25, 0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d,
-         0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 0x9f, 0x91, 0x83, 0x8d]
+         0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 0x9f, 0x91, 0x83, 0x8d].freeze
 
       # :nodoc:
       # Number of rounds needed in various parts of the algorithm, depends on the key size
-      NUMBER_OF_ROUNDS = {16 => 10, 24 => 12, 32 => 14}
+      NUMBER_OF_ROUNDS = {16 => 10, 24 => 12, 32 => 14}.freeze
 
       # KeyExpansion step
       #

data/lib/hexapdf/encryption/standard_security_handler.rb

@@ -67,7 +67,7 @@ module HexaPDF
           if !key?(:OE) || !key?(:UE) || !key?(:Perms)
             yield("Value of /OE, /UE or /Perms is missing for dictionary revision 6", false)
           end
-          if value[:U].length != 48 || value[:O].length != 48 || value[:UE].length == 32 ||
+          if value[:U].length != 48 || value[:O].length != 48 || value[:UE].length != 32 ||
               value[:OE].length != 32 || value[:Perms].length != 16
             yield("Invalid size for /U, /O, /UE, /OE or /Perms values for revisions 6", false)
           end
@@ -140,7 +140,7 @@ module HexaPDF
           EXTRACT_CONTENT | ASSEMBLE_DOCUMENT | HIGH_QUALITY_PRINT
 
         # Reserved permission bits
-        RESERVED = 0xFFFFF000
+        RESERVED = 0xFFFFF000 | 0b11000000
 
         # Maps permission symbols to their respective value
         SYMBOL_TO_PERMISSION = {
@@ -152,7 +152,7 @@ module HexaPDF
           extract_content: EXTRACT_CONTENT,
           assemble_document: ASSEMBLE_DOCUMENT,
           high_quality_print: HIGH_QUALITY_PRINT,
-        }
+        }.freeze
 
         # Maps a permission value to its symbol
         PERMISSION_TO_SYMBOL = {
@@ -164,7 +164,7 @@ module HexaPDF
           EXTRACT_CONTENT => :extract_content,
           ASSEMBLE_DOCUMENT => :assemble_document,
           HIGH_QUALITY_PRINT => :high_quality_print,
-        }
+        }.freeze
 
       end
 
@@ -198,6 +198,7 @@ module HexaPDF
           fallback_pwd = data.delete(:password) { '' }
           @user_password = data.delete(:user_password) { fallback_pwd }
           @owner_password = data.delete(:owner_password) { fallback_pwd }
+          @owner_password = @user_password if @owner_password.to_s.empty?
           @permissions = process_permissions(data.delete(:permissions) { Permissions::ALL })
           @algorithm = data.delete(:algorithm) { :arc4 }
           @encrypt_metadata = data.delete(:encrypt_metadata) { true }
@@ -209,13 +210,15 @@ module HexaPDF
         private
 
         # Maps the permissions to an integer for use by the standard security handler.
+        #
+        # See: PDF1.7 s7.6.3.2, ADB1.7 3.5.2 (table 3.20 and the paragraphs before)
         def process_permissions(perms)
           if perms.kind_of?(Array)
             perms = perms.inject(0) do |result, perm|
               result | Permissions::SYMBOL_TO_PERMISSION.fetch(perm, 0)
             end
           end
-          Permissions::RESERVED | perms
+          ((Permissions::RESERVED | perms) & 0xFFFFFFFC) - 2**32
         end
 
       end
@@ -224,7 +227,7 @@ module HexaPDF
       #
       # See: SecurityHandler#encryption_key_valid?
       def encryption_key_valid?
-        super && trailer_id_hash == @trailer_id_hash
+        super && (document.trailer[:Encrypt][:R] > 4 || trailer_id_hash == @trailer_id_hash)
       end
 
       # Returns the permissions of the managed dictionary as array of symbol values.
@@ -269,7 +272,7 @@ module HexaPDF
               Length: key_length,
             },
           }
-          dict[:StmF] = dict[:StrF] = dict[:EFF] = :StdCF
+          dict[:StmF] = dict[:StrF] = :StdCF
         end
 
         if dict[:R] <= 4 && !document.trailer[:ID].kind_of?(Array)
@@ -567,7 +570,7 @@ module HexaPDF
         while i < 64 || e.getbyte(-1) > i - 32
           k1 = "#{password}#{k}#{user_key}" * 64
           e = aes_algorithm.new(k[0, 16], k[16, 16], :encrypt).process(k1)
-          k = case e.unpack('C16').inject(&:+) % 3  # 256 % 3 == 1 % 3 --> x*256 % 3 == x % 3
+          k = case e.unpack('C16').inject(&:+) % 3 # 256 % 3 == 1 % 3 --> x*256 % 3 == x % 3
               when 0 then Digest::SHA256.digest(e)
               when 1 then Digest::SHA384.digest(e)
               when 2 then Digest::SHA512.digest(e)

data/lib/hexapdf/filter/ascii85_decode.rb

@@ -55,7 +55,7 @@ module HexaPDF
       POW85_3 = 85**3 #:nodoc:
       POW85_4 = 85**4 #:nodoc:
 
-      MAX_VALUE = 0xffffffff  #:nodoc:
+      MAX_VALUE = 0xffffffff #:nodoc:
       FIXED_SUBTRAHEND = 33 * (POW85_4 + POW85_3 + POW85_2 + POW85_1 + 1) #:nodoc:
 
       # See HexaPDF::Filter

data/lib/hexapdf/filter/ascii_hex_decode.rb

@@ -58,12 +58,7 @@ module HexaPDF
             end
 
             data = rest << data if rest
-
-            if data.size.odd?
-              rest = data.slice!(-1, 1)
-            else
-              rest = nil
-            end
+            rest = (data.size.odd? ? data.slice!(-1, 1) : nil)
 
             Fiber.yield([data].pack('H*'))
           end

data/lib/hexapdf/font/cmap/writer.rb

@@ -50,7 +50,7 @@ module HexaPDF
         #
         # Note that the returned CMap always uses a 16-bit input code space!
         def create_to_unicode_cmap(mapping)
-          return to_unicode_template % '' if mapping.length == 0
+          return to_unicode_template % '' if mapping.empty?
 
           chars, ranges = compute_section_entries(mapping)
 
@@ -93,13 +93,11 @@ module HexaPDF
             if last_code + 1 == code && last_value + 1 == value && code % 256 != 0
               ranges << last_code << nil << last_value unless is_range
               is_range = true
+            elsif is_range
+              ranges[-2] = last_code
+              is_range = false
             else
-              if is_range
-                ranges[-2] = last_code
-                is_range = false
-              else
-                chars << last_code << last_value
-              end
+              chars << last_code << last_value
             end
             last_code = code
             last_value = value

data/lib/hexapdf/font/true_type.rb

@@ -37,7 +37,10 @@ module HexaPDF
     # This module provides classes for handling TrueType fonts.
     #
     # Note that currently not all parts of the file format are supported, only those needed for
-    # using the fonts with PDF.
+    # using the fonts with PDF. This means that the implementation is not a *complete* font handling
+    # library but is designed to allow reading font files and extracting information. Furthermore
+    # creating a font subset is also possible which is not the same as writing a complete font file
+    # from scratch.
     module TrueType
 
       autoload(:Font, 'hexapdf/font/true_type/font')

data/lib/hexapdf/font/true_type/font.rb

@@ -65,18 +65,16 @@ module HexaPDF
         }
 
 
-        # The IO stream associated with this file. If this is +nil+ then the TrueType font wasn't
-        # originally read from an IO stream.
+        # The IO stream associated with this file.
         attr_reader :io
 
         # The configuration for the TrueType font.
         attr_reader :config
 
-        # Creates a new TrueType font file object. If an IO object is given, the TrueType font data
-        # is read from it.
+        # Creates a new TrueType font file object for the given IO object.
         #
         # The +config+ hash can contain configuration options.
-        def initialize(io: nil, config: {})
+        def initialize(io, config: {})
           @io = io
           @config = DEFAULT_CONFIG.merge(config)
           @tables = {}
@@ -90,12 +88,6 @@ module HexaPDF
           entry ? @tables[tag] = table_class(tag).new(self, entry) : nil
         end
 
-        # Adds a new table instance for the given tag (a symbol) to the font if such a table
-        # instance doesn't already exist. Returns the table instance for the tag.
-        def add_table(tag)
-          @tables[tag] ||= table_class(tag).new(self)
-        end
-
         # Returns the font directory.
         def directory
           @directory ||= Table::Directory.new(self, io ? Table::Directory::SELF_ENTRY : nil)
@@ -118,7 +110,7 @@ module HexaPDF
 
         # Returns the weight of the font.
         def weight
-          self[:"OS/2"]&.weight_class || 0
+          self[:"OS/2"].weight_class || 0
         end
 
         # Returns the bounding of the font.
@@ -128,22 +120,22 @@ module HexaPDF
 
         # Returns the cap height of the font.
         def cap_height
-          self[:"OS/2"]&.cap_height
+          self[:"OS/2"].cap_height
         end
 
         # Returns the x-height of the font.
         def x_height
-          self[:"OS/2"]&.x_height
+          self[:"OS/2"].x_height
         end
 
         # Returns the ascender of the font.
         def ascender
-          self[:"OS/2"]&.typo_ascender || self[:hhea].ascent
+          self[:"OS/2"].typo_ascender || self[:hhea].ascent
         end
 
         # Returns the descender of the font.
         def descender
-          self[:"OS/2"]&.typo_descender || self[:hhea].descent
+          self[:"OS/2"].typo_descender || self[:hhea].descent
         end
 
         # Returns the italic angle of the font, in degrees counter-clockwise from the vertical.

data/lib/hexapdf/font/true_type/table.rb

@@ -67,14 +67,14 @@ module HexaPDF
         # The TrueType font object associated with this table.
         attr_reader :font
 
-        # Creates a new Table object for the given font and initializes it by either reading the
-        # data from the font's associated IO stream if +entry+ is given or by using default values.
+        # Creates a new Table object for the given font and initializes it by reading the
+        # data from the font's associated IO stream
         #
-        # See: #parse_table, #load_default
-        def initialize(font, entry = nil)
+        # See: #parse_table
+        def initialize(font, entry)
           @font = font
           @directory_entry = entry
-          entry ? load_from_io : load_default
+          load_from_io
         end
 
         # Returns the directory entry for this table.
@@ -87,10 +87,6 @@ module HexaPDF
         # Returns +true+ if the checksum stored in the directory entry of the table matches the
         # tables data.
         def checksum_valid?
-          unless directory_entry
-            raise HexaPDF::Error, "Can't verify the checksum, no directory entry available"
-          end
-
           data = with_io_pos(directory_entry.offset) { io.read(directory_entry.length) }
           directory_entry.checksum == self.class.calculate_checksum(data)
         end
@@ -120,13 +116,6 @@ module HexaPDF
           # noop for unsupported tables
         end
 
-        # Uses default values to populate the table.
-        #
-        # This method must be implemented by subclasses.
-        def load_default
-          # noop for unsupported tables
-        end
-
         # Sets the IO cursor to the given position while yielding to the block and returns the
         # block's return value.
         def with_io_pos(pos)