" Text formatter plugin for Vim text editor
"
" Version:              2.1
" Last Change:          2008-09-13
" Maintainer:           Teemu Likonen <tlikonen@iki.fi>
" License:              This file is placed in the public domain.
" GetLatestVimScripts:  2324 1 :AutoInstall: TextFormat

"{{{1 The beginning stuff
if &compatible
	finish
endif
let s:save_cpo = &cpo
set cpo&vim

" Constant variables(s) {{{1
let s:default_width = 80

function! s:Align_Range_Left(...) range "{{{1
	" The optional parameter is the left indent. If it is not given we
	" detect the indent used in the buffer.
	if a:0 && a:1 >= 0
		" The parameter was given so we just use that as the left
		" indent.
		let l:leading_ws = s:Retab_Indent(a:1)
		for l:line in range(a:firstline,a:lastline)
			let l:line_string = getline(l:line)
			let l:line_replace = s:Align_String_Left(l:line_string)
			if &formatoptions =~ 'w' && l:line_string =~ '\m\s$'
				" Preserve trailing whitespace because fo=~w
				let l:line_replace .= ' '
			endif
			if l:line_replace =~ '\m^\s*$'
				call setline(l:line,'')
			else
				call setline(l:line,l:leading_ws.l:line_replace)
			endif
		endfor
	else
		" The parameter was not given so we detect each paragraph's
		" indent.
		let l:line = a:firstline
		while l:line <= a:lastline
			let l:line_string = getline(l:line)
			if l:line_string =~ '\m^\s*$'
				" The line is empty or contains only
				" whitespaces so print empty line and
				" continue.
				call setline(l:line,'')
				let l:line += 1
				continue
			endif

			" Paragraph (or the whole line range) begins here so
			" get the indent of the first line and print the line.
			let l:leading_ws = s:Retab_Indent(indent(l:line))
			let l:line_replace = s:Align_String_Left(l:line_string)
			if &formatoptions =~ 'w' && l:line_string =~ '\m\s$'
				let l:line_replace .= ' '
			endif
			call setline(l:line,l:leading_ws.l:line_replace)
			let l:line += 1

			" If fo=~w, does the paragraph end here? If yes,
			" continue to next round and find a new first line.
			if &formatoptions =~ 'w' && l:line_string =~ '\m\S$'
				continue
			endif

			" If fo=~2 get the indent of the second line
			if &formatoptions =~ '2'
				let l:leading_ws = s:Retab_Indent(indent(l:line))
			endif

			" This loop will go through all the lines in the
			" paragraph (or till the a:lastline) - starting from
			" the second line.
			while l:line <= a:lastline && getline(l:line) !~ '\m^\s*$'
				let l:line_string = getline(l:line)
				let l:line_replace = s:Align_String_Left(l:line_string)
				if &formatoptions =~ 'w'
					if l:line_string =~ '\m\s$'
						call setline(l:line,l:leading_ws.l:line_replace.' ')
						let l:line += 1
						continue
					else
						call setline(l:line,l:leading_ws.l:line_replace)
						let l:line += 1
						" fo=~w and paragraph ends
						" here so we break the loop.
						" The next line is new first
						" line.
						break
					endif
				else
					call setline(l:line,l:leading_ws.l:line_replace)
					let l:line += 1
				endif
			endwhile
		endwhile
	endif
endfunction

function! s:Align_Range_Right(width) "{{{1
	let l:line_replace = s:Align_String_Right(getline('.'),a:width)
	if &formatoptions =~ 'w' && getline('.') =~ '\m\s$'
		let l:line_replace .= ' '
	endif
	if l:line_replace =~ '\m^\s*$'
		" If line would be full of spaces just print empty line.
		call setline(line('.'),'')
	else
		" Retab leading whitespaces
		let l:leading_ws = s:Retab_Indent(strlen(substitute(l:line_replace,'\v^( *).*$','\1','')))
		" Get the rest of the line
		let l:line_replace = substitute(l:line_replace,'^ *','','')
		call setline(line('.'),l:leading_ws.l:line_replace)
	endif
endfunction

function! s:Align_Range_Justify(width, ...) range "{{{1
	" If the optional second argument is given (and is non-zero) each
	" paragraph's last line and range's last line is left-aligned.
	if a:0 && a:1
		let l:paragraph = 1
	else
		let l:paragraph = 0
	endif
	let l:line = a:firstline
	while l:line <= a:lastline
		let l:line_string = getline(l:line)
		if l:line_string =~ '\m^\s*$'
			" The line is empty or contains only
			" whitespaces so print empty line and
			" continue.
			call setline(l:line,'')
			let l:line += 1
			continue
		endif

		" Paragraph (or the whole line range) begins here so
		" get the indent of the first line and print the line.
		let l:indent = indent(l:line)
		let l:width = a:width - l:indent
		let l:leading_ws = s:Retab_Indent(l:indent)

		if l:paragraph && (l:line == a:lastline || getline(l:line+1) =~ '\m^\s*$' || (&formatoptions =~ 'w' && l:line_string =~ '\m\S$'))
			let l:line_replace = s:Align_String_Left(l:line_string)
		else
			let l:line_replace = s:Align_String_Justify(l:line_string,l:width)
		endif
		if &formatoptions =~ 'w' && l:line_string =~ '\m\s$'
			let l:line_replace .= ' '
		endif
		call setline(l:line,l:leading_ws.l:line_replace)
		let l:line += 1

		" If fo=~w, does the paragraph end here? If yes,
		" continue to next round and find a new first line.
		if &formatoptions =~ 'w' && l:line_string =~ '\m\S$'
			continue
		endif

		" If fo=~2 get the indent of the second line
		if &formatoptions =~ '2'
			let l:indent = indent(l:line)
			let l:width = a:width - l:indent
			let l:leading_ws = s:Retab_Indent(l:indent)
		endif

		" This loop will go through all the lines in the
		" paragraph (or till the a:lastline) - starting from
		" paragraph's second line.
		while l:line <= a:lastline && getline(l:line) !~ '\m^\s*$'
			let l:line_string = getline(l:line)
			if l:paragraph && (l:line == a:lastline || getline(l:line+1) =~ '\m^\s*$' || (&formatoptions =~ 'w' && l:line_string =~ '\m\S$'))
				let l:line_replace = s:Align_String_Left(l:line_string)
			else
				let l:line_replace = s:Align_String_Justify(l:line_string,l:width)
			endif
			if &formatoptions =~ 'w'
				if l:line_string =~ '\m\s$'
					call setline(l:line,l:leading_ws.l:line_replace.' ')
					let l:line += 1
					continue
				else
					call setline(l:line,l:leading_ws.l:line_replace)
					let l:line += 1
					" fo=~w and paragraph ends
					" here so we break the loop.
					" The next line is new first
					" line.
					break
				endif
			else
				call setline(l:line,l:leading_ws.l:line_replace)
				let l:line += 1
			endif
		endwhile
	endwhile
endfunction

function! s:Align_Range_Center(width) "{{{1
	let l:line_replace = s:Truncate_Spaces(getline('.'))
	let l:line_replace = s:Add_Double_Spacing(l:line_replace)
	if &formatoptions =~ 'w' && getline('.') =~ '\m\s$'
		let l:line_replace .= ' '
	endif
	call setline(line('.'),l:line_replace)
	execute '.center '.a:width
endfunction

function! s:Align_String_Left(string) "{{{1
	let l:string_replace = s:Truncate_Spaces(a:string)
	let l:string_replace = s:Add_Double_Spacing(l:string_replace)
	return l:string_replace
endfunction

function! s:Align_String_Right(string, width) "{{{1
	let l:string_replace = s:Truncate_Spaces(a:string)
	let l:string_replace = s:Add_Double_Spacing(l:string_replace)
	let l:string_width = s:String_Width(l:string_replace)
	let l:more_spaces = a:width-l:string_width
	return repeat(' ',l:more_spaces).l:string_replace
endfunction

function! s:Align_String_Justify(string, width) "{{{1
	let l:string = s:Truncate_Spaces(a:string)
	" If the parameter string is empty we can just return a line full of
	" spaces. No need to go further.
	if l:string =~ '\m^ *$'
		return repeat(' ',a:width)
	endif
	if s:String_Width(s:Add_Double_Spacing(l:string)) >= a:width
		" The original string is longer than width so we can just
		" return the string. No need to go further.
		return s:Add_Double_Spacing(l:string)
	endif
	let l:string_width = s:String_Width(l:string)

	" This many extra spaces we need.
	let l:more_spaces = a:width-l:string_width
	" Convert the string to a list of words.
	let l:word_list = split(l:string)
	" This is the amount of spaces available in the original string (word
	" count minus one).
	let l:string_spaces = len(l:word_list)-1
	" If there are no spaces there is only one word. We can just return
	" the string with padded spaces. No need to go further.
	if l:string_spaces == 0
		return l:string.repeat(' ',l:more_spaces)
	endif
	" Ok, there are more than one word in the string so we get to do some
	" real work...

	" Make a list of which each item represent a space available in the
	" string. The value means how many spaces there are. At the moment set
	" every list item to one: [1, 1, 1, 1, ...]
	let l:space_list = []
	for l:item in range(l:string_spaces)
		let l:space_list += [1]
	endfor

	" Repeat while there are no more need to add any spaces.
	while l:more_spaces > 0
		if l:more_spaces >= l:string_spaces
			" More extra spaces are needed than there are spaces
			" available in the string so we add one more space 
			" after every word (add 1 to items of space list).
			for l:i in range(l:string_spaces)
				let l:space_list[l:i] += 1
			endfor
			let l:more_spaces -= l:string_spaces
			" And then another round... and a check if more spaces
			" are needed.
		else " l:more_spaces < l:string_spaces
			" This list tells where .?! characters are.
			let l:space_sentence_full = []
			" This list tells where ,:; characters are.
			let l:space_sentence_semi = []
			" And this is for the rest of spaces.
			let l:space_other = []
			" Now, find those things:
			for l:i in range(l:string_spaces)
				if l:word_list[l:i] =~ '\m\S[.?!]$'
					let l:space_sentence_full += [l:i]
				elseif l:word_list[l:i] =~ '\m\S[,:;]$'
					let l:space_sentence_semi += [l:i]
				else
					let l:space_other += [l:i]
				endif
			endfor

			" First distribute spaces after .?!
			if l:more_spaces >= len(l:space_sentence_full)
				" If we need more extra spaces than there are
				" .?! spaces, just add one after every item.
				for l:i in l:space_sentence_full
					let l:space_list[l:i] += 1
				endfor
				let l:more_spaces -= len(l:space_sentence_full)
				if l:more_spaces == 0 | break | endif
			else
				" Distribute the rest of spaces evenly and
				" break the loop. All the spaces have been
				" added.
				for l:i in s:Distributed_Selection(l:space_sentence_full,l:more_spaces)
					let l:space_list[l:i] +=1
				endfor
				break
			endif

			" Then distribute spaces after ,:;
			if l:more_spaces >= len(l:space_sentence_semi)
				" If we need more extra spaces than there are
				" ,:; spaces available, just add one after
				" every item.
				for l:i in l:space_sentence_semi
					let l:space_list[l:i] += 1
				endfor
				let l:more_spaces -= len(l:space_sentence_semi)
				if l:more_spaces == 0 | break | endif
			else
				" Distribute the rest of spaces evenly and
				" break the loop. All the spaces have been
				" added.
				for l:i in s:Distributed_Selection(l:space_sentence_semi,l:more_spaces)
					let l:space_list[l:i] +=1
				endfor
				break
			endif

			" Finally distribute spaces to other available
			" positions and exit the loop.
			for l:i in s:Distributed_Selection(l:space_other,l:more_spaces)
				let l:space_list[l:i] +=1
			endfor
			break
		endif
	endwhile

	" Now we now where all the extra spaces will go. We have to construct
	" the string again.
	let l:string = ''
	for l:item in range(l:string_spaces)
		let l:string .= l:word_list[l:item].repeat(' ',l:space_list[l:item])
	endfor
	" Add the last word to the end and return the string.
	return l:string.l:word_list[-1]
endfunction

function! s:Truncate_Spaces(string) "{{{1
	let l:string = substitute(a:string,'\v\s+',' ','g')
	let l:string = substitute(l:string,'\m^\s*','','')
	let l:string = substitute(l:string,'\m\s*$','','')
	return l:string
endfunction

function! s:String_Width(string) "{{{1
	" This counts the string width in characters. Combining diacritical
	" marks do not count so the base character with all the combined
	" diacritics is just one character (which is good for our purposes).
	" Double-wide characters will not get double width so unfortunately
	" they don't work in our algorithm.
	return strlen(substitute(a:string,'\m.','x','g'))
endfunction

function! s:Add_Double_Spacing(string) "{{{1
	if &joinspaces
		return substitute(a:string,'\m\S[.?!] ','& ','g')
	else
		return a:string
	endif
endfunction

function! s:Distributed_Selection(list, pick) "{{{1
	" 'list' is a list-type variable [ item1, item2, ... ]
	" 'pick' is a number how many of the list's items we want to choose
	"
	" This function returns a list which has 'pick' number of items from
	" the original list. Items are chosen in distributed manner. For
	" example, if 'pick' is 1 then the algorithm chooses an item near the
	" center of the 'list'. If 'pick' is 2 then the first one is about 1/3
	" from the beginning and the another one about 2/3 from the beginning.

	" l:pick_list is a list of 0's and 1's and its length will be the
	" same as original list's. Number 1 means that this list item will be
	" picked and 0 means that the item will be dropped. Finally
	" l:pick_list could look like this: [0, 1, 0, 1, 0]
	" (i.e., two items evenly picked from a list of five items)
	let l:pick_list = []

	" First pick items evenly from the beginning of the list. This also
	" actually constructs the list.
	let l:div1 = len(a:list) / a:pick
	let l:mod1 = len(a:list) % a:pick
	for l:i in range(len(a:list)-l:mod1)
		if !eval(l:i%l:div1)
			let l:pick_list += [1]
		else
			let l:pick_list += [0]
		endif
	endfor

	if l:mod1 > 0
		" The division wasn't even so we get the remaining items and
		" distribute them evenly again to the list.
		let l:div2 = len(l:pick_list) / l:mod1
		let l:mod2 = len(l:pick_list) % l:mod1
		for l:i in range(len(l:pick_list)-l:mod2)
			if !eval(l:i%l:div2)
				call insert(l:pick_list,0,l:i)
			endif
		endfor
	endif

	" There may be very different number of zeros in the beginning and the
	" end of the list. We count them.
	let l:zeros_begin = 0
	for l:i in l:pick_list
		if l:i == 0
			let l:zeros_begin += 1
		else
			break
		endif
	endfor
	let l:zeros_end = 0
	for l:i in reverse(copy(l:pick_list))
		if l:i == 0
			let l:zeros_end += 1
		else
			break
		endif
	endfor

	" Then we remove them.
	if l:zeros_end
		" Remove "0" items from the end. We need to remove them first
		" from the end because list items' index number will change
		" when items are removed from the beginning. Then it would be
		" more difficult to remove trailing zeros.
		call remove(l:pick_list,len(l:pick_list)-l:zeros_end,-1)
	endif
	if l:zeros_begin
		" Remove zero items from the beginning.
		call remove(l:pick_list,0,l:zeros_begin-1)
	endif
	let l:zeros_both = l:zeros_begin + l:zeros_end

	" Put even amount of zeros to beginning and end
	for l:i in range(l:zeros_both/2)
		call insert(l:pick_list,0,0)
	endfor
	for l:i in range((l:zeros_both/2)+(l:zeros_both%2))
		call add(l:pick_list,0)
	endfor

	" Finally construct and return a new list which has only the items we
	" have chosen.
	let l:new_list = []
	for l:i in range(len(l:pick_list))
		if l:pick_list[l:i] == 1
			let l:new_list += [a:list[l:i]]
		endif
	endfor
	return l:new_list
endfunction

function! s:Retab_Indent(column) "{{{1
	" column = the left indent column starting from 0 Function returns
	" a string of whitespaces, a mixture of tabs and spaces depending on
	" the 'expandtab' and 'tabstop' options.
	if &expandtab
		" Only spaces
		return repeat(' ',a:column)
	else
		" Tabs and spaces
		let l:tabs = a:column / &tabstop
		let l:spaces = a:column % &tabstop
		return repeat("\<Tab>",l:tabs).repeat(' ',l:spaces)
	endif
endfunction

function! s:Reformat_Range(...) range "{{{1
	if a:0 == 2
		let l:first = a:1
		let l:last = a:2
	else
		let l:first = a:firstline
		let l:last = a:lastline
	endif
	let l:autoindent = &autoindent
	setlocal autoindent
	execute l:first
	normal! 0
	execute 'normal! V'.l:last.'G$gw'
	let &l:autoindent = l:autoindent
	" The formatting may change the last line of the range so we return
	" it.
	return line("'>")
endfunction

function! textformat#Visual_Align_Left() range "{{{1
	execute a:firstline.','.a:lastline.'call s:Align_Range_Left()'
	call s:Reformat_Range(a:firstline,a:lastline)
endfunction

function! textformat#Visual_Align_Right() range "{{{1
	let l:width = &textwidth
	if l:width == 0 | let l:width = s:default_width | endif

	execute a:firstline.','.a:lastline.'call s:Align_Range_Right('.l:width.')'
	normal! '>$
endfunction

function! textformat#Visual_Align_Justify() range "{{{1
	let l:width = &textwidth
	if l:width == 0 | let l:width = s:default_width | endif

	execute a:firstline.','.a:lastline.'call s:Align_Range_Left()'

	let l:last = s:Reformat_Range(a:firstline,a:lastline)
	let l:pos = getpos('.')
	execute a:firstline.','.l:last.'call s:Align_Range_Justify('.l:width.',1)'
	call setpos('.',l:pos)
endfunction

function! textformat#Visual_Align_Center() range "{{{1
	let l:width = &textwidth
	if l:width == 0 | let l:width = s:default_width | endif

	execute a:firstline.','.a:lastline.'call s:Align_Range_Center('.l:width.')'
	normal! '>$
endfunction

function! textformat#Quick_Align_Left() "{{{1
	let l:autoindent = &autoindent
	setlocal autoindent
	let l:pos = getpos('.')
	silent normal! vip:call s:Align_Range_Left()
	call setpos('.',l:pos)
	silent normal! gwip
	let &l:autoindent = l:autoindent
endfunction

function! textformat#Quick_Align_Right() "{{{1
	let l:width = &textwidth
	if l:width == 0 | let l:width = s:default_width | endif
	let l:pos = getpos('.')
	silent normal! vip:call s:Align_Range_Right(l:width)
	call setpos('.',l:pos)
endfunction

function! textformat#Quick_Align_Justify() "{{{1
	let l:width = &textwidth
	if l:width == 0 | let l:width = s:default_width  | endif
	let l:autoindent = &autoindent
	setlocal autoindent
	let l:pos = getpos('.')
	silent normal! vip:call s:Align_Range_Left()
	call setpos('.',l:pos)
	silent normal! gwip
	let l:pos = getpos('.')
	silent normal! vip:call s:Align_Range_Justify(l:width,1)
	call setpos('.',l:pos)
	let &l:autoindent = l:autoindent
endfunction

function! textformat#Quick_Align_Center() "{{{1
	let l:width = &textwidth
	if l:width == 0 | let l:width = s:default_width  | endif
	let l:pos = getpos('.')
	silent normal! vip:call s:Align_Range_Center(l:width)
	call setpos('.',l:pos)
endfunction

function! textformat#Align_Command(align, ...) range "{{{1
	" For left align the optional parameter a:1 is [indent]. For others
	" it's [width].
	let l:pos = getpos('.')
	if a:align ==? 'left'
		if a:0 && a:1 >= 0
			execute a:firstline.','.a:lastline.'call s:Align_Range_Left('.a:1.')'
		else
			execute a:firstline.','.a:lastline.'call s:Align_Range_Left()'
		endif
	else
		if a:0 && a:1 > 0
			let l:width = a:1
		elseif &textwidth
			let l:width = &textwidth
		else
			let l:width = s:default_width
		endif

		if a:align ==? 'right'
			execute a:firstline.','.a:lastline.'call s:Align_Range_Right('.l:width.')'
		elseif a:align ==? 'justify'
			execute a:firstline.','.a:lastline.'call s:Align_Range_Justify('.l:width.')'
		elseif a:align ==? 'center'
			execute a:firstline.','.a:lastline.'call s:Align_Range_Center('.l:width.')'
		endif
	endif
	call setpos('.',l:pos)
endfunction

"{{{1 The ending stuff
let &cpo = s:save_cpo

" vim600: fdm=marker