ASTActionScriptProject.java

/*
 * ASTASProject.java
 * 
 * Copyright (c) 2006-2007 David Holroyd
 *
 * 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 uk.co.badgersinfoil.metaas.impl;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import uk.co.badgersinfoil.metaas.ActionScriptProject;
import uk.co.badgersinfoil.metaas.ActionScriptFactory;
import uk.co.badgersinfoil.metaas.dom.ASCompilationUnit;

// TODO: some checks that types are not created that clash with existing types,
// or at least filenames wont collide in the outputDir, would be good.

public class ASTActionScriptProject implements ActionScriptProject {
	private List classpath = new ArrayList();
	private Map resourceRoots = new HashMap();
	private List compilationUnits = new ArrayList();
	private String outputLocation;
	private ActionScriptFactory fact;

	public ASTActionScriptProject(ActionScriptFactory fact) {
		this.fact = fact;
	}

	// TODO: interface for cp entries; not just strings.  Add support for
	//       .swc classpath entries
	public void addClasspathEntry(String classpathEntry) {
		ResourceRoot root = resourceRootFor(classpathEntry);
		resourceRoots.put(classpathEntry, root);
		classpath.add(classpathEntry);
	}

	private ResourceRoot resourceRootFor(String classpathEntry) {
		File path = new File(classpathEntry);
		if (path.isDirectory()) {
			return new SourceFolderResourceRoot(path);
		}
		if (classpathEntry.endsWith(".swc")) {
			try {
				return new SWCResourceRoot(classpathEntry);
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		throw new IllegalArgumentException("Unknown resorce type: "+classpathEntry);
	}
	
	/**
	 * Returns a list of ResourceRoot implementations pertaining to the
	 * classpath entries that have been added to this project.
	 */
	public Collection getResourceRoots() {
		return resourceRoots.values();
	}

	public void removeClasspathEntry(String classpathEntry) {
		classpath.remove(classpathEntry);
		resourceRoots.remove(classpathEntry);
	}

	public List getClasspathEntries() {
		return Collections.unmodifiableList(classpath);
	}

	public void addCompilationUnit(ASCompilationUnit cu) {
		compilationUnits.add(cu);
	}

	public void removeCompilationUnit(ASCompilationUnit cu) {
		compilationUnits.remove(cu);
	}
	public ASCompilationUnit newClass(String qualifiedClassName) {
		ASCompilationUnit cu = fact.newClass(qualifiedClassName);
		addCompilationUnit(cu);
		return cu;
	}
	public ASCompilationUnit newInterface(String qualifiedInterfaceName) {
		ASCompilationUnit cu = fact.newInterface(qualifiedInterfaceName);
		addCompilationUnit(cu);
		return cu;
	}

	public List getCompilationUnits() {
		return Collections.unmodifiableList(compilationUnits);
	}

	public String getOutputLocation() {
		return outputLocation;
	}

	public void setOutputLocation(String outputLocation) {
		this.outputLocation = outputLocation;
	}

	public void writeAll() throws IOException {
		for (Iterator i=compilationUnits.iterator(); i.hasNext(); ) {
			ASCompilationUnit cu = (ASCompilationUnit)i.next();
			write(outputLocation, cu);
		}
	}

	public void performAutoImport() {
		AutoImporter autoImporter = new AutoImporter();
		autoImporter.performAutoImport(this);
	}

	/**
	 * Writes the ActionScript code in the given CompilationUnit to the
	 * given directory, creating any subfolders for package hierarchy as
	 * appropriate, and deriving the filename from the name of the type
	 * defined by the compilation unit.
	 */
	private void write(String destinationDir, ASCompilationUnit cu) throws IOException {
		String filename = filenameFor(cu);
		File destFile = new File(destinationDir, filename);
		destFile.getParentFile().mkdirs();
		FileOutputStream os = new FileOutputStream(destFile);
		OutputStreamWriter out = new OutputStreamWriter(os);
		fact.newWriter().write(out, cu);
		out.close();
	}

	private static String filenameFor(ASCompilationUnit unit) {
		String name;
		String pkg = unit.getPackageName();
		if (pkg == null || pkg.equals("")) {
			name = unit.getType().getName();
		} else {
			name = unit.getPackageName() + "." + unit.getType().getName();
		}
		return name.replace('.', File.separatorChar) + ".as";
	}
}