pdf-reader 0.8.6 → 0.9.0

data/lib/pdf/reader.rb

@@ -9,10 +9,10 @@
 # distribute, sublicense, and/or sell copies of the Software, and to
 # permit persons to whom the Software is furnished to do so, subject to
 # the following conditions:
-# 
+#
 # The above copyright notice and this permission notice shall be
 # included in all copies or substantial portions of the Software.
-# 
+#
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -24,6 +24,8 @@
 ################################################################################
 
 require 'stringio'
+require 'zlib'
+
 require 'ascii85'
 
 module PDF
@@ -37,77 +39,127 @@ module PDF
   # on receivers.
   #
   # = Parsing a file
-  #   
+  #
   #   PDF::Reader.file("somefile.pdf", receiver)
   #
   # = Parsing a String
-  # 
+  #
   # This is useful for processing a PDF that is already in memory
   #
   #   PDF::Reader.string(pdf_string, receiver)
   #
   # = Parsing an IO object
-  # 
+  #
   # This can be a useful alternative to the first 2 options in some situations
   #
   #   pdf = PDF::Reader.new
   #   pdf.parse(File.new("somefile.pdf"), receiver)
   #
   # = Parsing parts of a file
-  # 
-  # Both PDF::Reader#file and PDF::Reader#string accept a 3 argument that specifies which
-  # parts of the file to process. By default, all options are enabled, so this can be useful 
-  # to cut down processing time if you're only interested in say, metadata.
   #
-  # As an example, the following call will disable parsing the contents of pages in the file,
-  # but explicitly enables processing metadata.
+  # Both PDF::Reader#file and PDF::Reader#string accept a third argument that
+  # specifies which parts of the file to process. By default, all options are
+  # enabled, so this can be useful to cut down processing time if you're only
+  # interested in say, metadata.
+  #
+  # As an example, the following call will disable parsing the contents of
+  # pages in the file, but explicitly enables processing metadata.
   #
   #   PDF::Reader.new("somefile.pdf", receiver, {:metadata => true, :pages => false})
   #
   # Available options are currently:
-  #   
+  #
   #   :metadata
   #   :pages
+  #   :raw_text
+  #
   class Reader
-    ################################################################################
+
     # Parse the file with the given name, sending events to the given receiver.
+    #
     def self.file(name, receiver, opts = {})
       File.open(name,"rb") do |f|
         new.parse(f, receiver, opts)
       end
     end
-    ################################################################################
+
     # Parse the given string, sending events to the given receiver.
+    #
     def self.string(str, receiver, opts = {})
       StringIO.open(str) do |s|
         new.parse(s, receiver, opts)
       end
     end
-    ################################################################################
-    def self.object_file(name, id, gen)
-      File.open(name,"rb") do |f|
-        new.object(f, id, gen)
-      end
+
+    # 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
-    ################################################################################
-    def self.object_string(name, id, gen)
-      StringIO.open(str) do |s|
-        new.object(s, id, gen)
+
+    # 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
+
+    # Given an IO object that contains PDF data, parse it.
+    #
+    def parse(io, receiver, opts = {})
+      ohash    = ObjectHash.new(io)
+
+      if ohash.trailer[:Encrypt]
+        raise PDF::Reader::UnsupportedFeatureError, 'PDF::Reader cannot read encrypted PDF files'
+      end
+
+      options = {:pages => true, :raw_text => false, :metadata => true}
+      options.merge!(opts)
+
+      strategies.each do |s|
+        s.new(ohash, receiver, options).process
       end
+
+      self
+    end
+
+    # Given an IO object that contains PDF data, return the contents of a single object
+    #
+    def object (io, id, gen)
+      @ohash = ObjectHash.new(io)
+
+      @ohash.object(Reference.new(id, gen))
+    end
+
+    private
+
+    def strategies
+      @strategies ||= [
+        PDF::Reader::MetadataStrategy,
+        PDF::Reader::PagesStrategy
+      ]
     end
-    ################################################################################
   end
-  ################################################################################
 end
 ################################################################################
-require 'pdf/reader/explore'
+
+require 'pdf/reader/abstract_strategy'
 require 'pdf/reader/buffer'
 require 'pdf/reader/cmap'
-require 'pdf/reader/content'
 require 'pdf/reader/encoding'
 require 'pdf/reader/error'
 require 'pdf/reader/filter'
 require 'pdf/reader/font'
+require 'pdf/reader/lzw'
+require 'pdf/reader/metadata_strategy'
+require 'pdf/reader/object_hash'
+require 'pdf/reader/object_stream'
+require 'pdf/reader/pages_strategy'
 require 'pdf/reader/parser'
 require 'pdf/reader/print_receiver'
 require 'pdf/reader/reference'
@@ -117,31 +169,3 @@ require 'pdf/reader/text_receiver'
 require 'pdf/reader/token'
 require 'pdf/reader/xref'
 require 'pdf/hash'
-
-class PDF::Reader
-  ################################################################################
-  # Given an IO object that contains PDF data, parse it.
-  def parse (io, receiver, opts = {})
-    @xref     = XRef.new(io)
-    @content  = (receiver == Explore ? Explore : Content).new(receiver, @xref)
-
-    options = {:pages => true, :metadata => true}
-    options.merge!(opts)
-
-    trailer = @xref.load
-    raise PDF::Reader::UnsupportedFeatureError, 'PDF::Reader cannot read encrypted PDF files' if trailer[:Encrypt]
-    @content.metadata(@xref.object(trailer[:Root]), @xref.object(trailer[:Info])) if options[:metadata]
-    @content.document(@xref.object(trailer[:Root])) if options[:pages]
-    self
-  end
-  ################################################################################
-  # Given an IO object that contains PDF data, return the contents of a single object
-  def object (io, id, gen)
-    @xref     = XRef.new(io)
-    @xref.load
-
-    @xref.object(Reference.new(id, gen))
-  end
-  ################################################################################
-end
-################################################################################

data/lib/pdf/reader/abstract_strategy.rb

@@ -0,0 +1,77 @@
+# coding: utf-8
+
+class PDF::Reader
+
+  class AbstractStrategy # :nodoc:
+
+    def initialize(ohash, receiver, options = {})
+      @ohash, @receiver, @options = ohash, receiver, options
+    end
+
+    private
+
+    def options
+      @options || {}
+    end
+
+    # calls the name callback method on the receiver class with params as the arguments
+    #
+    def callback (name, params=[])
+      receiver.send(name, *params) if receiver.respond_to?(name)
+    end
+
+    # strings outside of page content should be in either PDFDocEncoding or UTF-16.
+    def decode_strings(obj)
+      case obj
+      when String then
+        if obj[0,2].unpack("C*").slice(0,2) == [254,255]
+          PDF::Reader::Encoding.new(:UTF16Encoding).to_utf8(obj[2, obj.size])
+        else
+          PDF::Reader::Encoding.new(:PDFDocEncoding).to_utf8(obj)
+        end
+      when Hash   then obj.each { |key,val| obj[key] = decode_strings(val) }
+      when Array  then obj.collect { |item| decode_strings(item) }
+      else
+        obj
+      end
+    end
+
+    def info
+      ohash.object(trailer[:Info])
+    end
+
+    def info?
+      info ? true : false
+    end
+
+    def ohash
+      @ohash
+    end
+
+    def pages
+      ohash.object(root[:Pages])
+    end
+
+    def pages?
+      pages ? true : false
+    end
+
+    def receiver
+      @receiver
+    end
+
+    def root
+      ohash.object(trailer[:Root])
+    end
+
+    def root?
+      root ? true : false
+    end
+
+    def trailer
+      ohash.trailer
+    end
+
+  end
+end
+

data/lib/pdf/reader/buffer.rb

@@ -48,11 +48,13 @@ class PDF::Reader
     # options:
     #
     #   :seek - a byte offset to seek to before starting to tokenise
+    #   :content_stream - set to true if buffer will be tokenising a
+    #                     content stream. Defaults to false
     #
     def initialize (io, opts = {})
       @io = io
       @tokens = []
-      @options = opts
+      @in_content_stream = opts[:content_stream]
 
       @io.seek(opts[:seek]) if opts[:seek]
       @pos = @io.pos
@@ -98,30 +100,6 @@ class PDF::Reader
       bytes
     end
 
-    # return raw bytes from the underlying IO stream. All bytes up to the first
-    # occurrence of needle will be returned. The match (if any) is not returned.
-    # The IO stream cursor is left on the first byte of the match.
-    #
-    #   needle - a string to search the IO stream for
-    #
-    def read_until(needle)
-      reset_pos
-      out = ""
-      size = needle.size
-
-      while out[size * -1, size] != needle && !@io.eof?
-        out << @io.read(1)
-      end
-
-      if out[size * -1, size] == needle
-        out = out[0, out.size - size]
-        @io.seek(size * -1, IO::SEEK_CUR)
-      end
-
-      save_pos
-      out
-    end
-
     # return the next token from the source. Returns a string if a token
     # is found, nil if there are no tokens left.
     #
@@ -141,19 +119,8 @@ class PDF::Reader
       data = @io.read(1024)
 
       # the PDF 1.7 spec (section #3.4) says that EOL markers can be either \r, \n, or both.
-      # To ensure we find the xref offset correctly, change all possible options to a
-      # standard format
-      data = data.gsub("\r\n","\n").gsub("\n\r","\n").gsub("\r","\n")
-      lines = data.split(/\n/).reverse
-
-      eof_index = nil
-
-      lines.each_with_index do |line, index|
-        if line =~ /^%%EOF\r?$/
-          eof_index = index
-          break
-        end
-      end
+      lines = data.split(/[\n\r]+/).reverse
+      eof_index = lines.index { |l| l.strip == "%%EOF" }
 
       raise MalformedPDFError, "PDF does not contain EOF marker" if eof_index.nil?
       raise MalformedPDFError, "PDF EOF marker does not follow offset" if eof_index >= lines.size-1
@@ -162,6 +129,12 @@ class PDF::Reader
 
     private
 
+    # Returns true if this buffer is parsing a content stream
+    #
+    def in_content_stream?
+      @in_content_stream ? true : false
+    end
+
     # Some bastard moved our IO stream cursor. Restore it.
     #
     def reset_pos
@@ -181,8 +154,12 @@ class PDF::Reader
       10.times do
         if state == :literal_string
           prepare_literal_token
+        elsif state == :hex_string
+          prepare_hex_token
         elsif state == :regular
           prepare_regular_token
+        elsif state == :inline
+          prepare_inline_token
         end
       end
 
@@ -195,8 +172,12 @@ class PDF::Reader
     def state
       if @tokens[-1] == "("
         :literal_string
+      elsif @tokens[-1] == "<"
+        :hex_string
       elsif @tokens[-1] == "stream"
         :stream
+      elsif in_content_stream? && @tokens[-1] == "ID"
+        :inline
       else
         :regular
       end
@@ -226,6 +207,44 @@ class PDF::Reader
       end
     end
 
+    def prepare_inline_token
+      str = ""
+
+      while str[-2,2] != "EI"
+        chr = @io.read(1)
+        break if chr.nil?
+        str << chr
+      end
+
+      @tokens << str[0, str.size-2].strip
+      @io.seek(-2, IO::SEEK_CUR) unless chr.nil?
+    end
+
+    # if we're currently inside a hex string, read hex nibbles until
+    # we find a closing >
+    #
+    def prepare_hex_token
+      str = ""
+      finished = false
+
+      while !finished
+        chr = @io.read(1)
+        codepoint = chr.to_s.unpack("C*").first
+        if chr.nil?
+          finished = true # unbalanced params
+        elsif (48..57).include?(codepoint) || (65..90).include?(codepoint) || (97..122).include?(codepoint)
+          str << chr
+        elsif codepoint <= 32
+          # ignore it
+        else
+          @tokens << str if str.size > 0
+          @tokens << ">" if chr != ">"
+          @tokens << chr
+          finished = true
+        end
+      end
+    end
+
     # if we're currently inside a literal string we more or less just read bytes until
     # we find the closing ) delimiter. Lots of bytes that would otherwise indicate the
     # start of a new token in regular mode are left untouched when inside a literal
@@ -243,10 +262,12 @@ class PDF::Reader
         chr = @io.read(1)
         if chr.nil?
           count = 0 # unbalanced params
-        elsif chr == "(" && str[-1,1] != "\x5C"
+        elsif chr == "\x5c"
+          str << chr << @io.read(1).to_s
+        elsif chr == "("
           str << "("
           count += 1
-        elsif chr == ")" && str[-1,1] != "\x5C"
+        elsif chr == ")"
           count -= 1
           str << ")" unless count == 0
         else

data/lib/pdf/reader/cmap.rb

@@ -24,30 +24,31 @@
 ################################################################################
 
 class PDF::Reader
-  class CMap
+  class CMap # :nodoc:
 
     def initialize(data)
       @map = {}
-      in_char_mode = false
-      in_range_mode = false
+      process_data(data)
+    end
+
+    def process_data(data)
+      mode = nil
       instructions = ""
 
       data.each_line do |l|
         if l.include?("beginbfchar")
-          in_char_mode = true
+          mode = :char
         elsif l.include?("endbfchar")
           process_bfchar_instructions(instructions)
           instructions = ""
-          in_char_mode = false
+          mode = nil
         elsif l.include?("beginbfrange")
-          in_range_mode = true
+          mode = :range
         elsif l.include?("endbfrange")
           process_bfrange_instructions(instructions)
           instructions = ""
-          in_range_mode = false
-        end
-
-        if !l.include?("begin") && (in_char_mode || in_range_mode)
+          mode = nil
+        elsif mode == :char || mode == :range
           instructions << l
         end
       end