hexapdf 0.12.3 → 0.13.0

data/lib/hexapdf/serializer.rb

@@ -243,7 +243,7 @@ module HexaPDF
             else
               obj.dup
             end
-      obj.gsub!(/[\(\)\\\r]/n, STRING_ESCAPE_MAP)
+      obj.gsub!(/[()\\\r]/n, STRING_ESCAPE_MAP)
       "(#{obj})"
     end
 

data/lib/hexapdf/task/optimize.rb

@@ -129,9 +129,10 @@ module HexaPDF
             xref_stream = false
             objects_to_delete = []
             rev.each do |obj|
-              if obj.type == :ObjStm
+              case obj.type
+              when :ObjStm
                 objects_to_delete << obj
-              elsif obj.type == :XRef
+              when :XRef
                 xref_stream = true
                 objects_to_delete << obj if xref_streams == :delete
               else
@@ -150,9 +151,10 @@ module HexaPDF
             objstms = [doc.wrap({Type: :ObjStm})]
             old_objstms = []
             rev.each do |obj|
-              if obj.type == :XRef
+              case obj.type
+              when :XRef
                 xref_stream = true
-              elsif obj.type == :ObjStm
+              when :ObjStm
                 old_objstms << obj
               end
               delete_fields_with_defaults(obj)

data/lib/hexapdf/type/acro_form/choice_field.rb

@@ -148,10 +148,10 @@ module HexaPDF
         def default_field_value=(value)
           items = option_items
           self[:DV] = if [value].flatten.all? {|v| items.include?(v) }
-                       value
-                     else
-                       @document.config['acro_form.on_invalid_value'].call(self, value)
-                     end
+                        value
+                      else
+                        @document.config['acro_form.on_invalid_value'].call(self, value)
+                      end
         end
 
         # Returns the array with the available option items.

data/lib/hexapdf/type/acro_form/field.rb

@@ -236,6 +236,11 @@ module HexaPDF
           kids.nil? || kids.empty? || kids.none? {|kid| kid.key?(:T) }
         end
 
+        # Returns +true+ if the field contains an embedded widget.
+        def embedded_widget?
+          key?(:Subtype)
+        end
+
         # :call-seq:
         #   field.each_widget {|widget| block}    -> field
         #   field.each_widget                     -> Enumerator
@@ -245,7 +250,7 @@ module HexaPDF
         # See: HexaPDF::Type::Annotations::Widget
         def each_widget # :yields: widget
           return to_enum(__method__) unless block_given?
-          if self[:Subtype]
+          if embedded_widget?
             yield(document.wrap(self))
           elsif terminal_field?
             self[:Kids]&.each {|kid| yield(document.wrap(kid)) }
@@ -275,9 +280,9 @@ module HexaPDF
 
           widget_data = {Type: :Annot, Subtype: :Widget, Rect: [0, 0, 0, 0], **values}
 
-          if !allow_embedded || key?(:Subtype) || (key?(:Kids) && !self[:Kids].empty?)
+          if !allow_embedded || embedded_widget? || (key?(:Kids) && !self[:Kids].empty?)
             kids = self[:Kids] ||= []
-            kids << extract_widget if key?(:Subtype)
+            kids << extract_widget if embedded_widget?
             widget = document.add(widget_data)
             widget[:Parent] = self
             self[:Kids] << widget
@@ -291,6 +296,31 @@ module HexaPDF
           widget
         end
 
+        # Deletes the given widget annotation object from this field, the page it appears on and the
+        # document.
+        #
+        # If the given widget is not a widget of this field, nothing is done.
+        def delete_widget(widget)
+          widget = if embedded_widget? && self == widget
+                     widget
+                   elsif terminal_field?
+                     (widget_index = self[:Kids]&.index(widget)) && widget
+                   end
+
+          return unless widget
+
+          document.pages.each do |page|
+            break if page[:Annots]&.delete(widget) # See comment in #extract_widget
+          end
+
+          if embedded_widget?
+            WIDGET_FIELDS.each {|key| delete(key) }
+          else
+            self[:Kids].delete_at(widget_index)
+            document.delete(widget)
+          end
+        end
+
         private
 
         # An array of all widget annotation field names.
@@ -300,14 +330,14 @@ module HexaPDF
         # directly in the field and adjust the references accordingly. If the field doesn't have any
         # widget data, +nil+ is returned.
         def extract_widget
-          return unless key?(:Subtype)
+          return unless embedded_widget?
           data = WIDGET_FIELDS.each_with_object({}) do |key, hash|
             hash[key] = delete(key) if key?(key)
           end
           widget = document.add(data, type: :Annot)
           widget[:Parent] = self
           document.pages.each do |page|
-            if page.key?(:Annots) && (index = page[:Annots].index {|annot| annot.data == self.data })
+            if page.key?(:Annots) && (index = page[:Annots].index(self))
               page[:Annots][index] = widget
               break # Each annotation dictionary may only appear on one page, see PDF1.7 12.5.2
             end

data/lib/hexapdf/type/acro_form/form.rb

@@ -191,7 +191,8 @@ module HexaPDF
 
         # Returns the dictionary containing the default resources for form field appearance streams.
         def default_resources
-          self[:DR] ||= document.wrap({}, type: :XXResources)
+          self[:DR] ||= document.wrap({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]},
+                                      type: :XXResources)
         end
 
         # Sets the global default appearance string using the provided values.
@@ -249,14 +250,15 @@ module HexaPDF
         end
 
         def perform_validation # :nodoc:
+          super
+
           if (da = self[:DA])
             unless self[:DR]
               yield("When the field /DA is present, the field /DR must also be present")
+              return
             end
             font_name = nil
-            HexaPDF::Content::Parser.parse(da) do |obj, params|
-              font_name = params[0] if obj == :Tf
-            end
+            HexaPDF::Content::Parser.parse(da) {|obj, params| font_name = params[0] if obj == :Tf }
             if font_name && !(self[:DR][:Font] && self[:DR][:Font][font_name])
               yield("The font specified in /DA is not in the /DR resource dictionary")
             end

data/lib/hexapdf/type/acro_form/text_field.rb

@@ -173,8 +173,9 @@ module HexaPDF
 
           if self[:V] && !(self[:V].kind_of?(String) || self[:V].kind_of?(HexaPDF::Stream))
             yield("Text field doesn't contain text but #{self[:V].class} object")
+            return
           end
-          if (max_len = self[:MaxLen]) && field_value.length > max_len
+          if (max_len = self[:MaxLen]) && field_value && field_value.length > max_len
             yield("Text contents of field '#{full_field_name}' is too long")
           end
         end

data/lib/hexapdf/type/actions/uri.rb

@@ -53,9 +53,10 @@ module HexaPDF
 
         def perform_validation #:nodoc:
           super
-          unless self[:URI].ascii_only?
+          uri = self[:URI]
+          if uri && !uri.ascii_only?
             yield("URIs have to contain ASCII characters only", true)
-            uri = self[:URI].dup.force_encoding(Encoding::BINARY)
+            uri = uri.dup.force_encoding(Encoding::BINARY)
             uri.encode!(Encoding::US_ASCII, fallback: lambda {|c| "%#{c.ord.to_s(16).upcase}" })
             self[:URI] = uri
           end

data/lib/hexapdf/type/annotations/widget.rb

@@ -307,10 +307,9 @@ module HexaPDF
             color = [0]
             if (da = self[:DA] || field[:DA])
               HexaPDF::Content::Parser.parse(da) do |obj, params|
-                if obj == :rg || obj == :g || obj == :k
-                  color = params.dup
-                elsif obj == :Tf
-                  size = params[1]
+                case obj
+                when :rg, :g, :k then color = params.dup
+                when :Tf then size = params[1]
                 end
               end
             end

data/lib/hexapdf/type/catalog.rb

@@ -120,12 +120,12 @@ module HexaPDF
       private
 
       # Ensures that there is a valid page tree.
-      def perform_validation
+      def perform_validation(&block)
         super
         unless key?(:Pages)
           yield("A PDF document needs a page tree", true)
           value[:Pages] = document.add({Type: :Pages})
-          value[:Pages].validate {|msg, correctable| yield(msg, correctable) }
+          value[:Pages].validate(&block)
         end
       end
 

data/lib/hexapdf/type/file_specification.rb

@@ -220,7 +220,7 @@ module HexaPDF
 
         if document.catalog.key?(:Names) && document.catalog[:Names].key?(:EmbeddedFiles)
           tree = document.catalog[:Names][:EmbeddedFiles]
-          tree.each_entry.find_all {|_, spec| document.deref(spec) == self }.each do |(name, _)|
+          tree.each_entry.find_all {|_, spec| spec == self }.each do |(name, _)|
             tree.delete_entry(name)
           end
         end

data/lib/hexapdf/type/font_simple.rb

@@ -170,7 +170,9 @@ module HexaPDF
         [:FirstChar, :LastChar, :Widths].each do |field|
           yield("Required field #{field} is not set", false) if self[field].nil?
         end
-        if self[:Widths].length != (self[:LastChar] - self[:FirstChar] + 1)
+
+        if key?(:Widths) && key?(:LastChar) && key?(:FirstChar) &&
+            self[:Widths].length != (self[:LastChar] - self[:FirstChar] + 1)
           yield("Invalid number of entries in field Widths", false)
         end
       end

data/lib/hexapdf/type/font_true_type.rb

@@ -48,8 +48,12 @@ module HexaPDF
       private
 
       def perform_validation
-        super
-        yield("Required field FontDescriptor is not set", false) if self[:FontDescriptor].nil?
+        std_font = FontType1::StandardFonts.standard_font?(self[:BaseFont])
+        super(ignore_missing_font_fields: std_font)
+
+        if self[:FontDescriptor].nil? && !std_font
+          yield("Required field FontDescriptor is not set", false)
+        end
       end
 
     end

data/lib/hexapdf/type/font_type0.rb

@@ -59,7 +59,7 @@ module HexaPDF
       # Returns the CID font of this type 0 font.
       def descendant_font
         document.cache(@data, :descendant_font) do
-          document.wrap(document.deref(self[:DescendantFonts][0]))
+          document.wrap(self[:DescendantFonts][0])
         end
       end
 

data/lib/hexapdf/type/form.rb

@@ -101,7 +101,8 @@ module HexaPDF
 
       # Returns the resource dictionary which is automatically created if it doesn't exist.
       def resources
-        self[:Resources] ||= document.wrap({}, type: :XXResources)
+        self[:Resources] ||= document.wrap({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]},
+                                           type: :XXResources)
       end
 
       # Processes the content stream of the form XObject with the given processor object.

data/lib/hexapdf/type/image.rb

@@ -150,7 +150,7 @@ module HexaPDF
         color_space, = *self[:ColorSpace]
         if color_space == :Indexed
           result.indexed = true
-          color_space, = *document.deref(self[:ColorSpace][1])
+          color_space, = *self[:ColorSpace][1]
         end
         case color_space
         when :DeviceRGB, :CalRGB
@@ -240,7 +240,7 @@ module HexaPDF
         end
 
         if color_type == ImageLoader::PNG::INDEXED
-          palette_data = document.deref(self[:ColorSpace][3])
+          palette_data = self[:ColorSpace][3]
           palette_data = palette_data.stream unless palette_data.kind_of?(String)
           palette = ''.b
           if info.color_space == :rgb

data/lib/hexapdf/type/page.rb

@@ -304,7 +304,7 @@ module HexaPDF
       def contents
         Array(self[:Contents]).each_with_object("".b) do |content_stream, content|
           content << " " unless content.empty?
-          content << document.deref(content_stream).stream
+          content << content_stream.stream
         end
       end
 
@@ -323,10 +323,11 @@ module HexaPDF
         end
       end
 
-      # Returns the possibly inherited resource dictionary which is automatically created if it
+      # Returns the, possibly inherited, resource dictionary which is automatically created if it
       # doesn't exist.
       def resources
-        self[:Resources] ||= document.wrap({}, type: :XXResources)
+        self[:Resources] ||= document.wrap({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]},
+                                           type: :XXResources)
       end
 
       # Processes the content streams associated with the page with the given processor object.
@@ -344,8 +345,7 @@ module HexaPDF
         node = self
         while (parent_node = node[:Parent])
           parent_node[:Kids].each do |kid|
-            kid = document.deref(kid)
-            break if kid.data == node.data
+            break if kid == node
             idx += (kid.type == :Page ? 1 : kid[:Count])
           end
           node = parent_node
@@ -353,6 +353,16 @@ module HexaPDF
         idx
       end
 
+      # Returns all parent nodes of the page up to the root of the page tree.
+      #
+      # The direct parent is the first node in the array and the root node the last.
+      def ancestor_nodes
+        parent = self[:Parent]
+        result = [parent]
+        result << parent while (parent = parent[:Parent])
+        result
+      end
+
       # Returns the requested type of canvas for the page.
       #
       # The canvas object is cached once it is created so that its graphics state is correctly
@@ -463,8 +473,7 @@ module HexaPDF
         REQUIRED_INHERITABLE_FIELDS.each do |name|
           next if self[name]
           yield("Inheritable page field #{name} not set", name == :Resources)
-          self[:Resources] = {}
-          self[:Resources].validate(&block)
+          resources.validate(&block) if name == :Ressources
         end
       end
 

data/lib/hexapdf/type/page_tree_node.rb

@@ -172,11 +172,10 @@ module HexaPDF
         return unless page && !page.null? && page[:Parent]
 
         parent = page[:Parent]
-        index = parent[:Kids].index {|kid| kid.data == page.data }
+        index = parent[:Kids].index(page)
 
         if index
-          ancestors = [parent]
-          ancestors << parent while (parent = parent[:Parent])
+          ancestors = page.ancestor_nodes
           return nil unless ancestors.include?(self)
 
           page[:Parent][:Kids].delete_at(index)
@@ -188,6 +187,31 @@ module HexaPDF
         end
       end
 
+      # :call-seq:
+      #   pages.move_page(page, to_index)
+      #   pages.move_page(index, to_index)
+      #
+      # Moves the given page or the page at the position specified by the zero-based index to the
+      # +to_index+ position.
+      #
+      # If the page that should be moved, doesn't exist or is invalid, an error is raised.
+      #
+      # Negative indices count backwards from the end, i.e. -1 is the last page. When using a
+      # negative index, the page will be moved after that element. So using an index of -1 will
+      # move the page after the last page.
+      def move_page(page, to_index)
+        page = self.page(page) if page.kind_of?(Integer)
+        if page.nil? || page.null? || !page[:Parent] ||
+            !(ancestors = page.ancestor_nodes).include?(self)
+          raise HexaPDF::Error, "The page to be moved doesn't exist in this page tree"
+        end
+
+        parent = page[:Parent]
+        insert_page(to_index, page)
+        ancestors.each {|node| node[:Count] -= 1 }
+        parent[:Kids].delete(page)
+      end
+
       # :call-seq:
       #   pages.each_page {|page| block }   -> pages
       #   pages.each_page                   -> Enumerator
@@ -222,7 +246,7 @@ module HexaPDF
       # Ensures that the /Count and /Parent fields of the whole page tree are set up correctly and
       # that there is at least one page node. This is therefore only done for the root node of the
       # page tree!
-      def perform_validation
+      def perform_validation(&block)
         super
         return if key?(:Parent)
 
@@ -255,7 +279,7 @@ module HexaPDF
 
         if self[:Count] == 0
           yield("A PDF document needs at least one page", true)
-          add_page.validate {|msg, correctable| yield(msg, correctable) }
+          add_page.validate(&block)
         end
       end
 

data/lib/hexapdf/type/resources.rb

@@ -219,6 +219,7 @@ module HexaPDF
         super
         val = self[:ProcSet]
         if !val
+          yield("No procedure set specified", true)
           self[:ProcSet] = [:PDF, :Text, :ImageB, :ImageC, :ImageI]
         else
           val.reject! do |name|

data/lib/hexapdf/type/trailer.rb

@@ -97,7 +97,7 @@ module HexaPDF
       private
 
       # Validates the trailer.
-      def perform_validation
+      def perform_validation(&block)
         super
         unless value[:ID]
           msg = if value[:Encrypt]
@@ -111,8 +111,7 @@ module HexaPDF
 
         unless value[:Root]
           yield("A PDF document must have a Catalog dictionary", true)
-          value[:Root] = document.add({Type: :Catalog})
-          value[:Root].validate {|message, correctable| yield(message, correctable) }
+          catalog.validate(&block)
         end
 
         if value[:Encrypt] && (!document.security_handler ||

data/lib/hexapdf/utils/sorted_tree_node.rb

@@ -143,12 +143,12 @@ module HexaPDF
         stack.reverse_each.inject do |nested_node, node|
           if (!nested_node[container_name] || nested_node[container_name].empty?) &&
               (!nested_node[:Kids] || nested_node[:Kids].empty?)
-            node[:Kids].delete_at(node[:Kids].index {|n| document.deref(n) == nested_node })
+            node[:Kids].delete(nested_node)
             document.delete(nested_node)
           end
           if !node[:Kids].empty? && node[:Limits]
-            node[:Limits][0] = document.deref(node[:Kids][0])[:Limits][0]
-            node[:Limits][1] = document.deref(node[:Kids][-1])[:Limits][1]
+            node[:Limits][0] = node[:Kids][0][:Limits][0]
+            node[:Limits][1] = node[:Kids][-1][:Limits][1]
           end
           node
         end
@@ -167,11 +167,11 @@ module HexaPDF
           if node.key?(container_name)
             index = find_in_leaf_node(node[container_name], key)
             if node[container_name][index] == key
-              result = document.deref(node[container_name][index + 1])
+              result = node[container_name][index + 1]
             end
           elsif node.key?(:Kids)
             index = find_in_intermediate_node(node[:Kids], key)
-            node = document.deref(node[:Kids][index])
+            node = node[:Kids][index]
             break unless key >= node[:Limits][0] && key <= node[:Limits][1]
           else
             break
@@ -192,12 +192,12 @@ module HexaPDF
         container_name = leaf_node_container_name
         stack = [self]
         until stack.empty?
-          node = document.deref(stack.pop)
+          node = stack.pop
           if node.key?(container_name)
             data = node[container_name]
             index = 0
             while index < data.length
-              yield(data[index], document.deref(data[index + 1]))
+              yield(data[index], data[index + 1])
               index += 2
             end
           elsif node.key?(:Kids)
@@ -215,7 +215,7 @@ module HexaPDF
       def path_to_key(node, key, stack)
         return unless node.key?(:Kids)
         index = find_in_intermediate_node(node[:Kids], key)
-        stack << document.deref(node[:Kids][index])
+        stack << node[:Kids][index]
         path_to_key(stack.last, key, stack)
       end
 
@@ -226,7 +226,7 @@ module HexaPDF
         right = array.length - 1
         while left < right
           mid = (left + right) / 2
-          limits = document.deref(array[mid])[:Limits]
+          limits = array[mid][:Limits]
           if limits[1] < key
             left = mid + 1
           elsif limits[0] > key
@@ -295,7 +295,7 @@ module HexaPDF
           node[container_name] = leaf_node[container_name].slice!(split_point..-1)
           node[:Limits] = node[container_name].values_at(0, -2)
           leaf_node[:Limits][1] = leaf_node[container_name][-2]
-          index = 1 + parent[:Kids].index {|o| document.deref(o) == leaf_node }
+          index = 1 + parent[:Kids].index {|o| o == leaf_node }
           parent[:Kids].insert(index, node)
         end
       end
@@ -307,10 +307,10 @@ module HexaPDF
 
         # All kids entries must be indirect objects
         if key?(:Kids)
-          self[:Kids].each do |kid|
-            unless (kid.kind_of?(HexaPDF::Object) && kid.indirect?) ||
-                kid.kind_of?(HexaPDF::Reference)
-              yield("Child entries of sorted tree nodes must be indirect objects", false)
+          self[:Kids].each_with_index do |kid, index|
+            unless kid.kind_of?(HexaPDF::Object) && kid.indirect?
+              yield("Child entries of sorted tree nodes must be indirect objects", true)
+              value[:Kids][index] = document.add(kid)
             end
           end
         end
@@ -321,15 +321,18 @@ module HexaPDF
           container = self[container_name]
           if container.length.odd?
             yield("Sorted tree leaf node contains odd number of entries", false)
+            return
           end
           index = 0
           old = nil
           while index < container.length
-            key = document.unwrap(container[index])
+            key = container[index]
             if !key.kind_of?(key_type)
               yield("A key must be a #{key_type} object, not a #{key.class}", false)
+              return
             elsif old && old > key
               yield("Sorted tree leaf node entries are not correctly sorted", false)
+              return
             end
             old = key
             index += 2