Version 1.1.0-dev.5.3

dart/editor/tools/plugins/com.google.dart.tools.core/src/com/google/dart/tools/core/internal/analysis/model/ProjectImpl.java

 /*
  * Copyright (c) 2013, the Dart project authors.
- * 
+ *
  * Licensed under the Eclipse Public License v1.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.eclipse.org/legal/epl-v10.html
- * 
+ *
  * 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.google.dart.tools.core.internal.analysis.model;
 
 import com.google.dart.engine.AnalysisEngine;
 import com.google.dart.engine.context.AnalysisContext;
 import com.google.dart.engine.index.Index;
@@ skipping 42 matching lines @@
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map.Entry;
 import java.util.Set;
 
 /**
  * Represents an Eclipse project that has a Dart nature.
- * 
+ *
  * @coverage dart.tools.core.model
  */
 public class ProjectImpl extends ContextManagerImpl implements Project {
 
   public static class AnalysisContextFactory {
     public AnalysisContext createContext() {
       return AnalysisEngine.getInstance().createAnalysisContext();
     }
 
     public File[] getPackageRoots(IContainer container) {
       return ProjectImpl.getPackageRoots(
           DartCore.getPlugin(),
           CmdLineOptions.getOptions(),
           container);
     }
   }
 
   /**
    * Answer the package roots for the specified project with the given options. May return an empty
    * array if no package roots are specified either at the project level or in the command line
    * options.
-   * 
+   *
    * @param core the instance of DartCore used to access project preferences
    * @param options the command line options (not {@code null})
    * @param container the container for which package roots are to be returned
    * @return the package roots (not {@code null}, contains no {@code null}s)
    */
-  public static File[] getPackageRoots(DartCore core, CmdLineOptions options, IContainer container) {
+  public static File[] getPackageRoots(
+      DartCore core, CmdLineOptions options, IContainer container) {
     if (container instanceof IProject) {
       IEclipsePreferences prefs = core.getProjectPreferences((IProject) container);
       String setting = prefs.get(DartCore.PROJECT_PREF_PACKAGE_ROOT, "");
       if (setting != null && setting.length() > 0) {
         ArrayList<File> files = new ArrayList<File>();
         String[] paths = setting.split(File.pathSeparator);
         for (String path : paths) {
           files.add(new File(path));
         }
         return files.toArray(new File[files.size()]);
       }
 
       File packOverrideDir = options.getPackageOverrideDirectory();
       if (packOverrideDir != null) {
         File root = new File(packOverrideDir, container.getLocation().toOSString());
         return new File[] {new File(root, DartCore.PACKAGES_DIRECTORY_NAME)};
       }
 
     }
     return options.getPackageRoots();
   }
 
   /**
    * The Eclipse project associated with this Dart project (not {@code null})
    */
   private final IProject projectResource;
 
   /**
    * The project resource location on disk or {@code null} if it has not yet been initialized.
-   * 
+   *
    * @see #getResourceLocation()
    */
   private IPath projectResourceLocation;
 
   /**
    * The factory used to create new {@link AnalysisContext} (not {@code null})
    */
   private final AnalysisContextFactory factory;
 
   /**
@@ skipping 14 matching lines @@
    * no pubspec or package root is defined.
    */
   private ResourceMap defaultResourceMap;
 
   /**
    * The index which is updated when contexts are discarded (not {@code null}).
    */
   private final Index index;
 
   /**
+   * The default package resolver used for the project
+   */
+  private UriResolver defaultPackageResolver;
+
+  /**
    * Construct a new instance representing a Dart project
-   * 
+   *
    * @param resource the Eclipse project associated with this Dart project (not {@code null})
    * @param sdk the Dart SDK to use when initializing contexts (not {@code null})
    */
   public ProjectImpl(IProject resource, DartSdk sdk) {
     this(resource, sdk, DartCore.getProjectManager().getIndex(), new AnalysisContextFactory());
   }
 
   /**
    * Construct a new instance representing a Dart project
-   * 
+   *
    * @param resource the Eclipse project associated with this Dart project (not {@code null})
    * @param sdk the Dart SDK to use when initializing contexts (not {@code null})
    * @param index the index to be updated when contexts are discarded (not {@code null})
    * @param factory the factory used to construct new analysis contexts (not {@code null})
    */
   public ProjectImpl(IProject resource, DartSdk sdk, Index index, AnalysisContextFactory factory) {
     super(sdk);
     if (resource == null | factory == null | sdk == null) {
       throw new IllegalArgumentException();
     }
@@ skipping 176 matching lines @@
         return;
       }
 
       // If there is already a pubFolder, then ignore the addition
       if (getPubFolder(container.getFullPath()) != null) {
         return;
       }
 
       // Create and cache a new pub folder
       DartSdk sdk = getSdk();
-      PubFolderImpl pubFolder = new PubFolderImpl(container, createContext(container, sdk), sdk);
+      UriResolver pkgResolver = getPackageUriResolver(container, sdk, true);
+      PubFolderImpl pubFolder = new PubFolderImpl(
+          container,
+          createContext(container, sdk),
+          sdk,
+          pkgResolver);
       pubFolders.put(container.getFullPath(), pubFolder);
 
       // If this is the project, then adjust the context source factory
       if (container.getType() == PROJECT) {
         initContext(
             defaultContext,
             projectResource,
             sdk,
             getPackageUriResolver(projectResource, sdk, true));
       }
 
       // Merge any overlapping pub folders
-      for (Iterator<Entry<IPath, PubFolder>> iter = pubFolders.entrySet().iterator(); iter.hasNext();) {
+      for (Iterator<Entry<IPath, PubFolder>> iter = pubFolders.entrySet().iterator();
+          iter.hasNext();) {
         Entry<IPath, PubFolder> entry = iter.next();
         PubFolder parent = getParentPubFolder(entry.getKey());
         if (parent != null) {
           parent.getContext().mergeContext(entry.getValue().getContext());
           iter.remove();
         }
       }
     }
   }
 
@@ skipping 22 matching lines @@
             getSdk(),
             getPackageUriResolver(container, getSdk(), false));
       }
 
       // Traverse container to find pubspec files that were overshadowed by the one just removed
       createPubFolders(container);
     }
   }
 
   @Override
+  public String resolvePathToPackage(String path) {
+
+    PubFolder folder = getPubFolder(new Path(path));
+    if (folder != null) {
+      return folder.resolvePathToPackage(path);
+    } else {
+      if (defaultPackageResolver instanceof ExplicitPackageUriResolver) {
+        return ((ExplicitPackageUriResolver) defaultPackageResolver).resolvePathToPackage(path);
+      }
+    }
+    return null;
+  }
+
+  @Override
   public IFileInfo resolveUriToFileInfo(IResource relativeTo, String uri) {
 
     AnalysisContext context = getContext(relativeTo);
     Source source = context.getSourceFactory().forUri(uri);
 
     ResourceMap map = getResourceMap(relativeTo);
     if (source != null && map != null) {
       IFile resource = map.getResource(source);
       if (resource != null) {
         return new FileInfo(resource);
@@ skipping 31 matching lines @@
     } catch (Exception e) {
       name = "unknown: " + e.getMessage();
     }
     return getClass().getSimpleName() + "[" + name + "]@" + Integer.toHexString(hashCode());
   }
 
   /**
    * Answer the {@link AnalysisContext} for the specified container, creating one if necessary. Must
    * synchronize against {@link #pubFolders} before calling this method and either call
    * {@link #initialize()} or check that {@link #isInitialized()} returns {@code true}.
-   * 
+   *
    * @param container the container with sources to be analyzed (not {@code null})
    * @param sdk the Dart SDK to use when initializing the context (not {@code null})
    * @return the context (not {@code null})
    */
   private AnalysisContext createContext(IContainer container, DartSdk sdk) {
     if (container.equals(projectResource)) {
       return defaultContext;
     }
     AnalysisContext context;
     IPath location = container.getLocation();
     if (location != null) {
       SourceContainer sourceContainer = new DirectoryBasedSourceContainer(location.toFile());
       context = defaultContext.extractContext(sourceContainer);
     } else {
       logNoLocation(container);
       context = factory.createContext();
     }
     return initContext(context, container, sdk, getPackageUriResolver(container, sdk, true));
   }
 
   /**
    * Create pub folders for any pubspec files found within the specified container. Must synchronize
    * against {@link #pubFolders} before calling this method and either call {@link #initialize()} or
    * check that {@link #isInitialized()} returns {@code true}.
-   * 
+   *
    * @param container the container (not {@code null})
    */
   private void createPubFolders(IContainer container) {
     DeltaProcessor processor = new DeltaProcessor(this);
     processor.addDeltaListener(new DeltaAdapter() {
       @Override
       public void pubspecAdded(ResourceDeltaEvent event) {
         IContainer container = event.getResource().getParent();
         IPath path = container.getFullPath();
         // Pub folders do not nest, so don't create a folder if a parent folder already exists
         if (getParentPubFolder(path) == null) {
           DartSdk sdk = getSdk();
-          pubFolders.put(path, new PubFolderImpl(container, createContext(container, sdk), sdk));
+          UriResolver pkgResolver = getPackageUriResolver(container, sdk, true);
+          pubFolders.put(
+              path,
+              new PubFolderImpl(container, createContext(container, sdk), sdk, pkgResolver));
         }
       }
     });
     try {
       processor.traverse(container);
     } catch (CoreException e) {
       DartCore.logError("Failed to build pub folder mapping", e);
     }
     // Remove nested pub folders
     Iterator<Entry<IPath, PubFolder>> iter = pubFolders.entrySet().iterator();
     while (iter.hasNext()) {
       Entry<IPath, PubFolder> entry = iter.next();
       PubFolder parent = getParentPubFolder(entry.getKey());
       if (parent != null) {
         parent.getContext().mergeContext(entry.getValue().getContext());
         iter.remove();
       }
     }
   }
 
   /**
    * Answer all the {@link AnalysisContext} for this project. Must synchronize against
    * {@link #pubFolders} before calling this method and either call {@link #initialize()} or check
    * that {@link #isInitialized()} returns {@code true}.
-   * 
+   *
    * @return all the analysis contexts in the project
    */
   private AnalysisContext[] getAnalysisContexts() {
     Set<AnalysisContext> contexts = new HashSet<AnalysisContext>();
     for (PubFolder folder : getPubFolders()) {
       contexts.add(folder.getContext());
     }
     contexts.add(getDefaultContext());
     return contexts.toArray(new AnalysisContext[contexts.size()]);
   }
 
   /**
    * Find the most appropriate package resolver for the given container, based on presence of
    * pubspec, package roots etc.
-   * 
+   *
    * @return UriResolver used to resolve package: uris.
    */
   private UriResolver getPackageUriResolver(IContainer container, DartSdk sdk, boolean hasPubspec) {
 
     UriResolver pkgResolver = null;
     File[] packageRoots = factory.getPackageRoots(container);
     File[] packagesDirs = null;
     if (hasPubspec) {
       IPath location = container.getLocation();
       if (location != null) {
@@ skipping 11 matching lines @@
           (DirectoryBasedDartSdk) sdk,
           container.getLocation().toFile());
     }
     return pkgResolver;
   }
 
   /**
    * Find the {@link PubFolder} defined for an ancestor. Must synchronize against
    * {@link #pubFolders} before calling this method and either call {@link #initialize()} or check
    * that {@link #isInitialized()} returns {@code true}.
-   * 
+   *
    * @param path the resource's full path
    * @return the containing pub folder or {@code null} if none
    */
   private PubFolder getParentPubFolder(IPath path) {
     return path.segmentCount() > 1 ? getPubFolder(path.removeLastSegments(1)) : null;
   }
 
   /**
    * Answer the {@link PubFolder} for the specified resource path. Must synchronize against
    * {@link #pubFolders} before calling this method and either call {@link #initialize()} or check
    * that {@link #isInitialized()} returns {@code true}.
-   * 
+   *
    * @param path the resource full path (not {@code null})
    * @return the folder or {@code null} if none is found
    */
   private PubFolder getPubFolder(IPath path) {
     if (pubFolders.size() == 0) {
       return null;
     }
     for (int count = path.segmentCount() - 1; count >= 0; count--) {
       PubFolder pubFolder = pubFolders.get(path.removeLastSegments(count));
       if (pubFolder != null) {
@@ skipping 10 matching lines @@
     if (projectResourceLocation == null) {
       projectResourceLocation = projectResource.getLocation();
     }
     return projectResourceLocation;
   }
 
   /**
    * Initialize the context for analyzing sources in the specified directory. Must synchronize
    * against {@link #pubFolders} before calling this method and either call {@link #initialize()} or
    * check that {@link #isInitialized()} returns {@code true}.
-   * 
+   *
    * @param context the context to be initialized (not {@code null})
    * @param container the container with sources to be analyzed
    * @param sdk the Dart SDK to use when initializing the context (not {@code null})
    * @param hasPubspec {@code true} if the container has a pubspec file
    * @return the context (not {@code null})
    */
-  private AnalysisContext initContext(AnalysisContext context, IContainer container, DartSdk sdk,
-      UriResolver pkgResolver) {
+  private AnalysisContext initContext(
+      AnalysisContext context, IContainer container, DartSdk sdk, UriResolver pkgResolver) {
     DartUriResolver dartResolver = new DartUriResolver(sdk);
 
     FileUriResolver fileResolver = new FileUriResolver();
 
     SourceFactory sourceFactory;
 
     if (pkgResolver != null) {
       sourceFactory = new SourceFactory(dartResolver, pkgResolver, fileResolver);
     } else {
       logNoLocation(container);
@@ skipping 14 matching lines @@
 
   /**
    * Initialize {@link #pubFolders} and {@link #defaultContext} if not already been initialized.
    * Must synchronize against {@link #pubFolders} before calling this method.
    */
   private void initialize() {
     if (isInitialized()) {
       return;
     }
     boolean hasPubspec = projectResource.getFile(PUBSPEC_FILE_NAME).exists();
+    defaultPackageResolver = getPackageUriResolver(projectResource, getSdk(), hasPubspec);
     defaultContext = initContext(
         factory.createContext(),
         projectResource,
         getSdk(),
-        getPackageUriResolver(projectResource, getSdk(), hasPubspec));
+        defaultPackageResolver);
     defaultResourceMap = new SimpleResourceMapImpl(projectResource, defaultContext);
     createPubFolders(projectResource);
   }
 
   /**
    * Answer true if {@link #defaultContext} and {@link #pubFolders} have been initialized. Must
    * synchronize against {@link #pubFolders} before calling this method.
-   * 
+   *
    * @return {@code true} if initialized, else {@code false}
    */
   private boolean isInitialized() {
     return defaultContext != null;
   }
 
   private void logNoLocation(IContainer container) {
     DartCore.logInformation("No location for " + container);
   }
 }