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 static com.google.common.base.Preconditions.checkNotNull; import java.io.File; import java.io.FilenameFilter; import java.lang.ref.SoftReference; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import org.apache.commons.io.FilenameUtils; import org.apache.commons.io.IOCase; import org.apache.commons.io.filefilter.FileFilterUtils; import org.apache.flex.compiler.internal.caches.CacheStoreKeyBase; import org.apache.flex.compiler.internal.caches.SWFCache; import org.apache.flex.compiler.internal.units.ResourceBundleCompilationUnit; import org.apache.flex.compiler.internal.units.SWCCompilationUnit; import org.apache.flex.compiler.problems.DuplicateSourceFileProblem; import org.apache.flex.compiler.problems.ICompilerProblem; import org.apache.flex.compiler.projects.IFlexProject; import org.apache.flex.compiler.units.ICompilationUnit; import org.apache.flex.swc.ISWC; import org.apache.flex.swc.ISWCFileEntry; import org.apache.flex.swc.ISWCLibrary; import org.apache.flex.swc.ISWCManager; import org.apache.flex.swc.ISWCScript; import org.apache.flex.swc.SWCManager; import org.apache.flex.swf.ITagContainer; import org.apache.flex.utils.FileID; import org.apache.flex.utils.FilenameNormalization; import com.google.common.base.Splitter; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; /** * Manages the library path of a {@link ASProject}. It has a list of SWC file * handles discovered on the library path. The manager doesn't keep SWC models, * because the {@link SWCManager} keep them as {@link SoftReference}. * {@link SWCManager} is responsible for providing a {@link ISWC} model from a * file. */ public final class LibraryPathManager { public static final String SWC_EXT = "swc"; public static final String ANE_EXT = "ane"; // SWC file extension public static final String DOT_SWC_EXT = "." + SWC_EXT; // ANE file extension public static final String DOT_ANE_EXT = "." + ANE_EXT; // A filename filter that only accepts SWC files and ANE files. private static final FilenameFilter SWC_FILTER = FileFilterUtils.or( FileFilterUtils.suffixFileFilter(DOT_SWC_EXT, IOCase.INSENSITIVE), FileFilterUtils.suffixFileFilter(DOT_ANE_EXT, IOCase.INSENSITIVE)); public static boolean isSWCFile(File file) { return SWC_FILTER.accept(file.getParentFile(), file.getName()); } /** * Find all the SWC files on the library path. The given library path * entries can be a SWC file or a directory containing SWC files. Note that * it does <b>NOT</b> read the directories recursively. * * Returns FileID objects so we can be sure that we have not accidenly made a case sensitive comparison */ public static Set<FileID> discoverSWCFilePaths(final File[] libraryPath) { final Set<FileID> swcFiles = new LinkedHashSet<FileID>(); for (final File path : libraryPath) { if (path.isDirectory()) { final File[] swcsInFolder = path.listFiles(SWC_FILTER); for (final File file : swcsInFolder) swcFiles.add(new FileID(file)); } else { swcFiles.add(new FileID(path)); } } return swcFiles; } /** * like discoverSWCFilePaths, but returns File instead of FileID. Only needed for extrenal clients * who don't / shouldn't have access to FileID * @param libraryPath An array of {@code File} objects. */ public static Set<File> discoverSWCFilePathsAsFiles(final File[] libraryPath) { Set<File> ret = new HashSet<File>(); Set<FileID> fileIds = discoverSWCFilePaths(libraryPath); for (FileID f : fileIds) { ret.add(f.getFile()); } return ret; } /** * Create a library path manager for a given project. * * @param flashProject flash project */ public LibraryPathManager(final ASProject flashProject) { checkNotNull(flashProject, "Flash project cannot be null."); this.flashProject = flashProject; this.libraryFilePaths = new LinkedHashMap<String, String>(); } /** Owner project. */ private final ASProject flashProject; /** * The bidirectional map stores normalized paths and source paths of the SWC * files on library path. * <p> * The key is the SWC file path; The value is the source file directory. */ private final Map<String, String> libraryFilePaths; /** * Create {@code SWCCompilationUnit} objects from the given SWC files. These * compilation units will be added to the project. * * @param swcFilePaths an array of SWC file paths * @return new compilation units from the given SWC file paths */ private List<ICompilationUnit> computeUnitsToAdd(final Collection<String> swcFilePaths) { int order = 0; final List<ICompilationUnit> result = new LinkedList<ICompilationUnit>(); final ISWCManager swcManager = flashProject.getWorkspace().getSWCManager(); for (final String swcFilePath : swcFilePaths) { // it is possible for the SWC to not exist on disk, if this method // is being called as part of a SWC file file removal invalidation. File swcFile = new File(swcFilePath); final ISWC swc = swcManager.get(swcFile); computeUnitsToAdd(swc, order, result); order++; } return result; } /** * Create {@code SWCCompilationUnit} objects from the given ISWC. These * compilation units will be added to the project. * * @param swc ISWC * @param order The oder of the SWC in the project * @param cus New compilation units from the given SWC file paths */ private void computeUnitsToAdd(ISWC swc, int order, List<ICompilationUnit> cus) { for (final ISWCLibrary library : swc.getLibraries()) { for (final ISWCScript script : library.getScripts()) { // Multiple definition in a script share the same compilation unit // with the same ABC byte code block. final List<String> qnames = new ArrayList<String>(script.getDefinitions().size()); for (final String definitionQName : script.getDefinitions()) { qnames.add(definitionQName.replace(":", ".")); } final ICompilationUnit cu = new SWCCompilationUnit(flashProject, swc, library, script, qnames, order); cus.add(cu); } } //If the project's locale is empty, then don't try to create ResourceBundleCompilationUnits // because no resource bundles won't go into swf or swc anyways. if (flashProject instanceof IFlexProject && ((IFlexProject) flashProject).getLocales().size() > 0) { //Create compilation units for all the .properties files in the swc. for (final ISWCFileEntry entry : swc.getFiles().values()) { if (FilenameUtils.getExtension(entry.getPath()).equals(ResourceBundleSourceFileHandler.EXTENSION)) { final ICompilationUnit cu = createResourceBundleCompilationUnit(swc, entry); if (cu != null) { cus.add(cu); } } } } } /** * Set the library path. It will populate {@link SWCManager} with SWC files * found on the library path. It also creates {@link SWCCompilationUnit} * objects for the discovered SWC files, and add these compilation units to * the project. * <p> * It is optimized to do nothing when the new library path is same as the * existing setting. * * See setLibrarySourcePath() as to why discoverSWCFilePaths() just ignores * invalid entries in the path * * @param libraryPath the {@code File} on the library path can be a SWC file * or a directory containing SWC files. */ public void setLibraryPath(final File libraryPath[]) { assert libraryPath != null : "Library path cannot be null"; final Set<FileID> swcFilePaths = discoverSWCFilePaths(libraryPath); // compute SWC files to add and remove final Collection<String> swcFilesToAdd = new LinkedHashSet<String>(); final Collection<String> swcFilesToRemove = new LinkedHashSet<String>(); // Now we can convert the FileID's to Strings, since we have eliminated dupes that use // mixed case. From here on, we don't have to worry about upper/lower case. Set<String> swcFilePathStrings = new LinkedHashSet<String>(); for (FileID f : swcFilePaths) swcFilePathStrings.add(f.getFile().getAbsolutePath()); computeAddRemoveSet(swcFilePathStrings, swcFilesToAdd, swcFilesToRemove); // update the library path map libraryFilePaths.clear(); for (final FileID path : swcFilePaths) { libraryFilePaths.put(path.getFile().getAbsolutePath(), null); } // apply changes to the project updateLibraryPath(swcFilesToAdd, swcFilesToRemove); } /** * Set the source path of a SWC library. * * @param library SWC file path * @param sourceDir source directory * * Note if we are passed a bad path here, we just ignore it. This happens often when * Projects have stale/strange lib source paths. * We COULD try to log a problem, but Bruce and Chris discussed this, and it seems like * overkill, as this only affects code hinting. */ public void setLibrarySourcePath(final File library, final File sourceDir) { if (library == null) return; final String swcPath = FilenameNormalization.normalize(library.getPath()); if (sourceDir == null) { // clear source path libraryFilePaths.put(swcPath, null); } else { if (!sourceDir.exists() || !sourceDir.isDirectory() || !libraryFilePaths.containsKey(swcPath)) return; // set source path final String sourcePath = FilenameNormalization.normalize(sourceDir.getPath()); libraryFilePaths.put(swcPath, sourcePath); } } /** * Find the directory were a given library might live. * Normally used for finding source attachments. * @param libraryFilename name of a library we want to find * @return a String with the full path to the folder. */ public String getAttachedSourceDirectory(String libraryFilename) { final String swcPath = FilenameNormalization.normalize(libraryFilename); final String attachedSourceDirectory = libraryFilePaths.get(swcPath); return attachedSourceDirectory; } /** * Finds a source file in the source directory * for the specified qualified name. * @param sourceDirectory Path to directory where source attachment directory should be exist. * @param qualifiedName Dotted qualified name to find a source file for. * @return Absolute file name of for specified dotted qualified name in the specified library file. */ public static String getAttachedSourceFilename(String sourceDirectory, String qualifiedName) { if (sourceDirectory == null) return null; // Infer source file path based on QName using Flex source path convention. final String relativePath = qualifiedName.replace('.', File.separatorChar); // Hard code to known list of extensions. If we need to get this from project we could // always pass in the extension list, but that seems unnecessary. We DON'T want to force callers // to pass in a project String[] knownExtensions = { "mxml", "as", "fxg" }; for (String ext : knownExtensions) { final File f = new File(sourceDirectory, relativePath.concat(".").concat(ext)); // TODO: there is a potential bug here on case sensitive file systems // as on the fs there could be foo.AS, but we only check the existence // of foo.as, as getHandledFileExtensions() returns lower cases strings. // Also, if there is foo.AS and foo.as, which one do we choose? if (f.exists()) return FilenameNormalization.normalize(f).getAbsolutePath(); } return null; } /** * Get source path for a SWC library. * * @param library SWC file * @return Directory that contains the source for a SWC library; Null if the * source path hasn't been set. */ public File getLibrarySourcePath(final File library) { final String swcPath = FilenameNormalization.normalize(library.getPath()); final String sourcePath = libraryFilePaths.get(swcPath); if (sourcePath == null) return null; else return new File(sourcePath); } /** * Compute the set of libraries to add and remove.<br> * Remove all the existing libraries that are in the new library path.<br> * Add all the new library path that are not in the existing library path. * * @param swcFilePaths Set of swcs to load. The iterator will iterate over * the swcs in priority order. * @param swcFilesToAdd SWC files to be added * @param swcFilesToRemove SWD files to be removed */ private void computeAddRemoveSet(final Set<String> swcFilePaths, final Collection<String> swcFilesToAdd, final Collection<String> swcFilesToRemove) { // only add a SWC to the swcFilesToAdd if it exists in on disk. swcFilePaths // can have files which don't exist yet, as a library project we depend on // may not have been compiled yet. for (String swcPath : swcFilePaths) { File f = new File(swcPath); if (f.exists()) swcFilesToAdd.add(swcPath); } Iterator<String> swcFilePathsIter = swcFilePaths.iterator(); boolean swcOrderDiffers = false; // if an existing swc is not in the newPath, it needs to be removed. for (final String existingSWCFilePath : libraryFilePaths.keySet()) { /* * If the order of the SWCs is different then add and remove all * SWCs in the list after and including that SWC. */ String newSWCFilePath = null; if (!swcOrderDiffers) { if (!swcFilePathsIter.hasNext()) { // we can run past the swcFilePaths when removing the last // element from the library path swcOrderDiffers = true; } else { newSWCFilePath = swcFilePathsIter.next(); if (existingSWCFilePath.equals(newSWCFilePath)) { swcFilesToAdd.remove(existingSWCFilePath); continue; } else { swcOrderDiffers = true; } } } /* * If the SWC order is detected as being different, then * always remove existing SWCs. Remove SWCs from the "add" * list that are no longer needed. */ if (swcOrderDiffers) { swcFilesToRemove.add(existingSWCFilePath); if (!swcFilesToAdd.contains(existingSWCFilePath)) swcFilesToAdd.remove(existingSWCFilePath); } } } /** * Add and remove SWC file on the {@link ASProject}. This method will add * and remove the corresponding {@link ISWC} object as well. * * @param swcFilesToAdd * @param swcFilesToRemove * @param isExternal */ private void updateLibraryPath(final Collection<String> swcFilesToAdd, final Collection<String> swcFilesToRemove) { final List<ICompilationUnit> unitsToAdd = computeUnitsToAdd(swcFilesToAdd); final List<ICompilationUnit> unitsToRemove = computeUnitsToRemove(swcFilesToRemove); assert unitsToAdd != null; assert unitsToRemove != null; // update the project flashProject.updateCompilationUnitsForPathChange(unitsToRemove, unitsToAdd); } /** * Find all the compilation units related to the given SWC file paths. These * compilation units will be removed from the project. This method also * removes the {@code ISWC} objects from the {@link SWCManager}. * * @param swcFilesToRemove SWC file paths * @return compilation units associated with the SWC files */ private List<ICompilationUnit> computeUnitsToRemove(final Collection<String> swcFilesToRemove) { final List<ICompilationUnit> unitsToRemove; unitsToRemove = new ArrayList<ICompilationUnit>(); for (final String swcFilePath : swcFilesToRemove) { final Collection<ICompilationUnit> compilationUnits = flashProject.getCompilationUnits(swcFilePath); // only add SWC compilation units. It's possible to get other compilation unit types here when // looking up by filename, as am EmbedCompilationUnit can have a SWC filename List<ICompilationUnit> swcCompilationUnits = new ArrayList<ICompilationUnit>(compilationUnits.size()); for (ICompilationUnit cu : compilationUnits) { switch (cu.getCompilationUnitType()) { case SWC_UNIT: case RESOURCE_UNIT: swcCompilationUnits.add(cu); break; } } unitsToRemove.addAll(swcCompilationUnits); } return unitsToRemove; } /** * Get {@link ISWC} objects for the SWC files on the library path. * {@code LibraryPathManager} does not keep a list of all the SWC model. * * @return A list of {@link ISWC}'s on the library path. */ protected ImmutableList<ISWC> getLibrarySWCs() { final ISWCManager swcManager = flashProject.getWorkspace().getSWCManager(); final ImmutableList.Builder<ISWC> builder = new ImmutableList.Builder<ISWC>(); for (final String libraryPath : libraryFilePaths.keySet()) { final File swcFile = new File(libraryPath); if (swcFile.exists()) { final ISWC swc = swcManager.get(swcFile); builder.add(swc); // ImmutableList throws exception on null element. } } return builder.build(); } /** * Invalidate a collection of SWC files on the library path. * * @param swcFiles SWC files on the library path * @return true if a library referenced by the project was invalidated */ protected boolean invalidate(Collection<File> swcFiles) { Set<String> swcFilePaths = new HashSet<String>(swcFiles.size()); for (File swcFile : swcFiles) { if (swcFile != null) { String swcFilePath = FilenameNormalization.normalize(swcFile.getPath()); if (libraryFilePaths.containsKey(swcFilePath)) { swcFilePaths.add(swcFilePath); } } } if (swcFilePaths.isEmpty()) return false; updateLibraryPath(swcFilePaths, swcFilePaths); return true; } /** * Invalidate a SWC on the library path. * * @param swc ISWC to invalidate */ protected void invalidate(ISWC swc) { String swcFilename = swc.getSWCFile().getAbsolutePath(); final Collection<ICompilationUnit> unitsToRemove = flashProject.getCompilationUnits(swcFilename); final List<ICompilationUnit> unitsToAdd = new LinkedList<ICompilationUnit>(); computeUnitsToAdd(swc, 0, unitsToAdd); // update any depending projects on this library change flashProject.getWorkspace().swcChanged(unitsToRemove, unitsToAdd, new Runnable() { @Override public final void run() { // update the project flashProject.updateCompilationUnitsForPathChange(unitsToRemove, unitsToAdd); } }); } /** * Search the library path for file entries matching the filename * @param filename Filename to search for * @return ISWCFileEntry or null if not found */ public ISWCFileEntry getFileEntryFromLibraryPath(String filename) { ImmutableList<ISWC> swcs = getLibrarySWCs(); ISWCFileEntry fileEntry = null; for (ISWC swc : swcs) { fileEntry = swc.getFile(filename); if (fileEntry != null) break; } return fileEntry; } /** * Computes the qualified name of a properties file that is in a swc and * creates a compilation unit for that. * * Example: For a properties file located at * "locale/en_US/foo/bar/core.properties" in a swc, the qualified name is * computed as "foo.bar.core". * * @param swc swc that contains the properties file * @param fileEntry file entry that points to the properties file in the swc * @return {@link ResourceBundleCompilationUnit} for the specified swc file entry. */ private ICompilationUnit createResourceBundleCompilationUnit(ISWC swc, ISWCFileEntry fileEntry) { String path = FilenameUtils.separatorsToSystem(fileEntry.getPath()); String[] segments = Iterables.toArray(Splitter.on(File.separator).split(path), String.class); //the pattern used in SWC files to store resource bundles is 'locale/{locale}/..", //therefore the segment count needs to be at least 2. if (segments.length > 2 && ResourceBundleCompilationUnit.LOCALE.equals(segments[0])) { StringBuilder qName = new StringBuilder(); for (int i = 2; i < segments.length - 1; i++) { qName.append(segments[i]); qName.append('.'); } qName.append(FilenameUtils.getBaseName(segments[segments.length - 1])); return new ResourceBundleCompilationUnit(flashProject, fileEntry, qName.toString(), segments[1]); } return null; } /** * Add {@link ICompilerProblem}'s found in the current library path to the * specified collection. * <p> * These problems are with the library path itself, not with the libraries * themselves. For example if a SWC has been deleted and no longer exists. * {@link DuplicateSourceFileProblem} problems. */ void collectProblems(Collection<ICompilerProblem> problems) { final ISWCManager swcManager = flashProject.getWorkspace().getSWCManager(); for (String swcPath : libraryFilePaths.keySet()) { final File swcFile = new File(swcPath); ISWC swc = swcManager.get(swcFile); problems.addAll(swc.getProblems()); for (ISWCLibrary library : swc.getLibraries()) { final CacheStoreKeyBase key = SWFCache.createKey(swc, library.getPath()); final ITagContainer tags = swcManager.getSWFCache().get(key); problems.addAll(tags.getProblems()); } } } /** * For debugging only. */ @Override public String toString() { StringBuilder sb = new StringBuilder(); for (String libraryFilePath : libraryFilePaths.keySet().toArray(new String[0])) { sb.append(libraryFilePath); sb.append('\n'); } return sb.toString(); } }