pdf-reader 0.8.6 → 0.9.0

data/lib/pdf/reader/metadata_strategy.rb

@@ -0,0 +1,53 @@
+# coding: utf-8
+
+class PDF::Reader
+
+  class MetadataStrategy < AbstractStrategy # :nodoc:
+
+    def self.to_sym
+      :metadata
+    end
+
+    def process
+      return false unless options[:metadata]
+
+      # may be useful to some people
+      callback(:pdf_version, ohash.pdf_version)
+
+      # ye olde metadata
+      callback(:metadata, [decoded_info]) if info?
+
+      # new style xml metadata
+      callback(:xml_metadata, [xml_metadata]) if xml_metadata?
+
+      # page count
+      if pages?
+        count = ohash.object(pages[:Count])
+        callback(:page_count, count.to_i)
+      end
+    end
+
+    private
+
+    def xml_metadata
+      return @xml_metadata if defined?(@xml_metadata)
+
+      if root[:Metadata].nil?
+        @xml_metadata = nil
+      else
+        string = ohash.object(root[:Metadata]).unfiltered_data
+        string.force_encoding("utf-8") if string.respond_to?(:force_encoding)
+        @xml_metadata = string
+      end
+    end
+
+    def xml_metadata?
+      xml_metadata ? true : false
+    end
+
+    def decoded_info
+      @decoded_info ||= decode_strings(info)
+    end
+
+  end
+end

data/lib/pdf/reader/object_hash.rb

@@ -0,0 +1,275 @@
+# coding: utf-8
+
+class PDF::Reader
+  # Provides low level access to the objects in a PDF file via a hash-like
+  # object.
+  #
+  # A PDF file can be viewed as a large hash map. It is a series of objects
+  # stored at an exact byte offsets, and a table that maps object IDs to byte
+  # offsets. Given an object ID, looking up an object is an O(1) operation.
+  #
+  # Each PDF object can be mapped to a ruby object, so by passing an object
+  # ID to the [] method, a ruby representation of that object will be
+  # retrieved.
+  #
+  # The class behaves much like a standard Ruby hash, including the use of
+  # the Enumerable mixin. The key difference is no []= method - the hash
+  # is read only.
+  #
+  # == Basic Usage
+  #
+  #     h = PDF::Reader::ObjectHash.new("somefile.pdf")
+  #     h[1]
+  #     => 3469
+  #
+  #     h[PDF::Reader::Reference.new(1,0)]
+  #     => 3469
+  #
+  class ObjectHash
+    include Enumerable
+
+    attr_accessor :default
+    attr_reader :trailer, :pdf_version
+
+    # Creates a new ObjectHash object. input can be a string with a valid filename,
+    # a string containing a PDF file, or an IO object.
+    #
+    def initialize(input)
+      if input.respond_to?(:seek) && input.respond_to?(:read)
+        @io = input
+      elsif File.file?(input.to_s)
+        if File.respond_to?(:binread)
+          input = File.binread(input.to_s)
+        else
+          input = File.read(input.to_s)
+        end
+        @io = StringIO.new(input)
+      else
+        raise ArgumentError, "input must be an IO-like object or a filename"
+      end
+      @pdf_version = read_version
+      @xref        = PDF::Reader::XRef.new(@io)
+      @trailer     = @xref.trailer
+    end
+
+    # returns the type of object a ref points to
+    def obj_type(ref)
+      self[ref].class.to_s.to_sym
+    rescue
+      nil
+    end
+
+    # returns true if the supplied references points to an object with a stream
+    def stream?(ref)
+      self[ref].class == PDF::Reader::Stream
+    rescue
+      false
+    end
+
+    # Access an object from the PDF. key can be an int or a PDF::Reader::Reference
+    # object.
+    #
+    # If an int is used, the object with that ID and a generation number of 0 will
+    # be returned.
+    #
+    # If a PDF::Reader::Reference object is used the exact ID and generation number
+    # can be specified.
+    #
+    def [](key)
+      return default if key.to_i <= 0
+      begin
+        unless key.kind_of?(PDF::Reader::Reference)
+          key = PDF::Reader::Reference.new(key.to_i, 0)
+        end
+        if xref[key].is_a?(Fixnum)
+          buf = new_buffer(xref[key])
+          Parser.new(buf, self).object(key.id, key.gen)
+        elsif xref[key].is_a?(PDF::Reader::Reference)
+          container_key = xref[key]
+          object_streams[container_key] ||= PDF::Reader::ObjectStream.new(object(container_key))
+          object_streams[container_key][key.id]
+        end
+      rescue InvalidObjectError
+        return default
+      end
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    def object(key)
+      key.is_a?(PDF::Reader::Reference) ? self[key] : key
+    end
+
+    # Access an object from the PDF. key can be an int or a PDF::Reader::Reference
+    # object.
+    #
+    # If an int is used, the object with that ID and a generation number of 0 will
+    # be returned.
+    #
+    # If a PDF::Reader::Reference object is used the exact ID and generation number
+    # can be specified.
+    #
+    # local_default is the object that will be returned if the requested key doesn't
+    # exist.
+    #
+    def fetch(key, local_default = nil)
+      obj = self[key]
+      if obj
+        return obj
+      elsif local_default
+        return local_default
+      else
+        raise IndexError, "#{key} is invalid" if key.to_i <= 0
+      end
+    end
+
+    # iterate over each key, value. Just like a ruby hash.
+    #
+    def each(&block)
+      @xref.each do |ref|
+        yield ref, self[ref]
+      end
+    end
+    alias :each_pair :each
+
+    # iterate over each key. Just like a ruby hash.
+    #
+    def each_key(&block)
+      each do |id, obj|
+        yield id
+      end
+    end
+
+    # iterate over each value. Just like a ruby hash.
+    #
+    def each_value(&block)
+      each do |id, obj|
+        yield obj
+      end
+    end
+
+    # return the number of objects in the file. An object with multiple generations
+    # is counted once.
+    def size
+      xref.size
+    end
+    alias :length :size
+
+    # return true if there are no objects in this file
+    #
+    def empty?
+      size == 0 ? true : false
+    end
+
+    # return true if the specified key exists in the file. key
+    # can be an int or a PDF::Reader::Reference
+    #
+    def has_key?(check_key)
+      # TODO update from O(n) to O(1)
+      each_key do |key|
+        if check_key.kind_of?(PDF::Reader::Reference)
+          return true if check_key == key
+        else
+          return true if check_key.to_i == key.id
+        end
+      end
+      return false
+    end
+    alias :include? :has_key?
+    alias :key? :has_key?
+    alias :member? :has_key?
+
+    # return true if the specifiedvalue exists in the file
+    #
+    def has_value?(value)
+      # TODO update from O(n) to O(1)
+      each_value do |obj|
+        return true if obj == value
+      end
+      return false
+    end
+    alias :value? :has_key?
+
+    def to_s
+      "<PDF::Reader::ObejctHash size: #{self.size}>"
+    end
+
+    # return an array of all keys in the file
+    #
+    def keys
+      ret = []
+      each_key { |k| ret << k }
+      ret
+    end
+
+    # return an array of all values in the file
+    #
+    def values
+      ret = []
+      each_value { |v| ret << v }
+      ret
+    end
+
+    # return an array of all values from the specified keys
+    #
+    def values_at(*ids)
+      ids.map { |id| self[id] }
+    end
+
+    # return an array of arrays. Each sub array contains a key/value pair.
+    #
+    def to_a
+      ret = []
+      each do |id, obj|
+        ret << [id, obj]
+      end
+      ret
+    end
+
+    # returns an array of PDF::Reader::References. Each reference in the
+    # array points a Page object, one for each page in the PDF. The first
+    # reference is page 1, second reference is page 2, etc.
+    #
+    # Useful for apps that want to extract data from specific pages.
+    #
+    def page_references
+      root  = fetch(trailer[:Root])
+      @page_references ||= get_page_objects(root[:Pages]).flatten
+    end
+
+    private
+
+    def new_buffer(offset = 0)
+      PDF::Reader::Buffer.new(@io, :seek => offset)
+    end
+
+    def xref
+      @xref
+    end
+
+    def object_streams
+      @object_stream ||= {}
+    end
+
+    # returns a nested array of object references for all pages in this object store.
+    #
+    def get_page_objects(ref)
+      obj = fetch(ref)
+
+      if obj[:Type] == :Page
+        ref
+      elsif obj[:Type] == :Pages
+        obj[:Kids].map { |kid| get_page_objects(kid) }
+      end
+    end
+
+    def read_version
+      @io.seek(0)
+      m, version = *@io.read(10).match(/PDF-(\d.\d)/)
+      @io.seek(0)
+      version.to_f
+    end
+
+  end
+end

data/lib/pdf/reader/object_stream.rb

@@ -0,0 +1,51 @@
+# coding: utf-8
+
+class PDF::Reader
+
+  # provides a wrapper around a PDF stream object that contains other objects in it.
+  # This is done for added compression and is described as an "Object Stream" in the spec.
+  #
+  class ObjectStream # :nodoc:
+    def initialize(stream)
+      @dict = stream.hash
+      @data = stream.unfiltered_data
+    end
+
+    def [](objid)
+      if offsets[objid].nil?
+        nil
+      else
+        buf = PDF::Reader::Buffer.new(StringIO.new(@data), :seek => offsets[objid])
+        parser = PDF::Reader::Parser.new(buf)
+        parser.parse_token
+      end
+    end
+
+    def size
+      @dict[:N]
+    end
+
+    private
+
+    def offsets
+      @offsets ||= {}
+      return @offsets if @offsets.keys.size > 0
+
+      size.times do
+        @offsets[buffer.token.to_i] = first + buffer.token.to_i
+      end
+      @offsets
+    end
+
+    def first
+      @dict[:First]
+    end
+
+    def buffer
+      @buffer ||= PDF::Reader::Buffer.new(StringIO.new(@data))
+    end
+
+  end
+
+end
+

data/lib/pdf/reader/{content.rb → pages_strategy.rb}

@@ -22,12 +22,11 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 ################################################################################
-require 'stringio'
 
 class PDF::Reader
   ################################################################################
-  # Walks the PDF file and calls the appropriate callback methods when something of interest is
-  # found.
+  # Walks the pages of the PDF file and calls the appropriate callback methods when
+  # something of interest is found.
   #
   # The callback methods should exist on the receiver object passed into the constructor. Whenever
   # some content is found that will trigger a callback, the receiver is checked to see if the callback
@@ -78,6 +77,14 @@ class PDF::Reader
   # - move_to_next_line_and_show_text
   # - set_spacing_next_line_show_text
   #
+  # If the :raw_text option was passed to the PDF::Reader class the following callbacks
+  # may also appear:
+  #
+  # - show_text_raw
+  # - show_text_with_positioning_raw
+  # - move_to_next_line_and_show_text_raw
+  # - set_spacing_next_line_show_text_raw
+  #
   # == Graphics Callbacks
   # - close_fill_stroke
   # - fill_stroke
@@ -168,7 +175,7 @@ class PDF::Reader
   # If it gets mapped to the name "IM1", then it can be placed on the page using
   # invoke_xobject "IM1".
   #
-  class Content
+  class PagesStrategy< AbstractStrategy # :nodoc:
     OPERATORS = {
       'b'   => :close_fill_stroke,
       'B'   => :fill_stroke,
@@ -244,45 +251,19 @@ class PDF::Reader
       '\''  => :move_to_next_line_and_show_text,
       '"'   => :set_spacing_next_line_show_text,
     }
-    ################################################################################
-    # Create a new PDF::Reader::Content object to process the contents of PDF file
-    # - receiver - an object containing the required callback methods
-    # - xref     - a PDF::Reader::Xref object that contains references to all the objects in a PDF file
-    def initialize (receiver, xref)
-      @receiver = receiver
-      @xref     = xref
-    end
-    ################################################################################
-    # Begin processing the document metadata
-    def metadata (root, info)
-      info = decode_strings(info)
-
-      # may be useful to some people
-      callback(:pdf_version, @xref.pdf_version)
-
-      # ye olde metadata
-      callback(:metadata, [info]) if info
-
-      # new style xml metadata
-      if root[:Metadata]
-        stream = @xref.object(root[:Metadata])
-        callback(:xml_metadata,stream.unfiltered_data)
-      end
-
-      # page count
-      if (pages = @xref.object(root[:Pages]))
-        if (count = @xref.object(pages[:Count]))
-          callback(:page_count, count.to_i)
-        end
-      end
+    def self.to_sym
+      :pages
     end
     ################################################################################
     # Begin processing the document
-    def document (root)
+    def process
+      return false unless options[:pages]
+
       callback(:begin_document, [root])
-      walk_pages(@xref.object(root[:Pages]))
+      walk_pages(@ohash.object(root[:Pages]))
       callback(:end_document)
     end
+    private
     ################################################################################
     # Walk over all pages in the PDF file, calling the appropriate callbacks for each page and all
     # its content
@@ -291,19 +272,19 @@ class PDF::Reader
       # extract page content
       if page[:Type] == :Pages
         callback(:begin_page_container, [page])
-        res = @xref.object(page[:Resources])
+        res = @ohash.object(page[:Resources])
         resources.push res if res
-        @xref.object(page[:Kids]).each {|child| walk_pages(@xref.object(child))}
+        @ohash.object(page[:Kids]).each {|child| walk_pages(@ohash.object(child))}
         resources.pop if res
         callback(:end_page_container)
       elsif page[:Type] == :Page
         callback(:begin_page, [page])
-        res = @xref.object(page[:Resources])
+        res = @ohash.object(page[:Resources])
         resources.push res if res
         walk_resources(current_resources)
 
-        if @xref.object(page[:Contents]).kind_of?(Array)
-          contents = @xref.object(page[:Contents])
+        if @ohash.object(page[:Contents]).kind_of?(Array)
+          contents = @ohash.object(page[:Contents])
         else
           contents = [page[:Contents]]
         end
@@ -311,10 +292,8 @@ class PDF::Reader
         fonts = font_hash_from_resources(current_resources)
 
         if page.has_key?(:Contents) and page[:Contents]
-          contents.each do |content|
-            obj = @xref.object(content)
-            content_stream(obj, fonts)
-          end 
+          direct_contents = contents.map { |content| @ohash.object(content) }
+          content_stream(direct_contents, fonts)
         end
 
         resources.pop if res
@@ -326,12 +305,12 @@ class PDF::Reader
     # like a regular page content stream.
     #
     def walk_xobject_form(label)
-      xobjects = @xref.object(current_resources[:XObject]) || {}
-      xobject  = @xref.object(xobjects[label])
+      xobjects = @ohash.object(current_resources[:XObject]) || {}
+      xobject  = @ohash.object(xobjects[label])
 
       if xobject && xobject.hash[:Subtype] == :Form
         callback(:begin_form_xobject)
-        resources = @xref.object(xobject.hash[:Resources])
+        resources = @ohash.object(xobject.hash[:Resources])
         walk_resources(resources) if resources
         fonts = font_hash_from_resources(resources)
         content_stream(xobject, fonts)
@@ -352,30 +331,40 @@ class PDF::Reader
     ################################################################################
     # Reads a PDF content stream and calls all the appropriate callback methods for the operators
     # it contains
+    #
     def content_stream (instructions, fonts = {})
-      instructions = instructions.unfiltered_data if instructions.kind_of?(PDF::Reader::Stream)
-      buffer       = Buffer.new(StringIO.new(instructions))
-      parser       = Parser.new(buffer, @xref)
+      instructions = [instructions] unless instructions.kind_of?(Array)
+      instructions = instructions.map { |ins|
+        ins.is_a?(PDF::Reader::Stream) ? ins.unfiltered_data : ins.to_s
+      }.join
+      buffer       = Buffer.new(StringIO.new(instructions), :content_stream => true)
+      parser       = Parser.new(buffer, @ohash)
       current_font = nil
       params       = []
 
       while (token = parser.parse_token(OPERATORS))
         if token.kind_of?(Token) and OPERATORS.has_key?(token)
-          current_font = params.first if OPERATORS[token] == :set_text_font_and_size
+           if OPERATORS[token] == :set_text_font_and_size
+            current_font = params.first
+            if fonts[current_font].nil?
+              raise MalformedPDFError, "Unknown font #{current_font}"
+            end
+          end
 
           # handle special cases in response to certain operators
-          if OPERATORS[token].to_s.include?("show_text") && fonts[current_font]
-            # convert any text to utf-8
+          if OPERATORS[token].to_s.include?("show_text")
+            # convert any text to utf-8, but output the raw string if the user wants it
+            if options[:raw_text]
+              callback("#{OPERATORS[token]}_raw".to_sym, params)
+            end
             params = fonts[current_font].to_utf8(params)
           elsif token == "ID"
             # inline image data, first convert the current params into a more familiar hash
             map = {}
-            params.each_slice(2) do |a|
-              map[a.first] = a.last
+            params.each_slice(2) do |key, value|
+              map[key] = value
             end
-            params = [map]
-            # read the raw image data from the buffer without tokenising
-            params << buffer.read_until("EI")
+            params = [map, buffer.token]
           end
 
           callback(OPERATORS[token], params)
@@ -407,29 +396,29 @@ class PDF::Reader
 
       # extract any xobject information
       if resources[:XObject]
-        @xref.object(resources[:XObject]).each do |name, val|
-          callback(:resource_xobject, [name, @xref.object(val)])
+        @ohash.object(resources[:XObject]).each do |name, val|
+          callback(:resource_xobject, [name, @ohash.object(val)])
         end
       end
 
       # extract any extgstate information
       if resources[:ExtGState]
-        @xref.object(resources[:ExtGState]).each do |name, val|
-          callback(:resource_extgstate, [name, @xref.object(val)])
+        @ohash.object(resources[:ExtGState]).each do |name, val|
+          callback(:resource_extgstate, [name, @ohash.object(val)])
         end
       end
 
       # extract any colorspace information
       if resources[:ColorSpace]
-        @xref.object(resources[:ColorSpace]).each do |name, val|
-          callback(:resource_colorspace, [name, @xref.object(val)])
+        @ohash.object(resources[:ColorSpace]).each do |name, val|
+          callback(:resource_colorspace, [name, @ohash.object(val)])
         end
       end
 
       # extract any pattern information
       if resources[:Pattern]
-        @xref.object(resources[:Pattern]).each do |name, val|
-          callback(:resource_pattern, [name, @xref.object(val)])
+        @ohash.object(resources[:Pattern]).each do |name, val|
+          callback(:resource_pattern, [name, @ohash.object(val)])
         end
       end
 
@@ -449,7 +438,7 @@ class PDF::Reader
         obj.hash = resolve_references(obj.hash)
         obj
       when PDF::Reader::Reference then
-        resolve_references(@xref.object(obj))
+        resolve_references(@ohash.object(obj))
       when Hash                   then obj.each { |key,val| obj[key] = resolve_references(val) }
       when Array                  then obj.collect { |item| resolve_references(item) }
       else
@@ -457,53 +446,27 @@ class PDF::Reader
       end
     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
-    ################################################################################
-    private
     ################################################################################
     def font_hash_from_resources(resources)
       return {} unless resources.respond_to?(:[])
 
       fonts = {}
-      resources = @xref.object(resources[:Font]) || {}
+      resources = @ohash.object(resources[:Font]) || {}
       resources.each do |label, desc|
-        desc = @xref.object(desc)
+        desc = @ohash.object(desc)
         fonts[label] = PDF::Reader::Font.new
         fonts[label].label = label
         fonts[label].subtype = desc[:Subtype] if desc[:Subtype]
         fonts[label].basefont = desc[:BaseFont] if desc[:BaseFont]
-        fonts[label].encoding = PDF::Reader::Encoding.new(@xref.object(desc[:Encoding]))
+        fonts[label].encoding = PDF::Reader::Encoding.new(@ohash.object(desc[:Encoding]))
         fonts[label].descendantfonts = desc[:DescendantFonts] if desc[:DescendantFonts]
         if desc[:ToUnicode]
-          # this stream is a cmap
-          begin
-            stream = desc[:ToUnicode]
-            fonts[label].tounicode = PDF::Reader::CMap.new(stream.unfiltered_data)
-          rescue
-            # if the CMap fails to parse, don't worry too much. Means we can't translate the text properly
-          end
+          stream = @ohash.object(desc[:ToUnicode])
+          fonts[label].tounicode = PDF::Reader::CMap.new(stream.unfiltered_data)
         end
       end
       fonts
     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] == "\376\377"
-          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 resources
       @resources ||= []
     end