pdf-reader 0.6.2 → 0.7

data/lib/pdf/reader/filter.rb

@@ -38,9 +38,9 @@ class PDF::Reader
     def initialize (name, options)
       @options = options
 
-      case name
-      when "FlateDecode"    then @filter = :flate
-      #else                    raise UnsupportedFeatureError, "Unknown filter: #{name}"
+      case name.to_sym
+      when :FlateDecode    then @filter = :flate
+      #else                raise UnsupportedFeatureError, "Unknown filter: #{name}"
       end
     end
     ################################################################################
@@ -56,11 +56,21 @@ class PDF::Reader
     # Decode the specified data with the Zlib compression algorithm
     def flate (data)
       begin
-        z = Zlib::Inflate.new
-        z.inflate(data)
-      rescue Exception => e
-        raise MalformedPDFError, "Error occured while inflating a compressed stream (#{e.class.to_s}: #{e.to_s})"
+        Zlib::Inflate.new.inflate(data)
+      rescue Zlib::DataError => e
+        # by default, Ruby's Zlib assumes the data it's inflating
+        # is RFC1951 deflated data, wrapped in a RFC1951 zlib container.
+        # If that fails, then use an undocumented 'feature' to attempt to inflate
+        # the data as a raw RFC1951 stream.
+        #
+        # See 
+        # - http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/243545
+        # - http://www.gzip.org/zlib/zlib_faq.html#faq38
+        Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(data)
       end
+    rescue Exception => e
+      # Oops, there was a problem inflating the stream
+      raise MalformedPDFError, "Error occured while inflating a compressed stream (#{e.class.to_s}: #{e.to_s})"
     end
     ################################################################################
   end

data/lib/pdf/reader/font.rb

@@ -35,7 +35,8 @@ class PDF::Reader
       @@glyphs ||= {}
       
       if @@glyphs.empty?
-        File.open(File.dirname(__FILE__) + "/glyphlist.txt","r") do |f|
+        RUBY_VERSION >= "1.9" ? mode = "r:BINARY" : mode = "r"
+        File.open(File.dirname(__FILE__) + "/glyphlist.txt",mode) do |f|
           f.each do |l|
             m, name, code = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
             @@glyphs[name] = "0x#{code}".hex if name

data/lib/pdf/reader/parser.rb

@@ -32,7 +32,7 @@ class PDF::Reader
     # Create a new parser around a PDF::Reader::Buffer object
     #
     # buffer - a PDF::Reader::Buffer object that contains PDF data
-    # xref   - an integer that specifies the byte offset of the xref table in the buffer
+    # xref   - a PDF::Reader::XRef object that represents the document's object offsets
     def initialize (buffer, xref)
       @buffer = buffer
       @xref   = xref
@@ -47,7 +47,7 @@ class PDF::Reader
       token = @buffer.token
 
       case token
-      when "/"                        then return Name.new(@buffer.token)
+      when "/"                        then return @buffer.token.to_sym
       when "<<"                       then return dictionary()
       when "["                        then return array()
       when "("                        then return string()
@@ -72,7 +72,7 @@ class PDF::Reader
       loop do
         key = parse_token
         break if key.kind_of?(Token) and key == ">>"
-        raise MalformedPDFError, "Dictionary key (#{key.inspect}) is not a name" unless key.kind_of?(Name)
+        raise MalformedPDFError, "Dictionary key (#{key.inspect}) is not a name" unless key.kind_of?(Symbol)
 
         value = parse_token
         value.kind_of?(Token) and Error.str_assert_not(value, ">>")
@@ -174,28 +174,28 @@ class PDF::Reader
       obj = parse_token
       post_obj = parse_token
       case post_obj
-      when "endobj"   then return obj
-      when "stream"   then return obj, stream(obj)
+      when "endobj"   then return [obj,nil]
+      when "stream"   then return [obj, stream(obj)]
       else            raise MalformedPDFError, "PDF malformed, unexpected token #{post_obj}"
       end
     end
     ################################################################################
     # Decodes the contents of a PDF Stream and returns it as a Ruby String.
     def stream (dict)
-      raise MalformedPDFError, "PDF malformed, missing stream length" unless dict.has_key?('Length')
-      data = @buffer.read(@xref.object(dict['Length']))
+      raise MalformedPDFError, "PDF malformed, missing stream length" unless dict.has_key?(:Length)
+      data = @buffer.read(@xref.object(dict[:Length]).first)
       
       Error.str_assert(parse_token, "endstream")
       Error.str_assert(parse_token, "endobj")
 
-      if dict.has_key?('Filter')
+      if dict.has_key?(:Filter)
         options = []
 
-        if dict.has_key?('DecodeParms')
-          options = Array(dict['DecodeParms'])
+        if dict.has_key?(:DecodeParms)
+          options = Array(dict[:DecodeParms])
         end
 
-        Array(dict['Filter']).each_with_index do |filter, index|
+        Array(dict[:Filter]).each_with_index do |filter, index|
           data = Filter.new(filter, options[index]).filter(data)
         end
       end

data/lib/pdf/reader/parser.rb.rej

@@ -0,0 +1,29 @@
+***************
+*** 173,178 ****
+  
+       obj = parse_token
+       post_obj = parse_token
+         case post_obj
+         when "endobj"   then return [obj,nil]
+         when "stream"   then return [obj, stream(obj)]
+--- 173,192 ----
+  
+       obj = parse_token
+       post_obj = parse_token
++ 
++       if obj.class == Array
++          newobj = Array.new
++          obj.each_index {|idx|
++              if obj[idx].class == PDF::Reader::Reference
++                xo, xs = @xref.object(obj[idx])
++                if xs
++                   newobj << xs
++                   end
++                end
++              }
++          return newobj.flatten
++          end
++ 
+         case post_obj
+         when "endobj"   then return [obj,nil]
+         when "stream"   then return [obj, stream(obj)]

data/lib/pdf/reader/text_receiver.rb

@@ -217,8 +217,8 @@ class PDF::Reader
     def media_box_check (dict)
       corners = (@upper_corners.last || {:urx => 0, :ury => 0}).dup
 
-      if dict.has_key?('MediaBox')
-        media_box = dict['MediaBox']
+      if dict.has_key?(:MediaBox)
+        media_box = dict[:MediaBox]
         corners[:urx] = media_box[2] - media_box[0]
         corners[:ury] = media_box[3] - media_box[1]
       end

data/lib/pdf/reader/xref.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
@@ -45,9 +45,11 @@ class PDF::Reader
       offset ||= @buffer.find_first_xref_offset
       @buffer.seek(offset)
       token = @buffer.token
-      
+
       if token == "xref" || token == "ref"
         load_xref_table
+      elsif token.to_i >= 0 && @buffer.token.to_i >= 0 && @buffer.token == "obj"
+        raise PDF::Reader::UnsupportedFeatureError, "XRef streams are not supported in PDF::Reader yet"
       else
         raise PDF::Reader::MalformedPDFError, "xref table not found at offset #{offset} (#{token} != xref)"
       end
@@ -59,14 +61,14 @@ class PDF::Reader
     #
     # If the object is a stream, that is returned as well
     def object (ref, save_pos = true)
-      return ref unless ref.kind_of?(Reference)
+      return ref, nil unless ref.kind_of?(Reference)
       pos = @buffer.pos if save_pos
       obj, stream = Parser.new(@buffer.seek(offset_for(ref)), self).object(ref.id, ref.gen)
       @buffer.seek(pos) if save_pos
       if stream
-        return obj, stream
+        return [obj, stream]
       else
-        return obj
+        return [obj, nil]
       end
     end
     ################################################################################
@@ -78,7 +80,7 @@ class PDF::Reader
       begin
         # loop over all subsections of the xref table
         # In a well formed PDF, the 'trailer' token will indicate
-        # the end of the table. However we need to be careful in case 
+        # the end of the table. However we need to be careful in case
         # we're processing a malformed pdf that is missing the trailer.
         loop do
           tok_one, tok_two = @buffer.token, @buffer.token
@@ -104,10 +106,20 @@ class PDF::Reader
       raise MalformedPDFError, "PDF malformed, trailer should be a dictionary" unless tok_two == "<<"
 
       trailer = Parser.new(@buffer, self).dictionary
-      load(trailer['Prev'].to_i) if trailer.has_key?('Prev')
+      load(trailer[:Prev].to_i) if trailer.has_key?(:Prev)
 
       trailer
     end
+    # returns the type of object a ref points to
+    def obj_type(ref)
+      obj, stream = object(ref)
+      obj.class.to_s.to_sym
+    end
+    # returns true if the supplied references points to an object with a stream
+    def stream?(ref)
+      obj, stream = @xref.object(ref)
+      stream ? true : false
+    end
     ################################################################################
     # returns the byte offset for the specified PDF object.
     #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pdf-reader
 version: !ruby/object:Gem::Version 
-  version: 0.6.2
+  version: "0.7"
 platform: ruby
 authors: 
 - Peter Jones
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-03-22 00:00:00 +11:00
+date: 2008-05-06 00:00:00 +10:00
 default_executable: 
 dependencies: []
 
@@ -28,9 +28,8 @@ files:
 - lib/pdf/reader
 - lib/pdf/reader/explore.rb
 - lib/pdf/reader/reference.rb
-- lib/pdf/reader/name.rb
-- lib/pdf/reader/token.rb
 - lib/pdf/reader/xref.rb
+- lib/pdf/reader/token.rb
 - lib/pdf/reader/filter.rb
 - lib/pdf/reader/text_receiver.rb
 - lib/pdf/reader/buffer.rb
@@ -42,6 +41,7 @@ files:
 - lib/pdf/reader/register_receiver.rb
 - lib/pdf/reader/font.rb
 - lib/pdf/reader/glyphlist.txt
+- lib/pdf/reader/parser.rb.rej
 - lib/pdf/reader.rb
 - Rakefile
 - README

data/lib/pdf/reader/name.rb

@@ -1,37 +0,0 @@
-################################################################################
-#
-# Copyright (C) 2006 Peter J Jones (pjones@pmade.com)
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# 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
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-################################################################################
-
-class PDF::Reader
-  ################################################################################
-  class Name < String
-    ################################################################################
-    def initialize (val)
-      super
-    end
-    ################################################################################
-  end
-  ################################################################################
-end
-################################################################################