#!/usr/bin/env cobra
"""
le.cobra

"line endings" - Report the line endings of text files as 'dos', 'unix', 'oldmac', 'both' or '?'.

Skips binary files and reports files with unknown extensions.

Also, can convert to dos or unix line endings.

This is a console/command-line utility.

Run with -h for usage help.

Notes

 * The program looks at the extension of a file to determine if it is text or binary. While this is
   less technically accurate than examining file contents and also requires the extension lists to
   be occasionally augmented, it is very efficient--many files do not have to be opened.

Future

 * Permissions are lost when a file is modified because a new file is created and then moved in
   place of the existing after it is deleted.

"""

use System.Text.RegularExpressions


enum Action
	None
	ToUnix
	ToDos


class LineEndings

	var _excludeNamesSpec   = '.svn _svn .hg .git .bzr'
	var _binExtensionsSpec  = 'dll exe pdb mdb snk ' + _
								'pyc pyo ' + _
								'gif ico jpg jpeg png tif tiff ' + _
								'doc docx ppt pptx xls xlsx ' + _
								'gz tar tgz zip ' + _
								'pdf ' + _
								'ds_store'
	var _textExtensionsSpec = _
		'bash bat c cmd cobra cobratext cobraproj config cpp cs css cxx ' + _
		'dif diff h htaccess htm html java js kv m ' + _
		'patch py rb sh shtml sln sql svg targets text txt xhtml xaml xml'

	var _excludeNamesCache   = List<of String>()
	var _binExtensionsCache  = List<of String>()
	var _textExtensionsCache = List<of String>()

	var _action as Action

	var _crLfRegEx = Regex(r'\r\n')  # dos / windows
	var _notCrLfRegEx = Regex(r'[^\r]\n')  # unix / mac / linux / etc
	var _crRegEx = Regex(r'\r')  # old mac

	var _exts = Set<of String>()

	get excludeNames as IList<of String>
		if not _excludeNamesCache.count, _excludeNamesCache = _excludeNamesSpec.split.toList
		return _excludeNamesCache

	get binExtensions as IList<of String>
		if not _binExtensionsCache.count, _binExtensionsCache = _binExtensionsSpec.split.toList
		return _binExtensionsCache

	get textExtensions as IList<of String>
		if not _textExtensionsCache.count, _textExtensionsCache = _textExtensionsSpec.split.toList
		return _textExtensionsCache

	def main is shared
		LineEndings().run(CobraCore.commandLineArgs)

	def printHelp
		print 'le <option> \[<paths>]'
		print
		print '  -r or -report : information is printed and no actions are taken'
		print '  -to-unix      : files that are detected with DOS endings are rewritten'
		print '  -to-dos       : files that are detected with UNIX endings are rewritten'
		print
		print 'You can specify one or more files or directories after the option.'
		print 'Or if you specify none, then the currect directory is processed.'
		print 'Directories are always processed recursively.'
		print
		print 'The program source contains names to ignore (.svn/_svn) and '
		print 'extension types (text vs. binary).'
		print

	def reset
		_action = Action.None
		_exts.clear
		_excludeNamesCache.clear
		_binExtensionsCache.clear
		_textExtensionsCache.clear

	def run(args as List<of String>)
		require args.count > 0  # first arg is program name/path
		print 'Line Endings'
		print
		.reset
		if args.count == 1
			.printHelp
			return
		arg = args[1]
		branch arg
			on '-h' or '-help' or '--help'
				.printHelp
				return
			on '-r' or '-report'
				_action = Action.None
			on '-to-unix'
				_action = Action.ToUnix
			on '-to-dos'
				_action = Action.ToDos
			else
				print 'Unknown option. Try -h'
				return
		assert args.count >= 2
		if args.count == 2, args.add('.')  # current directory

		# CC:
		# paths, badPaths = for arg in args[2:] splitby Directory.exists(arg) or File.exists(arg)
		# kind of like:
		# paths = for arg in args[2:] where Directory.exists(arg) or File.exists(arg)

		paths = List<of String>()
		for arg in args[2:]
			if File.exists(arg)
				paths.add(arg)
			else if Directory.exists(arg)
				paths.add(arg)
			else
				print 'Unknown path:', arg
				return

		if true
			print 'Action: ' stop
			branch _action
				on Action.None,   print 'Report'
				on Action.ToUnix, print 'Convert line endings to Unix'
				on Action.ToDos,  print 'Convert line endings to DOS/Windows'
			print

		.scanPaths(paths)
		.summarizeExtensions

	def scanPaths(paths as IList<of String>)
		for path in paths
			# print 'scanning:', path
			if Directory.exists(path), .scanDir(path)
			else if File.exists(path), .scanFile(path)
			else, print 'warning: cannot find:', path
	
	def scanDir(path as String)
		assert not path.endsWith('.svn')
		dirInfo = DirectoryInfo(path)
		for fi in dirInfo.getFiles
			.scanFile(fi)
		for di in dirInfo.getDirectories
			if di.name in .excludeNames, continue
			.scanDir(di.fullName)
			
	def scanFile(path as String)
		.scanFile(FileInfo(path))

	def scanFile(fi as FileInfo)
		if fi.name in .excludeNames, return
		ext = (fi.extension ? '').toLower
		if ext.startsWith('.'), ext = ext[1:]
		_exts.add(ext)
		if ext in .binExtensions
			print 'skipping bin file        : [fi]'
		else if ext in .textExtensions or ext == ''
			# In practice, I find that files without extensions are text files.
			# Usually captured text output from a command or a shell script.
			type = .lineEndingsType(fi)
			pad = if(type=='dos', '   ', if(type=='unix', '  ', ''))  # 'oldmac' is longest
			print 'found text file ([type]) [pad]: [fi]'
			.act(type, fi)
		else
			print 'unknown file type        : "[ext]" for [fi]'

	def lineEndingsType(fi as FileInfo) as String
		ensure result in ['unix', 'dos', 'both', 'oldmac', '?']
		try
			text = File.readAllText(fi.fullName)
		catch IOException
			return '?'
		match = _crLfRegEx.match(text)
		if match.success
			matchText = match.groups[0].value
			assert matchText == '\r\n'
			# print 'DOS ([CobraCore.toTechString(matchText)])'
			isDos = true
		else
			isDos = false
		match = _notCrLfRegEx.match(text)
		if match.success
			matchText = match.groups[0].value
			assert matchText.length == 2
			assert matchText[0] <> '\r'
			assert matchText[1] == '\n'
			# print 'Unix ([CobraCore.toTechString(matchText)])'
			isUnix = true
		else
			isUnix = false
		if isDos and isUnix, return 'both'
		if isDos, return 'dos'
		if isUnix, return 'unix'
		match = _crRegEx.match(text)
		if match.success
			matchText = match.groups[0].value
			assert matchText == '\r'
			# print 'OldMac ([CobraCore.toTechString(matchText)])'
			return 'oldmac'
		return '?'

	def act(type as String, fi as FileInfo)
		text as String?
		branch _action
			on Action.None
				pass
			on Action.ToUnix
				if type not in ['unix', '?']
					text = File.readAllText(fi.fullName)
					if type == 'oldmac', text = text.replace('\r', '\n')
					else, text = text.replace('\r', '')
			on Action.ToDos
				if type not in ['dos', '?']
					text = File.readAllText(fi.fullName)
					if type == 'oldmac', text = text.replace('\r', '\r\n')
					else, text = text.replace('\r', '').replace('\n', '\r\n')
		if text
			suffix = '-convert-line-endings-' + DateTime.now.toString('yyyy-MM-dd')
			assert ' ' not in suffix
			newName = fi.fullName + suffix
			if true
				# to-do: this approach kills permissions such as on executable scripts in unix
				File.writeAllText(newName, text)
				File.delete(fi.fullName)
				File.move(newName, fi.fullName)
				print '                           Converted'

	def summarizeExtensions
		exts = _exts.toList.sorted
		print 'Extensions found: ' stop
		for ext in exts, print '[ext] ' stop
		print