Version 1.1.0-dev.5.3

dart/editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/source/ExplicitPackageUriResolver.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.engine.source;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.dart.engine.AnalysisEngine;
 import com.google.dart.engine.sdk.DirectoryBasedDartSdk;
 import com.google.dart.engine.utilities.io.ProcessRunner;
 
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
 import java.io.File;
 import java.io.IOException;
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
 /**
  * An explicit package: resolver. This UriResolver shells out to pub, calling it's list-package-dirs
  * command. It parses the resulting json map, which maps symbolic package references to their
  * concrete locations on disk.
- * 
+ *
  * <pre>
- * {
- *   "packages": {
- *     "foo": "path/to/foo",
- *     "bar": "path/to/bar"
- *   },
- *   "input_files": [
- *     ...
- *   ]
- * },
- * </pre>
+ *{
+ *"packages": {
+ *"foo": "path/to/foo",
+ *"bar": "path/to/bar"
+ *},
+ *"input_files": [
+ *...
+ *]
+ *},
+ *</pre>
  */
 public class ExplicitPackageUriResolver extends UriResolver {
   /**
    * The name of the {@code package} scheme.
    */
   public static final String PACKAGE_SCHEME = "package";
 
   private static final String PUB_LIST_COMMAND = "list-package-dirs";
 
   /**
    * Return {@code true} if the given URI is a {@code package} URI.
-   * 
+   *
    * @param uri the URI being tested
    * @return {@code true} if the given URI is a {@code package} URI
    */
   public static boolean isPackageUri(URI uri) {
     return PACKAGE_SCHEME.equals(uri.getScheme());
   }
 
   private File rootDir;
   private DirectoryBasedDartSdk sdk;
-  private Map<String, List<File>> packageMap;
+  @VisibleForTesting
+  protected Map<String, List<File>> packageMap;
 
   // TODO: For now, this takes a DirectoryBasedDartSdk. We may want to abstract this out into
   // something that can return a package map.
 
   /**
    * Create a new ExplicitPackageUriResolver.
-   * 
+   *
    * @param sdk the sdk; this is used to locate the pub command to run
    * @param rootDir the directory for which we'll be resolving package information
    */
   public ExplicitPackageUriResolver(DirectoryBasedDartSdk sdk, File rootDir) {
     if (rootDir == null) {
       throw new IllegalArgumentException("the root dir must not be null");
     }
 
     this.sdk = sdk;
     this.rootDir = rootDir;
@@ skipping 53 matching lines @@
         }
       }
     }
 
     // Return a FileBasedSource that doesn't exist. This helps provide more meaningful error 
     // messages to users (a missing file error, as opposed to an invalid uri error).
 
     String fullPackagePath = pkgName + "/" + relPath;
 
     return new FileBasedSource( //
-        contentCache,
-        new File(rootDir, fullPackagePath.replace('/', File.separatorChar)),
-        UriKind.PACKAGE_URI);
+        contentCache, new File(rootDir, fullPackagePath.replace('/', File.separatorChar)), UriKind.PACKAGE_URI);
+  }
+
+  public String resolvePathToPackage(String path) {
+    if (packageMap == null) {
+      return null;
+    }
+
+    for (String key : packageMap.keySet()) {
+      List<File> files = packageMap.get(key);
+      for (File file : files) {
+        try {
+          if (file.getCanonicalPath().endsWith(path)) {
+            return key;
+          }
+        } catch (IOException e) {
+
+        }
+      }
+    }
+    return null;
   }
 
   @Override
   public URI restoreAbsolute(Source source) {
     if (packageMap == null) {
       return null;
     }
 
     if (source instanceof FileBasedSource) {
       String sourcePath = ((FileBasedSource) source).getFile().getPath();
@@ skipping 24 matching lines @@
     ProcessRunner runner = new ProcessRunner(builder);
 
     try {
       if (runner.runSync(0) == 0) {
         return parsePackageMap(runner.getStdOut());
       } else {
         AnalysisEngine.getInstance().getLogger().logInformation(
             "pub " + PUB_LIST_COMMAND + " failed: exit code " + runner.getExitCode());
       }
     } catch (IOException ioe) {
-      AnalysisEngine.getInstance().getLogger().logInformation(
-          "error running pub " + PUB_LIST_COMMAND,
-          ioe);
+      AnalysisEngine.getInstance()
+          .getLogger().logInformation("error running pub " + PUB_LIST_COMMAND, ioe);
     } catch (JSONException e) {
-      AnalysisEngine.getInstance().getLogger().logError(
-          "malformed json from pub " + PUB_LIST_COMMAND,
-          e);
+      AnalysisEngine.getInstance()
+          .getLogger().logError("malformed json from pub " + PUB_LIST_COMMAND, e);
     }
 
     return new HashMap<String, List<File>>();
   }
 
   protected Map<String, List<File>> parsePackageMap(String jsonText) throws JSONException {
     Map<String, List<File>> map = new HashMap<String, List<File>>();
 
     // Json format:
 //    {
@@ skipping 39 matching lines @@
             }
           }
         }
       }
     }
 
     return map;
   }
 
 }