hexapdf 0.7.0 → 0.8.0

data/lib/hexapdf/type/font_type3.rb

@@ -0,0 +1,61 @@
+# -*- 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-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
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#++
+
+require 'hexapdf/type/font_simple'
+
+module HexaPDF
+  module Type
+
+    # Represents a Type 3 font.
+    #
+    # See: PDF1.7 s9.6.5
+    class FontType3 < FontSimple
+
+      define_field :Subtype,    type: Symbol, required: true, default: :Type3
+      define_field :Name,       type: Symbol
+      define_field :FontBBox,   type: Rectangle, required: true
+      define_field :FontMatrix, type: Array, required: true
+      define_field :CharProcs,  type: Dictionary, required: true
+      define_field :Resources,  type: Dictionary, version: '1.2'
+
+      private
+
+      def perform_validation
+        super
+        yield("Required field Encoding is not set", false) if self[:Encoding].nil?
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/type/graphics_state_parameter.rb

@@ -58,18 +58,18 @@ module HexaPDF
       define_field :op,            type: Boolean, version: "1.3"
       define_field :OPM,           type: Integer, version: "1.3"
       define_field :Font,          type: Array, version: "1.3"
-      define_field :BG,            type: [Dictionary, Hash, Stream]
-      define_field :BG2,           type: [Dictionary, Hash, Stream, Symbol], version: "1.3"
-      define_field :UCR,           type: [Dictionary, Hash, Stream]
-      define_field :UCR2,          type: [Dictionary, Hash, Stream, Symbol], version: "1.3"
-      define_field :TR,            type: [Dictionary, Hash, Stream, Array, Symbol]
-      define_field :TR2,           type: [Dictionary, Hash, Stream, Array, Symbol], version: "1.3"
-      define_field :HT,            type: [Dictionary, Hash, Stream, Symbol]
+      define_field :BG,            type: [Dictionary, Stream]
+      define_field :BG2,           type: [Dictionary, Stream, Symbol], version: "1.3"
+      define_field :UCR,           type: [Dictionary, Stream]
+      define_field :UCR2,          type: [Dictionary, Stream, Symbol], version: "1.3"
+      define_field :TR,            type: [Dictionary, Stream, Array, Symbol]
+      define_field :TR2,           type: [Dictionary, Stream, Array, Symbol], version: "1.3"
+      define_field :HT,            type: [Dictionary, Stream, Symbol]
       define_field :FL,            type: Numeric, version: "1.3"
       define_field :SM,            type: Numeric, version: "1.3"
       define_field :SA,            type: Boolean
       define_field :BM,            type: [Symbol, Array], version: "1.4"
-      define_field :SMask,         type: [Dictionary, Hash, Symbol], version: "1.4"
+      define_field :SMask,         type: [Dictionary, Symbol], version: "1.4"
       define_field :CA,            type: Numeric, version: "1.4"
       define_field :ca,            type: Numeric, version: "1.4"
       define_field :AIS,           type: Boolean, version: "1.4"

data/lib/hexapdf/type/image.rb

@@ -76,6 +76,16 @@ module HexaPDF
       # facility and not when the image is part of a loaded PDF file.
       attr_accessor :source_path
 
+      # Returns the width of the image.
+      def width
+        self[:Width]
+      end
+
+      # Returns the height of the image.
+      def height
+        self[:Height]
+      end
+
       # Returns an Info structure with information about the image.
       #
       # Available accessors:

data/lib/hexapdf/type/page.rb

@@ -36,6 +36,7 @@ require 'hexapdf/dictionary'
 require 'hexapdf/stream'
 require 'hexapdf/type/page_tree_node'
 require 'hexapdf/content'
+require 'hexapdf/content/transformation_matrix'
 
 module HexaPDF
   module Type
@@ -129,7 +130,7 @@ module HexaPDF
       define_field :TrimBox,              type: Rectangle, version: '1.3'
       define_field :ArtBox,               type: Rectangle, version: '1.3'
       define_field :BoxColorInfo,         type: Dictionary, version: '1.4'
-      define_field :Contents,             type: [Array, Stream]
+      define_field :Contents,             type: [Stream, Array]
       define_field :Rotate,               type: Integer, default: 0
       define_field :Group,                type: Dictionary, version: '1.4'
       define_field :Thumb,                type: Stream
@@ -182,7 +183,13 @@ module HexaPDF
         end
       end
 
-      # Returns the rectangle defining a certain kind of box for the page.
+      # :call-seq:
+      #   page.box(type = :media)              -> box
+      #   page.box(type = :media, rectangle)   -> rectangle
+      #
+      # If no +rectangle+ is given, returns the rectangle defining a certain kind of box for the
+      # page. Otherwise sets the value for the given box type to +rectangle+ (an array with four
+      # values or a HexaPDF::Rectangle).
       #
       # This method should be used instead of directly accessing any of /MediaBox, /CropBox,
       # /BleedBox, /ArtBox or /TrimBox because it also takes the fallback values into account!
@@ -209,15 +216,81 @@ module HexaPDF
       #     author. The default is the crop box.
       #
       # See: PDF1.7 s14.11.2
-      def box(type = :media)
-        case type
-        when :media then self[:MediaBox]
-        when :crop then self[:CropBox] || self[:MediaBox]
-        when :bleed then self[:BleedBox] || self[:CropBox] || self[:MediaBox]
-        when :trim then self[:TrimBox] || self[:CropBox] || self[:MediaBox]
-        when :art then self[:ArtBox] || self[:CropBox] || self[:MediaBox]
+      def box(type = :media, rectangle = nil)
+        if rectangle
+          case type
+          when :media, :crop, :bleed, :trim, :art
+            self["#{type.capitalize}Box".to_sym] = rectangle
+          else
+            raise ArgumentError, "Unsupported page box type provided: #{type}"
+          end
+        else
+          case type
+          when :media then self[:MediaBox]
+          when :crop then self[:CropBox] || self[:MediaBox]
+          when :bleed then self[:BleedBox] || self[:CropBox] || self[:MediaBox]
+          when :trim then self[:TrimBox] || self[:CropBox] || self[:MediaBox]
+          when :art then self[:ArtBox] || self[:CropBox] || self[:MediaBox]
+          else
+            raise ArgumentError, "Unsupported page box type provided: #{type}"
+          end
+        end
+      end
+
+      # Returns the orientation of the media box, either :portrait or :landscape.
+      def orientation
+        box = self[:MediaBox]
+        rotation = self[:Rotate]
+        if (box.height > box.width && (rotation == 0 || rotation == 180)) ||
+            (box.height < box.width && (rotation == 90 || rotation == 270))
+          :portrait
+        else
+          :landscape
+        end
+      end
+
+      # Rotates the page +angle+ degrees counterclockwise where +angle+ has to be a multiple of 90.
+      #
+      # Positive values rotate the page to the left, negative values to the right. If +flatten+ is
+      # +true+, the rotation is not done via the page's meta data but by "rotating" the canvas
+      # itself.
+      #
+      # Note that the :Rotate key of a page object describes the angle in a clockwise orientation
+      # but this method uses counterclockwise rotation to be consistent with other rotation methods
+      # (e.g. HexaPDF::Content::Canvas#rotate).
+      def rotate(angle, flatten: false)
+        if angle % 90 != 0
+          raise ArgumentError, "Page rotation has to be multiple of 90 degrees"
+        end
+
+        cw_angle = (self[:Rotate] - angle) % 360
+
+        if flatten
+          delete(:Rotate)
+          return if cw_angle == 0
+
+          matrix, llx, lly, urx, ury = \
+            case cw_angle
+            when 90
+              [HexaPDF::Content::TransformationMatrix.new(0, -1, 1, 0),
+               box.right, box.bottom, box.left, box.top]
+            when 180
+              [HexaPDF::Content::TransformationMatrix.new(-1, 0, 0, -1),
+               box.right, box.top, box.left, box.bottom]
+            when 270
+              [HexaPDF::Content::TransformationMatrix.new(0, 1, -1, 0),
+               box.left, box.top, box.right, box.bottom]
+            end
+          [:MediaBox, :CropBox, :BleedBox, :TrimBox, :ArtBox].each do |box|
+            next unless key?(box)
+            self[box].value = matrix.evaluate(llx, lly).concat(matrix.evaluate(urx, ury))
+          end
+
+          before_contents = document.add({}, stream: " q #{matrix.to_a.join(' ')} cm ")
+          after_contents = document.add({}, stream: " Q ")
+          self[:Contents] = [before_contents, *self[:Contents], after_contents]
         else
-          raise ArgumentError, "Unsupported page box type provided: #{type}"
+          self[:Rotate] = cw_angle
         end
       end
 

data/lib/hexapdf/version.rb

@@ -34,6 +34,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 
 end

data/test/hexapdf/common_tokenizer_tests.rb

@@ -51,7 +51,7 @@ module CommonTokenizerTests
         <</Name 5>>
 
         % Test
-        EOF
+    EOF
 
     expected_tokens = [
       true, false,
@@ -125,7 +125,7 @@ module CommonTokenizerTests
     create_tokenizer(<<-EOF.chomp.gsub(/^ {8}/, ''))
         true false null 123 34.5 (string) <4E6F76> /Name
         [5 6 /Name] <</Name 5/Null null>>
-        EOF
+    EOF
     assert_equal(true, @tokenizer.next_object)
     assert_equal(false, @tokenizer.next_object)
     assert_nil(@tokenizer.next_object)

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

@@ -0,0 +1,79 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../common'
+require 'hexapdf/document'
+require 'hexapdf/content'
+require 'hexapdf/content/graphic_object'
+
+describe HexaPDF::Content::GraphicObject::Geom2D do
+  before do
+    @obj = HexaPDF::Content::GraphicObject::Geom2D.new
+  end
+
+  it "allows creation via the ::configure method" do
+    obj = HexaPDF::Content::GraphicObject::Geom2D.configure(object: Geom2D::Point(5, 5))
+    assert_equal(Geom2D::Point(5, 5), obj.object)
+  end
+
+  it "creates a default Geom2D drawing support object" do
+    obj = HexaPDF::Content::GraphicObject::Geom2D.new
+    assert_nil(obj.object)
+    assert_equal(1, obj.point_radius)
+    assert_equal(false, obj.path_only)
+  end
+
+  it "allows configuration of the object" do
+    @obj.configure(object: Geom2D::Point(5, 5), point_radius: 3, path_only: true)
+    assert_equal(Geom2D::Point(5, 5), @obj.object)
+    assert_equal(3, @obj.point_radius)
+    assert_equal(true, @obj.path_only)
+  end
+
+  describe "draw" do
+    before do
+      doc = HexaPDF::Document.new
+      @canvas = doc.pages.add.canvas
+    end
+
+    it "draws a Geom2D::Point onto the canvas" do
+      @obj.object = Geom2D::Point(5, 5)
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :curve_to, :curve_to,
+                        :close_subpath, :fill_path_non_zero],
+                       only_names: true)
+    end
+
+    it "draws a Geom2D::Segment onto the canvas" do
+      @obj.object = Geom2D::Segment([5, 6], [10, 11])
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [[:move_to, [5, 6]], [:line_to, [10, 11]], [:stroke_path]])
+    end
+
+    it "draws a Geom2D::Polygon onto the canvas" do
+      @obj.object = Geom2D::Polygon([5, 6], [10, 11], [7, 9])
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [[:move_to, [5, 6]], [:line_to, [10, 11]], [:line_to, [7, 9]],
+                        [:stroke_path]])
+    end
+
+    it "draws a Geom2D::PolygonSet onto the canvas" do
+      @obj.object = Geom2D::PolygonSet(Geom2D::Polygon([5, 6], [10, 11], [7, 9]),
+                                       Geom2D::Polygon([0, 0], [4, 0], [2, 3]))
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [[:move_to, [5, 6]], [:line_to, [10, 11]], [:line_to, [7, 9]],
+                        [:close_subpath],
+                        [:move_to, [0, 0]], [:line_to, [4, 0]], [:line_to, [2, 3]],
+                        [:close_subpath], [:stroke_path]])
+    end
+
+    it "fails for unkown classes" do
+      @obj.object = 5
+      assert_raises(HexaPDF::Error) { @obj.draw(@canvas) }
+    end
+  end
+end

data/test/hexapdf/encryption/test_standard_security_handler.rb

@@ -76,7 +76,7 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
       end
     end
 
-    if basename !~ /\Auserpwd/
+    unless basename.start_with?("userpwd")
       it "can decrypt the encrypted file #{basename} with the owner password" do
         begin
           doc = HexaPDF::Document.new(io: StringIO.new(File.binread(file)),

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -111,7 +111,7 @@ describe HexaPDF::Font::TrueTypeWrapper do
       assert_equal(:Font, cidfont[:Type])
       assert_equal(:CIDFontType2, cidfont[:Subtype])
       assert_equal({Registry: "Adobe", Ordering: "Identity", Supplement: 0},
-                   cidfont[:CIDSystemInfo])
+                   cidfont[:CIDSystemInfo].value)
       assert_equal(:Identity, cidfont[:CIDToGIDMap])
       assert_equal(@font_wrapper.glyph(3).width, cidfont[:DW])
       assert_equal([2, [glyph.width]], cidfont[:W])

data/test/hexapdf/font/test_type1_wrapper.rb

@@ -75,7 +75,7 @@ describe HexaPDF::Font::Type1Wrapper do
         code = @symbol_wrapper.encode(@symbol_wrapper.glyph(:plus))
         @doc.dispatch_message(:complete_objects)
         assert_equal("\x21", code)
-        assert_equal({Differences: [32, :space, :plus]}, @symbol_wrapper.dict[:Encoding])
+        assert_equal({Differences: [32, :space, :plus]}, @symbol_wrapper.dict[:Encoding].value)
       end
     end
   end

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

@@ -11,7 +11,7 @@ describe HexaPDF::Font::TrueType::Table::Cmap do
       [0, 1, 28],
       [3, 1, 28 + f0.length],
       [1, 0, 28],
-    ].map {|a| a.pack('n2N') }.join('') << f0 << f0
+    ].map {|a| a.pack('n2N') }.join('') << f0 << [10, 22, 0, 0, 2, 10, 13].pack('nN2N2n2')
     set_up_stub_true_type_font(data)
   end
 

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

@@ -22,7 +22,7 @@ describe HexaPDF::Font::TrueType::Table::Directory do
       dir = HexaPDF::Font::TrueType::Table::Directory.new(@file, @self_entry)
       entry = dir.entry('CUST')
       assert_equal('CUST', entry.tag)
-      assert_equal('----'.unpack('N').first, entry.checksum)
+      assert_equal('----'.unpack1('N'), entry.checksum)
       assert_equal(28, entry.offset)
       assert_equal(5, entry.length)
     end

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

@@ -8,7 +8,7 @@ describe HexaPDF::Font::TrueType::Table::Head do
   before do
     data = [1, 0, 2, 6554, 0, 42, 0x5f0f, 0x3CF5, 3, 64].pack('n*')
     @time = Time.new(2016, 05, 01)
-    data << ([(@time - HexaPDF::Font::TrueType::Table::TIME_EPOCH).to_i] * 2).pack('Q>*')
+    data << ([(@time - HexaPDF::Font::TrueType::Table::TIME_EPOCH).to_i] * 2).pack('q>*')
     data << [-132, -152, 3423, 4231, 3, 9, -2, 0, 0].pack('s>4n2s>3')
     set_up_stub_true_type_font(data)
   end
@@ -43,8 +43,12 @@ describe HexaPDF::Font::TrueType::Table::Head do
 
   describe "checksum_valid?" do
     it "checks whether an entry's checksum is valid" do
-      data = 254.chr * 12 + [0x5F0F3CF5].pack('N') + 254.chr * 36 + 0.chr * 4
-      @entry.checksum = (0xfefefefe * 11 + 0x5F0F3CF5) % 2**32
+      data = 254.chr * 12 + # fields before checksum field
+        [0x5F0F3CF5].pack('N') + # checksum field
+        254.chr * 4 +
+        0.chr * 4 + 254.chr * 4 + 0.chr * 4 + 254.chr * 4 + # date fields
+        254.chr * 16 + 0.chr * 4
+      @entry.checksum = (0xfefefefe * 9 + 0x5F0F3CF5) % 2**32
       table = create_table(:Head, data)
       assert(table.checksum_valid?)
     end

data/test/hexapdf/layout/test_box.rb

@@ -10,21 +10,31 @@ describe HexaPDF::Layout::Box do
     HexaPDF::Layout::Box.new(*args, &block)
   end
 
-  describe "initialize" do
+  describe "::create" do
+    it "passes the block on to #initialize" do
+      block = proc {}
+      box = HexaPDF::Layout::Box.create(&block)
+      assert_same(block, box.instance_eval { @draw_block })
+    end
+
+    it "allows specifying style options" do
+      box = HexaPDF::Layout::Box.create(background_color: 20)
+      assert_equal(20, box.style.background_color)
+    end
+
     it "takes content width and height" do
-      box = create_box(content_width: 100, content_height: 200)
+      box = HexaPDF::Layout::Box.create(width: 100, height: 200, content_box: true,
+                                        padding: 10, border: {width: 10})
       assert_equal(100, box.content_width)
       assert_equal(200, box.content_height)
     end
+  end
 
+  describe "initialize" do
     it "takes box width and height" do
       box = create_box(width: 100, height: 200)
-      assert_equal(100, box.content_width)
-      assert_equal(200, box.content_height)
-
-      box = create_box(width: 100, height: 200, style: {padding: [20, 10], border: {width: [10, 5]}})
-      assert_equal(70, box.content_width)
-      assert_equal(140, box.content_height)
+      assert_equal(100, box.width)
+      assert_equal(200, box.height)
     end
 
     it "allows passing a Style object or a hash" do
@@ -36,16 +46,41 @@ describe HexaPDF::Layout::Box do
     end
   end
 
-  it "returns the full width and height of the box" do
-    box = create_box(content_width: 100, content_height: 200,
-                     style: {padding: [20, 10], border: {width: [10, 5]}})
-    assert_equal(130, box.width)
-    assert_equal(260, box.height)
+  describe "fit" do
+    before do
+      @frame = Object.new
+    end
+
+    it "fits a fixed sized box" do
+      box = create_box(width: 50, height: 50)
+      assert(box.fit(100, 100, @frame))
+      assert_equal(50, box.width)
+      assert_equal(50, box.height)
+    end
+
+    it "uses the maximum available width" do
+      box = create_box(height: 50)
+      assert(box.fit(100, 100, @frame))
+      assert_equal(100, box.width)
+      assert_equal(50, box.height)
+    end
+
+    it "uses the maximum available height" do
+      box = create_box(width: 50)
+      assert(box.fit(100, 100, @frame))
+      assert_equal(50, box.width)
+      assert_equal(100, box.height)
+    end
+
+    it "returns false if the box doesn't fit" do
+      box = create_box(width: 101)
+      refute(box.fit(100, 100, @frame))
+    end
   end
 
   describe "draw" do
     it "draws the box onto the canvas" do
-      box = create_box(content_width: 100, content_height: 100) do |canvas, _|
+      box = create_box(width: 150, height: 130) do |canvas, _|
         canvas.line_width(15)
       end
       box.style.background_color = 0.5
@@ -69,6 +104,8 @@ describe HexaPDF::Layout::Box do
                                           [:restore_graphics_state],
                                           [:save_graphics_state],
                                           [:set_line_width, [5]],
+                                          [:append_rectangle, [5, 5, 150, 130]],
+                                          [:clip_path_non_zero], [:end_path],
                                           [:append_rectangle, [7.5, 7.5, 145, 125]],
                                           [:stroke_path],
                                           [:restore_graphics_state],
@@ -86,8 +123,13 @@ describe HexaPDF::Layout::Box do
 
     it "draws nothing onto the canvas if the box is empty" do
       @canvas = HexaPDF::Document.new.pages.add.canvas
-      create_box.draw(@canvas, 5, 5)
+      box = create_box
+      box.draw(@canvas, 5, 5)
       assert_operators(@canvas.contents, [])
+      refute(box.style.background_color?)
+      refute(box.style.underlays?)
+      refute(box.style.border?)
+      refute(box.style.overlays?)
     end
   end