hexapdf 0.2.0 → 0.3.0

data/test/hexapdf/test_serializer.rb

@@ -116,6 +116,9 @@ describe HexaPDF::Serializer do
     assert_serialized("/Name", HexaPDF::Object.new(:Name, oid: 1))
     assert_serialized("<</Name 2 0 R>>",
                       HexaPDF::Object.new({Name: HexaPDF::Object.new(5, oid: 2)}, oid: 1))
+    obj = HexaPDF::Object.new({Name: HexaPDF::Object.new(5, oid: 2)}, oid: 1)
+    obj.value[:Self] = obj
+    assert_serialized("<</Name 2 0 R/Self 1 0 R>>", obj)
   end
 
   it "serializes HexaPDF reference objects" do

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ startxref
 219
 %%EOF
 3 0 obj
-<</Producer(HexaPDF version 0.2.0)>>
+<</Producer(HexaPDF version 0.3.0)>>
 endobj
 xref
 3 1
@@ -72,7 +72,7 @@ startxref
 141
 %%EOF
 6 0 obj
-<</Producer(HexaPDF version 0.2.0)>>
+<</Producer(HexaPDF version 0.3.0)>>
 endobj
 2 0 obj
 <</Length 10>>stream
@@ -117,4 +117,13 @@ EOF
     xref_section.add_compressed_entry(1, 2, 3)
     assert_raises(HexaPDF::Error) { writer.send(:write_xref_section, xref_section) }
   end
+
+  it "removes the /XRefStm entry in a trailer" do
+    io = StringIO.new
+    doc = HexaPDF::Document.new
+    doc.trailer[:XRefStm] = 1234
+    doc.write(io)
+    doc = HexaPDF::Document.new(io: io)
+    refute(doc.trailer.key?(:XRefStm))
+  end
 end

data/test/hexapdf/test_xref_section.rb

@@ -8,6 +8,21 @@ describe HexaPDF::XRefSection do
     @xref_section = HexaPDF::XRefSection.new
   end
 
+  describe "merge" do
+    it "adds all entries from the other xref section, potentially overwriting entries" do
+      @xref_section.add_in_use_entry(1, 0, 1)
+      xref = HexaPDF::XRefSection.new
+      xref.add_in_use_entry(1, 0, 2)
+      xref.add_in_use_entry(2, 0, 2)
+      assert_equal(1, @xref_section[1, 0].pos)
+      assert_nil(@xref_section[2, 0])
+
+      @xref_section.merge!(xref)
+      assert_equal(2, @xref_section[1, 0].pos)
+      assert_equal(2, @xref_section[2, 0].pos)
+    end
+  end
+
   describe "each_subsection" do
     def assert_subsections(result)
       assert_equal(result, @xref_section.each_subsection.map {|s| s.map(&:oid)})

data/test/hexapdf/type/test_image.rb

@@ -0,0 +1,234 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'tempfile'
+require 'hexapdf/document'
+
+describe HexaPDF::Type::Image do
+  before do
+    @jpg = File.join(TEST_DATA_DIR, 'images', 'rgb.jpg')
+    @doc = HexaPDF::Document.new
+  end
+
+  describe "info" do
+    before do
+      @image = @doc.wrap(Subtype: :Image, Width: 10, Height: 5, ColorSpace: :DeviceRGB,
+                         BitsPerComponent: 4)
+    end
+
+    it "uses the Width, Height and BitsPerComponent values" do
+      assert_equal(10, @image.info.width)
+      assert_equal(5, @image.info.height)
+      assert_equal(4, @image.info.bits_per_component)
+    end
+
+    it "determines the type and extension based on the stream filter" do
+      @image.set_filter(:DCTDecode)
+      info = @image.info
+      assert_equal(:jpeg, info.type)
+      assert_equal('jpg', info.extension)
+      assert(info.writable)
+
+      @image.set_filter(:JPXDecode)
+      info = @image.info
+      assert_equal(:jp2, info.type)
+      assert_equal('jpx', info.extension)
+      assert(info.writable)
+
+      @image.set_filter(:JBIG2Decode)
+      info = @image.info
+      assert_equal(:jbig2, info.type)
+      refute(info.writable)
+
+      @image.set_filter(:CCITTFaxDecode)
+      info = @image.info
+      assert_equal(:ccitt, info.type)
+      refute(info.writable)
+
+      @image.set_filter(nil)
+      info = @image.info
+      assert_equal(:png, @image.info.type)
+      assert_equal('png', info.extension)
+      assert(info.writable)
+    end
+
+    it "determines the color space, indexed and components values using the ColorSpace value" do
+      @image[:ColorSpace] = :DeviceGray
+      info = @image.info
+      assert_equal(:gray, info.color_space)
+      assert_equal(1, info.components)
+      refute(info.indexed)
+      assert(info.writable)
+
+      @image[:ColorSpace] = [:CalGray, {WhitePoint: [1, 1, 1]}]
+      info = @image.info
+      assert_equal(:gray, info.color_space)
+      assert_equal(1, info.components)
+      refute(info.indexed)
+      assert(info.writable)
+
+      @image[:ColorSpace] = :DeviceRGB
+      info = @image.info
+      assert_equal(:rgb, info.color_space)
+      assert_equal(3, info.components)
+      refute(info.indexed)
+      assert(info.writable)
+
+      @image[:ColorSpace] = [:CalRGB, {WhitePoint: [1, 1, 1]}]
+      info = @image.info
+      assert_equal(:rgb, info.color_space)
+      assert_equal(3, info.components)
+      refute(info.indexed)
+      assert(info.writable)
+
+
+      @image[:ColorSpace] = :DeviceCMYK
+      @image[:Filter] = :DCTDecode
+      info = @image.info
+      assert_equal(:cmyk, info.color_space)
+      assert_equal(4, info.components)
+      refute(info.indexed)
+      assert(info.writable)
+
+      @image[:ColorSpace] = :DeviceCMYK
+      @image[:Filter] = :FlateDecode
+      info = @image.info
+      assert_equal(:cmyk, info.color_space)
+      assert_equal(4, info.components)
+      refute(info.indexed)
+      refute(info.writable)
+
+
+      @image[:ColorSpace] = [:Indexed, :DeviceRGB, 1, "\x80".b * 6]
+      info = @image.info
+      assert_equal(:rgb, info.color_space)
+      assert_equal(3, info.components)
+      assert(info.indexed)
+      assert(info.writable)
+
+
+      @image[:ColorSpace] = :ICCBased
+      info = @image.info
+      assert_equal(:other, info.color_space)
+      assert_equal(-1, info.components)
+    end
+  end
+
+  describe "write" do
+    before do
+      @file = Tempfile.new(['hexapdf-image-write-test', '.png'])
+    end
+
+    after do
+      @file.unlink
+    end
+
+    `pngcheck 2>&1`
+    if $?.exitstatus != 0
+      warn("Skipping PNG output validity check because pngcheck executable is missing")
+      PNG_CHECK_AVAILABLE = false
+    else
+      PNG_CHECK_AVAILABLE = true
+    end
+
+    def assert_valid_png(filename)
+      return unless PNG_CHECK_AVAILABLE
+      result = `pngcheck -q #{filename}`
+      assert(result.empty?, "pngcheck error: #{result}")
+    end
+
+    it "can write to an IO" do
+      io = StringIO.new(''.b)
+      image = @doc.images.add(@jpg)
+      image.write(io)
+      assert_equal(File.binread(@jpg), io.string)
+    end
+
+    it "writes JPEG images to a file with .jpg extension" do
+      begin
+        file = Tempfile.new(['hexapdf-image-write-test', '.jpg'])
+        image = @doc.images.add(@jpg)
+        image.write(file.path)
+        assert_equal(File.binread(@jpg), File.binread(file.path))
+      ensure
+        file.unlink
+      end
+    end
+
+    it "writes JPEG2000 images to a file with .jpx extension" do
+      begin
+        file = Tempfile.new(['hexapdf-image-write-test', '.jpx'])
+        image = @doc.images.add(@jpg)
+        image.set_filter(:JPXDecode) # fake it
+        image.write(file.path)
+        assert_equal(File.binread(@jpg), File.binread(file.path))
+      ensure
+        file.unlink
+      end
+    end
+
+    Dir.glob(File.join(TEST_DATA_DIR, 'images', '*.png')).each do |png_file|
+      it "writes #{File.basename(png_file)} correctly as PNG file" do
+        image = @doc.images.add(png_file)
+        image.write(@file.path)
+
+        assert_valid_png(@file.path)
+
+        new_image = @doc.images.add(@file.path)
+
+        assert_equal(image[:Width], new_image[:Width], "file: #{png_file}")
+        assert_equal(image[:Height], new_image[:Height], "file: #{png_file}")
+        assert_equal(image[:BitsPerComponent], new_image[:BitsPerComponent], "file: #{png_file}")
+        if image[:Mask]
+          assert_equal(image[:Mask], new_image[:Mask], "file: #{png_file}")
+        else
+          assert_nil(new_image[:Mask], "file: #{png_file}")
+        end
+        assert_equal(image.stream, new_image.stream, "file: #{png_file}")
+
+        # ColorSpace is currently not always preserved, e.g. with CalRGB
+        if Array(image[:ColorSpace]).first == :Indexed
+          assert_equal(image[:ColorSpace][2], new_image[:ColorSpace][2], "file: #{png_file}")
+
+          img_palette = image[:ColorSpace][3]
+          img_palette = img_palette.stream if img_palette.respond_to?(:stream)
+          new_img_palette = new_image[:ColorSpace][3]
+          new_img_palette = new_img_palette.stream if new_img_palette.respond_to?(:stream)
+          assert_equal(img_palette, new_img_palette, "file: #{png_file}")
+        end
+      end
+    end
+
+    it "works for greyscale indexed images" do
+      image = @doc.add(Subtype: :Image, Width: 2, Height: 2, BitsPerComponent: 2,
+                       ColorSpace: [:Indexed, :DeviceGray, 3, "\x00\x40\x80\xFF".b])
+      image.stream = HexaPDF::StreamData.new(filter: :ASCIIHexDecode) { "10 B0".b }
+      image.write(@file.path)
+      assert_valid_png(@file.path)
+
+      new_image = @doc.images.add(@file.path)
+      assert_equal([:Indexed, :DeviceRGB, 3, "\x00\x00\x00\x40\x40\x40\x80\x80\x80\xFF\xFF\xFF".b],
+                   new_image[:ColorSpace])
+      assert_equal(image.stream, new_image.stream)
+    end
+
+    it "fails if an unsupported stream filter is used" do
+      image = @doc.images.add(@jpg)
+      image.set_filter([:DCTDecode, :ASCIIHexDecode])
+      assert_raises(HexaPDF::Error) { image.write(@file) }
+    end
+
+    it "fails if an unsupported colorspace is used" do
+      image = @doc.add(Subtype: :Image, Width: 1, Height: 1, BitsPerComponent: 8,
+                       ColorSpace: :ICCBased)
+      assert_raises(HexaPDF::Error) { image.write(@file) }
+    end
+
+    it "fails if an indexed image with an unsupported colorspace is used" do
+      image = @doc.add(Subtype: :Image, Width: 1, Height: 1, BitsPerComponent: 8,
+                       ColorSpace: [:Indexed, :ICCBased, 0, "0"])
+      assert_raises(HexaPDF::Error) { image.write(@file) }
+    end
+  end
+end

data/test/hexapdf/type/test_object_stream.rb

@@ -49,11 +49,11 @@ describe HexaPDF::Type::ObjectStream do
     @obj.delete_object(5)
     assert_equal(0, @obj.object_index(9))
     assert_equal(1, @obj.object_index(7))
-    assert_equal(nil, @obj.object_index(5))
+    assert_nil(@obj.object_index(5))
 
     @obj.delete_object(7)
     @obj.delete_object(9)
-    assert_equal(nil, @obj.object_index(5))
+    assert_nil(@obj.object_index(5))
   end
 
   it "allows writing the objects to the stream" do

data/test/hexapdf/type/test_trailer.rb

@@ -51,6 +51,10 @@ describe HexaPDF::Type::Trailer do
       @obj.update_id
       assert_same(@obj[:ID][0], @obj[:ID][1])
 
+      @obj[:ID] = 5
+      @obj.update_id
+      assert_same(@obj[:ID][0], @obj[:ID][1])
+
       @obj.update_id
       refute_same(@obj[:ID][0], @obj[:ID][1])
     end

data/test/hexapdf/utils/test_bit_stream.rb

@@ -0,0 +1,69 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/utils/bit_stream'
+
+describe HexaPDF::Utils::BitStreamReader do
+  before do
+    @reader = HexaPDF::Utils::BitStreamReader.new
+  end
+
+  it "allows appending data" do
+    assert_equal(0, @reader.remaining_bits)
+    @reader << "data"
+    assert_equal(32, @reader.remaining_bits)
+    @reader << "some"
+    assert_equal(64, @reader.remaining_bits)
+    @reader.read(4)
+    assert_equal(60, @reader.remaining_bits)
+    @reader << "more"
+    assert_equal(92, @reader.remaining_bits)
+  end
+
+  it "allows checking whether a certain number of bits can be read" do
+    refute(@reader.read?(1))
+    @reader << "data"
+    assert(@reader.read?(1))
+    assert(@reader.read?(32))
+    refute(@reader.read?(33))
+  end
+
+  describe "read" do
+    it "allows reading any number of bits" do
+      @reader << "\xaa" * 8  # 10101010 * 8
+      assert_equal(1, @reader.read(1))
+      assert_equal(0, @reader.read(1))
+      assert_equal(2, @reader.read(2))
+      assert_equal(10, @reader.read(4))
+      assert_equal(5, @reader.read(3))
+      assert_equal((0b01010 << 8) | 0xaa, @reader.read(13))
+      assert_equal(5, @reader.read(3))
+      assert_equal((0b01010 << 7) | (0xaa >> 1), @reader.read(12))
+      assert_equal(2, @reader.read(3))
+    end
+
+    it "allows reading many bits" do
+      @reader << "\x80" << "\x00" * 20
+      assert_equal(2**127, @reader.read(128))
+    end
+
+    it "returns nil if enough bits are available" do
+      assert_nil(@reader.read(1))
+    end
+  end
+end
+
+describe HexaPDF::Utils::BitStreamWriter do
+  before do
+    @writer = HexaPDF::Utils::BitStreamWriter.new
+  end
+
+  it "allows writing any number of bits" do
+    result = @writer.write(1, 1)
+    result << @writer.write(0b101, 3)
+    result << @writer.write(0xff, 8)
+    result << @writer.write(0x5ddd, 15)
+    result << @writer.finalize
+    assert_equal("\xdf\xfb\xbb\xa0".b, result)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-28 00:00:00.000000000 Z
+date: 2017-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -19,7 +19,7 @@ dependencies:
         version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: 3.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: 3.0.3
 - !ruby/object:Gem::Dependency
   name: kramdown
   requirement: !ruby/object:Gem::Requirement
@@ -98,10 +98,14 @@ files:
 - examples/truetype.rb
 - lib/hexapdf.rb
 - lib/hexapdf/cli.rb
-- lib/hexapdf/cli/extract.rb
+- lib/hexapdf/cli/command.rb
+- lib/hexapdf/cli/files.rb
+- lib/hexapdf/cli/images.rb
 - lib/hexapdf/cli/info.rb
 - lib/hexapdf/cli/inspect.rb
+- lib/hexapdf/cli/merge.rb
 - lib/hexapdf/cli/modify.rb
+- lib/hexapdf/cli/optimize.rb
 - lib/hexapdf/configuration.rb
 - lib/hexapdf/content.rb
 - lib/hexapdf/content/canvas.rb
@@ -159,6 +163,7 @@ files:
 - lib/hexapdf/font/encoding/zapf_dingbats_encoding.rb
 - lib/hexapdf/font/true_type.rb
 - lib/hexapdf/font/true_type/font.rb
+- lib/hexapdf/font/true_type/subsetter.rb
 - lib/hexapdf/font/true_type/table.rb
 - lib/hexapdf/font/true_type/table/cmap.rb
 - lib/hexapdf/font/true_type/table/cmap_subtable.rb
@@ -360,6 +365,7 @@ files:
 - test/hexapdf/font/true_type/table/test_os2.rb
 - test/hexapdf/font/true_type/table/test_post.rb
 - test/hexapdf/font/true_type/test_font.rb
+- test/hexapdf/font/true_type/test_subsetter.rb
 - test/hexapdf/font/true_type/test_table.rb
 - test/hexapdf/font/type1/test_afm_parser.rb
 - test/hexapdf/font/type1/test_font.rb
@@ -398,6 +404,7 @@ files:
 - test/hexapdf/type/test_font_simple.rb
 - test/hexapdf/type/test_font_type1.rb
 - test/hexapdf/type/test_form.rb
+- test/hexapdf/type/test_image.rb
 - test/hexapdf/type/test_info.rb
 - test/hexapdf/type/test_names.rb
 - test/hexapdf/type/test_object_stream.rb
@@ -407,6 +414,7 @@ files:
 - test/hexapdf/type/test_trailer.rb
 - test/hexapdf/type/test_xref_stream.rb
 - test/hexapdf/utils/test_bit_field.rb
+- test/hexapdf/utils/test_bit_stream.rb
 - test/hexapdf/utils/test_lru_cache.rb
 - test/hexapdf/utils/test_object_hash.rb
 - test/hexapdf/utils/test_pdf_doc_encoding.rb
@@ -432,7 +440,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby