hexapdf 0.10.0 → 0.11.0

data/test/hexapdf/content/test_canvas.rb

@@ -777,9 +777,9 @@ describe HexaPDF::Content::Canvas do
 
   describe "xobject" do
     before do
-      @image = @doc.add(Type: :XObject, Subtype: :Image, Width: 10, Height: 5)
+      @image = @doc.add({Type: :XObject, Subtype: :Image, Width: 10, Height: 5})
       @image.source_path = File.join(TEST_DATA_DIR, 'images', 'gray.jpg')
-      @form = @doc.add(Type: :XObject, Subtype: :Form, BBox: [100, 50, 200, 100])
+      @form = @doc.add({Type: :XObject, Subtype: :Form, BBox: [100, 50, 200, 100]})
     end
 
     it "can use any xobject specified via a filename" do

data/test/hexapdf/content/test_processor.rb

@@ -117,9 +117,9 @@ describe HexaPDF::Content::Processor do
     before do
       @doc = HexaPDF::Document.new
       @processor.process(:BT)
-      @processor.graphics_state.font = @font = @doc.add(Type: :Font, Subtype: :Type1,
-                                                        Encoding: :WinAnsiEncoding,
-                                                        BaseFont: :"Times-Roman")
+      @processor.graphics_state.font = @font = @doc.add({Type: :Font, Subtype: :Type1,
+                                                         Encoding: :WinAnsiEncoding,
+                                                         BaseFont: :"Times-Roman"})
       @processor.graphics_state.font_size = 10
       @processor.graphics_state.text_rise = 10
       @processor.graphics_state.character_spacing = 1

data/test/hexapdf/document/test_files.rb

@@ -50,9 +50,9 @@ describe HexaPDF::Document::Files do
 
   describe "each" do
     it "iterates only over named embedded files and file annotations if search=false" do
-      @doc.add(Type: :Filespec)
+      @doc.add({Type: :Filespec})
       spec1 = @doc.files.add(__FILE__)
-      spec2 = @doc.add(Type: :Filespec)
+      spec2 = @doc.add({Type: :Filespec})
       @doc.pages.add # page without annot
       @doc.pages.add[:Annots] = [
         {Subtype: :FileAttachment, FS: HexaPDF::Reference.new(spec1.oid, spec1.gen)},
@@ -64,8 +64,8 @@ describe HexaPDF::Document::Files do
 
     it "iterates over all file specifications of the document if search=true" do
       specs = []
-      specs << @doc.add(Type: :Filespec)
-      specs << @doc.add(Type: :Filespec)
+      specs << @doc.add({Type: :Filespec})
+      specs << @doc.add({Type: :Filespec})
       assert_equal(specs, @doc.files.each(search: true).to_a)
     end
   end

data/test/hexapdf/document/test_fonts.rb

@@ -37,7 +37,9 @@ describe HexaPDF::Document::Fonts do
     end
 
     it "fails if the requested font is not found"  do
-      assert_raises(HexaPDF::Error) { @doc.fonts.add("Unknown") }
+      @doc.config['font_loader'] << 'HexaPDF::FontLoader::Standard14'
+      error = assert_raises(HexaPDF::Error) { @doc.fonts.add("Unknown") }
+      assert_match(/Times \(none/, error.message)
     end
 
     it "raises an error if a font loader cannot be correctly retrieved" do
@@ -45,4 +47,14 @@ describe HexaPDF::Document::Fonts do
       assert_raises(HexaPDF::Error) { @doc.fonts.add(:Other) }
     end
   end
+
+  it "returns the configured fonts" do
+    @doc.config['font_loader'] << 'HexaPDF::FontLoader::Standard14'
+    @doc.config['font_loader'] << 'HexaPDF::FontLoader::FromConfiguration'
+    @doc.config['font.map'] = {'Times' => {heavy: 'none', none: 'none'}, 'Other' => {none: 'none'}}
+    fonts = @doc.fonts.configured_fonts
+    assert_equal([:none], fonts['Symbol'])
+    assert_equal([:none, :bold, :italic, :bold_italic, :heavy], fonts['Times'])
+    assert_equal([:none], fonts['Other'])
+  end
 end

data/test/hexapdf/document/test_images.rb

@@ -60,12 +60,12 @@ describe HexaPDF::Document::Images do
     it "iterates over all non-mask images" do
       @doc.add(5)
       images = []
-      images << @doc.add(Type: :XObject, Subtype: :Image)
-      images << @doc.add(Type: :XObject, Subtype: :Image, Mask: [5, 6])
-      images << @doc.add(Type: :XObject, Subtype: :Image,
-                         Mask: @doc.add(Type: :XObject, Subtype: :Image))
-      images << @doc.add(Type: :XObject, Subtype: :Image,
-                         SMask: @doc.add(Type: :XObject, Subtype: :Image))
+      images << @doc.add({Type: :XObject, Subtype: :Image})
+      images << @doc.add({Type: :XObject, Subtype: :Image, Mask: [5, 6]})
+      images << @doc.add({Type: :XObject, Subtype: :Image,
+                          Mask: @doc.add({Type: :XObject, Subtype: :Image})})
+      images << @doc.add({Type: :XObject, Subtype: :Image,
+                          SMask: @doc.add({Type: :XObject, Subtype: :Image})})
       assert_equal(images.sort, @doc.images.to_a.sort)
     end
   end

data/test/hexapdf/document/test_pages.rb

@@ -17,7 +17,7 @@ describe HexaPDF::Document::Pages do
   describe "add" do
     it "adds a new empty page when no page is given" do
       page = @doc.pages.add
-      assert_equal([page], @doc.pages.root[:Kids])
+      assert_equal([page], @doc.pages.root[:Kids].value)
     end
 
     it "adds a new empty page with the given dimensions" do
@@ -34,9 +34,9 @@ describe HexaPDF::Document::Pages do
 
     it "adds the given page to the end" do
       page = @doc.pages.add
-      new_page = @doc.add(Type: :Page)
+      new_page = @doc.add({Type: :Page})
       assert_same(new_page, @doc.pages.add(new_page))
-      assert_equal([page, new_page], @doc.pages.root[:Kids])
+      assert_equal([page, new_page], @doc.pages.root[:Kids].value)
     end
 
     it "fails if an unknown page format is given" do
@@ -46,10 +46,10 @@ describe HexaPDF::Document::Pages do
 
   describe "<<" do
     it "works like add but always needs a page returns self" do
-      page1 = @doc.add(Type: :Page)
-      page2 = @doc.add(Type: :Page)
+      page1 = @doc.add({Type: :Page})
+      page2 = @doc.add({Type: :Page})
       @doc.pages << page1 << page2
-      assert_equal([page1, page2], @doc.pages.root[:Kids])
+      assert_equal([page1, page2], @doc.pages.root[:Kids].value)
     end
   end
 
@@ -66,7 +66,7 @@ describe HexaPDF::Document::Pages do
     end
 
     it "insert a given page at a given index" do
-      new_page = @doc.add(Type: :Page)
+      new_page = @doc.add({Type: :Page})
       assert_same(new_page, @doc.pages.insert(2, new_page))
       assert_equal(new_page, @doc.pages.root[:Kids][2])
     end
@@ -88,7 +88,7 @@ describe HexaPDF::Document::Pages do
       page2 = @doc.pages.add
       page3 = @doc.pages.add
       assert_same(page2, @doc.pages.delete_at(1))
-      assert_equal([page1, page3], @doc.pages.root[:Kids])
+      assert_equal([page1, page3], @doc.pages.root[:Kids].value)
     end
   end
 

data/test/hexapdf/encryption/test_security_handler.rb

@@ -201,14 +201,14 @@ describe HexaPDF::Encryption::SecurityHandler do
 
   describe "set_up_decryption" do
     it "wraps the given hash in an encryption dictionary class, uses it for its dict, returns it" do
-      dict = @handler.set_up_decryption(Filter: :test, V: 1)
+      dict = @handler.set_up_decryption({Filter: :test, V: 1})
       assert_equal(dict, @handler.dict)
       assert_kind_of(HexaPDF::Encryption::EncryptionDictionary, @handler.dict)
       assert_equal({Filter: :test, V: 1}, @handler.dict.value)
     end
 
     it "doesn't modify the trailer's /Encrypt dictionary" do
-      @handler.set_up_decryption(Filter: :test, V: 4, Length: 128)
+      @handler.set_up_decryption({Filter: :test, V: 4, Length: 128})
       assert_nil(@document.trailer[:Encrypt])
     end
 
@@ -238,8 +238,8 @@ describe HexaPDF::Encryption::SecurityHandler do
     end
 
     it "selects the correct algorithm for string, stream and embedded file decryption" do
-      @handler.set_up_decryption(V: 4, StrF: :Mine, StmF: :Mine, EFF: :Mine,
-                                 CF: {Mine: {CFM: :V2}})
+      @handler.set_up_decryption({V: 4, StrF: :Mine, StmF: :Mine, EFF: :Mine,
+                                  CF: {Mine: {CFM: :V2}}})
       assert_equal(HexaPDF::Encryption::FastARC4, @handler.send(:embedded_file_algorithm))
       assert_equal(HexaPDF::Encryption::FastARC4, @handler.send(:string_algorithm))
       assert_equal(HexaPDF::Encryption::FastARC4, @handler.send(:stream_algorithm))
@@ -254,14 +254,14 @@ describe HexaPDF::Encryption::SecurityHandler do
 
     it "fails for unsupported /V values in the dict" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
-        @handler.set_up_decryption(V: 3)
+        @handler.set_up_decryption({V: 3})
       end
       assert_match(/Unsupported encryption version/i, exp.message)
     end
 
     it "fails for unsupported crypt filter encryption methods" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
-        @handler.set_up_decryption(V: 4, StrF: :Mine, CF: {Mine: {CFM: :Unknown}})
+        @handler.set_up_decryption({V: 4, StrF: :Mine, CF: {Mine: {CFM: :Unknown}}})
       end
       assert_match(/Unsupported encryption method/i, exp.message)
     end
@@ -269,7 +269,7 @@ describe HexaPDF::Encryption::SecurityHandler do
 
   describe "decrypt" do
     before do
-      @handler.set_up_decryption(V: 1)
+      @handler.set_up_decryption({V: 1})
       @encrypted = @handler.encrypt_string('string', @obj)
       @obj.value = {Key: @encrypted.dup, Array: [@encrypted.dup], Hash: {Another: @encrypted.dup}}
     end

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -217,29 +217,29 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
   describe "prepare_decryption" do
     it "fails if the /Filter value is incorrect" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
-        @handler.set_up_decryption(Filter: :NonStandard, V: 2)
+        @handler.set_up_decryption({Filter: :NonStandard, V: 2})
       end
       assert_match(/Invalid \/Filter/i, exp.message)
     end
 
     it "fails if the /R value is incorrect" do
       exp = assert_raises(HexaPDF::UnsupportedEncryptionError) do
-        @handler.set_up_decryption(Filter: :Standard, V: 2, R: 5)
+        @handler.set_up_decryption({Filter: :Standard, V: 2, R: 5})
       end
       assert_match(/Invalid \/R/i, exp.message)
     end
 
     it "fails if the ID in the document's trailer is missing although it is needed" do
       exp = assert_raises(HexaPDF::EncryptionError) do
-        @handler.set_up_decryption(Filter: :Standard, V: 2, R: 2)
+        @handler.set_up_decryption({Filter: :Standard, V: 2, R: 2})
       end
       assert_match(/Document ID/i, exp.message)
     end
 
     it "fails if the supplied password is invalid" do
       exp = assert_raises(HexaPDF::EncryptionError) do
-        @handler.set_up_decryption(Filter: :Standard, V: 2, R: 6, U: 'a' * 48, O: 'a' * 48,
-                                     UE: 'a' * 32, OE: 'a' * 32)
+        @handler.set_up_decryption({Filter: :Standard, V: 2, R: 6, U: 'a' * 48, O: 'a' * 48,
+                                    UE: 'a' * 32, OE: 'a' * 32})
       end
       assert_match(/Invalid password/i, exp.message)
     end

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -114,7 +114,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
                    cidfont[:CIDSystemInfo].value)
       assert_equal(:Identity, cidfont[:CIDToGIDMap])
       assert_equal(@font_wrapper.glyph(3).width, cidfont[:DW])
-      assert_equal([2, [glyph.width]], cidfont[:W])
+      assert_equal([2, [glyph.width]], cidfont[:W].value)
       assert(cidfont.validate)
 
       # Checking font descriptor
@@ -155,7 +155,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
 
       assert_equal(HexaPDF::Font::CMap.create_to_unicode_cmap([[3, ' '.ord], [glyph.id, 'H'.ord]]),
                    dict[:ToUnicode].stream)
-      assert_equal([glyph.id, [glyph.width]], dict[:DescendantFonts][0][:W])
+      assert_equal([glyph.id, [glyph.width]], dict[:DescendantFonts][0][:W].value)
     end
   end
 

data/test/hexapdf/font_loader/test_from_configuration.rb

@@ -32,4 +32,8 @@ describe HexaPDF::FontLoader::FromConfiguration do
   it "returns nil for unknown fonts" do
     assert_nil(@klass.call(@doc, "Unknown"))
   end
+
+  it "returns a hash with all configured fonts" do
+    assert_equal({'font' => [:none]}, @klass.available_fonts(@doc))
+  end
 end

data/test/hexapdf/font_loader/test_standard14.rb

@@ -20,4 +20,14 @@ describe HexaPDF::FontLoader::Standard14 do
   it "returns nil for unknown fonts" do
     assert_nil(@obj.call(@doc, "Unknown"))
   end
+
+  it "returns a hash with all standard PDF fonts" do
+    assert_equal({
+                   'Times' => [:none, :bold, :italic, :bold_italic],
+                   'Helvetica' => [:none, :bold, :italic, :bold_italic],
+                   'Courier' => [:none, :bold, :italic, :bold_italic],
+                   'Symbol' => [:none], 'ZapfDingbats' => [:none]
+                 },
+                 @obj.available_fonts(@doc))
+  end
 end

data/test/hexapdf/image_loader/test_jpeg.rb

@@ -62,7 +62,7 @@ describe HexaPDF::ImageLoader::JPEG do
       assert_equal(5, image[:Width])
       assert_equal(5, image[:Height])
       assert_equal(:DeviceCMYK, image[:ColorSpace])
-      assert_equal([1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0], image[:Decode])
+      assert_equal([1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0], image[:Decode].value)
       assert_equal(File.binread(jpeg), image.stream)
     end
 

data/test/hexapdf/image_loader/test_png.rb

@@ -29,7 +29,7 @@ describe HexaPDF::ImageLoader::PNG do
     assert_equal(width, image[:Width])
     assert_equal(height, image[:Height])
     assert_equal(bpc, image[:BitsPerComponent])
-    assert_equal(color_space, image[:ColorSpace]) if color_space
+    assert_equal(color_space, @doc.unwrap(image[:ColorSpace])) if color_space
     data = stream.map {|row| [row.map {|i| i.to_s(2).rjust(bpc, '0') }.join("")].pack('B*') }.join("")
     assert_equal(data, image.stream)
   end
@@ -111,7 +111,7 @@ describe HexaPDF::ImageLoader::PNG do
               [253, 202, 151, 100, 50],
               [253, 202, 151, 100, 49]]
       assert_image(image, 5, 5, 8, :DeviceGray, data)
-      assert_equal([203, 203], image[:Mask])
+      assert_equal([203, 203], image[:Mask].value)
     end
 
     it "works for a greyscale png with a gamma value of 1" do
@@ -123,7 +123,7 @@ describe HexaPDF::ImageLoader::PNG do
     it "works for a greyscale png with a gamma value of 1/1.5" do
       png = @images.grep(/greyscale-with-gamma1\.5\.png/).first
       image = @loader.load(@doc, png)
-      assert_equal([:CalGray, {WhitePoint: [1.0, 1.0, 1.0], Gamma: 1 / 1.5}], image[:ColorSpace])
+      assert_equal([:CalGray, {WhitePoint: [1.0, 1.0, 1.0], Gamma: 1 / 1.5}], image[:ColorSpace].value)
     end
 
     it "works for an indexed 1-bit png" do

data/test/hexapdf/layout/test_box.rb

@@ -6,8 +6,8 @@ require 'hexapdf/document'
 require 'hexapdf/layout/box'
 
 describe HexaPDF::Layout::Box do
-  def create_box(*args, &block)
-    HexaPDF::Layout::Box.new(*args, &block)
+  def create_box(**args, &block)
+    HexaPDF::Layout::Box.new(**args, &block)
   end
 
   describe "::create" do

data/test/hexapdf/layout/test_frame.rb

@@ -50,7 +50,7 @@ describe HexaPDF::Layout::Frame do
     # checked whether the box coordinates are pos and whether the frame has the shape given by
     # points.
     def check_box(box_opts, pos, points)
-      @box = HexaPDF::Layout::Box.create(box_opts) {}
+      @box = HexaPDF::Layout::Box.create(**box_opts) {}
       @canvas.expect(:translate, nil, pos)
       assert(@frame.draw(@canvas, @box))
       assert_equal(points, @frame.shape.polygons.map(&:to_a))

data/test/hexapdf/layout/test_image_box.rb

@@ -13,7 +13,7 @@ describe HexaPDF::Layout::ImageBox do
   end
 
   def create_box(**kwargs)
-    HexaPDF::Layout::ImageBox.new(@image, kwargs)
+    HexaPDF::Layout::ImageBox.new(@image, **kwargs)
   end
 
   describe "initialize" do

data/test/hexapdf/layout/test_style.rb

@@ -136,8 +136,8 @@ describe HexaPDF::Layout::Style::Quad do
 end
 
 describe HexaPDF::Layout::Style::Border do
-  def create_border(*args)
-    HexaPDF::Layout::Style::Border.new(*args)
+  def create_border(**args)
+    HexaPDF::Layout::Style::Border.new(**args)
   end
 
   it "has accessors for with, color and style that return Quads" do
@@ -531,13 +531,13 @@ describe HexaPDF::Layout::Style::LinkLayer do
     end
 
     def call_link(hash)
-      link = HexaPDF::Layout::Style::LinkLayer.new(hash)
+      link = HexaPDF::Layout::Style::LinkLayer.new(**hash)
       link.call(@canvas, @box)
       @canvas.context[:Annots]&.first
     end
 
     it "does nothing if the context is not a page object" do
-      @canvas = HexaPDF::Document.new.add(Type: :XObject, Subtype: :Form).canvas
+      @canvas = HexaPDF::Document.new.add({Type: :XObject, Subtype: :Form}).canvas
       assert_nil(call_link(dest: true))
     end
 
@@ -545,28 +545,28 @@ describe HexaPDF::Layout::Style::LinkLayer do
       annot = call_link(dest: true)
       assert_equal(:Link, annot[:Subtype])
       assert_equal([10, 10, 25, 20], annot[:Rect].value)
-      assert_equal([10, 10, 25, 10, 25, 20, 10, 20], annot[:QuadPoints])
+      assert_equal([10, 10, 25, 10, 25, 20, 10, 20], annot[:QuadPoints].value)
     end
 
     it "removes the border by default" do
       annot = call_link(dest: true)
-      assert_equal([0, 0, 0], annot[:Border])
+      assert_equal([0, 0, 0], annot[:Border].value)
     end
 
     it "uses a default border if no specific border style is specified" do
       annot = call_link(dest: true, border: true)
-      assert_equal([0, 0, 1], annot[:Border])
+      assert_equal([0, 0, 1], annot[:Border].value)
     end
 
     it "uses the specified border and border color" do
       annot = call_link(dest: true, border: [10, 10, 2], border_color: [255])
-      assert_equal([10, 10, 2], annot[:Border])
-      assert_equal([1.0], annot[:C])
+      assert_equal([10, 10, 2], annot[:Border].value)
+      assert_equal([1.0], annot[:C].value)
     end
 
     it "works for simple destinations" do
       annot = call_link(dest: [@canvas.context, :FitH])
-      assert_equal([@canvas.context, :FitH], annot[:Dest])
+      assert_equal([@canvas.context, :FitH], annot[:Dest].value)
       assert_nil(annot[:A])
     end
 
@@ -641,14 +641,14 @@ describe HexaPDF::Layout::Style do
     assert_equal(100, @style.horizontal_scaling)
     assert_equal(0, @style.text_rise)
     assert_equal({}, @style.font_features)
-    assert_equal(:fill, @style.text_rendering_mode)
+    assert_equal(HexaPDF::Content::TextRenderingMode::FILL, @style.text_rendering_mode)
     assert_equal([0], @style.fill_color.components)
     assert_equal(1, @style.fill_alpha)
     assert_equal([0], @style.stroke_color.components)
     assert_equal(1, @style.stroke_alpha)
     assert_equal(1, @style.stroke_width)
-    assert_equal(:butt, @style.stroke_cap_style)
-    assert_equal(:miter, @style.stroke_join_style)
+    assert_equal(HexaPDF::Content::LineCapStyle::BUTT_CAP, @style.stroke_cap_style)
+    assert_equal(HexaPDF::Content::LineJoinStyle::MITER_JOIN, @style.stroke_join_style)
     assert_equal(10.0, @style.stroke_miter_limit)
     assert_equal(:left, @style.align)
     assert_equal(:top, @style.valign)
@@ -677,6 +677,11 @@ describe HexaPDF::Layout::Style do
     assert_equal([[5], 2], @style.stroke_dash_pattern.to_operands)
   end
 
+  it "allows checking for valid values" do
+    error = assert_raises(ArgumentError) { @style.align = :none }
+    assert_match(/not a valid align value \(:left, :center, :right, :justify\)/, error.message)
+  end
+
   it "allows checking whether a property has been set or accessed" do
     refute(@style.align?)
     assert_equal(:left, @style.align)

data/test/hexapdf/layout/test_text_box.rb

@@ -12,7 +12,7 @@ describe HexaPDF::Layout::TextBox do
   end
 
   def create_box(items, **kwargs)
-    HexaPDF::Layout::TextBox.new(items, kwargs)
+    HexaPDF::Layout::TextBox.new(items, **kwargs)
   end
 
   describe "initialize" do