hexapdf 0.3.0 → 0.4.0

data/lib/hexapdf/content/parser.rb

@@ -33,6 +33,7 @@
 
 require 'stringio'
 require 'hexapdf/tokenizer'
+require 'hexapdf/content/processor'
 
 module HexaPDF
   module Content
@@ -45,6 +46,9 @@ module HexaPDF
     # See: PDF1.7 s7.2
     class Tokenizer < HexaPDF::Tokenizer #:nodoc:
 
+      # The string that is tokenized.
+      attr_reader :string
+
       # Creates a new tokenizer.
       def initialize(string)
         @ss = StringScanner.new(string)
@@ -168,6 +172,8 @@ module HexaPDF
 
       private
 
+      MAX_TOKEN_CHECK = 5 #:nodoc:
+
       # Parses the inline image at the current position.
       def parse_inline_image(tokenizer)
         # BI has already been read, so read the image dictionary
@@ -190,13 +196,41 @@ module HexaPDF
         # one whitespace character after ID
         tokenizer.next_byte
 
-        # find the EI operator
-        data = tokenizer.scan_until(/(?=EI[#{Tokenizer::WHITESPACE}])/o)
-        if data.nil?
-          raise HexaPDF::Error, "End inline image marker EI not found"
+        real_end_found = false
+        image_data = ''.b
+
+        # find the EI operator and handle EI appearing inside the image data
+        until real_end_found
+          data = tokenizer.scan_until(/(?=EI(?:[#{Tokenizer::WHITESPACE}]|\z))/o)
+          if data.nil?
+            raise HexaPDF::Error, "End inline image marker EI not found"
+          end
+          image_data << data
+          tokenizer.pos += 2
+          last_pos = tokenizer.pos
+
+          # Check if we found EI inside of the image data
+          count = 0
+          while count < MAX_TOKEN_CHECK
+            token = tokenizer.next_object(allow_keyword: true) rescue break
+            if token == Tokenizer::NO_MORE_TOKENS
+              count += MAX_TOKEN_CHECK
+            elsif token.kind_of?(Tokenizer::Token) &&
+                !Processor::OPERATOR_MESSAGE_NAME_MAP.key?(token.to_sym)
+              break #  invalid token
+            end
+            count += 1
+          end
+
+          if count >= MAX_TOKEN_CHECK
+            real_end_found = true
+          else
+            image_data << "EI"
+          end
+          tokenizer.pos = last_pos
         end
-        tokenizer.pos += 3
-        [dict, data]
+
+        [dict, image_data]
       end
 
     end

data/lib/hexapdf/content/processor.rb

@@ -408,7 +408,7 @@ module HexaPDF
       def decode_horizontal_text(array)
         font = graphics_state.font
         scaled_char_space = graphics_state.scaled_character_spacing
-        scaled_word_space = graphics_state.scaled_word_spacing
+        scaled_word_space = (font.word_spacing_applicable? ? graphics_state.scaled_word_spacing : 0)
         scaled_font_size = graphics_state.scaled_font_size
 
         below_baseline = font.bounding_box[1] * scaled_font_size / \
@@ -423,15 +423,15 @@ module HexaPDF
           else
             font.decode(item).each do |code_point|
               char = font.to_utf8(code_point)
-              width = font.width(code_point) * scaled_font_size
+              width = font.width(code_point) * scaled_font_size + scaled_char_space + \
+                (code_point == 32 ? scaled_word_space : 0)
               matrix = graphics_state.ctm.dup.premultiply(*graphics_state.tm)
               fragment = GlyphBox.new(code_point, char,
                                       *matrix.evaluate(0, below_baseline),
                                       *matrix.evaluate(width, below_baseline),
                                       *matrix.evaluate(0, above_baseline))
               text << fragment
-              graphics_state.tm.translate(width + scaled_char_space + \
-                                          (char == ' ' ? scaled_word_space : 0), 0)
+              graphics_state.tm.translate(width, 0)
             end
           end
         end

data/lib/hexapdf/document.rb

@@ -135,6 +135,7 @@ module HexaPDF
       end
 
       @listeners = {}
+      @cache = Hash.new {|h, k| h[k] = {} }
     end
 
     # :call-seq:
@@ -315,25 +316,24 @@ module HexaPDF
       if type.kind_of?(Class)
         klass = type
       else
-        default = if data.stream
-                    HexaPDF::Stream
-                  elsif data.value.kind_of?(Hash)
-                    HexaPDF::Dictionary
-                  else
-                    HexaPDF::Object
-                  end
         if data.value.kind_of?(Hash)
           type ||= deref(data.value[:Type])
           subtype ||= deref(data.value[:Subtype])
         end
 
         if subtype
-          klass = GlobalConfiguration.constantize('object.subtype_map'.freeze, subtype)
+          klass = GlobalConfiguration.constantize('object.subtype_map'.freeze, subtype) { nil }
         end
         if type && !klass
-          klass = GlobalConfiguration.constantize('object.type_map'.freeze, type)
+          klass = GlobalConfiguration.constantize('object.type_map'.freeze, type) { nil }
         end
-        klass ||= default
+        klass ||= if data.stream
+                    HexaPDF::Stream
+                  elsif data.value.kind_of?(Hash)
+                    HexaPDF::Dictionary
+                  else
+                    HexaPDF::Object
+                  end
       end
 
       klass.new(data, document: self)
@@ -418,6 +418,36 @@ module HexaPDF
       @listeners[name] && @listeners[name].each {|obj| obj.call(*args)}
     end
 
+    # Caches the value or the return value of the given block using the given Object::PDFData and
+    # key arguments as composite hash key. If a cached value already exists, it is just returned.
+    #
+    # This facility can be used to cache expensive operations in PDF objects that are easy to
+    # compute again.
+    #
+    # Use #clear_cache to clear the cache if necessary.
+    def cache(pdf_data, key, value = nil)
+      @cache[pdf_data][key] ||= value || yield
+    end
+
+    # Returns +true+ if there is a value cached for the composite key consisting of the given
+    # +pdf_data+ and +key+ objects.
+    #
+    # Also see: #cache
+    def cached?(pdf_data, key)
+      @cache.key?(pdf_data) && @cache[pdf_data].key?(key)
+    end
+
+    # Clears all cached data or, if a Object::PDFData object is given, just the cache for this one
+    # object.
+    #
+    # It is *not* recommended to clear the whole cache! Better clear the cache for individual PDF
+    # objects!
+    #
+    # Also see: #cache
+    def clear_cache(pdf_data = nil)
+      pdf_data ? @cache[pdf_data].clear : @cache.clear
+    end
+
     # Returns the Pages object that provides convenience methods for working with pages.
     #
     # Also see: HexaPDF::Type::PageTreeNode

data/lib/hexapdf/document/fonts.rb

@@ -55,6 +55,7 @@ module HexaPDF
       #
       # If a font with the same parameters has been loaded before, the cached font object is used.
       def load(name, **options)
+        options[:variant] ||= :none # assign default value for consistency with caching
         font = @loaded_fonts_cache[[name, options]]
         return font if font
 

data/lib/hexapdf/encryption/security_handler.rb

@@ -143,12 +143,10 @@ module HexaPDF
       #
       # See: #set_up_encryption (for the common encryption options).
       def self.set_up_encryption(document, handler_name, **options)
-        handler = HexaPDF::GlobalConfiguration.constantize('encryption.filter_map', handler_name)
-        if handler.nil?
-          handler = HexaPDF::GlobalConfiguration.constantize('encryption.sub_filter_map', handler_name)
-        end
-        if handler.nil?
-          raise HexaPDF::EncryptionError, "Could not find the specified security handler"
+        handler = GlobalConfiguration.constantize('encryption.filter_map', handler_name) do
+          GlobalConfiguration.constantize('encryption.sub_filter_map', handler_name) do
+            raise HexaPDF::EncryptionError, "Could not find the specified security handler"
+          end
         end
 
         handler = handler.new(document)
@@ -172,12 +170,10 @@ module HexaPDF
         if dict.nil?
           raise HexaPDF::EncryptionError, "No /Encrypt dictionary found"
         end
-        handler = HexaPDF::GlobalConfiguration.constantize('encryption.filter_map', dict[:Filter])
-        if handler.nil?
-          handler = HexaPDF::GlobalConfiguration.constantize('encryption.sub_filter_map', dict[:SubFilter])
-        end
-        if handler.nil?
-          raise HexaPDF::EncryptionError, "Could not find a suitable security handler"
+        handler = HexaPDF::GlobalConfiguration.constantize('encryption.filter_map', dict[:Filter]) do
+          HexaPDF::GlobalConfiguration.constantize('encryption.sub_filter_map', dict[:SubFilter]) do
+            raise HexaPDF::EncryptionError, "Could not find a suitable security handler"
+          end
         end
 
         handler = handler.new(document)

data/lib/hexapdf/filter/flate_decode.rb

@@ -45,10 +45,33 @@ module HexaPDF
     # See: HexaPDF::Filter, PDF1.7 s7.4.4
     module FlateDecode
 
+      class Pool #:nodoc:
+
+        # Creates a new Zlib::Stream pool. A block must be given that returns a new Zlib::Stream
+        # instance.
+        def initialize(&block)
+          @creator = block
+          @pool = []
+        end
+
+        # Returns the next available stream of the pool, already reset to its initial state.
+        def next_available
+          @pool.find(-> { e = @creator.call; @pool << e; e }, &:finished?).tap(&:reset)
+        end
+
+      end
+
+      @inflate_pool = Pool.new { Zlib::Inflate.new }
+      @deflate_pool = Pool.new do
+        Zlib::Deflate.new(HexaPDF::GlobalConfiguration['filter.flate_compression'],
+                          Zlib::MAX_WBITS,
+                          HexaPDF::GlobalConfiguration['filter.flate_memory'])
+      end
+
       # See HexaPDF::Filter
       def self.decoder(source, options = nil)
         fib = Fiber.new do
-          inflater = Zlib::Inflate.new
+          inflater = @inflate_pool.next_available
           while source.alive? && (data = source.resume)
             begin
               data = inflater.inflate(data)
@@ -78,7 +101,7 @@ module HexaPDF
         end
 
         Fiber.new do
-          deflater = Zlib::Deflate.new(HexaPDF::GlobalConfiguration['filter.flate_compression'])
+          deflater = @deflate_pool.next_available
           while source.alive? && (data = source.resume)
             data = deflater.deflate(data)
             Fiber.yield(data)

data/lib/hexapdf/font/cmap.rb

@@ -31,20 +31,44 @@
 # is created or manipulated using HexaPDF.
 #++
 
+require 'hexapdf/error'
+require 'hexapdf/data_dir'
+
 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
+    # See: PDF1.7 s9.7.5, s9.10.3; Adobe Technical Notes #5014 and #5411
     class CMap
 
       autoload(:Parser, 'hexapdf/font/cmap/parser')
       autoload(:Writer, 'hexapdf/font/cmap/writer')
 
+      CMAP_DIR = File.join(HexaPDF.data_dir, 'cmap') #:nodoc:
+
+      @cmap_cache = {}
+
+      # Returns +true+ if the given name specifies a predefined CMap.
+      def self.predefined?(name)
+        File.exist?(File.join(CMAP_DIR, name))
+      end
+
+      # Creates a new CMap object by parsing a predefined CMap with the given name.
+      #
+      # Raises an error if the given CMap is not found.
+      def self.for_name(name)
+        return @cmap_cache[name] if @cmap_cache.key?(name)
+
+        file = File.join(CMAP_DIR, name)
+        if File.exist?(file)
+          @cmap_cache[name] = parse(File.read(file, encoding: ::Encoding::UTF_8))
+        else
+          raise HexaPDF::Error, "No CMap named '#{name}' found"
+        end
+      end
+
       # 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)
@@ -58,6 +82,7 @@ module HexaPDF
         Writer.new.create_to_unicode_cmap(mapping)
       end
 
+
       # The registry part of the CMap version.
       attr_accessor :registry
 
@@ -70,16 +95,107 @@ module HexaPDF
       # The name of the CMap.
       attr_accessor :name
 
-      # The mapping from character codes to Unicode values.
-      attr_accessor :unicode_mapping
+      # The writing mode of the CMap: 0 for horizontal, 1 for vertical writing.
+      attr_accessor :wmode
+
+      attr_reader :codespace_ranges     #: nodoc:
+      attr_reader :cid_mapping          # :nodoc:
+      attr_reader :cid_range_mappings   # :nodoc:
+      attr_reader :unicode_mapping      # :nodoc:
+      protected :codespace_ranges, :cid_mapping, :cid_range_mappings, :unicode_mapping
 
       # Creates a new CMap object.
       def initialize
-        @unicode_mapping = Hash.new("".freeze)
+        @codespace_ranges = []
+        @cid_mapping = {}
+        @cid_range_mappings = []
+        @unicode_mapping = {}
+      end
+
+      # Add all mappings from the given CMap to this CMap.
+      def use_cmap(cmap)
+        @codespace_ranges.concat(cmap.codespace_ranges)
+        @cid_mapping.merge!(cmap.cid_mapping)
+        @cid_range_mappings.concat(cmap.cid_range_mappings)
+        @unicode_mapping.merge!(cmap.unicode_mapping)
+      end
+
+      # Add a codespace range using an array of ranges for the individual bytes.
+      #
+      # This means that the first range is checked against the first byte, the second range against
+      # the second byte and so on.
+      def add_codespace_range(first, *rest)
+        @codespace_ranges << [first, rest]
+      end
+
+      # Parses the string and returns all character codes.
+      #
+      # An error is raised if the string contains invalid bytes.
+      def read_codes(string)
+        codes = []
+        bytes = string.each_byte
+
+        loop do
+          byte = bytes.next
+          code = 0
+
+          found = @codespace_ranges.any? do |first_byte_range, rest_ranges|
+            next unless first_byte_range.cover?(byte)
+
+            code = (code << 8) + byte
+            valid = rest_ranges.all? do |range|
+              begin
+                byte = bytes.next
+              rescue StopIteration
+                raise HexaPDF::Error, "Missing bytes while reading codes via CMap"
+              end
+              code = (code << 8) + byte
+              range.cover?(byte)
+            end
+
+            codes << code if valid
+          end
+
+          unless found
+            raise HexaPDF::Error, "Invalid byte while reading codes via CMap: #{byte}"
+          end
+        end
+
+        codes
+      end
+
+      # Adds an individual mapping from character code to CID.
+      def add_cid_mapping(code, cid)
+        @cid_mapping[code] = cid
+      end
+
+      # Adds a CID range, mapping characters codes from +start_code+ to +end_code+ to CIDs starting
+      # with +start_cid+.
+      def add_cid_range(start_code, end_code, start_cid)
+        @cid_range_mappings << [start_code..end_code, start_cid]
+      end
+
+      # Returns the CID for the given character code, or 0 if no mapping was found.
+      def to_cid(code)
+        cid = @cid_mapping.fetch(code, -1)
+        if cid == -1
+          @cid_range_mappings.reverse_each do |range, start_cid|
+            if range.cover?(code)
+              cid = start_cid + code - range.first
+              break
+            end
+          end
+        end
+        (cid == -1 ? 0 : cid)
+      end
+
+      # Adds a mapping from character code to Unicode string in UTF-8 encoding.
+      def add_unicode_mapping(code, string)
+        @unicode_mapping[code] = string
       end
 
-      # Returns the Unicode string in UTF-8 encoding for the given character code, or an empty
-      # string if no mapping was found.
+      # Returns the Unicode string in UTF-8 encoding for the given character code, or +nil+ if no
+      # mapping was found.
       def to_unicode(code)
         unicode_mapping[code]
       end

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

@@ -41,7 +41,7 @@ module HexaPDF
 
       # Parses CMap files.
       #
-      # Currently only ToUnicode CMaps are supported.
+      # See: Adobe Technical Notes #5014 and #5411
       class Parser
 
         # Parses the given string and returns a CMap object.
@@ -54,10 +54,18 @@ module HexaPDF
               case token
               when 'beginbfchar'.freeze then parse_bf_char(tokenizer, cmap)
               when 'beginbfrange'.freeze then parse_bf_range(tokenizer, cmap)
+              when 'begincidchar'.freeze then parse_cid_char(tokenizer, cmap)
+              when 'begincidrange'.freeze then parse_cid_range(tokenizer, cmap)
+              when 'begincodespacerange'.freeze then parse_codespace_range(tokenizer, cmap)
               when 'endcmap' then break
               end
             elsif token.kind_of?(Symbol)
-              parse_dict_mapping(tokenizer, cmap, token)
+              value = tokenizer.next_token
+              if value.kind_of?(HexaPDF::Tokenizer::Token)
+                parse_cmap(cmap, token) if value == 'usecmap'.freeze
+              else
+                parse_dict_mapping(cmap, token, value)
+              end
             end
           end
 
@@ -68,17 +76,59 @@ module HexaPDF
 
         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)
+        # Populates the CMap with the values from the CMap with the given name.
+        def parse_cmap(cmap, name)
+          cmap.use_cmap(CMap.for_name(name.to_s))
+        end
 
+        # Parses a single mapping of a dictionary pair. The +name+ and +value+ of the mapping have
+        # already been parsed.
+        def parse_dict_mapping(cmap, name, value)
           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)
+          when :Registry
+            cmap.registry = value.force_encoding(::Encoding::UTF_8) if value.kind_of?(String)
+          when :Ordering
+            cmap.ordering = value.force_encoding(::Encoding::UTF_8) if value.kind_of?(String)
+          when :Supplement
+            cmap.supplement = value if value.kind_of?(Integer)
+          when :CMapName
+            cmap.name = value.to_s.force_encoding(::Encoding::UTF_8) if value.kind_of?(Symbol)
+          when :WMode
+            cmap.wmode = value
+          end
+        end
+
+        # Parses the "begincodespacerange" operator at the current position.
+        def parse_codespace_range(tokenizer, cmap)
+          until (code1 = tokenizer.next_token).kind_of?(HexaPDF::Tokenizer::Token)
+            code2 = tokenizer.next_token
+            byte_ranges = []
+            code1.each_byte.with_index do |byte, index|
+              byte_ranges << (byte..(code2.getbyte(index)))
+            end
+            cmap.add_codespace_range(*byte_ranges)
+          end
+        end
+
+        # Parses the "cidchar" operator at the current position.
+        def parse_cid_char(tokenizer, cmap)
+          until (code = tokenizer.next_token).kind_of?(HexaPDF::Tokenizer::Token)
+            cmap.add_cid_mapping(bytes_to_int(code), tokenizer.next_token)
+          end
+        end
+
+        # Parses the "cidrange" operator at the current position.
+        def parse_cid_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)
+            cid_start = tokenizer.next_object
+
+            if code1 == code2
+              cmap.add_cid_mapping(code1, cid_start)
+            else
+              cmap.add_cid_range(code1, code2, cid_start)
+            end
           end
         end
 
@@ -86,7 +136,7 @@ module HexaPDF
         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
+            cmap.add_unicode_mapping(bytes_to_int(code), str)
           end
         end
 
@@ -112,13 +162,13 @@ module HexaPDF
             if dest.kind_of?(String)
               codepoint = dest.force_encoding(::Encoding::UTF_16BE).ord
               code1.upto(code2) do |code|
-                cmap.unicode_mapping[code] = '' << codepoint
+                cmap.add_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)
+                str = dest[code - code1].encode!(::Encoding::UTF_8, ::Encoding::UTF_16BE)
+                cmap.add_unicode_mapping(code, str)
               end
             else
               raise HexaPDF::Error, "Invalid bfrange operator in CMap"