hexapdf 0.9.3 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1011a745720b76eaa963d0a54b6807e732fe6ecd3bcb029870309e42296bbe9
-  data.tar.gz: 0aed16b283825785a7039ebca11a61da853c7fb01e8d2fadc9e5d7a722e56754
+  metadata.gz: e7d800154c0525b724aa0b1a91e360aff2d443bd56e260b5b051a06d605cdb9c
+  data.tar.gz: d658fa5ff09f12a169156ee091f66b189874ae4b847cb4effa8d2c60b5f836b1
 SHA512:
-  metadata.gz: 70bee8b172f67ab59559ec1b0d740d767dad0db0a5d30476bdbfd71f80f443b31fc8b98bfd62a6d632411c246aa04af9c4203c443f4affc7b0307694bd5b725b
-  data.tar.gz: 04002b0d6728a37c499c1453a4068161b6c3c2631e318981559e52207681ae268de39b6a5b9127b39ee009be079c06e8ea761c2633d1f586efb0294a923e7a61
+  metadata.gz: b600fb0c600a0093e08d5ed3a4d16c2bfee637b0d338783c663f664aa7b4eb5384b20f064137c26d83f4269ed213b5d46c390421946d747f16be9d7e5600f381
+  data.tar.gz: 31f7c75f80db9b467f0fe8582616a9d136b9da86995cd6c57c76678a4e916fef0e73a4ad22ef53d8e8c36ce7ab620e303d6d05268d3ce6d551bbc33b67c7f959

data/CHANGELOG.md

@@ -1,3 +1,38 @@
+## 0.10.0 - 2019-10-02
+
+### Added
+
+* [HexaPDF::Reference#to_s] to return the serialized form of the PDF reference
+* [HexaPDF::Revision#xref] for getting cross-reference entries
+* HexaPDF::XRefSection::Entry#to_s to return a description of the
+  cross-reference entry
+
+### Changed
+
+* Enhanced the `hexapdf images` command to also show information on PPI (pixels
+  per inch) and size
+* Completely revamped the `hexapdf inspect` command with an interactive mode,
+  structure output, cross-reference entry output and object search
+* Output of validation problem messages for `hexapdf` command to include more
+  information
+* The Validation feature to automatically correct String-for-Symbol and
+  Symbol-for-String problems
+
+### Fixed
+
+* [HexaPDF::Document#wrap] to better handle subtype mappings in case of unknown
+  type information
+* [HexaPDF::DictionaryFields::DictionaryConverter] to not allow conversion to a
+  [HexaPDF::Stream] subclass from objects without stream data
+* Import of JPEG images with YCCK color encoding
+* Export of images without `/FlateDecode` filter or `/DecodeParms` to PNG files
+* Mistyped name of field type for field `/Popup` of
+  [HexaPDF::Type::Annotations::MarkupAnnotation]
+* Loading and saving of encrypted and signed PDFs
+* CLI commands that optimize font data structures won't crash when encountering
+  invalid font objects
+
+
 ## 0.9.3 - 2019-06-13
 
 ### Changed

data/CONTRIBUTERS

@@ -1,4 +1,5 @@
   Count Name
 ======= ====
-   1041 Thomas Leitner <t_leitner@gmx.at>
+   1069 Thomas Leitner <t_leitner@gmx.at>
+      1 Stanislav (Stas) Katkov <sk@skylup.com>
       1 Daniel Kraus <bovender@bovender.de>

data/VERSION

@@ -1 +1 @@
-0.9.3
+0.10.0

data/lib/hexapdf/cli/command.rb

@@ -120,7 +120,7 @@ module HexaPDF
         if out_file
           doc.validate(auto_correct: true) do |object, msg, correctable|
             if command_parser.strict && !correctable
-              raise "Validation error: #{msg}"
+              raise "Validation error for object (#{object.oid},#{object.gen}): #{msg}"
             elsif command_parser.verbosity_info?
               $stderr.puts "#{correctable ? 'Corrected' : 'Ignored'} validation problem " \
                 "for object (#{object.oid},#{object.gen}): #{msg}"
@@ -247,7 +247,7 @@ module HexaPDF
       # Applies the chosen stream mode to the given object.
       def optimize_stream(obj)
         return if @out_options.streams == :preserve || !obj.respond_to?(:set_filter) ||
-            Array(obj[:Filter]).any? {|f| IGNORED_FILTERS[f] }
+          Array(obj[:Filter]).any? {|f| IGNORED_FILTERS[f] }
 
         obj.set_filter(@out_options.streams == :compress ? :FlateDecode : nil)
       end
@@ -255,14 +255,18 @@ module HexaPDF
       # Optimize the object if it is a font object.
       def optimize_font(obj)
         return unless @out_options.optimize_fonts && obj.kind_of?(HexaPDF::Type::Font) &&
-            (obj[:Subtype] == :TrueType ||
-             (obj[:Subtype] == :Type0 && obj.descendant_font[:Subtype] == :CIDFontType2)) &&
-            obj.embedded?
+          (obj[:Subtype] == :TrueType ||
+           (obj[:Subtype] == :Type0 && obj.descendant_font[:Subtype] == :CIDFontType2)) &&
+          obj.embedded?
 
         font = HexaPDF::Font::TrueType::Font.new(StringIO.new(obj.font_file.stream))
         data = HexaPDF::Font::TrueType::Optimizer.build_for_pdf(font)
         obj.font_file.stream = data
         obj.font_file[:Length1] = data.size
+      rescue StandardError => e
+        if command_parser.verbosity_info?
+          $stderr.puts "Error optimizing font object (#{obj.oid},#{obj.gen}): #{e.message}"
+        end
       end
 
       # Applies the encryption related options to the given HexaPDF::Document instance.

data/lib/hexapdf/cli/images.rb

@@ -45,6 +45,41 @@ module HexaPDF
     # See: HexaPDF::Type::Image
     class Images < Command
 
+      # Extracts the PPI (pixel per inch) information for each image of a content stream.
+      class ImageLocationProcessor < HexaPDF::Content::Processor
+
+        # The mapping of XObject name to [x_ppi, y_ppi].
+        attr_reader :result
+
+        # Initialize the processor with the names of the images for which the PPI should be
+        # determined.
+        def initialize(names, user_unit)
+          super()
+          @names = names
+          @user_unit = user_unit
+          @result = {}
+        end
+
+        # Determine the PPI in x- and y-directions of the specified images.
+        def paint_xobject(name)
+          super
+          return unless @names.delete(name)
+          xobject = resources.xobject(name)
+          return unless xobject[:Subtype] == :Image
+
+          w, h = xobject.width, xobject.height
+          llx, lly = graphics_state.ctm.evaluate(0, 0).map {|i| i * @user_unit }
+          lrx, lry = graphics_state.ctm.evaluate(1, 0).map {|i| i * @user_unit }
+          ulx, uly = graphics_state.ctm.evaluate(0, 1).map {|i| i * @user_unit }
+
+          x_ppi = 72.0 * w / Math.sqrt((lrx - llx)**2 + (lry - lly)**2)
+          y_ppi = 72.0 * h / Math.sqrt((ulx - llx)**2 + (uly - lly)**2)
+          @result[name] = [x_ppi.round, y_ppi.round]
+          raise StopIteration if @names.empty?
+        end
+
+      end
+
       def initialize #:nodoc:
         super('images', takes_commands: false)
         short_desc("List or extract images from a PDF file")
@@ -94,16 +129,17 @@ module HexaPDF
 
       # Outputs a table with the images of the PDF document.
       def list_images(doc)
-        printf("%5s %5s %9s %6s %6s %5s %4s %3s %5s %8s\n",
-               "index", "page", "oid", "width", "height", "color", "comp", "bpc", "type",
-               "writable")
-        puts("-" * 65)
-        each_image(doc) do |image, index, pindex|
+        printf("%5s %5s %9s %6s %6s %5s %4s %3s %5s %5s %6s %5s %8s\n",
+               "index", "page", "oid", "width", "height", "color", "comp", "bpc",
+               "x-ppi", "y-ppi", "size", "type", "writable")
+        puts("-" * 77)
+        each_image(doc) do |image, index, pindex, (x_ppi, y_ppi)|
           info = image.info
-          printf("%5i %5s %9s %6i %6i %5s %4i %3i %5s %8s\n",
+          size = human_readable_file_size(image[:Length] + image[:SMask]&.[](:Length).to_i)
+          printf("%5i %5s %9s %6i %6i %5s %4i %3i %5s %5s %6s %5s %8s\n",
                  index, pindex || '-', "#{image.oid},#{image.gen}", info.width, info.height,
-                 info.color_space, info.components, info.bits_per_component, info.type,
-                 info.writable)
+                 info.color_space, info.components, info.bits_per_component, x_ppi, y_ppi,
+                 size, info.type, info.writable)
         end
       end
 
@@ -131,11 +167,21 @@ module HexaPDF
         seen = {}
 
         doc.pages.each_with_index do |page, pindex|
-          page.resources[:XObject]&.each do |_name, xobject|
+          image_names = []
+          xobjects = page.resources[:XObject]
+
+          xobjects&.each&.map do |name, xobject|
+            image_names << name if xobject[:Subtype] == :Image && !xobject[:ImageMask]
+          end
+
+          processor = ImageLocationProcessor.new(image_names, page[:UserUnit] || 1)
+          page.process_contents(processor)
+          processor.result.each do |name, ppi|
+            xobject = xobjects[name]
             if seen[xobject]
-              yield(xobject, seen[xobject], pindex + 1)
-            elsif xobject[:Subtype] == :Image && !xobject[:ImageMask]
-              yield(xobject, index, pindex + 1)
+              yield(xobject, seen[xobject], pindex + 1, ppi)
+            else
+              yield(xobject, index, pindex + 1, ppi)
               seen[xobject] = index
               index += 1
             end
@@ -145,12 +191,21 @@ module HexaPDF
         if @search
           doc.images.each do |image|
             next if seen[image]
-            yield(image, index, nil)
+            yield(image, index, nil, nil)
             index += 1
           end
         end
       end
 
+      # Returns the human readable file size.
+      def human_readable_file_size(size)
+        case size
+        when 0..9999 then "#{size}B"
+        when 10_000..999_999 then "#{(size / 1024.to_f).round(1)}K"
+        else "#{(size.to_f / 1024 / 1024).round(1)}M"
+        end
+      end
+
     end
 
   end

data/lib/hexapdf/cli/inspect.rb

@@ -50,98 +50,148 @@ module HexaPDF
           needs to inspect the internal object structure or a stream of a PDF file. A PDF object is
           always shown in the PDF syntax.
 
-          If no option is given, the PDF trailer is shown. Otherwise the various, mutually exclusive
-          display options define the shown content. If multiple such options are specified only the
-          last is respected.
-        EOF
+          If no arguments are given, the interactive mode is started. Otherwise the arguments are
+          interpreted as interactive mode commands and executed. It is possible to specify more than
+          one command in this way by separating them with semicolons, or whitespace in case the
+          number of command arguments is fixed.
 
-        options.on("--catalog", "Show the PDF catalog dictionary.") do
-          @exec = :catalog
-        end
-        options.on("-c", "--page-count", "Print the number of pages.") do
-          @exec = :page_count
-        end
-        options.on("--pages [PAGES]", "Show the pages with their object and generation numbers " \
-                   "and their associated content streams. If the optional argument PAGES is " \
-                   "specified, only the specified pages are listed.") do |range|
-          @exec = :pages
-          @param = range || '1-e'
-        end
-        options.on("-o", "--object OID[,GEN]", "Show the object with the given object and " \
-                   "generation numbers. The generation number defaults to 0 if not given.") do |str|
-          @exec = :object
-          @param = str
-        end
-        options.on("-s", "--stream OID[,GEN]", "Show the filtered stream data (add --raw to get " \
-                   "the raw stream data) of the object with the given object and generation " \
-                   "numbers. The generation number defaults to 0 if not given.") do |str|
-          @exec = :stream
-          @param = str
-        end
-        options.on("--raw", "Modifies --stream to show the raw stream data instead of the " \
-                   "filtered one.") do
-          @raw = true
-        end
+        EOF
 
-        options.separator("")
         options.on("--password PASSWORD", "-p", String,
                    "The password for decryption. Use - for reading from standard input.") do |pwd|
           @password = (pwd == '-' ? read_password : pwd)
         end
 
         @password = nil
-        @exec = :trailer
-        @param = nil
-        @raw = nil
+        @serializer = HexaPDF::Serializer.new
       end
 
-      def execute(file) #:nodoc:
-        with_document(file, password: @password) {|doc| send("do_#{@exec}", doc) }
+      def execute(file, *commands) #:nodoc:
+        with_document(file, password: @password) do |doc|
+          @doc = doc
+          if commands.empty?
+            while true
+              print "cmd> "
+              input = $stdin.gets
+              (puts; break) unless input
+              commands = input.scan(/(["'])(.+?)\1|(\S+)/).map {|a| a[1] || a[2] }
+              break if execute_commands(commands)
+            end
+          else
+            execute_commands(commands)
+          end
+        end
       end
 
       private
 
-      def do_catalog(doc) #:nodoc:
-        puts HexaPDF::Serializer.new.serialize(doc.catalog)
-      end
+      def execute_commands(data) #:nodoc:
+        data.map! {|item| item == ";" ? nil : item }
+        until data.empty?
+          command = data.shift || next
+          case command
+          when /^\d+(,\d+)?$/, 'o', 'object'
+            arg = (command.start_with?('o') ? data.shift : command)
+            obj = pdf_object_from_string_reference(arg) rescue puts($!.message)
+            if obj.data.stream && command_parser.verbosity_info?
+              $stderr.puts("Note: Object also has stream data")
+            end
+            serialize(obj.value, recursive: false) if obj
 
-      def do_trailer(doc) #:nodoc:
-        puts HexaPDF::Serializer.new.serialize(doc.trailer)
-      end
+          when 'r', 'recursive'
+            obj = if (obj = data.shift)
+                    pdf_object_from_string_reference(obj) rescue puts($!.message)
+                  else
+                    @doc.trailer
+                  end
+            serialize(obj.value, recursive: true) if obj
 
-      def do_page_count(doc) #:nodoc:
-        puts doc.pages.count
-      end
+          when 's', 'stream', 'raw', 'raw-stream'
+            if (obj = pdf_object_from_string_reference(data.shift) rescue puts($!.message)) &&
+                obj.kind_of?(HexaPDF::Stream)
+              source = (command.start_with?('raw') ? obj.stream_source : obj.stream_decoder)
+              while source.alive? && (stream_data = source.resume)
+                $stdout.write(stream_data)
+              end
+            elsif command_parser.verbosity_info?
+              $stderr.puts("Note: Object has no stream data")
+            end
 
-      def do_pages(doc) #:nodoc:
-        pages = parse_pages_specification(@param, doc.pages.count)
-        page_list = doc.pages.to_a
-        pages.each do |index, _|
-          page = page_list[index]
-          str = +"page #{index + 1} (#{page.oid},#{page.gen}): "
-          str << Array(page[:Contents]).map {|c| "#{c.oid},#{c.gen}" }.join(" ")
-          puts str
-        end
-      end
+          when 'x', 'xref'
+            if (obj = pdf_object_from_string_reference(data.shift) rescue puts($!.message))
+              @doc.revisions.reverse_each do |rev|
+                if (xref = rev.xref(obj))
+                  puts xref
+                  break
+                end
+              end
+            end
+
+          when 'c', 'catalog'
+            serialize(@doc.catalog.value, recursive: false)
+
+          when 't', 'trailer'
+            serialize(@doc.trailer.value, recursive: false)
+
+          when 'p', 'pages'
+            begin
+              pages = parse_pages_specification(data.shift || '1-e', @doc.pages.count)
+            rescue StandardError
+              $stderr.puts("Error: Invalid page range argument")
+              next
+            end
+            page_list = @doc.pages.to_a
+            pages.each do |index, _|
+              page = page_list[index]
+              str = +"page #{index + 1} (#{page.oid},#{page.gen}): "
+              str << Array(page[:Contents]).map {|c| "#{c.oid},#{c.gen}" }.join(" ")
+              puts str
+            end
+
+          when 'pc', 'page-count'
+            puts @doc.pages.count
 
-      def do_object(doc) #:nodoc:
-        object = doc.object(pdf_reference_from_string(@param))
-        return unless object
-        if object.data.stream && command_parser.verbosity_info?
-          $stderr.puts("Note: Object also has stream data")
+          when 'search'
+            regexp = data.shift
+            unless regexp
+              $stderr.puts("Error: Missing argument regexp")
+              next
+            end
+            re = Regexp.new(regexp, Regexp::IGNORECASE)
+            @doc.each do |object|
+              if @serializer.serialize(object.value).match?(re)
+                puts "#{object.oid} #{object.gen} obj"
+                serialize(object.value, recursive: false)
+                puts "endobj"
+              end
+            end
+
+          when 'q', 'quit'
+            return true
+
+          when 'h', 'help'
+            puts COMMAND_DESCRIPTIONS.map {|cmd, desc| cmd.ljust(35) << desc }.join("\n")
+
+          else
+            if command
+              $stderr.puts("Error: Unknown command '#{command}' - enter 'h' for a list of commands")
+            end
+          end
         end
-        puts HexaPDF::Serializer.new.serialize(object.value)
+
+        false
       end
 
-      def do_stream(doc) #:nodoc:
-        object = doc.object(pdf_reference_from_string(@param))
-        if object.kind_of?(HexaPDF::Stream)
-          source = (@raw ? object.stream_source : object.stream_decoder)
-          while source.alive? && (data = source.resume)
-            $stdout.write(data)
-          end
-        elsif command_parser.verbosity_info?
-          $stderr.puts("Note: Object has no stream data")
+      # Resolves the PDF object from the given string reference and returns it.
+      def pdf_object_from_string_reference(str)
+        if str.nil?
+          raise "Error: Missing argument object identifier OID[,GEN]"
+        elsif !str.match?(/^\d+(,\d+)?$/)
+          raise "Error: Invalid argument: Must be of form OID[,GEN]"
+        elsif !(obj = @doc.object(pdf_reference_from_string(str)))
+          raise "Error: No object with the given object identifier found"
+        else
+          obj
         end
       end
 
@@ -151,6 +201,86 @@ module HexaPDF
         HexaPDF::Reference.new(oid, gen || 0)
       end
 
+      # Prints the serialized value to the standard output. If +recursive+ is +true+, then the whole
+      # object tree is printed, with object references to already printed objects replaced by
+      # specially generated PDF references.
+      def serialize(val, recursive: true, seen: {}, indent: 0) #:nodoc:
+        case val
+        when Hash
+          puts "<<"
+          (recursive ? val.sort : val).each do |k, v|
+            next if v.nil? || (v.respond_to?(:null?) && v.null?)
+            print '  ' * (indent + 1) + @serializer.serialize_symbol(k) + " "
+            serialize(v, recursive: recursive, seen: seen, indent: indent + 1)
+            puts
+          end
+          print "#{'  ' * indent}>>"
+        when Array
+          print "["
+          val.each do |v|
+            serialize(v, recursive: recursive, seen: seen, indent: indent)
+            print " "
+          end
+          print "]"
+        when HexaPDF::Reference
+          serialize(@doc.object(val), recursive: recursive, seen: seen, indent: indent)
+        when HexaPDF::Object
+          if !recursive
+            if val.indirect?
+              print "#{val.oid} #{val.gen} R"
+            else
+              serialize(val.value, recursive: recursive, seen: seen, indent: indent)
+            end
+          elsif val.nil? || seen.key?(val.data)
+            print "{ref #{seen[val.data]}}"
+          else
+            seen[val.data] = (val.type == :Page ? "page #{val.index + 1}" : seen.length + 1)
+            print "{obj #{seen[val.data]}} "
+            serialize(val.value, recursive: recursive, seen: seen, indent: indent)
+          end
+        else
+          print @serializer.serialize(val)
+        end
+        puts if indent == 0
+      end
+
+      COMMAND_DESCRIPTIONS = [ #:nodoc:
+        ["OID[,GEN] | o[bject] OID[,GEN]", "Print object"],
+        ["r[ecursive] OID[,GEN]", "Print object recursively"],
+        ["s[tream] OID[,GEN]", "Print filtered stream"],
+        ["raw[-stream] OID[,GEN]", "Print raw stream"],
+        ["x[ref] OID[,GEN]", "Print the cross-reference entry"],
+        ["c[atalog]", "Print the catalog dictionary"],
+        ["t[railer]", "Print the trailer dictionary"],
+        ["p[ages] [RANGE]",  "Print information about pages"],
+        ["pc | page-count", "Print the number of pages"],
+        ["search REGEXP", "Print objects matching the pattern"],
+        ["h[elp]", "Show the help"],
+        ["q[uit]", "Quit"],
+      ]
+
+      def help_long_desc #:nodoc:
+        output = super
+        summary_width = command_parser.main_options.summary_width
+        data = <<~HELP
+          If a command or an argument is OID[,GEN], object and generation numbers are expected. The
+          generation number defaults to 0 if not given. The available commands are:
+        HELP
+        content = format(data, indent: 0,
+                         width: command_parser.help_line_width - command_parser.help_indent)
+        content << "\n\n"
+        COMMAND_DESCRIPTIONS.each do |cmd, desc|
+          content << format(cmd.ljust(summary_width + 1) << desc,
+                            width: command_parser.help_line_width - command_parser.help_indent,
+                            indent: summary_width + 1, indent_first_line: false) << "\n"
+        end
+        output << cond_format_help_section("Interactive Mode Commands", content, preformatted: true)
+      end
+
+      def usage_arguments #:nodoc:
+        "FILE [[CMD [ARGS]]...]"
+      end
+
     end
 
   end