hexapdf 0.12.0 → 0.14.0

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)
@@ -163,7 +163,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 +182,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
@@ -273,7 +273,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

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/encoding/base.rb

@@ -73,6 +73,14 @@ module HexaPDF
           @unicode_cache[code] ||= GlyphList.name_to_unicode(name(code))
         end
 
+        # Returns the code for the given glyph name (a Symbol) or +nil+ if there is no code for the
+        # given glyph name.
+        #
+        # If multiple codes reference the given glyph name, the first found is always returned.
+        def code(name)
+          @code_to_name.key(name)
+        end
+
       end
 
     end

data/lib/hexapdf/font/encoding/difference_encoding.rb

@@ -60,6 +60,12 @@ module HexaPDF
           code_to_name[code] || base_encoding.name(code)
         end
 
+        # Returns the code for the given glyph name, either from this object, if a code references
+        # the name, or from the base encoding.
+        def code(name)
+          code_to_name.key(name) || base_encoding.code(name)
+        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/type1_wrapper.rb

@@ -192,7 +192,7 @@ module HexaPDF
             if glyph.name == @wrapped_font.missing_glyph_id
               raise HexaPDF::Error, "Glyph for #{glyph.str.inspect} missing"
             end
-            code = @encoding.code_to_name.key(glyph.name)
+            code = @encoding.code(glyph.name)
             if code
               code.chr.freeze
             elsif @max_code < 255

data/lib/hexapdf/image_loader/png.rb

@@ -162,9 +162,10 @@ module HexaPDF
                 io.seek(length, IO::SEEK_CUR)
               end
             when 'tRNS' # PNG s11.3.2
-              if @color_type == INDEXED
+              case @color_type
+              when INDEXED
                 trns = io.read(length).unpack('C*')
-              elsif @color_type == TRUECOLOR || @color_type == GREYSCALE
+              when TRUECOLOR, GREYSCALE
                 dict[:Mask] = io.read(length).unpack('n*').map {|val| [val, val] }.flatten
               else
                 io.seek(length, IO::SEEK_CUR)

data/lib/hexapdf/layout/line.rb

@@ -198,7 +198,7 @@ module HexaPDF
       # Note: The cache is not cleared!
       def add(item)
         last = @items.last
-        if last.class == item.class && item.kind_of?(TextFragment) && last.style == item.style
+        if last.instance_of?(item.class) && item.kind_of?(TextFragment) && last.style == item.style
           if last.items.frozen?
             @items[-1] = last = last.dup
             last.items = last.items.dup

data/lib/hexapdf/layout/style.rb

@@ -524,7 +524,7 @@ module HexaPDF
       #   Style.new(font_size: 15, align: :center, valign: center)
       def initialize(**properties)
         update(**properties)
-        @scaled_item_widths = {}
+        @scaled_item_widths = {}.compare_by_identity
       end
 
       # Duplicates the complex properties that can be modified, as well as the cache.
@@ -883,41 +883,41 @@ module HexaPDF
         [:text_rise, 0],
         [:font_features, {}],
         [:text_rendering_mode, "Content::TextRenderingMode::FILL",
-         setter: "Content::TextRenderingMode.normalize(value)"],
+         {setter: "Content::TextRenderingMode.normalize(value)"}],
         [:subscript, false,
-         setter: "value; superscript(false) if superscript",
-         valid_values: [true, false]],
+         {setter: "value; superscript(false) if superscript",
+          valid_values: [true, false]}],
         [:superscript, false,
-         setter: "value; subscript(false) if subscript",
-         valid_values: [true, false]],
-        [:underline, false, valid_values: [true, false]],
-        [:strikeout, false, valid_values: [true, false]],
+         {setter: "value; subscript(false) if subscript",
+          valid_values: [true, false]}],
+        [:underline, false, {valid_values: [true, false]}],
+        [:strikeout, false, {valid_values: [true, false]}],
         [:fill_color, "default_color"],
         [:fill_alpha, 1],
         [:stroke_color, "default_color"],
         [:stroke_alpha, 1],
         [:stroke_width, 1],
         [:stroke_cap_style, "Content::LineCapStyle::BUTT_CAP",
-         setter: "Content::LineCapStyle.normalize(value)"],
+         {setter: "Content::LineCapStyle.normalize(value)"}],
         [:stroke_join_style, "Content::LineJoinStyle::MITER_JOIN",
-         setter: "Content::LineJoinStyle.normalize(value)"],
+         {setter: "Content::LineJoinStyle.normalize(value)"}],
         [:stroke_miter_limit, 10.0],
         [:stroke_dash_pattern, "Content::LineDashPattern.new",
-         setter: "Content::LineDashPattern.normalize(value, phase)", extra_args: ", phase = 0"],
-        [:align, :left, valid_values: [:left, :center, :right, :justify]],
-        [:valign, :top, valid_values: [:top, :center, :bottom]],
+         {setter: "Content::LineDashPattern.normalize(value, phase)", extra_args: ", phase = 0"}],
+        [:align, :left, {valid_values: [:left, :center, :right, :justify]}],
+        [:valign, :top, {valid_values: [:top, :center, :bottom]}],
         [:text_indent, 0],
         [:line_spacing, "LineSpacing.new(type: :single)",
-         setter: "LineSpacing.new(**(value.kind_of?(Symbol) ? {type: value, value: extra_arg} : value))",
-         extra_args: ", extra_arg = nil"],
-        [:last_line_gap, false, valid_values: [true, false]],
+         {setter: "LineSpacing.new(**(value.kind_of?(Symbol) ? {type: value, value: extra_arg} : value))",
+          extra_args: ", extra_arg = nil"}],
+        [:last_line_gap, false, {valid_values: [true, false]}],
         [:background_color, nil],
-        [:padding, "Quad.new(0)", setter: "Quad.new(value)"],
-        [:margin, "Quad.new(0)", setter: "Quad.new(value)"],
-        [:border, "Border.new", setter: "Border.new(**value)"],
-        [:overlays, "Layers.new", setter: "Layers.new(value)"],
-        [:underlays, "Layers.new", setter: "Layers.new(value)"],
-        [:position, :default, valid_values: [:default, :float, :flow, :absolute]],
+        [:padding, "Quad.new(0)", {setter: "Quad.new(value)"}],
+        [:margin, "Quad.new(0)", {setter: "Quad.new(value)"}],
+        [:border, "Border.new", {setter: "Border.new(**value)"}],
+        [:overlays, "Layers.new", {setter: "Layers.new(value)"}],
+        [:underlays, "Layers.new", {setter: "Layers.new(value)"}],
+        [:position, :default, {valid_values: [:default, :float, :flow, :absolute]}],
         [:position_hint, nil],
       ].each do |name, default, options = {}|
         default = default.inspect unless default.kind_of?(String)
@@ -1075,7 +1075,7 @@ module HexaPDF
       # The item may be a (singleton) glyph object or an integer/float, i.e. items that can appear
       # inside a TextFragment.
       def scaled_item_width(item)
-        @scaled_item_widths[item.object_id] ||=
+        @scaled_item_widths[item] ||=
           begin
             if item.kind_of?(Numeric)
               -item * scaled_font_size

data/lib/hexapdf/layout/text_layouter.rb

@@ -388,7 +388,7 @@ module HexaPDF
               end
             when :penalty
               if item.penalty <= -Penalty::INFINITY
-                add_box_item(item.item) if item.item
+                add_box_item(item.item) if item.width > 0
                 break unless yield(create_unjustified_line, item)
                 reset_after_line_break(index + 1)
               elsif item.penalty >= Penalty::INFINITY
@@ -458,7 +458,7 @@ module HexaPDF
               end
             when :penalty
               if item.penalty <= -Penalty::INFINITY
-                add_box_item(item.item) if item.item
+                add_box_item(item.item) if item.width > 0
                 break unless (action = yield(create_unjustified_line, item))
                 reset_after_line_break_variable_width(index + 1, true, action)
               elsif item.penalty >= Penalty::INFINITY