hexapdf 0.3.0 → 0.4.0

data/lib/hexapdf/cli/files.rb

@@ -69,7 +69,7 @@ module HexaPDF
       end
 
       def execute(pdf) #:nodoc:
-        HexaPDF::Document.open(pdf, decryption_opts: {password: @password}) do |doc|
+        with_document(pdf, password: @password) do |doc|
           if @indices.empty?
             list_files(doc)
           else
@@ -103,7 +103,7 @@ module HexaPDF
         each_file(doc) do |obj, index|
           next unless @indices.include?(index + 1) || @indices.include?(0)
           maybe_raise_on_existing_file(obj.path)
-          puts "Extracting #{obj.path}..."
+          puts "Extracting #{obj.path}..." if command_parser.verbosity_info?
           File.open(obj.path, 'wb') do |file|
             fiber = obj.embedded_file_stream.stream_decoder
             while fiber.alive? && (data = fiber.resume)

data/lib/hexapdf/cli/images.rb

@@ -31,6 +31,7 @@
 # is created or manipulated using HexaPDF.
 #++
 
+require 'set'
 require 'hexapdf/cli/command'
 
 module HexaPDF
@@ -77,7 +78,7 @@ module HexaPDF
       end
 
       def execute(pdf) #:nodoc:
-        HexaPDF::Document.open(pdf, decryption_opts: {password: @password}) do |doc|
+        with_document(pdf, password: @password) do |doc|
           if @indices.empty?
             list_images(doc)
           else
@@ -106,12 +107,19 @@ module HexaPDF
 
       # Extracts the images with the given indices.
       def extract_images(doc)
+        done = Set.new
         each_image(doc) do |image, index, _|
-          next unless @indices.include?(index) || @indices.include?(0)
-          path = "#{@prefix}-#{index}.#{image.info.extension}"
-          maybe_raise_on_existing_file(path)
-          puts "Extracting #{path}..."
-          image.write(path)
+          next unless (@indices.include?(index) || @indices.include?(0)) && !done.include?(index)
+          info = image.info
+          if info.writable
+            path = "#{@prefix}-#{index}.#{image.info.extension}"
+            maybe_raise_on_existing_file(path)
+            puts "Extracting #{path}..." if command_parser.verbosity_info?
+            image.write(path)
+            done << index
+          elsif command_parser.verbosity_warning?
+            $stderr.puts "Warning (image #{index}): PDF image format not supported for writing"
+          end
         end
       end
 

data/lib/hexapdf/cli/info.rb

@@ -73,9 +73,11 @@ module HexaPDF
       COLUMN_WIDTH = 20 #:nodoc:
 
       def output_info(file) # :nodoc:
-        options = {decryption_opts: {password: @password},
-                   config: {'document.auto_decrypt' => @auto_decrypt}}
+        options = pdf_options(@password)
+        options[:config]['document.auto_decrypt'] = @auto_decrypt
         HexaPDF::Document.open(file, options) do |doc|
+          output_line("File name", file)
+          output_line("File size", File.stat(file).size.to_s + " bytes")
           INFO_KEYS.each do |name|
             next unless doc.trailer.info.key?(name)
             output_line(name.to_s, doc.trailer.info[name].to_s)
@@ -98,17 +100,13 @@ module HexaPDF
           output_line("Pages", doc.pages.count.to_s)
           output_line("Version", doc.version)
         end
-      rescue HexaPDF::EncryptionError => e
+      rescue HexaPDF::EncryptionError
         if @auto_decrypt
           @auto_decrypt = false
           retry
         else
-          $stderr.puts "Error while decrypting the PDF file: #{e.message}"
-          exit(1)
+          raise
         end
-      rescue HexaPDF::Error => e
-        $stderr.puts "Error while processing the PDF file: #{e.message}"
-        exit(1)
       end
 
       def output_line(header, text) #:nodoc:

data/lib/hexapdf/cli/inspect.rb

@@ -94,12 +94,7 @@ module HexaPDF
       end
 
       def execute(file) #:nodoc:
-        HexaPDF::Document.open(file, decryption_opts: {password: @password}) do |doc|
-          send("do_#{@exec}", doc)
-        end
-      rescue HexaPDF::Error => e
-        $stderr.puts "Error while processing the PDF file: #{e.message}"
-        exit(1)
+        with_document(file, password: @password) {|doc| send("do_#{@exec}", doc)}
       end
 
       private
@@ -130,7 +125,9 @@ module HexaPDF
       def do_object(doc) #:nodoc:
         object = doc.object(pdf_reference_from_string(@param))
         return unless object
-        $stderr.puts("Note: Object also has stream data") if object.data.stream
+        if object.data.stream && command_parser.verbosity_info?
+          $stderr.puts("Note: Object also has stream data")
+        end
         puts HexaPDF::Serializer.new.serialize(object.value)
       end
 
@@ -141,7 +138,7 @@ module HexaPDF
           while source.alive? && (data = source.resume)
             $stdout.write(data)
           end
-        else
+        elsif command_parser.verbosity_info?
           $stderr.puts("Note: Object has no stream data")
         end
       end

data/lib/hexapdf/cli/merge.rb

@@ -105,8 +105,15 @@ module HexaPDF
         # 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})
+          cache[spec.file] ||=
+            begin
+              io = if spec.file == output_file
+                     StringIO.new(File.binread(spec.file))
+                   else
+                     File.open(spec.file)
+                   end
+              HexaPDF::Document.new(io: io, **pdf_options(spec.password))
+            end
           spec.file = cache[spec.file]
         end
 
@@ -115,24 +122,13 @@ module HexaPDF
         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
-        end
+        remove_unused_pages(target)
+        target.pages.add unless target.pages.count > 0
 
         apply_encryption_options(target)
         apply_optimization_options(target)
 
-        target.write(output_file)
-      rescue HexaPDF::Error => e
-        $stderr.puts "Processing error : #{e.message}"
-        exit(1)
+        write_document(target, output_file)
       end
 
       def usage #:nodoc:
@@ -148,10 +144,7 @@ module HexaPDF
         @files.each do |s|
           page_list = s.file.pages.to_a
           s.pages = 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
+          s.pages.each {|arr| arr[0] = page_list[arr[0]]}
         end
 
         if @interleave

data/lib/hexapdf/cli/modify.rb

@@ -77,16 +77,12 @@ module HexaPDF
 
       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|
+        with_document(in_file, password: @password, out_file: out_file) 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
-      rescue HexaPDF::Error => e
-        $stderr.puts "Processing error : #{e.message}"
-        exit(1)
       end
 
       private
@@ -100,13 +96,14 @@ module HexaPDF
           page.value.update(page.copy_inherited_values)
           if rotation == :none
             page.delete(:Rotate)
-          else
+          elsif rotation.kind_of?(Integer)
             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
+        remove_unused_pages(doc)
+        doc.pages.add unless doc.pages.count > 0
       end
 
     end

data/lib/hexapdf/cli/optimize.rb

@@ -54,6 +54,7 @@ module HexaPDF
         @out_options.xref_streams = :generate
         @out_options.object_streams = :generate
         @out_options.streams = :compress
+        @out_options.optimize_fonts = true
 
         options.on("--password PASSWORD", "-p", String,
                    "The password for decryption. Use - for reading from standard input.") do |pwd|
@@ -67,14 +68,10 @@ module HexaPDF
 
       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|
+        with_document(in_file, password: @password, out_file: out_file) 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

data/lib/hexapdf/configuration.rb

@@ -92,13 +92,13 @@ module HexaPDF
     end
 
     # :call-seq:
-    #   config.constantize(name, key = nil)                  -> constant or nil
+    #   config.constantize(name, key = nil)                  -> constant
     #   config.constantize(name, key = nil) {|name| block}   -> obj
     #
     # Returns the constant the option +name+ is referring to. If +key+ is provided and the value
     # of the option +name+ responds to \#[], the constant to which +key+ refers is returned.
     #
-    # If no constant can be found and no block is provided, +nil+ is returned. If a block is
+    # If no constant can be found and no block is provided, an error is raised. If a block is
     # provided it is called with the option name and its result will be returned.
     #
     #   config.constantize('encryption.aes')      #=> HexaPDF::Encryption::FastAES
@@ -107,7 +107,12 @@ module HexaPDF
       data = self[name]
       data = data[key] if key != :__unset && data.respond_to?(:[])
       (data = ::Object.const_get(data) rescue nil) if data.kind_of?(String)
-      data = yield(name) if block_given? && data.nil?
+      if data.nil? && block_given?
+        data = yield(name)
+      elsif data.nil?
+        raise HexaPDF::Error, "Error getting constant for configuration option '#{name}'" <<
+          (key == :__unset ? "" : " and key '#{key}'")
+      end
       data
     end
 
@@ -160,6 +165,15 @@ module HexaPDF
   #
   #    The default implementation raises an error.
   #
+  # font.on_missing_unicode_mapping::
+  #    Callback hook when a character code point cannot be converted to a Unicode character.
+  #
+  #    The value needs to be an object that responds to \#call(code, font_dict) where +code+ is the
+  #    decoded code point and +font_dict+ is the font dictionary which was used for the conversion.
+  #    The returned value is used as the Unicode character and should be a string.
+  #
+  #    The default implementation raises an error.
+  #
   # font_loader::
   #    An array with font loader implementations. When a font should be loaded, the array is
   #    iterated in sequence and the first valid font returned by a font loader is used.
@@ -222,6 +236,10 @@ module HexaPDF
                       'font.on_missing_glyph' => proc do |n, f|
                         raise HexaPDF::Error, "No glyph for '#{n}' in font #{f.font_name} found"
                       end,
+                      'font.on_missing_unicode_mapping' => proc do |code_point, font|
+                        raise HexaPDF::Error, "No Unicode mapping for code point #{code_point} " \
+                          "in font #{font[:BaseFont]}"
+                      end,
                       'font_loader' => [
                         'HexaPDF::FontLoader::Standard14',
                         'HexaPDF::FontLoader::FromConfiguration',
@@ -283,6 +301,13 @@ module HexaPDF
   #    Specifies the compression level that should be used with the FlateDecode filter. The level
   #    can range from 0 (no compression), 1 (best speed) to 9 (best compression, default).
   #
+  # filter.flate_memory::
+  #    Specifies the memory level that should be used with the FlateDecode filter. The level can
+  #    range from 1 (minimum memory usage; slow, reduces compression) to 9 (maximum memory usage).
+  #
+  #    The HexaPDF default value of 6 has been found in tests to be nearly equivalent to the Zlib
+  #    default of 8 in terms of speed and compression level but uses less memory.
+  #
   # filter.map::
   #    A mapping from a PDF name (a Symbol) to a filter object (see Filter). If the value is a
   #    String, it should contain the name of a constant that contains a filter object.
@@ -328,6 +353,7 @@ module HexaPDF
                       'encryption.sub_filter_map' => {
                       },
                       'filter.flate_compression' => 9,
+                      'filter.flate_memory' => 6,
                       'filter.map' => {
                         ASCIIHexDecode: 'HexaPDF::Filter::ASCIIHexDecode',
                         AHx: 'HexaPDF::Filter::ASCIIHexDecode',
@@ -381,8 +407,11 @@ module HexaPDF
                       'object.subtype_map' => {
                         Image: 'HexaPDF::Type::Image',
                         Form: 'HexaPDF::Type::Form',
+                        Type0: 'HexaPDF::Type::FontType0',
                         Type1: 'HexaPDF::Type::FontType1',
                         TrueType: 'HexaPDF::Type::FontTrueType',
+                        CIDFontType0: 'HexaPDF::Type::CIDFont',
+                        CIDFontType2: 'HexaPDF::Type::CIDFont',
                       },
                       'task.map' => {
                         optimize: 'HexaPDF::Task::Optimize',

data/lib/hexapdf/content/canvas.rb

@@ -35,6 +35,7 @@ require 'hexapdf/content/graphics_state'
 require 'hexapdf/content/operator'
 require 'hexapdf/serializer'
 require 'hexapdf/utils/math_helpers'
+require 'hexapdf/utils/graphics_helpers'
 require 'hexapdf/content/graphic_object'
 require 'hexapdf/stream'
 
@@ -132,6 +133,7 @@ module HexaPDF
     class Canvas
 
       include HexaPDF::Utils::MathHelpers
+      include HexaPDF::Utils::GraphicsHelpers
 
       # The context for which the canvas was created (a HexaPDF::Type::Page or HexaPDF::Type::Form
       # object).
@@ -1693,7 +1695,7 @@ module HexaPDF
       #
       # Low-level method for actually showing text on the canvas.
       #
-      # The argument +data+ needs to be a an array of glyph objects valid for the current font,
+      # The argument +glyphs+ needs to be a an array of glyph objects valid for the current font,
       # optionally interspersed with numbers for kerning.
       #
       # Text is always shown at the current position of the text cursor, i.e. the origin of the text
@@ -1702,13 +1704,13 @@ module HexaPDF
       #
       # The text matrix is updated to correctly represent the graphics state after the invocation.
       #
-      # This method is usually not invoked directly but by higher level methods like #show_text.
-      def show_glyphs(data)
+      # This method is usually not invoked directly but by higher level methods like #text.
+      def show_glyphs(glyphs)
         begin_text
 
         result = [''.b]
         offset = 0
-        data.each do |item|
+        glyphs.each do |item|
           if item.kind_of?(Numeric)
             result << item << ''.b
             offset -= item * graphics_state.scaled_font_size
@@ -1718,7 +1720,7 @@ module HexaPDF
 
             offset += item.width * graphics_state.scaled_font_size +
               graphics_state.scaled_character_spacing
-            offset += graphics_state.scaled_word_spacing if encoded.length == 1 && item.space?
+            offset += graphics_state.scaled_word_spacing if encoded == " ".freeze
           end
         end
 
@@ -1727,6 +1729,124 @@ module HexaPDF
         self
       end
 
+      # :call-seq:
+      #   canvas.show_glyphs_only(glyphs)      -> canvas
+      #
+      # Same operation as with #show_glyphs but without updating the text matrix.
+      #
+      # This method should only be used by advanced text layouting algorithms which perform the
+      # necessary calculations themselves!
+      #
+      # *Warning*: Since this method doesn't update the text matrix, all following results from
+      # #text_cursor and other methods using the current text matrix are invalid until the next call
+      # to #text_matrix or #end_text.
+      def show_glyphs_only(glyphs)
+        begin_text
+
+        result = [''.b]
+        glyphs.each do |item|
+          if item.kind_of?(Numeric)
+            result << item << ''.b
+          else
+            result[-1] << @font.encode(item)
+          end
+        end
+
+        serialize1(:TJ, result)
+        self
+      end
+
+      # :call-seq:
+      #   canvas.marked_content_point(tag, property_list: nil)     -> canvas
+      #
+      # Inserts a marked-content point, optionally associated with a property list.
+      #
+      # A marked-content point is used to identify a position in the content stream for later use by
+      # other applications. The symbol +tag+ is used to uniquely identify the role of the
+      # marked-content point and should be registered with ISO to avoid conflicts.
+      #
+      # The optional +property_list+ argument can either be a valid PDF dictionary or a symbol
+      # referencing an already used property list in the resource dictionary's /Properties
+      # dictionary.
+      #
+      # Examples:
+      #
+      #   canvas.marked_content_point(:Divider)
+      #   canvas.marked_content_point(:Divider, property_list: {Key: 'value'})
+      #
+      # See: PDF1.7 s14.6
+      def marked_content_point(tag, property_list: nil)
+        raise_unless_at_page_description_level_or_in_text
+        if property_list
+          property_list = resources.property_list(property_list) if property_list.kind_of?(Symbol)
+          invoke2(:DP, tag, resources.add_property_list(property_list))
+        else
+          invoke1(:MP, tag)
+        end
+        self
+      end
+
+      # :call-seq:
+      #   canvas.marked_content_sequence(tag, property_list: nil)               -> canvas
+      #   canvas.marked_content_sequence(tag, property_list: nil) { block }     -> canvas
+      #
+      # Inserts a marked-content sequence, optionally associated with a property list.
+      #
+      # A marked-content sequence is used to identify a sequence of complete graphics objects in the
+      # content stream for later use by other applications. The symbol +tag+ is used to uniquely
+      # identify the role of the marked-content sequence and should be registered with ISO to avoid
+      # conflicts.
+      #
+      # The optional +property_list+ argument can either be a valid PDF dictionary or a symbol
+      # referencing an already used property list in the resource dictionary's /Properties
+      # dictionary.
+      #
+      # If invoked without a block, a corresponding call to #end_marked_content_sequence must be
+      # done. Otherwise the marked-content sequence automatically ends when the block is finished.
+      #
+      # Although the PDF specification would allow using marked-content sequences inside text
+      # objects, this is prohibited.
+      #
+      # Examples:
+      #
+      #   canvas.marked_content_sequence(:Divider)
+      #   # Other instructions
+      #   canvas.end_marked_content_sequence
+      #
+      #   canvas.marked_content_sequence(:Divider, property_list: {Key: 'value'}) do
+      #     # Other instructions
+      #   end
+      #
+      # See: PDF1.7 s14.6, #end_marked_content_sequence
+      def marked_content_sequence(tag, property_list: nil)
+        raise_unless_at_page_description_level
+        if property_list
+          property_list = resources.property_list(property_list) if property_list.kind_of?(Symbol)
+          invoke2(:BDC, tag, resources.add_property_list(property_list))
+        else
+          invoke1(:BMC, tag)
+        end
+        if block_given?
+          yield
+          end_marked_content_sequence
+        end
+        self
+      end
+
+      # :call-seq:
+      #   canvas.end_marked_content_sequence       -> canvas
+      #
+      # Ends a marked-content sequence.
+      #
+      # See #marked_content_sequence for details.
+      #
+      # See: PDF1.7 s14.6, #marked_content_sequence
+      def end_marked_content_sequence
+        raise_unless_at_page_description_level
+        invoke0(:EMC)
+        self
+      end
+
       private
 
       # Invokes the given operator with the operands and serializes it.
@@ -1752,6 +1872,11 @@ module HexaPDF
         @contents << @operators[operator].serialize(@serializer, op1)
       end
 
+      # Optimized method for one operand.
+      def serialize1(operator, op1)
+        @contents << @operators[operator].serialize(@serializer, op1)
+      end
+
       # Optimized method for two operands.
       def invoke2(operator, op1, op2)
         @operators[operator].invoke(self, op1, op2)
@@ -1936,38 +2061,6 @@ module HexaPDF
         curve_to(p3[0], p3[1], p1: p1, p2: p2)
       end
 
-      # Given two points p0 = (x0, y0) and p1 = (x1, y1), returns the point on the line through
-      # these points that is +distance+ units away from p0.
-      #
-      #   v = p1 - p0
-      #   result = p0 + distance * v/norm(v)
-      def point_on_line(x0, y0, x1, y1, distance:)
-        norm = Math.sqrt((x1 - x0)**2 + (y1 - y0)**2)
-        [x0 + distance / norm * (x1 - x0), y0 + distance / norm * (y1 - y0)]
-      end
-
-      # Calculates and returns the requested dimensions for the rectangular object with the given
-      # +width+ and +height+ based on the options.
-      #
-      # +rwidth+::
-      #     The requested width. If +rheight+ is not specified, it is chosen so that the aspect
-      #     ratio is maintained
-      #
-      # +rheight+::
-      #     The requested height. If +rwidth+ is not specified, it is chosen so that the aspect
-      #     ratio is maintained
-      def calculate_dimensions(width, height, rwidth: nil, rheight: nil)
-        if rwidth && rheight
-          [rwidth, rheight]
-        elsif rwidth
-          [rwidth, height * rwidth / width.to_f]
-        elsif rheight
-          [width * rheight / height.to_f, rheight]
-        else
-          [width, height]
-        end
-      end
-
     end
 
   end