hexapdf 0.1.0

data/lib/hexapdf/filter.rb

@@ -0,0 +1,176 @@
+# -*- 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 'fiber'
+require 'hexapdf/error'
+
+module HexaPDF
+
+  # This special Fiber class should be used when the total length of the data yielded by the fiber
+  # is known beforehand. HexaPDF uses this information to avoid unnecessary memory usage.
+  class FiberWithLength < Fiber
+
+    # The total length of the data that will be yielded by this fiber. If the return value is
+    # negative the total length is *not* known.
+    attr_reader :length
+
+    # Initializes the Fiber and sets the +length+.
+    def initialize(length, &block)
+      super(&block)
+      @length = length || -1
+    end
+
+  end
+
+
+  # == Overview
+  #
+  # A stream filter is used to compress a stream or to encode it in an ASCII compatible way; or
+  # to reverse this process. Some filters can be used for any content, like FlateDecode, others
+  # are specifically designed for image streams, like DCTDecode.
+  #
+  # Each filter is implemented via fibers. This allows HexaPDF to easily process either small
+  # chunks or a whole stream at once, depending on the memory restrictions and to create flexible
+  # filter pipelines.
+  #
+  # It also allows the easy re-processing of a stream without first decoding and the encoding it.
+  # Such functionality is useful, for example, when a PDF file should be decrypted and streams
+  # compressed in one step.
+  #
+  #
+  # == Implementation of a Filter Object
+  #
+  # Each filter is an object (normally a module) that responds to two methods: \#encoder and
+  # \#decoder. Both of these methods are given a *source* (a Fiber) and *options* (a Hash) and have
+  # to return a Fiber object.
+  #
+  # The returned fiber should resume the *source* fiber to get the next chunk of binary data
+  # (possibly only one byte of data, so this situation should be handled gracefully). Once the
+  # fiber has processed this chunk, it should yield the processed chunk as binary string. This
+  # should be done as long as the source fiber is #alive? and doesn't return +nil+ when resumed.
+  #
+  # Such a fiber should *not* return +nil+ unless this signifies that no more data is coming!
+  #
+  # See: PDF1.7 s7.4
+  module Filter
+
+    autoload(:ASCII85Decode, 'hexapdf/filter/ascii85_decode')
+    autoload(:ASCIIHexDecode, 'hexapdf/filter/ascii_hex_decode')
+    autoload(:DCTDecode, 'hexapdf/filter/dct_decode')
+    autoload(:FlateDecode, 'hexapdf/filter/flate_decode')
+    autoload(:JPXDecode, 'hexapdf/filter/jpx_decode')
+    autoload(:LZWDecode, 'hexapdf/filter/lzw_decode')
+    autoload(:RunLengthDecode, 'hexapdf/filter/run_length_decode')
+
+    autoload(:Predictor, 'hexapdf/filter/predictor')
+
+    autoload(:Encryption, 'hexapdf/filter/encryption')
+
+    # Returns a Fiber that can be used as a source for decoders/encoders and that is based on a
+    # String object.
+    def self.source_from_string(str)
+      FiberWithLength.new(str.length) { str.dup }
+    end
+
+    # Returns a Fiber that can be used as a source for decoders/encoders and that reads chunks of
+    # data from an IO object.
+    #
+    # Each time a chunk is read, the position pointer of the IO is adjusted. This should be taken
+    # into account when working with the IO object.
+    #
+    # Options:
+    #
+    # :pos:: The position from where the reading should start. A negative position is treated as
+    #        zero. Default: 0.
+    #
+    # :length:: The length indicating the number of bytes to read. An error is raised if not all
+    #           specified bytes could be read. A negative length means reading until the end of
+    #           the IO stream. Default: -1.
+    #
+    # :chunk_size:: The size of the chunks that should be returned in each iteration. A chunk size
+    #               of less than or equal to 0 means using the biggest chunk size available (can
+    #               change between versions!). Default: 0.
+    def self.source_from_io(io, pos: 0, length: -1, chunk_size: 0)
+      orig_length = length
+      chunk_size = 2**20 if chunk_size <= 0
+      chunk_size = length if length >= 0 && chunk_size > length
+      length = 2**61 if length < 0
+      pos = 0 if pos < 0
+
+      FiberWithLength.new(orig_length) do
+        while length > 0 && (io.pos = pos) && (data = io.read(chunk_size))
+          pos = io.pos
+          length -= data.size
+          chunk_size = length if chunk_size > length
+          Fiber.yield(data)
+        end
+        if length > 0 && orig_length >= 0
+          raise FilterError, "Couldn't read all requested bytes before encountering EOF"
+        end
+      end
+    end
+
+    # Returns a Fiber that can be used as a source for decoders/encoders and that reads chunks
+    # from a file.
+    #
+    # Note that there will be a problem if the size of the file changes between the invocation of
+    # this method and the actual consumption of the file!
+    #
+    # See ::source_from_io for a description of the available options.
+    def self.source_from_file(filename, pos: 0, length: -1, chunk_size: 0)
+      fib_length = (length < 0 ? File.stat(filename).size - pos : length)
+      FiberWithLength.new(fib_length) do
+        File.open(filename, 'rb') do |file|
+          source = source_from_io(file, pos: pos, length: length, chunk_size: chunk_size)
+          while source.alive? && (io_data = source.resume)
+            Fiber.yield(io_data)
+          end
+        end
+      end
+    end
+
+    # Returns the concatenated string chunks retrieved by resuming the given source Fiber until it
+    # is dead.
+    #
+    # The returned string is always a string with +BINARY+ (= +ASCII-8BIT+) encoding.
+    def self.string_from_source(source)
+      str = ''.b
+      while source.alive? && (data = source.resume)
+        str << data
+      end
+      str
+    end
+
+  end
+
+end

data/lib/hexapdf/font/cmap/parser.rb

@@ -0,0 +1,146 @@
+# -*- 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/error'
+require 'hexapdf/font/cmap'
+require 'hexapdf/content/parser'
+
+module HexaPDF
+  module Font
+    class CMap
+
+      # Parses CMap files.
+      #
+      # Currently only ToUnicode CMaps are supported.
+      class Parser
+
+        # Parses the given string and returns a CMap object.
+        def parse(string)
+          tokenizer = HexaPDF::Content::Tokenizer.new(string)
+          cmap = CMap.new
+
+          while (token = tokenizer.next_token) != HexaPDF::Tokenizer::NO_MORE_TOKENS
+            if token.kind_of?(HexaPDF::Tokenizer::Token)
+              case token
+              when 'beginbfchar'.freeze then parse_bf_char(tokenizer, cmap)
+              when 'beginbfrange'.freeze then parse_bf_range(tokenizer, cmap)
+              when 'endcmap' then break
+              end
+            elsif token.kind_of?(Symbol)
+              parse_dict_mapping(tokenizer, cmap, token)
+            end
+          end
+
+          cmap
+        rescue => e
+          raise HexaPDF::Error, "Error parsing CMap: #{e.message}", e.backtrace
+        end
+
+        private
+
+        # Parses a single mapping of a dictionary pair. The +name+ of the mapping has already been
+        # parsed.
+        def parse_dict_mapping(tokenizer, cmap, name)
+          value = tokenizer.next_token
+          return if value.kind_of?(HexaPDF::Tokenizer::Token)
+
+          case name
+          when :Registry then cmap.registry = value if value.kind_of?(String)
+          when :Ordering then cmap.ordering = value if value.kind_of?(String)
+          when :Supplement then cmap.supplement = value if value.kind_of?(Integer)
+          when :CMapName then cmap.name = value.to_s if value.kind_of?(Symbol)
+          end
+        end
+
+        # Parses the "bfchar" operator at the current position.
+        def parse_bf_char(tokenizer, cmap)
+          until (code = tokenizer.next_token).kind_of?(HexaPDF::Tokenizer::Token)
+            str = tokenizer.next_token.encode!(::Encoding::UTF_8, ::Encoding::UTF_16BE)
+            cmap.unicode_mapping[bytes_to_int(code)] = str
+          end
+        end
+
+        # Parses the "bfrange" operator at the current position.
+        #
+        #--
+        # PDF1.7 s9.10.3 and Adobe Technical Note #5411 have different views as to how "bfrange"
+        # operators of the form "startCode endCode codePoint" should be handled.
+        #
+        # PDF1.7 mentions that the last byte of "codePoint" should be incremented, up to a maximum
+        # of 255. However #5411 has the range "<1379> <137B> <90FE>" as example which contradicts
+        # this.
+        #
+        # Additionally, #5411 mentions in section 1.4.1 that the first byte of "startCode" and
+        # "endCode" have to be the same. So it seems that this is a mistake in the PDF reference.
+        #++
+        def parse_bf_range(tokenizer, cmap)
+          until (code1 = tokenizer.next_token).kind_of?(HexaPDF::Tokenizer::Token)
+            code1 = bytes_to_int(code1)
+            code2 = bytes_to_int(tokenizer.next_token)
+            dest = tokenizer.next_object
+
+            if dest.kind_of?(String)
+              codepoint = dest.force_encoding(::Encoding::UTF_16BE).ord
+              code1.upto(code2) do |code|
+                cmap.unicode_mapping[code] = '' << codepoint
+                codepoint += 1
+              end
+            elsif dest.kind_of?(Array)
+              code1.upto(code2) do |code|
+                cmap.unicode_mapping[code] =
+                  dest[code - code1].encode!(::Encoding::UTF_8, ::Encoding::UTF_16BE)
+              end
+            else
+              raise HexaPDF::Error, "Invalid bfrange operator in CMap"
+            end
+          end
+        end
+
+        # Treats the string as an array of bytes and converts it to an integer.
+        #
+        # The bytes are converted in the big-endian way.
+        def bytes_to_int(string)
+          result = 0
+          index = 0
+          while index < string.length
+            result = (result << 8) | string.getbyte(index)
+            index += 1
+          end
+          result
+        end
+
+      end
+
+    end
+  end
+end

data/lib/hexapdf/font/cmap/writer.rb

@@ -0,0 +1,176 @@
+# -*- 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/font/cmap'
+
+module HexaPDF
+  module Font
+    class CMap
+
+      # Creates a CMap file.
+      #
+      # Currently only ToUnicode CMaps are supported.
+      class Writer
+
+        # Maximum number of entries in one section.
+        MAX_ENTRIES_IN_SECTION = 100
+
+        # Returns a ToUnicode CMap for the given input code to Unicode codepoint mapping which needs
+        # to be sorted by input codes.
+        #
+        # Note that the returned CMap always uses a 16-bit input code space!
+        def create_to_unicode_cmap(mapping)
+          return to_unicode_template % '' if mapping.length == 0
+
+          chars, ranges = compute_section_entries(mapping)
+
+          result = create_sections("bfchar", chars.size / 2) do |index|
+            index *= 2
+            sprintf("<%04X>", chars[index]) << "<" <<
+              (''.force_encoding(::Encoding::UTF_16BE) << chars[index + 1]).unpack('H*').first <<
+              ">\n"
+          end
+
+          result << create_sections("bfrange", ranges.size / 3) do |index|
+            index *= 3
+            sprintf("<%04X><%04X>", ranges[index], ranges[index + 1]) << "<" <<
+              (''.force_encoding(::Encoding::UTF_16BE) << ranges[index + 2]).unpack('H*').first <<
+              ">\n"
+          end
+
+          to_unicode_template % result.chop!
+        end
+
+        private
+
+        # Computes the entries for the "char" and "range" sections based on the given mapping.
+        #
+        # Returns two arrays +char_mappings+ and +range_mappings+ where +char_mappings+ is an array
+        # of the form
+        #
+        #   [code1, value1, code2, value2, ...]
+        #
+        # and +range_mappings+ an array of the form
+        #
+        #   [start1, end1, value1, start2, end2, value2, ...]
+        def compute_section_entries(mapping)
+          chars = []
+          ranges = []
+
+          last_code, last_value = *mapping[0]
+          is_range = false
+          mapping.slice(1..-1).each do |code, value|
+            if last_code + 1 == code && last_value + 1 == value && code % 256 != 0
+              ranges << last_code << nil << last_value unless is_range
+              is_range = true
+            else
+              if is_range
+                ranges[-2] = last_code
+                is_range = false
+              else
+                chars << last_code << last_value
+              end
+            end
+            last_code = code
+            last_value = value
+          end
+
+          # Handle last remaining mapping
+          if is_range
+            ranges[-2] = last_code
+          else
+            chars << last_code << last_value
+          end
+
+          [chars, ranges]
+        end
+
+        # Creates one or more sections of a CMap file and returns the resulting string.
+        #
+        # +type+::
+        #     The name of the section, e.g. "bfchar" or "bfrange".
+        #
+        # +size+::
+        #     The maximum number of elements of this type. Used for determining when to start a new
+        #     section.
+        #
+        # The method makes sure that no section has more than the maximum number of allowed entries.
+        #
+        # Numbers from 0 up to size - 1 are yielded, indicating the current entry that should be
+        # processed and for which an appropriate section line should be returned from the block.
+        def create_sections(type, size)
+          return '' if size == 0
+
+          result = ""
+          index = 0
+          while size > 0
+            count = [MAX_ENTRIES_IN_SECTION, size].min
+            result << "#{count} begin#{type}\n"
+            index.upto(index + count - 1) {|i| result << yield(i)}
+            result << "end#{type}\n"
+            index += count
+            size -= count
+          end
+
+          result
+        end
+
+        # Returns the CMap file template for a ToUnicode CMap.
+        def to_unicode_template
+          <<-TEMPLATE
+/CIDInit /ProcSet findresource begin
+12 dict begin
+begincmap
+/CIDSystemInfo
+<< /Registry (Adobe)
+/Ordering (UCS)
+/Supplement 0
+>> def
+/CMapName /Adobe-Identity-UCS def
+/CMapType 2 def
+1 begincodespacerange
+<0000> <FFFF>
+endcodespacerange
+%s
+endcmap
+CMapName currentdict /CMap defineresource pop
+end
+end
+          TEMPLATE
+        end
+
+      end
+
+    end
+  end
+end

data/lib/hexapdf/font/cmap.rb

@@ -0,0 +1,90 @@
+# -*- 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.
+#++
+
+module HexaPDF
+  module Font
+
+    # Represents a CMap, a mapping from character codes to CIDs (character IDs) or to their Unicode
+    # value.
+    #
+    # Currently, only the mapping to the Unicode values is supported.
+    #
+    # See: PDF1.7 s9.7.5, s9.10.3; Adobe Technical Note #5411
+    class CMap
+
+      autoload(:Parser, 'hexapdf/font/cmap/parser')
+      autoload(:Writer, 'hexapdf/font/cmap/writer')
+
+      # Creates a new CMap object from the given string which needs to contain a valid CMap file.
+      def self.parse(string)
+        Parser.new.parse(string)
+      end
+
+      # Returns a string containing a ToUnicode CMap that represents the given code to Unicode
+      # codepoint mapping.
+      #
+      # See: Writer#create_to_unicode_cmap
+      def self.create_to_unicode_cmap(mapping)
+        Writer.new.create_to_unicode_cmap(mapping)
+      end
+
+      # The registry part of the CMap version.
+      attr_accessor :registry
+
+      # The ordering part of the CMap version.
+      attr_accessor :ordering
+
+      # The supplement part of the CMap version.
+      attr_accessor :supplement
+
+      # The name of the CMap.
+      attr_accessor :name
+
+      # The mapping from character codes to Unicode values.
+      attr_accessor :unicode_mapping
+
+      # Creates a new CMap object.
+      def initialize
+        @unicode_mapping = Hash.new("".freeze)
+      end
+
+      # Returns the Unicode string in UTF-8 encoding for the given character code, or an empty
+      # string if no mapping was found.
+      def to_unicode(code)
+        unicode_mapping[code]
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/font/encoding/base.rb

@@ -0,0 +1,77 @@
+# -*- 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/font/encoding/glyph_list'
+
+module HexaPDF
+  module Font
+    module Encoding
+
+      # Base for encoding classes that are used for mapping codes in the range of 0 to 255 to glyph
+      # names.
+      class Base
+
+        # The name of the encoding or +nil+ if the encoding has not been assigned a name.
+        attr_reader :encoding_name
+
+        # The hash mapping codes to names.
+        attr_reader :code_to_name
+
+        # Creates a new encoding object containing no default mappings.
+        def initialize
+          @code_to_name = {}
+          @unicode_cache = {}
+          @encoding_name = nil
+        end
+
+        # Returns the name for the given code, or .notdef if no glyph for the code is defined.
+        #
+        # The returned value is always a Symbol object!
+        def name(code)
+          @code_to_name.fetch(code, :'.notdef')
+        end
+
+        # Returns the Unicode value in UTF-8 for the given code, or an empty string if the code
+        # cannot be mapped.
+        #
+        # Note that this method caches the result of the Unicode mapping and therefore should only
+        # be called after all codes have been defined.
+        def unicode(code)
+          @unicode_cache[code] ||= GlyphList.name_to_unicode(name(code))
+        end
+
+      end
+
+    end
+  end
+end