hexapdf 0.12.1 → 0.14.1

data/lib/hexapdf/configuration.rb

@@ -334,6 +334,20 @@ module HexaPDF
   #    The value needs to be an object that responds to \#call(document, message, position) and
   #    returns +true+ if an error should be raised.
   #
+  # parser.try_xref_reconstruction::
+  #    A boolean specifying whether non-recoverable parsing errors should lead to reconstructing the
+  #    main cross-reference table.
+  #
+  #    The reconstructed cross-reference table might make damaged files usable but there is no way
+  #    to ensure that the reconstructed file is equal to the undamaged original file (though
+  #    generally it works out).
+  #
+  #    There is also the possibility that reconstructing doesn't work because the algorithm has to
+  #    assume that the PDF was written in a certain way (which is recommended by the PDF
+  #    specification).
+  #
+  #    Defaults to +true+.
+  #
   # sorted_tree.max_leaf_node_size::
   #    The maximum number of nodes that should be in a leaf node of a node tree.
   #
@@ -412,6 +426,7 @@ module HexaPDF
                       'page.default_media_box' => :A4,
                       'page.default_media_orientation' => :portrait,
                       'parser.on_correctable_error' => proc { false },
+                      'parser.try_xref_reconstruction' => true,
                       'sorted_tree.max_leaf_node_size' => 64,
                       'style.layers_map' => {
                         link: 'HexaPDF::Layout::Style::LinkLayer',

data/lib/hexapdf/content/graphic_object/arc.rb

@@ -45,7 +45,7 @@ module HexaPDF
       # all either in clockwise or counterclockwise direction and optionally inclined in respect to
       # the x-axis.
       #
-      # See: ELL - https://www.spaceroots.org/documents/ellipse/elliptical-arc.pdf
+      # See: ELL - https://spaceroots.org/documents/ellipse/elliptical-arc.pdf
       class Arc
 
         include HexaPDF::Utils::MathHelpers
@@ -202,8 +202,8 @@ module HexaPDF
             p2x_prime, p2y_prime = derivative_evaluate(eta2)
 
             result << [p2x, p2y,
-                       p1: [p1x + alpha * p1x_prime, p1y + alpha * p1y_prime],
-                       p2: [p2x - alpha * p2x_prime, p2y - alpha * p2y_prime]]
+                       {p1: [p1x + alpha * p1x_prime, p1y + alpha * p1y_prime],
+                        p2: [p2x - alpha * p2x_prime, p2y - alpha * p2y_prime]}]
           end
 
           result

data/lib/hexapdf/content/parser.rb

@@ -177,7 +177,7 @@ module HexaPDF
       def parse(contents, processor = nil, &block) #:yields: object, params
         raise ArgumentError, "Argument processor or block is needed" if processor.nil? && block.nil?
         if processor.nil?
-          block.singleton_class.alias_method(:process, :call)
+          block.singleton_class.send(:alias_method, :process, :call)
           processor = block
         end
 

data/lib/hexapdf/dictionary.rb

@@ -97,7 +97,7 @@ module HexaPDF
     #
     # version:: Specifies the minimum version of the PDF specification needed for this value.
     def self.define_field(name, type:, required: false, default: nil, indirect: nil,
-                          allowed_values: nil, version: '1.2')
+                          allowed_values: nil, version: '1.0')
       @fields ||= {}
       @fields[name] = Field.new(type, required: required, default: default, indirect: indirect,
                                 allowed_values: allowed_values, version: version)
@@ -155,6 +155,9 @@ module HexaPDF
     #   available (see ::define_field).
     #
     # * Returns the default value if one is specified and no value is available.
+    #
+    # Note: This method may throw a "can't add a new key into hash during iteration" error in
+    # certain cases because it potentially modifies the underlying hash!
     def [](name)
       field = self.class.field(name)
       data = if key?(name)
@@ -163,7 +166,7 @@ module HexaPDF
                value[name] = field.default
              end
       value[name] = data = document.deref(data) if data.kind_of?(HexaPDF::Reference)
-      if data.class == HexaPDF::Object || (data.kind_of?(HexaPDF::Object) && data.value.nil?)
+      if data.instance_of?(HexaPDF::Object) || (data.kind_of?(HexaPDF::Object) && data.value.nil?)
         data = data.value
       end
       if (result = field&.convert(data, document))
@@ -182,7 +185,7 @@ module HexaPDF
         raise ArgumentError, "Only Symbol (Name) keys are allowed to be used in PDF dictionaries"
       end
 
-      if value[name].class == HexaPDF::Object && !data.kind_of?(HexaPDF::Object) &&
+      if value[name].instance_of?(HexaPDF::Object) && !data.kind_of?(HexaPDF::Object) &&
           !data.kind_of?(HexaPDF::Reference)
         value[name].value = data
       else
@@ -255,7 +258,7 @@ module HexaPDF
 
     # Iterates over all currently set fields and those that are required.
     def each_set_key_or_required_field #:yields: name, field
-      value.each_key {|name| yield(name, self.class.field(name)) }
+      value.keys.each {|name| yield(name, self.class.field(name)) }
       self.class.each_field do |name, field|
         yield(name, field) if field.required? && !value.key?(name)
       end
@@ -273,7 +276,7 @@ module HexaPDF
         # Check that required fields are set
         if field.required? && obj.nil?
           yield("Required field #{name} is not set", field.default?)
-          self[name] = obj = field.default
+          self[name] = obj = field.default if field.default?
         end
 
         # Check if the document version is set high enough
@@ -301,7 +304,7 @@ module HexaPDF
 
         # Check the value of the field against the allowed values.
         if field.allowed_values && !field.allowed_values.include?(obj)
-          yield("Field #{name} does not contain an allowed value")
+          yield("Field #{name} does not contain an allowed value: #{obj.inspect}")
         end
 
         # Check if field value needs to be (in)direct

data/lib/hexapdf/dictionary_fields.rb

@@ -151,17 +151,9 @@ module HexaPDF
       # Returns a duplicated default value, automatically taking unduplicatable classes into
       # account.
       def default
-        duplicatable_default? ? @default.dup : @default
+        @default.dup
       end
 
-      # Returns +true+ if the default value can safely be duplicated with #dup.
-      def duplicatable_default?
-        @duplicatable_default ||= HexaPDF::Object::NOT_DUPLICATABLE_CLASSES.none? do |klass|
-          @default.kind_of?(klass)
-        end
-      end
-      private :duplicatable_default?
-
       # Returns +true+ if the given object is valid for this field.
       def valid_object?(obj)
         type.any? {|t| obj.kind_of?(t) } ||

data/lib/hexapdf/document.rb

@@ -69,15 +69,35 @@ module HexaPDF
 
   autoload(:Composer, 'hexapdf/composer')
 
+  # == HexaPDF::Document
+  #
   # Represents one 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
   # incrementally updated and can therefore contain one or more revisions, there are also methods
-  # to work with these revisions.
+  # for working with these revisions.
   #
   # 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 whatsoever.
+  # that there are no convenience methods for higher PDF functionality. Those can be found in the
+  # objects linked from here, like #catalog.
+  #
+  # == Known Messages
+  #
+  # 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:
+  #
+  # :complete_objects::
+  #      This message is called before the first step of writing a document. Listeners should
+  #      complete PDF objects that are missing some information.
+  #
+  #      For example, the font system uses this message to complete the font objects with
+  #      information that is only available once all the used glyphs are known.
+  #
+  # :before_write::
+  #      This message is called before a document is actually serialized and written.
   class Document
 
     autoload(:Pages, 'hexapdf/document/pages')
@@ -400,11 +420,11 @@ module HexaPDF
     # object in the PDF document. The block may either accept only the object or the object and the
     # revision it is in.
     #
-    # By default, only the current version of each object is returned which implies that each
-    # object number is yielded exactly once. If the +current+ option is +false+, all stored
-    # objects from newest to oldest are returned, not only the current version of each object.
+    # By default, only the current version of each object is returned which implies that each object
+    # number is yielded exactly once. If the +only_current+ option is +false+, all stored objects
+    # from newest to oldest are returned, not only the current version of each object.
     #
-    # The +current+ option can make a difference because the document can contain multiple
+    # The +only_current+ option can make a difference because the document can contain multiple
     # revisions:
     #
     # * Multiple revisions may contain objects with the same object and generation numbers, e.g.
@@ -442,19 +462,28 @@ module HexaPDF
     end
 
     # Dispatches the message +name+ with the given arguments to all registered listeners.
+    #
+    # See the main Document documentation for an overview of messages that are used by HexaPDF
+    # itself.
     def dispatch_message(name, *args)
       @listeners[name]&.each {|obj| obj.call(*args) }
     end
 
-    # Caches the value or the return value of the given block using the given Object::PDFData and
-    # key arguments as composite hash key. If a cached value already exists, it is just returned.
+    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.
+    #
+    # Set +update+ to +true+ to force an update of the cached value.
     #
     # This facility can be used to cache expensive operations in PDF objects that are easy to
     # compute again.
     #
     # Use #clear_cache to clear the cache if necessary.
-    def cache(pdf_data, key, value = nil)
-      @cache[pdf_data][key] ||= value || yield
+    def cache(pdf_data, key, value = UNSET, update: false)
+      return @cache[pdf_data][key] if cached?(pdf_data, key) && !update
+      @cache[pdf_data][key] = (value == UNSET ? yield : value)
     end
 
     # Returns +true+ if there is a value cached for the composite key consisting of the given
@@ -594,13 +623,9 @@ module HexaPDF
     # If a block is given, it is called on validation problems.
     #
     # See HexaPDF::Object#validate for more information.
-    def validate(auto_correct: true, only_loaded: false) #:yield: object, msg, correctable
-      cur_obj = trailer
-      block = (block_given? ? lambda {|msg, correctable| yield(cur_obj, msg, correctable) } : nil)
-
+    def validate(auto_correct: true, only_loaded: false, &block) #:yield: msg, correctable, object
       result = trailer.validate(auto_correct: auto_correct, &block)
       each(only_current: false, only_loaded: only_loaded) do |obj|
-        cur_obj = obj
         result &&= obj.validate(auto_correct: auto_correct, &block)
       end
       result
@@ -643,7 +668,7 @@ module HexaPDF
       end
 
       if validate
-        self.validate(auto_correct: true) do |obj, msg, correctable|
+        self.validate(auto_correct: true) do |msg, correctable, obj|
           next if correctable
           raise HexaPDF::Error, "Validation error for (#{obj.oid},#{obj.gen}): #{msg}"
         end

data/lib/hexapdf/document/files.rb

@@ -117,7 +117,6 @@ module HexaPDF
 
           @document.pages.each do |page|
             page[:Annots]&.each do |annot|
-              annot = @document.deref(annot)
               next unless annot[:Subtype] == :FileAttachment
               spec = @document.deref(annot[:FS])
               yield(spec) unless seen.key?(spec)

data/lib/hexapdf/encryption/fast_arc4.rb

@@ -49,7 +49,7 @@ module HexaPDF
 
       # Creates a new FastARC4 object using the given encryption key.
       def initialize(key)
-        @cipher = OpenSSL::Cipher::RC4.new
+        @cipher = OpenSSL::Cipher.new('rc4')
         @cipher.key_len = key.length
         @cipher.key = key
       end

data/lib/hexapdf/encryption/security_handler.rb

@@ -72,6 +72,7 @@ module HexaPDF
         super
         unless [1, 2, 4, 5].include?(value[:V])
           yield("Value of /V is not one of 1, 2, 4 or 5", false)
+          return
         end
         if value[:V] == 2 && (!key?(:Length) || value[:Length] < 40 ||
           value[:Length] > 128 || value[:Length] % 8 != 0)

data/lib/hexapdf/encryption/standard_security_handler.rb

@@ -69,6 +69,7 @@ module HexaPDF
         when 6
           if !key?(:OE) || !key?(:UE) || !key?(:Perms)
             yield("Value of /OE, /UE or /Perms is missing for dictionary revision 6", false)
+            return
           end
           if value[:U].length != 48 || value[:O].length != 48 || value[:UE].length != 32 ||
               value[:OE].length != 32 || value[:Perms].length != 16

data/lib/hexapdf/font/cmap.rb

@@ -100,10 +100,7 @@ module HexaPDF
       # The writing mode of the CMap: 0 for horizontal, 1 for vertical writing.
       attr_accessor :wmode
 
-      attr_reader :codespace_ranges     #: nodoc:
-      attr_reader :cid_mapping          # :nodoc:
-      attr_reader :cid_range_mappings   # :nodoc:
-      attr_reader :unicode_mapping      # :nodoc:
+      attr_reader :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping # :nodoc:
       protected :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping
 
       # Creates a new CMap object.

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

@@ -63,6 +63,12 @@ module HexaPDF
         def use_glyph(glyph_id)
           return @glyph_map[glyph_id] if @glyph_map.key?(glyph_id)
           @last_id += 1
+          # Handle codes for ASCII characters \r, (, ) and \ specially so that they never appear in
+          # the output (PDF serialization would need to escape them)
+          if @last_id == 13 || @last_id == 40 || @last_id == 41 || @last_id == 92
+            @glyph_map[:"s#{@last_id}"] = @last_id
+            @last_id += 1
+          end
           @glyph_map[glyph_id] = @last_id
         end
 
@@ -107,7 +113,7 @@ module HexaPDF
           locations = []
 
           @glyph_map.each_key do |old_gid|
-            glyph = orig_glyf[old_gid]
+            glyph = orig_glyf[old_gid.kind_of?(Symbol) ? 0 : old_gid]
             locations << table.size
             data = glyph.raw_data
             if glyph.compound?
@@ -134,7 +140,7 @@ module HexaPDF
           hmtx = @font[:hmtx]
           data = ''.b
           @glyph_map.each_key do |old_gid|
-            metric = hmtx[old_gid]
+            metric = hmtx[old_gid.kind_of?(Symbol) ? 0 : old_gid]
             data << [metric.advance_width, metric.left_side_bearing].pack('n2')
           end
           data
@@ -166,7 +172,10 @@ module HexaPDF
         # Adds the components of compound glyphs to the subset.
         def add_glyph_components
           glyf = @font[:glyf]
-          @glyph_map.keys.each {|gid| glyf[gid].components&.each {|cgid| use_glyph(cgid) } }
+          @glyph_map.keys.each do |gid|
+            next if gid.kind_of?(Symbol)
+            glyf[gid].components&.each {|cgid| use_glyph(cgid) }
+          end
         end
 
       end

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

@@ -76,6 +76,7 @@ module HexaPDF
 
           # Apple Mac style information.
           attr_accessor :mac_style
+
           bit_field(:mac_style, {bold: 0, italic: 1, underline: 2, outline: 3, shadow: 4,
                                  condensed: 5, extended: 6})
 

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

@@ -65,6 +65,7 @@ module HexaPDF
 
           # Characteristics and properties of this font.
           attr_accessor :type
+
           bit_field(:type, {restricted_license_embedding: 1, preview_and_print_embedding: 2,
                             editable_embedding: 3, no_subsetting: 8, bitmap_embedding_only: 9})
 
@@ -112,6 +113,7 @@ module HexaPDF
 
           # Information concerning the nature of the font patterns.
           attr_accessor :selection
+
           bit_field(:selection, {italic: 0, underscore: 1, negative: 2, outlined: 3, strikeout: 4,
                                  bold: 5, regular: 6, use_typo_metrics: 7, wws: 8, oblique: 9})
 

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

@@ -99,18 +99,23 @@ module HexaPDF
               @max_mem_type42, @min_mem_type1, @max_mem_type1 = read_formatted(24, 's>2N5')
 
             sub_table_length = directory_entry.length - 32
-            @glyph_names = case @format
-                           when 1 then Format1.parse(io, sub_table_length)
-                           when 2 then Format2.parse(io, sub_table_length)
-                           when 3 then Format3.parse(io, sub_table_length)
-                           when 4 then Format4.parse(io, sub_table_length)
-                           else
-                             if font.config['font.true_type.unknown_format'] == :raise
-                               raise HexaPDF::Error, "Unsupported post table format: #{@format}"
+            cur_pos = io.pos
+            @glyph_names = lambda do |glyph_id|
+              io.pos = cur_pos
+              @glyph_names = case @format
+                             when 1 then Format1.parse(io, sub_table_length)
+                             when 2 then Format2.parse(io, sub_table_length)
+                             when 3 then Format3.parse(io, sub_table_length)
+                             when 4 then Format4.parse(io, sub_table_length)
                              else
-                               []
+                               if font.config['font.true_type.unknown_format'] == :raise
+                                 raise HexaPDF::Error, "Unsupported post table format: #{@format}"
+                               else
+                                 []
+                               end
                              end
-                           end
+              @glyph_names[glyph_id]
+            end
           end
 
           # 'post' table format 1

data/lib/hexapdf/font_loader/from_configuration.rb

@@ -63,8 +63,8 @@ module HexaPDF
         file = document.config['font.map'].dig(name, variant)
         return nil if file.nil?
 
-        unless File.file?(file)
-          raise HexaPDF::Error, "The configured font file #{file} does not exist"
+        unless file.kind_of?(HexaPDF::Font::TrueType::Font) || File.file?(file)
+          raise HexaPDF::Error, "The configured font file #{file} is not a valid value"
         end
         FromFile.call(document, file, subset: subset)
       end

data/lib/hexapdf/font_loader/from_file.rb

@@ -39,26 +39,36 @@ require 'hexapdf/font/true_type_wrapper'
 module HexaPDF
   module FontLoader
 
-    # This module interprets the font name as file name and tries to load it.
+    # This module interprets the font name either as file name and tries to load it, or as font
+    # object to be wrapped directly.
     module FromFile
 
-      # Loads the given font by interpreting the font name as file name.
+      # :call-seq:
+      #   FromFile.call(document, file_name, subset: true, **)           -> wrapped_font
+      #   FromFile.call(document, font_object, subset: true, **)    -> wrapped_font
       #
-      # The file object representing the font file is *not* closed and if needed must be closed by
-      # the caller once the font is not needed anymore.
+      # Returns an appropriate font wrapper for the given file name or font object.
+      #
+      # If a file name is given, the file object representing the font file is *not* closed and if
+      # needed must be closed by the caller once the font is not needed anymore.
+      #
+      # The first form using a file name is easier to use in one-off cases. However, if multiple
+      # documents always refer to the same font, the second form is better to avoid re-parsing the
+      # font file.
       #
       # +document+::
       #     The PDF document to associate the font object with.
       #
-      # +name+::
-      #     The file name.
+      # +file_name+/+font_object+::
+      #     The file name or TrueType font object.
       #
       # +subset+::
       #     Specifies whether the font should be subset if possible.
       def self.call(document, name, subset: true, **)
-        return nil unless File.file?(name)
+        is_font = name.kind_of?(HexaPDF::Font::TrueType::Font)
+        return nil unless is_font || File.file?(name)
 
-        font = HexaPDF::Font::TrueType::Font.new(File.open(name, 'rb'))
+        font = is_font ? name : HexaPDF::Font::TrueType::Font.new(File.open(name, 'rb'))
         HexaPDF::Font::TrueTypeWrapper.new(document, font, subset: subset)
       end