Creating An XML Representation Of A Directory (And Sub-Directories) Using ColdFusion

<directory
	name="..."
	path="...">

	<directories>

		<directory
			name="..."
			path="...">

			--[ RECURSIVE AREA ]--

		</directory>

	</directories>

	<files>

		<file
			name="..."
			path="..."
			bytes="..."
			/>

	</files>

</directory>

<cffunction
	name="GetDirectoryXml"
	access="public"
	returntype="string"
	output="false"
	hint="Gets directory information from a directory File object and returns it in XML format.">

	<!--- Define arguments. --->
	<cfargument
		name="Directory"
		type="any"
		required="true"
		hint="The Java FILE object representing a directory."
		/>

	<cfargument
		name="Recurse"
		type="boolean"
		required="false"
		default="false"
		hint="Determines whether we will get child directory information recursively."
		/>

	<cfargument
		name="Buffer"
		type="any"
		required="false"
		default=""
		hint="This is the string buffer to which the result is written before being returned."
		/>

	<cfscript>

		// Set up local scope.
		var LOCAL = StructNew();

		// Create an array for files.
		LOCAL.Files = ArrayNew( 1 );

		// Create an array for directories.
		LOCAL.Directories = ArrayNew( 1 );

		// Get the children for this directory.
		LOCAL.Children = ARGUMENTS.Directory.ListFiles();

		// Set up a flag for returning the buffer. If the buffer
		// is a simple value then we want to return the buffer.
		// If it is a complex value, then either we are part
		// of the recursive call or a buffer was passed in.
		// Either way, don't return anything in that case.
		LOCAL.ReturnBuffer = IsSimpleValue( ARGUMENTS.Buffer );


		// Check to see if we have a buffer yet to which we
		// will be writing the result.
		if (IsSimpleValue( ARGUMENTS.Buffer )){

			// Create the string buffer.
			ARGUMENTS.Buffer = CreateObject(
				"java",
				"java.lang.StringBuffer"
				).Init();

		}


		// Loop over the children objects to figure out which
		// array they should go in: File or Directory.
		for (
			LOCAL.ChildIndex = 1 ;
			LOCAL.ChildIndex LTE ArrayLen( LOCAL.Children ) ;
			LOCAL.ChildIndex = (LOCAL.ChildIndex + 1)
			){

			// Check for file type.
			if (LOCAL.Children[ LOCAL.ChildIndex ].IsDirectory()){

				// Add to directory array.
				ArrayAppend(
					LOCAL.Directories,
					LOCAL.Children[ LOCAL.ChildIndex ]
					);

			} else {

				// Add to directory array.
				ArrayAppend(
					LOCAL.Files,
					LOCAL.Children[ LOCAL.ChildIndex ]
					);

			}

		}


		// ASSERT: At this point, we have two fully populated
		// arrays for Files and Directories. These are populated
		// with actual Java FILE objects, not just paths.


		// Start the directory node.
		ARGUMENTS.Buffer.Append(
			"<directory name=""" &
			XmlFormat( ARGUMENTS.Directory.GetName() ) &
			""" path=""" &
			XmlFormat( ARGUMENTS.Directory.GetPath() ) &
			""">"
			);


		// Start the directory node.
		ARGUMENTS.Buffer.Append(
			"<directories>"
			);

		// Loop over the directories to output xml data.
		for (
			LOCAL.DirectoryIndex = 1 ;
			LOCAL.DirectoryIndex LTE ArrayLen( LOCAL.Directories ) ;
			LOCAL.DirectoryIndex = (LOCAL.DirectoryIndex + 1)
			){

			// Get short hand.
			LOCAL.Directory = LOCAL.Directories[ LOCAL.DirectoryIndex ];

			// Check to see if we are recursing. If we are then
			// we can send this directory object right back to
			// this function (hello recursion). If not, we can
			// just output the basic data.
			if (ARGUMENTS.Recurse){

				// Since we are recursing, send back to self.
				GetDirectoryXml(
					Directory = LOCAL.Directory,
					Recurse = ARGUMENTS.Recurse,
					Buffer = ARGUMENTS.Buffer
					);

			} else {

				// Since we are not recursing, just output
				// simple data.
				ARGUMENTS.Buffer.Append(
					"<directory name=""" &
					XmlFormat( LOCAL.Directory.GetName() ) &
					""" path=""" &
					XmlFormat( LOCAL.Directory.GetPath() ) &
					""">"
					);

			}

		}

		// End the directory node.
		ARGUMENTS.Buffer.Append(
			"</directories>"
			);

		// Start the files node.
		ARGUMENTS.Buffer.Append(
			"<files>"
			);

		// Loop over the files to output xml data.
		for (
			LOCAL.FileIndex = 1 ;
			LOCAL.FileIndex LTE ArrayLen( LOCAL.Files ) ;
			LOCAL.FileIndex = (LOCAL.FileIndex + 1)
			){

			// Get short hand.
			LOCAL.File = LOCAL.Files[ LOCAL.FileIndex ];

			// Write file node.
			ARGUMENTS.Buffer.Append(
				"<file name=""" &
				XmlFormat( LOCAL.File.GetName() ) &
				""" path=""" &
				XmlFormat( LOCAL.File.GetPath() ) &
				""" bytes=""" &
				XmlFormat( LOCAL.File.Length() ) &
				"""/>"
				);

		}

		// Start the files node.
		ARGUMENTS.Buffer.Append(
			"</files>"
			);

		// Close the directory node.
		ARGUMENTS.Buffer.Append(
			"</directory>"
			);


		// Check to see if we should return the buffer.
		if (LOCAL.ReturnBuffer){

			// Return the directory Xml data.
			return( ARGUMENTS.Buffer.ToString() );

		} else {

			// Just return the empty string.
			return( "" );

		}

	</cfscript>
</cffunction>

<!--- Search for the file "set.cfm". --->
<cfset arrFind = XmlSearch(
	xmlDir,
	"//file[@name='set.cfm']"
	) />

<cffunction
	name="RenderDirectoryXml"
	access="public"
	output="true"
	returntype="void"
	hint="Graphically renders the XML created via GetDirectoryXml().">

	<!--- Define arguments. --->
	<cfargument
		name="Xml"
		type="xml"
		required="true"
		hint="The XML object created via GetDirectoryXml()."
		/>

	<cfargument
		name="Indent"
		type="string"
		required="false"
		default=""
		hint="The left hand buffer (in spaces)"
		/>

	<!--- Define local scope. --->
	<cfset var LOCAL = StructNew() />

	<!---
		Get current directory element. This might be the full
		XML object, or it might be a sub directory.
	--->
	<cfif StructKeyExists( ARGUMENTS.Xml, "XmlRoot" )>

		<!---
			We have a full on ColdFusion XML document object.
			Grab the root and use that.
		--->
		<cfset LOCAL.Root = ARGUMENTS.Xml.XmlRoot />

	<cfelse>

		<!---
			We are dealing with an actual XML directory
			node. Just use that as the root.
		--->
		<cfset LOCAL.Root = ARGUMENTS.Xml />

	</cfif>


	<!--- Get the sub directories. --->
	<cfset LOCAL.Directories = LOCAL.Root.directories.XmlChildren />

	<!--- Get the files. --->
	<cfset LOCAL.Files = LOCAL.Root.files.XmlChildren />


	<!--- Safe guard for indent. --->
	<cfif (Len( ARGUMENTS.Indent ) GT 20)>

		<cfthrow
			type="Too.Much.Recursion"
			message="We have recursed to many times."
			/>

	</cfif>


	<!--- Output the name of the current directory. --->
	<pre>#ARGUMENTS.Indent##LOCAL.Root.XmlAttributes.Name#/</pre>

	<!--- Loop over directories to output recursively. --->
	<cfloop
		index="LOCAL.DirectoryIndex"
		from="1"
		to="#ArrayLen( LOCAL.Directories )#"
		step="1">

		<!---
			Render sub directories. Notice that we are adding
			".." to the indent to show that we are in a sub-
			directory.
		--->
		<cfset RenderDirectoryXml(
			Xml = LOCAL.Directories[ LOCAL.DirectoryIndex ],
			Indent = (ARGUMENTS.Indent & "..")
			) />

	</cfloop>


	<!--- Loop over files to output. --->
	<cfloop
		index="LOCAL.FileIndex"
		from="1"
		to="#ArrayLen( LOCAL.Files )#"
		step="1">

		<pre>#ARGUMENTS.Indent#..#LOCAL.Files[ LOCAL.FileIndex ].XmlAttributes.Name#</pre>

	</cfloop>

	<!--- Return out. --->
	<cfreturn />
</cffunction>