combine_pdf 0.2.21 → 0.2.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4705fea5bde857e260f98fa8610c8947895a8771
-  data.tar.gz: f48137c987828a2ff637006360a9085bec11d6d4
+  metadata.gz: b28c525adfbcb7025e3510ede89ba70593ee92cc
+  data.tar.gz: bcd134da186dadebdc27839c2ce09f3133119763
 SHA512:
-  metadata.gz: d8aa105aa32d36a45c030a774029635f32e7d042e9afc3db86664eb99f6cc872a262b1d46613dc6e6884fbee53aa0cda02f32528a93a2e220621a592e7e39f6c
-  data.tar.gz: cced4adc08cb505eac7fffc39262f3ce0abe9d1d64853bab3c2eb8d52d7a0c04f35f24c240b80cab2ea34e1b46a88ab28c8654cf152adcede37ec01c59f02ba6
+  metadata.gz: a61cd27e67327472a645bccb8f4f63c7e472d65ae51b122727e7eddca4ff9d58ead490030a55dc991450df2ae2f41343845f19cf587d5aff21ca7a93dcb0ba79
+  data.tar.gz: b5bfe0b958dd21ae305698b1e4376940a1fe0055f79cfbf75d8a0d003ba7de57dfb8b2d9cd15e39fc6dcac8277ff9f766fc9163154f4b39f4ec9b67ebf5f5c55

data/CHANGELOG.md

@@ -2,6 +2,60 @@
 
 ***
 
+Change log v.0.2.27
+
+**Fix**: Fixed an issue where a `nil` outline count would cause PDF merger to fail.
+
+**Fix**: Fixed an issue where `nil` data would cause the named destination rebuilding process to quit early, leaving some of the data unprocessed. Credit to Stefan Leitner (@sLe1tner) for exposing the issue.
+
+**Feature**: PDF outlines are now merged and named destination links are preserved (both in the outlines and the page content). Credit to Stefan Leitner (@sLe1tner) for this feature.
+
+***
+
+Change log v.0.2.26
+
+**Fix**: Merged PR #72, fixing a typo in the parser that caused incorrect byte substitution to corrupt certain PDF data (adversely effecting encrypted PDFs). Credit to Gyuchang Jun (@gyuchang) for the fix.
+
+***
+
+Change log v.0.2.25
+
+**Fix**: Fixed issue #71, merging PDF outline that exist but have 0 entries fails and raises an exception. Credit to @Kagetsuki for exposing the issue.
+
+***
+
+Change log v.0.2.24
+
+**Fix**: Fixed an issue with PDF Catalog and PDF Page property inheritance that could cause corrupted PDF output (invalid PDF data). Credit to @Kagetsuki for opening an issue that let to this discovery.
+
+**Fix**: Fixed an issue with the parser where (ignored) empty strings would cause incorrect alignment when converting PDF dictionary objects from an Array to a Hash, mixing up keys and values. Credit to @Kagetsuki for opening an issue that let to this discovery.
+
+**Fix**: more fixes and refinements to the PDF Names dictionary with better named destination support and document navigation support.
+
+***
+
+Change log v.0.2.23
+
+**Fix**: fixed an issue introduced in v.0.2.22, where name dictionary conflict resolution would result in corrupted PDF files. The issue was caused because the name conflict resolution wasn't updated to handle the changes in the new reference linking algorithm used by the parser. During this fix, the whole name dictionary algorithm was re-written, providing better support for named destinations, links and (future feature) ToCs. Credit to Kevin Shen (@kevshin2) for exposing the issue.
+
+***
+
+Change log v.0.2.22 (yanked)
+
+**Fix**: fixed an issue with PDF font importing (registering).
+
+**Fix**: fixed issue #65 where some form data (radio buttons) could be lost. Credit to @joshirashmics for exposing the issue.
+
+**Fix**: fixed an issue where empty names would be ignored by the parser (who knew they existed...).
+
+**Fix**: Possible fix for issue #66 (similar to PR #61)... Credit to Serafeim Maroulis (@Reyko) and Kevin Shen (@kevshin2) for exposing the issue.
+
+**Update**: Rewrote some internal algorithms, avoiding recursive logic and optimizing against excessive stack stress.
+
+**Feature**: Credit to Joel Williams (@joelw) for providing `CombinePDF.load` and `CombinePDF.parse` customization, allowing optional content errors to be ignored - taking the risk of a corrupt PDF instead of raising an exception (hey, loading PDF data with optional content sometimes works).
+
+***
+
 Change log v.0.2.21
 
 **Fix**: fix for issue #54 and #59 (duplicate), discovered by @iggant (Anton Kolodii), related to name conflict resolution and page resources. The issue would cause and error (exception) to occur when attempting to merge pages with specific resource structures. Credit to @cw6365 (Chris Ward) and @DenKey (Den) as well.

data/LICENSE.txt

@@ -1,4 +1,5 @@
-Copyright (c) 2014 Myst
+Copyright (c) 2014,2015,2016 Boaz Segev (Myst - @boazsegev)
+Copyright (c) 2016 Stefan Leitner (@sLe1tner) (credit for outline merging code)
 
 MIT License
 

data/README.md

@@ -14,6 +14,24 @@ gem install combine_pdf
 
 ## Known Limitations
 
+Quick rundown:
+
+* When reading PDF Forms, some form data might be lost. I tried fixing this to the best of my ability, but I'm not sure it all works just yet.
+
+* When combining PDF Forms, form data might be unified. If you're combining two PDF files with form data, the data might be unified. I couldn't fix this, but frankly, I kinda liked the issue... it's almost a feature.
+
+* When unifying the same TOC data more then once, one of the references will be unified with the other.
+
+* Links and named destinations (i.e., a link in the PDF to a web page or a different page in the same PDF) might break. Again, I tried fixing this, but some of it depends on the TOC and some of it is susceptible to conflicts between files.
+
+    Also, some links and data (URL links and PDF "Named Destinations") are stored at the root of a PDF and they aren't linked back to from the page.
+
+    For this reason, some links will be lost when ripping pages out of PDF files and merging them with another PDF.
+
+* Some encrypted PDF files (usually the ones you can't view without a password) will fail quietly instead of noisily.
+
+* Sometimes the CombinePDF will raise an exception even if the PDF could be parsed (i.e., when PDF optional content exists)... I find it better to err on the side of caution, although for optional content PDFs it is avoidable using `CombinePDF.load(pdf_file, allow_optional_content: true)`.
+
 CombinePDF is written natively in Ruby and should (presumably) work on all Ruby platforms that follow Ruby 2.0 compatibility.
 
 However, PDF files are quite complex creatures and no guaranty is provided.
@@ -122,6 +140,16 @@ headers 'content-type' => "application/pdf"
 
 If you prefer to save the PDF data to a file, you can always use the `save` method as we did in our earlier examples.
 
+Some PDF files contain optional content sections which cannot always be merged reliably. By default, an exception is
+raised if one of these files are detected. You can optionally pass an `allow_optional_content` parameter to the
+`PDFParser.new`, `CombinePDF.load` and `CombinePDF.parse` methods:
+
+```ruby
+new_pdf = CombinePDF.new
+new_pdf << CombinePDF.load(pdf_file, allow_optional_content: true)
+attachments.each { |att| new_pdf << CombinePDF.load(att, allow_optional_content: true) }
+```
+
 Demo
 ====
 
@@ -148,6 +176,8 @@ The code itself should be very straight forward, but feel free to ask whatever y
 Credit
 ======
 
+Stefan Leitner (@sLe1tner) wrote the outline merging code supporting PDFs which contain a ToC.
+
 Caige Nichols wrote an amazing RC4 gem which I used in my code.
 
 I wanted to install the gem, but I had issues with the internet and ended up copying the code itself into the combine_pdf_decrypt class file.

data/lib/combine_pdf.rb

@@ -6,25 +6,23 @@ require 'strscan'
 require 'matrix'
 require 'set'
 
-#require the RC4 Gem
+# require the RC4 Gem
 require 'rc4'
 
-
-load "combine_pdf/api.rb"
-load "combine_pdf/renderer.rb"
-load "combine_pdf/page_methods.rb"
-load "combine_pdf/basic_writer.rb"
-load "combine_pdf/decrypt.rb"
-load "combine_pdf/fonts.rb"
-load "combine_pdf/filter.rb"
-load "combine_pdf/parser.rb"
-load "combine_pdf/pdf_public.rb"
-load "combine_pdf/pdf_protected.rb"
+load 'combine_pdf/api.rb'
+load 'combine_pdf/renderer.rb'
+load 'combine_pdf/page_methods.rb'
+load 'combine_pdf/basic_writer.rb'
+load 'combine_pdf/decrypt.rb'
+load 'combine_pdf/fonts.rb'
+load 'combine_pdf/filter.rb'
+load 'combine_pdf/parser.rb'
+load 'combine_pdf/pdf_public.rb'
+load 'combine_pdf/pdf_protected.rb'
 
 # load "combine_pdf/operations.rb"
 
-load "combine_pdf/version.rb"
-
+load 'combine_pdf/version.rb'
 
 # This is a pure ruby library to combine/merge, stmap/overlay and number PDF files - as well as to create tables (ment for indexing combined files).
 #
@@ -128,11 +126,8 @@ load "combine_pdf/version.rb"
 #
 # MIT
 module CombinePDF
-
 end
 
-
-
 #########################################################
 # this file is part of the CombinePDF library and the code
 # is subject to the same license (MIT).
@@ -181,4 +176,3 @@ end
 ### gives 0.000000   0.000000   1.010000 (  1.147135)
 ### file merge FAILS with 1,000 empty pages (undecrypted)
 ####### gives: 0.000000   0.000000   1.770000 (  1.775513) with draft. file size 4.9MB (!!!)
-

data/lib/combine_pdf/api.rb

@@ -1,167 +1,170 @@
 # -*- encoding : utf-8 -*-
 
+module CombinePDF
+  module_function
 
+  # Create an empty PDF object or create a PDF object from a file (parsing the file).
+  # file_name:: is the name of a file to be parsed.
+  def load(file_name = '', options = {})
+    raise TypeError, "couldn't parse data, expecting type String" unless file_name.is_a?(String) || file_name.is_a?(Pathname)
+    return PDF.new if file_name == ''
+    PDF.new(PDFParser.new(IO.read(file_name, mode: 'rb').force_encoding(Encoding::ASCII_8BIT), options))
+  end
 
+  # creats a new PDF object.
+  #
+  # Combine PDF will check to see if `string` is a filename.
+  # If it's a file name, it will attempt to load the PDF file using `CombinePDF.load`. Otherwise it will attempt parsing `string` using `CombinePDF.parse`.
+  #
+  # If the string is empty it will return a new PDF object (the same as parse).
+  #
+  # For both performance and code readability reasons, `CombinePDF.load` and `CombinePDF.parse` should be preffered unless creating a new PDF object.
+  def new(string = false)
+    return PDF.new unless string
+    raise TypeError, "couldn't create PDF object, expecting type String" unless string.is_a?(String) || string.is_a?(Pathname)
+    begin
+      (begin
+     File.file? string
+   rescue
+     false
+   end) ? load(string) : parse(string)
+    rescue => e
+      raise 'General PDF error - Use CombinePDF.load or CombinePDF.parse for a non-general error message (the requested file was not found OR the string received is not a valid PDF stream OR the file was found but not valid).'
+    end
+  end
 
+  # Create a PDF object from a raw PDF data (parsing the data).
+  # data:: is a string that represents the content of a PDF file.
+  def parse(data, options = {})
+    raise TypeError, "couldn't parse and data, expecting type String" unless data.is_a? String
+    PDF.new(PDFParser.new(data, options))
+  end
 
-module CombinePDF
-	module_function
+  # makes a PDFWriter object
+  #
+  # PDFWriter objects reresent an empty page and have the method "textbox"
+  # that adds content to that page.
+  #
+  # PDFWriter objects are used internally for numbering pages (by creating a PDF page
+  # with the page number and "stamping" it over the existing page).
+  #
+  # ::mediabox an Array representing the size of the PDF document. defaults to: [0.0, 0.0, 612.0, 792.0] (US Letter)
+  #
+  # if the page is PDFWriter object as a stamp, the final size will be that of the original page.
+  def create_page(mediabox = [0, 0, 612.0, 792.0])
+    PDFWriter.new mediabox
+  end
 
-	# Create an empty PDF object or create a PDF object from a file (parsing the file).
-	# file_name:: is the name of a file to be parsed.
-	def load(file_name = "")
-		raise TypeError, "couldn't parse data, expecting type String" unless file_name.is_a?(String) || file_name.is_a?(Pathname)
-		return PDF.new() if file_name == ''
-		PDF.new( PDFParser.new(  IO.read(file_name, mode: 'rb').force_encoding(Encoding::ASCII_8BIT) ) )
-	end
-	# creats a new PDF object.
-	#
-	# Combine PDF will check to see if `string` is a filename.
-	# If it's a file name, it will attempt to load the PDF file using `CombinePDF.load`. Otherwise it will attempt parsing `string` using `CombinePDF.parse`.
-	#
-	# If the string is empty it will return a new PDF object (the same as parse).
-	#
-	# For both performance and code readability reasons, `CombinePDF.load` and `CombinePDF.parse` should be preffered unless creating a new PDF object.
-	def new(string = false)
-		return PDF.new unless string
-		raise TypeError, "couldn't create PDF object, expecting type String" unless string.is_a?(String) || string.is_a?(Pathname)
-		begin
-			(File.file? string rescue false) ? load(string) : parse(string)
-		rescue => e
-			raise 'General PDF error - Use CombinePDF.load or CombinePDF.parse for a non-general error message (the requested file was not found OR the string received is not a valid PDF stream OR the file was found but not valid).'
-		end
-		
-	end
+  # makes a PDF object containing a table
+  #
+  # all the pages in this PDF object are PDFWriter objects and are
+  # writable using the texbox function (should you wish to add a title, or more info)
+  #
+  # the main intended use of this method is to create indexes (a table of contents) for merged data.
+  #
+  # example:
+  #   pdf = CombinePDF.create_table headers: ["header 1", "another header"], table_data: [ ["this is one row", "with two columns"] , ["this is another row", "also two columns", "the third will be ignored"] ]
+  #   pdf.save "table_file.pdf"
+  #
+  # accepts a Hash with any of the following keys as well as any of the Page_Methods#textbox options:
+  # headers:: an Array of strings with the headers (will be repeated every page).
+  # table_data:: as Array of Arrays, each containing a string for each column. the first row sets the number of columns. extra columns will be ignored.
+  # font:: a registered or standard font name (see Page_Methods). defaults to nil (:Helvetica).
+  # header_font:: a registered or standard font name for the headers (see Page_Methods). defaults to nil (the font for all the table rows).
+  # max_font_size:: the maximum font size. if the string doesn't fit, it will be resized. defaults to 14.
+  # column_widths:: an array of relative column widths ([1,2] will display only the first two columns, the second twice as big as the first). defaults to nil (even widths).
+  # header_color:: the header color. defaults to [0.8, 0.8, 0.8] (light gray).
+  # main_color:: main row color. defaults to nil (transparent / white).
+  # alternate_color:: alternate row color. defaults to [0.95, 0.95, 0.95] (very light gray).
+  # font_color:: font color. defaults to [0,0,0] (black).
+  # border_color:: border color. defaults to [0,0,0] (black).
+  # border_width:: border width in PDF units. defaults to 1.
+  # header_align:: the header text alignment within each column (:right, :left, :center). defaults to :center.
+  # row_align:: the row text alignment within each column. defaults to :left (:right for RTL table).
+  # direction:: the table's writing direction (:ltr or :rtl). this reffers to the direction of the columns and doesn't effect text (rtl text is automatically recognized). defaults to :ltr.
+  # max_rows:: the number of rows per page, INCLUDING the header row. deafults to 25.
+  # page_size:: the size of the page in PDF points. defaults to [0, 0, 595.3, 841.9] (A4).
+  def create_table(options = {})
+    options[:max_rows] = options[:rows_per_page] if options[:rows_per_page]
 
-	# Create a PDF object from a raw PDF data (parsing the data).
-	# data:: is a string that represents the content of a PDF file.
-	def parse(data)
-		raise TypeError, "couldn't parse and data, expecting type String" unless data.is_a? String
-		PDF.new( PDFParser.new(data) )
-	end
-	# makes a PDFWriter object
-	#
-	# PDFWriter objects reresent an empty page and have the method "textbox"
-	# that adds content to that page.
-	#
-	# PDFWriter objects are used internally for numbering pages (by creating a PDF page
-	# with the page number and "stamping" it over the existing page).
-	#
-	# ::mediabox an Array representing the size of the PDF document. defaults to: [0.0, 0.0, 612.0, 792.0] (US Letter)
-	#
-	# if the page is PDFWriter object as a stamp, the final size will be that of the original page.
-	def create_page(mediabox = [0, 0, 612.0, 792.0])
-		PDFWriter.new mediabox
-	end
+    page_size = options[:page_size] || [0, 0, 595.3, 841.9]
+    table = PDF.new
+    page = nil
+    until options[:table_data].empty?
+      page = create_page page_size
+      page.write_table options
+      table << page
+    end
+    table
+  end
 
-	# makes a PDF object containing a table
-	#
-	# all the pages in this PDF object are PDFWriter objects and are
-	# writable using the texbox function (should you wish to add a title, or more info)
-	#
-	# the main intended use of this method is to create indexes (a table of contents) for merged data.
-	#
-	# example:
-	#   pdf = CombinePDF.create_table headers: ["header 1", "another header"], table_data: [ ["this is one row", "with two columns"] , ["this is another row", "also two columns", "the third will be ignored"] ]
-	#   pdf.save "table_file.pdf"
-	#
-	# accepts a Hash with any of the following keys as well as any of the Page_Methods#textbox options:
-	# headers:: an Array of strings with the headers (will be repeated every page).
-	# table_data:: as Array of Arrays, each containing a string for each column. the first row sets the number of columns. extra columns will be ignored.
-	# font:: a registered or standard font name (see Page_Methods). defaults to nil (:Helvetica).
-	# header_font:: a registered or standard font name for the headers (see Page_Methods). defaults to nil (the font for all the table rows).
-	# max_font_size:: the maximum font size. if the string doesn't fit, it will be resized. defaults to 14.
-	# column_widths:: an array of relative column widths ([1,2] will display only the first two columns, the second twice as big as the first). defaults to nil (even widths).
-	# header_color:: the header color. defaults to [0.8, 0.8, 0.8] (light gray).
-	# main_color:: main row color. defaults to nil (transparent / white).
-	# alternate_color:: alternate row color. defaults to [0.95, 0.95, 0.95] (very light gray).
-	# font_color:: font color. defaults to [0,0,0] (black).
-	# border_color:: border color. defaults to [0,0,0] (black).
-	# border_width:: border width in PDF units. defaults to 1.
-	# header_align:: the header text alignment within each column (:right, :left, :center). defaults to :center.
-	# row_align:: the row text alignment within each column. defaults to :left (:right for RTL table).
-	# direction:: the table's writing direction (:ltr or :rtl). this reffers to the direction of the columns and doesn't effect text (rtl text is automatically recognized). defaults to :ltr.
-	# max_rows:: the number of rows per page, INCLUDING the header row. deafults to 25.
-	# page_size:: the size of the page in PDF points. defaults to [0, 0, 595.3, 841.9] (A4).
-	def create_table(options = {})
-		options[:max_rows] = options[:rows_per_page] if options[:rows_per_page]
+  def new_table(options = {})
+    create_table options
+  end
 
-		page_size = options[:page_size] || [0, 0, 595.3, 841.9]
-		table = PDF.new()
-		page = nil
-		until options[:table_data].empty?
-			page = create_page page_size
-			page.write_table options
-			table << page
-		end
-		table
-	end
-	def new_table(options = {})
-		create_table options
-	end
+  # calculate a CTM value for a specific transformation.
+  #
+  # this could be used to apply transformation in #textbox and to convert visual
+  # rotation values into actual rotation transformation.
+  #
+  # this method accepts a Hash containing any of the following parameters:
+  #
+  # deg:: the clockwise rotation to be applied, in degrees
+  # tx:: the x translation to be applied.
+  # ty:: the y translation to be applied.
+  # sx:: the x scaling to be applied.
+  # sy:: the y scaling to be applied.
+  #
+  # * scaling will be applied after the transformation is applied.
+  #
+  def calc_ctm(parameters)
+    p = { deg: 0, tx: 0, ty: 0, sx: 1, sy: 1 }.merge parameters
+    r = p[:deg] * Math::PI / 180
+    s = Math.sin(r)
+    c = Math.cos(r)
+    # start with tranlation matrix
+    m = Matrix[[1, 0, 0], [0, 1, 0], [p[:tx], p[:ty], 1]]
+    # then rotate
+    m *= Matrix[[c, s, 0], [-s, c, 0], [0, 0, 1]] if parameters[:deg]
+    # then scale
+    m *= Matrix[[p[:sx], 0, 0], [0, p[:sy], 0], [0, 0, 1]] if parameters[:sx] || parameters[:sy]
+    # flaten array and round to 6 digits
+    m.to_a.flatten.values_at(0, 1, 3, 4, 6, 7).map! { |f| f.round 6 }
+  end
 
-	# calculate a CTM value for a specific transformation.
-	#
-	# this could be used to apply transformation in #textbox and to convert visual
-	# rotation values into actual rotation transformation.
-	#
-	# this method accepts a Hash containing any of the following parameters:
-	#
-	# deg:: the clockwise rotation to be applied, in degrees
-	# tx:: the x translation to be applied.
-	# ty:: the y translation to be applied.
-	# sx:: the x scaling to be applied.
-	# sy:: the y scaling to be applied.
-	#
-	# * scaling will be applied after the transformation is applied.
-	#
-	def calc_ctm parameters
-		p = {deg: 0, tx: 0, ty: 0, sx: 1, sy: 1}.merge parameters
-		r = p[:deg] * Math::PI / 180
-		s = Math.sin(r)
-		c = Math.cos(r)
-		# start with tranlation matrix
-		m = Matrix[ [1,0,0], [0,1,0], [ p[:tx], p[:ty], 1] ]
-		# then rotate
-		m = m * Matrix[ [c, s, 0], [-s, c, 0], [0, 0, 1]] if parameters[:deg]
-		# then scale
-		m = m * Matrix[ [p[:sx], 0, 0], [0, p[:sy], 0], [0,0,1] ] if parameters[:sx] || parameters[:sy]
-		# flaten array and round to 6 digits
-		m.to_a.flatten.values_at(0,1,3,4,6,7).map! {|f| f.round 6}
-	end
+  # adds a correctly formatted font object to the font library.
+  #
+  # registered fonts will remain in the library and will only be embeded in
+  # PDF objects when they are used by PDFWriter objects (for example, for numbering pages).
+  #
+  # this function enables plug-ins to expend the font functionality of CombinePDF.
+  #
+  # font_name:: a Symbol with the name of the font. if the fonts exists in the library, it will be overwritten!
+  # font_metrics:: a Hash of font metrics, of the format char => {wx: char_width, boundingbox: [left_x, buttom_y, right_x, top_y]} where char == character itself (i.e. " " for space). The Hash should contain a special value :missing for the metrics of missing characters. an optional :wy might be supported in the future, for up to down fonts.
+  # font_pdf_object:: a Hash in the internal format recognized by CombinePDF, that represents the font object.
+  # font_cmap:: a CMap dictionary Hash) which maps unicode characters to the hex CID for the font (i.e. {"a" => "61", "z" => "7a" }).
+  def register_font(font_name, font_metrics, font_pdf_object, font_cmap = nil)
+    Fonts.register_font font_name, font_metrics, font_pdf_object, font_cmap
+  end
 
-	# adds a correctly formatted font object to the font library.
-	#
-	# registered fonts will remain in the library and will only be embeded in
-	# PDF objects when they are used by PDFWriter objects (for example, for numbering pages).
-	#
-	# this function enables plug-ins to expend the font functionality of CombinePDF.
-	#
-	# font_name:: a Symbol with the name of the font. if the fonts exists in the library, it will be overwritten!
-	# font_metrics:: a Hash of font metrics, of the format char => {wx: char_width, boundingbox: [left_x, buttom_y, right_x, top_y]} where char == character itself (i.e. " " for space). The Hash should contain a special value :missing for the metrics of missing characters. an optional :wy might be supported in the future, for up to down fonts.
-	# font_pdf_object:: a Hash in the internal format recognized by CombinePDF, that represents the font object.
-	# font_cmap:: a CMap dictionary Hash) which maps unicode characters to the hex CID for the font (i.e. {"a" => "61", "z" => "7a" }).
-	def register_font(font_name, font_metrics, font_pdf_object, font_cmap = nil)
-		Fonts.register_font font_name, font_metrics, font_pdf_object, font_cmap
-	end
+  # adds an existing font (from any PDF Object) to the font library.
+  #
+  # returns the font on success or false on failure.
+  #
+  # example:
+  #   fonts = CombinePDF.new("japanese_fonts.pdf").fonts(true)
+  #   CombinePDF.register_font_from_pdf_object :david, fonts[0]
+  #
+  # VERY LIMITTED SUPPORT:
+  # - at the moment it only imports Type0 fonts.
+  # - also, to extract the Hash of the actual font object you were looking for, is not a trivial matter. I do it on the console.
+  # font_name:: a Symbol with the name of the font registry. if the fonts exists in the library, it will be overwritten!
+  # font_object:: a Hash in the internal format recognized by CombinePDF, that represents the font object.
+  def register_existing_font(font_name, font_object)
+    Fonts.register_font_from_pdf_object font_name, font_object
+  end
 
-	# adds an existing font (from any PDF Object) to the font library.
-	#
-	# returns the font on success or false on failure.
-	#
-	# example:
-	#   fonts = CombinePDF.new("japanese_fonts.pdf").fonts(true)
-	#   CombinePDF.register_font_from_pdf_object :david, fonts[0]
-	#
-	# VERY LIMITTED SUPPORT:
-	# - at the moment it only imports Type0 fonts.
-	# - also, to extract the Hash of the actual font object you were looking for, is not a trivial matter. I do it on the console.
-	# font_name:: a Symbol with the name of the font registry. if the fonts exists in the library, it will be overwritten! 
-	# font_object:: a Hash in the internal format recognized by CombinePDF, that represents the font object.
-	def register_existing_font font_name, font_object
-		Fonts.register_font_from_pdf_object font_name, font_object
-	end
-	def register_font_from_pdf_object font_name, font_object
-		register_existing_font font_name, font_object
-	end
+  def register_font_from_pdf_object(font_name, font_object)
+    register_existing_font font_name, font_object
+  end
 end