hexapdf 0.32.2 → 0.34.0

data/lib/hexapdf/document.rb

@@ -64,32 +64,43 @@ end
 #
 # Here are some pointers to more in depth information:
 #
-# * For information about the command line application, see the HexaPDF::CLI module.
+# * HexaPDF::CLI has information about the accompanying command line application.
 # * HexaPDF::Document provides information about how to work with a PDF file.
+# * HexaPDF::Composer is the main class for easily creating PDF documents from scratch.
 # * HexaPDF::Content::Canvas provides the canvas API for drawing/writing on a page or form XObject
+# * HexaPDF::Type::AcroForm::Form is the entry point for working with interactive forms.
+# * HexaPDF::Type::Outline has information on working with outlines/bookmarks.
+# * HexaPDF::Encryption provides information on how encryption works.
+# * HexaPDF::DigitalSignature is the entry point for working with digital signaturs.
 module HexaPDF
 
   autoload(:Composer, 'hexapdf/composer')
 
   # == HexaPDF::Document
   #
-  # Represents one PDF document.
+  # Represents a PDF document.
   #
-  # A PDF document consists of (indirect) objects, so the main job of this class is to provide
-  # methods for working with these objects. However, since a PDF document may also be
+  # A PDF document essentially consists of (indirect) objects, so the main job of this class is to
+  # provide methods for working with these objects. However, since a PDF document may also be
   # incrementally updated and can therefore contain one or more revisions, there are also methods
-  # for working with these revisions.
+  # for working with these revisions (see Revisions for details).
   #
-  # Note: This class provides everything to work on PDF documents on a low-level basis. This means
-  # that there are no convenience methods for higher PDF functionality. Those can be found in the
-  # objects linked from here, like #catalog.
+  # Additionally, there are many convenience methods for easily accessing the most important PDF
+  # functionality, like encrypting a document (#encrypt), working with digital signatures
+  # (#signatures), accessing the interactive form data (#acro_form), working with the pages
+  # (#pages), fonts (#fonts) and images (#images).
   #
-  # == Known Messages
+  # Note: This class provides the basis for working with a PDF document. The higher PDF
+  # functionality is *not* implemented here but either in the appropriate PDF type classes or in
+  # special convenience classes. All this functionality can be accessed via the convenience methods
+  # described above.
+  #
+  # == Available Message Hooks
   #
   # The document object provides a basic message dispatch system via #register_listener and
   # #dispatch_message.
   #
-  # Following are the messages that are used by HexaPDF itself:
+  # Following messages are used by HexaPDF itself:
   #
   # :complete_objects::
   #      This message is called before the first step of writing a document. Listeners should
@@ -138,17 +149,22 @@ module HexaPDF
       end
     end
 
-    # The configuration for the document.
+    # The configuration object for the document.
+    #
+    # See Configuration for details.
     attr_reader :config
 
     # The revisions of the document.
+    #
+    # See Revisions.
     attr_reader :revisions
 
     # Creates a new PDF document, either an empty one or one read from the provided +io+.
     #
     # When an IO object is provided and it contains an encrypted PDF file, it is automatically
     # decrypted behind the scenes. The +decryption_opts+ argument has to be set appropriately in
-    # this case.
+    # this case. In case this is not wanted, the configuration option 'document.auto_decrypt' needs
+    # to be used.
     #
     # Options:
     #
@@ -183,8 +199,8 @@ module HexaPDF
     #   doc.object(ref)    -> obj or nil
     #   doc.object(oid)    -> obj or nil
     #
-    # Returns the current version of the indirect object for the given exact reference or for the
-    # given object number.
+    # Returns the current version of the indirect object for the given exact reference (see
+    # Reference) or for the given object number.
     #
     # For references to unknown objects, +nil+ is returned but free objects are represented by a
     # PDF Null object, not by +nil+!
@@ -199,7 +215,7 @@ module HexaPDF
     #   doc.object?(oid)    -> true or false
     #
     # Returns +true+ if the the document contains an indirect object for the given exact reference
-    # or for the given object number.
+    # (see Reference) or for the given object number.
     #
     # Even though this method might return +true+ for some references, #object may return +nil+
     # because this method takes *all* revisions into account. Also see the discussion on #each for
@@ -212,7 +228,7 @@ module HexaPDF
 
     # Dereferences the given object.
     #
-    # Return the object itself if it is not a reference, or the indirect object specified by the
+    # Returns the object itself if it is not a reference, or the indirect object specified by the
     # reference.
     def deref(obj)
       obj.kind_of?(Reference) ? object(obj) : obj
@@ -227,7 +243,7 @@ module HexaPDF
     # HexaPDF::Object. If it is not the latter, #wrap is called with the object and the
     # additional keyword arguments.
     #
-    # See: Revisions#add_object
+    # See: #wrap, Revisions#add_object
     def add(obj, **wrap_opts)
       obj = wrap(obj, **wrap_opts) unless obj.kind_of?(HexaPDF::Object)
 
@@ -266,14 +282,14 @@ module HexaPDF
       HexaPDF::Importer.for(self).import(obj, source: source)
     end
 
-    # Wraps the given object inside a HexaPDF::Object class which allows one to use
+    # Wraps the given object inside a HexaPDF::Object (sub)class which allows one to use
     # convenience functions to work with the object.
     #
     # The +obj+ argument can also be a HexaPDF::Object object so that it can be re-wrapped if
-    # needed.
+    # necessary.
     #
     # The class of the returned object is always a subclass of HexaPDF::Object (or of
-    # HexaPDF::Stream if a +stream+ is given). Which subclass is used, depends on the values of the
+    # HexaPDF::Stream if +stream+ is given). Which subclass is used, depends on the values of the
     # +type+ and +subtype+ options as well as on the 'object.type_map' and 'object.subtype_map'
     # global configuration options:
     #
@@ -291,13 +307,13 @@ module HexaPDF
     #
     # * If there is no valid class after the above steps, HexaPDF::Stream is used if a stream is
     #   given, HexaPDF::Dictionary if the given object is a hash, HexaPDF::PDFArray if it is an
-    #   array or else HexaPDF::Object is used.
+    #   array or else HexaPDF::Object.
     #
     # Options:
     #
     # :type:: (Symbol or Class) The type of a PDF object that should be used for wrapping. This
     #         could be, for example, :Pages. If a class object is provided, it is used directly
-    #         instead of the type detection system.
+    #         instead of determining the class through the type detection system.
     #
     # :subtype:: (Symbol) The subtype of a PDF object which further qualifies a type. For
     #            example, image objects in PDF have a type of :XObject and a subtype of :Image.
@@ -341,7 +357,9 @@ module HexaPDF
       if subtype
         sub_klass = GlobalConfiguration.constantize('object.subtype_map', type, subtype) { klass }
         if type ||
-            sub_klass&.each_field&.none? {|name, field| field.required? && !data.value.key?(name) }
+            sub_klass&.each_field&.none? do |name, field|
+              field.required? && !data.value.key?(name) && name != :Type
+            end
           klass = sub_klass
         end
       end
@@ -410,6 +428,11 @@ module HexaPDF
     #    doc.register_listener(name) {|*args| block}       -> block
     #
     # Registers the given listener for the message +name+.
+    #
+    # If +callable+ is provided, it needs to be an Object responding to #call. Otherwise the block
+    # has to be provided. The arguments that are provided to the #call method depend on the message.
+    #
+    # See: dispatch_message
     def register_listener(name, callable = nil, &block)
       callable ||= block
       (@listeners[name] ||= []) << callable
@@ -420,6 +443,8 @@ module HexaPDF
     #
     # See the main Document documentation for an overview of messages that are used by HexaPDF
     # itself.
+    #
+    # See: register_listener
     def dispatch_message(name, *args)
       @listeners[name]&.each {|obj| obj.call(*args) }
     end
@@ -427,10 +452,10 @@ module HexaPDF
     UNSET = ::Object.new # :nordoc:
 
     # Caches and returns the given +value+ or the value of the given block using the given
-    # +pdf_data+ and +key+ arguments as composite cache key. If a cached value already exists and
-    # +update+ is +false+, the cached value is just returned.
+    # +pdf_data+ and +key+ arguments as composite cache key.
     #
-    # Set +update+ to +true+ to force an update of the cached value.
+    # If a cached value already exists and +update+ is +false+, the cached value is just returned.
+    # If +update+ is set to +true+, an update of the cached value is forced.
     #
     # This facility can be used to cache expensive operations in PDF objects that are easy to
     # compute again.
@@ -444,7 +469,7 @@ module HexaPDF
     # Returns +true+ if there is a value cached for the composite key consisting of the given
     # +pdf_data+ and +key+ objects.
     #
-    # Also see: #cache
+    # See: #cache
     def cached?(pdf_data, key)
       @cache.key?(pdf_data) && @cache[pdf_data].key?(key)
     end
@@ -455,29 +480,32 @@ module HexaPDF
     # It is *not* recommended to clear the whole cache! Better clear the cache for individual PDF
     # objects!
     #
-    # Also see: #cache
+    # See: #cache, #cached?
     def clear_cache(pdf_data = nil)
       pdf_data ? @cache[pdf_data].clear : @cache.clear
     end
 
-    # Returns the Pages object that provides convenience methods for working with pages.
+    # Returns the Pages object that provides convenience methods for working with the pages of the
+    # PDF file.
     #
-    # Also see: HexaPDF::Type::PageTreeNode
+    # See: Pages, Type::PageTreeNode
     def pages
       @pages ||= Pages.new(self)
     end
 
-    # Returns the Images object that provides convenience methods for working with images.
+    # Returns the Images object that provides convenience methods for working with images (e.g.
+    # adding them to the PDF or listing them).
     def images
       @images ||= Images.new(self)
     end
 
-    # Returns the Files object that provides convenience methods for working with files.
+    # Returns the Files object that provides convenience methods for working with embedded files.
     def files
       @files ||= Files.new(self)
     end
 
-    # Returns the Fonts object that provides convenience methods for working with fonts.
+    # Returns the Fonts object that provides convenience methods for working with the fonts used in
+    # the PDF file.
     def fonts
       @fonts ||= Fonts.new(self)
     end
@@ -496,24 +524,33 @@ module HexaPDF
 
     # Returns the main AcroForm object for dealing with interactive forms.
     #
-    # See HexaPDF::Type::Catalog#acro_form for details on the arguments.
+    # The meaning of the +create+ argument is detailed at Type::Catalog#acro_form.
+    #
+    # See: Type::AcroForm::Form
     def acro_form(create: false)
       catalog.acro_form(create: create)
     end
 
-    # Returns the main document outline object.
+    # Returns the entry object to the document outline (a.k.a. bookmarks).
     #
-    # See HexaPDF::Type::Outline for details.
+    # See: Type::Outline
     def outline
       catalog.outline
     end
 
+    # Returns the main object for working with optional content (a.k.a. layers).
+    #
+    # See: Type::Catalog#optional_content
+    def optional_content
+      catalog.optional_content
+    end
+
     # Executes the given task and returns its result.
     #
     # Tasks provide an extensible way for performing operations on a PDF document without
     # cluttering the Document interface.
     #
-    # See Task for more information.
+    # See: Task
     def task(name, **opts, &block)
       task = config.constantize('task.map', name) do
         raise HexaPDF::Error, "No task named '#{name}' is available"
@@ -522,11 +559,15 @@ module HexaPDF
     end
 
     # Returns the trailer dictionary for the document.
+    #
+    # See: Type::Trailer
     def trailer
       @revisions.current.trailer
     end
 
     # Returns the document's catalog, the root of the object tree.
+    #
+    # See: Type::Catalog
     def catalog
       trailer.catalog
     end
@@ -537,14 +578,16 @@ module HexaPDF
     # version has been set manually and the catalog's /Version key refers to a later version, the
     # later version is used.
     #
-    # See: PDF1.7 s7.2.2
+    # See: PDF2.0 s7.2.2
     def version
       catalog_version = (catalog[:Version] || '1.0').to_s
       (@version < catalog_version ? catalog_version : @version)
     end
 
-    # Sets the version of the PDF document. The argument must be a string in the format 'M.N'
-    # where M is the major version and N the minor version (e.g. '1.4' or '2.0').
+    # Sets the version of the PDF document.
+    #
+    # The argument +value+ must be a string in the format 'M.N' where M is the major version and N
+    # the minor version (e.g. '1.4' or '2.0').
     def version=(value)
       raise ArgumentError, "PDF version must follow format M.N" unless value.to_s.match?(/\A\d\.\d\z/)
       @version = value.to_s
@@ -557,9 +600,9 @@ module HexaPDF
 
     # Encrypts the document.
     #
-    # This is done by setting up a security handler for this purpose and populating the trailer's
-    # Encrypt dictionary accordingly. The actual encryption, however, is only done when writing the
-    # document.
+    # Encryption is done by setting up a security handler for this purpose and populating the
+    # trailer's Encrypt dictionary accordingly. The actual encryption, however, is only done when
+    # writing the document.
     #
     # The security handler used for encrypting is selected via the +name+ argument. All other
     # arguments are passed on the security handler.
@@ -567,9 +610,8 @@ module HexaPDF
     # If the document should not be encrypted, the +name+ argument has to be set to +nil+. This
     # removes the security handler and deletes the trailer's Encrypt dictionary.
     #
-    # See: HexaPDF::Encryption::SecurityHandler#set_up_encryption and
-    # HexaPDF::Encryption::StandardSecurityHandler::EncryptionOptions for possible encryption
-    # options.
+    # See: Encryption::SecurityHandler#set_up_encryption and
+    # Encryption::StandardSecurityHandler::EncryptionOptions for possible encryption options.
     def encrypt(name: :Standard, **options)
       if name.nil?
         trailer.delete(:Encrypt)
@@ -605,17 +647,16 @@ module HexaPDF
     # Signs the document and writes it to the given file or IO object.
     #
     # For details on the arguments +file_or_io+, +signature+ and +write_options+ see
-    # HexaPDF::DigitalSignature::Signatures#add.
+    # DigitalSignature::Signatures#add.
     #
     # The signing handler to be used is determined by the +handler+ argument together with the rest
-    # of the keyword arguments (see HexaPDF::DigitalSignature::Signatures#signing_handler for
-    # details).
+    # of the keyword arguments (see DigitalSignature::Signatures#signing_handler for details).
     #
-    # If not changed, the default signing handler is
-    # HexaPDF::DigitalSignature::Signing::DefaultHandler.
+    # If not changed, the default signing handler is DigitalSignature::Signing::DefaultHandler.
     #
-    # *Note*: Once signing is done the document cannot be changed anymore since it was written. If a
-    # document needs to be signed multiple times, it needs to be loaded again after writing.
+    # *Note*: Once signing is done the document cannot be changed anymore since it was written
+    # during the signing process. If a document needs to be signed multiple times, it needs to be
+    # loaded again afterwards.
     def sign(file_or_io, handler: :default, signature: nil, write_options: {}, **handler_options)
       handler = signatures.signing_handler(name: handler, **handler_options)
       signatures.add(file_or_io, handler, signature: signature, write_options: write_options)
@@ -626,7 +667,7 @@ module HexaPDF
     #
     # If a block is given, it is called on validation problems.
     #
-    # See HexaPDF::Object#validate for more information.
+    # See Object#validate for more information.
     def validate(auto_correct: true, only_loaded: false, &block) #:yield: msg, correctable, object
       result = trailer.validate(auto_correct: auto_correct, &block)
       each(only_loaded: only_loaded) do |obj|
@@ -651,7 +692,7 @@ module HexaPDF
     #   This is needed, for example, when modifying a signed PDF and the original signature should
     #   stay valid.
     #
-    #   See: PDF1.7 s7.5.6
+    #   See: PDF2.0 s7.5.6
     #
     # validate::
     #   Validates the document and raises an error if an uncorrectable problem is found.

data/lib/hexapdf/encryption/aes.rb

@@ -43,7 +43,7 @@ module HexaPDF
     # Common interface for AES algorithms
     #
     # This module defines the common interface that is used by the security handlers to encrypt or
-    # decrypt data with AES. It has to be *prepended* by any AES algorithm class.
+    # decrypt data with AES. It has to be *prepended* by any specific AES algorithm class.
     #
     # See the ClassMethods module for available class level methods of AES algorithms.
     #
@@ -79,7 +79,7 @@ module HexaPDF
         # The data is padded using the PKCS#5 padding scheme and the initialization vector is
         # prepended to the encrypted data,
         #
-        # See: PDF1.7 s7.6.2.
+        # See: PDF2.0 s7.6.3
         def encrypt(key, data)
           iv = random_bytes(BLOCK_SIZE)
           iv << new(key, iv, :encrypt).process(pad(data))
@@ -112,7 +112,7 @@ module HexaPDF
         # It is assumed that the initialization vector is included in the first BLOCK_SIZE bytes
         # of the data. After the decryption the PKCS#5 padding is removed.
         #
-        # See: PDF1.7 s7.6.2.
+        # See: PDF2.0 s7.6.3
         def decrypt(key, data)
           return data if data.empty? # Handle invalid files with empty strings
           if data.length % BLOCK_SIZE != 0 || data.length < BLOCK_SIZE
@@ -167,7 +167,7 @@ module HexaPDF
         # Pads the data to a muliple of BLOCK_SIZE using the PKCS#5 padding scheme and returns the
         # result.
         #
-        # See: PDF1.7 s7.6.2
+        # See: PDF2.0 s7.6.3
         def pad(data)
           padding_length = BLOCK_SIZE - data.size % BLOCK_SIZE
           data + padding_length.chr * padding_length
@@ -179,7 +179,7 @@ module HexaPDF
         # In case the padding is not correct as per the specification, it is assumed that there is
         # no padding and the input is returned as is.
         #
-        # See: PDF1.7 s7.6.2
+        # See: PDF2.0 s7.6.3
         def unpad(data)
           padding_length = data.getbyte(-1)
           if padding_length > BLOCK_SIZE || padding_length == 0 ||

data/lib/hexapdf/encryption/arc4.rb

@@ -65,7 +65,7 @@ module HexaPDF
 
         # Encrypts the given +data+ with the +key+.
         #
-        # See: PDF1.7 s7.6.2.
+        # See: PDF2.0 s7.6.3
         def encrypt(key, data)
           new(key).process(data)
         end

data/lib/hexapdf/encryption/fast_aes.rb

@@ -48,7 +48,7 @@ module HexaPDF
     #
     # This implementation is using AES in Cipher Block Chaining (CBC) mode.
     #
-    # See: PDF1.7 s7.6.2
+    # See: PDF2.0 s7.6.3
     class FastAES
 
       prepend AES
@@ -68,7 +68,7 @@ module HexaPDF
         @cipher.send(mode)
         @cipher.key = key
         @cipher.iv = iv
-        @cipher.padding = 0
+        @cipher.padding = 0 # Padding handled by HexaPDF, also no @cipher.final call needed
       end
 
       # Encrypts or decrypts the given data whose length must be a multiple of 16.

data/lib/hexapdf/encryption/fast_arc4.rb

@@ -45,7 +45,7 @@ module HexaPDF
 
       # Implementation of the general encryption algorithm ARC4 using OpenSSL as backend.
       #
-      # See: PDF1.7 s7.6.2
+      # See: PDF2.0 s7.6.3
       class FastARC4
 
         prepend ARC4

data/lib/hexapdf/encryption/identity.rb

@@ -42,7 +42,7 @@ module HexaPDF
     # This "algorithm" does nothing, i.e. it returns the given data as is without encrypting or
     # decrypting it.
     #
-    # See: PDF1.7 s7.6.5
+    # See: PDF2.0 s7.6.6
     module Identity
 
       class << self

data/lib/hexapdf/encryption/ruby_aes.rb

@@ -51,7 +51,7 @@ module HexaPDF
     #
     # This implementation is using AES in Cipher Block Chaining (CBC) mode.
     #
-    # See: PDF1.7 s7.6.2
+    # See: PDF2.0 s7.6.3
     class RubyAES
 
       prepend AES
@@ -92,9 +92,8 @@ module HexaPDF
 
       private
 
-      # :nodoc:
       # Rijndael S-box
-      SBOX = [
+      SBOX = [ # :nodoc:
         0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
         0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
         0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
@@ -113,9 +112,8 @@ module HexaPDF
         0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
       ].freeze
 
-      # :nodoc:
       # Inverse of the Rijndael S-box
-      INV_SBOX = [
+      INV_SBOX = [ # :nodoc:
         0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
         0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
         0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
@@ -134,12 +132,10 @@ module HexaPDF
         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].freeze
+      RCON = [0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c].freeze # :nodoc:
 
-      # :nodoc:
       # Precomputed Galois multiplication table for multiplication with 2 in GF(2^8)
-      G2MULT = [
+      G2MULT = [ # :nodoc:
         0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e,
         0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e,
         0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e,
@@ -158,9 +154,8 @@ module HexaPDF
         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)
-      G3MULT = [
+      G3MULT = [ # :nodoc:
         0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d, 0x14, 0x17, 0x12, 0x11,
         0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39, 0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22, 0x21,
         0x60, 0x63, 0x66, 0x65, 0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71,
@@ -179,9 +174,8 @@ module HexaPDF
         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)
-      G9MULT = [
+      G9MULT = [ # :nodoc:
         0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53, 0x6c, 0x65, 0x7e, 0x77,
         0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf, 0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7,
         0x3b, 0x32, 0x29, 0x20, 0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
@@ -200,9 +194,8 @@ module HexaPDF
         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)
-      G11MULT = [
+      G11MULT = [ # :nodoc:
         0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45, 0x74, 0x7f, 0x62, 0x69,
         0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81, 0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9,
         0x7b, 0x70, 0x6d, 0x66, 0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12,
@@ -221,9 +214,8 @@ module HexaPDF
         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)
-      G13MULT = [
+      G13MULT = [ # :nodoc:
         0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f, 0x5c, 0x51, 0x46, 0x4b,
         0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3, 0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b,
         0xbb, 0xb6, 0xa1, 0xac, 0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0,
@@ -242,9 +234,8 @@ module HexaPDF
         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)
-      G14MULT = [
+      G14MULT = [ # :nodoc:
         0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62, 0x48, 0x46, 0x54, 0x5a,
         0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca, 0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba,
         0xdb, 0xd5, 0xc7, 0xc9, 0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81,
@@ -263,9 +254,8 @@ module HexaPDF
         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}.freeze
+      NUMBER_OF_ROUNDS = {16 => 10, 24 => 12, 32 => 14}.freeze # :nodoc:
 
       # KeyExpansion step
       #

data/lib/hexapdf/encryption/ruby_arc4.rb

@@ -46,7 +46,7 @@ module HexaPDF
     #
     # For reference: This implementation is about 250 times slower than the FastARC4 version.
     #
-    # See: PDF1.7 s7.6.2
+    # See: PDF2.0 s7.6.3
     class RubyARC4
 
       prepend ARC4