hexapdf 0.7.0 → 0.8.0

data/test/hexapdf/layout/test_width_from_polygon.rb

@@ -0,0 +1,108 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/layout/width_from_polygon'
+
+describe HexaPDF::Layout::WidthFromPolygon do
+  def create_width_spec(polygon, offset = 0)
+    HexaPDF::Layout::WidthFromPolygon.new(polygon, offset)
+  end
+
+  it "respects the offset" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [10, 5]), 5)
+    assert_equal([0, 8], ws.call(0, 1))
+  end
+
+  it "works in the case bottom and top line are the same" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [10, 5]))
+    assert_equal([0, 0], ws.call(0, 0))
+    assert_equal([0, 0], ws.call(5, 0))
+  end
+
+  it "works when the first segment has not the minimal x-value" do
+    ws = create_width_spec(Geom2D::Polygon([10, 10], [10, 0], [0, 0], [5, 10]))
+    assert_equal([5, 5], ws.call(0, 1))
+    assert_equal([2.5, 7.5], ws.call(5, 1))
+  end
+
+  it "works when the polygon is specified in counterclockwise order" do
+    ws = create_width_spec(Geom2D::Polygon([10, 10], [5, 10], [0, 0], [10, 0]))
+    assert_equal([5, 5], ws.call(0, 1))
+    assert_equal([2.5, 7.5], ws.call(5, 1))
+  end
+
+  it "works if some segments only cross the top line" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [2, 11], [4, 9], [6, 11], [10, 10],
+                                           [10, 0]))
+    assert_equal([0, 3, 2, 5], ws.call(1, 2))
+  end
+
+  it "works if some segments only cross the bottom line" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [2, 4], [4, 6], [6, 4], [10, 10],
+                                           [10, 0]))
+    assert_equal([0, 1, 7, 2], ws.call(3, 2))
+  end
+
+  it "works if some non-horizontal segments don't cross the top/bottom line at all" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [2, 4], [4, 6.5], [6, 6], [10, 10],
+                                           [10, 0]))
+    assert_equal([0, 1, 6, 3], ws.call(3, 2))
+  end
+
+  it "works if there is no available space" do
+    ws = create_width_spec(Geom2D::Polygon([0, 0], [0, 10], [5, 9], [10, 10], [10, 0]))
+    assert_equal([0, 0], ws.call(0, 2))
+  end
+
+  it "works if the first processed segment doesn't cross both lines" do
+    ws = create_width_spec(Geom2D::Polygon([0, 5], [0, 0], [10, 0], [10, 10], [5, 10], [5, 5]))
+    assert_equal([5, 5], ws.call(4, 2))
+  end
+
+  describe "multiple polygons" do
+    it "rectangle in rectangle" do
+      ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),
+                                                Geom2D::Polygon([2, 2], [2, 8], [8, 8], [8, 2])))
+      assert_equal([0, 2, 6, 2], ws.call(1, 8))
+      assert_equal([0, 10], ws.call(0, 2))
+      assert_equal([0, 2, 6, 2], ws.call(2, 1))
+      assert_equal([0, 2, 6, 2], ws.call(7, 2))
+    end
+
+    it "rectangle in rectangle with reverse direction" do
+      ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),
+                                                Geom2D::Polygon([2, 8], [2, 2], [8, 2], [8, 8])))
+      assert_equal([0, 2, 6, 2], ws.call(7, 2))
+      assert_equal([0, 2, 6, 2], ws.call(1, 8))
+      assert_equal([0, 10], ws.call(0, 2))
+      assert_equal([0, 2, 6, 2], ws.call(2, 1))
+    end
+
+    it "first segment of inner polygon is between the lines, polygon crosses both lines" do
+      ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),
+                                                Geom2D::Polygon([2, 4], [2, 6], [8, 8], [8, 2])))
+      assert_equal([0, 10], ws.call(0, 2))
+      assert_equal([0, 5, 3, 2], ws.call(2, 1).map {|f| f.round(5) })
+      assert_equal([0, 2, 6, 2], ws.call(3, 4))
+    end
+
+    it "first segment of inner polygon is between the lines, polygon crosses one line" do
+      ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),
+                                                Geom2D::Polygon([2, 4], [4, 6], [8, 2])))
+      assert_equal([0, 2, 5, 3], ws.call(3, 4))
+    end
+
+    it "polygon is partly between the lines, maximum between the lines" do
+      ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),
+                                                Geom2D::Polygon([2, 4], [2, 6], [8, 8], [9, 5],
+                                                                [8, 2])))
+      assert_equal([0, 2, 7, 1], ws.call(3, 4))
+    end
+
+    it "polygon is partly between the lines, maximum is at an line crossing" do
+      ws = create_width_spec(Geom2D::PolygonSet(Geom2D::Polygon([0, 0], [0, 10], [10, 10], [10, 0]),
+                                                Geom2D::Polygon([2, 4], [8, 8], [5, 5], [8, 2])))
+      assert_equal([0, 2, 5, 3], ws.call(3, 4))
+    end
+  end
+end

data/test/hexapdf/test_dictionary_fields.rb

@@ -10,7 +10,7 @@ describe HexaPDF::DictionaryFields do
 
   describe "Field" do
     before do
-      @field = self.class::Field.new([:Integer, Integer], true, 500, false, '1.2')
+      @field = self.class::Field.new([:Integer, self.class::PDFByteString], true, 500, false, '1.2')
       HexaPDF::GlobalConfiguration['object.type_map'][:Integer] = Integer
     end
 
@@ -27,22 +27,26 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "maps string types to constants" do
-      assert_equal([Integer], @field.type)
+      assert_equal([Integer, self.class::PDFByteString, Hash, String], @field.type)
     end
 
-    it "uses the additional types from a converter" do
-      @field = self.class::Field.new(self.class::PDFByteString)
-      assert_equal([self.class::PDFByteString, String], @field.type)
-    end
+    describe "convert" do
+      it "returns the converted object, using the first usable converter" do
+        doc = Minitest::Mock.new
+        doc.expect(:wrap, :data, [Hash, Hash])
+        @field.convert({}, doc)
+        doc.verify
 
-    it "does not allow any conversion with the identity converter" do
-      x = '5'
-      refute(@field.convert?(x))
-      assert_same(x, @field.convert(x, self))
+        assert(@field.convert('str', self).encoding == Encoding::BINARY)
+      end
+
+      it "returns nil for unconvertable objects" do
+        assert_nil(@field.convert(5.5, self))
+      end
     end
 
     it "can check for a valid object" do
-      refute(@field.valid_object?('Test'))
+      refute(@field.valid_object?(5.5))
       assert(@field.valid_object?(5))
       assert(@field.valid_object?(HexaPDF::Object.new(5)))
     end
@@ -59,18 +63,20 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "allows conversion from a hash" do
-      assert(@field.convert?({}))
       @doc.expect(:wrap, :data, [Hash, Hash])
       @field.convert({Test: :value}, @doc)
       @doc.verify
     end
 
     it "allows conversion from a Dictionary" do
-      assert(@field.convert?(HexaPDF::Dictionary.new({})))
       @doc.expect(:wrap, :data, [HexaPDF::Dictionary, Hash])
       @field.convert(HexaPDF::Dictionary.new(Test: :value), @doc)
       @doc.verify
     end
+
+    it "doesn't allow conversion from nil" do
+      refute(@field.convert(nil, @doc))
+    end
   end
 
   describe "StringConverter" do
@@ -79,7 +85,7 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "allows conversion to UTF-8 string from binary" do
-      assert(@field.convert?('test'.b))
+      refute(@field.convert("test", self))
 
       str = @field.convert("\xfe\xff\x00t\x00e\x00s\x00t".b, self)
       assert_equal('test', str)
@@ -100,8 +106,7 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "allows conversion to a binary string" do
-      assert(@field.convert?('test'))
-      refute(@field.convert?('test'.b))
+      refute(@field.convert('test'.b, self))
 
       str = @field.convert("test", self)
       assert_equal('test', str)
@@ -119,9 +124,7 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "allows conversion to a Time object from a binary string" do
-      date = "D:199812231952-08'00".b
-      refute(@field.convert?('test'.b))
-      assert(@field.convert?(date))
+      refute(@field.convert('test'.b, self))
 
       [
         ["D:1998", [1998, 01, 01, 00, 00, 00, "-00:00"]],
@@ -155,8 +158,6 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "allows conversion from a string" do
-      assert(@field.convert?("test"))
-
       @doc = Minitest::Mock.new
       @doc.expect(:wrap, :data, [{F: 'test'}, {type: HexaPDF::Type::FileSpecification}])
       @field.convert('test', @doc)
@@ -164,8 +165,6 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "allows conversion from a hash/dictionary" do
-      assert(@field.convert?({}))
-
       @doc = Minitest::Mock.new
       @doc.expect(:wrap, :data, [{F: 'test'}, {type: HexaPDF::Type::FileSpecification}])
       @field.convert({F: 'test'}, @doc)
@@ -183,9 +182,6 @@ describe HexaPDF::DictionaryFields do
     end
 
     it "allows conversion to a Rectangle from an Array" do
-      assert(@field.convert?([5, 6]))
-      refute(@field.convert?(:name))
-
       doc = Minitest::Mock.new
       doc.expect(:wrap, :data, [[0, 1, 2, 3], type: HexaPDF::Rectangle])
       @field.convert([0, 1, 2, 3], doc)

data/test/hexapdf/test_document.rb

@@ -436,17 +436,17 @@ describe HexaPDF::Document do
     end
 
     it "validates indirect objects" do
-      @doc.add(Type: :Catalog)
+      obj = @doc.add(Type: :Catalog)
       refute(@doc.validate(auto_correct: false))
 
       called = false
-      assert(@doc.validate { called = true })
+      assert(@doc.validate {|o| assert_same(obj, o); called = true })
       assert(called)
     end
 
     it "validates the trailer object" do
       @doc.trailer[:ID] = :Symbol
-      refute(@doc.validate)
+      refute(@doc.validate {|obj| assert_same(@doc.trailer, obj) })
     end
   end
 

data/test/hexapdf/test_reference.rb

@@ -19,6 +19,7 @@ describe HexaPDF::Reference do
     obj = Object.new
     obj.define_singleton_method(:oid) { 1 }
     obj.define_singleton_method(:gen) { 0 }
+    obj.define_singleton_method(:<=>) {|o| HexaPDF::Reference.new(oid, gen) <=> o }
     assert_equal([obj, HexaPDF::Reference.new(1, 1), HexaPDF::Reference.new(5, 7)],
                  [HexaPDF::Reference.new(5, 7), HexaPDF::Reference.new(1, 1), obj].sort)
     assert_nil(HexaPDF::Reference.new(1, 0) <=> 5)

data/test/hexapdf/test_writer.rb

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

data/test/hexapdf/type/test_font_true_type.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/font_true_type'
+
+describe HexaPDF::Type::FontTrueType do
+  before do
+    @doc = HexaPDF::Document.new
+    font_descriptor = @doc.add(Type: :FontDescriptor, FontName: :Something, Flags: 0b100,
+                               FontBBox: [0, 1, 2, 3], ItalicAngle: 0, Ascent: 900,
+                               Descent: -100, CapHeight: 800, StemV: 20)
+    @font = @doc.add(Type: :Font, Subtype: :TrueType, Encoding: :WinAnsiEncoding,
+                     FirstChar: 32, LastChar: 34, Widths: [600, 0, 700],
+                     BaseFont: :Something, FontDescriptor: font_descriptor)
+  end
+
+  describe "validation" do
+    it "requires that the FontDescriptor key is set" do
+      assert(@font.validate)
+      @font.delete(:FontDescriptor)
+      refute(@font.validate)
+    end
+  end
+end

data/test/hexapdf/type/test_font_type1.rb

@@ -124,5 +124,11 @@ describe HexaPDF::Type::FontType1 do
     it "allows empty fields for standard fonts" do
       assert(@font.validate)
     end
+
+    it "requires that the FontDescriptor key is set for non-standard fonts" do
+      assert(@embedded_font.validate)
+      @embedded_font.delete(:FontDescriptor)
+      refute(@embedded_font.validate)
+    end
   end
 end

data/test/hexapdf/type/test_font_type3.rb

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/type/font_type3'
+
+describe HexaPDF::Type::FontType3 do
+  before do
+    @doc = HexaPDF::Document.new
+    @font = @doc.add(Type: :Font, Subtype: :Type3, Encoding: :WinAnsiEncoding,
+                     FirstChar: 32, LastChar: 34, Widths: [600, 0, 700],
+                     FontBBox: [0, 0, 100, 100], FontMatrix: [1, 0, 0, 1, 0, 0],
+                     CharProcs: {})
+  end
+
+  describe "validation" do
+    it "works for valid objects" do
+      assert(@font.validate)
+    end
+
+    it "fails if the Encoding key is missing" do
+      @font.delete(:Encoding)
+      refute(@font.validate)
+    end
+  end
+end

data/test/hexapdf/type/test_image.rb

@@ -11,6 +11,16 @@ describe HexaPDF::Type::Image do
     @doc = HexaPDF::Document.new
   end
 
+  it "returns the width of the image" do
+    @image = @doc.wrap(Subtype: :Image, Width: 10)
+    assert_equal(10, @image.width)
+  end
+
+  it "returns the height of the image" do
+    @image = @doc.wrap(Subtype: :Image, Height: 10)
+    assert_equal(10, @image.height)
+  end
+
   describe "info" do
     before do
       @image = @doc.wrap(Subtype: :Image, Width: 10, Height: 5, ColorSpace: :DeviceRGB,

data/test/hexapdf/type/test_page.rb

@@ -118,6 +118,120 @@ describe HexaPDF::Type::Page do
     it "fails if an unknown box type is supplied" do
       assert_raises(ArgumentError) { @page.box(:undefined) }
     end
+
+    it "sets the correct box" do
+      @page.box(:media, :media)
+      assert_equal(:media, @page.box(:media))
+      @page.box(:crop, :crop)
+      assert_equal(:crop, @page.box(:crop))
+      @page.box(:bleed, :bleed)
+      assert_equal(:bleed, @page.box(:bleed))
+      @page.box(:trim, :trim)
+      assert_equal(:trim, @page.box(:trim))
+      @page.box(:art, :art)
+      assert_equal(:art, @page.box(:art))
+    end
+
+    it "fails if an unknown box type is supplied when setting a box" do
+      assert_raises(ArgumentError) { @page.box(:undefined, [1, 2, 3, 4]) }
+    end
+  end
+
+  describe "orientation" do
+    before do
+      @page = @doc.pages.add
+    end
+
+    it "returns :portrait for appropriate media boxes and rotation values" do
+      @page.box(:media, [0, 0, 100, 300])
+      assert_equal(:portrait, @page.orientation)
+      @page[:Rotate] = 0
+      assert_equal(:portrait, @page.orientation)
+      @page[:Rotate] = 180
+      assert_equal(:portrait, @page.orientation)
+
+      @page.box(:media, [0, 0, 300, 100])
+      @page[:Rotate] = 90
+      assert_equal(:portrait, @page.orientation)
+      @page[:Rotate] = 270
+      assert_equal(:portrait, @page.orientation)
+    end
+
+    it "returns :landscape for appropriate media boxes and rotation values" do
+      @page.box(:media, [0, 0, 300, 100])
+      assert_equal(:landscape, @page.orientation)
+      @page[:Rotate] = 0
+      assert_equal(:landscape, @page.orientation)
+      @page[:Rotate] = 180
+      assert_equal(:landscape, @page.orientation)
+
+      @page.box(:media, [0, 0, 100, 300])
+      @page[:Rotate] = 90
+      assert_equal(:landscape, @page.orientation)
+      @page[:Rotate] = 270
+      assert_equal(:landscape, @page.orientation)
+    end
+  end
+
+  describe "rotate" do
+    before do
+      @page = @doc.pages.add
+      reset_media_box
+    end
+
+    def reset_media_box
+      @page.box(:media, [50, 100, 200, 300])
+    end
+
+    it "works directly on the :Rotate key" do
+      @page.rotate(90)
+      assert_equal(270, @page[:Rotate])
+
+      @page.rotate(180)
+      assert_equal(90, @page[:Rotate])
+
+      @page.rotate(-90)
+      assert_equal(180, @page[:Rotate])
+    end
+
+    describe "flatten" do
+      it "adjust all page boxes" do
+        @page.box(:crop, @page.box)
+        @page.box(:bleed, @page.box)
+        @page.box(:trim, @page.box)
+        @page.box(:art, @page.box)
+
+        @page.rotate(90, flatten: true)
+        box = [-300, 50, -100, 200]
+        assert_equal(box, @page.box(:media).value)
+        assert_equal(box, @page.box(:crop).value)
+        assert_equal(box, @page.box(:bleed).value)
+        assert_equal(box, @page.box(:trim).value)
+        assert_equal(box, @page.box(:art).value)
+      end
+
+      it "works correctly for 90 degrees" do
+        @page.rotate(90, flatten: true)
+        assert_equal([-300, 50, -100, 200], @page.box(:media).value)
+        assert_equal(" q 0 1 -1 0 0 0 cm   Q ", @page.contents)
+      end
+
+      it "works correctly for 180 degrees" do
+        @page.rotate(180, flatten: true)
+        assert_equal([-200, -300, -50, -100], @page.box(:media).value)
+        assert_equal(" q -1 0 0 -1 0 0 cm   Q ", @page.contents)
+      end
+
+      it "works correctly for 270 degrees" do
+        @page.rotate(270, flatten: true)
+        assert_equal([100, -200, 300, -50], @page.box(:media).value)
+        assert_equal(" q 0 -1 1 0 0 0 cm   Q ", @page.contents)
+      end
+    end
+
+    it "fails if the angle is not a multiple of 90" do
+      assert_raises(ArgumentError) { @page.rotate(27) }
+    end
   end
 
   describe "contents" do