hexapdf 0.2.0 → 0.3.0

data/lib/hexapdf/cli/modify.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2016 Thomas Leitner
+# Copyright (C) 2014-2017 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
@@ -32,284 +32,81 @@
 #++
 
 require 'ostruct'
-require 'hexapdf/cli'
+require 'hexapdf/cli/command'
 
 module HexaPDF
   module CLI
 
     # Modifies a 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 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:
+    class Modify < Command
 
       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 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.
+          the output file and/or rotate them. The output file can also be encrypted/decrypted and
+          optimized in various ways.
         EOF
 
-        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("-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
-        end
-        options.on("--[no-]compact", "Delete unnecessary PDF objects (default: yes)") do |c|
-          @compact = c
-        end
-        options.on("--object-streams MODE", [:generate, :preserve, :delete],
-                   "Handling of object streams (either generate, preserve or delete; " \
-                   "default: preserve)") do |os|
-          @object_streams = os
-        end
-        options.on("--xref-streams MODE", [:generate, :preserve, :delete],
-                   "Handling of cross-reference streams (either generate, preserve or delete; " \
-                   "default: preserve)") do |x|
-          @xref_streams = x
-        end
-        options.on("--streams MODE", [:compress, :preserve, :uncompress],
-                   "Handling of stream data (either compress, preserve or uncompress; default: " \
-                   "preserve)") do |streams|
-          @streams = streams
-        end
-        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
-        options.on("--encrypt", "Encrypt the output file") do
-          @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|
-          @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|
-          @encryption = :add
-          @enc_user_pwd = (pwd == '-' ? command_parser.read_password("User password") : pwd)
-        end
-        options.on("--algorithm ALGORITHM", [:aes, :arc4],
-                   "The encryption algorithm: aes or arc4 (default: aes)") do |a|
-          @encryption = :add
-          @enc_algorithm = a
-        end
-        options.on("--key-length BITS", Integer,
-                   "The encryption key length in bits (default: 128)") do |i|
-          @encryption = :add
-          @enc_key_length = i
-        end
-        options.on("--force-V4",
-                   "Force the use of encryption version 4 if key length=128 and algorithm=arc4") do
-          @encryption = :add
-          @enc_force_v4 = true
-        end
-        syms = HexaPDF::Encryption::StandardSecurityHandler::Permissions::SYMBOL_TO_PERMISSION.keys
-        options.on("--permissions PERMS", Array,
-                   "Comma separated list of permissions to be set on the output file. Possible " \
-                   "values: #{syms.join(', ')}") do |perms|
-          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
-
-        @files = []
-        @initial_empty = false
-        @interleave = false
-
+        @password = nil
+        @pages = '1-e'
         @embed_files = []
-        @compact = true
-        @compress_pages = false
-        @object_streams = :preserve
-        @xref_streams = :preserve
-        @streams = :preserve
 
-        @encryption = :preserve
-        @enc_user_pwd = @enc_owner_pwd = nil
-        @enc_key_length = 128
-        @enc_algorithm = :aes
-        @enc_force_v4 = false
-        @enc_permissions = []
-      end
-
-      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
+        options.on("--password PASSWORD", "-p", String,
+                   "The password for decryption. Use - for reading from standard input.") do |pwd|
+          @password = (pwd == '-' ? read_password : pwd)
         end
-
-        # 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]
+        options.on("-i", "--pages PAGES", "The pages of the input file that should be used " \
+                   "(default: 1-e)") do |pages|
+          @pages = pages
         end
-
-        # 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
-
-        # 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
+        options.on("-e", "--embed FILE", String, "Embed the file into the output file (can be " \
+                   "used multiple times)") do |file|
+          @embed_files << file
         end
+        define_optimization_options
+        define_encryption_options
+      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)
-
-        # 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)
+      def execute(in_file, out_file) #:nodoc:
+        maybe_raise_on_existing_file(out_file)
+        HexaPDF::Document.open(in_file, decryption_opts: {password: @password}) do |doc|
+          arrange_pages(doc) unless @pages == '1-e'
+          @embed_files.each {|file| doc.files.add(file, embed: true)}
+          apply_encryption_options(doc)
+          apply_optimization_options(doc)
+          doc.write(out_file)
         end
-
-        target.write(output_file)
       rescue HexaPDF::Error => e
         $stderr.puts "Processing error : #{e.message}"
         exit(1)
       end
 
-      def usage_arguments #:nodoc:
-        "{--file IN_FILE | --empty} OUT_FILE"
-      end
-
       private
 
-      # 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
-          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
+      # Arranges the pages of the document as specified with the --pages option.
+      def arrange_pages(doc)
+        all_pages = doc.pages.to_a
+        new_page_tree = doc.add(Type: :Pages)
+        parse_pages_specification(@pages, all_pages.length).each do |index, rotation|
+          page = all_pages[index]
           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
-        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)
-        doc.each(current: false) do |obj|
-          next if !obj.respond_to?(:set_filter) || obj[:Subtype] == :Image ||
-            Array(obj[:Filter]).any? {|f| IGNORED_FILTERS[f]}
-          if @streams == :compress
-            obj.set_filter(:FlateDecode)
+          if rotation == :none
+            page.delete(:Rotate)
           else
-            obj.set_filter(nil)
+            page[:Rotate] = ((page[:Rotate] || 0) + rotation) % 360
           end
+          new_page_tree.add_page(page)
         end
+        doc.delete(doc.catalog.delete(:Pages))
+        doc.catalog[:Pages] = new_page_tree
       end
 
     end

data/lib/hexapdf/cli/optimize.rb

@@ -0,0 +1,104 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2017 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/cli/command'
+
+module HexaPDF
+  module CLI
+
+    # Optimizes the size of a PDF file.
+    class Optimize < Command
+
+      def initialize #:nodoc:
+        super('optimize', takes_commands: false)
+        short_desc("Optimize the size of a PDF file")
+        long_desc(<<-EOF.gsub!(/^ */, ''))
+          This command uses several optimization strategies to reduce the file size of the PDF file.
+
+          By default, all strategies except page compression are used since page compression may
+          take a very long time without much benefit.
+        EOF
+
+        @password = nil
+        @out_options.compact = true
+        @out_options.xref_streams = :generate
+        @out_options.object_streams = :generate
+        @out_options.streams = :compress
+
+        options.on("--password PASSWORD", "-p", String,
+                   "The password for decryption. Use - for reading from standard input.") do |pwd|
+          @password = (pwd == '-' ? read_password : pwd)
+        end
+
+        options.separator("")
+        options.separator("Optimization options")
+        define_optimization_options
+      end
+
+      def execute(in_file, out_file) #:nodoc:
+        maybe_raise_on_existing_file(out_file)
+        HexaPDF::Document.open(in_file, decryption_opts: {password: @password}) do |doc|
+          optimize_page_tree(doc)
+          apply_optimization_options(doc)
+          doc.write(out_file)
+        end
+      rescue HexaPDF::Error => e
+        $stderr.puts "Processing error : #{e.message}"
+        exit(1)
+      end
+
+      private
+
+      # Optimizes the page tree by flattening it and deleting unsed objects.
+      def optimize_page_tree(doc)
+        page_tree = doc.add(Type: :Pages)
+        retained = {page_tree.data => true}
+        doc.pages.each do |page|
+          page.value.update(page.copy_inherited_values)
+          page_tree.add_page(page)
+          retained[page.data] = true
+        end
+        doc.catalog[:Pages] = page_tree
+
+        doc.each(current: false) do |obj|
+          next unless obj.kind_of?(HexaPDF::Dictionary)
+          if (obj.type == :Pages || obj.type == :Page) && !retained.key?(obj.data)
+            doc.delete(obj)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/configuration.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2016 Thomas Leitner
+# Copyright (C) 2014-2017 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

data/lib/hexapdf/content.rb

@@ -4,7 +4,7 @@
 # This file is part of HexaPDF.
 #
 # HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
-# Copyright (C) 2016 Thomas Leitner
+# Copyright (C) 2014-2017 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