gdx-studio

/*******************************************************************************

 * Copyright 2011 See AUTHORS file.

 * 

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 * 

 *   http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 ******************************************************************************/

package com.badlogic.gdx.tools;

import com.badlogic.gdx.utils.Array;

import java.io.File;

import java.io.FilenameFilter;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.LinkedHashMap;

import java.util.regex.Pattern;

/** Collects files recursively, filtering by file name. Callbacks are provided to process files and the results are collected,

 * either {@link #processFile(Entry)} or {@link #processDir(Entry, ArrayList)} can be overridden, or both. The entries provided to

 * the callbacks have the original file, the output directory, and the output file. If {@link #setFlattenOutput(boolean)} is

 * false, the output will match the directory structure of the input.

 * @author Nathan Sweet */

public class FileProcessor {

	FilenameFilter inputFilter;

	Comparator<File> comparator = new Comparator<File>() {

		public int compare (File o1, File o2) {

			return o1.getName().compareTo(o2.getName());

		}

	};

	Array<Pattern> inputRegex = new Array();

	String outputSuffix;

	ArrayList<Entry> outputFiles = new ArrayList();

	boolean recursive = true;

	boolean flattenOutput;

	Comparator<Entry> entryComparator = new Comparator<Entry>() {

		public int compare (Entry o1, Entry o2) {

			return comparator.compare(o1.inputFile, o2.inputFile);

		}

	};

	public FileProcessor () {

	}

	/** Copy constructor. */

	public FileProcessor (FileProcessor processor) {

		inputFilter = processor.inputFilter;

		comparator = processor.comparator;

		inputRegex.addAll(processor.inputRegex);

		outputSuffix = processor.outputSuffix;

		recursive = processor.recursive;

		flattenOutput = processor.flattenOutput;

	}

	public FileProcessor setInputFilter (FilenameFilter inputFilter) {

		this.inputFilter = inputFilter;

		return this;

	}

	/** Sets the comparator for {@link #processDir(Entry, ArrayList)}. By default the files are sorted by alpha. */

	public FileProcessor setComparator (Comparator<File> comparator) {

		this.comparator = comparator;

		return this;

	}

	public FileProcessor addInputSuffix (String... suffixes) {

		for (String suffix : suffixes)

			addInputRegex(".*" + Pattern.quote(suffix));

		return this;

	}

	public FileProcessor addInputRegex (String... regexes) {

		for (String regex : regexes)

			inputRegex.add(Pattern.compile(regex));

		return this;

	}

	/** Sets the suffix for output files, replacing the extension of the input file. */

	public FileProcessor setOutputSuffix (String outputSuffix) {

		this.outputSuffix = outputSuffix;

		return this;

	}

	public FileProcessor setFlattenOutput (boolean flattenOutput) {

		this.flattenOutput = flattenOutput;

		return this;

	}

	/** Default is true. */

	public FileProcessor setRecursive (boolean recursive) {

		this.recursive = recursive;

		return this;

	}

	/** @param outputRoot May be null.

	 * @see #process(File, File) */

	public ArrayList<Entry> process (String inputFile, String outputRoot) throws Exception {

		return process(new File(inputFile), outputRoot == null ? null : new File(outputRoot));

	}

	/** Processes the specified input file or directory.

	 * @param outputRoot May be null if there is no output from processing the files.

	 * @return the processed files added with {@link #addProcessedFile(Entry)}. */

	public ArrayList<Entry> process (File inputFile, File outputRoot) throws Exception {

		if (!inputFile.exists()) throw new IllegalArgumentException("Input file does not exist: " + inputFile.getAbsolutePath());

		if (inputFile.isFile())

			return process(new File[] {inputFile}, outputRoot);

		else

			return process(inputFile.listFiles(), outputRoot);

	}

	/** Processes the specified input files.

	 * @param outputRoot May be null if there is no output from processing the files.

	 * @return the processed files added with {@link #addProcessedFile(Entry)}. */

	public ArrayList<Entry> process (File[] files, File outputRoot) throws Exception {

		if (outputRoot == null) outputRoot = new File("");

		outputFiles.clear();

		LinkedHashMap<File, ArrayList<Entry>> dirToEntries = new LinkedHashMap();

		process(files, outputRoot, outputRoot, dirToEntries, 0);

		ArrayList<Entry> allEntries = new ArrayList();

		for (java.util.Map.Entry<File, ArrayList<Entry>> mapEntry : dirToEntries.entrySet()) {

			ArrayList<Entry> dirEntries = mapEntry.getValue();

			if (comparator != null) Collections.sort(dirEntries, entryComparator);

			File inputDir = mapEntry.getKey();

			File newOutputDir = null;

			if (flattenOutput)

				newOutputDir = outputRoot;

			else if (!dirEntries.isEmpty()) //

				newOutputDir = dirEntries.get(0).outputDir;

			String outputName = inputDir.getName();

			if (outputSuffix != null) outputName = outputName.replaceAll("(.*)\\..*", "$1") + outputSuffix;

			Entry entry = new Entry();

			entry.inputFile = mapEntry.getKey();

			entry.outputDir = newOutputDir;

			if (newOutputDir != null)

				entry.outputFile = newOutputDir.length() == 0 ? new File(outputName) : new File(newOutputDir, outputName);

			try {

				processDir(entry, dirEntries);

			} catch (Exception ex) {

				throw new Exception("Error processing directory: " + entry.inputFile.getAbsolutePath(), ex);

			}

			allEntries.addAll(dirEntries);

		}

		if (comparator != null) Collections.sort(allEntries, entryComparator);

		for (Entry entry : allEntries) {

			try {

				processFile(entry);

			} catch (Exception ex) {

				throw new Exception("Error processing file: " + entry.inputFile.getAbsolutePath(), ex);

			}

		}

		return outputFiles;

	}

	private void process (File[] files, File outputRoot, File outputDir, LinkedHashMap<File, ArrayList<Entry>> dirToEntries,

		int depth) {

		// Store empty entries for every directory.

		for (File file : files) {

			File dir = file.getParentFile();

			ArrayList<Entry> entries = dirToEntries.get(dir);

			if (entries == null) {

				entries = new ArrayList();

				dirToEntries.put(dir, entries);

			}

		}

		for (File file : files) {

			if (file.isFile()) {

				if (inputRegex.size > 0) {

					boolean found = false;

					for (Pattern pattern : inputRegex) {

						if (pattern.matcher(file.getName()).matches()) {

							found = true;

							continue;

						}

					}

					if (!found) continue;

				}

				File dir = file.getParentFile();

				if (inputFilter != null && !inputFilter.accept(dir, file.getName())) continue;

				String outputName = file.getName();

				if (outputSuffix != null) outputName = outputName.replaceAll("(.*)\\..*", "$1") + outputSuffix;

				Entry entry = new Entry();

				entry.depth = depth;

				entry.inputFile = file;

				entry.outputDir = outputDir;

				if (flattenOutput) {

					entry.outputFile = new File(outputRoot, outputName);

				} else {

					entry.outputFile = new File(outputDir, outputName);

				}

				dirToEntries.get(dir).add(entry);

			}

			if (recursive && file.isDirectory()) {

				File subdir = outputDir.getPath().length() == 0 ? new File(file.getName()) : new File(outputDir, file.getName());

				process(file.listFiles(inputFilter), outputRoot, subdir, dirToEntries, depth + 1);

			}

		}

	}

	/** Called with each input file. */

	protected void processFile (Entry entry) throws Exception {

	}

	/** Called for each input directory. The files will be {@link #setComparator(Comparator) sorted}. */

	protected void processDir (Entry entryDir, ArrayList<Entry> files) throws Exception {

	}

	/** This method should be called by {@link #processFile(Entry)} or {@link #processDir(Entry, ArrayList)} if the return value of

	 * {@link #process(File, File)} or {@link #process(File[], File)} should return all the processed files. */

	protected void addProcessedFile (Entry entry) {

		outputFiles.add(entry);

	}

	/** @author Nathan Sweet */

	static public class Entry {

		public File inputFile;

		/** May be null. */

		public File outputDir;

		public File outputFile;

		public int depth;

		public Entry () {

		}

		public Entry (File inputFile, File outputFile) {

			this.inputFile = inputFile;

			this.outputFile = outputFile;

		}

		public String toString () {

			return inputFile.toString();

		}

	}

}