hexapdf 0.6.0 → 0.7.0

data/lib/hexapdf/utils/pdf_doc_encoding.rb

@@ -1,10 +1,10 @@
-# -*- encoding: utf-8 -*-
+# -*- encoding: utf-8; frozen_string_literal: true -*-
 #
 #--
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2017 Thomas Leitner
+# Copyright (C) 2014-2018 Thomas Leitner
 #
 # HexaPDF is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License version 3 as
@@ -85,7 +85,7 @@ module HexaPDF
 
       # Converts the given string to UTF-8, assuming it contains bytes in PDFDocEncoding.
       def self.convert_to_utf8(str)
-        str.each_byte.with_object('') {|byte, result| result << CHARACTER_MAP[byte]}
+        str.each_byte.with_object(+'') {|byte, result| result << CHARACTER_MAP[byte] }
       end
 
     end

data/lib/hexapdf/utils/sorted_tree_node.rb

@@ -1,10 +1,10 @@
-# -*- encoding: utf-8 -*-
+# -*- encoding: utf-8; frozen_string_literal: true -*-
 #
 #--
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2017 Thomas Leitner
+# Copyright (C) 2014-2018 Thomas Leitner
 #
 # HexaPDF is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License version 3 as
@@ -51,6 +51,8 @@ module HexaPDF
     #
     #   For example, for name trees this would be String.
     #
+    # Note: Like with HexaPDF::Dictionary, the keys are assumed to always be direct objects!
+    #
     # See: HexaPDF::NameTreeNode, HexaPDF::NumberTreeNode
     module SortedTreeNode
 
@@ -130,8 +132,7 @@ module HexaPDF
         index = find_in_leaf_node(stack.last[container_name], key)
         return unless stack.last[container_name][index] == key
 
-        value = stack.last[container_name].delete_at(index)
-        document.delete(value) if value.kind_of?(HexaPDF::Object)
+        stack.last[container_name].delete_at(index) # deletes key
         value = stack.last[container_name].delete_at(index)
 
         stack.last[:Limits] = stack.last[container_name].values_at(0, -2) if stack.last[:Limits]
@@ -139,10 +140,10 @@ module HexaPDF
         stack.reverse_each.inject do |nested_node, node|
           if (!nested_node[container_name] || nested_node[container_name].empty?) &&
               (!nested_node[:Kids] || nested_node[:Kids].empty?)
-            node[:Kids].delete_at(node[:Kids].index {|n| document.deref(n) == nested_node})
+            node[:Kids].delete_at(node[:Kids].index {|n| document.deref(n) == nested_node })
             document.delete(nested_node)
           end
-          if node[:Kids].size > 0 && node[:Limits]
+          if !node[:Kids].empty? && node[:Limits]
             node[:Limits][0] = document.deref(node[:Kids][0])[:Limits][0]
             node[:Limits][1] = document.deref(node[:Kids][-1])[:Limits][1]
           end
@@ -287,12 +288,12 @@ module HexaPDF
           parent.delete(container_name)
           parent[:Kids] = [node1, node2]
         else
-          node1 = document.add(document.wrap({}, type: self.class))
-          node1[container_name] = leaf_node[container_name].slice!(split_point..-1)
-          node1[:Limits] = node1[container_name].values_at(0, -2)
+          node = document.add(document.wrap({}, type: self.class))
+          node[container_name] = leaf_node[container_name].slice!(split_point..-1)
+          node[:Limits] = node[container_name].values_at(0, -2)
           leaf_node[:Limits][1] = leaf_node[container_name][-2]
-          index = 1 + parent[:Kids].index {|o| document.deref(o) == leaf_node}
-          parent[:Kids].insert(index, node1)
+          index = 1 + parent[:Kids].index {|o| document.deref(o) == leaf_node }
+          parent[:Kids].insert(index, node)
         end
       end
 

data/lib/hexapdf/version.rb

@@ -1,10 +1,10 @@
-# -*- encoding: utf-8 -*-
+# -*- encoding: utf-8; frozen_string_literal: true -*-
 #
 #--
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2017 Thomas Leitner
+# Copyright (C) 2014-2018 Thomas Leitner
 #
 # HexaPDF is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License version 3 as
@@ -34,6 +34,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.6.0'.freeze
+  VERSION = '0.7.0'
 
 end

data/lib/hexapdf/writer.rb

@@ -1,10 +1,10 @@
-# -*- encoding: utf-8 -*-
+# -*- encoding: utf-8; frozen_string_literal: true -*-
 #
 #--
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2017 Thomas Leitner
+# Copyright (C) 2014-2018 Thomas Leitner
 #
 # HexaPDF is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License version 3 as
@@ -87,7 +87,7 @@ module HexaPDF
     # cross-reference section or stream if applicable.
     def write_revision(rev, previous_xref_pos = nil)
       xref_stream, object_streams = xref_and_object_streams(rev)
-      obj_to_stm = object_streams.each_with_object({}) {|stm, m| m.update(stm.write_objects(rev))}
+      obj_to_stm = object_streams.each_with_object({}) {|stm, m| m.update(stm.write_objects(rev)) }
 
       xref_section = XRefSection.new
       xref_section.add_free_entry(0, 65535) if previous_xref_pos.nil?
@@ -147,7 +147,7 @@ module HexaPDF
         end
       end
 
-      if object_streams.size > 0 && xref_stream.nil?
+      if !object_streams.empty? && xref_stream.nil?
         raise HexaPDF::Error, "Cannot use object streams when there is no xref stream"
       end
 
@@ -156,9 +156,9 @@ module HexaPDF
 
     # Writes the single indirect object which may be a stream object or another object.
     def write_indirect_object(obj)
-      @io << "#{obj.oid} #{obj.gen} obj\n".freeze
+      @io << "#{obj.oid} #{obj.gen} obj\n"
       @serializer.serialize_to_io(obj, @io)
-      @io << "\nendobj\n".freeze
+      @io << "\nendobj\n"
     end
 
     # Writes the cross-reference section.
@@ -170,9 +170,9 @@ module HexaPDF
         @io << "#{entries.empty? ? 0 : entries.first.oid} #{entries.size}\n"
         entries.each do |entry|
           if entry.in_use?
-            @io << sprintf("%010d %05d n \n".freeze, entry.pos, entry.gen).freeze
+            @io << sprintf("%010d %05d n \n", entry.pos, entry.gen).freeze
           elsif entry.free?
-            @io << "0000000000 65535 f \n".freeze
+            @io << "0000000000 65535 f \n"
           else
             # Should never occur since we create the xref section!
             raise HexaPDF::Error, "Cannot use xref type #{entry.type} in cross-reference section"

data/lib/hexapdf/xref_section.rb

@@ -1,10 +1,10 @@
-# -*- encoding: utf-8 -*-
+# -*- encoding: utf-8; frozen_string_literal: true -*-
 #
 #--
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2014-2017 Thomas Leitner
+# Copyright (C) 2014-2018 Thomas Leitner
 #
 # HexaPDF is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License version 3 as
@@ -123,7 +123,7 @@ module HexaPDF
 
     # Merges the entries from the given cross-reference section into this one.
     def merge!(xref_section)
-      xref_section.each {|oid, gen, data| self[oid, gen] = data}
+      xref_section.each {|oid, gen, data| self[oid, gen] = data }
     end
 
     # :call-seq:

data/test/hexapdf/common_tokenizer_tests.rb

@@ -8,8 +8,7 @@ module CommonTokenizerTests
   it "next_token: returns all available kinds of tokens on next_token" do
     create_tokenizer(<<-EOF.chomp.gsub(/^ {8}/, ''))
         % Regular tokens
-          		
-        true false
+          		true false
         123 +17 -98 0 0059
         34.5 -3.62 +123.6 4. -.002 .002 0.0
 
@@ -66,9 +65,9 @@ module CommonTokenizerTests
       :"The_Key_of_F#_Minor", :AB, :"",
       '[', 5, 6, :Name, ']', '[', 5, 6, :Name, ']',
       '<<', :Name, 5, '>>'
-    ].each {|t| t.force_encoding('BINARY') if t.respond_to?(:force_encoding)}
+    ].each {|t| t.force_encoding('BINARY') if t.respond_to?(:force_encoding) }
 
-    while expected_tokens.length > 0
+    until expected_tokens.empty?
       expected_token = expected_tokens.shift
       token = @tokenizer.next_token
       assert_equal(expected_token, token)
@@ -125,7 +124,7 @@ module CommonTokenizerTests
   it "next_object: works for all PDF object types, including array and dictionary" do
     create_tokenizer(<<-EOF.chomp.gsub(/^ {8}/, ''))
         true false null 123 34.5 (string) <4E6F76> /Name
-        [5 6 /Name] <</Name 5>>
+        [5 6 /Name] <</Name 5/Null null>>
         EOF
     assert_equal(true, @tokenizer.next_object)
     assert_equal(false, @tokenizer.next_object)
@@ -206,8 +205,8 @@ module CommonTokenizerTests
 
   it "next_xref_entry: fails on invalidly formatted entries" do
     create_tokenizer("0000000001 00001 g \n")
-    assert_raises(RuntimeError) { @tokenizer.next_xref_entry { raise }}
+    assert_raises(RuntimeError) { @tokenizer.next_xref_entry { raise } }
     create_tokenizer("0000000001 00001 n\n")
-    assert_raises(RuntimeError) { @tokenizer.next_xref_entry { raise }}
+    assert_raises(RuntimeError) { @tokenizer.next_xref_entry { raise } }
   end
 end

data/test/hexapdf/content/graphic_object/test_endpoint_arc.rb

@@ -19,7 +19,6 @@ describe HexaPDF::Content::GraphicObject::EndpointArc do
     end
   end
 
-
   describe "configure" do
     it "changes the values" do
       arc = HexaPDF::Content::GraphicObject::EndpointArc.new

data/test/hexapdf/content/test_canvas.rb

@@ -83,7 +83,7 @@ describe HexaPDF::Content::Canvas do
     end
 
     it "is serialized correctly when a block is used" do
-      @canvas.save_graphics_state { }
+      @canvas.save_graphics_state {}
       assert_operators(@canvas.contents, [[:save_graphics_state], [:restore_graphics_state]])
     end
 
@@ -714,8 +714,8 @@ describe HexaPDF::Content::Canvas do
     it "draws the, optionally configured, graphic object onto the canvas" do
       obj = Object.new
       obj.define_singleton_method(:options) { @options }
-      obj.define_singleton_method(:configure) {|**kwargs| @options = kwargs; self}
-      obj.define_singleton_method(:draw) {|canvas| canvas.move_to(@options[:x], @options[:y])}
+      obj.define_singleton_method(:configure) {|**kwargs| @options = kwargs; self }
+      obj.define_singleton_method(:draw) {|canvas| canvas.move_to(@options[:x], @options[:y]) }
       @canvas.draw(obj, x: 5, y: 6)
       assert_operators(@canvas.contents, [[:move_to, [5, 6]]])
     end
@@ -961,7 +961,7 @@ describe HexaPDF::Content::Canvas do
     it "invokes the operator implementation" do
       @canvas.text_matrix(1, 2, 3, 4, 5, 6)
       assert_operators(@canvas.contents, [[:begin_text],
-                                          [:set_text_matrix, [1, 2, 3, 4, 5,6]]])
+                                          [:set_text_matrix, [1, 2, 3, 4, 5, 6]]])
     end
 
     it "returns the canvas object" do
@@ -1002,7 +1002,7 @@ describe HexaPDF::Content::Canvas do
     end
 
     it "fails if invoked outside a text object" do
-      assert_raises_in_graphics_object(:none, :path, :clipping_path)  { @canvas.text_cursor }
+      assert_raises_in_graphics_object(:none, :path, :clipping_path) { @canvas.text_cursor }
     end
   end
 
@@ -1015,7 +1015,6 @@ describe HexaPDF::Content::Canvas do
       assert_same(@doc.fonts.add("Times"), @canvas.font)
       @canvas.font("Helvetica", size: 10)
       assert_operators(@canvas.contents, [[:set_font_and_size, [:F1, 10]],
-                                          [:set_leading, [12.0]],
                                           [:set_font_and_size, [:F2, 10]]])
     end
 
@@ -1035,16 +1034,9 @@ describe HexaPDF::Content::Canvas do
       assert_equal(10, @canvas.font_size)
     end
 
-    it "sets the font size and, optionally, the leading" do
+    it "sets the font size" do
       @canvas.font("Times", size: 10)
       assert_equal(10, @canvas.font_size)
-      assert_equal(12, @canvas.leading)
-      @canvas.font_size(10, leading: 20)
-      assert_equal(10, @canvas.font_size)
-      assert_equal(20, @canvas.leading)
-      @canvas.font_size(10, leading: nil)
-      assert_equal(10, @canvas.font_size)
-      assert_equal(20, @canvas.leading)
     end
 
     it "fails if no valid font is already set" do
@@ -1066,41 +1058,45 @@ describe HexaPDF::Content::Canvas do
       @canvas.font_size(10)
       @canvas.show_glyphs(font.decode_utf8("Hal"))
       assert_operators(@canvas.contents, [[:set_font_and_size, [:F1, 20]],
-                                          [:set_leading, [24]],
                                           [:set_horizontal_scaling, [200]],
                                           [:set_character_spacing, [1]],
                                           [:set_word_spacing, [2]],
                                           [:begin_text],
                                           [:show_text_with_positioning, [['', -10, "Ha", -35, "l lo"]]],
                                           [:set_font_and_size, [:F1, 10]],
-                                          [:set_leading, [12]],
-                                          [:show_text_with_positioning, [["Hal"]]],
-                                         ])
+                                          [:show_text_with_positioning, [["Hal"]]]])
     end
 
-    it "fails if no valid font is set" do
-      error = assert_raises(HexaPDF::Error) { @canvas.show_glyphs([]) }
-      assert_match(/if a font is set/, error.message)
+    it "does nothing if there are no glyphs" do
+      @canvas.show_glyphs_only([])
+      assert_operators(@canvas.contents, [])
     end
   end
 
   describe "show_glyphs_only" do
-    it "serializes correctly" do
+    it "serializes positioned glyphs correctly" do
       @canvas.font("Times", size: 20)
       font = @canvas.font
       @canvas.show_glyphs_only(font.decode_utf8("Hal lo").insert(2, -35))
       assert_equal(0, @canvas.text_cursor[0])
       assert_equal(0, @canvas.text_cursor[1])
       assert_operators(@canvas.contents, [[:set_font_and_size, [:F1, 20]],
-                                          [:set_leading, [24]],
                                           [:begin_text],
-                                          [:show_text_with_positioning, [["Ha", -35, "l lo"]]],
-                                         ])
+                                          [:show_text_with_positioning, [["Ha", -35, "l lo"]]]])
     end
 
-    it "fails if no valid font is set" do
-      error = assert_raises(HexaPDF::Error) { @canvas.show_glyphs([]) }
-      assert_match(/if a font is set/, error.message)
+    it "serializes unpositioned glyphs correctly" do
+      @canvas.font("Times", size: 20)
+      font = @canvas.font
+      @canvas.show_glyphs_only(font.decode_utf8("Hallo"))
+      assert_operators(@canvas.contents, [[:set_font_and_size, [:F1, 20]],
+                                          [:begin_text],
+                                          [:show_text, ["Hallo"]]])
+    end
+
+    it "does nothing if there are no glyphs" do
+      @canvas.show_glyphs_only([])
+      assert_operators(@canvas.contents, [])
     end
   end
 
@@ -1109,18 +1105,15 @@ describe HexaPDF::Content::Canvas do
       @canvas.font("Times", size: 10)
       @canvas.text("Hallo", at: [100, 100])
       assert_operators(@canvas.contents, [[:set_font_and_size, [:F1, 10]],
-                                          [:set_leading, [12]],
                                           [:begin_text],
                                           [:set_text_matrix, [1, 0, 0, 1, 100, 100]],
-                                          [:show_text_with_positioning, [["Hallo"]]],
-                                         ])
+                                          [:show_text_with_positioning, [["Hallo"]]]])
     end
 
     it "shows text, possibly split over multiple lines" do
       @canvas.font("Times", size: 10)
       @canvas.text("H\u{D A}H\u{A}H\u{B}H\u{c}H\u{D}H\u{85}H\u{2028}H\u{2029}H")
       assert_operators(@canvas.contents, [[:set_font_and_size, [:F1, 10]],
-                                          [:set_leading, [12]],
                                           [:begin_text],
                                           [:show_text_with_positioning, [["H"]]], [:move_text_next_line],
                                           [:show_text_with_positioning, [["H"]]], [:move_text_next_line],
@@ -1130,12 +1123,11 @@ describe HexaPDF::Content::Canvas do
                                           [:show_text_with_positioning, [["H"]]], [:move_text_next_line],
                                           [:show_text_with_positioning, [["H"]]], [:move_text_next_line],
                                           [:show_text_with_positioning, [["H"]]], [:move_text_next_line],
-                                          [:show_text_with_positioning, [["H"]]],
-                                         ])
+                                          [:show_text_with_positioning, [["H"]]]])
     end
 
     it "fails if no valid font is set" do
-      error = assert_raises(HexaPDF::Error) { @canvas.show_glyphs([]) }
+      error = assert_raises(HexaPDF::Error) { @canvas.text("test") }
       assert_match(/if a font is set/, error.message)
     end
   end
@@ -1172,7 +1164,7 @@ describe HexaPDF::Content::Canvas do
     end
 
     it "is serialized correctly when a block is used" do
-      @canvas.marked_content_sequence(:tag, property_list: {key: 5}) { }
+      @canvas.marked_content_sequence(:tag, property_list: {key: 5}) {}
       assert_operators(@canvas.contents, [[:begin_marked_content_with_property_list, [:tag, :P1]],
                                           [:end_marked_content]])
     end

data/test/hexapdf/content/test_color_space.rb

@@ -10,6 +10,10 @@ module CommonColorSpaceTests
     assert_equal(@color_space, @color.color_space)
   end
 
+  it "the color space class accepts the color space definition as argument to ::new" do
+    assert_equal(1, @color_space.class.method(:new).arity.abs)
+  end
+
   it "the color space responds to :default_color" do
     assert(@color_space.respond_to?(:default_color))
     assert_equal(0, @color_space.method(:default_color).arity)

data/test/hexapdf/content/test_graphics_state.rb

@@ -5,6 +5,7 @@ require 'hexapdf/content/graphics_state'
 
 # Dummy class used as wrapper so that constant lookup works correctly
 class GraphicsStateWrapper < Minitest::Spec
+
   include HexaPDF::Content
 
   describe NamedValue do
@@ -146,4 +147,5 @@ class GraphicsStateWrapper < Minitest::Spec
       assert_raises(HexaPDF::Error) { @gs.restore }
     end
   end
+
 end

data/test/hexapdf/content/test_operator.rb

@@ -41,7 +41,6 @@ describe HexaPDF::Content::Operator::SingleNumericArgumentOperator do
   end
 end
 
-
 module CommonOperatorTests
   extend Minitest::Spec::DSL
 
@@ -98,7 +97,6 @@ def describe_operator(name, symbol, &block)
   klass
 end
 
-
 describe_operator :SaveGraphicsState, :q do
   it "saves the graphics state" do
     width = @processor.graphics_state.line_width
@@ -196,7 +194,7 @@ describe_operator :SetGraphicsStateParameters, :gs do
                                                RI: 2, SA: true, BM: :Multiply, CA: 0.5, ca: 0.5,
                                                AIS: true, TK: false, Font: [:Test, 10]}}
     @processor.resources.define_singleton_method(:document) do
-      Object.new.tap {|obj| obj.define_singleton_method(:deref) {|o| o}}
+      Object.new.tap {|obj| obj.define_singleton_method(:deref) {|o| o } }
     end
 
     invoke(:Name)
@@ -561,7 +559,7 @@ end
 
 describe_operator :ShowText, :Tj do
   it "serializes correctly" do
-    assert_serialized("Some Text")
+    assert_equal("(Some Text)Tj\n", call(:serialize, @serializer, "Some Text"))
   end
 end
 
@@ -582,7 +580,7 @@ describe_operator :MoveTextNextLineAndShowText, :"'" do
   end
 
   it "serializes correctly" do
-    assert_serialized("Some Text")
+    assert_equal("(Some Text)'\n", call(:serialize, @serializer, "Some Text"))
   end
 end
 
@@ -609,12 +607,13 @@ describe_operator :SetSpacingMoveTextNextLineAndShowText, :'"' do
   end
 
   it "serializes correctly" do
-    assert_serialized(10, 15, "Some Text")
+    assert_equal("10 15 (Some Text)\"\n", call(:serialize, @serializer, 10, 15, "Some Text"))
   end
 end
 
 describe_operator :ShowTextWithPositioning, :TJ do
   it "serializes correctly" do
-    assert_serialized(["Some Text", 15, "other text", 20, "final text"])
+    assert_equal("[(Some Text)15(other text)20(final text)]TJ\n",
+                 call(:serialize, @serializer, ["Some Text", 15, "other text", 20, "final text"]))
   end
 end