hexapdf 0.12.3 → 0.14.3

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/cid_font.rb

@@ -95,7 +95,7 @@ module HexaPDF
       #
       # See: PDF1.7 s9.7.4.3
       def widths
-        document.cache(@data, :widths) do
+        cache(:widths) do
           result = {}
           index = 0
           array = self[:W] || []

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.rb

@@ -102,7 +102,7 @@ module HexaPDF
 
       # Parses and caches the ToUnicode CMap.
       def to_unicode_cmap
-        document.cache(@data, :to_unicode_cmap) do
+        cache(:to_unicode_cmap) do
           if key?(:ToUnicode)
             HexaPDF::Font::CMap.parse(self[:ToUnicode].stream)
           else

data/lib/hexapdf/type/font_simple.rb

@@ -57,7 +57,7 @@ module HexaPDF
       #
       # Note that the encoding is cached internally when accessed the first time.
       def encoding
-        document.cache(@data, :encoding) do
+        cache(:encoding) do
           case (val = self[:Encoding])
           when Symbol
             encoding = HexaPDF::Font::Encoding.for_name(val)
@@ -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

@@ -58,8 +58,8 @@ 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]))
+        cache(:descendant_font) do
+          document.wrap(self[:DescendantFonts][0])
         end
       end
 
@@ -116,7 +116,7 @@ module HexaPDF
       #
       # Note that the CMap is cached internally when accessed the first time.
       def cmap
-        document.cache(@data, :cmap) do
+        cache(:cmap) do
           val = self[:Encoding]
           if val.kind_of?(Symbol)
             HexaPDF::Font::CMap.for_name(val.to_s)
@@ -135,7 +135,7 @@ module HexaPDF
       #
       # See: PDF1.7 s9.10.2
       def ucs2_cmap
-        document.cache(@data, :ucs2_cmap) do
+        cache(:ucs2_cmap) do
           encoding = self[:Encoding]
           system_info = descendant_font[:CIDSystemInfo]
           registry = system_info[:Registry]

data/lib/hexapdf/type/form.rb

@@ -94,14 +94,18 @@ module HexaPDF
 
       # Replaces the contents of the form XObject with the given string.
       #
+      # This also clears the cache to avoid returning invalid objects.
+      #
       # Note: This is the same as #stream= but here for interface compatibility with Page.
       def contents=(data)
         self.stream = data
+        clear_cache
       end
 
       # 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.
@@ -133,7 +137,7 @@ module HexaPDF
       #
       # *Note* that a canvas can only be retrieved for initially empty form XObjects!
       def canvas
-        document.cache(@data, :canvas) do
+        cache(:canvas) do
           unless stream.empty?
             raise HexaPDF::Error, "Cannot create a canvas for a form XObjects with contents"
           end

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
@@ -373,7 +383,7 @@ module HexaPDF
           raise ArgumentError, "Invalid value for 'type', expected: :page, :underlay or :overlay"
         end
         cache_key = "#{type}_canvas".intern
-        return document.cache(@data, cache_key) if document.cached?(@data, cache_key)
+        return cache(cache_key) if cached?(cache_key)
 
         if type == :page && key?(:Contents)
           raise HexaPDF::Error, "Cannot get the canvas for a page with contents"
@@ -390,14 +400,14 @@ module HexaPDF
 
         contents = self[:Contents]
         if contents.nil?
-          page_canvas = document.cache(@data, :page_canvas, create_canvas.call)
+          page_canvas = cache(:page_canvas, create_canvas.call)
           self[:Contents] = document.add({Filter: :FlateDecode},
                                          stream: page_canvas.stream_data)
         end
 
         if type == :overlay || type == :underlay
-          underlay_canvas = document.cache(@data, :underlay_canvas, create_canvas.call)
-          overlay_canvas = document.cache(@data, :overlay_canvas, create_canvas.call)
+          underlay_canvas = cache(:underlay_canvas, create_canvas.call)
+          overlay_canvas = cache(:overlay_canvas, create_canvas.call)
 
           stream = HexaPDF::StreamData.new do
             Fiber.yield(" q ")
@@ -422,7 +432,7 @@ module HexaPDF
           self[:Contents] = [underlay, *self[:Contents], overlay]
         end
 
-        document.cache(@data, cache_key)
+        cache(cache_key)
       end
 
       # Creates a Form XObject from the page's dictionary and contents for the given PDF document.
@@ -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,8 +219,13 @@ module HexaPDF
         super
         val = self[:ProcSet]
         if !val
+          yield("No procedure set specified", true)
           self[:ProcSet] = [:PDF, :Text, :ImageB, :ImageC, :ImageI]
         else
+          if val.kind_of?(Symbol)
+            yield("Procedure set is a single value instead of an Array", true)
+            val = value[:ProcSet] = [val]
+          end
           val.reject! do |name|
             case name
             when :PDF, :Text, :ImageB, :ImageC, :ImageI

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/object_hash.rb

@@ -125,7 +125,6 @@ module HexaPDF
       def oids
         @oids.keys
       end
-      private :oids
 
     end
 

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