hexapdf 0.14.2 → 0.15.2

data/lib/hexapdf/type/annotation.rb

@@ -125,20 +125,24 @@ module HexaPDF
 
       # Returns the AppearanceDictionary instance associated with the annotation or +nil+ if none is
       # set.
-      def appearance
+      def appearance_dict
         self[:AP]
       end
 
-      # Returns +true+ if the widget's normal appearance exists.
+      # Returns the annotation's appearance stream of the given type (:normal, :rollover, or :down)
+      # or +nil+ if it doesn't exist.
       #
-      # Note that this checks only if the appearance exists but not if the structure of the
-      # appearance dictionary conforms to the expectations of the annotation.
-      def appearance?
-        return false unless (normal_appearance = appearance&.normal_appearance)
-        normal_appearance.kind_of?(HexaPDF::Stream) ||
-          (!normal_appearance.empty? &&
-           normal_appearance.each.all? {|_k, v| v.kind_of?(HexaPDF::Stream) })
+      # The appearance state is taken into account if necessary.
+      def appearance(type = :normal)
+        entry = appearance_dict&.send("#{type}_appearance")
+        if entry.kind_of?(HexaPDF::Dictionary) && !entry.kind_of?(HexaPDF::Stream)
+          entry = entry[self[:AS]]
+        end
+        if entry.kind_of?(HexaPDF::Stream)
+          entry[:Subtype] == :Form ? entry : document.wrap(entry, type: :XObject, subtype: :Form)
+        end
       end
+      alias appearance? appearance
 
       private
 

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

@@ -112,7 +112,9 @@ module HexaPDF
         def background_color(*color)
           if color.empty?
             components = self[:MK]&.[](:BG)
-            components.nil? ? nil : Content::ColorSpace.prenormalized_device_color(components)
+            if components && !components.empty?
+              Content::ColorSpace.prenormalized_device_color(components)
+            end
           else
             color = Content::ColorSpace.device_color_from_specification(color)
             (self[:MK] ||= {})[:BG] = color.components

data/lib/hexapdf/type/font_descriptor.rb

@@ -57,8 +57,7 @@ module HexaPDF
       define_field :FontStretch,  type: Symbol, version: '1.5',
         allowed_values: [:UltraCondensed, :ExtraCondensed, :Condensed, :SemiCondensed,
                          :Normal, :SemiExpanded, :Expanded, :ExtraExpanded, :UltraExpanded]
-      define_field :FontWeight,   type: Numeric, version: '1.5',
-        allowed_values: [100, 200, 300, 400, 500, 600, 700, 800, 900]
+      define_field :FontWeight,   type: Numeric, version: '1.5'
       define_field :Flags,        type: Integer, required: true
       define_field :FontBBox,     type: Rectangle
       define_field :ItalicAngle,  type: Numeric, required: true
@@ -98,12 +97,20 @@ module HexaPDF
         self[:Flags] = value
       end
 
+      ALLOWED_FONT_WEIGHTS = [100, 200, 300, 400, 500, 600, 700, 800, 900] #:nodoc:
+
       def perform_validation #:nodoc:
         super
         if [self[:FontFile], self[:FontFile2], self[:FontFile3]].compact.size > 1
           yield("Only one of /FontFile, /FontFile2 or /FontFile3 may be set", false)
         end
 
+        font_weight = self[:FontWeight]
+        if font_weight && !ALLOWED_FONT_WEIGHTS.include?(font_weight)
+          yield("Field FontWeight does not contain an allowed value", true)
+          delete(:FontWeight)
+        end
+
         descent = self[:Descent]
         if descent && descent > 0
           yield("The /Descent value needs to be a negative number", true)

data/lib/hexapdf/type/page.rb

@@ -465,6 +465,87 @@ module HexaPDF
         document.wrap(dict, stream: stream)
       end
 
+      # Flattens all or the given annotations of the page. Returns an array with all the annotations
+      # that couldn't be flattened because they don't have an appearance stream.
+      #
+      # Flattening means making the appearances of the annotations part of the content stream of the
+      # page and deleting the annotations themselves. Invisible and hidden fields are deleted but
+      # not rendered into the content stream.
+      #
+      # If an annotation is a form field widget, only the widget will be deleted but not the form
+      # field itself.
+      def flatten_annotations(annotations = self[:Annots])
+        return [] unless key?(:Annots)
+
+        not_flattened = annotations.to_ary
+        annotations = not_flattened & self[:Annots] if annotations != self[:Annots]
+        return not_flattened if annotations.empty?
+
+        canvas = self.canvas(type: :overlay)
+        canvas.save_graphics_state
+        media_box = box(:media)
+        if media_box.left != 0 || media_box.bottom != 0
+          canvas.translate(-media_box.left, -media_box.bottom) # revert initial translation of origin
+        end
+
+        to_delete = []
+        not_flattened -= annotations
+        annotations.each do |annotation|
+          annotation = document.wrap(annotation, type: :Annot)
+          appearance = annotation.appearance
+          if annotation.flagged?(:hidden) || annotation.flagged?(:invisible)
+            to_delete << annotation
+            next
+          elsif !appearance
+            not_flattened << annotation
+            next
+          end
+
+          rect = annotation[:Rect]
+          box = appearance.box
+          matrix = appearance[:Matrix]
+
+          # Adjust position based on matrix
+          pos = [rect.left - matrix[4], rect.bottom - matrix[5]]
+
+          # In case of a rotation we need to counter the default translation in #xobject by adding
+          # box.left and box.bottom, and then translate the origin for the rotation
+          angle = (-Math.atan2(matrix[2], matrix[0]) * 180 / Math::PI).to_i
+          case angle
+          when 0
+            # Nothing to do, no rotation
+          when 90
+            pos[0] += box.top + box.left
+            pos[1] += -box.left + box.bottom
+          when -90
+            pos[0] += -box.bottom + box.left
+            pos[1] += box.right + box.bottom
+          when 180, -180
+            pos[0] += box.right + box.left
+            pos[1] += box.top + box.bottom
+          else
+            not_flattened << annotation
+            next
+          end
+
+          width, height = (angle.abs == 90 ? [rect.height, rect.width] : [rect.width, rect.height])
+          canvas.xobject(appearance, at: pos, width: width, height: height)
+          to_delete << annotation
+        end
+        canvas.restore_graphics_state
+
+        to_delete.each do |annotation|
+          if annotation[:Subtype] == :Widget
+            annotation.form_field.delete_widget(annotation)
+          else
+            self[:Annots].delete(annotation)
+            document.delete(annotation)
+          end
+        end
+
+        not_flattened
+      end
+
       private
 
       # Ensures that the required inheritable fields are set.

data/lib/hexapdf/type/resources.rb

@@ -222,6 +222,10 @@ module HexaPDF
           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/xref_stream.rb

@@ -135,6 +135,13 @@ module HexaPDF
         w1 = w[1]
         w2 = w[2]
 
+        needed_bytes = (w0 + w1 + w2) * index.each_slice(2).sum(&:last)
+
+        if needed_bytes > data.size
+          raise HexaPDF::MalformedPDFError, "Cross-reference stream is missing data " \
+            "(#{needed_bytes} bytes needed, got #{data.size})"
+        end
+
         index.each_slice(2) do |first_oid, number_of_entries|
           first_oid.upto(first_oid + number_of_entries - 1) do |oid|
             # Default for first field: type 1

data/lib/hexapdf/utils/graphics_helpers.rb

@@ -47,18 +47,18 @@ module HexaPDF
       #
       # +rwidth+::
       #     The requested width. If +rheight+ is not specified, it is chosen so that the aspect
-      #     ratio is maintained
+      #     ratio is maintained. In case of +width+ begin zero, +height+ is used for the height.
       #
       # +rheight+::
       #     The requested height. If +rwidth+ is not specified, it is chosen so that the aspect
-      #     ratio is maintained
+      #     ratio is maintained. In case of +height+ begin zero, +width+ is used for the width.
       def calculate_dimensions(width, height, rwidth: nil, rheight: nil)
         if rwidth && rheight
           [rwidth, rheight]
         elsif rwidth
-          [rwidth, height * rwidth / width.to_f]
+          [rwidth, width == 0 ? height : height * rwidth / width.to_f]
         elsif rheight
-          [width * rheight / height.to_f, rheight]
+          [height == 0 ? width : width * rheight / height.to_f, rheight]
         else
           [width, height]
         end

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.14.2'
+  VERSION = '0.15.2'
 
 end

data/test/hexapdf/content/test_canvas.rb

@@ -831,6 +831,17 @@ describe HexaPDF::Content::Canvas do
                                         [:restore_graphics_state]])
     end
 
+    it "doesn't do anything if the image's width or height is zero" do
+      @image[:Width] = 0
+      @canvas.xobject(@image, at: [0, 0])
+      assert_operators(@page.contents, [])
+
+      @image[:Width] = 10
+      @image[:Height] = 0
+      @canvas.xobject(@image, at: [0, 0])
+      assert_operators(@page.contents, [])
+    end
+
     it "correctly serializes the form with no options" do
       @canvas.xobject(@form, at: [1, 2])
       assert_operators(@page.contents, [[:save_graphics_state],
@@ -862,6 +873,16 @@ describe HexaPDF::Content::Canvas do
                                         [:paint_xobject, [:XO1]],
                                         [:restore_graphics_state]])
     end
+
+    it "doesn't do anything if the form's width or height is zero" do
+      @form[:BBox] = [100, 50, 100, 200]
+      @canvas.xobject(@form, at: [0, 0])
+      assert_operators(@page.contents, [])
+
+      @form[:BBox] = [100, 50, 150, 50]
+      @canvas.xobject(@form, at: [0, 0])
+      assert_operators(@page.contents, [])
+    end
   end
 
   describe "character_spacing" do

data/test/hexapdf/encryption/test_security_handler.rb

@@ -297,6 +297,13 @@ describe HexaPDF::Encryption::SecurityHandler do
       assert_equal(@encrypted, @handler.decrypt(@obj)[:Key])
     end
 
+    it "defers handling encryption to a Crypt filter is specified" do
+      data = HexaPDF::StreamData.new(proc { 'mydata' }, filter: :Crypt)
+      obj = @document.wrap({}, oid: 1, stream: data)
+      @handler.decrypt(obj)
+      assert_equal('mydata', obj.stream)
+    end
+
     it "doesn't decrypt XRef streams" do
       @obj[:Type] = :XRef
       assert_equal(@encrypted, @handler.decrypt(@obj)[:Key])
@@ -343,6 +350,14 @@ describe HexaPDF::Encryption::SecurityHandler do
       assert_equal('string', @handler.encrypt_stream(@stream).resume)
     end
 
+    it "defers encrypting to a Crypt filter if specified" do
+      @stream.set_filter(:Crypt)
+      assert_equal('string', @handler.encrypt_stream(@stream).resume)
+
+      @stream.set_filter([:Crypt])
+      assert_equal('string', @handler.encrypt_stream(@stream).resume)
+    end
+
     it "doesn't encrypt the /Contents key of signature dictionaries" do
       @obj[:Type] = :Sig
       @obj[:Contents] = "test"

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -292,4 +292,30 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
     @handler.set_up_encryption(permissions: perms)
     assert_equal([:copy_content, :modify_content], @handler.permissions.sort)
   end
+
+  describe "handling of metadata streams" do
+    before do
+      @doc = HexaPDF::Document.new
+      @doc.encrypt(encrypt_metadata: false)
+      @output = StringIO.new(''.b)
+    end
+
+    it "doesn't decrypt or encrypt the document level metadata stream if /EncryptMetadata is false" do
+      @doc.catalog[:Metadata] = @doc.wrap({Type: :Metadata, Subtype: :XML}, stream: "HELLODATA")
+      @doc.write(@output)
+      assert_match(/stream\nHELLODATA\nendstream/, @output.string)
+
+      doc = HexaPDF::Document.new(io: @output)
+      assert_equal('HELLODATA', doc.catalog[:Metadata].stream)
+    end
+
+    it "doesn't modify decryption/encryption for arbitrary metadata streams" do
+      @doc.catalog[:Anything] = @doc.wrap({Type: :Metadata, Subtype: :XML}, stream: "HELLODATA")
+      @doc.write(@output)
+      refute_match(/stream\nHELLODATA\nendstream/, @output.string)
+
+      doc = HexaPDF::Document.new(io: @output)
+      assert_equal('HELLODATA', doc.catalog[:Anything].stream)
+    end
+  end
 end

data/test/hexapdf/filter/test_crypt.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/filter/crypt'
+
+describe HexaPDF::Filter::Crypt do
+  before do
+    @obj = HexaPDF::Filter::Crypt
+    @source = Fiber.new { "hallo" }
+  end
+
+  it "works with the Identity filter" do
+    assert_equal(@source, @obj.decoder(@source, nil))
+    assert_equal(@source, @obj.encoder(@source, {})) # sic: 'encoder'
+    assert_equal(@source, @obj.decoder(@source, {Name: :Identity}))
+  end
+
+  it "fails if crypt filter name is not Identity" do
+    assert_raises(HexaPDF::FilterError) { @obj.decoder(@source, {Name: :Other}) }
+  end
+end

data/test/hexapdf/font/true_type/test_subsetter.rb

@@ -29,6 +29,8 @@ describe HexaPDF::Font::TrueType::Subsetter do
 
   it "doesn't use certain subset glyph IDs for performance reasons" do
     1.upto(93) {|i| @subsetter.use_glyph(i) }
+    # glyph 0, 93 used glyph, 4 special glyphs
+    assert_equal(1 + 93 + 4, @subsetter.instance_variable_get(:@glyph_map).size)
     1.upto(12) {|i| assert_equal(i, @subsetter.subset_glyph_id(i), "id=#{i}") }
     13.upto(38) {|i| assert_equal(i + 1, @subsetter.subset_glyph_id(i), "id=#{i}") }
     39.upto(88) {|i| assert_equal(i + 3, @subsetter.subset_glyph_id(i), "id=#{i}") }

data/test/hexapdf/font/type1/test_afm_parser.rb

@@ -39,6 +39,11 @@ describe HexaPDF::Font::Type1::AFMParser do
     end
   end
 
+  it "parses until EOF if no end token is found" do
+    io = StringIO.new("StartFontMetrics 4.1\nFontName Test")
+    assert_equal('Test', HexaPDF::Font::Type1::AFMParser.parse(io).font_name)
+  end
+
   it "extracts kerning and ligature information" do
     metrics = FONT_TIMES.metrics
     glyph = metrics.character_metrics[:f]

data/test/hexapdf/test_dictionary_fields.rb

@@ -234,5 +234,12 @@ describe HexaPDF::DictionaryFields do
       @field.convert(data, doc)
       doc.verify
     end
+
+    it "converts to a null value if an (invalid) empty array is given" do
+      doc = Minitest::Mock.new
+      doc.expect(:wrap, :data, [nil])
+      @field.convert([], doc)
+      doc.verify
+    end
   end
 end

data/test/hexapdf/test_parser.rb

@@ -50,7 +50,8 @@ describe HexaPDF::Parser do
   end
 
   def create_parser(str)
-    @parser = HexaPDF::Parser.new(StringIO.new(str), @document)
+    @parse_io = StringIO.new(str)
+    @parser = HexaPDF::Parser.new(@parse_io, @document)
   end
 
   describe "parse_indirect_object" do
@@ -88,6 +89,18 @@ describe HexaPDF::Parser do
       assert_equal('12', TestHelper.collector(stream.fiber))
     end
 
+    it "handles keyword stream followed by space and CR or LF" do
+      create_parser("1 0 obj<</Length 2>> stream \n12\nendstream endobj")
+      *, stream = @parser.parse_indirect_object
+      assert_equal('12', TestHelper.collector(stream.fiber))
+    end
+
+    it "handles keyword stream followed by space and CR LF" do
+      create_parser("1 0 obj<</Length 2>> stream \r\n12\nendstream endobj")
+      *, stream = @parser.parse_indirect_object
+      assert_equal('12', TestHelper.collector(stream.fiber))
+    end
+
     it "handles invalid indirect object value consisting of number followed by endobj without space" do
       create_parser("1 0 obj 749endobj")
       object, * = @parser.parse_indirect_object
@@ -157,6 +170,18 @@ describe HexaPDF::Parser do
         assert_match(/not CR alone/, exp.message)
       end
 
+      it "fails if keyword stream is followed by space and CR or LF instead of LF or CR/LF" do
+        create_parser("1 0 obj<</Length 2>> stream \n12\nendstream endobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/followed by space instead/, exp.message)
+      end
+
+      it "fails if keyword stream is followed by space and CR LF instead of LF or CR/LF" do
+        create_parser("1 0 obj<</Length 2>> stream \r\n12\nendstream endobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/followed by space instead/, exp.message)
+      end
+
       it "fails for numbers followed by endobj without space" do
         create_parser("1 0 obj 749endobj")
         exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
@@ -222,6 +247,23 @@ describe HexaPDF::Parser do
       assert_equal([1, 2], obj.value)
     end
 
+    it "handles an invalid indirect object offset of 0" do
+      obj = @parser.load_object(HexaPDF::XRefSection.in_use_entry(2, 0, 0))
+      assert(obj.null?)
+      assert_equal(2, obj.oid)
+      assert_equal(0, obj.gen)
+    end
+
+    describe "with strict parsing" do
+      it "raises an error if an indirect object has an offset of 0" do
+        @document.config['parser.on_correctable_error'] = proc { true }
+        exp = assert_raises(HexaPDF::MalformedPDFError) do
+          @parser.load_object(HexaPDF::XRefSection.in_use_entry(2, 0, 0))
+        end
+        assert_match(/has offset 0/, exp.message)
+      end
+    end
+
     it "fails if another object is found instead of an object stream" do
       def (@document).object(_oid)
         :invalid
@@ -482,6 +524,13 @@ describe HexaPDF::Parser do
       assert_match(/not a cross-reference stream/, exp.message)
     end
 
+    it "fails if the cross-reference stream is missing data" do
+      @parse_io.string[287..288] = ''
+      exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.load_revision(212) }
+      assert_match(/missing data/, exp.message)
+      assert_equal(212, exp.pos)
+    end
+
     it "fails on strict parsing if the cross-reference stream doesn't contain an entry for itself" do
       @document.config['parser.on_correctable_error'] = proc { true }
       create_parser("2 0 obj\n<</Type/XRef/Length 3/W [1 1 1]/Size 1>>" \
@@ -502,16 +551,37 @@ describe HexaPDF::Parser do
       assert_equal(6, @parser.load_object(@xref).value)
     end
 
+    it "uses a security handler for decrypting indirect objects if necessary" do
+      handler = Minitest::Mock.new
+      handler.expect(:decrypt, HexaPDF::Object.new(:result, oid: 1), [HexaPDF::Object])
+      @document.instance_variable_set(:@security_handler, handler)
+      create_parser("1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
+      assert_equal(:result, @parser.load_object(@xref).value)
+      assert(handler.verify)
+    end
+
     it "ignores parts where the starting line is split across lines" do
       create_parser("1 0 obj\n5\nendobj\n1 0\nobj\n6\nendobj\ntrailer\n<</Size 1>>")
       assert_equal(5, @parser.load_object(@xref).value)
     end
 
+    it "handles the case when the specified object had an xref entry but is not found" do
+      create_parser("3 0 obj\n5\nendobj\ntrailer\n<</Size 1>>")
+      assert(@parser.load_object(@xref).null?)
+    end
+
     it "handles cases where the line contains an invalid string that exceeds the read buffer" do
       create_parser("(1" << "(abc" * 32188 << "\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
       assert_equal(6, @parser.load_object(@xref).value)
     end
 
+    it "handles pathalogical cases which contain many opened literal strings" do
+      time = Time.now
+      create_parser("(1" << "(abc\n" * 10000 << "\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
+      assert_equal(6, @parser.load_object(@xref).value)
+      assert(Time.now - time < 0.5, "Xref reconstruction takes too long")
+    end
+
     it "ignores invalid objects" do
       create_parser("1 x obj\n5\nendobj\n1 0 xobj\n6\nendobj\n1 0 obj 4\nendobj\ntrailer\n<</Size 1>>")
       assert_equal(4, @parser.load_object(@xref).value)
@@ -528,10 +598,20 @@ describe HexaPDF::Parser do
     end
 
     it "uses the first trailer in case of a linearized file" do
-      create_parser("trailer <</Size 1/Prev 342>>\ntrailer <</Size 2>>")
+      create_parser("1 0 obj\n<</Linearized true>>\nendobj\ntrailer <</Size 1/Prev 342>>\ntrailer <</Size 2>>")
       assert_equal({Size: 1}, @parser.reconstructed_revision.trailer.value)
     end
 
+    it "tries the trailer specified at the startxref position if no other is found" do
+      create_parser("1 0 obj\n5\nendobj\nquack xref trailer <</Size 1/Prev 5>>\nstartxref\n22\n%%EOF")
+      assert_equal({Size: 1}, @parser.reconstructed_revision.trailer.value)
+    end
+
+    it "fails if no trailer is found and the trailer specified at the startxref position is not valid" do
+      create_parser("1 0 obj\n5\nendobj\nquack trailer <</Size 1>>\nstartxref\n22\n%%EOF")
+      assert_raises(HexaPDF::MalformedPDFError) { @parser.reconstructed_revision.trailer }
+    end
+
     it "fails if no valid trailer is found" do
       create_parser("1 0 obj\n5\nendobj")
       assert_raises(HexaPDF::MalformedPDFError) { @parser.load_object(@xref) }