pdf-reader 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64f7a6d7ba48a6c2e9f665c30ccea5d402d1ecd2
-  data.tar.gz: 0e80a016f048834d6af4d392ab8d589753f6c907
+  metadata.gz: fb8a5be7c95212f559bb4d26af5fbdb484d21e77
+  data.tar.gz: f8fe70bf868dfff03b47a0b81993d1e680593e84
 SHA512:
-  metadata.gz: 2761c0e29839e6e832f08d6401ab585e0a34fb139c0d79678a24496b6b5ac97fd5c7160f8ab039d493629e759efa05ae0d69c370f52cb845015695945724ff10
-  data.tar.gz: 636cad85e5cbabc92f2752680f43c875da012bd3f0ec2047faa8653eeb84982c8935dbfb31f145e21bb5cec6984d1e05e0dd4b2e9d34dac7e5255133dc7075a3
+  metadata.gz: b881cecddfa41e3ad15dcafd31d4109290c664d0cf06478f3af6769aa7ced108e3ba082db54c6759c117d7559cc118e0d3a971c17b59cb23bf4e50024089fa6b
+  data.tar.gz: 50d61b135d79840dce5e5ca712b5db5185deefeee5de13d2adc63c1a8e1eb4b383bb0e8bb491c03bea49d11c4edf130b0fdb3b2eafea63ee0b85ca0390e047a0

data/CHANGELOG

@@ -1,9 +1,13 @@
+v1.4.1 (2nd January 2017)
+- improve compatability with ruby 2.4 (thanks Akira Matsuda)
+- various bug fixes
+
 v1.4.0 (22nd February 2016)
 - raise minimum ruby version to 1.9.3
 - print warnings to stderr when deprecated methods are used. These methods have been
   deprecated for 4 years, so hopefully few people are depending on them
-- Fix exception when a npn-breakng space (character 160) is used with a
-  built-in fint (helvetica, etc)
+- Fix exception when a non-breaking space (character 160) is used with a
+  built-in font (helvetica, etc)
 - various bug fixes
 
 v1.3.3 (7th April 2013)

data/Rakefile

@@ -4,27 +4,19 @@ require "rdoc/task"
 require "rspec/core/rake_task"
 require "yaml"
 
-# Cane requires ripper, which appears to only work on MRI 1.9
-if RUBY_VERSION >= "1.9" && RUBY_ENGINE == "ruby"
+desc "Default Task"
+task :default => [ :quality, :spec ]
 
-  desc "Default Task"
-  task :default => [ :quality, :spec ]
+require 'cane/rake_task'
+require 'morecane'
 
-  require 'cane/rake_task'
-  require 'morecane'
+desc "Run cane to check quality metrics"
+Cane::RakeTask.new(:quality) do |cane|
+  cane.abc_max = 20
+  cane.style_measure = 100
+  cane.max_violations = 93
 
-  desc "Run cane to check quality metrics"
-  Cane::RakeTask.new(:quality) do |cane|
-    cane.abc_max = 20
-    cane.style_measure = 100
-    cane.max_violations = 93
-
-    cane.use Morecane::EncodingCheck, :encoding_glob => "{app,lib,spec}/**/*.rb"
-  end
-
-else
-  desc "Default Task"
-  task :default => [ :spec ]
+  cane.use Morecane::EncodingCheck, :encoding_glob => "{app,lib,spec}/**/*.rb"
 end
 
 desc "Run all rspec files"

data/examples/callbacks.rb

@@ -9,12 +9,13 @@
 require 'rubygems'
 require 'pdf/reader'
 
-receiver = PDF::Reader::RegisterReceiver.new
 filename = File.expand_path(File.dirname(__FILE__)) + "/../spec/data/cairo-basic.pdf"
 
 PDF::Reader.open(filename) do |reader|
   reader.pages.each do |page|
+    receiver = PDF::Reader::RegisterReceiver.new
     page.walk(receiver)
+    
     receiver.callbacks.each do |cb|
       puts cb
     end

data/examples/fuzzy_paragraphs.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+# Extract an (imperfect) array of paragraphs divided somewhat
+# arbitrarily on line length. 
+
+require 'pdf/reader'
+
+reader = PDF::Reader.new('somefile.pdf')
+
+paragraph = ""
+paragraphs = []
+reader.pages.each do |page|
+  lines = page.text.scan(/^.+/)
+  lines.each do |line|
+    if line.length > 55
+      paragraph += " #{line}"
+    else
+      paragraph += " #{line}"
+      paragraphs << paragraph
+      paragraph = ""
+    end
+  end
+end

data/lib/pdf/reader.rb

@@ -285,7 +285,7 @@ module PDF
     #
     # Given an IO object that contains PDF data, return the contents of a single object
     #
-    def object (io, id, gen)
+    def object(io, id, gen)
       msg  = "PDF::Reader#object is deprecated and will be removed in the 2.0 release"
       $stderr.puts(msg)
       @objects = ObjectHash.new(io)

data/lib/pdf/reader/abstract_strategy.rb

@@ -23,7 +23,7 @@ class PDF::Reader
 
     # calls the name callback method on the receiver class with params as the arguments
     #
-    def callback (name, params=[])
+    def callback(name, params=[])
       @receivers.each do |receiver|
         receiver.send(name, *params) if receiver.respond_to?(name)
       end

data/lib/pdf/reader/buffer.rb

@@ -45,6 +45,7 @@ class PDF::Reader
     STREAM = "stream"
     ID = "ID"
     FWD_SLASH = "/"
+    NULL_BYTE = "\x00"
 
     attr_reader :pos
 
@@ -60,7 +61,7 @@ class PDF::Reader
     #   :content_stream - set to true if buffer will be tokenising a
     #                     content stream. Defaults to false
     #
-    def initialize (io, opts = {})
+    def initialize(io, opts = {})
       @io = io
       @tokens = []
       @in_content_stream = opts[:content_stream]
@@ -227,7 +228,7 @@ class PDF::Reader
 
       buffer = []
 
-      until buffer[0] =~ /\s/ && buffer[1, 2] == ["E", "I"]
+      until buffer[0] =~ /\s|\0/ && buffer[1, 2] == ["E", "I"]
         chr = @io.read(1)
         buffer << chr
 
@@ -236,7 +237,9 @@ class PDF::Reader
         end
       end
 
-      @tokens << string_token(str.strip)
+      str << NULL_BYTE if buffer.first == NULL_BYTE
+
+      @tokens << string_token(str)
       @io.seek(-3, IO::SEEK_CUR) unless chr.nil?
     end
 

data/lib/pdf/reader/cmap.rb

@@ -68,11 +68,11 @@ class PDF::Reader
 
     # Convert a glyph code into one or more Codepoints.
     #
-    # Returns an array of Fixnums.
+    # Returns an array of Integers.
     #
     def decode(c)
       # TODO: implement the conversion
-      return c unless c.class == Fixnum
+      return c unless Integer === c
       @map[c]
     end
 

data/lib/pdf/reader/encoding.rb

@@ -112,7 +112,7 @@ class PDF::Reader
     # convert an integer glyph code into an Adobe glyph name.
     #
     #     int_to_name(65)
-    #     => :A
+    #     => [:A]
     #
     def int_to_name(glyph_code)
       if @enc_name == "Identity-H" || @enc_name == "Identity-V"
@@ -210,7 +210,7 @@ class PDF::Reader
       RUBY_VERSION >= "1.9" ? mode = "r:BINARY" : mode = "r"
       File.open(file, mode) do |f|
         f.each do |l|
-          m, single_byte, unicode = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
+          _m, single_byte, unicode = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
           @mapping["0x#{single_byte}".hex] = "0x#{unicode}".hex if single_byte
         end
       end

data/lib/pdf/reader/error.rb

@@ -29,19 +29,19 @@ class PDF::Reader
   # are valid
   class Error # :nodoc:
     ################################################################################
-    def self.str_assert (lvalue, rvalue, chars=nil)
+    def self.str_assert(lvalue, rvalue, chars=nil)
       raise MalformedPDFError, "PDF malformed, expected string but found #{lvalue.class} instead" if chars and !lvalue.kind_of?(String)
       lvalue = lvalue[0,chars] if chars
       raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found #{lvalue} instead"  if lvalue != rvalue
     end
     ################################################################################
-    def self.str_assert_not (lvalue, rvalue, chars=nil)
+    def self.str_assert_not(lvalue, rvalue, chars=nil)
       raise MalformedPDFError, "PDF malformed, expected string but found #{lvalue.class} instead" if chars and !lvalue.kind_of?(String)
       lvalue = lvalue[0,chars] if chars
       raise MalformedPDFError, "PDF malformed, expected '#{rvalue}' but found #{lvalue} instead"  if lvalue == rvalue
     end
     ################################################################################
-    def self.assert_equal (lvalue, rvalue)
+    def self.assert_equal(lvalue, rvalue)
       raise MalformedPDFError, "PDF malformed, expected #{rvalue} but found #{lvalue} instead" if lvalue != rvalue
     end
     ################################################################################

data/lib/pdf/reader/font.rb

@@ -161,15 +161,16 @@ class PDF::Reader
     end
 
     def to_utf8_via_cmap(params)
-      if params.class == Fixnum
+      case params
+      when Integer
         [
           @tounicode.decode(params) || PDF::Reader::Encoding::UNKNOWN_CHAR
         ].flatten.pack("U*")
-      elsif params.class == String
+      when String
         params.unpack(encoding.unpack).map { |c|
           @tounicode.decode(c) || PDF::Reader::Encoding::UNKNOWN_CHAR
         }.flatten.pack("U*")
-      elsif params.class == Array
+      when Array
         params.collect { |param| to_utf8_via_cmap(param) }
       else
         params
@@ -181,11 +182,12 @@ class PDF::Reader
         raise UnsupportedFeatureError, "font encoding '#{encoding}' currently unsupported"
       end
 
-      if params.class == Fixnum
+      case params
+      when Integer
         encoding.int_to_utf8_string(params)
-      elsif params.class == String
+      when String
         encoding.to_utf8(params)
-      elsif params.class == Array
+      when Array
         params.collect { |param| to_utf8_via_encoding(param) }
       else
         params

data/lib/pdf/reader/glyph_hash.rb

@@ -81,16 +81,16 @@ class PDF::Reader
     #   h = GlyphHash.new
     #
     #   h.unicode_to_name(65)
-    #   => :A
+    #   => [:A]
     #
     #   h.unicode_to_name(8364)
-    #   => :Euro
+    #   => [:Euro]
     #
     #   h.unicode_to_name(34)
-    #   => :34
+    #   => [:34]
     #
     def unicode_to_name(codepoint)
-      @by_codepoint[codepoint.to_i]
+      @by_codepoint[codepoint.to_i] || []
     end
 
     private
@@ -105,7 +105,7 @@ class PDF::Reader
       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})/)
+          _m, name, code = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
           if name && code
             cp = "0x#{code}".hex
             keyed_by_name[name.to_sym]   = cp

data/lib/pdf/reader/object_hash.rb

@@ -78,7 +78,7 @@ class PDF::Reader
 
       if @cache.has_key?(key)
         @cache[key]
-      elsif xref[key].is_a?(Fixnum)
+      elsif xref[key].is_a?(Integer)
         buf = new_buffer(xref[key])
         @cache[key] = decrypt(key, Parser.new(buf, self).object(key.id, key.gen))
       elsif xref[key].is_a?(PDF::Reader::Reference)
@@ -323,7 +323,7 @@ class PDF::Reader
 
     def read_version
       @io.seek(0)
-      m, version = *@io.read(10).match(/PDF-(\d.\d)/)
+      _m, version = *@io.read(10).match(/PDF-(\d.\d)/)
       @io.seek(0)
       version.to_f
     end

data/lib/pdf/reader/page.rb

@@ -155,7 +155,7 @@ module PDF
 
       # calls the name callback method on each receiver object with params as the arguments
       #
-      def callback (receivers, name, params=[])
+      def callback(receivers, name, params=[])
         receivers.each do |receiver|
           receiver.send(name, *params) if receiver.respond_to?(name)
         end

data/lib/pdf/reader/page_state.rb

@@ -327,7 +327,6 @@ class PDF::Reader
           glyph_width = ((w0 - (tj/1000.0)) * fs) * th
           tx = glyph_width + ((tc + tw) * th)
         end
-        ty = 0
 
         # TODO: I'm pretty sure that tx shouldn't need to be divided by
         #       ctm[0] here, but this gets my tests green and I'm out of

data/lib/pdf/reader/page_text_receiver.rb

@@ -14,7 +14,7 @@ module PDF
 
       SPACE = " "
 
-      attr_reader :state, :content, :options
+      attr_reader :state, :options
 
       ########## BEGIN FORWARDERS ##########
       # Graphics State Operators

data/lib/pdf/reader/pages_strategy.rb

@@ -282,7 +282,7 @@ class PDF::Reader
     ################################################################################
     # Walk over all pages in the PDF file, calling the appropriate callbacks for each page and all
     # its content
-    def walk_pages (page)
+    def walk_pages(page)
 
       # extract page content
       if page[:Type] == :Pages
@@ -351,7 +351,7 @@ 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 = {})
+    def content_stream(instructions, fonts = {})
       instructions = [instructions] unless instructions.kind_of?(Array)
       instructions = instructions.map { |ins|
         ins.is_a?(PDF::Reader::Stream) ? ins.unfiltered_data : ins.to_s
@@ -399,7 +399,7 @@ class PDF::Reader
           params << token
         end
       end
-    rescue EOFError => e
+    rescue EOFError
       raise MalformedPDFError, "End Of File while processing a content stream"
     end
     ################################################################################

data/lib/pdf/reader/parser.rb

@@ -60,7 +60,7 @@ class PDF::Reader
     #
     # buffer - a PDF::Reader::Buffer object that contains PDF data
     # objects  - a PDF::Reader::ObjectHash object that can return objects from the PDF file
-    def initialize (buffer, objects=nil)
+    def initialize(buffer, objects=nil)
       @buffer = buffer
       @objects  = objects
     end
@@ -69,7 +69,7 @@ class PDF::Reader
     # object
     #
     # operators - a hash of supported operators to read from the underlying buffer.
-    def parse_token (operators={})
+    def parse_token(operators={})
       token = @buffer.token
 
       if STRATEGIES.has_key? token
@@ -93,7 +93,7 @@ class PDF::Reader
     #
     # id  - the object ID to return
     # gen - the object revision number to return
-    def object (id, gen)
+    def object(id, gen)
       Error.assert_equal(parse_token, id)
       Error.assert_equal(parse_token, gen)
       Error.str_assert(parse_token, "obj")
@@ -198,7 +198,7 @@ class PDF::Reader
 
     ################################################################################
     # Decodes the contents of a PDF Stream and returns it as a Ruby String.
-    def stream (dict)
+    def stream(dict)
       raise MalformedPDFError, "PDF malformed, missing stream length" unless dict.has_key?(:Length)
       if @objects
         length = @objects.deref(dict[:Length])

data/lib/pdf/reader/reference.rb

@@ -32,7 +32,7 @@ class PDF::Reader
     attr_reader :id, :gen
     ################################################################################
     # Create a new Reference to an object with the specified id and revision number
-    def initialize (id, gen)
+    def initialize(id, gen)
       @id, @gen = id, gen
     end
     ################################################################################

data/lib/pdf/reader/register_receiver.rb

@@ -64,7 +64,6 @@ class PDF::Reader
 
       indexes = (0..(callbacks.size-1))
       method_indexes = (0..(methods.size-1))
-      match = nil
 
       indexes.each do |idx|
         count = methods.size

data/lib/pdf/reader/stream.rb

@@ -37,7 +37,7 @@ class PDF::Reader
     ################################################################################
     # Creates a new stream with the specified dictionary and data. The dictionary
     # should be a standard ruby hash, the data should be a standard ruby string.
-    def initialize (hash, data)
+    def initialize(hash, data)
       @hash = hash
       @data = data
       @udata = nil

data/lib/pdf/reader/text_receiver.rb

@@ -39,13 +39,13 @@ class PDF::Reader
   class TextReceiver
     ################################################################################
     # Initialize with the library user's receiver
-    def initialize (main_receiver)
+    def initialize(main_receiver)
       @main_receiver = main_receiver
       @upper_corners = []
     end
     ################################################################################
     # Called when the document parsing begins
-    def begin_document (root)
+    def begin_document(root)
       @upper_corners = []
     end
     ################################################################################
@@ -54,7 +54,7 @@ class PDF::Reader
       @state.clear
     end
     ################################################################################
-    def begin_page_container (page)
+    def begin_page_container(page)
       @upper_corners.push(media_box_check(page))
     end
     ################################################################################
@@ -63,7 +63,7 @@ class PDF::Reader
     end
     ################################################################################
     # Called when new page parsing begins
-    def begin_page (info)
+    def begin_page(info)
       @page = info
 
       @state = [{
@@ -101,29 +101,29 @@ class PDF::Reader
     end
     ################################################################################
     # PDF operator Tm
-    def set_text_matrix_and_text_line_matrix (*args)
+    def set_text_matrix_and_text_line_matrix(*args)
       # these variable names look bad, but they're from the PDF spec
-      a, b, c, d, e, f = *args
+      _a, _b, _c, _d, _e, f = *args
       calculate_line_and_location(f)
     end
     ################################################################################
     # PDF operator Tc
-    def set_character_spacing (n)
+    def set_character_spacing(n)
       @state.last[:char_spacing] = n
     end
     ################################################################################
     # PDF operator Tw
-    def set_word_spacing (n)
+    def set_word_spacing(n)
       @state.last[:word_spacing] = n
     end
     ################################################################################
     # PDF operator Tz
-    def set_horizontal_text_scaling (n)
+    def set_horizontal_text_scaling(n)
       @state.last[:hori_scaling] = n/100
     end
     ################################################################################
     # PDF operator TL
-    def set_text_leading (n)
+    def set_text_leading(n)
       @state.last[:leading] = n
     end
     ################################################################################
@@ -133,19 +133,19 @@ class PDF::Reader
     end
     ################################################################################
     # PDF operator Td
-    def move_text_position (tx, ty)
+    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)
+    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)
+    def show_text(string)
       #puts "getting line #@line"
 
       place = (@output[@line] ||= "")
@@ -157,7 +157,7 @@ class PDF::Reader
       #puts "place is now: #{place}"
       @written_to = true
     end
-    def super_show_text (string)
+    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
 
@@ -193,12 +193,12 @@ class PDF::Reader
     end
     ################################################################################
     # PDF operator TJ
-    def show_text_with_positioning (params)
+    def show_text_with_positioning(params)
       prev_adjustment = @state.last[:tj_adjustment]
 
       params.each do |p|
         case p
-        when Float, Fixnum
+        when Float, Integer
           @state.last[:tj_adjustment] = p
         else
           show_text(p)
@@ -209,19 +209,19 @@ class PDF::Reader
     end
     ################################################################################
     # PDF operator '
-    def move_to_next_line_and_show_text (string)
+    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)
+    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)
+    def media_box_check(dict)
       corners = (@upper_corners.last || {:urx => 0, :ury => 0}).dup
 
       if dict.has_key?(:MediaBox)
@@ -233,7 +233,7 @@ class PDF::Reader
       corners
     end
     ################################################################################
-    def calculate_line_and_location (new_loc)
+    def calculate_line_and_location(new_loc)
       ##puts "calculate_line_and_location(#{new_loc})"
       key = new_loc; key.freeze
 

data/lib/pdf/reader/token.rb

@@ -33,7 +33,7 @@ class PDF::Reader
   class Token < String # :nodoc:
     ################################################################################
     # Creates a new token with the specified value
-    def initialize (val)
+    def initialize(val)
       super
     end
     ################################################################################

data/lib/pdf/reader/width_calculator/built_in.rb

@@ -30,6 +30,7 @@ class PDF::Reader
         m = @metrics.char_metrics_by_code[code_point]
         if m.nil?
           names = @font.encoding.int_to_name(code_point)
+
           m = names.map { |name|
             @metrics.char_metrics[name.to_s]
           }.compact.first

data/lib/pdf/reader/xref.rb

@@ -53,7 +53,7 @@ class PDF::Reader
     #
     # io - must be an IO object, generally either a file or a StringIO
     #
-    def initialize (io)
+    def initialize(io)
       @io = io
       @junk_offset = calc_junk_offset(io) || 0
       @xref = {}
@@ -219,7 +219,7 @@ class PDF::Reader
     ################################################################################
     # Stores an offset value for a particular PDF object ID and revision number
     #
-    def store (id, gen, offset)
+    def store(id, gen, offset)
       (@xref[id] ||= {})[gen] ||= offset
     end
     ################################################################################

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pdf-reader
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors:
 - James Healy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-22 00:00:00.000000000 Z
+date: 2017-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: morecane
   requirement: !ruby/object:Gem::Requirement
@@ -207,6 +207,7 @@ files:
 - examples/extract_bates.rb
 - examples/extract_fonts.rb
 - examples/extract_images.rb
+- examples/fuzzy_paragraphs.rb
 - examples/hash.rb
 - examples/metadata.rb
 - examples/page_count.rb
@@ -325,7 +326,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: A library for accessing the content of PDF files