hexapdf 0.8.0 → 0.9.0

data/lib/hexapdf/object.rb

@@ -293,9 +293,10 @@ module HexaPDF
       (oid == other.oid ? gen <=> other.gen : oid <=> other.oid)
     end
 
-    # Returns +true+ if the other object is an Object and wraps the same #data structure.
+    # Returns +true+ if the other object is an Object and wraps the same #data structure, or if the
+    # other object is a Reference with the same oid/gen.
     def ==(other)
-      other.kind_of?(Object) && data == other.data
+      (other.kind_of?(Object) && data == other.data) || (other.kind_of?(Reference) && other == self)
     end
 
     # Returns +true+ if the other object references the same PDF object as this object.

data/lib/hexapdf/parser.rb

@@ -45,6 +45,9 @@ module HexaPDF
   # See: PDF1.7 s7
   class Parser
 
+    # The IO stream which is parsed.
+    attr_reader :io
+
     # Creates a new parser for the given IO object.
     #
     # PDF references are resolved using the associated Document object.
@@ -270,6 +273,8 @@ module HexaPDF
     #
     # See: PDF1.7 s7.5.5, ADB1.7 sH.3-3.4.4
     def startxref_offset
+      return @startxref_offset if defined?(@startxref_offset)
+
       @io.seek(0, IO::SEEK_END)
       step_size = 1024
       pos = @io.pos
@@ -301,7 +306,7 @@ module HexaPDF
                     force: eof_index < 2 || lines[eof_index - 2].strip != "startxref")
       end
 
-      lines[eof_index - 1].to_i
+      @startxref_offset = lines[eof_index - 1].to_i
     end
 
     # Returns the PDF version number that is stored in the file header.

data/lib/hexapdf/rectangle.rb

@@ -81,6 +81,12 @@ module HexaPDF
       value[3] - value[1]
     end
 
+    # Compares this rectangle to +other+ like in Object#== but also allows comparison to simple
+    # arrays if the rectangle is a direct object.
+    def ==(other)
+      super || (other.kind_of?(Array) && !indirect? && other == data.value)
+    end
+
     private
 
     # Ensures that the value is an array containing four numbers that specify the bottom left and

data/lib/hexapdf/reference.rb

@@ -73,16 +73,14 @@ module HexaPDF
       (oid == other.oid ? gen <=> other.gen : oid <=> other.oid)
     end
 
-    # Returns +true+ if the other object is a Reference and has the same object and generation
-    # numbers.
-    def ==(other)
-      other.kind_of?(Reference) && oid == other.oid && gen == other.gen
-    end
-
     # Returns +true+ if the other object references the same PDF object as this reference object.
+    #
+    # This is necessary so that Object and Reference objects can be used as interchangable hash
+    # keys and can be compared.
     def eql?(other)
       other.respond_to?(:oid) && oid == other.oid && other.respond_to?(:gen) && gen == other.gen
     end
+    alias == eql?
 
     # Computes the hash value based on the object and generation numbers.
     def hash

data/lib/hexapdf/revision.rb

@@ -164,17 +164,18 @@ module HexaPDF
     end
 
     # :call-seq:
-    #   revision.each {|obj| block }   -> revision
-    #   revision.each                  -> Enumerator
+    #   revision.each(only_loaded: false) {|obj| block }   -> revision
+    #   revision.each(only_loaded: false)                  -> Enumerator
     #
-    # Calls the given block once for every object of the revision.
+    # Calls the given block for every object of the revision, or, if +only_loaded+ is +true+, for
+    # every already loaded object.
     #
-    # Objects that are loadable via an associated cross-reference section but are currently not,
-    # are loaded automatically.
-    def each
-      return to_enum(__method__) unless block_given?
+    # Objects that are loadable via an associated cross-reference section but are currently not
+    # loaded, are loaded automatically if +only_loaded+ is +false+.
+    def each(only_loaded: false)
+      return to_enum(__method__, only_loaded: only_loaded) unless block_given?
 
-      if defined?(@all_objects_loaded)
+      if defined?(@all_objects_loaded) || only_loaded
         @objects.each {|_oid, _gen, data| yield(data) }
       else
         seen = {}
@@ -189,6 +190,31 @@ module HexaPDF
       self
     end
 
+    # :call-seq:
+    #   revision.each_modified_object {|obj| block }   -> revision
+    #   revision.each_modified_object                  -> Enumerator
+    #
+    # Calls the given block once for each object that has been modified since it was loaded.
+    #
+    # Note that this also means that for revisions without an associated cross-reference section all
+    # loaded objects will be yielded.
+    def each_modified_object
+      return to_enum(__method__) unless block_given?
+
+      @objects.each do |oid, gen, obj|
+        if @xref_section.entry?(oid, gen)
+          stored_obj = @loader.call(@xref_section[oid, gen])
+          if obj.data.value != stored_obj.data.value || obj.data.stream != stored_obj.data.stream
+            yield(obj)
+          end
+        else
+          yield(obj)
+        end
+      end
+
+      self
+    end
+
     private
 
     # Loads a single object from the associated cross-reference section.

data/lib/hexapdf/revisions.rb

@@ -88,13 +88,16 @@ module HexaPDF
         end
 
         document.version = parser.file_header_version
-        new(document, initial_revisions: revisions)
+        new(document, initial_revisions: revisions, parser: parser)
       end
 
     end
 
     include Enumerable
 
+    # The Parser instance used for reading the initial revisions.
+    attr_reader :parser
+
     # Creates a new revisions object for the given PDF document.
     #
     # Options:
@@ -102,8 +105,15 @@ module HexaPDF
     # initial_revisions::
     #     An array of revisions that should initially be used. If this option is not specified, a
     #     single empty revision is added.
-    def initialize(document, initial_revisions: nil)
+    #
+    # parser::
+    #     The parser with which the initial revisions were read. If this option is not specified
+    #     even though the document was read from an IO stream, some parts may not work, like
+    #     incremental writing.
+    def initialize(document, initial_revisions: nil, parser: nil)
       @document = document
+      @parser = parser
+
       @revisions = []
       if initial_revisions
         @revisions += initial_revisions

data/lib/hexapdf/stream.rb

@@ -96,6 +96,24 @@ module HexaPDF
       end
     end
 
+    # Returns whether this stream data object is equal to the other stream data object.
+    def ==(other)
+      other.kind_of?(StreamData) &&
+        source == other.source && offset == other.offset && length == other.length &&
+        filter == other.filter && decode_parms == other.decode_parms
+    end
+
+    protected
+
+    # The source.
+    attr_reader :source
+
+    # The optional offset into the bytes provided by source.
+    attr_reader :offset
+
+    # The optional number of bytes to use starting from offset.
+    attr_reader :length
+
   end
 
   # Implements Stream objects of the PDF object system.

data/lib/hexapdf/task.rb

@@ -55,7 +55,7 @@ module HexaPDF
   #
   #   doc = HexaPDF::Document.new
   #   doc.config['task.map'][:validate] = lambda do |doc|
-  #     doc.each(current: false) {|obj| obj.validate || raise "Invalid object #{obj}"}
+  #     doc.each(only_current: false) {|obj| obj.validate || raise "Invalid object #{obj}"}
   #   end
   module Task
 

data/lib/hexapdf/task/dereference.rb

@@ -69,7 +69,7 @@ module HexaPDF
         else
           dereference(@doc.trailer)
           @result = []
-          @doc.each(current: false) do |obj|
+          @doc.each(only_current: false) do |obj|
             if !@seen.key?(obj.data) && obj.type != :ObjStm && obj.type != :XRef
               @result << obj
             elsif obj.kind_of?(HexaPDF::Stream) && (val = obj.value[:Length]) &&

data/lib/hexapdf/task/optimize.rb

@@ -78,7 +78,7 @@ module HexaPDF
         elsif xref_streams != :preserve
           process_xref_streams(doc, xref_streams)
         else
-          doc.each(current: false, &method(:delete_fields_with_defaults))
+          doc.each(only_current: false, &method(:delete_fields_with_defaults))
         end
 
         compress_pages(doc) if compress_pages
@@ -169,7 +169,7 @@ module HexaPDF
       def self.process_xref_streams(doc, method)
         case method
         when :delete
-          doc.each(current: false) do |obj, rev|
+          doc.each(only_current: false) do |obj, rev|
             if obj.type == :XRef
               rev.delete(obj)
             else

data/lib/hexapdf/type/form.rb

@@ -72,6 +72,16 @@ module HexaPDF
         self[:BBox]
       end
 
+      # Returns the width of the bounding box (see #box).
+      def width
+        box.width
+      end
+
+      # Returns the height of the bounding box (see #box).
+      def height
+        box.height
+      end
+
       # Returns the contents of the form XObject.
       #
       # Note: This is the same as #stream but here for interface compatibility with Page.

data/lib/hexapdf/version.rb

@@ -34,6 +34,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.8.0'
+  VERSION = '0.9.0'
 
 end

data/lib/hexapdf/writer.rb

@@ -41,9 +41,14 @@ module HexaPDF
   # Writes the contents of a PDF document to an IO stream.
   class Writer
 
-    # Writes the document to the IO object.
-    def self.write(document, io)
-      new(document, io).write
+    # Writes the document to the IO object. If +incremental+ is +true+ and the document was created
+    # from an existing PDF file, the changes are appended to a full copy of the source document.
+    def self.write(document, io, incremental: false)
+      if incremental && document.revisions.parser
+        new(document, io).write_incremental
+      else
+        new(document, io).write
+      end
     end
 
     # Creates a new writer object for the given HexaPDF document that gets written to the IO
@@ -56,13 +61,12 @@ module HexaPDF
       @io.seek(0, IO::SEEK_SET) # TODO: incremental update!
 
       @serializer = Serializer.new
+      @serializer.encrypter = @document.encrypted? ? @document.security_handler : nil
       @rev_size = 0
     end
 
     # Writes the document to the IO object.
     def write
-      @serializer.encrypter = @document.encrypted? ? @document.security_handler : nil
-
       write_file_header
 
       pos = nil
@@ -72,6 +76,22 @@ module HexaPDF
       end
     end
 
+    # Writes the complete source document and one revision containing all changes to the IO.
+    #
+    # For this method to work the document must have been created from an existing file.
+    def write_incremental
+      @document.revisions.parser.io.seek(0, IO::SEEK_SET)
+      IO.copy_stream(@document.revisions.parser.io, @io)
+
+      @rev_size = @document.revisions.current.next_free_oid
+
+      revision = Revision.new(@document.revisions.current.trailer)
+      @document.revisions.each do |rev|
+        rev.each_modified_object {|obj| revision.send(:add_without_check, obj) }
+      end
+      write_revision(revision, @document.revisions.parser.startxref_offset)
+    end
+
     private
 
     # Writes the PDF file header.

data/man/man1/hexapdf.1

@@ -29,6 +29,8 @@ Modifying an existing PDF file (see the \fBmodify\fP command)
 .IP \(bu 4
 Optimizing the file size of a PDF file (see the \fBoptimize\fP command)
 .IP \(bu 4
+Splitting a PDF file into individual pages (see the \fBsplit\fP command)
+.IP \(bu 4
 Batch execution of a command on multiple PDF files (see the \fBbatch\fP command)
 .PD
 .P
@@ -316,6 +318,17 @@ By default, all strategies except page compression are used since page compressi
 The password to decrypt the \fIINPUT\fP\&\. Use \fB\-\fP for \fIPASSWORD\fP for reading it from standard input\.
 .P
 The \fBOptimization Options\fP can be used with this command\. Note that the defaults are changed to provide good compression out of the box\.
+.SS "split"
+Synopsis: \fBsplit\fP [\fBOPTIONS\fP] \fIINPUT\fP [\fIOUTPUT_SPEC\fP]
+.P
+This command splits the input file into multiple output files, each containing one page\.
+.P
+If no \fIOUTPUT_SPEC\fP is given, files of the form \fIINPUT_0001\.pdf\fP, \fIINPUT_0002\.pdf\fP, \.\.\. and so on are created (only the name \fIINPUT\fP without the file extension is used)\. Otherwise \fIOUTPUT_SPEC\fP determines the file names of the created files, with a printf\-style format string like \[u2018]%04d\[u2019] being replaced by the page number\. For example, if the files should be named \fIpage_01\.pdf\fP, \fIpage_02\.pdf\fP and so on, use \fIpage_%02d\.pdf\fP for the \fIOUTPUT_SPEC\fP\&\.
+.TP
+\fB\-p\fP \fIPASSWORD\fP, \fB\-\-password\fP \fIPASSWORD\fP
+The password to decrypt the \fIINPUT\fP\&\. Use \fB\-\fP for \fIPASSWORD\fP for reading it from standard input\.
+.P
+Additionally, the \fBOptimization Options\fP and \fBEncryption Options\fP can be used\.
 .SS "version"
 This command shows the version of the hexapdf application\. It is an alternative to using the global \fB\-\-version\fP option\.
 .SH "PAGES SPECIFICATION"
@@ -392,6 +405,10 @@ Encryption removal: Create the \fBoutput\.pdf\fP as copy of \fBinput\.pdf\fP but
 \fBhexapdf optimize input\.pdf output\.pdf\fP
 .P
 Optimization: Compress the \fBinput\.pdf\fP to get a smaller file size\.
+.SS "split"
+\fBhexapdf split input\.pdf out_%02d\.pdf\fP
+.P
+Split the \fBinput\.pdf\fP into individual pages, naming the output files \fBout_01\.pdf\fP, \fBout_02\.pdf\fP, and so on\.
 .SS "files"
 \fBhexapdf files input\.pdf\fP
 .br

data/test/hexapdf/layout/test_box.rb

@@ -24,7 +24,8 @@ describe HexaPDF::Layout::Box do
 
     it "takes content width and height" do
       box = HexaPDF::Layout::Box.create(width: 100, height: 200, content_box: true,
-                                        padding: 10, border: {width: 10})
+                                        padding: [10, 8, 6, 4],
+                                        border: {width: [10, 8, 6, 4]})
       assert_equal(100, box.content_width)
       assert_equal(200, box.content_height)
     end
@@ -78,6 +79,11 @@ describe HexaPDF::Layout::Box do
     end
   end
 
+  it "can't be split into two parts" do
+    box = create_box(width: 100, height: 100)
+    assert_equal([nil, box], box.split(50, 50, nil))
+  end
+
   describe "draw" do
     it "draws the box onto the canvas" do
       box = create_box(width: 150, height: 130) do |canvas, _|

data/test/hexapdf/layout/test_frame.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Layout::Frame do
     assert_kind_of(HexaPDF::Layout::WidthFromPolygon, ws)
   end
 
-  describe "draw" do
+  describe "fit and draw" do
     before do
       @frame = HexaPDF::Layout::Frame.new(10, 10, 100, 100)
       @canvas = Minitest::Mock.new
@@ -80,6 +80,14 @@ describe HexaPDF::Layout::Frame do
         )
       end
 
+      it "determines the available space for #fit by using the space to the right and above" do
+        check_box(
+          {position: :absolute, position_hint: [10, 10]},
+          [20, 20],
+          [[[10, 10], [110, 10], [110, 20], [20, 20], [20, 110], [10, 110]]]
+        )
+      end
+
       it "always removes the whole margin box from the frame" do
         check_box(
           {width: 50, height: 50, position: :absolute, position_hint: [10, 10],
@@ -238,6 +246,26 @@ describe HexaPDF::Layout::Frame do
       box = HexaPDF::Layout::Box.create(width: 150, height: 50)
       refute(@frame.draw(@canvas, box))
     end
+
+    it "can't fit the box if there is no available space" do
+      @frame.remove_area(Geom2D::Polygon([0, 0], [110, 0], [110, 110], [0, 110]))
+      box = HexaPDF::Layout::Box.create
+      refute(@frame.fit(box))
+    end
+
+    it "draws the box even if the box's height is zero" do
+      box = HexaPDF::Layout::Box.create
+      box.define_singleton_method(:height) { 0 }
+      assert(@frame.draw(@canvas, box))
+    end
+  end
+
+  describe "split" do
+    it "splits the box if necessary" do
+      box = HexaPDF::Layout::Box.create(width: 10, height: 10)
+      assert_equal([nil, box], @frame.split(box))
+      assert_nil(@frame.instance_variable_get(:@fit_data).box)
+    end
   end
 
   describe "find_next_region" do
@@ -310,4 +338,13 @@ describe HexaPDF::Layout::Frame do
     end
   end
 
+  describe "remove_area" do
+    it "recalculates the contour line only if necessary" do
+      contour = Geom2D::Polygon([10, 10], [10, 90], [90, 90], [90, 10])
+      frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100, contour_line: contour)
+      frame.remove_area(Geom2D::Polygon([0, 0], [20, 0], [20, 100], [0, 100]))
+      assert_equal([[[20, 10], [90, 10], [90, 90], [20, 90]]],
+                   frame.contour_line.polygons.map(&:to_a))
+    end
+  end
 end

data/test/hexapdf/layout/test_image_box.rb

@@ -0,0 +1,73 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../content/common'
+require 'hexapdf/document'
+require 'hexapdf/layout/image_box'
+
+describe HexaPDF::Layout::ImageBox do
+  before do
+    @image = HexaPDF::Stream.new({Subtype: :Image}, stream: '')
+    @image.define_singleton_method(:width) { 40 }
+    @image.define_singleton_method(:height) { 20 }
+  end
+
+  def create_box(**kwargs)
+    HexaPDF::Layout::ImageBox.new(@image, kwargs)
+  end
+
+  describe "initialize" do
+    it "takes the image to be displayed" do
+      box = create_box
+      assert_equal(@image, box.image)
+    end
+  end
+
+  describe "fit" do
+    it "fits with fixed dimensions" do
+      box = create_box(width: 50, height: 30, style: {padding: [10, 4, 6, 2]})
+      assert(box.fit(100, 100, nil))
+      assert_equal(50, box.width)
+      assert_equal(30, box.height)
+    end
+
+    it "fits with a fixed width" do
+      box = create_box(width: 60, style: {padding: [10, 4, 6, 2]})
+      assert(box.fit(100, 100, nil))
+      assert_equal(60, box.width)
+      assert_equal(43, box.height)
+    end
+
+    it "fits with a fixed height" do
+      box = create_box(height: 40, style: {padding: [10, 4, 6, 2]})
+      assert(box.fit(100, 100, nil))
+      assert_equal(54, box.width)
+      assert_equal(40, box.height)
+    end
+
+    it "fits with auto-scaling to available space" do
+      box = create_box(style: {padding: [10, 4, 6, 2]})
+      assert(box.fit(100, 100, nil))
+      assert_equal(100, box.width)
+      assert_equal(63, box.height)
+
+      assert(box.fit(100, 30, nil))
+      assert_equal(34, box.width)
+      assert_equal(30, box.height)
+    end
+  end
+
+  describe "draw" do
+    it "draws the image" do
+      box = create_box(height: 40, style: {padding: [10, 4, 6, 2]})
+      box.fit(100, 100, nil)
+
+      @canvas = HexaPDF::Document.new.pages.add.canvas
+      box.draw(@canvas, 0, 0)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:concatenate_matrix, [48, 0, 0, 24, 2, 6]],
+                                          [:paint_xobject, [:XO1]],
+                                          [:restore_graphics_state]])
+    end
+  end
+end