hexapdf 0.1.0

data/examples/standard_pdf_fonts.rb

@@ -0,0 +1,72 @@
+# ## Standard PDF Fonts
+#
+# This example shows all characters that are available in the standard 14 PDF
+# fonts.
+#
+# The standard 14 PDF fonts are those fonts that all PDF reading/viewing
+# applications need to support. They only provide a limited set of glyphs but
+# have the advantage that they don't need to be embedded.
+#
+# Usage:
+# : `ruby standard_pdf_fonts.rb`
+#
+
+require 'hexapdf'
+
+def base_encoding_for_font(font)
+  case font.font_name
+  when 'Symbol', 'ZapfDingbats'
+    font.encoding
+  else
+    HexaPDF::Font::Encoding.for_name(:WinAnsiEncoding)
+  end
+end
+
+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.font("Helvetica", size: 14)
+    canvas.text("#{font_name} #{variant != :none ? variant : ''}", at: [100, 800])
+
+    canvas.font(font_name, size: 14, variant: variant)
+    canvas.leading = 20
+    font = canvas.font
+    encoding = base_encoding_for_font(font.wrapped_font)
+    used_glyphs = []
+
+    # Showing the glyphs of the WinAnsi or built-in encoding
+    canvas.move_text_cursor(offset: [100, 750])
+    (2..15).each do |y|
+      data = []
+      (0..15).each do |x|
+        code = y * 16 + x
+        glyph = font.glyph(encoding.name(code)) rescue font.glyph(:space)
+        used_glyphs << glyph.name
+        data << glyph << -(2000 - glyph.width)
+      end
+      canvas.show_glyphs(data)
+      canvas.move_text_cursor
+    end
+
+    # Showing the remaining glyphs
+    canvas.move_text_cursor(offset: [0, -40], absolute: false)
+    glyphs = font.wrapped_font.metrics.character_metrics.keys.select do |k|
+      Symbol === k
+    end.sort - used_glyphs
+    canvas.font(font_name, size: 14, variant: variant, custom_encoding: true)
+    font = canvas.font
+    glyphs.each_slice(16).with_index do |slice, index|
+      data = []
+      slice.each do |name|
+        glyph = font.glyph(name)
+        data << glyph << -(2000 - glyph.width)
+      end
+      canvas.show_glyphs(data)
+      canvas.move_text_cursor
+    end
+  end
+end
+
+doc.write("standard_pdf_fonts.pdf", optimize: true)

data/examples/truetype.rb

@@ -0,0 +1,45 @@
+# ## TrueType Fonts
+#
+# This example displays all glyphs of a TrueType font and shows that using a
+# TrueType font with HexaPDF is very similar to using one of the standard PDF
+# fonts.
+#
+# Before a TrueType font can be used, HexaPDF needs to be made aware of it. This
+# is done by setting the configuration option 'font.map'.
+#
+# Once that is done the [HexaPDF::Content::Canvas#font] method can be used as
+# usual.
+#
+# Usage:
+# : `ruby truetype.pdf [FONT_FILE]`
+#
+
+require 'hexapdf'
+
+doc = HexaPDF::Document.new
+doc.config['font.on_missing_glyph'] = ->(n,f) { f.missing_glyph_id }
+doc.config['font.map'] = {
+  'myfont' => {none: ARGV.shift || File.join(__dir__, '../test/data/fonts/Ubuntu-Title.ttf')}
+}
+
+wrapper = doc.fonts.load('myfont')
+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.font("Helvetica", size: 10)
+  canvas.text("Font: #{wrapper.wrapped_font.full_name}", at: [50, 825])
+
+  canvas.font("myfont", size: 15)
+  16.times do |y|
+    canvas.move_text_cursor(offset: [50, 800 - y * 50], absolute: true)
+    canvas.show_glyphs((0..15).map do |i|
+      gid = page * 256 + y * 16 + i
+      glyph = wrapper.glyph(gid)
+      gid > max_gid ? [] : [glyph, -(2000 - glyph.width)]
+    end.flatten!)
+  end
+end
+
+doc.write("truetype.pdf", optimize: true)

data/lib/hexapdf/cli/extract.rb

@@ -0,0 +1,128 @@
+# -*- 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/cli'
+
+module HexaPDF
+  module CLI
+
+    # Extracts files from a PDF file.
+    #
+    # See: HexaPDF::Type::EmbeddedFile
+    class Extract < CmdParse::Command
+
+      def initialize #:nodoc:
+        super('extract', takes_commands: false)
+        short_desc("Extract files from a PDF file")
+        long_desc(<<-EOF.gsub!(/^ */, ''))
+          This command extracts files embedded in a PDF file. If the option --indices is not given,
+          the available files are listed with their names and indices. The --indices option can then
+          be used to extract one or more files.
+        EOF
+        options.on("--indices a,b,c", "-i a,b,c,...", Array,
+                   "The indices of the files that should be extracted. Use 0 to extract " \
+                   "all files.") do |indices|
+          @indices = indices.map(&:to_i)
+        end
+        options.on("--[no-]search", "-s", "Search the whole PDF instead of the " \
+                   "standard locations (default: false)") do |search|
+          @search = search
+        end
+        options.on("--password PASSWORD", "-p", String,
+                   "The password for decryption. Use - for reading from standard input.") do |pwd|
+          @password = (pwd == '-' ? command_parser.read_password : pwd)
+        end
+        @indices = []
+        @password = ''
+        @search = false
+      end
+
+      def execute(file) #:nodoc:
+        HexaPDF::Document.open(file, decryption_opts: {password: @password}) do |doc|
+          if @indices.empty?
+            list_files(doc)
+          else
+            extract_files(doc)
+          end
+        end
+      rescue HexaPDF::Error => e
+        $stderr.puts "Error while processing the PDF file: #{e.message}"
+        exit(1)
+      end
+
+      private
+
+      # Outputs the list of files embedded in the given PDF document.
+      def list_files(doc)
+        each_file(doc) do |obj, index|
+          $stdout.write(sprintf("%4i: %s", index + 1, obj.path))
+          ef_stream = obj.embedded_file_stream
+          if (params = ef_stream[:Params]) && !params.empty?
+            data = []
+            data << "size: #{params[:Size]}" if params.key?(:Size)
+            data << "md5: #{params[:CheckSum].unpack('H*').first}" if params.key?(:CheckSum)
+            data << "ctime: #{params[:CreationDate]}" if params.key?(:CreationDate)
+            data << "mtime: #{params[:ModDate]}" if params.key?(:ModDate)
+            $stdout.write(" (#{data.join(', ')})")
+          end
+          $stdout.puts
+          $stdout.puts("      #{obj[:Desc]}") if obj[:Desc] && !obj[:Desc].empty?
+        end
+      end
+
+      # Extracts the files with the given indices.
+      def extract_files(doc)
+        each_file(doc) do |obj, index|
+          next unless @indices.include?(index + 1) || @indices.include?(0)
+          if File.exist?(obj.path)
+            raise HexaPDF::Error, "Output file #{obj.path} already exists, not overwriting"
+          end
+          puts "Extracting #{obj.path}..."
+          File.open(obj.path, 'wb') do |file|
+            fiber = obj.embedded_file_stream.stream_decoder
+            while fiber.alive? && (data = fiber.resume)
+              file << data
+            end
+          end
+        end
+      end
+
+      # 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)
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/cli/info.rb

@@ -0,0 +1,121 @@
+# -*- 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/cli'
+
+module HexaPDF
+  module CLI
+
+    # Outputs various bits of information about PDF files:
+    #
+    # * The entries in the trailers /Info dictionary
+    # * Encryption information from the trailers /Encrypt dictionary
+    # * The number of pages
+    # * The used PDF version
+    #
+    # See: HexaPDF::Type::Info, HexaPDF::Encryption::SecurityHandler
+    class Info < CmdParse::Command
+
+      def initialize #:nodoc:
+        super('info', takes_commands: false)
+        short_desc("Show document information")
+        long_desc(<<-EOF.gsub!(/^ */, ''))
+          This command extracts information from the Info dictionary of a PDF file as well
+          as some other useful information like the used PDF version and encryption information.
+        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 : pwd)
+        end
+        @password = ''
+        @auto_decrypt = true
+      end
+
+      def execute(file) #:nodoc:
+        output_info(file)
+      end
+
+      private
+
+      INFO_KEYS = [:Title, :Author, :Subject, :Keywords, :Creator, :Producer, #:nodoc:
+                   :CreationDate, :ModDate]
+
+      COLUMN_WIDTH = 20 #:nodoc:
+
+      def output_info(file) # :nodoc:
+        options = {decryption_opts: {password: @password},
+                   config: {'document.auto_decrypt' => @auto_decrypt}}
+        HexaPDF::Document.open(file, options) do |doc|
+          INFO_KEYS.each do |name|
+            next unless doc.trailer.info.key?(name)
+            output_line(name.to_s, doc.trailer.info[name].to_s)
+          end if @auto_decrypt
+
+          if doc.encrypted? && @auto_decrypt
+            details = doc.security_handler.encryption_details
+            data = "yes (version: #{details[:version]}, key length: #{details[:key_length]}bits)"
+            output_line("Encrypted", data)
+            output_line("  String algorithm", details[:string_algorithm].to_s)
+            output_line("  Stream algorithm", details[:stream_algorithm].to_s)
+            output_line("  EFF algorithm", details[:embedded_file_algorithm].to_s)
+            if doc.security_handler.respond_to?(:permissions)
+              output_line("  Permissions", doc.security_handler.permissions.join(", "))
+            end
+          elsif doc.encrypted?
+            output_line("Encrypted", "yes (no or wrong password given)")
+          end
+
+          output_line("Pages", doc.pages.page_count.to_s)
+          output_line("Version", doc.version)
+        end
+      rescue HexaPDF::EncryptionError => e
+        if @auto_decrypt
+          @auto_decrypt = false
+          retry
+        else
+          $stderr.puts "Error while decrypting the PDF file: #{e.message}"
+          exit(1)
+        end
+      rescue HexaPDF::Error => e
+        $stderr.puts "Error while processing the PDF file: #{e.message}"
+        exit(1)
+      end
+
+      def output_line(header, text) #:nodoc:
+        puts((header + ":").ljust(COLUMN_WIDTH) << text)
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/cli/inspect.rb

@@ -0,0 +1,157 @@
+# -*- 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/cli'
+
+module HexaPDF
+  module CLI
+
+    # Shows the internal structure of a PDF file.
+    class Inspect < CmdParse::Command
+
+      def initialize #:nodoc:
+        super('inspect', takes_commands: false)
+        short_desc("Dig into the internal structure of a PDF file")
+        long_desc(<<-EOF.gsub!(/^ */, ''))
+          Inspects a PDF file for debugging or testing purposes. This command is useful when one
+          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 main PDF object, the catalog, 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
+
+        options.on("-t", "--trailer", "Show the trailer dictionary.") do
+          @exec = :trailer
+        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
+          @raw = (@raw ? @raw : false)
+        end
+        options.on("--raw", "Modifies --stream to show the raw stream data instead of the " \
+                   "filtered one.") do
+          @raw = true
+        end
+
+        options.separator("")
+        options.on("--password PASSWORD", "-p", String,
+                   "The password for decryption. Use - for reading from standard input.") do |pwd|
+          @password = (pwd == '-' ? command_parser.read_password : pwd)
+        end
+
+        @password = nil
+        @exec = :catalog
+        @param = nil
+        @raw = nil
+      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)
+      end
+
+      private
+
+      def do_catalog(doc) #:nodoc:
+        puts HexaPDF::Serializer.new.serialize(doc.catalog)
+      end
+
+      def do_trailer(doc) #:nodoc:
+        puts HexaPDF::Serializer.new.serialize(doc.trailer)
+      end
+
+      def do_page_count(doc) #:nodoc:
+        puts doc.pages.page_count
+      end
+
+      def do_pages(doc) #:nodoc:
+        pages = command_parser.parse_pages_specification(@param, doc.pages.page_count)
+        pages.each do |index, _|
+          page = doc.pages.page(index)
+          str = "page #{index + 1} (#{page.oid},#{page.gen}): "
+          Array(page[:Contents]).each {|c| str << "#{c.oid},#{c.gen}"}
+          puts str
+        end
+      end
+
+      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
+        puts HexaPDF::Serializer.new.serialize(object.value)
+      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
+        else
+          $stderr.puts("Note: Object has no stream data")
+        end
+      end
+
+      # Parses the given string of the format "oid[,gen]" and returns a PDF reference object.
+      def pdf_reference_from_string(str)
+        oid, gen = str.split(",").map(&:to_i)
+        HexaPDF::Reference.new(oid, gen || 0)
+      end
+
+    end
+
+  end
+end