text_alignment 0.11.3 → 0.11.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f019e7fbd144890e96eda8f2cf9b27cf091930c96b81236452172a5142e2cf3
-  data.tar.gz: 47d32ec727511d53730bf56557992f972f7747832f9437f5e2f5798cd0764f41
+  metadata.gz: 5f95c7fb8bfdeb768fbd1400f7e785a2ed18016322f2cdcba3ea7196aa4e86ac
+  data.tar.gz: cad0296a218108884703af07bcbf1b303a6e12c51ab14ad872586c50cfc8e82c
 SHA512:
-  metadata.gz: bf2720ce7af3612a8c0b1823bf6265e90f0d5e92f315d7eb697c4b13e1c9752e795adb5b1dbc840629379f3e96cf94115dd5d9400663f1d43a4caf428274f69a
-  data.tar.gz: d7bca56968c54fa68d83b5e9d89aa89107774cde761117e28d561cf9c63226b08a613e84b3484f2df58edaadfac7e1b286155bc3486559d6fd7c63d6ec082907
+  metadata.gz: 5d18a8d142974967fcfe358b561c83d76d1c5d8d2a277092ed4a8b42de14cd791b004830ff9f145735e6bc0a1265295f4fd6190c674ba62b57190d7e035a863b
+  data.tar.gz: c155ff9780d5f82893825787ee39ba319ddb1f16396d6a933334a83e485ff4d2eb2840d5fc1399f9873cd69a2458f029ced0d128d9099c4f08137d360e3e2007

data/bin/align_annotations

@@ -2,6 +2,7 @@
 require 'text_alignment'
 require 'json'
 require 'pp'
+require 'optparse'
 
 def read_annotations(filename)
 	case File.extname(filename)
@@ -108,24 +109,54 @@ def align_mannotations(source_annotations, reference_text, alignment, debug = fa
 end
 
 
+## Options
+options = {}
+verbose = false
+
+## command line option processing
+require 'optparse'
+optparse = OptionParser.new do |opts|
+	opts.banner = "Usage: align_annotations [options] target_annotations(.json|.txt) reference_text(.json|.txt)"
+
+	opts.on('-d', '--duplicate', 'tells it to assume there may be duplicate texts.') do
+		options[:duplicate_texts] = true
+	end
+
+	opts.on('-w', '--no-whitespaces', 'tells it to ignore whitespaces.') do
+		options[:to_ignore_whitespaces] = true
+	end
+
+	opts.on('-o', '--no-order', 'tells it to ignore the order of the texts.') do
+		options[:to_ignore_text_order] = true
+	end
+
+	opts.on('-v', '--verbose', 'tells it to show the state verbosely for debugging.') do
+		verbose = true
+	end
+
+	opts.on('-h', '--help', 'displays this screen.') do
+		puts opts
+		exit
+	end
+end
+
+optparse.parse!
+
 unless ARGV.length == 2
-	warn "align_annotations target_annotations(.json|.txt) reference_annotations(.json|.txt)"
-	exit
+	puts optparse.help
+	exit 1
 end
 
 source_annotations = read_annotations(ARGV[0])
 reference_text = read_text(ARGV[1])
 
-alignment = TextAlignment::TextAlignment.new(reference_text, true)
+alignment = TextAlignment::TextAlignment.new(reference_text, options)
 
 target_annotations = if source_annotations.class == Array
-	# align_mannotations(source_annotations, reference_text, alignment, true)
-	align_mannotations(source_annotations, reference_text, alignment, false)
+	align_mannotations(source_annotations, reference_text, alignment, verbose)
 else
-	# denotations = align_denotations(source_annotations[:denotations], source_annotations[:text], alignment)
-	denotations = align_denotations(source_annotations[:denotations], source_annotations[:text], alignment, false)
+	denotations = align_denotations(source_annotations[:denotations], source_annotations[:text], alignment, verbose)
 	source_annotations.merge({text:reference_text, denotations:denotations})
 end
 
-# pp alignment.block_alignment
 # puts target_annotations.to_json

data/lib/text_alignment/anchor_finder.rb

@@ -6,11 +6,18 @@ module TextAlignment; end unless defined? TextAlignment
 
 class TextAlignment::AnchorFinder
 
-	def initialize(source_str, target_str, cultivation_map)
+	def initialize(source_str, target_str, cultivation_map, to_ignore_whitespaces = false, to_ignore_text_order = false)
+		@method_get_left_windows, @method_get_right_windows = if to_ignore_whitespaces
+			[method(:get_left_windows_no_squeeze_ws), method(:get_right_windows_no_squeeze_ws)]
+		else
+			[method(:get_left_windows), method(:get_right_windows)]
+		end
+
 		@s1 = source_str.downcase
 		@s2 = target_str.downcase
 
 		@cultivation_map = cultivation_map
+		@to_ignore_text_order = to_ignore_text_order
 
 		@size_ngram  = TextAlignment::SIZE_NGRAM
 		@size_window = TextAlignment::SIZE_WINDOW
@@ -65,10 +72,7 @@ class TextAlignment::AnchorFinder
 		# to get the anchor to search for in s2
 		anchor = @s1[beg_s1, @size_ngram]
 
-		# comment out below with the assumption that texts are in the same order
-		# search_position = 0
-		search_position = @pos_s2_last_match
-
+		search_position = @to_ignore_text_order ? 0 : @pos_s2_last_match
 		beg_s2_candidates = find_beg_s2_candidates(anchor, search_position)
 		return nil if beg_s2_candidates.empty?
 
@@ -108,14 +112,14 @@ class TextAlignment::AnchorFinder
 					next
 				end
 
-				left_window_s1, left_window_s2 = get_left_windows(beg_s1, beg_s2, size_window)
+				left_window_s1, left_window_s2 = @method_get_left_windows.call(beg_s1, beg_s2, size_window)
 				if left_window_s1 && (text_similarity(left_window_s1, left_window_s2) > @sim_threshold)
 					break unless valid_beg_s2.nil?
 					valid_beg_s2 = beg_s2
 					next
 				end
 
-				right_window_s1, right_window_s2 = get_right_windows(beg_s1, beg_s2, size_window)
+				right_window_s1, right_window_s2 = @method_get_right_windows.call(beg_s1, beg_s2, size_window)
 				if right_window_s2 && (text_similarity(right_window_s1, right_window_s2) > @sim_threshold)
 					break unless valid_beg_s2.nil?
 					valid_beg_s2 = beg_s2
@@ -139,7 +143,7 @@ class TextAlignment::AnchorFinder
 		size_window ||= @size_window
 
 		# comment out below with the assumption that the beginning of a document gives a significant locational information
-		# return if @beg_s1 < size_window || @beg_s2 < size_window
+		# return if beg_s1 < size_window || beg_s2 < size_window
 
 		window_s1 = ''
 		loc = beg_s1 - 1
@@ -170,7 +174,7 @@ class TextAlignment::AnchorFinder
 		size_window ||= @size_window
 
 		# commend below with the assumption that the end of a document gives a significant locational
-		# return if (@beg_s1 + @size_ngram > (@s1.length - size_window)) || (@beg_s2 + @size_ngram > (@s2.length - size_window))
+		# return if (beg_s1 + @size_ngram > (@s1.length - size_window)) || (beg_s2 + @size_ngram > (@s2.length - size_window))
 
 		window_s1 = ''
 		loc = beg_s1 + @size_ngram
@@ -199,6 +203,44 @@ class TextAlignment::AnchorFinder
 		[window_s1, window_s2]
 	end
 
+	def get_left_windows_no_squeeze_ws(beg_s1, beg_s2, size_window = nil)
+		size_window ||= @size_window
+
+		# comment out below with the assumption that the beginning of a document gives a significant locational information
+		# return if beg_s1 < size_window || beg_s2 < size_window
+
+		wbeg = beg_s1 - size_window
+		wbeg = 0 if wbeg < 0
+		window_s1 = @s1[wbeg ... beg_s1]
+
+		wbeg = beg_s2 - size_window
+		wbeg = 0 if wbeg < 0
+		window_s2 = @s2[wbeg ... beg_s2]
+
+		[window_s1, window_s2]
+	end
+
+	def get_right_windows_no_squeeze_ws(beg_s1, beg_s2, size_window = nil)
+		size_window ||= @size_window
+
+		# commend below with the assumption that the end of a document gives a significant locational
+		# return if (@beg_s1 + @size_ngram > (@s1.length - size_window)) || (@beg_s2 + @size_ngram > (@s2.length - size_window))
+
+		slen = @s1.length
+		wbeg = beg_s1 + @size_ngram
+		wend = wbeg + size_window
+		wend = slen if wend > slen
+		window_s1 = @s1[wbeg ... wend]
+
+		slen = @s2.length
+		wbeg = beg_s2 + @size_ngram
+		wend = wbeg + size_window
+		wend = slen if wend > slen
+		window_s2 = @s2[wbeg ... wend]
+
+		[window_s1, window_s2]
+	end
+
 	def text_similarity(str1, str2, ngram_order = 2)
 		return 0 if str1.nil? || str2.nil?
 		String::Similarity.cosine(str1, str2, ngram:ngram_order)

data/lib/text_alignment/char_mapping.rb

@@ -1,3 +1,5 @@
+require 'strscan'
+
 module TextAlignment; end unless defined? TextAlignment
 
 TextAlignment::CHAR_MAPPING = [
@@ -78,10 +80,18 @@ TextAlignment::CHAR_MAPPING = [
 
 
 class TextAlignment::CharMapping
-	attr_reader :mapped_text
+	attr_reader :mapped_text, :index_enmap
+
+	def initialize(_text, char_mapping = nil, to_ignore_whitespaces = false)
+		if to_ignore_whitespaces
+			@method_get_positions_squeeze_ws = method(:get_positions_squeeze_ws_0)
+			@method_squeeze_ws = method(:squeeze_ws_0!)
+		else
+			@method_get_positions_squeeze_ws = method(:get_positions_squeeze_ws_1)
+			@method_squeeze_ws = method(:squeeze_ws_1!)
+		end
 
-	def initialize(_text, char_mapping = nil)
-		char_mapping ||= TextAlignment::CHAR_MAPPING
+		char_mapping ||= TextAlignment::CHAR_MAPPING.sort{|a, b| b[1].length <=> a[1].length}
 		@mapped_text, offset_mapping = enmap_text(_text, char_mapping)
 		@index_enmap = offset_mapping.to_h
 		@index_demap = offset_mapping.map{|m| m.reverse}.to_h
@@ -105,22 +115,22 @@ class TextAlignment::CharMapping
 
 	private
 
-	def enmap_text(_text, char_mapping)
+	def enmap_text(_text, char_mapping, no_ws = false)
 		text = _text.dup
 
-		# To execute the single letter mapping
+		# To execute the single letter mapping replacement
 		char_mapping.each do |one, long|
 			text.gsub!(one, long) if long.length == 1
 		end
 
-		# To get the (location, length) index for replacements
-		loc_len = []
+		# To get the replacement positions, (position, old_length, new_length), for char mappings
+		rpositions = []
 		char_mapping.each do |one, long|
 			next if long.length == 1
 
 			init_next = 0
 			while loc = text.index(long, init_next)
-				loc_len << [loc, long.length]
+				rpositions << [loc, long.length, 1]
 				init_next = loc + long.length
 			end
 
@@ -128,32 +138,27 @@ class TextAlignment::CharMapping
 			text.gsub!(long, one * long.length)
 		end
 
-		# To get the (location, length) index for consecutive whitespace sequences
-		init_next = 0
-		while loc = text.index(/\s{2,}/, init_next)
-			len = $~[0].length
-			loc_len << [loc, len]
-			init_next = loc + len
-		end
-
-		loc_len.sort!{|a, b| a[0] <=> b[0]}
+		# To get the replacement positions, (position, old_length, new_length), for consecutive whitespaces
+		rpositions += @method_get_positions_squeeze_ws.call(text)
+		rpositions.sort!{|a, b| a[0] <=> b[0]}
 
 		# To get the offset_mapping before and after replacement
-		offset_mapping = []
-		init_next = 0
-		j = 0
-
-		loc_len.each do |loc, len|
-			offset_mapping += (init_next .. loc).map do |i|
-				j += 1
-				[i, j - 1]
+		offset_mapping = begin
+			i, j = 0, 0
+
+			offset_mappings = rpositions.map do |loc, old_len, new_len|
+				pre_len = loc - i
+				m = (0 .. pre_len).map{|c| [i + c, j + c]}
+				i = loc + old_len
+				j += pre_len + new_len
+
+				m
 			end
-			init_next = loc + len
-		end
 
-		offset_mapping += (init_next .. text.length).map do |i|
-			j += 1
-			[i, j - 1]
+			pre_len = text.length - i
+			offset_mappings << (0 .. pre_len).map{|c| [i + c, j + c]}
+
+			offset_mappings.reduce(:+)
 		end
 
 		# To execute the long letter mapping
@@ -162,14 +167,40 @@ class TextAlignment::CharMapping
 		end
 
 		# To replace multi whitespace sequences to a space
-		text.gsub!(/\s{2,}/, ' ')
+		@method_squeeze_ws.call(text)
 
 		[text, offset_mapping]
 	end
+
+	# To get squeeze positions of whitespaces to one
+	def get_positions_squeeze_ws_1(text)
+		rpositions = []
+		text.scan(/\s{2,}/) do |s|
+			loc = $~.begin(0)
+			len = $~.end(0) - loc
+			rpositions << [loc, len, 1]
+		end
+		rpositions
+	end
+
+	# To get squeeze positions of whitespaces to zero
+	def get_positions_squeeze_ws_0(text)
+		text.enum_for(:scan, /\s+/).map{[b = $~.begin(0), $~.end(0) - b, 0]}
+	end
+
+	def squeeze_ws_1!(text)
+		text.gsub!(/\s{2,}/, ' ')
+	end
+
+	def squeeze_ws_0!(text)
+		text.gsub!(/\s+/, '')
+	end
+
 end
 
 if __FILE__ == $0
 	require 'json'
+	# require 'profile'
 
 	unless ARGV.length == 1
 		warn "#{$0} an_annotation_json_file.json" 
@@ -181,10 +212,11 @@ if __FILE__ == $0
 		denotations = annotations[:tracks].first[:denotations]
 	end
 
-	text_mapping = TextAlignment::CharMapping.new(annotations[:text])
+	text_mapping = TextAlignment::CharMapping.new(annotations[:text], nil, false)
+	# text_mapping = TextAlignment::CharMapping.new(annotations[:text], nil, true)
 	text_mapped = text_mapping.mapped_text
 	denotations_mapped = text_mapping.enmap_denotations(denotations)
 	new_annotations = {text:text_mapped, denotations:denotations_mapped}
 
-	puts new_annotations.to_json
+	# puts new_annotations.to_json
 end

data/lib/text_alignment/mixed_alignment.rb

@@ -147,13 +147,24 @@ class TextAlignment::MixedAlignment
 		# recoverbility
 		count_nws =	sdiff.count{|d| d.old_element =~ /\S/}
 		count_nws_match =	sdiff.count{|d| d.action == '=' && d.old_element =~ /\S/}
-
 		coverage = count_nws_match.to_f / count_nws
 
 		# fragmentation rate
-		count_ofrag = sdiff.count{|d| d.old_element =~ /\s/} + 1
-		count_frag = sdiff.collect{|d| (d.action == '=') && (d.old_element =~/\s/) ? ' ' : d.action}.join.scan(/=+/).count
-		rate_frag = count_ofrag.to_f / count_frag
+		frag_str = sdiff.collect do |d|
+			case d.action
+			when '='
+				'='
+			when '-'
+				''
+			when '+'
+				(d.new_element =~ /\S/) ? '+' : ''
+			else
+				''
+			end
+		end.join.sub(/^[^=]++/, '').sub(/[^=]+$/, '')
+
+		count_frag = frag_str.scan(/=+/).count
+		rate_frag = 1.0 / count_frag
 
 		similarity = coverage * rate_frag
 	end

data/lib/text_alignment/text_alignment.rb

@@ -11,14 +11,18 @@ class TextAlignment::TextAlignment
 	attr_reader :similarity
 	attr_reader :lost_annotations
 
-	# Initialize with a reference text, again which texts will be aligned
-	def initialize(reference_text, to_prevent_overlap = false)
+	# Initialize with a reference text, against which texts will be aligned
+	def initialize(reference_text, options = {})
 		raise ArgumentError, "nil text" if reference_text.nil?
 
+		options ||= {}
+		@duplicate_texts = options[:duplicate_texts] || false
+		@to_ignore_whitespaces = options[:to_ignore_whitespaces] || false
+		@to_ignore_text_order = options[:to_ignore_text_order] || false
+
 		@original_reference_text = reference_text
-		@rtext_mapping = TextAlignment::CharMapping.new(reference_text)
+		@rtext_mapping = TextAlignment::CharMapping.new(reference_text, nil, @to_ignore_whitespaces)
 		@mapped_reference_text = @rtext_mapping.mapped_text
-		@to_prevent_overlap = to_prevent_overlap
 
 		@original_text = nil
 		@blocks = nil
@@ -27,12 +31,12 @@ class TextAlignment::TextAlignment
 
 	def align(text, denotations = nil)
 		# To maintain the cultivation map
-		update_cultivation_map if @to_prevent_overlap
+		update_cultivation_map unless @duplicate_texts
 
 		# In case the input text is the same as the previous one, reuse the previous text mapping
 		unless @original_text && @original_text == text
 			@original_text = text
-			@text_mapping = TextAlignment::CharMapping.new(text)
+			@text_mapping = TextAlignment::CharMapping.new(text, nil, @to_ignore_whitespaces)
 		end
 
 		@mapped_text = @text_mapping.mapped_text
@@ -202,7 +206,7 @@ class TextAlignment::TextAlignment
 
 	def find_block_alignment(str1, str2, denotations, cultivation_map)
 		## to find block alignments
-		anchor_finder = TextAlignment::AnchorFinder.new(str1, str2, cultivation_map)
+		anchor_finder = TextAlignment::AnchorFinder.new(str1, str2, cultivation_map, @to_ignore_whitespaces, @to_ignore_text_order)
 
 		blocks = []
 		while block = anchor_finder.get_next_anchor
@@ -238,68 +242,75 @@ class TextAlignment::TextAlignment
 			b1 = lblock.nil? ? 0 : lblock[:source][:end]
 			e1 = cblock.nil? ? str1.length : cblock[:source][:begin]
 
-			if b1 < e1
+			if b1 <= e1
+				_str1 = str1[b1 ... e1]
+
 				b2 = lblock.nil? ? 0 : lblock[:target][:end]
 				e2 = cblock.nil? ? str2.length : cblock[:target][:begin]
-				_str1 = str1[b1 ... e1]
-				_str2 = str2[b2 ... e2]
 
-				sum += if _str1.strip.empty? || _str2.strip.empty?
-					[{source:{begin:b1, end:e1}, target:{begin:b2, end:e2}, alignment: :empty}]
-				else
-					len_buffer = ((e1 - b1) * (1 + TextAlignment::BUFFER_RATE)).to_i + TextAlignment::BUFFER_MIN
-					region_state, state_region = cultivation_map.region_state([b2, e2])
-					case region_state
-					when :closed
-						[{source:{begin:b1, end:e1}, alignment: :empty}]
-					when :front_open
-						if sum.empty? # when there is no preceding matched block
-							[{source:{begin:b1, end:e1}, alignment: :empty}]
-						else
-							oe2 = state_region[1]
-							me2 = (oe2 - b2) > len_buffer ? b2 + len_buffer : oe2
-							local_alignment(str1, b1, e1, str2, b2, me2, denotations, cultivation_map)
-						end
-					when :rear_open
-						if cblock.nil? # when there is no following matched block
-							[{source:{begin:b1, end:e1}, alignment: :empty}]
-						else
-							ob2 = state_region[0]
-							mb2 = (e2 - ob2) > len_buffer ? e2 - len_buffer : ob2
-							local_alignment(str1, b1, e1, str2, mb2, e2, denotations, cultivation_map)
-						end
-					when :middle_closed
-						attempt1 = if sum.empty?
+				if b2 < e2
+					_str2 = str2[b2 ... e2]
+
+					sum += if _str1.strip.empty? || _str2.strip.empty?
+						[{source:{begin:b1, end:e1}, target:{begin:b2, end:e2}, alignment: :empty}]
+					else
+						len_buffer = ((e1 - b1) * (1 + TextAlignment::BUFFER_RATE)).to_i + TextAlignment::BUFFER_MIN
+						region_state, state_region = cultivation_map.region_state([b2, e2])
+						case region_state
+						when :closed
 							[{source:{begin:b1, end:e1}, alignment: :empty}]
-						else
-							oe2 = state_region[0]
-							me2 = (oe2 - b2) > len_buffer ? b2 + len_buffer : oe2
-							local_alignment(str1, b1, e1, str2, b2, me2, denotations, cultivation_map)
-						end
-						if (attempt1.empty? || attempt1.first[:alignment] == :empty) && !cblock.nil?
-							ob2 = state_region[1]
-							mb2 = (e2 - ob2) > len_buffer ? e2 - len_buffer : ob2
-							local_alignment(str1, b1, e1, str2, mb2, e2, denotations, cultivation_map)
-						else
-							attempt1
-						end
-					else # :open
-						if (e2 - b2) > len_buffer
+						when :front_open
+							if sum.empty? # when there is no preceding matched block
+								[{source:{begin:b1, end:e1}, alignment: :empty}]
+							else
+								oe2 = state_region[1]
+								me2 = (oe2 - b2) > len_buffer ? b2 + len_buffer : oe2
+								local_alignment(str1, b1, e1, str2, b2, me2, denotations, cultivation_map)
+							end
+						when :rear_open
+							if cblock.nil? # when there is no following matched block
+								[{source:{begin:b1, end:e1}, alignment: :empty}]
+							else
+								ob2 = state_region[0]
+								mb2 = (e2 - ob2) > len_buffer ? e2 - len_buffer : ob2
+								local_alignment(str1, b1, e1, str2, mb2, e2, denotations, cultivation_map)
+							end
+						when :middle_closed
 							attempt1 = if sum.empty?
 								[{source:{begin:b1, end:e1}, alignment: :empty}]
 							else
-								local_alignment(str1, b1, e1, str2, b2, b2 + len_buffer, denotations, cultivation_map)
+								oe2 = state_region[0]
+								me2 = (oe2 - b2) > len_buffer ? b2 + len_buffer : oe2
+								local_alignment(str1, b1, e1, str2, b2, me2, denotations, cultivation_map)
 							end
 							if (attempt1.empty? || attempt1.first[:alignment] == :empty) && !cblock.nil?
-								local_alignment(str1, b1, e1, str2, e2 - len_buffer, e2, denotations, cultivation_map)
+								ob2 = state_region[1]
+								mb2 = (e2 - ob2) > len_buffer ? e2 - len_buffer : ob2
+								local_alignment(str1, b1, e1, str2, mb2, e2, denotations, cultivation_map)
 							else
 								attempt1
 							end
-						else
-							local_alignment(str1, b1, e1, str2, b2, e2, denotations, cultivation_map)
+						else # :open
+							if (e2 - b2) > len_buffer
+								attempt1 = if sum.empty?
+									[{source:{begin:b1, end:e1}, alignment: :empty}]
+								else
+									local_alignment(str1, b1, e1, str2, b2, b2 + len_buffer, denotations, cultivation_map)
+								end
+								if (attempt1.empty? || attempt1.first[:alignment] == :empty) && !cblock.nil?
+									local_alignment(str1, b1, e1, str2, e2 - len_buffer, e2, denotations, cultivation_map)
+								else
+									attempt1
+								end
+							else
+								local_alignment(str1, b1, e1, str2, b2, e2, denotations, cultivation_map)
+							end
 						end
 					end
+				elsif b2 > e2 # when out of order
+					# ToDo
 				end
+
 			end
 
 			lblock = cblock
@@ -320,7 +331,7 @@ class TextAlignment::TextAlignment
 
 	def local_alignment(str1, b1, e1, str2, b2, e2, denotations = nil, cultivation_map)
 		tblocks = term_based_alignment(str1, b1, e1, str2, b2, e2, denotations, cultivation_map)
-		if tblocks.empty?
+		if tblocks.empty? || tblocks.first[:alignment] == :empty
 			lcs_alignment(str1, b1, e1, str2, b2, e2, cultivation_map)
 		else
 			tblocks

data/lib/text_alignment/version.rb

@@ -1,3 +1,3 @@
 class TextAlignment
-	VERSION = '0.11.3'
+	VERSION = '0.11.10'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: text_alignment
 version: !ruby/object:Gem::Version
-  version: 0.11.3
+  version: 0.11.10
 platform: ruby
 authors:
 - Jin-Dong Kim
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-19 00:00:00.000000000 Z
+date: 2021-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-dictionary
@@ -111,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.0.9
 signing_key: 
 specification_version: 4
 summary: Ruby class for aligning two character strings