Java tutorial
/* * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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 org.apache.flex.compiler.internal.projects; import java.io.File; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Set; import org.apache.commons.io.FilenameUtils; import org.apache.flex.compiler.problems.DuplicateQNameInSourcePathProblem; import org.apache.flex.compiler.problems.DuplicateSourceFileProblem; import org.apache.flex.compiler.problems.ICompilerProblem; import org.apache.flex.compiler.problems.NonDirectoryInSourcePathProblem; import org.apache.flex.compiler.problems.OverlappingSourcePathProblem; import org.apache.flex.compiler.problems.SourcePathNotFoundProblem; import org.apache.flex.compiler.problems.UnableToListFilesProblem; import org.apache.flex.compiler.projects.IASProject; import org.apache.flex.compiler.projects.IFlexProject; import org.apache.flex.compiler.units.ICompilationUnit; import org.apache.flex.utils.DirectoryID; import org.apache.flex.utils.FilenameNormalization; import com.google.common.base.Function; import com.google.common.base.Joiner; import com.google.common.base.Objects; import com.google.common.base.Predicate; import com.google.common.collect.Collections2; import com.google.common.collect.Iterables; import com.google.common.collect.Sets; /** * Maintains a source path for a {@link ASProject}. */ public final class SourcePathManager { /** * Constructor */ public SourcePathManager(ASProject compilerProject) { this.compilerProject = compilerProject; sourcePaths = new LinkedHashMap<DirectoryID, HashSet<QNameFile>>(); problems = Collections.emptyList(); } private final ASProject compilerProject; // map where we keep all the paths and the qnames/files they define. // use DirectoryID as the key so we can avoid two "identical" paths // that only differ in case (upper vs lower) private LinkedHashMap<DirectoryID, HashSet<QNameFile>> sourcePaths; private Collection<ICompilerProblem> problems; private Collection<ICompilerProblem> duplicateQNameProblems; /** * Test if a file is on the source path or not. * * @param file The file to test. May not be null. * @return true if the file is on the source path, false otherwise. */ public boolean isFileOnSourcePath(File file) { for (final DirectoryID directory : sourcePaths.keySet()) { if (directory.isParentOf(file)) return true; } return false; } private void accumulateQNameFiles(Set<QNameFile> qNameFiles, File directory, String baseQName, String locale, Collection<ICompilerProblem> problems, int order) { assert directory.isDirectory(); assert directory.equals(FilenameNormalization.normalize(directory)); File[] files = directory.listFiles(); if (files == null) { problems.add(new UnableToListFilesProblem(directory)); return; } for (final File file : directory.listFiles()) { assert file.equals(FilenameNormalization.normalize(file)); if (file.isDirectory()) { accumulateQNameFiles(qNameFiles, file, baseQName + file.getName() + ".", locale, problems, order); } else if (compilerProject.getSourceCompilationUnitFactory().canCreateCompilationUnit(file)) { String className = FilenameUtils.getBaseName(file.getName()); String qName = baseQName + className; qNameFiles.add(new QNameFile(qName, file, locale, order)); } } } public static String computeQName(File ancestor, File descendent) { assert ancestor.equals(FilenameNormalization.normalize(ancestor)); assert descendent.equals(FilenameNormalization.normalize(descendent)); StringBuilder result = new StringBuilder(); File current = descendent.getParentFile(); result.insert(0, FilenameUtils.getBaseName(descendent.getPath())); while (current != null) { if (current.equals(ancestor)) return result.toString(); result.insert(0, '.'); result.insert(0, FilenameUtils.getBaseName(current.getPath())); current = current.getParentFile(); } return null; } private static boolean arePathsEqual(File[] newPaths, LinkedHashMap<DirectoryID, HashSet<QNameFile>> oldPaths) { if (newPaths.length != oldPaths.size()) return false; int i = 0; for (DirectoryID oldPath : oldPaths.keySet()) { if (!newPaths[i].isDirectory()) return false; // all the old paths are directories. If this isn't then it must not be equal DirectoryID newDir = new DirectoryID(newPaths[i]); if (!(newDir.equals(oldPath))) return false; i++; } return true; } private static boolean isAncestorOf(File ancestor, File descendent) { return computeQName(ancestor, descendent) != null; } void handleChangedSourcePath(File[] newSourcePath) { // used to check for duplicates and buildup a mapping of which source files // are contained within each sourcePath Collection<ICompilerProblem> problems = new ArrayList<ICompilerProblem>(); LinkedHashMap<DirectoryID, HashSet<QNameFile>> newSourcePaths = new LinkedHashMap<DirectoryID, HashSet<QNameFile>>(); List<QNameFile> newQNameFilesToCreate = new ArrayList<QNameFile>(); int order = 0; for (File sourcePathEntry : newSourcePath) { // Make sure the entry is a directory if (!sourcePathEntry.isDirectory()) { problems.add(new NonDirectoryInSourcePathProblem(sourcePathEntry)); } else { DirectoryID directoryId = new DirectoryID(sourcePathEntry); if (!newSourcePaths.containsKey(directoryId)) { HashSet<QNameFile> filesInPath = new HashSet<QNameFile>(); newSourcePaths.put(directoryId, filesInPath); // Check for overlapping source path entries. for (File descendent : newSourcePath) { if ((sourcePathEntry != descendent) && (isAncestorOf(sourcePathEntry, descendent))) { problems.add(new OverlappingSourcePathProblem(sourcePathEntry, descendent)); } } String locale = null; if (compilerProject instanceof IFlexProject) locale = ((IFlexProject) compilerProject) .getResourceLocale(sourcePathEntry.getAbsolutePath()); accumulateQNameFiles(filesInPath, sourcePathEntry, "", locale, problems, order); // if the source path already exists, no need to re-add files which // already exist Set<QNameFile> existingEntriesForSourcePath = Objects.<Set<QNameFile>>firstNonNull( sourcePaths.get(directoryId), Collections.<QNameFile>emptySet()); // Any qname file that is in filesInPath, but not in existingEntriesForSourcePath // is a new qname file that we need to create a compilation unit for. newQNameFilesToCreate.addAll(Sets.difference(filesInPath, existingEntriesForSourcePath)); } } ++order; } // if an existing path is not in the newPaths, it needs to be removed. // work out which compilation units need to be removed as a result of changing Set<ICompilationUnit> unitsToRemove = new HashSet<ICompilationUnit>(); for (Map.Entry<DirectoryID, HashSet<QNameFile>> e : sourcePaths.entrySet()) { Set<QNameFile> newSourcePathFiles = Objects.<Set<QNameFile>>firstNonNull(newSourcePaths.get(e.getKey()), Collections.<QNameFile>emptySet()); Set<QNameFile> filesToRemove = Sets.difference(e.getValue(), newSourcePathFiles); for (QNameFile qNameFile : filesToRemove) { File sourceFile = qNameFile.file; Collection<ICompilationUnit> sourcePathCompilationUnitsToRemove = Collections2.filter( compilerProject.getCompilationUnits(sourceFile.getAbsolutePath()), new Predicate<ICompilationUnit>() { @Override public boolean apply(ICompilationUnit cu) { DefinitionPriority defPriority = (DefinitionPriority) cu.getDefinitionPriority(); return defPriority.getBasePriority() == DefinitionPriority.BasePriority.SOURCE_PATH; } }); unitsToRemove.addAll(sourcePathCompilationUnitsToRemove); } } // set the new sources sourcePaths = newSourcePaths; List<ICompilationUnit> unitsToAdd = new ArrayList<ICompilationUnit>(); if (!newQNameFilesToCreate.isEmpty()) { for (QNameFile qNameFile : newQNameFilesToCreate) { ICompilationUnit newCU = compilerProject.getSourceCompilationUnitFactory().createCompilationUnit( qNameFile.file, DefinitionPriority.BasePriority.SOURCE_PATH, qNameFile.order, qNameFile.qName, qNameFile.locale); //It can be null in some cases, see #ResourceBundleSourceFileHandler if (newCU != null) unitsToAdd.add(newCU); } } this.problems = problems; compilerProject.updateCompilationUnitsForPathChange(unitsToRemove, unitsToAdd); checkForDuplicateQNames(); } private boolean foundAllCompilationUnits() { compilerProject.getWorkspace(); for (Set<QNameFile> qNameFiles : sourcePaths.values()) { for (QNameFile qNameFile : qNameFiles) { if (compilerProject.getWorkspace() .getCompilationUnits(qNameFile.file.getAbsolutePath(), compilerProject).isEmpty()) { if (compilerProject.getSourceCompilationUnitFactory().needCompilationUnit(qNameFile.file, qNameFile.qName, qNameFile.locale)) return false; } } } return true; } /** * Updates the list of directories that are the source path. This method may * add or remove {@link ICompilationUnit}'s from the {@link IASProject} * associated with this {@link SourcePathManager}. * * @param newSourcePath */ void setSourcePath(File[] newSourcePath) { newSourcePath = FilenameNormalization.normalize(newSourcePath); try { if (arePathsEqual(newSourcePath, sourcePaths)) return; handleChangedSourcePath(newSourcePath); } finally { assert foundAllCompilationUnits(); } } private Collection<ICompilationUnit> getCompilationUnits(File f) { assert FilenameNormalization.normalize(f).equals(f); return Collections2.filter(compilerProject.getCompilationUnits(f.getAbsolutePath()), new Predicate<ICompilationUnit>() { @Override public boolean apply(ICompilationUnit compilationUnit) { DefinitionPriority priority = ((DefinitionPriority) compilationUnit .getDefinitionPriority()); return priority.getBasePriority() == DefinitionPriority.BasePriority.SOURCE_PATH; } }); } /** * Notifies this {@link SourcePathManager} that a file as been added to the * file system. * <p> * This {@link SourcePathManager} will determine if any source path entries * contain the specified file and if so, will create new * {@link ICompilationUnit}'s and add them to the project. * * @param f File that has been added to the file system. * @return true if any {@link ICompilationUnit}'s were created and added to * the project. */ public boolean addFile(File f) { f = FilenameNormalization.normalize(f); if (!getCompilationUnits(f).isEmpty()) return false; ArrayList<QNameFile> qNameFiles = new ArrayList<QNameFile>(1); int order = 0; for (Map.Entry<DirectoryID, HashSet<QNameFile>> sourcePathEntry : sourcePaths.entrySet()) { DirectoryID dir = sourcePathEntry.getKey(); String qname = computeQName(dir.getFile(), f); if (qname != null) { String locale = null; if (compilerProject instanceof IFlexProject) locale = ((IFlexProject) compilerProject).getResourceLocale(dir.getFile().getAbsolutePath()); QNameFile newQNameFile = new QNameFile(qname, f, locale, order); sourcePathEntry.getValue().add(newQNameFile); qNameFiles.add(newQNameFile); } ++order; } if (qNameFiles.isEmpty()) return false; List<ICompilationUnit> unitsToAdd = new ArrayList<ICompilationUnit>(); for (QNameFile qNameFile : qNameFiles) { ICompilationUnit newCU = compilerProject.getSourceCompilationUnitFactory().createCompilationUnit( qNameFile.file, DefinitionPriority.BasePriority.SOURCE_PATH, qNameFile.order, qNameFile.qName, qNameFile.locale); if (newCU != null) unitsToAdd.add(newCU); } // If none of the files had a file extension we knew how to make // a compilation unit for we might not have any new compilation // units to add to the project. if (unitsToAdd.size() == 0) return false; assert unitsToAdd != null; compilerProject.updateCompilationUnitsForPathChange(Collections.<ICompilationUnit>emptyList(), unitsToAdd); checkForDuplicateQNames(); return true; } private void checkForDuplicateQNames() { Map<String, Set<QNameFile>> qNameMap = new HashMap<String, Set<QNameFile>>(); for (HashSet<QNameFile> qNameFiles : sourcePaths.values()) { for (QNameFile qNameFile : qNameFiles) { Set<QNameFile> qNameFilesForQName = qNameMap.get(qNameFile.qName); if (qNameFilesForQName == null) { qNameFilesForQName = new HashSet<QNameFile>(1); qNameMap.put(qNameFile.qName, qNameFilesForQName); } qNameFilesForQName.add(qNameFile); } } ArrayList<ICompilerProblem> duplicateQNameProblems = new ArrayList<ICompilerProblem>(); for (Map.Entry<String, Set<QNameFile>> qNameMapEntry : qNameMap.entrySet()) { Set<QNameFile> qNameFiles = qNameMapEntry.getValue(); String qName = qNameMapEntry.getKey(); if (qNameFiles.size() > 1) { StringBuilder listString = new StringBuilder(); int found = 0; for (QNameFile qNameFile : qNameFiles) { if (ResourceBundleSourceFileHandler.EXTENSION .equalsIgnoreCase(FilenameUtils.getExtension(qNameFile.file.getAbsolutePath()))) { //TODO: https://bugs.adobe.com/jira/browse/CMP-923 //As of now, we ignore the properties files while //checking the duplicate names until we find a sophisticated way //to this in the future. continue; } if (found++ > 0) listString.append(", "); assert qName.equals(qNameFile.qName); listString.append(qNameFile.file.getAbsolutePath()); } if (found > 1) //if we found more than one duplicate qname then report a problem { ICompilerProblem problem = new DuplicateQNameInSourcePathProblem(listString.toString(), qName); duplicateQNameProblems.add(problem); } } } if (duplicateQNameProblems.size() > 0) this.duplicateQNameProblems = duplicateQNameProblems; else this.duplicateQNameProblems = null; } /** * Notifies this {@link SourcePathManager} that a file as been deleted from * the file system. * <p> * This {@link SourcePathManager} will determine if any source path entries * contain the specified file and if so, will remove * {@link ICompilationUnit}'s from the project. * * @param f File that has been removed from the file system. * @return true if any {@link ICompilationUnit}'s were removed from the * project. */ public boolean removeFile(File f) { Collection<ICompilationUnit> unitsToRemove = getCompilationUnits(f); if (!unitsToRemove.isEmpty()) { List<ICompilationUnit> unitsToAdd = Collections.emptyList(); compilerProject.updateCompilationUnitsForPathChange(unitsToRemove, unitsToAdd); removeQNames(f); // if there are already duplicate names, after the remove, check for duplicates // again, as the remove may have fixed the problem. if (this.duplicateQNameProblems != null && !this.duplicateQNameProblems.isEmpty()) { checkForDuplicateQNames(); } return true; } return false; } private void removeQNames(File f) { for (Map.Entry<DirectoryID, HashSet<QNameFile>> sourcePathEntry : sourcePaths.entrySet()) { DirectoryID dir = sourcePathEntry.getKey(); String qname = computeQName(dir.getFile(), f); if (qname != null) { for (Iterator<QNameFile> iter = sourcePathEntry.getValue().iterator(); iter.hasNext();) { QNameFile qNameFile = iter.next(); if (qNameFile.file.equals(f)) { iter.remove(); } } } } } /** * Add {@link ICompilerProblem}'s found in the current source path to the * specified collection. * <p> * These problems are with the source path itself, not with sources * discovered in the source path. For example the returned collection would * not contain syntax error problems, put will contain * {@link DuplicateSourceFileProblem} problems. */ void collectProblems(Collection<ICompilerProblem> problems) { problems.addAll(this.problems); if (duplicateQNameProblems != null) problems.addAll(duplicateQNameProblems); for (DirectoryID sourcePath : sourcePaths.keySet()) { if (!sourcePath.getFile().exists()) { problems.add(new SourcePathNotFoundProblem(sourcePath.getFile().getAbsolutePath())); } } } /** * Adds all the {@link ICompilationUnit}'s whose root source file is the * specified File to the specified collection. * * @param rootSourceFile File to search for. * @param units Collection to add to. */ public void collectionCompilationUnitsForRootSourceFile(File rootSourceFile, Collection<ICompilationUnit> units) { Collection<ICompilationUnit> compilationUnits = compilerProject .getCompilationUnits(rootSourceFile.getAbsolutePath()); units.addAll(compilationUnits); } /** * Determines of the specified file is the root source file of any * {@link ICompilationUnit} created by this {@link SourcePathManager}. * * @param rootSourceFile File to search for. * @return true if the specified file is the root source file of any * {@link ICompilationUnit}'s created by this {@link SourcePathManager}. */ public boolean hasCompilationUnitsForRootSourceFile(File rootSourceFile) { Collection<ICompilationUnit> compilationUnits = compilerProject .getCompilationUnits(rootSourceFile.getAbsolutePath()); return compilationUnits.size() > 0; } public static class QNameFile { final String qName; final File file; final String locale; final int order; QNameFile(String qName, File file, String locale, int order) { this.qName = qName; this.file = file; this.locale = locale; this.order = order; } @Override public int hashCode() { return qName.hashCode() + file.hashCode(); } @Override public boolean equals(Object other) { if (other == this) return true; if (!(other instanceof QNameFile)) return false; QNameFile otherQNameFile = (QNameFile) other; return qName.equals(otherQNameFile.qName) && file.equals(otherQNameFile.file); } @Override public String toString() { return "QNameFile qName:" + this.qName + " file:" + this.file; } } String getSourceFileFromSourcePath(String file) { String sourceFile = null; for (DirectoryID sourcePath : sourcePaths.keySet()) { sourceFile = getSourceFileInPath(sourcePath.getFile(), file); if (sourceFile != null) break; } return sourceFile; } private List<QNameFile> createQNameFilesForFile(File f) { ArrayList<QNameFile> qNameFiles = new ArrayList<QNameFile>(1); int order = 0; for (Map.Entry<DirectoryID, HashSet<QNameFile>> sourcePathEntry : sourcePaths.entrySet()) { DirectoryID dir = sourcePathEntry.getKey(); String qname = computeQName(dir.getFile(), f); if (qname != null) { String locale = null; if (compilerProject instanceof IFlexProject) locale = ((IFlexProject) compilerProject).getResourceLocale(dir.getFile().getAbsolutePath()); QNameFile newQNameFile = new QNameFile(qname, f, locale, order); sourcePathEntry.getValue().add(newQNameFile); qNameFiles.add(newQNameFile); } ++order; } return qNameFiles; } /** * @param rootSourceFileName The absolute normalized file name for the root * source file of the new {@link QNameFile}. * @return A QNameFile for the rootSourceFileName, or null if it could not be computed */ QNameFile computeQNameForFilename(String rootSourceFileName) { List<QNameFile> qNameFiles = createQNameFilesForFile(new File(rootSourceFileName)); if (qNameFiles.isEmpty()) return null; // If there is more than one qNameFile, just use the first one. return Iterables.getFirst(qNameFiles, null); } /** * @param path Path to search for file in. May be null. * @param file Filename to search for. Can't be null. * @return Full path to file. null if not found */ public static String getSourceFileInPath(File path, String file) { File sourceFile; if (path != null) { sourceFile = new File(path, file); } else { sourceFile = new File(file); } if (sourceFile.exists()) { return FilenameNormalization.normalize(sourceFile.getAbsolutePath()); } return null; } /** * * @return the source path as a list of {@linkplain File}. */ public List<File> getSourcePath() { List<File> paths = new ArrayList<File>(sourcePaths.keySet().size()); for (DirectoryID path : sourcePaths.keySet()) { paths.add(path.getFile()); } return paths; } /** * For debugging only. */ @Override public String toString() { return Joiner.on('\n').join(Iterables.transform(sourcePaths.keySet(), new Function<DirectoryID, String>() { @Override public String apply(DirectoryID input) { return input.getFile().getAbsolutePath(); } })); } }