pdf-reader 1.1.1 → 2.5.0

data/lib/pdf/reader/unimplemented_security_handler.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+class PDF::Reader
+
+  # Security handler for when we don't support the flavour of encryption
+  # used in a PDF.
+  class UnimplementedSecurityHandler
+    def self.supports?(encrypt)
+      true
+    end
+
+    def decrypt(buf, ref)
+      raise PDF::Reader::EncryptedPDFError, "Unsupported encryption style"
+    end
+  end
+end

data/lib/pdf/reader/width_calculator/built_in.rb

@@ -0,0 +1,67 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require 'afm'
+require 'pdf/reader/synchronized_cache'
+
+class PDF::Reader
+  module WidthCalculator
+
+    # Type1 fonts can be one of 14 "built in" standard fonts. In these cases,
+    # the reader is expected to have it's own copy of the font metrics.
+    # see Section 9.6.2.2, PDF 32000-1:2008, pp 256
+    class BuiltIn
+
+      BUILTINS = [
+        :Courier, :"Courier-Bold", :"Courier-BoldOblique", :"Courier-Oblique",
+        :Helvetica, :"Helvetica-Bold", :"Helvetica-BoldOblique", :"Helvetica-Oblique",
+        :Symbol,
+        :"Times-Roman", :"Times-Bold", :"Times-BoldItalic", :"Times-Italic",
+        :ZapfDingbats
+      ]
+
+      def initialize(font)
+        @font = font
+        @@all_metrics ||= PDF::Reader::SynchronizedCache.new
+
+        basefont = extract_basefont(font.basefont)
+        metrics_path = File.join(File.dirname(__FILE__), "..","afm","#{basefont}.afm")
+
+        if File.file?(metrics_path)
+          @metrics = @@all_metrics[metrics_path] ||= AFM::Font.new(metrics_path)
+        else
+          raise ArgumentError, "No built-in metrics for #{font.basefont}"
+        end
+      end
+
+      def glyph_width(code_point)
+        return 0 if code_point.nil? || code_point < 0
+
+        names = @font.encoding.int_to_name(code_point)
+        metrics = names.map { |name|
+          @metrics.char_metrics[name.to_s]
+        }.compact.first
+
+        if metrics
+          metrics[:wx]
+        else
+          @font.widths[code_point - 1] || 0
+        end
+      end
+
+      private
+
+      def control_character?(code_point)
+        @font.encoding.int_to_name(code_point).first.to_s[/\Acontrol..\Z/]
+      end
+
+      def extract_basefont(font_name)
+        if BUILTINS.include?(font_name)
+          font_name
+        else
+          "Times-Roman"
+        end
+      end
+    end
+  end
+end

data/lib/pdf/reader/width_calculator/composite.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+class PDF::Reader
+  module WidthCalculator
+    # CIDFontType0 or CIDFontType2 use DW (integer) and W (array) to determine
+    # codepoint widths, note that CIDFontType2 will contain a true type font
+    # program which could be used to calculate width, however, a conforming writer
+    # is supposed to convert the widths for the codepoints used into the W array
+    # so that it can be used.
+    # see Section 9.7.4.1, PDF 32000-1:2008, pp 269-270
+    class Composite
+
+      def initialize(font)
+        @font = font
+        @widths = PDF::Reader::CidWidths.new(@font.cid_default_width, @font.cid_widths)
+      end
+
+      def glyph_width(code_point)
+        return 0 if code_point.nil? || code_point < 0
+
+        w = @widths[code_point]
+        # 0 is a valid width
+        return w.to_f unless w.nil?
+      end
+    end
+  end
+end

data/lib/pdf/reader/width_calculator/true_type.rb

@@ -0,0 +1,56 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+class PDF::Reader
+  module WidthCalculator
+    # Calculates the width of a glyph in a TrueType font
+    class TrueType
+
+      def initialize(font)
+        @font = font
+
+        if @font.font_descriptor
+          @missing_width = @font.font_descriptor.missing_width
+        else
+          @missing_width = 0
+        end
+      end
+
+      def glyph_width(code_point)
+        return 0 if code_point.nil? || code_point < 0
+        glyph_width_from_font(code_point) || glyph_width_from_descriptor(code_point) || 0
+      end
+
+      private
+
+      #TODO convert Type3 units 1000 units => 1 text space unit
+      def glyph_width_from_font(code_point)
+        return if @font.widths.nil? || @font.widths.count == 0
+
+        # in ruby a negative index is valid, and will go from the end of the array
+        # which is undesireable in this case.
+        if @font.first_char <= code_point
+          @font.widths.fetch(code_point - @font.first_char, @missing_width).to_f
+        else
+          @missing_width.to_f
+        end
+      end
+
+      def glyph_width_from_descriptor(code_point)
+        return unless @font.font_descriptor
+
+        # true type fonts will have most of their information contained
+        # with-in a program inside the font descriptor, however the widths
+        # may not be in standard PDF glyph widths (1000 units => 1 text space unit)
+        # so this width will need to be scaled
+        w = @font.font_descriptor.glyph_width(code_point)
+        if w
+          w.to_f * @font.font_descriptor.glyph_to_pdf_scale_factor
+        else
+          nil
+        end
+      end
+    end
+  end
+end
+

data/lib/pdf/reader/width_calculator/type_one_or_three.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+class PDF::Reader
+  module WidthCalculator
+    # Calculates the width of a glyph in a Type One or Type Three
+    class TypeOneOrThree
+
+      def initialize(font)
+        @font = font
+
+        if @font.font_descriptor
+          @missing_width = @font.font_descriptor.missing_width
+        else
+          @missing_width = 0
+        end
+      end
+
+      def glyph_width(code_point)
+        return 0 if code_point.nil? || code_point < 0
+        return 0 if @font.widths.nil? || @font.widths.count == 0
+
+        # in ruby a negative index is valid, and will go from the end of the array
+        # which is undesireable in this case.
+        if @font.first_char <= code_point
+          @font.widths.fetch(code_point - @font.first_char, @missing_width).to_f
+        else
+          @missing_width.to_f
+        end
+      end
+    end
+  end
+end

data/lib/pdf/reader/width_calculator/type_zero.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+class PDF::Reader
+  module WidthCalculator
+    # Type0 (or Composite) fonts are a "root font" that rely on a "descendant font"
+    # to do the heavy lifting. The "descendant font" is a CID-Keyed font.
+    # see Section 9.7.1, PDF 32000-1:2008, pp 267
+    # so if we are calculating a Type0 font width, we just pass off to
+    # the descendant font
+    class TypeZero
+
+      def initialize(font)
+        @font = font
+        @descendant_font = @font.descendantfonts.first
+      end
+
+      def glyph_width(code_point)
+        return 0 if code_point.nil? || code_point < 0
+
+        @descendant_font.glyph_width(code_point).to_f
+      end
+    end
+  end
+end

data/lib/pdf/reader/width_calculator.rb

@@ -0,0 +1,12 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+# PDF files may define fonts in a number of ways. Each approach means we must
+# calculate glyph widths differently, so this set of classes conform to an
+# interface that will perform the appropriate calculations.
+
+require 'pdf/reader/width_calculator/built_in'
+require 'pdf/reader/width_calculator/composite'
+require 'pdf/reader/width_calculator/true_type'
+require 'pdf/reader/width_calculator/type_zero'
+require 'pdf/reader/width_calculator/type_one_or_three'

data/lib/pdf/reader/xref.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)
@@ -51,11 +54,13 @@ class PDF::Reader
     #
     # io - must be an IO object, generally either a file or a StringIO
     #
-    def initialize (io)
+    def initialize(io)
       @io = io
+      @junk_offset = calc_junk_offset(io) || 0
       @xref = {}
       @trailer = load_offsets
     end
+
     ################################################################################
     # return the number of objects in this file. Objects with multiple generations are
     # only counter once.
@@ -93,6 +98,7 @@ class PDF::Reader
     #
     def load_offsets(offset = nil)
       offset ||= new_buffer.find_first_xref_offset
+      offset += @junk_offset
 
       buf = new_buffer(offset)
       tok_one = buf.token
@@ -108,7 +114,8 @@ class PDF::Reader
         return load_xref_stream(stream)
       end
 
-      raise PDF::Reader::MalformedPDFError, "xref table not found at offset #{offset} (#{tok_one} != xref)"
+      raise PDF::Reader::MalformedPDFError,
+        "xref table not found at offset #{offset} (#{tok_one} != xref)"
     end
     ################################################################################
     # Assumes the underlying buffer is positioned at the start of a traditional
@@ -124,7 +131,7 @@ class PDF::Reader
             generation = buf.token.to_i
             state = buf.token
 
-            store(objid, generation, offset) if state == "n" && offset > 0
+            store(objid, generation, offset + @junk_offset) if state == "n" && offset > 0
             objid += 1
             params.clear
           end
@@ -134,7 +141,9 @@ class PDF::Reader
 
       trailer = Parser.new(buf, self).parse_token
 
-      raise MalformedPDFError, "PDF malformed, trailer should be a dictionary" unless trailer.kind_of?(Hash)
+      unless trailer.kind_of?(Hash)
+        raise MalformedPDFError, "PDF malformed, trailer should be a dictionary"
+      end
 
       load_offsets(trailer[:XRefStm])   if trailer.has_key?(:XRefStm)
       load_offsets(trailer[:Prev].to_i) if trailer.has_key?(:Prev)
@@ -143,7 +152,7 @@ class PDF::Reader
     end
 
     ################################################################################
-    # Read a XReaf stream from the underlying buffer instead of a traditional xref table.
+    # Read an XRef stream from the underlying buffer instead of a traditional xref table.
     #
     def load_xref_stream(stream)
       unless stream.is_a?(PDF::Reader::Stream) && stream.hash[:Type] == :XRef
@@ -169,7 +178,7 @@ class PDF::Reader
           f2    = unpack_bytes(entry[widths[0],widths[1]])
           f3    = unpack_bytes(entry[widths[0]+widths[1],widths[2]])
           if f1 == 1 && f2 > 0
-            store(objid, f3, f2)
+            store(objid, f3, f2 + @junk_offset)
           elsif f1 == 2 && f2 > 0
             store(objid, 0, PDF::Reader::Reference.new(f2, 0))
           end
@@ -195,15 +204,17 @@ class PDF::Reader
         ("\x00" + bytes).unpack("N")[0]
       elsif bytes.size == 4
         bytes.unpack("N")[0]
+      elsif bytes.size == 8
+        bytes.unpack("Q>")[0]
       else
-        raise UnsupportedFeatureError, "Unable to unpack xref stream entries with more than 4 bytes"
+        raise UnsupportedFeatureError, "Unable to unpack xref stream entries of #{bytes.size} bytes"
       end
     end
     ################################################################################
     # Wrap the io stream we're working with in a buffer that can tokenise it for us.
     #
     # We create multiple buffers so we can be tokenising multiple sections of the file
-    # at the same time without worring about clearing the buffers contents.
+    # at the same time without worrying about clearing the buffers contents.
     #
     def new_buffer(offset = 0)
       PDF::Reader::Buffer.new(@io, :seek => offset)
@@ -211,9 +222,30 @@ class PDF::Reader
     ################################################################################
     # Stores an offset value for a particular PDF object ID and revision number
     #
-    def store (id, gen, offset)
+    def store(id, gen, offset)
       (@xref[id] ||= {})[gen] ||= offset
     end
+    ################################################################################
+    # Returns the offset of the PDF document in the +stream+. In theory this
+    # should always be 0, but all sort of crazy junk is prefixed to PDF files
+    # in the real world.
+    #
+    # Checks up to 1024 chars into the file,
+    # returns nil if no PDF data detected.
+    # Adobe PDF 1.4 spec (3.4.1) 12. Acrobat viewers require only that the
+    # header appear somewhere within the first 1024 bytes of the file
+    #
+    def calc_junk_offset(io)
+      io.rewind
+      offset = io.pos
+      until (c = io.readchar) == '%' || c == 37 || offset > 1024
+        offset += 1
+      end
+      io.rewind
+      offset < 1024 ? offset : nil
+    rescue EOFError
+      nil
+    end
   end
   ################################################################################
 end

data/lib/pdf/reader.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)
@@ -25,9 +28,6 @@
 ################################################################################
 
 require 'stringio'
-require 'zlib'
-
-require 'ascii85'
 
 module PDF
   ################################################################################
@@ -111,10 +111,10 @@ module PDF
     #
     #   reader = PDF::Reader.new("somefile.pdf", :password => "apples")
     #
-    def initialize(input = nil, opts = {})
-      if input # support the deprecated Reader API
-        @objects = PDF::Reader::ObjectHash.new(input, opts)
-      end
+    def initialize(input, opts = {})
+      @cache   = PDF::Reader::ObjectCache.new
+      opts.merge!(:cache => @cache)
+      @objects = PDF::Reader::ObjectHash.new(input, opts)
     end
 
     def info
@@ -128,13 +128,16 @@ module PDF
         nil
       else
         xml = stream.unfiltered_data
-        xml.force_encoding("utf-8") if xml.respond_to?(:force_encoding)
+        xml.force_encoding("utf-8")
         xml
       end
     end
 
     def page_count
       pages = @objects.deref(root[:Pages])
+      unless pages.kind_of?(::Hash)
+        raise MalformedPDFError, 'Pages structure is missing'
+      end
       @page_count ||= @objects.deref(pages[:Count])
     end
 
@@ -159,53 +162,6 @@ module PDF
       yield PDF::Reader.new(input, opts)
     end
 
-    # DEPRECATED: this method was deprecated in version 1.0.0 and will
-    #             eventually be removed
-    #
-    #
-    # Parse the file with the given name, sending events to the given receiver.
-    #
-    def self.file(name, receivers, opts = {})
-      File.open(name,"rb") do |f|
-        new.parse(f, receivers, opts)
-      end
-    end
-
-    # DEPRECATED: this method was deprecated in version 1.0.0 and will
-    #             eventually be removed
-    #
-    # Parse the given string, sending events to the given receiver.
-    #
-    def self.string(str, receivers, opts = {})
-      StringIO.open(str) do |s|
-        new.parse(s, receivers, opts)
-      end
-    end
-
-    # DEPRECATED: this method was deprecated in version 1.0.0 and will
-    #             eventually be removed
-    #
-    # Parse the file with the given name, returning an unmarshalled ruby version of
-    # represents the requested pdf object
-    #
-    def self.object_file(name, id, gen = 0)
-      File.open(name,"rb") { |f|
-        new.object(f, id.to_i, gen.to_i)
-      }
-    end
-
-    # DEPRECATED: this method was deprecated in version 1.0.0 and will
-    #             eventually be removed
-    #
-    # Parse the given string, returning an unmarshalled ruby version of represents
-    # the requested pdf object
-    #
-    def self.object_string(str, id, gen = 0)
-      StringIO.open(str) { |s|
-        new.object(s, id.to_i, gen.to_i)
-      }
-    end
-
     # returns an array of PDF::Reader::Page objects, one for each
     # page in the source PDF.
     #
@@ -221,9 +177,13 @@ module PDF
     # methods available on each page
     #
     def pages
-      (1..self.page_count).map { |num|
-        PDF::Reader::Page.new(@objects, num)
-      }
+      (1..self.page_count).map do |num|
+        begin
+          PDF::Reader::Page.new(@objects, num, :cache => @cache)
+        rescue InvalidPageError
+          raise MalformedPDFError, "Missing data for page: #{num}"
+        end
+      end
     end
 
     # returns a single PDF::Reader::Page for the specified page.
@@ -240,38 +200,10 @@ module PDF
     #
     def page(num)
       num = num.to_i
-      raise ArgumentError, "valid pages are 1 .. #{self.page_count}" if num < 1 || num > self.page_count
-      PDF::Reader::Page.new(@objects, num)
-    end
-
-
-    # DEPRECATED: this method was deprecated in version 1.0.0 and will
-    #             eventually be removed
-    #
-    # Given an IO object that contains PDF data, parse it.
-    #
-    def parse(io, receivers, opts = {})
-      ohash    = ObjectHash.new(io)
-
-      options = {:pages => true, :raw_text => false, :metadata => true}
-      options.merge!(opts)
-
-      strategies.each do |s|
-        s.new(ohash, receivers, options).process
+      if num < 1 || num > self.page_count
+        raise InvalidPageError, "Valid pages are 1 .. #{self.page_count}"
       end
-
-      self
-    end
-
-    # DEPRECATED: this method was deprecated in version 1.0.0 and will
-    #             eventually be removed
-    #
-    # Given an IO object that contains PDF data, return the contents of a single object
-    #
-    def object (io, id, gen)
-      @objects = ObjectHash.new(io)
-
-      @objects.deref(Reference.new(id, gen))
+      PDF::Reader::Page.new(@objects, num, :cache => @cache)
     end
 
     private
@@ -295,14 +227,14 @@ module PDF
           pdfdoc_to_utf8(obj)
         end
       else
-        obj
+        @objects.deref(obj)
       end
     end
 
     # TODO find a PDF I can use to spec this behaviour
     #
     def pdfdoc_to_utf8(obj)
-      obj.force_encoding("utf-8") if obj.respond_to?(:force_encoding)
+      obj.force_encoding("utf-8")
       obj
     end
 
@@ -312,19 +244,18 @@ module PDF
     def utf16_to_utf8(obj)
       str = obj[2, obj.size]
       str = str.unpack("n*").pack("U*")
-      str.force_encoding("utf-8") if str.respond_to?(:force_encoding)
+      str.force_encoding("utf-8")
       str
     end
 
-    def strategies
-      @strategies ||= [
-        ::PDF::Reader::MetadataStrategy,
-        ::PDF::Reader::PagesStrategy
-      ]
-    end
-
     def root
-      @root ||= @objects.deref(@objects.trailer[:Root])
+      @root ||= begin
+        obj = @objects.deref(@objects.trailer[:Root])
+        unless obj.kind_of?(::Hash)
+          raise MalformedPDFError, "PDF malformed, trailer Root should be a dictionary"
+        end
+        obj
+      end
     end
 
   end
@@ -332,17 +263,24 @@ end
 ################################################################################
 
 require 'pdf/reader/resource_methods'
-require 'pdf/reader/abstract_strategy'
 require 'pdf/reader/buffer'
+require 'pdf/reader/cid_widths'
 require 'pdf/reader/cmap'
 require 'pdf/reader/encoding'
 require 'pdf/reader/error'
 require 'pdf/reader/filter'
+require 'pdf/reader/filter/ascii85'
+require 'pdf/reader/filter/ascii_hex'
+require 'pdf/reader/filter/depredict'
+require 'pdf/reader/filter/flate'
+require 'pdf/reader/filter/lzw'
+require 'pdf/reader/filter/null'
+require 'pdf/reader/filter/run_length'
 require 'pdf/reader/font'
+require 'pdf/reader/font_descriptor'
 require 'pdf/reader/form_xobject'
 require 'pdf/reader/glyph_hash'
 require 'pdf/reader/lzw'
-require 'pdf/reader/metadata_strategy'
 require 'pdf/reader/object_cache'
 require 'pdf/reader/object_hash'
 require 'pdf/reader/object_stream'
@@ -351,12 +289,15 @@ require 'pdf/reader/parser'
 require 'pdf/reader/print_receiver'
 require 'pdf/reader/reference'
 require 'pdf/reader/register_receiver'
+require 'pdf/reader/null_security_handler'
 require 'pdf/reader/standard_security_handler'
+require 'pdf/reader/standard_security_handler_v5'
+require 'pdf/reader/unimplemented_security_handler'
 require 'pdf/reader/stream'
-require 'pdf/reader/text_receiver'
+require 'pdf/reader/text_run'
 require 'pdf/reader/page_state'
 require 'pdf/reader/page_text_receiver'
 require 'pdf/reader/token'
 require 'pdf/reader/xref'
+require 'pdf/reader/orientation_detector'
 require 'pdf/reader/page'
-require 'pdf/hash'