<!--- 
	unfortunately due to inconsistent behavior from 
	getCurrentTemplatePath() and a total lack of alternatives 
	in ColdFusion, this library can't be placed in any CFCs 
--->
<cfscript>
	request.fs = structNew(); 
	
	function compress(directory) { 
		var domain = "C"; 
		var filter = request.tap.contentfilter; 
		var templatepath = directory & "/~ontap.cfm"; 
		
		// overwrite defaults for optional arguments -- avoid request.tapi.arg for performance 
		switch (arraylen(arguments)) { 
			case "4": { templatepath = arguments[4]; } 
			case "3": { filter = arguments[3]; } 
			case "2": { domain = arguments[2]; } 
		} 
		
		directory = request.fs.getPath(directory,domain); 
		templatepath = request.fs.getPath(templatepath,domain); 

		return server.tap.fileMan.compress(directory,filter,templatepath); 
	} 
	
	request.fs.compress = compress; 
	
	function deltree(directory) { 
		var format = server.tap.fileman.getFormat("text"); 
		var domain = request.tapi.arg(arguments,2,request.fs.getPath("","C")); 
		var path = request.fs.getPath(directory,domain); 
		var exists = directoryexists(path); 
		if (exists) { format.deltree(path); } 
		return exists; 
	} 
	
	request.fs.deltree = deltree; 
	
	function dir() { 
		var myfile = request.tapi.getObject("file").init(
			file = request.tapi.arg(arguments,1,""),
			domain = request.tapi.arg(arguments,2, request.fs.getPath("","C"))); 
		return myfile.dir(argumentcollection=request.tapi.arrayToStruct(arguments,"filter,sort,recurse",3)); 
	} 
	
	request.fs.dir = dir; 
	
	function fileAppend(output,file) { 
		var attr = request.tapi.arrayToStruct(arguments,"output,file,domain,addnewline,method"); 
		var format = server.tap.fileman.getFormat(request.tapi.arg(attr,"method","text")); 
		structDelete(attr,"domain"); structDelete(attr,"method"); attr.addnewline = true; 
		attr.file = request.fs.getPath(attr.file,request.tapi.arg(arguments,3,"C")); 
		return format.write(argumentcollection=attr); 
	} 
	
	request.fs.fileAppend = fileAppend; 
	
	function tap_fileCopy(file,destination) { 
		var domain = request.tapi.arg(arguments,3,request.fs.getPath("","C")); 
		var todomain = request.tapi.arg(arguments,4,domain); 
		request.tapi.getObject("file").init(file,domain).copy(destination,todomain); 
		return true; 
	} 
	
	request.fs.fileCopy = tap_fileCopy; 
	
	function tap_fileDelete(file) { 
		var format = server.tap.fileman.getFormat("text"); 
		var domain = request.tapi.arg(arguments,2,request.fs.getPath("","C")); 
		var path = request.fs.getPath(file,domain); 
		var exists = fileexists(path); 
		if (exists) { format.delete(path); } 
		return exists; 
	} 
	
	request.fs.fileDelete = tap_fileDelete; 
	
	function fileDownload(file) { 
		var attr = request.tapi.arrayToStruct(arguments,"file,domain,deletefile,filename"); 
		var format = server.tap.fileman.getFormat("text"); 
		structDelete(attr,"domain"); 
		attr.file = request.fs.getPath(file,request.tapi.arg(arguments,2,"C")); 
		return format.download(argumentcollection=attr); 
	} 
	
	request.fs.fileDownload = fileDownload; 
	
	function filemap() { 
		var directory = request.tapi.arg(arguments,1,""); 
		var domain = request.tapi.arg(arguments,2,"C"); 
		return request.tapi.getObject("file").init(directory,domain).map(); 
	} 
	
	request.fs.fileMap = fileMap; 
	
	function tap_fileMove(file,destination) { 
		var domain = request.tapi.arg(arguments,3,request.fs.getPath("","C")); 
		var todomain = request.tapi.arg(arguments,4,domain); 
		request.tapi.getObject("file").init(file,domain).move(destination,todomain); 
		return true; 
	} 
	
	request.fs.fileMove = tap_fileMove; 
	
	function tap_fileRead(filepath) { 
		var attr = request.tapi.arrayToStruct(arguments,"file,domain,method,refresh,cache,casesensitive"); 
		var domain = request.tapi.arg(attr,"domain","C"); 
		var format = server.tap.fileman.getFormat(request.tapi.arg(attr,"method","text")); 
		structDelete(attr,"domain"); 
		attr.file = request.fs.getPath(attr.file,domain); 
		return format.read(argumentcollection=attr); 
	} 
	
	request.fs.fileRead = tap_fileRead; 
	
	function fileRename(filepath,destination) { 
		var attr = structnew(); 
		var format = server.tap.fileman.getFormat("text"); 
		attr.destination = destination; 
		attr.file = request.fs.getPath(filepath,request.tapi.arg(arguments,3,"C")); 
		return format.rename(argumentcollection=attr); 
	} 
	
	request.fs.fileRename = fileRename; 
	
	function fileUpload(filefield,file) {
		var attr = request.tapi.arrayToStruct(arguments,"filefield,file,domain,nameconflict,accept,attributes,mode"); 
		var domain = request.tapi.arg(attr,"domain","C"); 
		var format = server.tap.fileman.getFormat("text"); 
		structDelete(attr,"domain"); 
		attr.file = request.fs.getPath(arguments.file,arguments.domain); 
		return format.upload(argumentcollection=attr); 
	}
	
	request.fs.fileUpload = fileUpload; 
	
	function tap_fileWrite(output,filepath) { 
		var attr = request.tapi.arrayToStruct(arguments,"output,file,domain,method,overwrite,attributes,mode,charset"); 
		var domain = request.tapi.arg(attr,"domain","C"); 
		var format = server.tap.fileman.getFormat(request.tapi.arg(attr,"method","text")); 
		attr.file = request.fs.getPath(filepath,domain); 
		structDelete(attr,"domain"); 
		return format.write(argumentcollection=attr); 
	} 
	
	request.fs.fileWrite = tap_fileWrite; 
	
	function getPath() { 
		var set = structNew(); 
		set.domain = "C"; 
		set.path = ""; 
		
		switch(arrayLen(arguments)) { 
			case 4: { arguments.controlCase = arguments[4]; } 
			case 3: { arguments.hackproof = arguments[3]; } 
			case 2: { 
				arguments.domain = trim(arguments[2]); 
				arguments.path = trim(arguments[1]); 
				break; 
			} 
			case 1: { arguments.path = trim(arguments[1]); } 
			default: { structAppend(arguments,set,false); } 
		} 
		// getCurrentTemplatePath() returns the function template when the cffunction tag is used 
		// using cfscript to declare this function is the only way to properly implement this default 
		if (arguments.domain is "C") { arguments.domain = getdirectoryfrompath(getcurrenttemplatepath()); } 
		return request.tap.getPath().getPath(argumentcollection=arguments); 
	} 
		
	request.fs.getPath = getPath; 
	
	function getPathTo(topath) { 
		var hackproof = true; 
		var frompath = getcurrenttemplatepath(); 
		switch (arraylen(arguments)) { 
			case "4": { frompath = arguments[4]; } 
			case "3": { hackproof = arguments[3]; } 
			case "2": { topath = request.fs.getPath(topath,arguments[2],hackproof); } 
		} 
		return server.tap.fileMan.getPathTo(topath,frompath); 
	} 
	
	request.fs.getPathTo = getPathTo; 
	
	function jarLoad(classname,jarfile) { 
		var URLObject = 0; var URLArray = 0; 
		var arrayClass = 0; var loader = 0; 
		
		jarFile = replace(request.fs.getPath(jarfile,request.tapi.arg(arguments,3,"C")),"\","/","all"); 
		
		URLObject = createObject("java","java.net.URL"); 
		URLObject.init("file:" & jarFile); 
		URLArray = createObject("java","java.lang.reflect.Array").newInstance(URLObject.getClass(),1); 
		arrayClass = createObject("java","java.lang.reflect.Array"); 
		arrayClass.set(URLArray,0,URLObject); 
		loader = createObject("java","java.net.URLClassLoader").init(URLArray); 
		
		return loader.loadClass(classname).newInstance(); 
	} 
	
	request.fs.jarLoad = jarLoad;
	
	function mkdir(path) { 
		var domain = request.tapi.arg(arguments,2,request.fs.getPath("","C")); 
		server.tap.fileman.mkDir(request.fs.getPath(path,domain)); 
		return true; 
	} 
	
	request.fs.mkdir = mkdir; 
	
	function processTemplates(process,stage) { 
		var reverseorder = request.tapi.arg(arguments,3,false); 
		var refresh = request.tapi.arg(arguments,4,request.tap.development); 
		var filter = request.tapi.arg(arguments,5,request.tap.contentfilter); 
		var compress = request.tapi.arg(arguments,6,request.tap.compress); 
		var modlist = ""; var i = 0; var loc = 0; var temp = ""; 
		var lang = arraynew(1); var lx = 0; var myprocess = ""; 
		var modArray = listtoarray("/_process.cfm,.cfm"); 
		var locArray = listtoarray("P"); var aTemplates = arraynew(1); 
		var templateArray = arraynew(1); var stack = arraynew(1); 
		var addpaths = yesnoformat(request.tap.development 
			and stage is not "exists" and request.tap.getPage().layout is not "debug"); 
		var tmpProcess = process; 
		
		process = request.tap.getProcess().getArray(process); 
		if (not len(trim(stage))) { stage = "content"; } 
		
		if (request.tap.brand) { arrayappend(locArray,"B"); } 
		
		if (listfindnocase("content,exists",stage)) { 
			for (i = 1; i lte arraylen(modArray); i = i + 1) { 
				tmpProcess = process; 
				while (arraylen(tmpProcess)) { 
					myprocess = tmpProcess[arraylen(tmpProcess)]; 
					
					// check for single-template process templates 
					for (loc = 1; loc lte arraylen(locarray); loc = loc + 1) { 
						temp = request.fs.getPath(myprocess & modarray[i],locArray[loc],false); 
						if (fileexists(temp)) { 
							if (addpaths) { arrayappend(request.tap.getCF().onrequestend.patharray,"01 - " & temp); } 
							templateArray[1] = request.fs.getPathTo(myprocess & modArray[i],locArray[loc],false); 
							return templateArray; 
						} 
					} 
					
					ArrayDeleteAt(tmpProcess,arraylen(tmpProcess)); 
				} 
			} 
			stage = ""; 
			process = listToArray(process[arraylen(process)]); 
		} else { stage = "_" & stage; 
			if (request.tap.getLocal().uselsdata) { 
				lang = listtoarray(lcase(request.tap.getLocal().language),"_-"); 
				lang[1] = "_l10n/" & lang[1]; 
				if (arraylen(lang) gt 1) { lang[2] = lang[1] & "/" & lang[2]; } 
				if (arraylen(lang) gt 2) { lang[3] = lang[2] & "/" & lang[3]; } 
				if (reverseorder) { temp = arraynew(1); 
					for (x = 1; x lte arraylen(lang); x = x + 1) 
						{ arrayprepend(temp,lang[x]); } 
					lang = temp; 
					ArrayAppend(lang,""); 
				} else { ArrayPrepend(lang,""); } 
			} 
		} 
		
		if (not ArrayLen(lang)) { lang[1] = ""; } 
		if (compress) { compress = "~ontap.cfm"; } else { compress = ""; } 
		
		// check for serialized process directories 
		for (x = 1; x lte arraylen(process); x = x + 1) { 
			for (loc = 1; loc lte arraylen(locarray); loc = loc + 1) { 
				for (lx = 1; lx lte arraylen(lang); lx = lx + 1) { 
					temp = "#process[x]#/#stage#/#lang[lx]#"; 
					modlist = request.fs.templateArray(temp,locArray[loc],filter,refresh,compress); 
					
					if (addpaths) { 
						// apppend direcotries to the framework's path stack 
						temp = request.fs.getPath(temp,locArray[loc]); 
						if (arraylen(modlist) and not len(trim(stage))) 
							{ arrayappend(request.tap.getCF().onrequestend.patharray,numberformat(arraylen(modlist),00) & " - " & temp); } 
						else if (reverseorder) { arrayprepend(stack,temp); arrayprepend(aTemplates,arraylen(modlist)); } 
						else { arrayappend(stack,temp); arrayappend(aTemplates,arraylen(modlist)); } 
					} 
					
					if (arraylen(modlist) and not len(trim(stage))) { return modlist; } 
					else if (reverseorder) { for (i = arraylen(modlist); i gte 1; i = i - 1) { arrayprepend(templateArray,modlist[i]); } } 
					else { for (i = 1; i lte arraylen(modlist); i = i + 1) { arrayappend(templateArray,modlist[i]); } } 
				} 
			} 
		} 
		
		if (addpaths) { for (x = 1; x lte arraylen(stack); x = x + 1) { arrayappend(request.tap.getCF().onrequestend.patharray,numberformat(aTemplates[x],00) & " - " & stack[x]); } } 
		
		return templateArray; 
	} 
	
	request.fs.processTemplates = processTemplates; 

	function readResourceBundle(filepath) { 
		var format = server.tap.fileman.getFormat("resourcebundle"); 
		var attr = request.tapi.arrayToStruct(arguments,"file,domain,locale,owrite,extension,refresh"); 
		var owrite = request.tapi.arg(attr,"owrite",""); 
		var domain = request.tapi.arg(attr,"domain","C"); 
		var bundle = structNew(); 
		
		structDelete(attr,"domain"); 
		structDelete(attr,"owrite"); 
		
		attr.file = request.fs.getPath(attr.file,domain); 
		bundle = format.read(argumentcollection=attr); 
		if (isboolean(owrite)) { request.tap.getLocal().appendKeys(bundle,owrite); } 
		return bundle; 
	} 
	
	request.fs.readresourcebundle = readresourcebundle; 
	
	function tReturn() { 
		if (arraylen(arguments) gte 1) { variables.returnvalue = arguments[1]; } 
		return request.fs.getPathTo("return.cfm","CT"); 
	} 
	
	request.fs.return = tReturn; 
	
	function subdirectories() { 
		var directory = request.tapi.arg(arguments,1,""); 
		var domain = request.tapi.arg(arguments,2,"C"); 
		var fso = CreateObject("java","java.io.File"); 
		var x = 1; var dir = 0; var i = 0; 
		var aDir = arrayNew(1); 
		var nextpath = ""; 
		
		aDir[1] = ""; domain = request.fs.getPath(directory,domain); 
		
		while (x lte arraylen(aDir)) { 
			fso.init(JavaCast("string",replace("#domain#/#aDir[x]#","\","/","ALL"))); 
			dir = fso.list(); for (i = 1; i lte arraylen(dir); i = i + 1) { 
				nextpath = aDir[x] & request.tap.getOS().pathdelimiter & dir[i]; 
				if (DirectoryExists(request.fs.getPath(nextpath,domain))) { ArrayAppend(aDir,nextpath); } 
			} x = x + 1; 
		} return aDir; 
	} 
	
	request.fs.subdirectories = subdirectories; 
	
	function templateArray(directory) { 
		var domain = "C"; 
		var filter = request.tap.contentfilter; 
		var refresh = request.tap.development; 
		var compress = "~ontap.cfm"; 
		var i = 0; var modlist = ""; 
		var root = request.fs.getPath("","T"); 
		var templateArray = arraynew(1); 
		var map = "/tap"; 
		
		switch (arraylen(arguments)) {
			case 5: compress = arguments[5]; 
			case 4: refresh = arguments[4]; 
			case 3: filter = arguments[3]; 
			case 2: domain = arguments[2]; 
		} 
		
		directory = request.fs.getPath(directory,domain,false); 
		map = map & Replace(removechars(directory,1,len(root)),"\","/","ALL"); 
		
		if (len(trim(compress)) and request.fs.compress("",directory,filter,compress)) { 
			arrayappend(templateArray,map & "/" & compress); 
		} else { 
			templateArray = listtoarray(request.fs.templateList("",directory,filter,refresh)); 
			for (i = 1; i lte arraylen(templateArray); i = i + 1) { 
				templateArray[i] = map & "/" & templateArray[i]; 
			} 
		} return templateArray; 
	} 
	
	request.fs.templateArray = templateArray; 

	function templateList(directory) { 
		var filter = request.tap.contentfilter; 
		var refresh = request.tap.development; 
		var domain = "C"; 
		
		// overwrite default arguments - avoid request.tapi.arg() for performance 
		switch (arraylen(arguments)) { 
			case "4": { refresh = arguments[4]; } 
			case "3": { filter = arguments[3]; } 
			case "2": { domain = arguments[2]; } 
		} directory = request.fs.getPath(directory,domain); 
		
		return server.tap.fileMan.getTemplateList(directory,filter,refresh); 
	} 
	
	request.fs.templateList = templateList; 
</cfscript>