hexapdf 0.1.0 → 0.2.0

data/test/hexapdf/test_rectangle.rb

@@ -2,6 +2,7 @@
 
 require 'test_helper'
 require 'hexapdf/rectangle'
+require 'hexapdf/document'
 
 describe HexaPDF::Rectangle do
   describe "after_data_change" do
@@ -33,4 +34,21 @@ describe HexaPDF::Rectangle do
     assert_equal(2, rect.width)
     assert_equal(4, rect.height)
   end
+
+  describe "validation" do
+    it "ensures that it is a correct PDF rectangle" do
+      doc = HexaPDF::Document.new
+      rect = HexaPDF::Rectangle.new([0, 1, 2, 3], document: doc)
+      assert(rect.validate)
+
+      rect.value.shift
+      refute(rect.validate)
+
+      rect.value.unshift(:A)
+      refute(rect.validate)
+
+      rect.data.value = :A
+      refute(rect.validate)
+    end
+  end
 end

data/test/hexapdf/test_revisions.rb

@@ -82,6 +82,13 @@ EOF
       assert_equal(1, @revisions.each.to_a.size)
       assert_equal([10, 200], @revisions.current.each.to_a.sort.map(&:value))
     end
+
+    it "handles objects correctly that are in multiple revisions" do
+      @revisions.current.add(@revisions[0].object(1))
+      @revisions.merge
+      assert_equal(1, @revisions.each.to_a.size)
+      assert_equal([10, 200], @revisions.current.each.to_a.sort.map(&:value))
+    end
   end
 
   describe "initialize" do

data/test/hexapdf/test_serializer.rb

@@ -25,6 +25,12 @@ describe HexaPDF::Serializer do
     assert_equal(result, @serializer.serialize(object))
   end
 
+  it "works correctly with unnamed classes and modules" do
+    klass = Class.new(String)
+    s = klass.new("test")
+    assert_serialized("(test)", s)
+  end
+
   it "serializes nil" do
     assert_serialized("null", nil)
   end

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ startxref
 219
 %%EOF
 3 0 obj
-<</Producer(HexaPDF version 0.1.0)>>
+<</Producer(HexaPDF version 0.2.0)>>
 endobj
 xref
 3 1
@@ -72,7 +72,7 @@ startxref
 141
 %%EOF
 6 0 obj
-<</Producer(HexaPDF version 0.1.0)>>
+<</Producer(HexaPDF version 0.2.0)>>
 endobj
 2 0 obj
 <</Length 10>>stream

data/test/hexapdf/type/test_form.rb

@@ -57,4 +57,16 @@ describe HexaPDF::Type::Form do
       assert_equal([[:set_line_width, [10]]], processor.recorded_ops)
     end
   end
+
+  describe "canvas" do
+    it "always returns the same Canvas instance" do
+      canvas = @form.canvas
+      assert_same(canvas, @form.canvas)
+    end
+
+    it "fails if the form XObject already has data" do
+      @form.stream = '10 w'
+      assert_raises(HexaPDF::Error) { @form.canvas }
+    end
+  end
 end

data/test/hexapdf/type/test_page.rb

@@ -49,13 +49,11 @@ describe HexaPDF::Type::Page do
 
       @kid[:Rotate] = :kid_rotate
       assert_equal(:kid_rotate, @page[:Rotate])
-      @kid.delete(:Rotate)
-      assert_equal(0, @page[:Rotate])
     end
 
-    it "fails if no parent node is associated" do
-      page = @doc.add(Type: :Page)
-      assert_raises(HexaPDF::InvalidPDFObjectError) { page[:Resources] }
+    it "returns nil or the default value if no value is set anywhere" do
+      assert_nil(@page[:MediaBox])
+      assert_equal(0, @page[:Rotate])
     end
   end
 
@@ -71,7 +69,7 @@ describe HexaPDF::Type::Page do
 
   describe "box" do
     before do
-      @page = @doc.pages.add_page
+      @page = @doc.pages.add
     end
 
     it "returns the correct media box" do
@@ -106,13 +104,13 @@ describe HexaPDF::Type::Page do
 
   describe "contents" do
     it "returns the contents of a single content stream" do
-      page = @doc.pages.add_page
+      page = @doc.pages.add
       page[:Contents] = @doc.wrap({}, stream: 'q 10 w Q')
       assert_equal('q 10 w Q', page.contents)
     end
 
     it "returns the concatenated contents of multiple content stream" do
-      page = @doc.pages.add_page
+      page = @doc.pages.add
       page[:Contents] = [@doc.wrap({}, stream: 'q 10'), @doc.wrap({}, stream: 'w Q')]
       assert_equal('q 10 w Q', page.contents)
     end
@@ -120,13 +118,13 @@ describe HexaPDF::Type::Page do
 
   describe "contents=" do
     it "creates a content stream if none already exist" do
-      page = @doc.pages.add_page
+      page = @doc.pages.add
       page.contents = 'test'
       assert_equal('test', page[:Contents].stream)
     end
 
     it "reuses an existing content stream" do
-      page = @doc.pages.add_page
+      page = @doc.pages.add
       page[:Contents] = content = @doc.wrap({}, stream: 'q 10 w Q')
       page.contents = 'test'
       assert_equal(content, page[:Contents])
@@ -134,7 +132,7 @@ describe HexaPDF::Type::Page do
     end
 
     it "reuses the first content stream and deletes the rest if more than one exist" do
-      page = @doc.pages.add_page
+      page = @doc.pages.add
       page[:Contents] = [content = @doc.add({}, stream: 'q 10 w Q'), @doc.add({}, stream: 'q Q')]
       page.contents = 'test'
       assert_equal(content, page[:Contents])
@@ -144,33 +142,54 @@ describe HexaPDF::Type::Page do
 
   describe "resources" do
     it "creates the resource dictionary if it is not found" do
-      page = @doc.add(Type: :Page, Parent: @doc.pages)
+      page = @doc.add(Type: :Page, Parent: @doc.pages.root)
       resources = page.resources
       assert_equal(:XXResources, resources.type)
       assert_equal({}, resources.value)
     end
 
     it "returns the already used resource dictionary" do
-      @doc.pages[:Resources] = {Font: {F1: nil}}
-      page = @doc.pages.add_page(@doc.add(Type: :Page))
+      @doc.pages.root[:Resources] = {Font: {F1: nil}}
+      page = @doc.pages.add(@doc.add(Type: :Page))
       resources = page.resources
       assert_equal(:XXResources, resources.type)
-      assert_equal(@doc.pages[:Resources], resources)
+      assert_equal(@doc.pages.root[:Resources], resources)
     end
   end
 
   describe "process_contents" do
     it "parses the contents and processes it" do
-      page = @doc.pages.add_page
+      page = @doc.pages.add
       page[:Contents] = @doc.wrap({}, stream: 'q 10 w Q')
       assert_operators(page, [[:save_graphics_state], [:set_line_width, [10]],
                               [:restore_graphics_state]])
     end
   end
 
+  describe "index" do
+    it "returns the index of the page in the page tree" do
+      kid1 = @doc.add(Type: :Pages, Parent: @doc.pages.root, Count: 4)
+      @doc.pages.root[:Kids] << kid1
+
+      kid11 = @doc.add(Type: :Pages, Parent: kid1)
+      page1 = kid11.add_page
+      kid1[:Kids] << kid11
+      page2 = kid1.add_page
+      kid12 = @doc.add(Type: :Pages, Parent: kid1)
+      page3 = kid12.add_page
+      page4 = kid12.add_page
+      kid1[:Kids] << kid12
+
+      assert_equal(0, page1.index)
+      assert_equal(1, page2.index)
+      assert_equal(2, page3.index)
+      assert_equal(3, page4.index)
+    end
+  end
+
   describe "canvas" do
     before do
-      @page = @doc.pages.add_page
+      @page = @doc.pages.add
     end
 
     it "works correctly if invoked on an empty page, using type :page in first invocation" do
@@ -234,7 +253,7 @@ describe HexaPDF::Type::Page do
 
   describe "to_form_xobject" do
     it "creates an independent form xobject" do
-      page = @doc.pages.add_page
+      page = @doc.pages.add
       page.contents = "test"
       form = page.to_form_xobject
       refute(form.indirect?)
@@ -242,13 +261,13 @@ describe HexaPDF::Type::Page do
     end
 
     it "works for pages without content" do
-      page = @doc.pages.add_page
+      page = @doc.pages.add
       form = page.to_form_xobject
       assert_equal('', form.stream)
     end
 
     it "uses the raw stream data if possible to avoid unnecessary work" do
-      page = @doc.pages.add_page
+      page = @doc.pages.add
       page.contents = HexaPDF::StreamData.new(StringIO.new("test"))
       form = page.to_form_xobject
       assert_same(form.raw_stream, page[:Contents].raw_stream)

data/test/hexapdf/type/test_page_tree_node.rb

@@ -151,40 +151,47 @@ describe HexaPDF::Type::PageTreeNode do
       define_multilevel_page_tree
     end
 
-    it "does nothing if the page index is not valid" do
-      assert_nil(@root.delete_page(20))
-      assert_nil(@root.delete_page(-20))
-      assert_equal(8, @root.page_count)
-    end
-
-    it "deletes the correct page" do
+    it "deletes the correct page by index" do
       assert_equal(@pages[2], @root.delete_page(2))
       assert_equal(2, @kid12.page_count)
       assert_equal(4, @kid1.page_count)
       assert_equal(7, @root.page_count)
+      assert_nil(@pages[2][:Parent])
 
       assert_equal(@pages[5], @root.delete_page(4))
       assert_equal(6, @root.page_count)
+      assert_nil(@pages[5][:Parent])
     end
 
-    it "deletes intermediate page tree nodes if they contain only one child after deletion" do
-      assert_equal(@pages[0], @root.delete_page(0))
-      assert_equal(4, @kid1.page_count)
+    it "deletes the given page" do
+      assert_equal(@pages[2], @root.delete_page(@pages[2]))
+      assert_equal(@pages[5], @root.delete_page(@pages[5]))
+    end
+
+    it "allows deleting a page from an intermediary node" do
+      assert_equal(@pages[2], @kid1.delete_page(@pages[2]))
       assert_equal(7, @root.page_count)
-      assert_nil(@doc.object(@kid11).value)
-      assert_equal(@pages[1], @kid1[:Kids][0])
     end
 
-    it "deletes intermediate page tree nodes if they don't have any children after deletion" do
-      node = @doc.add(Type: :Pages, Parent: @root)
-      page = node.add_page
-      @root[:Kids] << node
-      @root[:Count] += 1
+    it "does nothing if the page index is not valid" do
+      assert_nil(@root.delete_page(20))
+      assert_nil(@root.delete_page(-20))
+      assert_equal(8, @root.page_count)
+    end
 
-      assert_equal(page, @root.delete_page(-1))
-      assert_nil(@doc.object(node).value)
-      refute_equal(node, @root[:Kids].last)
-      assert(8, @root.page_count)
+    it "does nothing if the page is not in its parent's /Kids array" do
+      @kid12[:Kids].shift
+      assert_nil(@root.delete_page(@pages[2]))
+      assert_equal(8, @root.page_count)
+    end
+
+    it "does nothing if the page is not part of the page tree" do
+      pages = @doc.add(Type: :Pages, Count: 1)
+      page = @doc.add(Type: :Page, Parent: pages)
+      pages[:Kids] << page
+
+      assert_nil(@root.delete_page(page))
+      assert_equal(8, @root.page_count)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-26 00:00:00.000000000 Z
+date: 2016-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -31,19 +31,25 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 3.0.1
 - !ruby/object:Gem::Dependency
-  name: ronn
+  name: kramdown
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.13.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.13.0
 description: |-
   HexaPDF is a pure Ruby library with an accompanying application for working with PDF files.
 
@@ -56,6 +62,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - CONTRIBUTERS
 - LICENSE
 - README.md
@@ -112,7 +119,10 @@ files:
 - lib/hexapdf/dictionary.rb
 - lib/hexapdf/dictionary_fields.rb
 - lib/hexapdf/document.rb
-- lib/hexapdf/document_utils.rb
+- lib/hexapdf/document/files.rb
+- lib/hexapdf/document/fonts.rb
+- lib/hexapdf/document/images.rb
+- lib/hexapdf/document/pages.rb
 - lib/hexapdf/encryption.rb
 - lib/hexapdf/encryption/aes.rb
 - lib/hexapdf/encryption/arc4.rb
@@ -173,7 +183,6 @@ files:
 - lib/hexapdf/font_loader.rb
 - lib/hexapdf/font_loader/from_configuration.rb
 - lib/hexapdf/font_loader/standard14.rb
-- lib/hexapdf/font_utils.rb
 - lib/hexapdf/image_loader.rb
 - lib/hexapdf/image_loader/jpeg.rb
 - lib/hexapdf/image_loader/pdf.rb
@@ -306,6 +315,10 @@ files:
 - test/hexapdf/content/test_parser.rb
 - test/hexapdf/content/test_processor.rb
 - test/hexapdf/content/test_transformation_matrix.rb
+- test/hexapdf/document/test_files.rb
+- test/hexapdf/document/test_fonts.rb
+- test/hexapdf/document/test_images.rb
+- test/hexapdf/document/test_pages.rb
 - test/hexapdf/encryption/common.rb
 - test/hexapdf/encryption/test_aes.rb
 - test/hexapdf/encryption/test_arc4.rb
@@ -350,6 +363,7 @@ files:
 - test/hexapdf/font/true_type/test_table.rb
 - test/hexapdf/font/type1/test_afm_parser.rb
 - test/hexapdf/font/type1/test_font.rb
+- test/hexapdf/font/type1/test_font_metrics.rb
 - test/hexapdf/font/type1/test_pfb_parser.rb
 - test/hexapdf/font_loader/test_from_configuration.rb
 - test/hexapdf/font_loader/test_standard14.rb
@@ -363,9 +377,7 @@ files:
 - test/hexapdf/test_dictionary.rb
 - test/hexapdf/test_dictionary_fields.rb
 - test/hexapdf/test_document.rb
-- test/hexapdf/test_document_utils.rb
 - test/hexapdf/test_filter.rb
-- test/hexapdf/test_font_utils.rb
 - test/hexapdf/test_importer.rb
 - test/hexapdf/test_object.rb
 - test/hexapdf/test_parser.rb

data/lib/hexapdf/document_utils.rb

@@ -1,209 +0,0 @@
-# -*- encoding: utf-8 -*-
-#
-#--
-# This file is part of HexaPDF.
-#
-# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2016 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/configuration'
-
-module HexaPDF
-
-  # This class provides utility functions for PDF documents. It is available through the
-  # HexaPDF::Document#utils method.
-  #
-  # Some functions can't be attributed to a single "manager" object. For example, while embedding a
-  # file can be done within a HexaPDF::Type::Filespecification object, loading an image from a file
-  # as a PDF object doesn't have such a place. Such functions are available via this class.
-  class DocumentUtils
-
-    # This module provides methods for managing the images embedded in a PDF file; images
-    # themselves are represented by the HexaPDF::Type::Image class.
-    #
-    # Since an image can be used as a mask for another image, not all image objects found in a PDF
-    # are really used as images. Such cases are all handled by this class automatically.
-    module Images
-
-      # :call-seq:
-      #   images.add_image(file)            -> image
-      #   images.add_image(io)              -> image
-      #
-      # Adds the image from the given file or IO to the PDF and returns the image object.
-      #
-      # If the image has been added to the PDF before (i.e. if there is an image object with the
-      # same path name), the already existing image object is returned.
-      def add_image(file_or_io)
-        name = if file_or_io.kind_of?(String)
-                 file_or_io
-               elsif file_or_io.respond_to?(:to_path)
-                 file_or_io.to_path
-               end
-        if name
-          name = File.absolute_path(name)
-          image = each_image.find {|im| im.source_path == name}
-        end
-        unless image
-          image = image_loader_for(file_or_io).load(@document, file_or_io)
-          image.source_path = name
-        end
-        image
-      end
-
-      # :call-seq:
-      #   images.each_image {|image| block }   -> images
-      #   images.each_image                    -> Enumerator
-      #
-      # Iterates over all images in the PDF.
-      #
-      # Note that only real images are yielded which means, for example, that images used as soft
-      # mask are not.
-      def each_image(&block)
-        images = @document.each(current: false).select do |obj|
-          obj[:Subtype] == :Image && !obj[:ImageMask]
-        end
-        masks = images.each_with_object([]) do |image, temp|
-          temp << image[:Mask] if image[:Mask].kind_of?(Stream)
-          temp << image[:SMask] if image[:SMask].kind_of?(Stream)
-        end
-        (images - masks).each(&block)
-      end
-
-      private
-
-      # Returns the image loader (see ImageLoader) for the given file or IO stream or raises an
-      # error if no suitable image loader is found.
-      def image_loader_for(file_or_io)
-        GlobalConfiguration['image_loader'].each_index do |index|
-          loader = GlobalConfiguration.constantize('image_loader', index) do
-            raise HexaPDF::Error, "Couldn't retrieve image loader from configuration"
-          end
-          return loader if loader.handles?(file_or_io)
-        end
-
-        raise HexaPDF::Error, "Couldn't find suitable image loader"
-      end
-
-    end
-
-
-    # This module provides methods for managing file specification of a PDF file.
-    #
-    # Note that for a given PDF file not all file specifications may be found, e.g. when a file
-    # specification is only a string. Therefore this module can only handle those file
-    # specifications that are indirect file specification dictionaries with the /Type key set.
-    module Files
-
-      # :call-seq:
-      #   files.add_file(filename, name: File.basename(filename), description: nil, embed: true) -> file_spec
-      #   files.add_file(io, name:, description: nil)                      -> file_spec
-      #
-      # Adds the file or IO to the PDF and returns the corresponding file specification object.
-      #
-      # Options:
-      #
-      # name::
-      #     The name that should be used for the file path. This name is also for registering the
-      #     file in the EmbeddedFiles name tree.
-      #
-      # description::
-      #     A description of the file.
-      #
-      # embed::
-      #     When an IO object is given, it is always embedded and this option is ignored.
-      #
-      #     When a filename is given and this option is +true+, then the file is embedded. Otherwise
-      #     only a reference to it is stored.
-      #
-      # See: HexaPDF::Type::FileSpecification
-      def add_file(file_or_io, name: nil, description: nil, embed: true)
-        name ||= File.basename(file_or_io) if file_or_io.kind_of?(String)
-        if name.nil?
-          raise ArgumentError, "The name argument is mandatory when given an IO object"
-        end
-
-        spec = @document.add(Type: :Filespec)
-        spec.path = name
-        spec[:Desc] = description if description
-        spec.embed(file_or_io, name: name, register: true) if embed || !file_or_io.kind_of?(String)
-        spec
-      end
-
-      # :call-seq:
-      #   files.each_file(search: false) {|file_spec| block }   -> files
-      #   files.each_file(search: false)                        -> Enumerator
-      #
-      # Iterates over indirect file specification dictionaries of the PDF.
-      #
-      # By default, only the file specifications in their standard locations, namely in the
-      # EmbeddedFiles name tree and in the page annotations, are returned. If the +search+ option is
-      # +true+, then all indirect objects are searched for file specification dictionaries which is
-      # much slower.
-      def each_file(search: false)
-        return to_enum(__method__, search: search) unless block_given?
-
-        if search
-          @document.each(current: false) do |obj|
-            yield(obj) if obj.type == :Filespec
-          end
-        else
-          seen = {}
-          tree = @document.catalog[:Names] && @document.catalog[:Names][:EmbeddedFiles]
-          tree.each_entry do |_, spec|
-            seen[spec] = true
-            yield(spec)
-          end if tree
-
-          @document.pages.each_page do |page|
-            next unless page[:Annots]
-            page[:Annots].each do |annot|
-              annot = @document.deref(annot)
-              next unless annot[:Subtype] == :FileAttachment
-              spec = @document.deref(annot[:FS])
-              yield(spec) unless seen.key?(spec)
-              seen[spec] = true
-            end
-          end
-        end
-
-        self
-      end
-
-    end
-
-    include Images
-    include Files
-
-    # Creates a new DocumentUtils object for the given PDF document.
-    def initialize(document)
-      @document = document
-    end
-
-  end
-
-end