fireinc-pdf-reader 0.11.0.alpha

data/lib/pdf/reader/lzw.rb

@@ -0,0 +1,123 @@
+# coding: utf-8
+
+module PDF
+
+  class Reader
+
+    # A general class for decoding LZW compressed data. LZW can be
+    # used in PDF files to compresses streams, usually for image data sourced
+    # from a TIFF file.
+    #
+    # See the following links for more information:
+    #
+    #   ref http://www.fileformat.info/format/tiff/corion-lzw.htm
+    #   ref http://marknelson.us/1989/10/01/lzw-data-compression/
+    #
+    # The PDF spec also has some data on the algorithm.
+    #
+    class LZW # :nodoc:
+
+      class BitStream # :nodoc:
+
+        def initialize(data, bits_in_chunk)
+          @data = data
+          @data.force_encoding("BINARY") if @data.respond_to?(:force_encoding)
+          @bits_in_chunk = bits_in_chunk
+          @current_pos = 0
+          @bits_left_in_byte = 8
+        end
+
+        def set_bits_in_chunk(bits_in_chunk)
+          @bits_in_chunk = bits_in_chunk
+        end
+
+        def read
+          bits_left_in_chunk = @bits_in_chunk
+          chunk = nil
+          while bits_left_in_chunk > 0 and @current_pos < @data.size
+            chunk = 0 if chunk.nil?
+            codepoint = @data[@current_pos, 1].unpack("C*")[0]
+            current_byte = codepoint & (2**@bits_left_in_byte -1) #clear consumed bits
+            dif = bits_left_in_chunk - @bits_left_in_byte
+            if dif > 0 then  current_byte <<= dif
+            elsif dif < 0 then  current_byte >>= dif.abs
+            end
+            chunk |= current_byte #add bits to result
+            bits_left_in_chunk = if dif >= 0 then dif else 0 end
+            @bits_left_in_byte = if dif < 0 then dif.abs else 0 end
+            if @bits_left_in_byte.zero? #next byte
+              @current_pos += 1
+              @bits_left_in_byte = 8
+            end
+          end
+          chunk
+        end
+      end
+
+      CODE_EOD = 257 #end of data
+      CODE_CLEAR_TABLE = 256 #clear table
+
+      # stores de pairs code => string
+      class StringTable < Hash # :nodoc:
+        attr_reader :string_table_pos
+
+        def initialize
+          super
+          @string_table_pos = 258 #initial code
+        end
+
+        #if code less than 258 return fixed string
+        def [](key)
+          if key > 257 then super else key.chr end
+        end
+
+        def add(string)
+          store(@string_table_pos, string)
+          @string_table_pos += 1
+        end
+      end
+
+      # Decompresses a LZW compressed string.
+      #
+      def self.decode(data)
+        stream = BitStream.new data.to_s, 9 # size of codes between 9 and 12 bits
+        result = ''
+        while not (code = stream.read) == CODE_EOD
+          if code == CODE_CLEAR_TABLE
+            string_table = StringTable.new
+            code = stream.read
+            break if code == CODE_EOD
+            result << string_table[code]
+            old_code = code
+          else
+            string = string_table[code]
+            if string
+              result << string
+              string_table.add create_new_string(string_table, old_code, code)
+              old_code = code
+            else
+              new_string = create_new_string(string_table, old_code, old_code)
+              result << new_string
+              string_table.add new_string
+              old_code = code
+            end
+            #increase de size of the codes when limit reached
+            case string_table.string_table_pos
+            when 511 then stream.set_bits_in_chunk(10)
+            when 1023 then stream.set_bits_in_chunk(11)
+            when 2047 then stream.set_bits_in_chunk(12)
+            end
+          end
+        end
+        result
+      end
+
+      private
+
+      def self.create_new_string(string_table,some_code, other_code)
+        string_table[some_code] + string_table[other_code][0].chr
+      end
+
+    end
+  end
+end

data/lib/pdf/reader/metadata_strategy.rb

@@ -0,0 +1,56 @@
+# coding: utf-8
+
+class PDF::Reader
+
+  # DEPRECATED: this class was deprecated in version 0.11.0 and will
+  #             eventually be removed
+  #
+  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_cache.rb

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+class PDF::Reader
+
+  # A Hash-like object for caching commonly used objects from a PDF file.
+  #
+  # This is an internal class used by PDF::Reader::ObjectHash
+  #
+  class ObjectCache # nodoc
+
+    # These object types use little memory and are accessed a heap of times as
+    # part of random page access, so we'll cache the unmarshalled objects and
+    # avoid lots of repetitive (and expensive) tokenising
+    CACHEABLE_TYPES = [:Catalog, :Page, :Pages]
+
+    def initialize
+      @objects = {}
+    end
+
+    def [](key)
+      @objects[key]
+    end
+
+    def []=(key, value)
+      @objects[key] = value if cacheable?(value)
+    end
+
+    def fetch(key, local_default = nil)
+      @objects.fetch(key, local_default)
+    end
+
+    def each(&block)
+      @objects.each(&block)
+    end
+    alias :each_pair :each
+
+    def each_key(&block)
+      @objects.each_key(&block)
+    end
+
+    def each_value(&block)
+      @objects.each_value(&block)
+    end
+
+    def size
+      @objects.size
+    end
+    alias :length :size
+
+    def empty?
+      @objects.empty?
+    end
+
+    def has_key?(key)
+      @objects.has_key?(key)
+    end
+    alias :include? :has_key?
+    alias :key? :has_key?
+    alias :member? :has_key?
+
+    def has_value?(value)
+      @objects.has_value?(value)
+    end
+
+    def to_s
+      "<PDF::Reader::ObjectCache size: #{self.size}>"
+    end
+
+    def keys
+      @objects.keys
+    end
+
+    def values
+      @objects.values
+    end
+
+    private
+
+    def cacheable?(obj)
+      obj.is_a?(Hash) && CACHEABLE_TYPES.include?(obj[:Type])
+    end
+
+
+  end
+end

data/lib/pdf/reader/object_hash.rb

@@ -0,0 +1,289 @@
+# 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 precise 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
+
+    CACHEABLE_TYPES = [:Catalog, :Page, :Pages]
+
+    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
+      @cache       = PDF::Reader::ObjectCache.new
+
+      if trailer[:Encrypt]
+        raise ::PDF::Reader::UnsupportedFeatureError, 'PDF::Reader cannot read encrypted PDF files'
+      end
+    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 @cache.has_key?(key)
+          @cache[key]
+        elsif xref[key].is_a?(Fixnum)
+          buf = new_buffer(xref[key])
+          @cache[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))
+          @cache[key] = object_streams[container_key][key.id]
+        end
+      rescue InvalidObjectError
+        return default
+      end
+    end
+
+    def cacheable?(obj)
+      obj.is_a?(Hash) && CACHEABLE_TYPES.include?(obj[:Type])
+    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
+    alias :deref :object
+
+    # 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::ObjectHash 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
+