hexapdf 0.26.2 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f7ff4db8b6417cf6f0101a2e72e2481571a40c9542713be82753376d58c047c
-  data.tar.gz: 0b62a42fe5b91bdd8f11c4c31105e560cd4cf2f27259a86b9fd07db2f2280d6e
+  metadata.gz: 57b852a0648f47b5e3443e9b8aa4480a7a8cd187085c0067baf86af14cee7d9a
+  data.tar.gz: 6e28f748f1d8e089b6585748e2f56c3adf79669cf9b00d0d9fe8d83a74e97063
 SHA512:
-  metadata.gz: 0ef60dd2da6c1c233768e564c5afb9330fb07065a33f293a2fbca6c71b8948d2ab754b2c9383ed4a84400e944e98f6c5a3638bf0c970c2b819eb53a0e024a2ca
-  data.tar.gz: 9c0190529f0d25d9ec655bef27d25054b9bfb5dc2ec980742807e73e0eb953550033f5362249cad1ec83ff8e78a1f1ad91785614cecdbaed113ad6365a77ade5
+  metadata.gz: a1d2cd75344a3fc9cd54f0dafa6a0fd23b9821d67f54581090a6db2820f7e04a0989da01d7b5f9c558e02bb57cf254f4ebaab791b950d4dacc1e02a29c5f3844
+  data.tar.gz: ea758cdeb96d8282e3c6581785b690b8d79e9bee318a7cf80bfb4201b47fc0f1d721a78b5c703b32f20b8671211b604e78f83dec6768187321fef46e5dac3a81

data/CHANGELOG.md

@@ -1,3 +1,59 @@
+## 0.27.0 - 2022-11-18
+
+### Added
+
+* Support for timestamp signatures through the
+  [HexaPDF::Document::Signatures::TimestampHandler]
+* [HexaPDF::Document::Destinations#resolve] for resolving destination values
+* [HexaPDF::Document::Destinations::Destination#value] to return the destination
+  array
+* Support for verifying document timestamp signatures
+* [HexaPDF::Document::Signatures::DefaultHandler#signature_size] to support
+  setting custom signature sizes
+* [HexaPDF::Document::Signatures::DefaultHandler#external_signing] to support
+  signing via custom mechanisms
+* [HexaPDF::Document::Signatures::embed_signature] to enable asynchronous
+  external signing
+
+### Changed
+
+* **Breaking change**: The crop box is now used instead of the media box in most
+  cases to be in line with the specification
+* [HexaPDF::Document::Signatures::DefaultHandler] to allow setting the used
+  signature method
+* **Breaking change**: [HexaPDF::Document::Signatures::DefaultHandler#sign]
+  needs to accept the IO object and the byte range instead of just the data
+* **Breaking change**: Enhanced support for outline items with new methods
+  `#level` and `#destination_page` as well as changes to `#add` and `#each_item`
+* **Breaking change**: Removed `#filter_name` and `#sub_filter_name` from
+  [HexaPDF::Document::Signatures::DefaultHandler]
+* `HexaPDF::Type::Resources#perform_validation` to not add a default procedure
+  set since this feature is deprecated
+
+### Fixed
+
+* [HexaPDF::Document::Destinations::Destination::new] to also accept a hash
+* [HexaPDF::Type::Catalog] auto-conversion of /Outlines to correct class
+* [HexaPDF::Type::AcroForm::Form#flatten] to return the unflattened form fields
+  instead of the widgets
+* [HexaPDF::Writer#write_incremental] to set the /Version in the catalog
+  dictionary when necessary
+* [HexaPDF::Importer#import] to always return an imported object with the same
+  class as the argument
+* [HexaPDF::Type::OutlineItem] to always be an indirect object
+* `HexaPDF::Tokenizer#parse_number` to handle references correctly in all cases
+* [HexaPDF::Type::Page#rotate] to correctly flatten all page boxes
+* [HexaPDF::Document::Signatures#add] to raise an error if the reserved space
+  for the signature is not enough
+* `HexaPDF::Type::AcroForm::Form#perform_validation` to fix broken /Parent
+  entries and to remove invalid objects from the field hierarchy
+* `HexaPDF::Type::OutlineItem#perform_validation` bug where a missing /Count key
+  was deemed invalid
+* [HexaPDF::Revisions::from_io] to use the correct /Prev offset when revisions
+  have been merged
+* Handling of indirect objects with invalid values for more situations
+
+
 ## 0.26.2 - 2022-10-22
 
 ### Added

data/README.md

@@ -91,7 +91,7 @@ with example graphics and PDF files and tightly integrated into the rest of the
 ## Requirements and Installation
 
 Since HexaPDF is written in Ruby, a working Ruby installation is needed - see the
-[official installation documentation][rbinstall] for details. Note that you need Ruby version 2.5 or
+[official installation documentation][rbinstall] for details. Note that you need Ruby version 2.6 or
 higher as prior versions are not supported!
 
 HexaPDF works on all Ruby implementations that are CRuby compatible, e.g. TruffleRuby, and on any

data/examples/013-text_layouter_shapes.rb

@@ -73,14 +73,14 @@ canvas.circle(0, circle_top - radius, radius).stroke
 # Center: full circle
 layouter.style.align = :justify
 result = layouter.fit(items, circle, radius * 2)
-result.draw(canvas, page.box(:media).width / 2.0 - radius, circle_top)
-canvas.circle(page.box(:media).width / 2.0, circle_top - radius, radius).stroke
+result.draw(canvas, page.box.width / 2.0 - radius, circle_top)
+canvas.circle(page.box.width / 2.0, circle_top - radius, radius).stroke
 
 # Right: left half circle
 layouter.style.align = :right
 result = layouter.fit(items, left_half_circle, radius * 2)
-result.draw(canvas, page.box(:media).width - radius, circle_top)
-canvas.circle(page.box(:media).width, circle_top - radius, radius).stroke
+result.draw(canvas, page.box.width - radius, circle_top)
+canvas.circle(page.box.width, circle_top - radius, radius).stroke
 
 
 ########################################################################
@@ -115,7 +115,7 @@ canvas.polyline(0, diamond_top, diamond_width, diamond_top - diamond_width,
 # Center: full diamond
 layouter.style.align = :justify
 result = layouter.fit(items, full_diamond, 2 * diamond_width)
-left = page.box(:media).width / 2.0 - diamond_width
+left = page.box.width / 2.0 - diamond_width
 result.draw(canvas, left, diamond_top)
 canvas.polyline(left + diamond_width, diamond_top,
                 left + 2 * diamond_width, diamond_top - diamond_width,
@@ -125,7 +125,7 @@ canvas.polyline(left + diamond_width, diamond_top,
 # Right: left half diamond
 layouter.style.align = :right
 result = layouter.fit(items, left_half_diamond, 2 * diamond_width)
-middle = page.box(:media).width
+middle = page.box.width
 result.draw(canvas, middle - diamond_width, diamond_top)
 canvas.polyline(middle, diamond_top,
                 middle - diamond_width, diamond_top - diamond_width,
@@ -144,7 +144,7 @@ sine_wave = lambda do |height, line_height|
 end
 layouter.style.align = :justify
 result = layouter.fit(items, sine_wave, sine_wave_height)
-middle = page.box(:media).width / 2.0
+middle = page.box.width / 2.0
 result.draw(canvas, middle - (sine_wave_height + 100) / 2, sine_wave_top)
 
 ########################################################################
@@ -170,7 +170,7 @@ end
 layouter.style.align = :justify
 result = layouter.fit(items, house, 200)
 
-middle = page.box(:media).width / 2.0
+middle = page.box.width / 2.0
 result.draw(canvas, middle - (outer_width / 2), house_top)
 
 doc.write("text_layouter_shapes.pdf", optimize: true)

data/examples/016-frame_automatic_box_placement.rb

@@ -20,11 +20,11 @@ include HexaPDF::Layout
 
 doc = HexaPDF::Document.new
 page = doc.pages.add
-media_box = page.box(:media)
+page_box = page.box
 canvas = page.canvas
 
-frame = Frame.new(media_box.left + 20, media_box.bottom + 20,
-                  media_box.width - 40, media_box.height - 40)
+frame = Frame.new(page_box.left + 20, page_box.bottom + 20,
+                  page_box.width - 40, page_box.height - 40)
 
 box_counter = 1
 draw_box = lambda do |**args|

data/examples/017-frame_text_flow.rb

@@ -20,9 +20,9 @@ include HexaPDF::Utils::GraphicsHelpers
 doc = HexaPDF::Document.new
 
 page = doc.pages.add
-media_box = page.box(:media)
-frame = Frame.new(media_box.left + 20, media_box.bottom + 20,
-                  media_box.width - 40, media_box.height - 40)
+page_box = page.box
+frame = Frame.new(page_box.left + 20, page_box.bottom + 20,
+                  page_box.width - 40, page_box.height - 40)
 
 boxes = []
 boxes << doc.layout.image_box(File.join(__dir__, 'machupicchu.jpg'),

data/examples/020-column_box.rb

@@ -15,9 +15,9 @@ require 'hexapdf'
 
 doc = HexaPDF::Document.new
 page = doc.pages.add
-media_box = page.box(:media)
-frame = HexaPDF::Layout::Frame.new(media_box.left + 20, media_box.bottom + 20,
-                                   media_box.width - 40, media_box.height - 40)
+page_box = page.box
+frame = HexaPDF::Layout::Frame.new(page_box.left + 20, page_box.bottom + 20,
+                                   page_box.width - 40, page_box.height - 40)
 
 boxes = []
 5.times do

data/lib/hexapdf/cli/split.rb

@@ -114,7 +114,7 @@ module HexaPDF
         end
 
         doc.pages.each do |page|
-          out = out_files[page_size_name(page.box(:media).value)]
+          out = out_files[page_size_name(page.box.value)]
           out.pages.add(out.import(page))
         end
 
@@ -125,18 +125,18 @@ module HexaPDF
         end
       end
 
-      # Tries to retrieve a page size name based on the media box. If this is not possible, the
+      # Tries to retrieve a page size name based on the given page box. If this is not possible, the
       # returned page size name consists of width x height.
-      def page_size_name(media_box)
+      def page_size_name(box)
         @page_name_cache ||= {}
-        return @page_name_cache[media_box] if @page_name_cache.key?(media_box)
+        return @page_name_cache[box] if @page_name_cache.key?(box)
 
         paper_size = HexaPDF::Type::Page::PAPER_SIZE.find do |_name, box|
-          box.each_with_index.all? {|entry, index| (entry - media_box[index]).abs < 5 }
+          box.each_with_index.all? {|entry, index| (entry - box[index]).abs < 5 }
         end
 
-        @page_name_cache[media_box] =
-          paper_size ? paper_size[0] : sprintf("%.0fx%.0f", *media_box.values_at(2, 3))
+        @page_name_cache[box] =
+          paper_size ? paper_size[0] : sprintf("%.0fx%.0f", *box.values_at(2, 3))
       end
 
     end

data/lib/hexapdf/cli/watermark.rb

@@ -95,8 +95,8 @@ module HexaPDF
           doc.pages.each do |page|
             index = indices.next
             xobject = xobject_map[index] ||= doc.import(watermark.pages[index].to_form_xobject)
-            pw = page.box(:media).width.to_f
-            ph = page.box(:media).height.to_f
+            pw = page.box.width.to_f
+            ph = page.box.height.to_f
             xw = xobject.width.to_f
             xh = xobject.height.to_f
             canvas = page.canvas(type: @type)

data/lib/hexapdf/configuration.rb

@@ -488,11 +488,13 @@ module HexaPDF
                       },
                       'signature.signing_handler' => {
                         default: 'HexaPDF::Document::Signatures::DefaultHandler',
+                        timestamp: 'HexaPDF::Document::Signatures::TimestampHandler',
                       },
                       'signature.sub_filter_map' => {
                         'adbe.x509.rsa_sha1': 'HexaPDF::Type::Signature::AdbeX509RsaSha1',
                         'adbe.pkcs7.detached': 'HexaPDF::Type::Signature::AdbePkcs7Detached',
                         'ETSI.CAdES.detached': 'HexaPDF::Type::Signature::AdbePkcs7Detached',
+                        'ETSI.RFC3161': 'HexaPDF::Type::Signature::AdbePkcs7Detached',
                       },
                       'task.map' => {
                         optimize: 'HexaPDF::Task::Optimize',

data/lib/hexapdf/dictionary.rb

@@ -259,22 +259,13 @@ module HexaPDF
       end
     end
 
-    # Iterates over all currently set fields and those that are required.
-    def each_set_key_or_required_field #:yields: name, field
-      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
-    end
-
     # Performs validation tasks based on the currently set keys and defined fields.
     def perform_validation(&block)
       super
-      each_set_key_or_required_field do |name, field|
-        obj = key?(name) ? self[name] : nil
+      self.class.each_field do |name, field|
+        next unless field.required? || value.key?(name)
 
-        # The checks below need a valid field definition
-        next if field.nil?
+        obj = key?(name) ? self[name] : nil
 
         # Check that required fields are set
         if field.required? && obj.nil?

data/lib/hexapdf/document/destinations.rb

@@ -107,8 +107,7 @@ module HexaPDF
       #     not changing it from the current value.
       class Destination
 
-        # :nodoc:
-        TYPE_MAPPING = {
+        TYPE_MAPPING = { #:nodoc:
           XYZ: :xyz,
           Fit: :fit_page,
           FitH: :fit_page_horizontal,
@@ -119,8 +118,7 @@ module HexaPDF
           FitBV: :fit_bounding_box_vertical,
         }
 
-        # :nodoc:
-        REVERSE_TYPE_MAPPING = Hash[*TYPE_MAPPING.flatten.reverse]
+        REVERSE_TYPE_MAPPING = Hash[*TYPE_MAPPING.flatten.reverse] #:nodoc:
 
         # Returns +true+ if the destination is valid.
         def self.valid?(destination)
@@ -132,7 +130,11 @@ module HexaPDF
         # Creates a new Destination for the given +destination+ which may be an explicit destination
         # array or a dictionary with a /D entry (as allowed for a named destination).
         def initialize(destination)
-          @destination = (destination.kind_of?(HexaPDF::Dictionary) ? destination[:D] : destination)
+          @destination = if destination.kind_of?(HexaPDF::Dictionary) || destination.kind_of?(Hash)
+                           destination[:D]
+                         else
+                           destination
+                         end
         end
 
         # Returns +true+ if the destination references a destination in a remote document.
@@ -212,6 +214,11 @@ module HexaPDF
           self.class.valid?(@destination)
         end
 
+        # Returns the wrapped destination array.
+        def value
+          @destination
+        end
+
       end
 
       include Enumerable
@@ -447,6 +454,36 @@ module HexaPDF
         destinations.delete_entry(name)
       end
 
+      # :call-seq:
+      #   destinations.resolve(string_name)    -> destination or nil
+      #   destinations.resolve(symbol_name)    -> destination or nil
+      #   destinations.resolve(dest_array)     -> destination or nil
+      #
+      # Resolves the given value to a valid destination object, if possible, or otherwise returns
+      # +nil+.
+      #
+      # * If the given value is a string, it is treated as a destination name and looked up in the
+      #   destination name tree.
+      #
+      # * If the given value is a symbol, it is treated as an old-style destination name and looked
+      #   up in the destination dictionary.
+      #
+      # * If the given value is an array, it is treated as a destination array itself.
+      def resolve(value)
+        result = case value
+                 when String
+                   destinations.find_entry(value)
+                 when PDFArray
+                   value.value
+                 when Array
+                   value
+                 when Symbol
+                   @document.catalog[:Dests]&.[](value)
+                 end
+        result = Destination.new(result) if result
+        result&.valid? ? result : nil
+      end
+
       # :call-seq:
       #   destinations[name]    -> destination
       #