pdf-reader 1.0.0 → 1.1.0

data/CHANGELOG

@@ -1,3 +1,8 @@
+v1.1.0 (25th March 2012)
+- new PageState class for handling common state tracking in page receivers
+  - see PageTextReceiver for example usage
+- various bugfixes to support reading more PDF dialects
+
 v1.0.0 (16th January 2012)
 - support a new encryption variation
 - bugfix in PageTextRender (thanks Paul Gallagher)

data/lib/pdf/reader.rb

@@ -354,6 +354,7 @@ require 'pdf/reader/register_receiver'
 require 'pdf/reader/standard_security_handler'
 require 'pdf/reader/stream'
 require 'pdf/reader/text_receiver'
+require 'pdf/reader/page_state'
 require 'pdf/reader/page_text_receiver'
 require 'pdf/reader/token'
 require 'pdf/reader/xref'

data/lib/pdf/reader/buffer.rb

@@ -171,7 +171,11 @@ class PDF::Reader
       when "<" then :hex_string
       when "stream" then :stream
       when "ID"
-        in_content_stream? ? :inline : :regular
+        if in_content_stream?  && @tokens[-2] != "/"
+          :inline
+        else
+          :regular
+        end
       else
         :regular
       end
@@ -314,7 +318,7 @@ class PDF::Reader
           @tokens << chr
           tok = ""
           break
-        when "\x28", "\x5B", "\x7B", "\x2F"
+        when "\x28", "\x5B", "\x7B"
           # opening delimiter, start of new token
           @tokens << tok if tok.size > 0
           @tokens << chr
@@ -326,6 +330,14 @@ class PDF::Reader
           @tokens << chr
           tok = ""
           break
+        when "\x2F"
+          # PDF name, start of new token
+          @tokens << tok if tok.size > 0
+          @tokens << chr
+          next_char = peek_char
+          @tokens << "" if chr == "/" && [nil, " ", "\n"].include?(next_char)
+          tok = ""
+          break
         else
           tok << chr
         end

data/lib/pdf/reader/encoding.rb

@@ -41,16 +41,12 @@ class PDF::Reader
         enc = nil
       end
 
-      @to_unicode_required = unicode_required?(enc)
+      @enc_name = enc
       @unpack   = get_unpack(enc)
       @map_file = get_mapping_file(enc)
       load_mapping(@map_file) if @map_file
     end
 
-    def to_unicode_required?
-      @to_unicode_required
-    end
-
     # set the differences table for this encoding. should be an array in the following format:
     #
     #   [25, :A, 26, :B]
@@ -91,13 +87,40 @@ class PDF::Reader
     # * pack the final array of Unicode codepoints into a utf-8 string
     # * mark the string as utf-8 if we're running on a M17N aware VM
     #
-    def to_utf8(str, tounicode = nil)
+    def to_utf8(str)
+      if utf8_conversion_impossible?
+        little_boxes(str.unpack(unpack).size)
+      else
+        convert_to_utf8(str)
+      end
+    end
+
+    private
+
+    def utf8_conversion_impossible?
+      @enc_name == :"Identity-H" || @enc_name == :"Identity-V"
+    end
+
+    def little_boxes(times)
+      codepoints = [ PDF::Reader::Encoding::UNKNOWN_CHAR ] * times
+      ret = codepoints.pack("U*")
+      ret.force_encoding("UTF-8") if ret.respond_to?(:force_encoding)
+      ret
+    end
+
+    def convert_to_utf8(str)
       ret = str.unpack(unpack).map { |c|
         differences[c] || c
-      }.map { |num|
-        original_codepoint_to_unicode(num, tounicode)
+      }.map { |c|
+        mapping[c] || c
       }.map { |c|
         names_to_unicode[c] || c
+      }.map { |c|
+        if PDF::Reader::Encoding::CONTROL_CHARS.include?(c)
+          PDF::Reader::Encoding::UNKNOWN_CHAR
+        else
+          c
+        end
       }.map { |c|
         if c.nil? || !c.is_a?(Fixnum)
           PDF::Reader::Encoding::UNKNOWN_CHAR
@@ -111,22 +134,6 @@ class PDF::Reader
       ret
     end
 
-    private
-
-    def original_codepoint_to_unicode(cp, tounicode = nil)
-      if tounicode && (code = tounicode.decode(cp))
-        code
-      elsif to_unicode_required? && (tounicode.nil? || tounicode.decode(cp).nil?)
-        PDF::Reader::Encoding::UNKNOWN_CHAR
-      elsif mapping[cp]
-        mapping[cp]
-      elsif PDF::Reader::Encoding::CONTROL_CHARS.include?(cp)
-        PDF::Reader::Encoding::UNKNOWN_CHAR
-      else
-        cp
-      end
-    end
-
     def get_unpack(enc)
       case enc
       when :"Identity-H", :"Identity-V", :UTF16Encoding
@@ -157,10 +164,6 @@ class PDF::Reader
       end
     end
 
-    def unicode_required?(enc)
-      enc == :"Identity-H" or enc == :"Identity-V"
-    end
-
     def mapping
       @mapping ||= {}
     end

data/lib/pdf/reader/font.rb

@@ -35,6 +35,7 @@ class PDF::Reader
         return
       end
       @ohash = ohash
+      @tounicode = nil
 
       extract_base_info(obj)
       extract_descriptor(obj)
@@ -58,24 +59,17 @@ class PDF::Reader
     end
 
     def to_utf8(params)
-      raise UnsupportedFeatureError, "font encoding '#{encoding}' currently unsupported" if encoding.kind_of?(String)
-
-      if params.class == String
-        encoding.to_utf8(params, tounicode)
-      elsif params.class == Array
-        params.collect { |param| self.to_utf8(param) }
+      if @tounicode
+        to_utf8_via_cmap(params)
       else
-        params
+        to_utf8_via_encoding(params)
       end
     end
 
     def glyph_width(c)
       @missing_width ||= 0
-      if @widths.nil?
-        0
-      else
-        @widths.fetch(c.codepoints.first - @first_char, @missing_width)
-      end
+      @widths        ||= []
+      @widths.fetch(c - @first_char, @missing_width)
     end
 
     private
@@ -84,7 +78,7 @@ class PDF::Reader
       @subtype  = @ohash.object(obj[:Subtype])
       @basefont = @ohash.object(obj[:BaseFont])
       @encoding = PDF::Reader::Encoding.new(@ohash.object(obj[:Encoding]))
-      @widths   = @ohash.object(obj[:Widths])
+      @widths   = @ohash.object(obj[:Widths]) || []
       @first_char = @ohash.object(obj[:FirstChar])
       if obj[:ToUnicode]
         stream = @ohash.object(obj[:ToUnicode])
@@ -111,5 +105,29 @@ class PDF::Reader
       }
     end
 
+    def to_utf8_via_cmap(params)
+      if params.class == String
+        params.unpack(encoding.unpack).map { |c|
+          @tounicode.decode(c) || PDF::Reader::Encoding::UNKNOWN_CHAR
+        }.pack("U*")
+      elsif params.class == Array
+        params.collect { |param| to_utf8_via_cmap(param) }
+      else
+        params
+      end
+    end
+
+    def to_utf8_via_encoding(params)
+      raise UnsupportedFeatureError, "font encoding '#{encoding}' currently unsupported" if encoding.kind_of?(String)
+
+      if params.class == String
+        encoding.to_utf8(params)
+      elsif params.class == Array
+        params.collect { |param| to_utf8_via_encoding(param) }
+      else
+        params
+      end
+    end
+
   end
 end

data/lib/pdf/reader/form_xobject.rb

@@ -13,6 +13,8 @@ module PDF
     class FormXObject
       include ResourceMethods
 
+      attr_reader :xobject
+
       def initialize(page, xobject)
         @page    = page
         @objects = page.objects

data/lib/pdf/reader/object_hash.rb

@@ -317,7 +317,7 @@ class PDF::Reader
       if obj[:Type] == :Page
         ref
       elsif obj[:Type] == :Pages
-        obj[:Kids].map { |kid| get_page_objects(kid) }
+        deref(obj[:Kids]).map { |kid| get_page_objects(kid) }
       end
     end
 

data/lib/pdf/reader/page_state.rb

@@ -0,0 +1,295 @@
+# coding: utf-8
+
+require 'matrix'
+
+module PDF
+  class Reader
+    class PageState
+
+      DEFAULT_GRAPHICS_STATE = {
+        :ctm          => Matrix.identity(3),
+        :char_spacing => 0,
+        :word_spacing => 0,
+        :h_scaling    => 100,
+        :text_leading => 0,
+        :text_font    => nil,
+        :text_font_size => nil,
+        :text_mode    => 0,
+        :text_rise    => 0,
+        :text_knockout => 0
+      }
+
+      # starting a new page
+      def initialize(page)
+        @page          = page
+        @objects       = page.objects
+        @font_stack    = [build_fonts(page.fonts)]
+        @xobject_stack = [page.xobjects]
+        @cs_stack      = [page.color_spaces]
+        @stack         = [DEFAULT_GRAPHICS_STATE.dup]
+      end
+
+      #####################################################
+      # Graphics State Operators
+      #####################################################
+
+      def save_graphics_state
+        @stack.push clone_state
+      end
+
+      def restore_graphics_state
+        @stack.pop
+      end
+
+      #####################################################
+      # Matrix Operators
+      #####################################################
+
+      # update the current transformation matrix.
+      #
+      # If the CTM is currently undefined, just store the new values.
+      #
+      # If there's an existing CTM, then multiply the existing matrix
+      # with the new matrix to form the updated matrix.
+      #
+      def concatenate_matrix(a, b, c, d, e, f)
+        transform = Matrix[
+          [a, b, 0],
+          [c, d, 0],
+          [e, f, 1]
+        ]
+        if state[:ctm]
+          state[:ctm] = transform * state[:ctm]
+        else
+          state[:ctm] = transform
+        end
+      end
+
+      #####################################################
+      # Text Object Operators
+      #####################################################
+
+      def begin_text_object
+        @text_matrix      = Matrix.identity(3)
+        @text_line_matrix = Matrix.identity(3)
+      end
+
+      def end_text_object
+        @text_matrix      = Matrix.identity(3)
+        @text_line_matrix = Matrix.identity(3)
+      end
+
+      #####################################################
+      # Text State Operators
+      #####################################################
+
+      def set_character_spacing(char_spacing)
+        state[:char_spacing] = char_spacing
+      end
+
+      def set_horizontal_text_scaling(h_scaling)
+        state[:h_scaling] = h_scaling
+      end
+
+      def set_text_font_and_size(label, size)
+        state[:text_font]      = label
+        state[:text_font_size] = size
+      end
+
+      def font_size
+        state[:text_font_size] * @text_matrix[0,0]
+      end
+
+      def set_text_leading(leading)
+        state[:text_leading] = leading
+      end
+
+      def set_text_rendering_mode(mode)
+        state[:text_mode] = mode
+      end
+
+      def set_text_rise(rise)
+        state[:text_rise] = rise
+      end
+
+      def set_word_spacing(word_spacing)
+        state[:word_spacing] = word_spacing
+      end
+
+      #####################################################
+      # Text Positioning Operators
+      #####################################################
+
+      def move_text_position(x, y) # Td
+        temp_matrix = Matrix[
+          [1, 0, 0],
+          [0, 1, 0],
+          [x, y, 1]
+        ]
+        @text_matrix = @text_line_matrix = temp_matrix * @text_line_matrix
+      end
+
+      def move_text_position_and_set_leading(x, y) # TD
+        set_text_leading(-1 * y)
+        move_text_position(x, y)
+      end
+
+      def set_text_matrix_and_text_line_matrix(a, b, c, d, e, f) # Tm
+        @text_matrix = @text_line_matrix = Matrix[
+          [a, b, 0],
+          [c, d, 0],
+          [e, f, 1]
+        ]
+      end
+
+      def move_to_start_of_next_line # T*
+        move_text_position(0, -state[:text_leading])
+      end
+
+      #####################################################
+      # Text Showing Operators
+      #####################################################
+
+      def show_text_with_positioning(params) # TJ
+        # TODO record position changes in state here
+      end
+
+      def move_to_next_line_and_show_text(str) # '
+        move_to_start_of_next_line
+      end
+
+      def set_spacing_next_line_show_text(aw, ac, string) # "
+        set_word_spacing(aw)
+        set_character_spacing(ac)
+        move_to_next_line_and_show_text(string)
+      end
+
+      #####################################################
+      # XObjects
+      #####################################################
+      def invoke_xobject(label)
+        save_graphics_state
+        xobject = find_xobject(label)
+
+        raise MalformedPDFError, "XObject #{label} not found" if xobject.nil?
+        matrix = xobject.hash[:Matrix]
+        concatenate_matrix(*matrix) if matrix
+
+        if xobject.hash[:Subtype] == :Form
+          form = PDF::Reader::FormXObject.new(@page, xobject)
+          @font_stack.unshift(form.font_objects)
+          @xobject_stack.unshift(form.xobjects)
+          yield form if block_given?
+          @font_stack.shift
+          @xobject_stack.shift
+        else
+          yield xobject if block_given?
+        end
+
+        restore_graphics_state
+      end
+
+      #####################################################
+      # Public Visible State
+      #####################################################
+
+      # transform x and y co-ordinates from the current user space to the
+      # underlying device space.
+      #
+      def ctm_transform(x, y, z = 1)
+        [
+          (ctm[0,0] * x) + (ctm[1,0] * y) + (ctm[2,0] * z),
+          (ctm[0,1] * x) + (ctm[1,1] * y) + (ctm[2,1] * z)
+        ]
+      end
+
+      # transform x and y co-ordinates from the current text space to the
+      # underlying device space.
+      #
+      def trm_transform(x, y, z = 1)
+        trm = text_rendering_matrix
+        [
+          (trm[0,0] * x) + (trm[1,0] * y) + (trm[2,0] * z),
+          (trm[0,1] * x) + (trm[1,1] * y) + (trm[2,1] * z)
+        ]
+      end
+
+      def current_font
+        find_font(state[:text_font])
+      end
+
+      def find_font(label)
+        dict = @font_stack.detect { |fonts|
+          fonts.has_key?(label)
+        }
+        dict ? dict[label] : nil
+      end
+
+      def find_color_space(label)
+        dict = @cs_stack.detect { |colorspaces|
+          colorspaces.has_key?(label)
+        }
+        dict ? dict[label] : nil
+      end
+
+      def find_xobject(label)
+        dict = @xobject_stack.detect { |xobjects|
+          xobjects.has_key?(label)
+        }
+        dict ? dict[label] : nil
+      end
+
+      private
+
+      def text_rendering_matrix
+        state_matrix = Matrix[
+          [font_size * state[:h_scaling], 0, 0],
+          [0, font_size, 0],
+          [0, state[:text_rise], 1]
+        ]
+
+        state_matrix * @text_matrix * ctm
+      end
+
+      # return the current transformation matrix
+      #
+      def ctm
+        state[:ctm]
+      end
+
+      def state
+        @stack.last
+      end
+
+      # wrap the raw PDF Font objects in handy ruby Font objects.
+      #
+      def build_fonts(raw_fonts)
+        wrapped_fonts = raw_fonts.map { |label, font|
+          [label, PDF::Reader::Font.new(@objects, @objects.deref(font))]
+        }
+
+        ::Hash[wrapped_fonts]
+      end
+
+      # when save_graphics_state is called, we need to push a new copy of the
+      # current state onto the stack. That way any modifications to the state
+      # will be undone once restore_graphics_state is called.
+      #
+      # This returns a deep clone of the current state, ensuring changes are
+      # keep separate from earlier states.
+      #
+      # Marshal is used to round-trip the state through a string to easily
+      # perform the deep clone. Kinda hacky, but effective.
+      #
+      def clone_state
+        if @stack.empty?
+          {}
+        else
+          Marshal.load Marshal.dump(@stack.last)
+        end
+      end
+
+    end
+  end
+end
+

data/lib/pdf/reader/page_text_receiver.rb

@@ -1,156 +1,43 @@
 # coding: utf-8
 
 require 'matrix'
+require 'forwardable'
 
 module PDF
   class Reader
     class PageTextReceiver
+      extend Forwardable
 
-      DEFAULT_GRAPHICS_STATE = {
-        :ctm          => Matrix.identity(3),
-        :char_spacing => 0,
-        :word_spacing => 0,
-        :h_scaling    => 100,
-        :text_leading => 0,
-        :text_font    => nil,
-        :text_font_size => nil,
-        :text_mode    => 0,
-        :text_rise    => 0,
-        :text_knockout => 0
-      }
-
-      # starting a new page
-      def page=(page)
-        @page    = page
-        @objects = page.objects
-        @font_stack    = [build_fonts(page.fonts)]
-        @xobject_stack = [page.xobjects]
-        @content = {}
-        @stack   = [DEFAULT_GRAPHICS_STATE.dup]
-      end
-
-      def content
-        keys = @content.keys.sort.reverse
-        keys.map { |key|
-          @content[key]
-        }.join("\n")
-      end
-
-      #####################################################
       # Graphics State Operators
-      #####################################################
+      def_delegators :@state, :save_graphics_state, :restore_graphics_state
 
-      def save_graphics_state
-        @stack.push clone_state
-      end
-
-      def restore_graphics_state
-        @stack.pop
-      end
-
-      #####################################################
       # Matrix Operators
-      #####################################################
+      def_delegators :@state, :concatenate_matrix
 
-      # update the current transformation matrix.
-      #
-      # If the CTM is currently undefined, just store the new values.
-      #
-      # If there's an existing CTM, then multiply the existing matrix
-      # with the new matrix to form the updated matrix.
-      #
-      def concatenate_matrix(a, b, c, d, e, f)
-        transform = Matrix[
-          [a, b, 0],
-          [c, d, 0],
-          [e, f, 1]
-        ]
-        if state[:ctm]
-          state[:ctm] = transform * state[:ctm]
-        else
-          state[:ctm] = transform
-        end
-      end
-
-      #####################################################
       # Text Object Operators
-      #####################################################
+      def_delegators :@state, :begin_text_object, :end_text_object
 
-      def begin_text_object
-        @text_matrix      = Matrix.identity(3)
-        @text_line_matrix = Matrix.identity(3)
-      end
-
-      def end_text_object
-        @text_matrix      = Matrix.identity(3)
-        @text_line_matrix = Matrix.identity(3)
-      end
-
-      #####################################################
       # Text State Operators
-      #####################################################
-
-      def set_character_spacing(char_spacing)
-        state[:char_spacing] = char_spacing
-      end
+      def_delegators :@state, :set_character_spacing, :set_horizontal_text_scaling
+      def_delegators :@state, :set_text_font_and_size, :font_size
+      def_delegators :@state, :set_text_leading, :set_text_rendering_mode
+      def_delegators :@state, :set_text_rise, :set_word_spacing
 
-      def set_horizontal_text_scaling(h_scaling)
-        state[:h_scaling] = h_scaling
-      end
-
-      def set_text_font_and_size(label, size)
-        state[:text_font]      = label
-        state[:text_font_size] = size
-      end
-
-      def font_size
-        state[:text_font_size] * @text_matrix[0,0]
-      end
-
-      def set_text_leading(leading)
-        state[:text_leading] = leading
-      end
-
-      def set_text_rendering_mode(mode)
-        state[:text_mode] = mode
-      end
-
-      def set_text_rise(rise)
-        state[:text_rise] = rise
-      end
-
-      def set_word_spacing(word_spacing)
-        state[:word_spacing] = word_spacing
-      end
-
-      #####################################################
       # Text Positioning Operators
-      #####################################################
+      def_delegators :@state, :move_text_position, :move_text_position_and_set_leading
+      def_delegators :@state, :set_text_matrix_and_text_line_matrix, :move_to_start_of_next_line
 
-      def move_text_position(x, y) # Td
-        temp_matrix = Matrix[
-          [1, 0, 0],
-          [0, 1, 0],
-          [x, y, 1]
-        ]
-        @text_matrix = @text_line_matrix = temp_matrix * @text_line_matrix
-      end
-
-      def move_text_position_and_set_leading(x, y) # TD
-        set_text_leading(-1 * y)
-        move_text_position(x, y)
-      end
-
-      def set_text_matrix_and_text_line_matrix(a, b, c, d, e, f) # Tm
-        @text_matrix = @text_line_matrix = Matrix[
-          [a, b, 0],
-          [c, d, 0],
-          [e, f, 1]
-        ]
+      # starting a new page
+      def page=(page)
+        @state = PageState.new(page)
+        @content = {}
       end
 
-      def move_to_start_of_next_line # T*
-        move_text_position(0, -state[:text_leading])
+      def content
+        keys = @content.keys.sort.reverse
+        keys.map { |key|
+          @content[key]
+        }.join("\n")
       end
 
       #####################################################
@@ -159,10 +46,10 @@ module PDF
 
       # record text that is drawn on the page
       def show_text(string) # Tj
-        raise PDF::Reader::MalformedPDFError, "current font is invalid" if current_font.nil?
-        at = transform(Point.new(0,0))
-        @content[at.y] ||= ""
-        @content[at.y] << current_font.to_utf8(string)
+        raise PDF::Reader::MalformedPDFError, "current font is invalid" if @state.current_font.nil?
+        newx, newy = @state.trm_transform(0,0)
+        @content[newy] ||= ""
+        @content[newy] << @state.current_font.to_utf8(string)
       end
 
       def show_text_with_positioning(params) # TJ
@@ -177,13 +64,13 @@ module PDF
       end
 
       def move_to_next_line_and_show_text(str) # '
-        move_to_start_of_next_line
+        @state.move_to_start_of_next_line
         show_text(str)
       end
 
       def set_spacing_next_line_show_text(aw, ac, string) # "
-        set_word_spacing(aw)
-        set_character_spacing(ac)
+        @state.set_word_spacing(aw)
+        @state.set_character_spacing(ac)
         move_to_next_line_and_show_text(string)
       end
 
@@ -191,103 +78,14 @@ module PDF
       # XObjects
       #####################################################
       def invoke_xobject(label)
-        save_graphics_state
-        dict = @xobject_stack.detect { |xobjects|
-          xobjects.has_key?(label)
-        }
-        xobject = dict ? dict[label] : nil
-
-        raise MalformedPDFError, "XObject #{label} not found" if xobject.nil?
-        matrix = xobject.hash[:Matrix]
-        concatenate_matrix(*matrix) if matrix
-
-        if xobject.hash[:Subtype] == :Form
-          form = PDF::Reader::FormXObject.new(@page, xobject)
-          @font_stack.unshift(form.font_objects)
-          @xobject_stack.unshift(form.xobjects)
-          form.walk(self)
-          @font_stack.shift
-          @xobject_stack.shift
-        end
-
-        restore_graphics_state
-      end
-
-      private
-
-      # wrap the raw PDF Font objects in handy ruby Font objects.
-      #
-      def build_fonts(raw_fonts)
-        wrapped_fonts = raw_fonts.map { |label, font|
-          [label, PDF::Reader::Font.new(@objects, @objects.deref(font))]
-        }
-
-        ::Hash[wrapped_fonts]
-      end
-
-      # transform x and y co-ordinates from the current text space to the
-      # underlying device space.
-      #
-      def transform(point, z = 1)
-        point.transform(text_rendering_matrix, z)
-      end
-
-      def text_rendering_matrix
-        state_matrix = Matrix[
-          [font_size * state[:h_scaling], 0, 0],
-          [0, font_size, 0],
-          [0, state[:text_rise], 1]
-        ]
-
-        state_matrix * @text_matrix * ctm
-      end
-
-      def state
-        @stack.last
-      end
-
-      # when save_graphics_state is called, we need to push a new copy of the
-      # current state onto the stack. That way any modifications to the state
-      # will be undone once restore_graphics_state is called.
-      #
-      # This returns a deep clone of the current state, ensuring changes are
-      # keep separate from earlier states.
-      #
-      # Marshal is used to round-trip the state through a string to easily
-      # perform the deep clone. Kinda hacky, but effective.
-      #
-      def clone_state
-        if @stack.empty?
-          {}
-        else
-          Marshal.load Marshal.dump(@stack.last)
+        @state.invoke_xobject(label) do |xobj|
+          case xobj
+          when PDF::Reader::FormXObject then
+            xobj.walk(self)
+          end
         end
       end
 
-      # return the current transformation matrix
-      #
-      def ctm
-        state[:ctm]
-      end
-
-      def current_font
-        dict = @font_stack.detect { |fonts|
-          fonts.has_key?(state[:text_font])
-        }
-        dict ? dict[state[:text_font]] : nil
-      end
-
-      # private class for representing points on a cartesian plain. Used
-      # to simplify maths.
-      #
-      class Point < Struct.new(:x, :y)
-        def transform(trm, z)
-          Point.new(
-            (trm[0,0] * x) + (trm[1,0] * y) + (trm[2,0] * z),
-            (trm[0,1] * x) + (trm[1,1] * y) + (trm[2,1] * z)
-          )
-        end
-      end
     end
   end
 end

data/lib/pdf/reader/parser.rb

@@ -130,6 +130,7 @@ class PDF::Reader
     # reads a PDF name from the buffer and converts it to a Ruby Symbol
     def pdf_name
       tok = @buffer.token
+      tok = " " if tok == "" && RUBY_VERSION < "1.9"
       tok.gsub!(/#([A-Fa-f0-9]{2})/) do |match|
         match[1, 2].hex.chr
       end

data/lib/pdf/reader/resource_methods.rb

@@ -8,12 +8,20 @@ module PDF
     module ResourceMethods
       # Returns a Hash of color spaces that are available to this page
       #
+      # NOTE: this method de-serialise objects from the underlying PDF
+      #       with no caching. You will want to cache the results instead
+      #       of calling it over and over.
+      #
       def color_spaces
         @objects.deref!(resources[:ColorSpace]) || {}
       end
 
       # Returns a Hash of fonts that are available to this page
       #
+      # NOTE: this method de-serialise objects from the underlying PDF
+      #       with no caching. You will want to cache the results instead
+      #       of calling it over and over.
+      #
       def fonts
         @objects.deref!(resources[:Font]) || {}
       end
@@ -21,36 +29,60 @@ module PDF
       # Returns a Hash of external graphic states that are available to this
       # page
       #
+      # NOTE: this method de-serialise objects from the underlying PDF
+      #       with no caching. You will want to cache the results instead
+      #       of calling it over and over.
+      #
       def graphic_states
         @objects.deref!(resources[:ExtGState]) || {}
       end
 
       # Returns a Hash of patterns that are available to this page
       #
+      # NOTE: this method de-serialise objects from the underlying PDF
+      #       with no caching. You will want to cache the results instead
+      #       of calling it over and over.
+      #
       def patterns
         @objects.deref!(resources[:Pattern]) || {}
       end
 
       # Returns an Array of procedure sets that are available to this page
       #
+      # NOTE: this method de-serialise objects from the underlying PDF
+      #       with no caching. You will want to cache the results instead
+      #       of calling it over and over.
+      #
       def procedure_sets
         @objects.deref!(resources[:ProcSet]) || []
       end
 
       # Returns a Hash of properties sets that are available to this page
       #
+      # NOTE: this method de-serialise objects from the underlying PDF
+      #       with no caching. You will want to cache the results instead
+      #       of calling it over and over.
+      #
       def properties
         @objects.deref!(resources[:Properties]) || {}
       end
 
       # Returns a Hash of shadings that are available to this page
       #
+      # NOTE: this method de-serialise objects from the underlying PDF
+      #       with no caching. You will want to cache the results instead
+      #       of calling it over and over.
+      #
       def shadings
         @objects.deref!(resources[:Shading]) || {}
       end
 
       # Returns a Hash of XObjects that are available to this page
       #
+      # NOTE: this method de-serialise objects from the underlying PDF
+      #       with no caching. You will want to cache the results instead
+      #       of calling it over and over.
+      #
       def xobjects
         @objects.deref!(resources[:XObject]) || {}
       end

data/lib/pdf/reader/xref.rb

@@ -124,7 +124,7 @@ class PDF::Reader
             generation = buf.token.to_i
             state = buf.token
 
-            store(objid, generation, offset) if state == "n"
+            store(objid, generation, offset) if state == "n" && offset > 0
             objid += 1
             params.clear
           end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pdf-reader
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-16 00:00:00.000000000 Z
+date: 2012-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &24844240 !ruby/object:Gem::Requirement
+  requirement: &20774400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *24844240
+  version_requirements: *20774400
 - !ruby/object:Gem::Dependency
   name: roodi
-  requirement: &24843780 !ruby/object:Gem::Requirement
+  requirement: &20772820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *24843780
+  version_requirements: *20772820
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &24843280 !ruby/object:Gem::Requirement
+  requirement: &20771660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '2.3'
   type: :development
   prerelease: false
-  version_requirements: *24843280
+  version_requirements: *20771660
 - !ruby/object:Gem::Dependency
   name: ZenTest
-  requirement: &24842780 !ruby/object:Gem::Requirement
+  requirement: &20770840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 4.4.2
   type: :development
   prerelease: false
-  version_requirements: *24842780
+  version_requirements: *20770840
 - !ruby/object:Gem::Dependency
   name: Ascii85
-  requirement: &24842320 !ruby/object:Gem::Requirement
+  requirement: &20770080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +65,10 @@ dependencies:
         version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *24842320
+  version_requirements: *20770080
 - !ruby/object:Gem::Dependency
   name: ruby-rc4
-  requirement: &24841940 !ruby/object:Gem::Requirement
+  requirement: &20769400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *24841940
+  version_requirements: *20769400
 description: The PDF::Reader library implements a PDF parser conforming as much as
   possible to the PDF specification from Adobe
 email:
@@ -114,6 +114,7 @@ files:
 - lib/pdf/reader/filter.rb
 - lib/pdf/reader/object_hash.rb
 - lib/pdf/reader/stream.rb
+- lib/pdf/reader/page_state.rb
 - lib/pdf/reader/standard_security_handler.rb
 - lib/pdf/reader/cmap.rb
 - lib/pdf/reader/form_xobject.rb