/*
* Copyright (c) 2012, 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;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.dart.engine.AnalysisEngine;
import com.google.dart.engine.error.ErrorCode;
import com.google.dart.engine.index.Index;
import com.google.dart.engine.index.IndexFactory;
import com.google.dart.engine.index.IndexStore;
import com.google.dart.engine.sdk.DirectoryBasedDartSdk;
import com.google.dart.engine.utilities.instrumentation.Instrumentation;
import com.google.dart.engine.utilities.instrumentation.InstrumentationBuilder;
import com.google.dart.engine.utilities.logging.Logger;
import com.google.dart.server.generated.AnalysisServer;
import com.google.dart.server.internal.remote.DebugPrintStream;
import com.google.dart.server.internal.remote.RemoteAnalysisServerImpl;
import com.google.dart.server.internal.remote.StdioServerSocket;
import com.google.dart.server.utilities.logging.Logging;
import com.google.dart.tools.core.analysis.model.AnalysisServerData;
import com.google.dart.tools.core.analysis.model.ProjectManager;
import com.google.dart.tools.core.analysis.model.PubFolder;
import com.google.dart.tools.core.internal.MessageConsoleImpl;
import com.google.dart.tools.core.internal.OptionManager;
import com.google.dart.tools.core.internal.analysis.model.AnalysisServerDataImpl;
import com.google.dart.tools.core.internal.analysis.model.DartProjectManager;
import com.google.dart.tools.core.internal.analysis.model.ProjectManagerImpl;
import com.google.dart.tools.core.internal.analysis.model.WorkspaceAnalysisServerListener;
import com.google.dart.tools.core.internal.builder.AnalysisMarkerManager;
import com.google.dart.tools.core.internal.model.DartIgnoreManager;
import com.google.dart.tools.core.internal.model.DartProjectNature;
import com.google.dart.tools.core.internal.util.Extensions;
import com.google.dart.tools.core.internal.util.ResourceUtil;
import com.google.dart.tools.core.internal.util.Util;
import com.google.dart.tools.core.jobs.CleanLibrariesJob;
import com.google.dart.tools.core.model.DartIgnoreListener;
import com.google.dart.tools.core.model.DartSdkListener;
import com.google.dart.tools.core.model.DartSdkManager;
import com.google.dart.tools.core.pub.PubCacheManager_NEW;
import com.google.dart.tools.core.utilities.general.StringUtilities;
import com.google.dart.tools.core.utilities.io.FileUtilities;
import com.google.dart.tools.core.utilities.performance.PerformanceManager;
import com.google.dart.tools.core.utilities.yaml.PubYamlUtils;
import org.apache.commons.lang3.StringUtils;
import org.dartlang.analysis.server.protocol.RequestError;
import org.dartlang.analysis.server.protocol.ServerService;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceVisitor;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ProjectScope;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.ILog;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.content.IContentType;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Version;
import org.osgi.service.prefs.BackingStoreException;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.management.ManagementFactory;
import java.net.ServerSocket;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.List;
import java.util.Properties;
/**
* The class <code>DartCore</code> is used to access the elements modeling projects that have a Dart
* nature.
*
* @coverage dart.tools.core
*/
public class DartCore extends Plugin implements DartSdkListener {
/**
* The unique instance of this class.
*/
private static DartCore PLUG_IN;
/**
* The log used by {@link #logError(String)} and other local methods for logging errors, warnings,
* and information or <code>null</code> to use the default system log.
*/
private static ILog PLUGIN_LOG;
/**
* Flag indicating whether instrumentation logging of errors is enabled
*/
private static boolean instrumentationLogErrorEnabled = true;
/**
* The id of the plug-in that defines the Dart model.
*/
public static final String PLUGIN_ID = DartCore.class.getPackage().getName();
/**
* Name of file containing user-defined properties.
*/
public static final String EDITOR_PROPERTIES = "editor.properties";
/**
* The id of the project nature used for Dart projects.
*/
public static final String DART_PROJECT_NATURE = PLUGIN_ID + ".dartNature";
/**
* The id of the builder used for Dart projects.
*/
public static final String DART_BUILDER_ID = PLUGIN_ID + ".dartBuilder";
/**
* The id of the content type used to represent Dart compilation units.
*/
public static final String DART_SOURCE_CONTENT_TYPE = PLUGIN_ID + ".dartSourceFile";
/**
* Eclipse problem marker type used to display Dart compilation errors.
*/
public static final String DART_PROBLEM_MARKER_TYPE = PLUGIN_ID + ".problem";
/**
* Eclipse problem marker type used to display Dart hints.
*/
public static final String DART_HINT_MARKER_TYPE = PLUGIN_ID + ".hint";
/**
* Eclipse problem marker type used to display todo markers.
*/
public static final String DART_TASK_MARKER_TYPE = PLUGIN_ID + ".task";
/**
* Eclipse problem marker type used to Angular warning markers
*/
public static final String ANGULAR_WARNING_MARKER_TYPE = PLUGIN_ID + ".angular_warning";
/**
* Correction marker attribute.
*/
public static final String MARKER_ATTR_CORRECTION = "correction";
/**
* Extension for single unit compiled into JavaScript.
*/
public static final String EXTENSION_JS = "js";
/**
* Preference for automatically running pub.
*/
public static final String PUB_AUTO_RUN_PREFERENCE = "pubAutoRun";
/**
* Preference for pub global arguments.
*/
public static final String PUB_GLOBAL_ARGS_PREFERENCE = "pubGlobalArgs";
/**
* Preference for enabling hints.
*/
public static final String ENABLE_HINTS_PREFERENCE = "enableHints";
/**
* Preference for enabling lints.
*/
public static final String ENABLE_LINTS_PREFERENCE = "enableLints";
/**
* Preference for enabling dart2js related hints.
*/
public static final String ENABLE_HINTS_DART2JS_PREFERENCE = "enableHints_dart2js";
public static final String PROJECT_PREF_PACKAGE_ROOT = "projectPackageRoot";
/**
* Project package root for VM launches
*/
public static final String PROJECT_PREF_VM_PACKAGE_ROOT = "projectVmPackageRoot";
public static final String PREFS_DART2JS_FLAGS = "dart2jsFlags";
/**
* Preference for specifying location of the Dart SDK.
*/
public static final String PREFS_SDK_LOCATION = "sdkLocation";
/**
* Preference for specifying location of Dartium
*/
public static final String PREFS_DARTIUM_LOCATION = "dartiumLocation";
/**
* Preference to control if "not a member" warnings should be reported for inferred types.
*/
public static final String TYPE_CHECKS_FOR_INFERRED_TYPES = "typeChecksForInferredTypes";
public static final String PROJECT_PREF_DISABLE_DART_BASED_BUILDER = "disableDartBasedBuilder";
/**
* Preference for enabling usage collection
*/
public static final String PREFS_ENABLE_ANALYTICS = "enableAnalytics";
public static final String PREFS_SHOW_ANALYTICS_DIALOG = "showAnalyticsDialog";
// white listed dirs that can be used for pub build
public static final List<String> pubDirectories = Arrays.asList(
"assest",
"benchmark",
"bin",
"example",
"test",
"web");
/**
* Cached extensions for CSS files.
*/
private static final String[] CSS_FILE_EXTENSIONS = {"css"};
/**
* Cached extensions for HTML files.
*/
private static final String[] HTML_FILE_EXTENSIONS = {"html", "htm"};
/**
* Cached extensions for JS files.
*/
private static final String[] JS_FILE_EXTENSIONS = {"js"};
/**
* Cached extensions for TXT files.
*/
private static final String[] TXT_FILE_EXTENSIONS = {"txt"};
/**
* Cached extensions for files that are generated by the dartc compiler.
*/
private static final String[] DART_GENERATED_FILE_EXTENSIONS = {"api", "deps", "js", "map"};
/**
* Cached extensions for image files.
*/
public static final String[] IMAGE_FILE_EXTENSIONS = {
"bmp", "gif", "jpeg", "jpg", "png", "raw", "thm", "tif", "tiff"};
/**
* Name of directory for packages installed by pub
*/
public static final String PACKAGES_DIRECTORY_NAME = "packages";
/**
* Name of directory for build artifacts generated by pub
*/
public static final String BUILD_DIRECTORY_NAME = "build";
/**
* Name of "lib" directory in package
*/
public static final String LIB_DIRECTORY_NAME = "lib";
/**
* Path string for packages directory, uses "/" as path separator, equals "/packages/".
*/
public static final String PACKAGES_DIRECTORY_PATH = "/" + PACKAGES_DIRECTORY_NAME + "/";
/**
* Path string for packages directory in a url.
*/
public static final String PACKAGES_DIRECTORY_URL = "/" + PACKAGES_DIRECTORY_NAME + "/";
public static final String PACKAGE_SCHEME_SPEC = "package:";
/**
* Path string for lib directory in a url.
*/
public static final String LIB_URL_PATH = "/lib/";
/**
* Name of pubspec file
*/
public static final String PUBSPEC_FILE_NAME = "pubspec.yaml";
/**
* Name of special pubspec lock file
*/
public static final String PUBSPEC_LOCK_FILE_NAME = "pubspec.lock";
/**
* The name of the build.dart special file.
*/
public static final String BUILD_DART_FILE_NAME = "build.dart";
/**
* Used by the {@link DartDebugUserAgentManager} to indicate whether the allow remote connection
* dialog is open.
*/
public static boolean allowConnectionDialogOpen = false;
/**
* The shared message console instance.
*/
private static final MessageConsole CONSOLE = new MessageConsoleImpl();
/**
* The QualifiedName for a resource remapping (a.foo ==> a.bar).
*/
private static final QualifiedName RESOURCE_REMAP_NAME = new QualifiedName(
PLUGIN_ID,
"resourceRemap");
/**
* The QualifiedName for the package version.
*/
public static final QualifiedName PUB_PACKAGE_VERSION = new QualifiedName(
DartCore.PLUGIN_ID,
"pub.package.version");
/**
* The QualifiedName for library names.
*/
public static final QualifiedName LIBRARY_NAME = new QualifiedName(
DartCore.PLUGIN_ID,
"libraryName");
/**
* The unique project manager used for analysis of anything in the workspace
*/
private static ProjectManager projectManager;
/**
* Used to synchronize access to {@link #projectManager}.
*/
private static final Object projectManagerLock = new Object();
/**
* The unique {@link AnalysisServer} used for analysis of anything in the workspace.
*/
private static AnalysisServer analysisServer;
/**
* The unique {@link AnalysisServerDataImpl} instance.
*/
private static AnalysisServerDataImpl analysisServerDataImpl = new AnalysisServerDataImpl();
/**
* The unique {@link WorkspaceAnalysisServerListener} instance.
*/
private static WorkspaceAnalysisServerListener analysisServerListener;
/**
* Used to synchronize access to {@link #analysisServer}.
*/
private static final Object analysisServerLock = new Object();
/**
* Add the given listener for dart ignore changes to the Dart Model. Has no effect if an identical
* listener is already registered.
*
* @param listener the listener to add
*/
public static void addIgnoreListener(DartIgnoreListener listener) {
getIgnoreManager().addListener(listener);
}
/**
* Add the given resource to the set of ignored resources.
*
* @param resource the resource to ignore
* @throws IOException if there was an error accessing the ignore file
* @throws CoreException if there was an error deleting markers
*/
public static void addToIgnores(IResource resource) throws IOException, CoreException {
getIgnoreManager().addToIgnores(resource);
}
/**
* Remove any resource mapping for the given container.
*
* @param resource
*/
public static void clearResourceRemapping(IContainer container) {
try {
container.accept(new IResourceVisitor() {
@Override
public boolean visit(IResource resource) throws CoreException {
if (resource instanceof IFile) {
clearResourceRemapping((IFile) resource);
return true;
} else if (resource instanceof IContainer) {
IContainer childContainer = (IContainer) resource;
if (childContainer.getName().startsWith(".")) {
return false;
} else {
return true;
}
} else {
return false;
}
}
});
} catch (CoreException e) {
DartCore.logError(e);
}
}
/**
* Remove any resource mapping for the given file.
*
* @param resource
*/
public static void clearResourceRemapping(IFile resource) {
if (getResourceRemapping(resource) != null) {
setResourceRemapping(resource, null);
}
}
/**
* Return true if directory contains a "packages" directory that is installed by pub
*/
public static boolean containsPackagesDirectory(File file) {
return new File(file, PACKAGES_DIRECTORY_NAME).isDirectory();
}
/**
* Return <code>true</code> if the directory contains a "pubspec.yaml" file
*/
public static boolean containsPubspecFile(File directory) {
return new File(directory, PUBSPEC_FILE_NAME).isFile();
}
/**
* Find and return an unused server socket port.
*/
public static int findUnusedPort() {
try {
ServerSocket ss = new ServerSocket(0);
int port = ss.getLocalPort();
ss.close();
return port;
} catch (IOException ioe) {
//$FALL-THROUGH$
}
return -1;
}
/**
* Return an array of analysis server arguments.
*
* @return a non-null array of arguments
*/
public static String[] getAdditionalAnalysisServerArguments() {
String value = getUserDefinedProperty(ANALYSIS_SERVER_ARG_PROP_KEY);
if (value == null) {
return StringUtilities.EMPTY_ARRAY;
}
return value.split(",");
}
/**
* Return an list of Dart VM arguments for analysis server.
*
* @return a non-null array of arguments
*/
public static String[] getAdditionalAnalysisServerVmArguments() {
String value = getUserDefinedProperty(ANALYSIS_SERVER_VM_ARG_PROP_KEY);
if (value == null) {
return StringUtilities.EMPTY_ARRAY;
}
return value.split(",");
}
/**
* Answer the unique {@link AnalysisServer} used for analysis of anything in the workspace.
*
* @return the {@link AnalysisServer}
*/
public static AnalysisServer getAnalysisServer() {
synchronized (analysisServerLock) {
if (analysisServer == null) {
DartSdkManager sdkManager = DartSdkManager.getManager();
if (!sdkManager.hasSdk()) {
DartCore.logError("Add the dart sdk (com.google.dart.sdk) as a JVM argument");
return null;
}
boolean isRunningFromSource = false;
String runtimePath = sdkManager.getSdk().getVmExecutable().getAbsolutePath();
String analysisServerPath = DartCoreDebug.ANALYSIS_SERVER_PATH;
if (StringUtils.isEmpty(analysisServerPath)) {
String svnRoot = System.getProperty("com.google.dart.svnRoot");
if (svnRoot == null) {
File analysisServerSnapshot = new File(
DartSdkManager.getManager().getSdk().getDirectory(),
"bin/snapshots/analysis_server.dart.snapshot");
analysisServerPath = analysisServerSnapshot.getAbsolutePath();
if (!analysisServerSnapshot.exists()) {
DartCore.logError("Analysis Server snapshot was not found in "
+ analysisServerSnapshot.getAbsolutePath() + ", SDK is corrupt.");
return null;
}
} else {
analysisServerPath = svnRoot + "/pkg/analysis_server/bin/server.dart";
isRunningFromSource = true;
}
} else {
isRunningFromSource = true;
}
String packageRoot = System.getProperty("com.google.dart.packageRoot");
if (packageRoot == null && isRunningFromSource) {
DartCore.logError("To run analysis server from source, a package root must be "
+ "supplied using -Dcom.google.dart.packageRoot.");
return null;
}
try {
// VM arguments
List<String> additionalVmArguments = Lists.newArrayList(DartCore.getAdditionalAnalysisServerVmArguments());
additionalVmArguments.add("--package-root=" + packageRoot);
if (DartCoreDebug.ANALYSIS_SERVER_DEBUG) {
int debugPort = findUnusedPort();
Logging.getLogger().logInformation("Analysis server debug port " + debugPort);
additionalVmArguments.add("--debug:" + debugPort);
}
if (DartCoreDebug.ANALYSIS_SERVER_PROFILE) {
additionalVmArguments.add("--observe");
additionalVmArguments.add("--pause-isolates-on-exit");
additionalVmArguments.add("--code_comments");
additionalVmArguments.add("--collect-code=false");
}
// Server arguments
List<String> additionalArguments = Lists.newArrayList(DartCore.getAdditionalAnalysisServerArguments());
// prepare debug stream
DebugPrintStream debugStream;
{
String logPath = DartCoreDebug.ANALYSIS_SERVER_LOG_FILE;
if (StringUtils.isBlank(logPath)) {
debugStream = null;
} else if ("console".equals(logPath)) {
debugStream = new DebugPrintStream() {
@Override
public void println(String s) {
if (s.length() > 1000) {
s = s.substring(0, 1000) + "...";
}
System.out.println(s);
}
};
} else {
@SuppressWarnings("resource")
final PrintStream fileStream = new PrintStream(logPath);
debugStream = new DebugPrintStream() {
@Override
public void println(String s) {
fileStream.println(s);
}
};
}
}
// additional options
if (DartCoreDebug.ANALYSIS_SERVER_INCREMENTAL_RESOLUTION_API) {
additionalArguments.add("--enable-incremental-resolution-api");
}
if (DartCoreDebug.ANALYSIS_SERVER_NEW_TASK_MODEL) {
additionalArguments.add("--enable-new-task-model");
}
{
String log = DartCoreDebug.ANALYSIS_SERVER_INCREMENTAL_RESOLUTION_LOG;
if (!StringUtils.isEmpty(log)) {
additionalArguments.add("--incremental-resolution-log=" + log);
}
}
if (DartCoreDebug.ANALYSIS_SERVER_INCREMENTAL_RESOLUTION_VALIDATION) {
additionalArguments.add("--incremental-resolution-validation");
}
{
String log = DartCoreDebug.ANALYSIS_SERVER_INSTRUMENTATION_LOG_FILE;
if (!StringUtils.isEmpty(log)) {
log = log.trim();
if (log.length() > 0) {
additionalArguments.add("--instrumentation-log-file=" + log);
}
}
}
if (DartCoreDebug.ANALYSIS_SERVER_PRINT_TO_CONSOLE) {
additionalArguments.add("--internal-print-to-console");
}
additionalArguments.add("--useAnalysisHighlight2");
// HTTP port
int httpPort = 0;
if (DartCoreDebug.ANALYSIS_SERVER_HTTP_PORT != null
&& !DartCoreDebug.ANALYSIS_SERVER_HTTP_PORT.isEmpty()) {
try {
httpPort = Integer.parseInt(DartCoreDebug.ANALYSIS_SERVER_HTTP_PORT);
additionalArguments.add("--port=" + httpPort);
Logging.getLogger().logInformation("Analysis server http port " + httpPort);
} catch (NumberFormatException e) {
DartCore.logError("Analysis server HTTP port must be an integer.");
return null;
}
}
// create server, if "com.google.dart.svnRoot" flag was not set then use snapshot
StdioServerSocket socket = new StdioServerSocket(
runtimePath,
additionalVmArguments,
analysisServerPath,
additionalArguments,
debugStream);
if (isPluginsBuild()) {
// plugin mode
socket.setClientId("org.dartlang.dartplugin");
} else {
// editor mode
socket.setClientId("org.dartlang.darteditor");
}
socket.setClientVersion(getVersion());
// start server
analysisServer = new RemoteAnalysisServerImpl(socket);
analysisServerDataImpl.setServer(analysisServer);
analysisServerListener = new WorkspaceAnalysisServerListener(
analysisServerDataImpl,
new DartProjectManager(
ResourcesPlugin.getWorkspace().getRoot(),
analysisServer,
DartIgnoreManager.getInstance()));
analysisServer.addAnalysisServerListener(analysisServerListener);
analysisServer.start();
analysisServer.server_setSubscriptions(ImmutableList.of(ServerService.STATUS));
analysisServerDataImpl.updateOptions();
} catch (Throwable e) {
DartCore.logError("Enable to start stdio server", e);
return null;
}
}
}
return analysisServer;
}
/**
* Answer the unique {@link AnalysisServerData} used to provide analysis information in the
* workspace.
*
* @return the {@link AnalysisServerData} (not {@code null})
*/
public static AnalysisServerData getAnalysisServerData() {
getAnalysisServer();
return analysisServerDataImpl;
}
/**
* Answer the application directory (a directory contains a "packages" directory and a
* "pubspec.yaml" file) directly or indirectly containing the specified file or the file itself if
* it is an application directory.
*
* @param libFileOrDir the library file or directory
* @return the context in which the specified library should be analyzed (not <code>null</code>)
*/
public static File getApplicationDirectory(File file) {
while (file != null) {
if (isApplicationDirectory(file)) {
return file;
}
file = file.getParentFile();
}
return null;
}
/**
* Answer the application directory (a directory that contains a "packages" directory and a
* "pubspec.yaml" file) directly or indirectly containing the specified resource or the resource
* itself if it is an application directory.
*
* @param resource the file or directory
* @return the directory with the pubspec for the given file
*/
public static IContainer getApplicationDirectory(IResource resource) {
IContainer container;
if (resource instanceof IFile) {
container = resource.getParent();
} else {
container = (IContainer) resource;
}
while (container != null) {
if (isApplicationDirectory(container)) {
return container;
}
container = container.getParent();
}
return null;
}
/**
* Returns the day (yyyy-MM-dd) the product was built.
*/
public static String getBuildDate() {
return "@BUILDDATE@";
}
/**
* Returns the SVN revision number as a String.
*/
public static String getBuildId() {
return "@REVISION@";
}
/**
* Return a unique token that can be used to determine whether cached data that changes only when
* the version of the editor changes is still valid.
*
* @return a token used to determine the validity of cached data
*/
public static String getBuildIdOrDate() {
String buildIdOrDate = getBuildId();
if (buildIdOrDate.startsWith("@")) {
buildIdOrDate = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
}
return buildIdOrDate;
}
/**
* Returns the shared message console. Unlike the log ({@link DartCore#getLog()}), the console is
* intended for communication with the end-user.
*
* @return the message console
*/
public static MessageConsole getConsole() {
return CONSOLE;
}
/**
* Return the list of known Dart-like file extensions. Dart-like extensions are defined in the
* {@link Platform.getContentManager() content type manager} for the
* {@link #DART_SOURCE_CONTENT_TYPE}. Note that a Dart-like extension does not include the leading
* dot, and that the "dart" extension is always defined as a Dart-like extension.
*
* @return the list of known Dart-like file extensions
*/
public static String[] getDartLikeExtensions() {
IContentType dartContentType = Platform.getContentTypeManager().getContentType(
DART_SOURCE_CONTENT_TYPE);
HashSet<String> extensionSet = new HashSet<String>();
for (IContentType contentType : Platform.getContentTypeManager().getAllContentTypes()) {
if (contentType.isKindOf(dartContentType)) {
for (String extension : contentType.getFileSpecs(IContentType.FILE_EXTENSION_SPEC)) {
extensionSet.add(extension);
}
}
}
extensionSet.remove(Extensions.DART);
ArrayList<String> extensionList = new ArrayList<String>(extensionSet);
extensionList.add(0, Extensions.DART);
return extensionList.toArray(new String[extensionList.size()]);
}
/**
* Returns all existing and open workspace Dart projects.
*/
public static IProject[] getDartProjects() {
List<IProject> dartProjects = Lists.newArrayList();
IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
for (IProject project : projects) {
if (!project.isAccessible()) {
continue;
}
if (!DartProjectNature.hasDartNature(project)) {
continue;
}
if (PubCacheManager_NEW.isPubCacheProject(project)) {
continue;
}
dartProjects.add(project);
}
return dartProjects.toArray(new IProject[dartProjects.size()]);
}
/**
* Return a table of all known configurable options with their default values. These options allow
* to configure the behavior of the underlying components. The client may safely use the result as
* a template that they can modify and then pass to {@link #setOptions()}</code>.
* <p>
* Helper constants have been defined on DartPreferenceConstants for each of the option IDs
* (categorized in Code assist option ID, Compiler option ID and Core option ID) and some of their
* acceptable values (categorized in Option value). Some options accept open value sets beyond the
* documented constant values.
* <p>
* Note: each release may add new options.
*
* @return a table of all known configurable options with their default values
*/
public static Hashtable<String, String> getDefaultOptions() {
return null;
}
public static File getEclipseInstallationDirectory() {
return new File(Platform.getInstallLocation().getURL().getFile());
}
/**
* Return the workspace root default charset encoding.
*
* @return the name of the default charset encoding for the workspace root
*/
public static String getEncoding() {
try {
return ResourcesPlugin.getWorkspace().getRoot().getDefaultCharset();
} catch (IllegalStateException exception) {
// happen when there's no workspace (see bug
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=216817)
// or when it is shutting down (see bug
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=60687)
return System.getProperty("file.encoding"); //$NON-NLS-1$
} catch (CoreException exception) {
// fails silently and return plugin global encoding if core exception
// occurs
}
return ResourcesPlugin.getEncoding();
}
/**
* Extract {@link ErrorCode} form the given {@link IMarker}.
*
* @return the {@link ErrorCode}, may be {@code null}.
*/
public static ErrorCode getErrorCode(IMarker marker) {
return AnalysisMarkerManager.getErrorCode(marker);
}
/**
* Return the DartIgnoreManager
*/
public static DartIgnoreManager getIgnoreManager() {
if (DartCoreDebug.ENABLE_ANALYSIS_SERVER) {
return DartIgnoreManager.getInstance();
} else {
return getProjectManager().getIgnoreManager();
}
}
/**
* Utility method for returning one option value only. Equivalent to
* <code>DartCore.getOptions().get(optionName)</code> Note that it may answer <code>null</code> if
* this option does not exist.
* <p>
* Helper constants have been defined on DartPreferenceConstants for each of the option IDs
* (categorized in Code assist option ID, Compiler option ID and Core option ID) and some of their
* acceptable values (categorized in Option value). Some options accept open value sets beyond the
* documented constant values.
* <p>
* Note: each release may add new options.
*
* @param optionName the name of the option whose value is to be returned
* @return the value of a given option
*/
public static String getOption(String optionName) {
return OptionManager.getInstance().getOption(optionName);
}
/**
* Return the table of the current options. Initially, all options have their default values, and
* this method returns a table that includes all known options.
* <p>
* Helper constants have been defined on DartPreferenceConstants for each of the option IDs
* (categorized in Code assist option ID, Compiler option ID and Core option ID) and some of their
* acceptable values (categorized in Option value). Some options accept open value sets beyond the
* documented constant values.
* <p>
* Note: each release may add new options.
* <p>
* Returns a default set of options even if the platform is not running.
* </p>
*
* @return table of current settings of all options (key type: <code>String</code>; value type:
* <code>String</code>)
*/
public static HashMap<String, String> getOptions() {
return OptionManager.getInstance().getOptions();
}
/**
* Return the unique instance of this class.
*
* @return the unique instance of this class
*/
public static DartCore getPlugin() {
return PLUG_IN;
}
/**
* Answer the unique project manager used for analysis of anything in the workspace.
*
* @return the manager (not {@code null})
*/
public static ProjectManager getProjectManager() {
synchronized (projectManagerLock) {
if (projectManager == null) {
// start index
final Index index;
{
File stateDir = getPlugin().getStateLocation().toFile();
File indexDir = new File(stateDir, "index");
indexDir.mkdirs();
IndexStore indexStore = IndexFactory.newFileIndexStore(indexDir);
index = IndexFactory.newIndex(indexStore);
Thread thread = new Thread() {
@Override
public void run() {
index.run();
}
};
thread.setName("Index Thread");
thread.setDaemon(true);
thread.start();
}
// create ProjectManagerImpl
projectManager = new ProjectManagerImpl(
ResourcesPlugin.getWorkspace().getRoot(),
DartSdkManager.getManager().getSdk(),
DartSdkManager.getManager().getSdkContextId(),
index,
DartIgnoreManager.getInstance());
}
}
return projectManager;
}
/**
* @return the mapping for the given resource, if any
*/
public static String getResourceRemapping(IFile originalResource) {
try {
return originalResource.getPersistentProperty(RESOURCE_REMAP_NAME);
} catch (CoreException e) {
return null;
}
}
/**
* Returns the name of the directory in packages that is linked to the "lib" folder in the project
*
* @param project
* @return the name of the directory, <code>null</code> if there is no self linked packages folder
*/
public static String getSelfLinkedPackageName(IResource resource) {
String packageName = null;
try {
IContainer appFolder = getApplicationDirectory(resource);
if (appFolder != null) {
IResource pubspec = appFolder.findMember(DartCore.PUBSPEC_FILE_NAME);
if (pubspec != null) {
String contents = FileUtilities.getContents(pubspec.getLocation().toFile(), "UTF-8");
if (contents != null) {
String name = PubYamlUtils.getPubspecName(contents);
if (name != null) {
return name;
}
}
}
}
} catch (Exception e) {
}
return packageName;
}
/**
* Returns the path string for the default dart directory - user.home/dart
*
* @return the name of the user.home/dart directory
*/
public static String getUserDefaultDartFolder() {
String defaultLocation = System.getProperty("user.home"); //$NON-NLS-1$
return defaultLocation + File.separator + "dart" + File.separator; //$NON-NLS-1$
}
/**
* Returns the current value of the string-valued user-defined property with the given name.
* Returns <code>null</code> if there is no user-defined property with the given name.
* <p>
* User-defined properties are defined in the <code>editor.properties</code> file located in the
* eclipse installation directory.
*
* @see DartCore#getEclipseInstallationDirectory()
* @param name the name of the property
* @return the string-valued property
*/
public static String getUserDefinedProperty(String key) {
Properties properties = new Properties();
File installDirectory = getEclipseInstallationDirectory();
File file = new File(installDirectory, EDITOR_PROPERTIES);
if (file.exists()) {
try {
properties.load(new FileReader(file));
} catch (FileNotFoundException e) {
logError(e);
} catch (IOException e) {
logError(e);
}
}
return properties.getProperty(key);
}
/**
* @return the version text for this plugin (i.e. 1.1.0)
*/
public static String getVersion() {
Version version = getPlugin().getBundle().getVersion();
return version.getMajor() + "." + version.getMinor() + "." + version.getMicro();
}
public static boolean is32Bit() {
return Platform.getOSArch().indexOf("64") == -1;
}
/**
* Return <code>true</code> if the given resource should be analyzed. All resources are to be
* analyzed unless they have been excluded.
*
* @param resource the resource being tested
* @return <code>true</code> if the given resource should be analyzed
*/
public static boolean isAnalyzed(IResource resource) {
return getIgnoreManager().isAnalyzed(resource);
}
/**
* Return true if directory contains a "packages" directory and a "pubspec.yaml" file
*/
public static boolean isApplicationDirectory(File directory) {
return containsPubspecFile(directory);
}
/**
* Return true if directory contains a "packages" directory and a "pubspec.yaml" file
*/
public static boolean isApplicationDirectory(IContainer container) {
if (container.getLocation() == null) {
return false;
}
File directory = container.getLocation().toFile();
return isApplicationDirectory(directory);
}
/**
* Answer {@code true} if the specified resource is a build.dart file and exists either in a
* project or in a folder containing a pubspec file.
*
* @param file the file
* @return {@code true} if the file is a build.dart file that will be run by the builder
*/
public static boolean isBuildDart(IFile file) {
if (file == null || !file.getName().equals(BUILD_DART_FILE_NAME) || !file.exists()) {
return false;
}
IContainer container = file.getParent();
// Always run build.dart in a project's root.
if (container.getType() == IResource.PROJECT) {
return true;
}
return container.getFile(new Path(PUBSPEC_FILE_NAME)).exists();
}
/**
* Return true if directory is one that is generated by pub build
*
* @param folder the folder to be checked
* @return <code>true</code> if folder name matches and is sibling of pubspec.yaml
*/
public static boolean isBuildDirectory(IFolder folder) {
IPath location = folder.getLocation();
if (location != null && folder.getName().equals(BUILD_DIRECTORY_NAME)) {
if (folder.getParent().findMember(PUBSPEC_FILE_NAME) != null) {
return true;
}
}
return false;
}
/**
* Return <code>true</code> if the given file is contained in the packages directory created by
* pub
*
* @param file the file that is to be checked
* @return <code>true</code> if the given file is in packages
*/
public static boolean isContainedInPackages(File file) {
if (file.getAbsolutePath().contains(PACKAGES_DIRECTORY_NAME)) {
return true;
}
return false;
}
/**
* Return <code>true</code> if the given file is contained in the packages directory created by
* pub
*
* @param file the file that is to be checked
* @return <code>true</code> if the given file is in packages
*/
public static boolean isContainedInPackages(IFile file) {
return file.getFullPath().toString().contains(DartCore.PACKAGES_DIRECTORY_PATH);
}
/**
* Return <code>true</code> if the given file name's extension is an CSS-like extension.
*
* @param fileName the file name being tested
* @return <code>true</code> if the given file name's extension is an CSS-like extension
*/
public static boolean isCssLikeFileName(String fileName) {
return isLikeFileName(fileName, CSS_FILE_EXTENSIONS);
}
/**
* Return <code>true</code> if the given file name's extension is a generated Dart like extension.
*
* @return <code>true</code> if the given file name's extension is a generated Dart like extension
*/
public static boolean isDartGeneratedFile(String fileName) {
return isLikeFileName(fileName, DART_GENERATED_FILE_EXTENSIONS);
}
/**
* Return <code>true</code> if the name of the given {@link IFile} has a Dart-like extension.
*
* @param fileName the file name being tested
* @return <code>true</code> if the name of the given {@link IFile} has a Dart-like extension
*/
public static boolean isDartLikeFile(IFile file) {
String fileName = file.getName();
return isDartLikeFileName(fileName);
}
/**
* Return <code>true</code> if the given file name's extension is a Dart-like extension.
*
* @param fileName the file name being tested
* @return <code>true</code> if the given file name's extension is a Dart-like extension
*/
public static boolean isDartLikeFileName(String fileName) {
return StringUtilities.endsWithIgnoreCase(fileName, ".dart");
}
/**
* Return <code>true</code> if file is in the dart sdk lib directory
*
* @param file
* @return <code>true</code> if file is in dart-sdk/lib
*/
public static boolean isDartSdkLibraryFile(File file) {
File sdkLibrary = DartSdkManager.getManager().getSdk().getLibraryDirectory();
File parentFile = file.getParentFile();
while (parentFile != null) {
if (parentFile.equals(sdkLibrary)) {
return true;
}
parentFile = parentFile.getParentFile();
}
return false;
}
/**
* Return <code>true</code> if the given file name's extension is an HTML-like extension.
*
* @param fileName the file name being tested
* @return <code>true</code> if the given file name's extension is an HTML-like extension
*/
public static boolean isHtmlLikeFileName(String fileName) {
return isLikeFileName(fileName, HTML_FILE_EXTENSIONS);
}
/**
* Return <code>true</code> if the given file name's extension is an image-like extension.
*
* @param fileName the file name being tested
* @return <code>true</code> if the given file name's extension is an image-like extension
*/
public static boolean isImageLikeFileName(String fileName) {
return isLikeFileName(fileName, IMAGE_FILE_EXTENSIONS);
}
/**
* Return true if directory is build directory created by pub
*
* @param folder the folder to be checked
* @return <code>true</code> if folder/parent name matches and is sibling of pubspec.yaml
*/
public static boolean isInBuildDirectory(IContainer folder) {
while (folder.getParent() != null) {
if (folder.getName().equals(BUILD_DIRECTORY_NAME)
&& folder.getParent().getFile(new Path(PUBSPEC_FILE_NAME)).exists()) {
return true;
}
folder = folder.getParent();
}
return false;
}
/**
* Return true if is in build directory created by pub
*/
public static boolean isInBuildDirectory(IResource resource) {
if (resource == null) {
return false;
}
if (!(resource instanceof IContainer)) {
resource = resource.getParent();
}
return !(resource instanceof IProject || resource instanceof IWorkspaceRoot)
&& (isBuildDirectory((IFolder) resource) || isInBuildDirectory((IContainer) resource));
}
/**
* @return {@code true} if the given resource is located in the top-level "packages" folder of its
* enclosing package.
*/
public static boolean isInDuplicatePackageFolder(IResource resource) {
if (resource == null) {
return false;
}
// prepare "pub" folder
PubFolder pubFolder = DartCore.getProjectManager().getPubFolder(resource);
if (pubFolder == null) {
return false;
}
IPath pubPath = pubFolder.getResource().getFullPath();
// check if resource is in "packages"
IPath resourcePath = resource.getFullPath();
String[] segments = resourcePath.segments();
for (int i = 1; i < segments.length - 1; i++) {
String segment = segments[i];
if (segment.equals(PACKAGES_DIRECTORY_NAME)) {
return !resourcePath.uptoSegment(i).equals(pubPath);
}
}
// not in "packages"
return false;
}
/**
* @return {@code true} if the given resource is located in the "packages" sub-folder that
* corresponds to the enclosing package.
*/
public static boolean isInSelfLinkedPackageFolder(IResource resource) {
if (resource == null) {
return false;
}
try {
// prepare "pub" folder
PubFolder pubFolder = DartCore.getProjectManager().getPubFolder(resource);
if (pubFolder == null) {
return false;
}
// the name of the enclosing package
String packageName = pubFolder.getPubspec().getName();
// check if resource is in "packages" and references the enclosing package
String[] segments = resource.getFullPath().segments();
for (int i = 0; i < segments.length - 1; i++) {
String segment = segments[i];
if (segment.equals(PACKAGES_DIRECTORY_NAME) && segments[i + 1].equals(packageName)) {
return true;
}
}
} catch (Throwable e) {
// pubFolder.getPubspec() may fail
return false;
}
// not a self-reference
return false;
}
/**
* Return <code>true</code> if the given file name's extension is an HTML-like extension.
*
* @param fileName the file name being tested
* @return <code>true</code> if the given file name's extension is an HTML-like extension
*/
public static boolean isJSLikeFileName(String fileName) {
return isLikeFileName(fileName, JS_FILE_EXTENSIONS);
}
public static boolean isLinux() {
return !isMac() && !isWindows();
}
public static boolean isMac() {
// Look for the "Mac" OS name.
return System.getProperty("os.name").toLowerCase().startsWith("mac");
}
/**
* Return true if directory is one that is installed by pub
*
* @param file the file to be checked
* @return <code>true</code> if file name matches and is sibling of pubspec.yaml
*/
public static boolean isPackagesDirectory(File file) {
if (file.getName().equals(PACKAGES_DIRECTORY_NAME)) {
return true;
}
return false;
}
/**
* Return true if directory is one that is installed by pub
*
* @param folder the folder to be checked
* @return <code>true</code> if folder name matches and is sibling of pubspec.yaml
*/
public static boolean isPackagesDirectory(IFolder folder) {
IPath location = folder.getLocation();
return location != null && isPackagesDirectory(location.toFile());
}
/**
* Answer <code>true</code> if the string is a package spec
*/
public static boolean isPackageSpec(String spec) {
return spec != null && spec.startsWith(PACKAGE_SCHEME_SPEC);
}
/**
* @return <code>true</code> if given {@link IResource} was installed by pub.
*/
public static boolean isPackagesResource(IResource resource) {
if (resource instanceof IFolder) {
if (isPackagesDirectory((IFolder) resource)) {
return true;
}
}
if (resource != null && resource.getParent() instanceof IFolder) {
IFolder parentFolder = (IFolder) resource.getParent();
return isPackagesResource(parentFolder);
}
return false;
}
/**
* Check if this URI denotes a patch file.
*/
public static boolean isPatchfile(File file) {
return file != null && file.getName().endsWith("_patch.dart");
}
/**
* @return whether we're running in the context of the eclipse plugins build
*/
public static boolean isPluginsBuild() {
return Platform.getBundle("com.google.dart.eclipse.core") != null;
}
/**
* Checks if the given linkedResource points to a file in the container. This is used to check for
* the self link in the packages directory
*
* @param resource
* @param linkedResource
* @return <code>true</code> if the linked resource points to a file/folder in the project
*/
public static boolean isSelfLinkedResource(IContainer resource, IResource linkedResource) {
try {
// if (linkedResource.getParent().getParent() == resource) {
String resourcePath = resource.getLocation().toFile().getCanonicalPath();
String linkPath = linkedResource.getLocation().toFile().getCanonicalPath();
if (linkPath.startsWith(resourcePath)) {
return true;
}
// }
} catch (IOException e) {
return false;
}
return false;
}
/**
* Return <code>true</code> if the given file name's extension is an HTML-like extension.
*
* @param fileName the file name being tested
* @return <code>true</code> if the given file name's extension is an HTML-like extension
*/
public static boolean isTxtLikeFileName(String fileName) {
return isLikeFileName(fileName, TXT_FILE_EXTENSIONS);
}
public static boolean isWindows() {
// Look for the "Windows" OS name.
return System.getProperty("os.name").toLowerCase().startsWith("win");
}
public static boolean isWindowsXp() {
// Look for the "Windows XP" OS name.
return System.getProperty("os.name").toLowerCase().equals("windows xp");
}
/**
* Log the given message as an error.
*
* @param message an explanation of why the error occurred or what it means
*/
public static void logError(String message) {
logErrorImpl(message, null);
instrumentationLogErrorImpl(message, null);
}
/**
* Log the given exception as one representing an error.
*
* @param message an explanation of why the error occurred or what it means
* @param exception the exception being logged
*/
public static void logError(String message, Throwable exception) {
logErrorImpl(message, exception);
instrumentationLogErrorImpl(message, exception);
}
/**
* Log the given exception as one representing an error.
*
* @param exception the exception being logged
*/
public static void logError(Throwable exception) {
logErrorImpl(exception.getMessage(), exception);
instrumentationLogErrorImpl(null, exception);
}
/**
* Log the given informational message.
*
* @param message an explanation of why the error occurred or what it means
* @param exception the exception being logged
*/
public static void logInformation(String message) {
logInformation(message, null);
}
/**
* Log the given exception as one representing an informational message.
*
* @param message an explanation of why the error occurred or what it means
* @param exception the exception being logged
*/
public static void logInformation(String message, Throwable exception) {
if (DartCoreDebug.VERBOSE) {
ILog pluginLog = getPluginLog();
if (pluginLog != null) {
pluginLog.log(new Status(Status.INFO, PLUGIN_ID, "INFO: " + message, exception));
}
}
instrumentationLogInfoImpl(message, exception);
}
/**
* Log the given {@link RequestError}.
*/
public static void logRequestError(RequestError requestError) {
StringBuilder buf = new StringBuilder();
buf.append("RequestError: ");
buf.append(requestError.getCode());
buf.append("\n");
buf.append(requestError.getMessage());
buf.append("\n");
buf.append(requestError.getStackTrace());
buf.append("\n");
String str = buf.toString();
DartCore.logError(str);
}
/**
* This method exists as a convenient marker for methods that have not yet been fully implemented.
* It should be deleted before this product ships.
*/
public static void notYetImplemented() {
}
/**
* Removes the file extension from the given file name, if it has a Dart-like file extension.
* Otherwise the file name itself is returned. Note this removes the dot ('.') before the
* extension as well.
*
* @param fileName the name of a file
* @return the fileName without the Dart-like extension
*/
public static String removeDartLikeExtension(String fileName) {
return Util.getNameWithoutDartLikeExtension(fileName);
}
/**
* Remove the given resource (as a path) from the set of ignored resources.
*
* @param resource the resource path to (un)ignore
* @throws IOException if there was an error accessing the ignore file
*/
public static void removeFromIgnores(IPath resource) throws IOException {
getIgnoreManager().removeFromIgnores(resource);
}
/**
* Remove the given resource from the set of ignored resources.
*
* @param resource the resource to (un)ignore
* @throws IOException if there was an error accessing the ignore file
*/
public static void removeFromIgnores(IResource resource) throws IOException {
getIgnoreManager().removeFromIgnores(resource);
}
/**
* Remove the given listener for dart ignore changes from the Dart Model. Has no effect if an
* identical listener is not registered.
*
* @param listener the non-<code>null</code> listener to remove
*/
public static void removeIgnoreListener(DartIgnoreListener listener) {
getIgnoreManager().removeListener(listener);
}
public static void setOptions(HashMap<String, String> newOptions) {
}
/**
* Sets the current table of options. All and only the options explicitly included in the given
* table are remembered; all previous option settings are forgotten, including ones not explicitly
* mentioned.
* <p>
* Helper constants have been defined on DartPreferenceConstants for each of the option IDs
* (categorized in Code assist option ID, Compiler option ID and Core option ID) and some of their
* acceptable values (categorized in Option value). Some options accept open value sets beyond the
* documented constant values.
* <p>
* Note: each release may add new options.
*
* @param newOptions the new options, or <code>null</code> to reset all options to their default
* values
*/
public static void setOptions(Hashtable<String, String> newOptions) {
}
/**
* TESTING ONLY: Set the log used by {@link #logError(String)} and other local methods for logging
* errors, warnings, and information.
*
* @param log the log or <code>null</code> to use the default system log
* @return the log prior to calling this method or <code>null</code> for the default system log
*/
public static ILog setPluginLog(ILog log) {
ILog oldLog = PLUGIN_LOG;
PLUGIN_LOG = log;
return oldLog;
}
/**
* Set a symbolic resource mapping from one resource to another. For some uses of the original
* resource, like serving web content, the mapped resource should be substituted.
*
* @param originalResource
* @param newResource
*/
public static void setResourceRemapping(IFile originalResource, IFile newResource) {
try {
String resourcePath = (newResource == null ? null
: newResource.getFullPath().toPortableString());
originalResource.setPersistentProperty(RESOURCE_REMAP_NAME, resourcePath);
} catch (CoreException e) {
DartCore.logError(e);
}
}
/**
* Sets the value of the string-valued user-defined property for the given key.
* <p>
* User-defined properties are defined in the <code>editor.properties</code> file located in the
* eclipse installation directory.
*
* @see DartCore#getEclipseInstallationDirectory()
* @param key the name of the property
* @param value the string-valued property
*/
public static void setUserDefinedProperty(String key, String value) {
Properties properties = new Properties();
File installDirectory = getEclipseInstallationDirectory();
File file = new File(installDirectory, EDITOR_PROPERTIES);
try {
if (!file.exists()) {
file.createNewFile();
}
properties.load(new FileReader(file));
properties.setProperty(key, value);
properties.store(new FileWriter(file), null);
} catch (FileNotFoundException e) {
logError(e);
} catch (IOException e) {
logError(e);
}
}
/**
* Answer the log used by {@link #logError(String)} and other local methods for logging errors,
* warnings, and information.
*
* @return the {@link ILog} or {@code null} if not accessible (for example during platform
* shutdown)
*/
private static ILog getPluginLog() {
try {
return PLUGIN_LOG != null ? PLUGIN_LOG : getPlugin().getLog();
} catch (Throwable e) {
return null;
}
}
/**
* Record an error
*/
private static void instrumentationLogErrorImpl(String message, Throwable exception) {
instrumentationLogImpl(message, exception, "LogError");
}
/**
* Internal instrumentation message delivery implementation
*
* @param message optional message to be delivered
* @param exception optional exception to be delivered
* @param messageType message type, common values LogError/LogMessage
*/
private static void instrumentationLogImpl(String message, Throwable exception, String messageType) {
if (instrumentationLogErrorEnabled) {
InstrumentationBuilder instrumentation = Instrumentation.builder("DartCore." + messageType);
try {
instrumentation.data("Log_Message", message != null ? message : "null");
instrumentation.data("Log_Exception", exception != null ? exception.toString() : "null");
if (exception != null) {
instrumentation.record(exception);
}
} catch (Exception e) {
instrumentationLogErrorEnabled = false;
logErrorImpl("Instrumentation failed to log error", exception);
} finally {
instrumentation.log();
}
}
}
/**
* Record an 'informational exception'
*/
private static void instrumentationLogInfoImpl(String message, Throwable exception) {
instrumentationLogImpl(message, exception, "LogInfo");
}
/**
* Return <code>true</code> if the given file name's extension matches one of the passed
* extensions.
*
* @param fileName the file name being tested
* @param extensions an array of file extensions to test against
* @return <code>true</code> if the given file name's extension matches one of the passed
* extensions
*/
private static boolean isLikeFileName(String fileName, String[] extensions) {
if (fileName == null || fileName.length() == 0) {
return false;
}
for (String extension : extensions) {
if (StringUtilities.endsWithIgnoreCase(fileName, '.' + extension)) {
return true;
}
}
return false;
}
private static void logErrorImpl(String message, Throwable exception) {
ILog pluginLog = getPluginLog();
if (pluginLog != null) {
pluginLog.log(new Status(Status.ERROR, PLUGIN_ID, message, exception));
}
}
private IEclipsePreferences prefs;
/**
* Property key for user-specified analysis server arguments.
*/
public static final String ANALYSIS_SERVER_ARG_PROP_KEY = "com.dart.tools.server.args";
/**
* Property key for user-specified Dart VM arguments for analysis server.
*/
public static final String ANALYSIS_SERVER_VM_ARG_PROP_KEY = "com.dart.tools.server.vm.args";
/**
* Initialize a newly created instance of this class.
*/
public DartCore() {
PLUG_IN = this;
}
/**
* Use dart2js if the SDK is present.
*/
public boolean getCompileWithDart2JS() {
return DartSdkManager.getManager().hasSdk();
}
public String getDart2jsFlags() {
return getPrefs().get(PREFS_DART2JS_FLAGS, "");
}
public String[] getDart2jsFlagsAsArray() {
return StringUtilities.parseArgumentString(getDart2jsFlags());
}
public String getDartiumLocationPref() {
return getPrefs().get(PREFS_DARTIUM_LOCATION, "");
}
public boolean getDisableDartBasedBuilder(IProject project) {
return getProjectPreferences(project).getBoolean(PROJECT_PREF_DISABLE_DART_BASED_BUILDER, false);
}
public boolean getEnableAnalytics() {
if (DartCoreDebug.ASK_FOR_USER_ANALYTICS) {
return getPrefs().getBoolean(PREFS_ENABLE_ANALYTICS, false);
}
return false;
}
/**
* Given an File, return the appropriate java.io.File representing a package root. This can be
* null if a package root should not be used.
*
* @param file the File
* @return the File for the package root, or null if none
*/
public File getPackageRoot(File file) {
IResource resource = ResourceUtil.getResource(file);
if (resource != null) {
return getPackageRoot(resource.getProject());
}
return null;
}
/**
* Given an IProject, return the appropriate java.io.File representing a package root. This can be
* null if a package root should not be used.
*
* @param project the IProject
* @return the File for the package root, or null if none
*/
public File getPackageRoot(IProject project) {
if (project != null) {
String setting = getProjectPreferences(project).get(PROJECT_PREF_PACKAGE_ROOT, "");
if (setting != null && setting.length() > 0) {
String[] paths = setting.split(File.pathSeparator);
return new File(paths[0]);
}
}
File[] roots = CmdLineOptions.getOptions().getPackageRoots();
if (roots.length > 0) {
return roots[0];
}
return null;
}
/**
* Get the core plugin preferences. Use savePrefs() to save the preferences.
*/
public IEclipsePreferences getPrefs() {
if (prefs == null) {
prefs = InstanceScope.INSTANCE.getNode(PLUGIN_ID);
}
return prefs;
}
public IEclipsePreferences getProjectPreferences(IProject project) {
ProjectScope projectScope = new ProjectScope(project);
return projectScope.getNode(PLUGIN_ID);
}
public String getSdkLocationPref() {
return getPrefs().get(PREFS_SDK_LOCATION, "");
}
public boolean getShowAnalyticsDailog() {
return getPrefs().getBoolean(PREFS_SHOW_ANALYTICS_DIALOG, true);
}
/**
* Given an IProject, return string representing a package root to be used for all VM launches.
* This can be null if a package root should not be used.
*
* @param project the IProject
* @return the String for the package root, or null if none
*/
public String getVmPackageRoot(IProject project) {
if (project != null) {
String setting = getProjectPreferences(project).get(PROJECT_PREF_VM_PACKAGE_ROOT, "");
if (!setting.isEmpty()) {
return setting;
}
}
return null;
}
public boolean isAutoRunPubEnabled() {
return DartCore.getPlugin().getPrefs().getBoolean(PUB_AUTO_RUN_PREFERENCE, true);
}
public boolean isHintsDart2JSEnabled() {
return DartCore.getPlugin().getPrefs().getBoolean(ENABLE_HINTS_DART2JS_PREFERENCE, true);
}
public boolean isHintsEnabled() {
return DartCore.getPlugin().getPrefs().getBoolean(ENABLE_HINTS_PREFERENCE, true);
}
public boolean isLintsEnabled() {
return DartCore.getPlugin().getPrefs().getBoolean(ENABLE_LINTS_PREFERENCE, false);
}
/**
* Save the core plugin preferences
*
* @throws CoreException
*/
public void savePrefs() throws CoreException {
try {
getPrefs().flush();
} catch (BackingStoreException e) {
throw new CoreException(new Status(IStatus.ERROR, PLUGIN_ID, e.toString(), e));
}
}
@Override
public void sdkUpdated(DirectoryBasedDartSdk sdk) {
Job job = new CleanLibrariesJob();
job.schedule();
}
public void setDart2JsPreferences(String args) {
IEclipsePreferences prefs = getPrefs();
prefs.put(PREFS_DART2JS_FLAGS, args);
try {
getPrefs().flush();
} catch (BackingStoreException exception) {
logError(exception);
}
}
public void setDisableDartBasedBuilder(IProject project, boolean value) throws CoreException {
try {
IEclipsePreferences prefs = getProjectPreferences(project);
prefs.putBoolean(PROJECT_PREF_DISABLE_DART_BASED_BUILDER, value);
prefs.flush();
} catch (BackingStoreException ex) {
throw new CoreException(new Status(IStatus.ERROR, PLUGIN_ID, ex.toString(), ex));
}
}
public void setEnableAnalytics(boolean value) {
if (DartCoreDebug.ASK_FOR_USER_ANALYTICS) {
IEclipsePreferences prefs = getPrefs();
prefs.putBoolean(PREFS_ENABLE_ANALYTICS, value);
try {
getPrefs().flush();
} catch (BackingStoreException exception) {
logError(exception);
}
}
}
public void setPackageRoot(IProject project, String packageRootPath) throws CoreException {
try {
IEclipsePreferences prefs = getProjectPreferences(project);
prefs.put(PROJECT_PREF_PACKAGE_ROOT, packageRootPath);
prefs.flush();
} catch (BackingStoreException ex) {
throw new CoreException(new Status(IStatus.ERROR, PLUGIN_ID, ex.toString(), ex));
}
}
public void setShowAnalyticsDialogFalse() {
IEclipsePreferences prefs = getPrefs();
prefs.putBoolean(PREFS_SHOW_ANALYTICS_DIALOG, false);
try {
getPrefs().flush();
} catch (BackingStoreException exception) {
logError(exception);
}
}
public void setVmPackageRoot(IProject project, String packageRootPath) throws CoreException {
try {
IEclipsePreferences prefs = getProjectPreferences(project);
prefs.put(PROJECT_PREF_VM_PACKAGE_ROOT, packageRootPath);
prefs.flush();
} catch (BackingStoreException ex) {
throw new CoreException(new Status(IStatus.ERROR, PLUGIN_ID, ex.toString(), ex));
}
}
@Override
public void start(BundleContext context) throws Exception {
super.start(context);
CmdLineOptions.setOptions(CmdLineOptions.parseCmdLine(Platform.getApplicationArgs()));
CmdLineOptions.getOptions().printWarnings();
if (DartCoreDebug.PERF_THREAD_CONTENTION_MONIOR) {
try {
java.lang.management.ThreadMXBean th = ManagementFactory.getThreadMXBean();
th.setThreadContentionMonitoringEnabled(true);
} catch (UnsupportedOperationException e) {
}
}
AnalysisEngine analysisEngine = AnalysisEngine.getInstance();
analysisEngine.setLogger(new Logger() {
@Override
public void logError(String message) {
DartCore.logError(message);
}
@Override
public void logError(String message, Throwable exception) {
DartCore.logError(message, exception);
}
@Override
public void logInformation(String message) {
DartCore.logInformation(message);
}
@Override
public void logInformation(String message, Throwable exception) {
DartCore.logInformation(message, exception);
}
});
Logging.setLogger(new com.google.dart.server.utilities.logging.Logger() {
@Override
public void logError(String message) {
DartCore.logError(message);
}
@Override
public void logError(String message, Throwable exception) {
DartCore.logError(message, exception);
}
@Override
public void logInformation(String message) {
DartCore.logInformation(message);
}
@Override
public void logInformation(String message, Throwable exception) {
DartCore.logInformation(message, exception);
}
});
DartSdkManager.getManager().addSdkListener(this);
if (!DartCoreDebug.ENABLE_ANALYSIS_SERVER) {
getProjectManager().hookListeners();
} else {
getAnalysisServer();
}
}
@Override
public void stop(BundleContext context) throws Exception {
DartSdkManager.getManager().removeSdkListener(this);
try {
if (!DartCoreDebug.ENABLE_ANALYSIS_SERVER) {
getProjectManager().stop();
}
synchronized (analysisServerLock) {
if (analysisServer != null) {
analysisServer.server_shutdown();
}
}
if (DartCoreDebug.METRICS) {
StringWriter writer = new StringWriter();
PerformanceManager.getInstance().printMetrics(new PrintWriter(writer));
String metricsInfo = writer.toString();
if (metricsInfo.length() > 0) {
getLog().log(new Status(Status.INFO, PLUGIN_ID, metricsInfo, null));
}
}
} finally {
super.stop(context);
}
}
}