hexapdf 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c10b3600c81488af01c877e24fc31aa859968e8
-  data.tar.gz: 6bdde619dae45921219a100612fd67e3fd1e1317
+  metadata.gz: 874a5d2e5a2408ceed91a9bc61df138248fbbcd2
+  data.tar.gz: 894e67110daae93c1479a5ced992a84dabc66cd1
 SHA512:
-  metadata.gz: 9b79e62cf749a111b4a81a6ce7dab39dfca4b66ba47cd9961ab7452fb75a75373bb01a088659d7bca31429969341b980e75a3a39008525effb2bd116d0162a69
-  data.tar.gz: b09a691c6f92f6035a73f226ec0d566f2d48a18082478a03037ea4dd0dded3698d25a0e403aa7f51cea8d9481bafd923f8de8d9510a961994c0f5e733aa12bbf
+  metadata.gz: 9d7c18191ea0d64992fc01b05904c3324cc1f32e98fe848bc931970b53f42d9ab6878d4e8c3730a570c607f677dfdaa8a8adebe7ab4c8e279cc13383124dee1b
+  data.tar.gz: 1e080dd694ad58c3256a647a98a9b03c439ae340311b037fad3b1bdbe436ffbed74fec0c00af3df68540ca32aa75336c328a317a74233428dcf16d8920cc8e75

data/CHANGELOG.md

@@ -0,0 +1,56 @@
+## 0.2.0 - unreleased
+
+### Added
+
+* PDF file merge ability to `hexapdf modify`, i.e. adding pages from other PDFs
+* Page interleaving support to 'hexapdf modify'
+* Step values in pages definitions for CLI commands
+* Convenience class for working with pages through [HexaPDF::Document#pages]
+  with a more Ruby-like interface
+* Method [HexaPDF::Type::Form#canvas]
+* Method [HexaPDF::Type::Page#index]
+* Validation for [HexaPDF::Rectangle] objects
+* [HexaPDF::Font::Type1::FontMetrics#weight_class] for returning the numeric
+  weight
+
+### Changed
+
+* Refactor document utilities into own classes with a more Ruby-like interface;
+  concern fonts, images and files, now accessible through
+  [HexaPDF::Document#fonts], [HexaPDF::Document#images] and
+  [HexaPDF::Document#files]
+* Validate nested collection values in [HexaPDF::Object]
+* Allow [HexaPDF::Dictionary#[]] to always unwrap nil values
+* Update [HexaPDF::Task::Optimize] to delete unused objects on `:compact`
+* Allow [HexaPDF::Type::PageTreeNode#delete_page] to take a page object or a
+  page index
+* Don't set /EFF key in encryption dictionary
+* Better error handling for hexapdf CLI commands
+* Show help output when no command is given for `hexapdf` CLI
+* Set /FontWeight in [HexaPDF::Font::Type1Wrapper]
+* Use kramdown's man page support for the `hexapdf` man page instead of ronn
+
+### Removed
+
+* Remove unneeded parts of TrueType implementation
+
+### Fixed
+
+* Problem with unnamed classes/modules on serialization
+* Handle potentially indirect objects correctly in [HexaPDF::Object::deep_copy]
+* [HexaPDF::Revisions#merge] for objects that appear in multiple revisions
+* Output of `--pages` option of 'hexapdf inspect' command
+* Infinite recursion problem in [HexaPDF::Task::Dereference]
+* Problem with iteration over images in certain cases
+* [HexaPDF::Type::Page#[]] with respect to inherited fields
+* Problems with access permissions on encryption
+* Encryption routine of standard security handler with respect to owner password
+* Invalid check in validation of standard encryption dictionary
+* 'hexapdf modify' command to support files with many pages
+* Validation of encryption key for encryption revision 6
+* Various parts of the API documentation
+
+
+## 0.1.0 - 2016-10-26
+
+* Initial release

data/CONTRIBUTERS

@@ -1,3 +1,3 @@
   Count Name
 ======= ====
-    601 Thomas Leitner <t_leitner@gmx.at>
+    647 Thomas Leitner <t_leitner@gmx.at>

data/Rakefile

@@ -16,7 +16,7 @@ namespace :dev do
   PKG_FILES = FileList.new([
     'Rakefile',
     'LICENSE', 'agpl-3.0.txt',
-    'README.md',
+    'README.md', 'CHANGELOG.md',
     'VERSION', 'CONTRIBUTERS',
     'bin/*',
     'lib/**/*.rb',
@@ -29,7 +29,7 @@ namespace :dev do
   CLOBBER << "man/man1/hexapdf.1"
   file 'man/man1/hexapdf.1' => ['man/man1/hexapdf.1.md'] do
     puts "Generating hexapdf man page"
-    system "ronn --pipe -r man/man1/hexapdf.1.md > man/man1/hexapdf.1"
+    system "kramdown -o man man/man1/hexapdf.1.md > man/man1/hexapdf.1"
   end
 
   CLOBBER << "VERSION"
@@ -65,7 +65,7 @@ namespace :dev do
     s.executables = ['hexapdf']
     s.default_executable = 'hexapdf'
     s.add_dependency('cmdparse', '~> 3.0', '>= 3.0.1')
-    s.add_development_dependency('ronn', '~> 0.7')
+    s.add_development_dependency('kramdown', '~> 1.0', '>= 1.13.0')
 
     s.author = 'Thomas Leitner'
     s.email = 't_leitner@gmx.at'

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/examples/arc.rb

@@ -10,7 +10,7 @@
 require 'hexapdf'
 
 doc = HexaPDF::Document.new
-page = doc.pages.add_page
+page = doc.pages.add
 canvas = page.canvas
 
 radius = 75

data/examples/graphics.rb

@@ -14,7 +14,7 @@
 require 'hexapdf'
 
 doc = HexaPDF::Document.new
-page = doc.pages.add_page
+page = doc.pages.add
 canvas = page.canvas
 
 # Draws the shape that is used to showcase the transformations in the given

data/examples/hello_world.rb

@@ -10,7 +10,7 @@
 require 'hexapdf'
 
 doc = HexaPDF::Document.new
-canvas = doc.pages.add_page.canvas
+canvas = doc.pages.add.canvas
 canvas.font('Helvetica', size: 100)
 canvas.text("Hello World!", at: [20, 400])
 doc.write("hello_world.pdf", optimize: true)

data/examples/merging.rb

@@ -19,6 +19,6 @@ require 'hexapdf'
 target = HexaPDF::Document.new
 ARGV.each do |file|
   pdf = HexaPDF::Document.open(file)
-  pdf.pages.each_page {|page| target.pages.add_page(target.import(page))}
+  pdf.pages.each {|page| target.pages << target.import(page)}
 end
 target.write("merging.pdf", optimize: true)

data/examples/show_char_bboxes.rb

@@ -47,7 +47,7 @@ class ShowTextProcessor < HexaPDF::Content::Processor
 end
 
 doc = HexaPDF::Document.open(ARGV.shift)
-doc.pages.each_page.with_index do |page, index|
+doc.pages.each_with_index do |page, index|
   puts "Processing page #{index + 1}"
   processor = ShowTextProcessor.new(page)
   page.process_contents(processor)

data/examples/standard_pdf_fonts.rb

@@ -26,7 +26,7 @@ doc = HexaPDF::Document.new
 
 HexaPDF::FontLoader::Standard14::MAPPING.each do |font_name, mapping|
   mapping.each_key do |variant|
-    canvas = doc.pages.add_page.canvas
+    canvas = doc.pages.add.canvas
     canvas.font("Helvetica", size: 14)
     canvas.text("#{font_name} #{variant != :none ? variant : ''}", at: [100, 800])
 

data/examples/truetype.rb

@@ -27,7 +27,7 @@ max_gid = wrapper.wrapped_font[:maxp].num_glyphs
 
 255.times do |page|
   break unless page * 256 < wrapper.wrapped_font[:maxp].num_glyphs
-  canvas = doc.pages.add_page.canvas
+  canvas = doc.pages.add.canvas
   canvas.font("Helvetica", size: 10)
   canvas.text("Font: #{wrapper.wrapped_font.full_name}", at: [50, 825])
 

data/lib/hexapdf/cli.rb

@@ -49,6 +49,9 @@ module HexaPDF
     # Runs the CLI application.
     def self.run(args = ARGV)
       Application.new.parse(args)
+    rescue => e
+      $stderr.puts "An error occurred: #{e.message}"
+      exit(1)
     end
 
     # The CmdParse::CommandParser class that is used for running the CLI application.
@@ -66,8 +69,13 @@ module HexaPDF
         add_command(CmdParse::VersionCommand.new)
       end
 
-      PAGE_NUMBER_SPEC = "([1-9]\\d*|e)" #:nodoc:
-      ROTATE_MAP = {'l' => -90, 'r' => 90, 'd' => 180, 'n' => :none, nil => :none} #:nodoc:
+      def parse(argv = ARGV) #:nodoc:
+        ARGV.unshift('help') if ARGV.empty?
+        super
+      end
+
+      PAGE_NUMBER_SPEC = "([1-9]\\d*|e)".freeze #:nodoc:
+      ROTATE_MAP = {'l' => -90, 'r' => 90, 'd' => 180, 'n' => :none}.freeze #:nodoc:
 
       # Parses the pages specification string and returns an array of tuples containing a page
       # number and a rotation value (either -90, 90, 180 or :none).
@@ -78,13 +86,12 @@ module HexaPDF
           case str
           when /\A#{PAGE_NUMBER_SPEC}(l|r|d|n)?\z/o
             arr << [($1 == 'e' ? count : str.to_i) - 1, ROTATE_MAP[$2]]
-          when /\A#{PAGE_NUMBER_SPEC}-#{PAGE_NUMBER_SPEC}(l|r|d|n)?\z/
+          when /\A#{PAGE_NUMBER_SPEC}-#{PAGE_NUMBER_SPEC}(?:\/([1-9]\d*))?(l|r|d|n)?\z/
             start_nr = ($1 == 'e' ? count : $1.to_i) - 1
             end_nr = ($2 == 'e' ? count : $2.to_i) - 1
-            rotation = ROTATE_MAP[$3]
-            (start_nr > end_nr ? (end_nr..start_nr).reverse_each : (start_nr..end_nr)).each do |n|
-              arr << [n, rotation]
-            end
+            step = ($3 ? $3.to_i : 1) * (start_nr > end_nr ? -1 : 1)
+            rotation = ROTATE_MAP[$4]
+            start_nr.step(to: end_nr, by: step) {|n| arr << [n, rotation]}
           else
             raise OptionParser::InvalidArgument, "invalid page range format: #{str}"
           end

data/lib/hexapdf/cli/extract.rb

@@ -119,7 +119,7 @@ module HexaPDF
 
       # Iterates over all embedded files.
       def each_file(doc, &block) # :yields: obj, index
-        doc.utils.each_file(search: @search).select(&:embedded_file?).each_with_index(&block)
+        doc.files.each(search: @search).select(&:embedded_file?).each_with_index(&block)
       end
 
     end

data/lib/hexapdf/cli/info.rb

@@ -68,7 +68,7 @@ module HexaPDF
       private
 
       INFO_KEYS = [:Title, :Author, :Subject, :Keywords, :Creator, :Producer, #:nodoc:
-                   :CreationDate, :ModDate]
+                   :CreationDate, :ModDate].freeze
 
       COLUMN_WIDTH = 20 #:nodoc:
 
@@ -95,7 +95,7 @@ module HexaPDF
             output_line("Encrypted", "yes (no or wrong password given)")
           end
 
-          output_line("Pages", doc.pages.page_count.to_s)
+          output_line("Pages", doc.pages.count.to_s)
           output_line("Version", doc.version)
         end
       rescue HexaPDF::EncryptionError => e

data/lib/hexapdf/cli/inspect.rb

@@ -113,15 +113,15 @@ module HexaPDF
       end
 
       def do_page_count(doc) #:nodoc:
-        puts doc.pages.page_count
+        puts doc.pages.count
       end
 
       def do_pages(doc) #:nodoc:
-        pages = command_parser.parse_pages_specification(@param, doc.pages.page_count)
+        pages = command_parser.parse_pages_specification(@param, doc.pages.count)
         pages.each do |index, _|
-          page = doc.pages.page(index)
+          page = doc.pages[index]
           str = "page #{index + 1} (#{page.oid},#{page.gen}): "
-          Array(page[:Contents]).each {|c| str << "#{c.oid},#{c.gen}"}
+          str << Array(page[:Contents]).map {|c| "#{c.oid},#{c.gen}"}.join(" ")
           puts str
         end
       end

data/lib/hexapdf/cli/modify.rb

@@ -39,28 +39,58 @@ module HexaPDF
 
     # Modifies a PDF file:
     #
-    # * Decrypts or encrypts the PDF file.
+    # * Adds pages from other PDF files.
+    # * Decrypts or encrypts the resulting output PDF file.
     # * Generates or deletes object and cross-reference streams.
-    # * Optimizes a PDF by merging the revisions of a PDF file and removes unused entries.
+    # * Optimizes the output PDF by merging the revisions of a PDF file and removes unused entries.
     #
     # See: HexaPDF::Task::Optimize
     class Modify < CmdParse::Command
 
+      InputSpec = Struct.new(:file, :pages, :password) #:nodoc:
+
       def initialize #:nodoc:
         super('modify', takes_commands: false)
         short_desc("Modify a PDF file")
         long_desc(<<-EOF.gsub!(/^ */, ''))
-          This command modifies a PDF file. It can be used to encrypt/decrypt a file, to optimize it
-          and remove unused entries and to generate or delete object and cross-reference streams.
+          This command modifies a PDF file. It can be used to select pages that should appear in
+          the output file and to add pages from other PDF files. The output file can be
+          encrypted/decrypted and optimized in various ways.
+
+          The first input file is the primary file which gets modified, so meta data like file
+          information, outlines, etc. are taken from it. Alternatively, it is possible to start
+          with an empty PDF file by using --empty. The order of the options specifying the files
+          is important as they are used in that order.
+
+          Also note that the --password and --pages options apply to the last preceeding input file.
         EOF
 
-        options.on("--password PASSWORD", "-p", String,
-                   "The password for decryption. Use - for reading from standard input.") do |pwd|
-          @password = (pwd == '-' ? command_parser.read_password("Input file password") : pwd)
+        options.separator("")
+        options.separator("Input file(s) related options")
+        options.on("-f", "--file FILE", "Input file, can be specified multiple times") do |file|
+          @files << InputSpec.new(file, '1-e')
+        end
+        options.on("-p", "--password PASSWORD", String, "The password for decrypting the last " \
+                   "specified input file (use - for reading from standard input)") do |pwd|
+          raise OptionParser::InvalidArgument, "(No prior input file specified)" if @files.empty?
+          pwd = (pwd == '-' ? command_parser.read_password("#{@files.last.file} password") : pwd)
+          @files.last.password = pwd
         end
-        options.on("--pages PAGES", "The pages to be used in the output file") do |pages|
-          @pages = pages
+        options.on("-i", "--pages PAGES", "The pages of the last specified input file that " \
+                   "should be used (default: 1-e)") do |pages|
+          raise OptionParser::InvalidArgument, "(No prior input file specified)" if @files.empty?
+          @files.last.pages = pages
         end
+        options.on("-e", "--empty", "Use an empty file as the first input file") do
+          @initial_empty = true
+        end
+        options.on("--[no-]interleave", "Interleave the pages from the input files (default: " \
+                   "false)") do |c|
+          @interleave = c
+        end
+
+        options.separator("")
+        options.separator("Output file related options")
         options.on("--embed FILE", String, "Embed the file into the output file (can be used " \
                    "multiple times)") do |file|
           @embed_files << file
@@ -83,9 +113,10 @@ module HexaPDF
                    "preserve)") do |streams|
           @streams = streams
         end
-
-        options.separator("")
-        options.separator("Encryption related options")
+        options.on("--[no-]compress-pages", "Recompress page content streams (may take a long " \
+                   "time; default: no)") do |c|
+          @compress_pages = c
+        end
         options.on("--decrypt", "Remove any encryption") do
           @encryption = :remove
         end
@@ -93,12 +124,12 @@ module HexaPDF
           @encryption = :add
         end
         options.on("--owner-password PASSWORD", String, "The owner password to be set on the " \
-                   "output file. Use - for reading from standard input.") do |pwd|
+                   "output file (use - for reading from standard input)") do |pwd|
           @encryption = :add
           @enc_owner_pwd = (pwd == '-' ? command_parser.read_password("Owner password") : pwd)
         end
         options.on("--user-password PASSWORD", String, "The user password to be set on the " \
-                   "output file. Use - for reading from standard input.") do |pwd|
+                   "output file (use - for reading from standard input)") do |pwd|
           @encryption = :add
           @enc_user_pwd = (pwd == '-' ? command_parser.read_password("User password") : pwd)
         end
@@ -121,19 +152,23 @@ module HexaPDF
         options.on("--permissions PERMS", Array,
                    "Comma separated list of permissions to be set on the output file. Possible " \
                    "values: #{syms.join(', ')}") do |perms|
-          perms.each do |perm|
-            unless syms.include?(perm)
+          perms.map! do |perm|
+            unless syms.include?(perm.to_sym)
               raise OptionParser::InvalidArgument, "#{perm} (invalid permission name)"
             end
+            perm.to_sym
           end
           @encryption = :add
           @enc_permissions = perms
         end
 
-        @password = nil
-        @pages = '1-e'
+        @files = []
+        @initial_empty = false
+        @interleave = false
+
         @embed_files = []
         @compact = true
+        @compress_pages = false
         @object_streams = :preserve
         @xref_streams = :preserve
         @streams = :preserve
@@ -146,58 +181,123 @@ module HexaPDF
         @enc_permissions = []
       end
 
-      def execute(input_file, output_file) #:nodoc:
-        @compact = true unless @pages == '1-e'
-        if @enc_user_pwd && !@enc_user_pwd.empty? && (!@enc_owner_pwd || @enc_owner_pwd.empty?)
-          @enc_owner_pwd = @enc_user_pwd
+      def execute(output_file) #:nodoc:
+        if !@initial_empty && @files.empty?
+          error = OptionParser::ParseError.new("At least one --file FILE or --empty is needed")
+          error.reason = "Missing argument"
+          raise error
         end
 
-        HexaPDF::Document.open(input_file, decryption_opts: {password: @password}) do |doc|
-          arrange_pages(doc) unless @pages == '1-e'
-          @embed_files.each {|file|  doc.utils.add_file(file, embed: true)}
-
-          doc.task(:optimize, compact: @compact, object_streams: @object_streams,
-                   xref_streams: @xref_streams)
+        # Create PDF documents for each input file
+        cache = {}
+        @files.each do |spec|
+          cache[spec.file] ||= HexaPDF::Document.new(io: File.open(spec.file),
+                                                     decryption_opts: {password: spec.password})
+          spec.file = cache[spec.file]
+        end
 
-          handle_streams(doc) if @streams != :preserve
+        # Assemble pages
+        target = (@initial_empty ? HexaPDF::Document.new : @files.first.file)
+        page_tree = target.add(Type: :Pages)
+        import_pages(page_tree)
+        target.catalog[:Pages] = page_tree
 
-          if @encryption == :add
-            doc.encrypt(algorithm: @enc_algorithm, key_length: @enc_key_length,
-                        force_V4: @enc_force_v4, permissions: @enc_permissions,
-                        owner_password: @enc_owner_pwd, user_password: @enc_user_pwd)
-          elsif @encryption == :remove
-            doc.encrypt(name: nil)
+        # Remove potentially imported but unused pages and page tree nodes
+        retained = target.pages.each_with_object({}) {|page, h| h[page.data] = true}
+        retained[target.pages.root.data] = true
+        target.each(current: false) do |obj|
+          next unless obj.kind_of?(HexaPDF::Dictionary)
+          if (obj.type == :Pages || obj.type == :Page) && !retained.key?(obj.data)
+            target.delete(obj)
           end
+        end
+
+        # Embed the given files
+        @embed_files.each {|file| target.files.add(file, embed: true)}
+
+        # Optimize the PDF file
+        target.task(:optimize, compact: @compact, object_streams: @object_streams,
+                    xref_streams: @xref_streams, compress_pages: @compress_pages)
 
-          doc.write(output_file)
+        # Update stream filters
+        handle_streams(target) unless @streams == :preserve
+
+        # Encrypt, decrypt or do nothing
+        if @encryption == :add
+          target.encrypt(algorithm: @enc_algorithm, key_length: @enc_key_length,
+                         force_V4: @enc_force_v4, permissions: @enc_permissions,
+                         owner_password: @enc_owner_pwd, user_password: @enc_user_pwd)
+        elsif @encryption == :remove
+          target.encrypt(name: nil)
         end
+
+        target.write(output_file)
       rescue HexaPDF::Error => e
-        $stderr.puts "Error while processing the PDF file: #{e.message}"
+        $stderr.puts "Processing error : #{e.message}"
         exit(1)
       end
 
+      def usage_arguments #:nodoc:
+        "{--file IN_FILE | --empty} OUT_FILE"
+      end
+
       private
 
-      # Arranges the pages of the document as specified with the --pages option.
-      def arrange_pages(doc)
-        pages = command_parser.parse_pages_specification(@pages, doc.pages.page_count)
-        new_page_tree = doc.add(Type: :Pages)
-        pages.each do |index, rotation|
-          page = doc.pages.page(index)
-          page.value.update(page.copy_inherited_values)
-          if rotation == :none
-            page.delete(:Rotate)
-          else
-            page[:Rotate] = ((page[:Rotate] || 0) + rotation) % 360
+      # Imports the pages of the document as specified with the --pages option to the given page
+      # tree.
+      def import_pages(page_tree)
+        @files.each do |s|
+          page_list = s.file.pages.to_a
+          s.pages = command_parser.parse_pages_specification(s.pages, s.file.pages.count)
+          s.pages.each do |arr|
+            arr[0] = page_list[arr[0]]
+            arr[1] = arr[0].value[:Rotate] || :none unless arr[1]
+          end
+        end
+
+        if @interleave
+          max_pages_per_file = 0
+          all = @files.each_with_index.map do |spec, findex|
+            list = []
+            spec.pages.each {|index, rotation| list << [spec.file, findex, index, rotation]}
+            max_pages_per_file = list.size if list.size > max_pages_per_file
+            list
           end
-          new_page_tree.add_page(page)
+          first, *rest = *all
+          first[max_pages_per_file - 1] ||= nil
+          first.zip(*rest) do |slice|
+            slice.each do |source, findex, page, rotation|
+              next unless source
+              import_page(page_tree, findex, page, rotation)
+            end
+          end
+        else
+          @files.each_with_index do |s, findex|
+            s.pages.each {|page, rotation| import_page(page_tree, findex, page, rotation)}
+          end
+        end
+      end
+
+      # Import the page with the given +rotation+ into the page tree.
+      def import_page(page_tree, source_index, page, rotation)
+        if page_tree.document == page.document
+          page.value.update(page.copy_inherited_values)
+          page = page.deep_copy unless source_index == 0
+        else
+          page = page_tree.document.import(page).deep_copy
+        end
+        if rotation == :none
+          page.delete(:Rotate)
+        elsif rotation.kind_of?(Integer)
+          page[:Rotate] = ((page[:Rotate] || 0) + rotation) % 360
         end
-        doc.catalog[:Pages] = new_page_tree
+        page_tree.document.add(page)
+        page_tree.add_page(page)
       end
 
       IGNORED_FILTERS = { #:nodoc:
         CCITTFaxDecode: true, JBIG2Decode: true, DCTDecode: true, JPXDecode: true, Crypt: true
-      }
+      }.freeze
 
       # Applies the chosen stream mode to all streams.
       def handle_streams(doc)