combine_pdf 0.1.23 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eca9f69f00f53b73949ed2b50dbfeb1f805003f6
-  data.tar.gz: 69b5a220280dfbd5ec5b20f78c5f47fd2011a328
+  metadata.gz: e4bac3486fb9fc968d2ca625eb4ad9c0f9423cc7
+  data.tar.gz: 5d7d3b20987af05c2cf71c2513bf09418125cae3
 SHA512:
-  metadata.gz: f1544fdae3546f748a640c2a8b2e7902b1bc38eae5cebf3f4a4849da0e584504ea8343705210f7ad9a3d5ca6c9ce3491202aefcfee5f049f9fc2a88f98962c9b
-  data.tar.gz: 9bb5f19edac2b53133ad3d2e8e1a4d02e478b15f46ff3f13e75ada91b56fce38595e4e67696280771bb75a210136120de1be0f598a73f678bff621a1dba54b9b
+  metadata.gz: cb03d4476aa78f13d783142c9f91263814d5c9dce299ceb5728dddc79cac0253f4d45ea048953dc69b04fa4ad8416926cd09f05c124ba3b6f3169b827fed86be
+  data.tar.gz: c3dbbfc3716b9caa49ffc1b98282a266d20ebf66a126d2cd7d8a06699ed196a97491a51ad425e1d0d4dcc940eb87721e5114b9aed3d2511b4f0ae33ec05ebb6a

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ***
 
+Change log v.0.2.0
+
+Refractoring of code and API overhall.
+
+Any code relying on inner/advanced API calls might be broken.
+
+**fix**: fixed an object numbering issue introduced by duplicating pages. The issue didn't seem to effect readers nor performance.
+
+**fix**: combine_pdf will now properly raise an error when Optional Content Groups (OCG's) are implemented in a PDF file. Page extraction isn't supported for PDF files with OCG's.
+
+***
+
 Change log v.0.1.23
 
 **fix**: @kruszczynski fixed an issue with CombinePDF::PDF#number_pages where the page numbering margines were ignored and only the default values were used. Thank you @kruszczynski .

data/README.md

@@ -15,15 +15,15 @@ To combine PDF files (or data):
 
 ```ruby
 pdf = CombinePDF.new
-pdf << CombinePDF.new("file1.pdf") # one way to combine, very fast.
-pdf << CombinePDF.new("file2.pdf")
+pdf << CombinePDF.load("file1.pdf") # one way to combine, very fast.
+pdf << CombinePDF.load("file2.pdf")
 pdf.save "combined.pdf"
 ```
 
 Or even a one liner:
 
 ```ruby
-(CombinePDF.new("file1.pdf") << CombinePDF.new("file2.pdf") << CombinePDF.new("file3.pdf")).save("combined.pdf")
+(CombinePDF.load("file1.pdf") << CombinePDF.load("file2.pdf") << CombinePDF.load("file3.pdf")).save("combined.pdf")
 ```
 
 you can also add just odd or even pages:
@@ -31,7 +31,7 @@ you can also add just odd or even pages:
 ```ruby
 pdf = CombinePDF.new
 i = 0
-CombinePDF.new("file.pdf").pages.each do |page|
+CombinePDF.load("file.pdf").pages.each do |page|
   i += 1
   pdf << page if i.even?
 end
@@ -46,8 +46,8 @@ To add content to existing PDF pages, first import the new content from an exist
 In this example, we will add a company logo to each page:
 
 ```ruby
-company_logo = CombinePDF.new("company_logo.pdf").pages[0]
-pdf = CombinePDF.new "content_file.pdf"
+company_logo = CombinePDF.load("company_logo.pdf").pages[0]
+pdf = CombinePDF.load "content_file.pdf"
 pdf.pages.each {|page| page << company_logo} # notice the << operator is on a page and not a PDF object.
 pdf.save "content_with_logo.pdf"
 ```
@@ -65,7 +65,7 @@ pdf.pages(nil, false).each {|page| page << stamp_page}
 adding page numbers to a PDF object or file is as simple as can be:
 
 ```ruby
-pdf = CombinePDF.new "file_to_number.pdf"
+pdf = CombinePDF.load "file_to_number.pdf"
 pdf.number_pages
 pdf.save "file_with_numbering.pdf"
 ```
@@ -79,7 +79,7 @@ Loading PDF data can be done from file system or directly from the memory.
 Loading data from a file is easy:
 
 ```ruby
-pdf = CombinePDF.new("file.pdf")
+pdf = CombinePDF.load("file.pdf")
 ```
 
 you can also parse PDF files from memory:

data/combine_pdf.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Boaz Segev"]
   spec.email         = ["boaz@2be.co.il"]
   spec.summary       = %q{Combine, stamp and watermark PDF files in pure Ruby.}
-  spec.description   = %q{A nifty gem, in pure Ruby, to parse PDF files and combine (merge) them with other PDF files, number the pages, watermark them or stamp them, create tables or basic text objects etc` (all using the PDF file format).}
+  spec.description   = %q{A nifty gem, in pure Ruby, to parse PDF files and combine (merge) them with other PDF files, number the pages, watermark them or stamp them, create tables, add basic text objects etc` (all using the PDF file format).}
   spec.homepage      = "https://github.com/boazsegev/combine_pdf"
   spec.license       = "MIT"
 

data/lib/combine_pdf.rb

@@ -9,17 +9,20 @@ require 'matrix'
 require 'rc4'
 
 
-load "combine_pdf/combine_pdf_operations.rb"
-load "combine_pdf/combine_pdf_page.rb"
-load "combine_pdf/combine_pdf_basic_writer.rb"
-load "combine_pdf/combine_pdf_decrypt.rb"
-load "combine_pdf/combine_pdf_fonts.rb"
-load "combine_pdf/combine_pdf_filter.rb"
-load "combine_pdf/combine_pdf_parser.rb"
-load "combine_pdf/combine_pdf_pdf.rb"
-require "combine_pdf/version"
+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/combine_pdf_methods.rb"
+# load "combine_pdf/operations.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).
@@ -33,22 +36,22 @@ load "combine_pdf/combine_pdf_methods.rb"
 # Loading PDF data can be done from file system or directly from the memory.
 #
 # Load data from a file:
-#   pdf = CombinePDF.new("file.pdf")
+#   pdf = CombinePDF.load("file.pdf")
 # parse PDF files from memory:
 #   pdf = CombinePDF.parse(pdf_data)
 #
 # == Combine/Merge PDF files or Pages
 # To combine PDF files (or data):
 #   pdf = CombinePDF.new
-#   pdf << CombinePDF.new("file1.pdf")
-#   pdf << CombinePDF.new("file2.pdf")
+#   pdf << CombinePDF.load("file1.pdf")
+#   pdf << CombinePDF.load("file2.pdf")
 #   pdf.save "combined.pdf"
 #
 # It is possible to add only specific pages.
 # in this example, only even pages will be added:
 #   pdf = CombinePDF.new
 #   i = 0
-#   CombinePDF.new("file.pdf").pages.each do |page|
+#   CombinePDF.load("file.pdf").pages.each do |page|
 #     i += 1
 #     pdf << page if i.even?
 #   end
@@ -56,14 +59,14 @@ load "combine_pdf/combine_pdf_methods.rb"
 # Notice that adding the whole file is faster then adding each page seperately.
 # == Add content to existing pages (Stamp / Watermark)
 # It is possible "stamp" one PDF page using another PDF page. In this example, a company logo will be stamped over each page:
-#   company_logo = CombinePDF.new("company_logo.pdf").pages[0]
-#   pdf = CombinePDF.new "content_file.pdf"
+#   company_logo = CombinePDF.load("company_logo.pdf").pages[0]
+#   pdf = CombinePDF.load "content_file.pdf"
 #   pdf.pages.each {|page| page << company_logo}
 #   pdf.save "content_with_logo.pdf"
 # Notice the << operator is on a page and not a PDF object. The << operator acts differently on PDF objects and on Pages.
 # == Page Numbering
 # It is possible to number the pages. in this example we will add very simple numbering:
-#   pdf = CombinePDF.new "file_to_number.pdf"
+#   pdf = CombinePDF.load "file_to_number.pdf"
 #   pdf.number_pages
 #   pdf.save "file_with_numbering.pdf"
 #
@@ -73,13 +76,13 @@ load "combine_pdf/combine_pdf_methods.rb"
 #
 # in this example, all the PDF pages will be stamped, along the top, with a red box, with blue text, stating "Draft, page #".
 # here is the easy way (we can even use "number_pages" without page numbers, if we wish):
-#   pdf = CombinePDF.new "file_to_stamp.pdf"
+#   pdf = CombinePDF.load "file_to_stamp.pdf"
 #   pdf.number_pages number_format: " - Draft, page %d - ", number_location: [:top], font_color: [0,0,1], box_color: [0.4,0,0], opacity: 0.75, font_size:16
 #   pdf.save "draft.pdf"
 #
 # in this example we will add a first page with the word "Draft", in red over a colored background:
 #
-#   pdf = CombinePDF.new "file.pdf"
+#   pdf = CombinePDF.load "file.pdf"
 #   pdf_first_page = pdf.pages[0]
 #   mediabox = page[:CropBox] || page[:MediaBox] #copy page size
 #   title_page = CombinePDF.create_page mediabox #make title page same size as first page

data/lib/combine_pdf/{combine_pdf_methods.rb → api.rb}

@@ -10,12 +10,22 @@ module CombinePDF
 	# 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 and data, expecting type String" unless file_name.is_a?(String) || file_name.is_a?(Pathname)
+		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
-	def new(file_name = "")
-		load(file_name) rescue parse(file_name)
+	# 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)
+		(File.file? string rescue false) ? load(string) : parse(string)
 	end
 
 	# Create a PDF object from a raw PDF data (parsing the data).
@@ -50,11 +60,11 @@ module CombinePDF
 	#   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 PDFWriter#textbox options:
+	# 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 PDFWriter). defaults to nil (:Helvetica).
-	# header_font:: a registered or standard font name for the headers (see PDFWriter). defaults to nil (the font for all the table rows).
+	# 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).
@@ -80,83 +90,6 @@ module CombinePDF
 			table << page
 		end
 		table
-
-		# defaults = {
-		# 	headers: nil,
-		# 	table_data: [[]],
-		# 	font: nil,
-		# 	header_font: nil,
-		# 	max_font_size: 14,
-		# 	column_widths: nil,
-		# 	header_color: [0.8, 0.8, 0.8],
-		# 	main_color: nil,
-		# 	alternate_color: [0.95, 0.95, 0.95],
-		# 	font_color: [0,0,0],
-		# 	border_color: [0,0,0],
-		# 	border_width: 1,
-		# 	header_align: :center,
-		# 	row_align: nil,
-		# 	direction: :ltr,
-		# 	rows_per_page: 25,
-		# 	page_size: [0, 0, 595.3, 841.9] #A4
-		# }
-		# options = defaults.merge options
-		# options[:header_font] = options[:font] unless options[:header_font]
-		# options[:row_align] ||= ( (options[:direction] == :rtl) ? :right : :left )
-		# # assert table_data is an array of arrays
-		# return false unless (options[:table_data].select {|r| !r.is_a?(Array) }).empty?
-		# # compute sizes
-		# page_size = options[:page_size]
-		# top = page_size[3] * 0.9
-		# height = page_size[3] * 0.8 / options[:rows_per_page]
-		# from_side = page_size[2] * 0.1
-		# width = page_size[2] * 0.8
-		# columns = options[:table_data][0].length
-		# column_widths = []
-		# columns.times {|i| column_widths << (width/columns) }
-		# if options[:column_widths]
-		# 	scale = 0
-		# 	options[:column_widths].each {|w| scale += w}
-		# 	column_widths = []
-		# 	options[:column_widths].each { |w|  column_widths << (width*w/scale) }
-		# end
-		# column_widths = column_widths.reverse if options[:direction] == :rtl
-		# # set pdf object and start writing the data
-		# table = PDF.new()
-		# page = nil
-		# rows_per_page = options[:rows_per_page]
-		# row_number = rows_per_page + 1
-
-		# options[:table_data].each do |row_data|
-		# 	if row_number > rows_per_page
-		# 		page = create_page page_size
-		# 		table << page
-		# 		row_number = 1
-		# 		# add headers
-		# 		if options[:headers]
-		# 			x = from_side
-		# 			headers = options[:headers]
-		# 			headers = headers.reverse if options[:direction] == :rtl
-		# 			column_widths.each_index do |i|
-		# 				text = headers[i].to_s
-		# 				page.textbox text, {x: x, y: (top - (height*row_number)), width: column_widths[i], height: height, box_color: options[:header_color], text_align: options[:header_align] }.merge(options).merge({font: options[:header_font]})
-		# 				x += column_widths[i]
-		# 			end
-		# 			row_number += 1
-		# 		end
-		# 	end
-		# 	x = from_side
-		# 	row_data = row_data.reverse if options[:direction] == :rtl
-		# 	column_widths.each_index do |i|
-		# 		text = row_data[i].to_s
-		# 		box_color = options[:main_color]
-		# 		box_color = options[:alternate_color] if options[:alternate_color] && row_number.odd?
-		# 		page.textbox text, {x: x, y: (top - (height*row_number)), width: column_widths[i], height: height, box_color: box_color, text_align: options[:row_align]}.merge(options)
-		# 		x += column_widths[i]
-		# 	end			
-		# 	row_number += 1
-		# end
-		# table
 	end
 	def new_table(options = {})
 		create_table options

data/lib/combine_pdf/basic_writer.rb

@@ -0,0 +1,62 @@
+# -*- encoding : utf-8 -*-
+########################################################
+## Thoughts from reading the ISO 32000-1:2008
+## this file is part of the CombinePDF library and the code
+## is subject to the same license.
+########################################################
+
+
+
+
+module CombinePDF
+
+	# Limited Unicode Support (font dependent)!
+	#
+	# The PDFWriter class is a subclass of Hash and represents a PDF Page object. 
+	#
+	# Writing on this Page is done using the textbox function.
+	#
+	# Setting the page dimensions can be either at the new or using the mediabox method. New pages default to size A4, which is: [0, 0, 595.3, 841.9].
+	#
+	# Once the Page is completed (the last text box was added),
+	# we can insert the page to a CombinePDF object.
+	#
+	# We can either insert the PDFWriter as a new page:
+	#   pdf = CombinePDF.new
+	#   new_page = CombinePDF.create_page # => PDFWriter object
+	#   new_page.textbox "some text"
+	#   pdf << new_page
+	#   pdf.save "file_with_new_page.pdf"
+	#
+	# Or we can use the Page_Methods methods to write an overlay (stamp / watermark) over existing pages:
+	#   pdf = CombinePDF.new
+	#   new_page = PDFWriter.new "some_file.pdf"
+	#   pdf.pages.each {|page| page.textbox "Draft", opacity: 0.4 }
+	#   pdf.save "stamped_file.pdf"
+	class PDFWriter < Hash
+
+		# create a new PDFWriter object.
+		#
+		# mediabox:: the PDF page size in PDF points. defaults to [0, 0, 595.3, 841.9] (A4)
+		def initialize(mediabox = [0, 0, 595.3, 841.9])
+			# indirect_reference_id, :indirect_generation_number
+			@contents = ""
+			@base_font_name = "Writer" + SecureRandom.hex(7) + "PDF"
+			self[:Type] = :Page
+			self[:indirect_reference_id] = 0
+			self[:Resources] = {}
+			self[:Contents] = { is_reference_only: true , referenced_object: {indirect_reference_id: 0, raw_stream_content: @contents} }
+			self[:MediaBox] = mediabox
+		end
+
+		# includes the PDF Page_Methods module, including all page methods (textbox etc').
+		include Page_Methods
+
+	end
+	
+end
+
+
+
+
+

data/lib/combine_pdf/{combine_pdf_decrypt.rb → decrypt.rb}

@@ -34,7 +34,7 @@ module CombinePDF
 							0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A ]
 			@key_crypt_first_iv_store = nil
 			@encryption_iv = nil
-			PDFOperations.change_references_to_actual_values @objects, @encryption_dictionary
+			change_references_to_actual_values @encryption_dictionary
 		end
 
 		# call this to start the decryption.
@@ -142,6 +142,9 @@ module CombinePDF
 			cipher.padding = 0
 			(cipher.update(encrypted) + cipher.final).unpack("C*")
 		end
+
+		protected
+
 		def _perform_decrypt_proc_ (object, decrypt_proc, encrypted_id = nil, encrypted_generation = nil, encrypted_filter = nil)
 			case
 			when object.is_a?(Array)
@@ -153,7 +156,7 @@ module CombinePDF
 				if object[:raw_stream_content]
 					stream_length = object[:Length]
 					if stream_length.is_a?(Hash) && stream_length[:is_reference_only]
-						stream_length = PDFOperations.get_refernced_object( @objects, stream_length)[:indirect_without_dictionary]
+						stream_length = get_refernced_object(stream_length)[:indirect_without_dictionary]
 					end
 					actual_length = object[:raw_stream_content].length
 					warn "Stream registeded length was #{object[:Length].to_s} and the actual length was #{actual_length}." if actual_length < stream_length
@@ -174,6 +177,36 @@ module CombinePDF
 			warn "Data raising exception:\n #{object.to_s.split(',').join("\n")}"
 			raise "File is encrypted - not supported."			
 		end
+
+		def change_references_to_actual_values(hash_with_references = {})
+			hash_with_references.each do |k,v|
+				if v.is_a?(Hash) && v[:is_reference_only]
+					hash_with_references[k] = get_refernced_object(v)
+					hash_with_references[k] = hash_with_references[k][:indirect_without_dictionary] if hash_with_references[k].is_a?(Hash) && hash_with_references[k][:indirect_without_dictionary]
+					warn "Couldn't connect all values from references - didn't find reference #{hash_with_references}!!!" if hash_with_references[k] == nil
+					hash_with_references[k] = v unless hash_with_references[k]
+				end
+			end
+			hash_with_references
+		end
+		def get_refernced_object(reference_hash = {})
+			@objects.each do |stored_object|
+				return stored_object if ( stored_object.is_a?(Hash) &&
+					reference_hash[:indirect_reference_id] == stored_object[:indirect_reference_id] &&
+					reference_hash[:indirect_generation_number] == stored_object[:indirect_generation_number] )
+			end
+			warn "didn't find reference #{reference_hash}"
+			nil		
+		end
+
+
+		# # returns the PDF Object Hash holding the acutal data (if exists) or the original hash (if it wasn't a reference)
+		# #
+		# # works only AFTER references have been connected.
+		# def get_referenced object
+		# 	object[:referenced_object] || object
+		# end
+
 	end
 	#####################################################
 	## The following isn't my code!!!!

data/lib/combine_pdf/{combine_pdf_fonts.rb → fonts.rb}

@@ -18,6 +18,7 @@ module CombinePDF
 
 
 	module Fonts
+		extend Renderer
 
 		protected
 
@@ -53,7 +54,7 @@ module CombinePDF
 			# This function translate a unicode string, to a character glyph ID stream.
 			def encode text
 				# FixMe: embed RTL text convertion
-				return PDFOperations._format_string_to_pdf(text) unless self.cmap
+				return format_string_to_pdf(text) unless self.cmap
 				coded_array = text.chars.map do |c|
 					if self.cmap[c]
 						self.cmap[c]
@@ -91,14 +92,24 @@ module CombinePDF
 			FONTS_LIBRARY.keys			
 		end
 
-		# gets a font from the fonts library
-		def get_font(name = :Helvetica)
+		# gets the original font object from the fonts library (this allows you to edit the font).
+		def get_original_font(name = :Helvetica)
 			initiate_library
 			FONTS_LIBRARY[name]
 		end
 
+		# gets a copy of the font object from the fonts library (this allows you to use the font as an object is a PDF file, without altering the original registered font).
+		def get_font(name = :Helvetica)
+			initiate_library
+			font = FONTS_LIBRARY[name]
+			return nil unless font
+			font = font.dup
+			font[:referenced_object] = font[:referenced_object].dup if font[:referenced_object]
+			font
+		end
+
 		# adds a correctly formatted font object to the font library.
-		# font_name:: a Symbol with the name of the font. if the fonts exists, it will be overwritten!
+		# font_name:: a Symbol with the name of the font. if the fonts name exists, the font will be overwritten!
 		# font_metrics:: a Hash of ont metrics, of the format char => {wx: char_width, boundingbox: [left_x, buttom_y, right_x, top_y]} where i == character code (i.e. 32 for space). The Hash should contain a special value :missing for the metrics of missing characters. an optional :wy will 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" }).
@@ -125,9 +136,9 @@ module CombinePDF
 			merged_metrics = {}
 			# merge the metrics last to first (so that important fonts override secondary fonts)
 			fonts.length.downto(1).each do |i|
-				f = get_font(fonts[i-1])
+				f = get_original_font(fonts[i-1])
 				if f && f.metrics
-					merged_metrics.update( get_font(fonts[i-1]).metrics)
+					merged_metrics.update( get_original_font(fonts[i-1]).metrics)
 				else
 					warn "metrics of font not found!"
 				end
@@ -212,7 +223,7 @@ module CombinePDF
 				to_unicode = font_object[:ToUnicode]
 				to_unicode = to_unicode[:referenced_object] if to_unicode[:is_reference_only]
 				# deflate the cmap file stream before parsing
-				to_unicode = PDFOperations.create_deep_copy to_unicode
+				to_unicode = create_deep_copy to_unicode
 				CombinePDF::PDFFilter.inflate_object to_unicode
 				# parse the deflated stream
 				cmap = self.parse_cmap to_unicode[:raw_stream_content]
@@ -241,7 +252,7 @@ module CombinePDF
 			if old_widths[:W]
 				old_widths = old_widths[:W]
 				old_widths = old_widths[:referenced_object][:indirect_without_dictionary] if old_widths[:is_reference_only]
-				old_widths = PDFOperations.create_deep_copy old_widths
+				old_widths = create_deep_copy old_widths
 				while old_widths[0] do
 					a = old_widths.shift
 					b = old_widths.shift