hexapdf 0.11.4 → 0.11.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0907516ec3eaf3e982a0380bab72ea8923ea18ed3213b426061572913c2c426e'
-  data.tar.gz: 6541fdd61bfc2000a3bd77e8aa8ebf046e14c56a87d856bace5f89c586042f42
+  metadata.gz: f56bc512ed28de11d43f5b2eb662729086734dc3120e6c8e96b56eab89420da4
+  data.tar.gz: 4b9e75f7d533cc7b3c3a6e297d26ab0358dcaa4ac0f0a5346df3e95c90d9c173
 SHA512:
-  metadata.gz: 76a46bb08612f035c0e1159c1644797ecb949933ea73451d4f2e3bb128f5db3fd240bb759ec750ab42469c378b3fc36ec8ff466a6c39682a166b606dca5e7ca1
-  data.tar.gz: 1368b225b5d638c8cfc36057d983126746df3333e73f2b88d50238c51bdef095de275b9c872653b5c78a3009dbf60d71a7cd0ae7f9e231e6966c590e831de834
+  metadata.gz: 3651a7ed4a7fb305c79a70b0c009441b0e3012188ce5e8baf8847107bce27793e0c48a577ae0bbc9ae3d6bece5356b86955b4deb2abd505d0b7a856053461ab3
+  data.tar.gz: 7cfd77439479567d81133e39243715dd05b3a3b31ccc64fd923ec7391ba745834977011e4618f1f9462cdcb2a682ed1b102c20474a4b3f5d7c69be438c6abd51

data/CHANGELOG.md

@@ -1,3 +1,53 @@
+## 0.11.9 - 2020-06-15
+
+### Changed
+
+* Encryption dictionaries to always be indirect objects
+
+
+## 0.11.8 - 2020-06-11
+
+### Fixed
+
+* Serialization of special `/` (zero-length name) object in dictionaries and
+  arrays
+
+
+## 0.11.7 - 2020-06-10
+
+### Fixed
+
+* Deletion of object streams in [HexaPDF::Task::Optimize] to avoid accessing
+  then invalid object streams
+* [HexaPDF::Task::Optimize] to work correctly when deleting object streams and
+  generating xref streams
+
+
+## 0.11.6 - 2020-05-27
+
+### Fixed
+
+* [HexaPDF::Layout::TextBox] to respect the set width and height when fitting
+  and splitting the box
+
+
+## 0.11.5 - 2020-01-27
+
+### Changed
+
+* [HexaPDF::Font::TrueType::Table::CmapSubtable] to lazily parse the subtable
+* [HexaPDF::Font::TrueType::Table::Hmtx] to lazily parse the width data
+* CLI command `hexapdf image2pdf` to use the last argument as output file
+  instead of the first (same order as `merge`)
+* Automatically require the HexaPDF C extension if it is installed
+
+### Fixed
+
+* Wrong line length calculation for variable width layouting when a text box is
+  too wide and needs to be broken into parts
+* CLI command `hexapdf image2pdf` so that treating a PDF as image works
+
+
 ## 0.11.4 - 2019-12-28
 
 ### Fixed

data/lib/hexapdf/cli/image2pdf.rb

@@ -99,15 +99,15 @@ module HexaPDF
         @margins = [0, 0, 0, 0]
       end
 
-      def execute(out_file, *images) #:nodoc:
+      def execute(*images, out_file) #:nodoc:
         maybe_raise_on_existing_file(out_file)
 
         out = HexaPDF::Document.new
 
         images.each do |image_file|
           image = out.images.add(image_file)
-          iw = image.info.width.to_f
-          ih = image.info.height.to_f
+          iw = image.width.to_f
+          ih = image.height.to_f
           if @scale != :fit
             iw *= 72 / @scale
             ih *= 72 / @scale

data/lib/hexapdf/document.rb

@@ -52,6 +52,11 @@ require 'hexapdf/image_loader'
 require 'hexapdf/font_loader'
 require 'hexapdf/layout'
 
+begin
+  require 'hexapdf/cext'
+rescue LoadError
+end
+
 # == HexaPDF API Documentation
 #
 # Here are some pointers to more in depth information:

data/lib/hexapdf/document/pages.rb

@@ -107,6 +107,8 @@ module HexaPDF
       # Deletes the given page object from the document's page tree (but *not* from the document).
       #
       # Returns the page object, or +nil+ if the page object was not in the page tree.
+      #
+      # Also see: HexaPDF::Type::PageTreeNode#delete_page
       def delete(page)
         @document.catalog.pages.delete_page(page)
       end
@@ -118,6 +120,8 @@ module HexaPDF
       # document).
       #
       # Returns the page object, or +nil+ if the index was invalid.
+      #
+      # Also see: HexaPDF::Type::PageTreeNode#delete_page
       def delete_at(index)
         @document.catalog.pages.delete_page(index)
       end

data/lib/hexapdf/encryption/security_handler.rb

@@ -59,6 +59,12 @@ module HexaPDF
       define_field :StrF,      type: Symbol, default: :Identity, version: '1.5'
       define_field :EFF,       type: Symbol, version: '1.6'
 
+      # Returns +true+ because some PDF readers stumble when encountering a non-indirect encryption
+      # dictionary.
+      def must_be_indirect?
+        true
+      end
+
       private
 
       # Ensures that the encryption dictionary's content is valid.

data/lib/hexapdf/font/true_type/table/cmap_subtable.rb

@@ -73,9 +73,14 @@ module HexaPDF
           attr_accessor :language
 
           # The complete code map.
+          #
+          # Is only fully initialized for existing fonts when a mapping is first accessed via #[].
           attr_accessor :code_map
 
           # The complete gid map.
+          #
+          # Is only fully initialized for existing fonts when a mapping is first accessed via
+          # #gid_to_code.
           attr_accessor :gid_map
 
           # Creates a new subtable.
@@ -127,7 +132,22 @@ module HexaPDF
             elsif [0, 2, 4, 6].include?(@format)
               length, @language = io.read(4).unpack('n2')
             end
-            supported = true
+
+            return false unless [0, 2, 4, 6, 10, 12].include?(@format)
+            offset = io.pos
+            @code_map = lambda do |code|
+              parse_mapping(io, offset, length)
+              @code_map[code]
+            end
+            @gid_map = lambda do |gid|
+              parse_mapping(io, offset, length)
+              @gid_map[gid]
+            end
+            true
+          end
+
+          def parse_mapping(io, offset, length)
+            io.pos = offset
             @code_map, @gid_map = case @format
                                   when 0 then Format0.parse(io, length)
                                   when 2 then Format2.parse(io, length)
@@ -135,12 +155,9 @@ module HexaPDF
                                   when 6 then Format6.parse(io, length)
                                   when 10 then Format10.parse(io, length)
                                   when 12 then Format12.parse(io, length)
-                                  else
-                                    supported = false
-                                    [{}, {}]
                                   end
-            supported
           end
+          private :parse_mapping
 
           def inspect #:nodoc:
             "#<#{self.class.name} (#{platform_id}, #{encoding_id}, #{language}, " \

data/lib/hexapdf/font/true_type/table/hmtx.rb

@@ -51,7 +51,7 @@ module HexaPDF
           # the :left_side_bearing.
           Metric = Struct.new(:advance_width, :left_side_bearing)
 
-          # An array of Metric objects, one for each glyph in the font.
+          # A hash of glyph ID to Metric objects mapping.
           attr_accessor :horizontal_metrics
 
           # Returns the Metric object for the give glyph ID.
@@ -63,10 +63,20 @@ module HexaPDF
 
           def parse_table #:nodoc:
             nr_entries = font[:hhea].num_of_long_hor_metrics
-            @horizontal_metrics = Array.new(nr_entries) { Metric.new(*read_formatted(4, 'ns>')) }
-            last_advance_width = @horizontal_metrics[-1].advance_width
-            read_formatted(directory_entry.length - 4 * nr_entries, 's>*').map do |lsb|
-              @horizontal_metrics << Metric.new(last_advance_width, lsb)
+            max_id = nr_entries + (directory_entry.length - 4 * nr_entries) / 2
+            @horizontal_metrics = Hash.new do |hash, glyph_id|
+              return nil if glyph_id >= max_id
+              if glyph_id >= nr_entries
+                with_io_pos(directory_entry.offset + 4 * nr_entries + (glyph_id - nr_entries) * 2) do
+                  hash[glyph_id] = Metric.new(@horizontal_metrics[nr_entries - 1].advance_width,
+                                              *read_formatted(2, 's>'))
+                end
+              else
+                with_io_pos(directory_entry.offset + 4 * glyph_id) do
+                  hash[glyph_id] = Metric.new(*read_formatted(4, 'ns>'))
+                end
+              end
+              hash[glyph_id]
             end
           end
 

data/lib/hexapdf/layout/text_box.rb

@@ -64,6 +64,9 @@ module HexaPDF
       #
       # Also see TextLayouter#style for other style properties taken into account.
       def fit(available_width, available_height, frame)
+        return false if (@initial_width > 0 && @initial_width > available_width) ||
+          (@initial_height > 0 && @initial_height > available_height)
+
         @width = @height = 0
         @result = if style.position == :flow
                     @tl.fit(@items, frame.width_specification, frame.contour_line.bbox.height)
@@ -74,8 +77,8 @@ module HexaPDF
                     height = (@initial_height > 0 ? @initial_height : available_height) - @height
                     @tl.fit(@items, width, height)
                   end
-        @width += @result.lines.max_by(&:width)&.width || 0
-        @height += @result.height
+        @width += (@initial_width > 0 ? width : @result.lines.max_by(&:width)&.width || 0)
+        @height += (@initial_height > 0 ? height : @result.height)
         if style.last_line_gap && @result.lines.last
           @height += style.line_spacing.gap(@result.lines.last, @result.lines.last)
         end
@@ -86,7 +89,9 @@ module HexaPDF
       # Splits the text box into two boxes if necessary and possible.
       def split(available_width, available_height, frame)
         fit(available_width, available_height, frame) unless @result
-        if @result.remaining_items.empty?
+        if @width > available_width || @height > available_height
+          [nil, self]
+        elsif @result.remaining_items.empty?
           [self]
         elsif @result.lines.empty?
           [nil, self]

data/lib/hexapdf/layout/text_layouter.rb

@@ -751,6 +751,7 @@ module HexaPDF
 
         while true
           too_wide_box = nil
+          line_height = 0
 
           rest = style.text_line_wrapping_algorithm.call(rest, width_block) do |line, item|
             # make sure empty lines broken by mandatory paragraph breaks are not empty

data/lib/hexapdf/serializer.rb

@@ -187,7 +187,7 @@ module HexaPDF
         begin
           str = obj.to_s.dup.force_encoding(Encoding::BINARY)
           str.gsub!(NAME_REGEXP, NAME_SUBSTS)
-          "/#{str}"
+          str.empty? ? "/ " : "/#{str}"
         end
     end
 

data/lib/hexapdf/task/optimize.rb

@@ -127,13 +127,18 @@ module HexaPDF
         when :delete
           doc.revisions.each_with_index do |rev, rev_index|
             xref_stream = false
+            objects_to_delete = []
             rev.each do |obj|
-              if obj.type == :ObjStm || (obj.type == :XRef && xref_streams == :delete)
-                rev.delete(obj)
+              if obj.type == :ObjStm
+                objects_to_delete << obj
+              elsif obj.type == :XRef
+                xref_stream = true
+                objects_to_delete << obj if xref_streams == :delete
               else
                 delete_fields_with_defaults(obj)
               end
             end
+            objects_to_delete.each {|obj| rev.delete(obj) }
             if xref_streams == :generate && !xref_stream
               doc.add({Type: :XRef}, revision: rev_index)
             end
@@ -143,11 +148,12 @@ module HexaPDF
             xref_stream = false
             count = 0
             objstms = [doc.wrap({Type: :ObjStm})]
+            old_objstms = []
             rev.each do |obj|
               if obj.type == :XRef
                 xref_stream = true
               elsif obj.type == :ObjStm
-                rev.delete(obj)
+                old_objstms << obj
               end
               delete_fields_with_defaults(obj)
 
@@ -160,6 +166,7 @@ module HexaPDF
                 count = 0
               end
             end
+            old_objstms.each {|objstm| rev.delete(objstm) }
             objstms.each {|objstm| doc.add(objstm, revision: rev_index) }
             doc.add({Type: :XRef}, revision: rev_index) unless xref_stream
           end

data/lib/hexapdf/version.rb

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

data/test/hexapdf/encryption/test_security_handler.rb

@@ -13,6 +13,10 @@ describe HexaPDF::Encryption::EncryptionDictionary do
     @dict[:V] = 1
   end
 
+  it "must be an indirect object" do
+    assert(@dict.must_be_indirect?)
+  end
+
   it "validates the /V value" do
     @dict[:V] = 1
     assert(@dict.validate)

data/test/hexapdf/font/true_type/table/test_cmap_subtable.rb

@@ -43,14 +43,14 @@ describe HexaPDF::Font::TrueType::Table::CmapSubtable do
 
     it "works for format 0" do
       t = table([0, 262, 0].pack('n3') + [255].pack('C*') + (0..254).to_a.pack('C*'))
+      assert_equal(0, t.gid_to_code(255))
+      assert_equal(234, t.gid_to_code(233))
+
       assert_equal(255, t[0])
       assert_equal(233, t[234])
       assert_nil(t[256])
 
-      assert_equal(0, t.gid_to_code(255))
-      assert_equal(234, t.gid_to_code(233))
-
-      assert_raises(HexaPDF::Error) { table([0, 20, 0].pack('n3') + "a" * 20) }
+      assert_raises(HexaPDF::Error) { table([0, 20, 0].pack('n3') + "a" * 20)[0] }
     end
 
     it "works for format 2" do

data/test/hexapdf/font/true_type/table/test_hmtx.rb

@@ -5,7 +5,7 @@ require_relative 'common'
 require 'hexapdf/font/true_type/table/hhea'
 require 'hexapdf/font/true_type/table/hmtx'
 
-describe HexaPDF::Font::TrueType::Table::Hhea do
+describe HexaPDF::Font::TrueType::Table::Hmtx do
   before do
     data = [1, -2, 3, -4, 5, -6].pack('ns>ns>s>2')
     set_up_stub_true_type_font(data)
@@ -17,14 +17,14 @@ describe HexaPDF::Font::TrueType::Table::Hhea do
   describe "initialize" do
     it "reads the data from the associated file" do
       table = create_table(:Hmtx)
-      assert_equal(1, table[0].advance_width)
-      assert_equal(-2, table[0].left_side_bearing)
-      assert_equal(3, table[1].advance_width)
-      assert_equal(-4, table[1].left_side_bearing)
       assert_equal(3, table[2].advance_width)
       assert_equal(5, table[2].left_side_bearing)
       assert_equal(3, table[3].advance_width)
       assert_equal(-6, table[3].left_side_bearing)
+      assert_equal(1, table[0].advance_width)
+      assert_equal(-2, table[0].left_side_bearing)
+      assert_equal(3, table[1].advance_width)
+      assert_equal(-4, table[1].left_side_bearing)
     end
   end
 end

data/test/hexapdf/layout/test_text_box.rb

@@ -31,11 +31,11 @@ describe HexaPDF::Layout::TextBox do
     end
 
     it "respects the set width and height" do
-      box = create_box([@inline_box] * 5, width: 40, height: 50, style: {padding: 10})
+      box = create_box([@inline_box], width: 40, height: 50, style: {padding: 10})
       assert(box.fit(100, 100, @frame))
       assert_equal(40, box.width)
       assert_equal(50, box.height)
-      assert_equal([20, 20, 10], box.instance_variable_get(:@result).lines.map(&:width))
+      assert_equal([10], box.instance_variable_get(:@result).lines.map(&:width))
     end
 
     it "fits into the frame's outline" do
@@ -52,6 +52,16 @@ describe HexaPDF::Layout::TextBox do
       assert_equal(50, box.width)
       assert_equal(20, box.height)
     end
+
+    it "can't fit the text box if the set width is bigger than the available width" do
+      box = create_box([@inline_box], width: 101)
+      refute(box.fit(100, 100, @frame))
+    end
+
+    it "can't fit the text box if the set height is bigger than the available height" do
+      box = create_box([@inline_box], height: 101)
+      refute(box.fit(100, 100, @frame))
+    end
   end
 
   describe "split" do
@@ -70,6 +80,14 @@ describe HexaPDF::Layout::TextBox do
       assert_equal([nil, box], box.split(5, 20, @frame))
     end
 
+    it "works if the whole text box doesn't fits" do
+      box = create_box([@inline_box], width: 102)
+      assert_equal([nil, box], box.split(100, 100, @frame))
+
+      box = create_box([@inline_box], height: 102)
+      assert_equal([nil, box], box.split(100, 100, @frame))
+    end
+
     it "splits the box if necessary" do
       box = create_box([@inline_box] * 10)
       boxes = box.split(50, 10, @frame)

data/test/hexapdf/layout/test_text_layouter.rb

@@ -556,18 +556,37 @@ describe HexaPDF::Layout::TextLayouter do
       end
     end
 
-    it "breaks a text fragment into parts if it is wider than the available width" do
-      str = " Thisisaverylongstring"
-      frag = HexaPDF::Layout::TextFragment.create(str, font: @font)
-      result = @layouter.fit([frag], 20, 100)
-      assert(result.remaining_items.empty?)
-      assert_equal(:success, result.status)
-      assert_equal(str.strip.length, result.lines.sum {|l| l.items.sum {|i| i.items.count } })
-      assert_equal(45, result.height)
+    describe "breaks a text fragment into parts if it is wider than the available width" do
+      before do
+        @str = " This is averylongstring"
+        @frag = HexaPDF::Layout::TextFragment.create(@str, font: @font)
+      end
 
-      result = @layouter.fit([frag], 1, 100)
-      assert_equal(str.strip.length, result.remaining_items.count)
-      assert_equal(:box_too_wide, result.status)
+      it "works with fixed width" do
+        result = @layouter.fit([@frag], 20, 100)
+        assert(result.remaining_items.empty?)
+        assert_equal(:success, result.status)
+        assert_equal(@str.delete(" ").length, result.lines.sum {|l| l.items.sum {|i| i.items.count } })
+        assert_equal(54, result.height)
+
+        result = @layouter.fit([@frag], 1, 100)
+        assert_equal(8, result.remaining_items.count)
+        assert_equal(:box_too_wide, result.status)
+      end
+
+      it "works with variable width" do
+        width_block = lambda do |height, line_height|
+          # 'averylongstring' would fit when only considering height but not height + line_height
+          if height + line_height < 15
+            63
+          else
+            10
+          end
+        end
+        result = @layouter.fit([@frag], width_block, 30)
+        assert_equal(:height, result.status)
+        assert_equal([26.95, 9.44, 7.77], result.lines.map {|l| l.width.round(3) })
+      end
     end
 
     describe "horizontal alignment" do

data/test/hexapdf/task/test_optimize.rb

@@ -7,13 +7,15 @@ require 'hexapdf/task/optimize'
 describe HexaPDF::Task::Optimize do
   class TestType < HexaPDF::Dictionary
 
+    define_type :Test
     define_field :Optional, type: Symbol, default: :Optional
 
   end
 
   before do
+    HexaPDF::GlobalConfiguration['object.type_map'][:Test] = TestType
     @doc = HexaPDF::Document.new
-    @obj1 = @doc.add(@doc.wrap({Optional: :Optional}, type: TestType))
+    @obj1 = @doc.add({Type: :Test, Optional: :Optional})
     @doc.trailer[:Test] = @doc.wrap(@obj1)
     @doc.revisions.add
     @obj2 = @doc.add({Type: :UsedEntry})
@@ -22,6 +24,10 @@ describe HexaPDF::Task::Optimize do
     @obj1[:Test] = @doc.wrap(@obj4, type: TestType)
   end
 
+  after do
+    HexaPDF::GlobalConfiguration['object.type_map'].delete(:Test)
+  end
+
   def assert_objstms_generated
     assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :ObjStm } })
     assert(@doc.revisions.all? {|rev| rev.any? {|obj| obj.type == :XRef } })
@@ -40,7 +46,7 @@ describe HexaPDF::Task::Optimize do
   end
 
   def assert_default_deleted
-    refute(@obj1.value.key?(:Optional))
+    refute(@doc.object(1).key?(:Optional))
   end
 
   describe "compact" do
@@ -84,21 +90,29 @@ describe HexaPDF::Task::Optimize do
   end
 
   describe "object_streams" do
-    it "generates object streams" do
+    def reload_document_with_objstm_from_io
+      io = StringIO.new
       objstm = @doc.add({Type: :ObjStm})
-      xref = @doc.add({Type: :XRef})
+      @doc.add({Type: :XRef})
+      objstm.add_object(@doc.add({Type: :Test}))
+      @doc.write(io)
+      io.rewind
+      @doc = HexaPDF::Document.new(io: io)
+    end
+
+    it "generates object streams" do
       210.times { @doc.add(5) }
+      objstm = @doc.add({Type: :ObjStm})
+      reload_document_with_objstm_from_io
       @doc.task(:optimize, object_streams: :generate)
       assert_objstms_generated
       assert_default_deleted
       assert_nil(@doc.object(objstm).value)
-      assert(3, @doc.revisions.current.find_all {|obj| obj.type == :ObjStm }.size)
-      assert([xref], @doc.revisions.current.find_all {|obj| obj.type == :XRef })
+      assert_equal(2, @doc.revisions.current.find_all {|obj| obj.type == :ObjStm }.size)
     end
 
     it "deletes object and xref streams" do
-      @doc.add({Type: :ObjStm})
-      @doc.add({Type: :XRef})
+      reload_document_with_objstm_from_io
       @doc.task(:optimize, object_streams: :delete, xref_streams: :delete)
       assert_no_objstms
       assert_no_xrefstms
@@ -107,9 +121,11 @@ describe HexaPDF::Task::Optimize do
 
     it "deletes object and generates xref streams" do
       @doc.add({Type: :ObjStm})
+      xref = @doc.add({Type: :XRef})
       @doc.task(:optimize, object_streams: :delete, xref_streams: :generate)
       assert_no_objstms
       assert_xrefstms_generated
+      assert_equal([xref], @doc.revisions.current.find_all {|obj| obj.type == :XRef })
       assert_default_deleted
     end
   end

data/test/hexapdf/test_serializer.rb

@@ -75,18 +75,18 @@ describe HexaPDF::Serializer do
     assert_serialized('/lime#20Green', 'lime Green'.intern)
     assert_serialized('/paired#28#29parentheses', 'paired()parentheses'.intern)
     assert_serialized('/The_Key_of_F#23_Minor', 'The_Key_of_F#_Minor'.intern)
-    assert_serialized('/', ''.intern)
+    assert_serialized('/ ', ''.intern)
     assert_serialized('/H#c3#b6#c3#9fgang', "Hößgang".intern)
     assert_serialized('/H#e8lp', "H\xE8lp".force_encoding('BINARY').intern)
   end
 
   it "serializes arrays" do
-    assert_serialized("[-12 2.4321/Name true(345)true]", [-12, 2.4321, :Name, true, '345', true])
+    assert_serialized("[-12/  2.4321/Name true(345)true]", [-12, :"", 2.4321, :Name, true, '345', true])
     assert_serialized("[]", [])
   end
 
   it "serializes hashes" do
-    assert_serialized("<</hallo 5/other true/name[5]>>", hallo: 5, other: true, name: [5])
+    assert_serialized("<</hallo 5/  true/other true/name[5]>>", hallo: 5, "": true, other: true, name: [5])
     assert_serialized("<<>>", {})
   end
 

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.11.4)>>
+      <</Producer(HexaPDF version 0.11.9)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.11.4)>>
+      <</Producer(HexaPDF version 0.11.9)>>
       endobj
       2 0 obj
       <</Length 10>>stream

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.11.4
+  version: 0.11.9
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-28 00:00:00.000000000 Z
+date: 2020-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -102,11 +102,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- CONTRIBUTERS
 - LICENSE
 - README.md
 - Rakefile
-- VERSION
 - agpl-3.0.txt
 - bin/hexapdf
 - data/hexapdf/afm/Courier-Bold.afm
@@ -401,7 +399,6 @@ files:
 - lib/hexapdf/version.rb
 - lib/hexapdf/writer.rb
 - lib/hexapdf/xref_section.rb
-- man/man1/hexapdf.1
 - test/data/aes-test-vectors/CBCGFSbox-128-decrypt.data.gz
 - test/data/aes-test-vectors/CBCGFSbox-128-encrypt.data.gz
 - test/data/aes-test-vectors/CBCGFSbox-192-decrypt.data.gz

data/CONTRIBUTERS

@@ -1,5 +0,0 @@
-  Count Name
-======= ====
-   1097 Thomas Leitner <t_leitner@gmx.at>
-      1 Stanislav (Stas) Katkov <sk@skylup.com>
-      1 Daniel Kraus <bovender@bovender.de>

data/VERSION

@@ -1 +0,0 @@
-0.11.4