pdf-reader 0.5

data/lib/pdf/reader/filter.rb

@@ -0,0 +1,62 @@
+################################################################################
+#
+# 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.
+#
+################################################################################
+require 'zlib'
+
+class PDF::Reader
+  ################################################################################
+  # Various parts of a PDF file can be passed through a filter before being stored to provide
+  # support for features like compression and encryption. This class is for decoding that
+  # content.
+  #
+  # Currently only 1 filter type is supported. Hopefully support for others will be added
+  # in the future.
+  class Filter
+    ################################################################################
+    # creates a new filter for decoding content
+    def initialize (name, options)
+      @options = options
+
+      case name
+      when "FlateDecode"    : @filter = :flate
+      else                    raise UnsupportedFeatureError, "Unknown filter: #{name}"
+      end
+    end
+    ################################################################################
+    # attempts to decode the specified data with the current filter
+    def filter (data)
+      self.send(@filter, data)
+    end
+    ################################################################################
+    # Decode the specified data with the Zlib compression algorithm
+    def flate (data)
+      z = Zlib::Inflate.new
+      z << data
+      z.inflate(nil)
+    end
+    ################################################################################
+  end
+  ################################################################################
+end
+################################################################################

data/lib/pdf/reader/name.rb

@@ -0,0 +1,37 @@
+################################################################################
+#
+# 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
+################################################################################

data/lib/pdf/reader/parser.rb

@@ -0,0 +1,203 @@
+################################################################################
+#
+# 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
+  ################################################################################
+  # An internal PDF::Reader class that reads objects from the PDF file and converts
+  # them into useable ruby objects (hash's, arrays, true, false, etc)
+  class Parser
+    ################################################################################
+    # 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
+    def initialize (buffer, xref)
+      @buffer = buffer
+      @xref   = xref
+    end
+    ################################################################################
+    # Reads the next token from the underlying buffer and convets it to an appropriate
+    # object
+    #
+    # operators - a hash of supported operators to read from the underlying buffer.
+    def parse_token (operators={})
+      ref = Reference.from_buffer(@buffer) and return ref
+      token = @buffer.token
+
+      case token
+      when "/"                        : return Name.new(@buffer.token)
+      when "<<"                       : return dictionary()
+      when "["                        : return array()
+      when "("                        : return string()
+      when "<"                        : return hex_string()
+      when "true"                     : return true
+      when "false"                    : return false
+      when "null"                     : return nil
+      when "obj", "endobj"            : return Token.new(token)
+      when "stream", "endstream"      : return Token.new(token)
+      when ">>", "]", ">"             : return Token.new(token)
+      else                          
+        if operators.has_key?(token)  : return Token.new(token)
+        else                            return token.to_f
+        end
+      end
+    end
+    ################################################################################
+    # reads a PDF dict from the buffer and converts it to a Ruby Hash.
+    def dictionary
+      dict = {}
+
+      loop do
+        key = parse_token
+        break if key.kind_of?(Token) and key == ">>"
+        raise MalformedPDFError, "PDF malformed, dictionary key is not a name" unless key.kind_of?(Name)
+
+        value = parse_token
+        value.kind_of?(Token) and Error.str_assert_not(value, ">>")
+        dict[key] = value
+      end
+
+      dict
+    end
+    ################################################################################
+    # reads a PDF array from the buffer and converts it to a Ruby Array.
+    def array
+      a = []
+
+      loop do
+        item = parse_token
+        break if item.kind_of?(Token) and item == "]"
+        a << item
+      end
+
+      a
+    end
+    ################################################################################
+    # Reads a PDF hex string from the buffer and converts it to a Ruby String
+    def hex_string
+      str = @buffer.token
+      Error.str_assert(@buffer.token, ">")
+
+      str << "0" unless str.size % 2 == 0
+      str.scan(/../).map {|i| i.hex.chr}.join
+    end
+    ################################################################################
+    # Reads a PDF String from the buffer and converts it to a Ruby String
+    def string
+      str = ""
+      count = 1
+
+      while count != 0
+        @buffer.ready_token(false, false)
+        i = @buffer.raw.index(/[\\\(\)]/)
+
+        if i.nil?
+          str << @buffer.raw + "\n"
+          @buffer.raw.replace("")
+          next
+        end
+
+        str << @buffer.head(i, false)
+        to_remove = 1
+
+        case @buffer.raw[0, 1]
+        when "("
+          str << "("
+          count += 1
+        when ")"
+          count -= 1
+          str << ")" unless count == 0
+        when "\\"
+          to_remove = 2
+          case @buffer.raw[1, 1]
+          when ""   : to_remove = 1
+          when "n"  : str << "\n"
+          when "r"  : str << "\r"
+          when "t"  : str << "\t"
+          when "b"  : str << "\b"
+          when "f"  : str << "\f"
+          when "("  : str << "("
+          when ")"  : str << ")"
+          when "\\" : str << "\\"
+          else
+            if m = @buffer.raw.match(/^\\(\d{1,3})/)
+              to_remove = m[0].size
+              str << m[1].oct.chr
+            end
+          end
+        end
+
+        @buffer.head(to_remove, false)
+      end
+
+      str
+    end
+    ################################################################################
+    # Reads an entire PDF object from the buffer and returns it as a Ruby String.
+    #
+    # id  - the object ID to return
+    # gen - the object revision number to return
+    def object (id, gen)
+      Error.assert_equal(parse_token, id)
+      Error.assert_equal(parse_token, gen)
+      Error.str_assert(parse_token, "obj")
+
+      obj = parse_token
+      post_obj = parse_token
+
+      case post_obj
+      when "endobj"   : return obj
+      when "stream"   : return 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')
+      dict['Length'] = @xref.object(dict['Length']) if dict['Length'].kind_of?(Reference)
+      data = @buffer.read(dict['Length'])
+      Error.str_assert(parse_token, "endstream")
+      Error.str_assert(parse_token, "endobj")
+
+      if dict.has_key?('Filter')
+        options = []
+
+        if dict.has_key?('DecodeParms')
+          options = dict['DecodeParms'].to_a
+        end
+
+        dict['Filter'].to_a.each_with_index do |filter, index|
+          data = Filter.new(filter, options[index]).filter(data)
+        end
+      end
+
+      data
+    end
+    ################################################################################
+  end
+  ################################################################################
+end
+################################################################################

data/lib/pdf/reader/reference.rb

@@ -0,0 +1,55 @@
+################################################################################
+#
+# 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
+  ################################################################################
+  # An internal PDF::Reader class that represents an indirect reference to a PDF Object 
+  class Reference
+    ################################################################################
+    # check if the next token in the buffer is a reference, and return a PDF::Reader::Reference
+    # instance. Returns nil if the next token isn't an indirect reference.
+    def self.from_buffer (buffer)
+      buffer.ready_token
+      return nil unless m = buffer.raw.match(/^(\d+)\s+(\d+)\s+R\b/)
+      buffer.head(m[0].size)
+      self.new(m[1].to_i, m[2].to_i)
+    end
+    ################################################################################
+    attr_reader :id, :gen
+    ################################################################################
+    # Create a new Reference to an object with the specified id and revision number
+    def initialize (id, gen)
+      @id, @gen = id, gen
+    end
+    ################################################################################
+    # returns the current Reference object in an array with a single element
+    def to_a
+      [self]
+    end
+    ################################################################################
+  end
+  ################################################################################
+end
+################################################################################

data/lib/pdf/reader/register_receiver.rb

@@ -0,0 +1,18 @@
+class PDF::Reader
+  class RegisterReceiver
+
+    attr_accessor :callbacks
+
+    def initialize
+      @callbacks = []
+    end
+
+    def respond_to?(meth)
+      true
+    end
+
+    def method_missing(methodname, *args)
+      callbacks << methodname.to_sym
+    end
+  end
+end

data/lib/pdf/reader/text_receiver.rb

@@ -0,0 +1,259 @@
+################################################################################
+#
+# 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
+  ################################################################################
+  # An example receiver class that processes all text found in a PDF file. All text that
+  # is found will be printed to the IO object specified in the constructor.
+  #
+  # Usage:
+  #  receiver = PDF::Reader::TextReceiver.new($stdout)
+  #  PDF::Reader.file("somefile.pdf", receiver)
+  class TextReceiver
+    ################################################################################
+    # Initialize with the library user's receiver
+    def initialize (main_receiver)
+      @main_receiver = main_receiver
+      @upper_corners = []
+    end
+    ################################################################################
+    # Called when the document parsing begins
+    def begin_document (root)
+      @upper_corners = []
+    end
+    ################################################################################
+    # Called when the document parsing ends
+    def end_document
+      @state.clear
+    end
+    ################################################################################
+    def begin_page_container (page)
+      @upper_corners.push(media_box_check(page))
+    end
+    ################################################################################
+    def end_page_container
+      @upper_corners.pop
+    end
+    ################################################################################
+    # Called when new page parsing begins
+    def begin_page (info)
+      @page = info
+
+      @state = [{
+        :char_spacing     => 0,
+        :word_spacing     => 0,
+        :hori_scaling     => 100,
+        :leading          => 0,
+        :tj_adjustment    => 0,
+      }]
+
+      @upper_corners.push(media_box_check(info))
+
+      @output = []
+      @line = 0
+      @location = 0
+      @displacement = {}
+      @smallest_y_loc = @upper_corners.last[:ury]
+      @written_to = false
+    end
+    ################################################################################
+    # Called when page parsing ends
+    def end_page
+      @main_receiver << @output.join("\n")
+      @upper_corners.pop
+    end
+    ################################################################################
+    # PDF operator BT
+    def begin_text_object
+      @state.push(@state.last.dup)
+    end
+    ################################################################################
+    # PDF operator ET
+    def end_text_object
+      @state.pop
+    end
+    ################################################################################
+    # PDF operator Tm
+    def set_text_matrix_and_text_line_matrix (a, b, c, d, e, f)
+      calculate_line_and_location(f)
+    end
+    ################################################################################
+    # PDF operator Tc
+    def set_character_spacing (n)
+      @state.last[:char_spacing] = n
+    end
+    ################################################################################
+    # PDF operator Tw
+    def set_word_spacing (n)
+      @state.last[:word_spacing] = n
+    end
+    ################################################################################
+    # PDF operator Tz
+    def set_horizontal_text_scaling (n)
+      @state.last[:hori_scaling] = n/100
+    end
+    ################################################################################
+    # PDF operator TL
+    def set_text_leading (n)
+      @state.last[:leading] = n
+    end
+    ################################################################################
+    # PDF operator T*
+    def move_to_start_of_next_line
+      move_text_position(0, @state.last[:leading])
+    end
+    ################################################################################
+    # PDF operator Td
+    def move_text_position (tx, ty)
+      #puts "#{tx} #{ty} Td"
+      calculate_line_and_location(@location + ty)
+    end
+    ################################################################################
+    # PDF operator TD
+    def move_text_position_and_set_leading (tx, ty)
+      set_text_leading(ty)# * -1)
+      move_text_position(tx, ty)
+    end
+    ################################################################################
+    # PDF operator Tj
+    def show_text (string)
+      #puts "getting line #@line"
+
+      place = (@output[@line] ||= "")
+      #place << "  " unless place.empty?
+
+      place << " " * (@state.last[:tj_adjustment].abs/900) if @state.last[:tj_adjustment] < -1000
+      place << string
+
+      #puts "place is now: #{place}"
+      @written_to = true
+    end
+    def super_show_text (string)
+      urx = @upper_corners.last[:urx]/TS_UNITS_PER_H_CHAR
+      ury = @upper_corners.last[:ury]/TS_UNITS_PER_V_CHAR
+
+      x = (@tm[2,0]/TS_UNITS_PER_H_CHAR).to_i
+      y = (ury - (@tm[2,1]/TS_UNITS_PER_V_CHAR)).to_i
+      
+      #puts "rendering '#{string}' to #{x}x#{y}"
+
+      place = (@output[y] ||= (" " * urx.to_i))
+      #puts "#{urx} #{place.size} #{string.size} #{x}"
+      return if x+string.size >= urx
+
+      string.split(//).each do |c|
+        chars = 1
+
+        case c
+        when " "
+          chars += @state.last[:word_spacing].to_i
+          place[x-1, chars] = (" " * chars)
+        else
+          chars += @state.last[:char_spacing].to_i
+          chars -= (@state.last[:tj_adjustment]/1000).to_i if @state.last[:tj_adjustment]
+          chars = 1 if chars < 1
+
+          place[x-1] = c
+          place[x, chars-1] = (" " * (chars-1)) if chars > 1
+        end
+
+        x += chars
+      end
+
+      @tm += Matrix.rows([[1, 0, 0], [0, 1, 0], [x*TS_UNITS_PER_H_CHAR, y*TS_UNITS_PER_V_CHAR, 1]])
+    end
+    ################################################################################
+    # PDF operator TJ
+    def show_text_with_positioning (params)
+      prev_adjustment = @state.last[:tj_adjustment]
+
+      params.each do |p|
+        case p
+        when Float
+          @state.last[:tj_adjustment] = p
+        else
+          show_text(p)
+        end
+      end
+
+      @state.last[:tj_adjustment]  = prev_adjustment
+    end
+    ################################################################################
+    # PDF operator '
+    def move_to_next_line_and_show_text (string)
+      move_to_start_of_next_line
+      show_text(string)
+    end
+    ################################################################################
+    # PDF operator "
+    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
+    ################################################################################
+    def media_box_check (dict)
+      corners = (@upper_corners.last || {:urx => 0, :ury => 0}).dup
+
+      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
+
+      corners
+    end
+    ################################################################################
+    def calculate_line_and_location (new_loc)
+      ##puts "calculate_line_and_location(#{new_loc})"
+      key = new_loc; key.freeze
+
+      #key = new_loc.to_s # because hashes with string keys are magic (auto-freeze)
+
+      if @written_to
+        unless @displacement.has_key?(key)
+          if key < @location
+            @displacement[key] = @line + 1
+          elsif key < @smallest_y_loc
+            @displacement[key] = @line + 1
+          else
+            key = @displacement.keys.find_all {|i| key > i}.sort.last
+            @displacement[key] = 0 unless @displacement.has_key?(key)
+          end
+        end
+      else
+        @displacement[key] = 0
+      end
+
+      @smallest_y_loc = key if key < @smallest_y_loc
+      @location = key
+      @line = @displacement[key]
+      #puts "calculate_line_and_location: @location=#@location @line=#@line smallest_y_loc=#@smallest_y_loc"
+    end
+    ################################################################################
+  end
+  ################################################################################
+end
+################################################################################