static boolean shouldSkipPlugin(
final IdeaPluginDescriptor descriptor, IdeaPluginDescriptor[] loaded) {
final String idString = descriptor.getPluginId().getIdString();
if (idString.equals(CORE_PLUGIN_ID)) {
return false;
}
//noinspection HardCodedStringLiteral
final String pluginId = System.getProperty("idea.load.plugins.id");
if (pluginId == null) {
if (descriptor instanceof IdeaPluginDescriptorImpl && !descriptor.isEnabled()) return true;
if (!shouldLoadPlugins()) return true;
}
final List<String> pluginIds = pluginId == null ? null : StringUtil.split(pluginId, ",");
final boolean checkModuleDependencies =
!ourAvailableModules.isEmpty() && !ourAvailableModules.contains("com.intellij.modules.all");
if (checkModuleDependencies && !hasModuleDependencies(descriptor)) {
return true;
}
boolean shouldLoad;
//noinspection HardCodedStringLiteral
final String loadPluginCategory = System.getProperty("idea.load.plugins.category");
if (loadPluginCategory != null) {
shouldLoad = loadPluginCategory.equals(descriptor.getCategory());
} else {
if (pluginIds != null) {
shouldLoad = pluginIds.contains(idString);
if (!shouldLoad) {
Map<PluginId, IdeaPluginDescriptor> map = new HashMap<PluginId, IdeaPluginDescriptor>();
for (final IdeaPluginDescriptor pluginDescriptor : loaded) {
map.put(pluginDescriptor.getPluginId(), pluginDescriptor);
}
addModulesAsDependents(map);
final IdeaPluginDescriptor descriptorFromProperty = map.get(PluginId.getId(pluginId));
shouldLoad =
descriptorFromProperty != null
&& isDependent(
descriptorFromProperty,
descriptor.getPluginId(),
map,
checkModuleDependencies);
}
} else {
shouldLoad = !getDisabledPlugins().contains(idString);
}
if (shouldLoad && descriptor instanceof IdeaPluginDescriptorImpl) {
if (isIncompatible(descriptor)) return true;
}
}
return !shouldLoad;
}
static void mergeOptionalConfigs(Map<PluginId, IdeaPluginDescriptorImpl> descriptors) {
final Map<PluginId, IdeaPluginDescriptorImpl> descriptorsWithModules =
new HashMap<PluginId, IdeaPluginDescriptorImpl>(descriptors);
addModulesAsDependents(descriptorsWithModules);
for (IdeaPluginDescriptorImpl descriptor : descriptors.values()) {
final Map<PluginId, IdeaPluginDescriptorImpl> optionalDescriptors =
descriptor.getOptionalDescriptors();
if (optionalDescriptors != null && !optionalDescriptors.isEmpty()) {
for (Map.Entry<PluginId, IdeaPluginDescriptorImpl> entry : optionalDescriptors.entrySet()) {
if (descriptorsWithModules.containsKey(entry.getKey())) {
descriptor.mergeOptionalConfig(entry.getValue());
}
}
}
}
}
@Nullable
static String filterBadPlugins(
List<? extends IdeaPluginDescriptor> result, final Map<String, String> disabledPluginNames) {
final Map<PluginId, IdeaPluginDescriptor> idToDescriptorMap =
new HashMap<PluginId, IdeaPluginDescriptor>();
final StringBuffer message = new StringBuffer();
boolean pluginsWithoutIdFound = false;
for (Iterator<? extends IdeaPluginDescriptor> it = result.iterator(); it.hasNext(); ) {
final IdeaPluginDescriptor descriptor = it.next();
final PluginId id = descriptor.getPluginId();
if (id == null) {
pluginsWithoutIdFound = true;
}
if (idToDescriptorMap.containsKey(id)) {
message.append("<br>");
message.append(IdeBundle.message("message.duplicate.plugin.id"));
message.append(id);
it.remove();
} else if (descriptor.isEnabled()) {
idToDescriptorMap.put(id, descriptor);
}
}
addModulesAsDependents(idToDescriptorMap);
final List<String> disabledPluginIds = new ArrayList<String>();
final LinkedHashSet<String> faultyDescriptors = new LinkedHashSet<String>();
for (final Iterator<? extends IdeaPluginDescriptor> it = result.iterator(); it.hasNext(); ) {
final IdeaPluginDescriptor pluginDescriptor = it.next();
checkDependants(
pluginDescriptor,
new Function<PluginId, IdeaPluginDescriptor>() {
@Override
public IdeaPluginDescriptor fun(final PluginId pluginId) {
return idToDescriptorMap.get(pluginId);
}
},
new Condition<PluginId>() {
@Override
public boolean value(final PluginId pluginId) {
if (!idToDescriptorMap.containsKey(pluginId)) {
pluginDescriptor.setEnabled(false);
if (!pluginId.getIdString().startsWith(MODULE_DEPENDENCY_PREFIX)) {
faultyDescriptors.add(pluginId.getIdString());
disabledPluginIds.add(pluginDescriptor.getPluginId().getIdString());
message.append("<br>");
final String name = pluginDescriptor.getName();
final IdeaPluginDescriptor descriptor = idToDescriptorMap.get(pluginId);
String pluginName;
if (descriptor == null) {
pluginName = pluginId.getIdString();
if (disabledPluginNames.containsKey(pluginName)) {
pluginName = disabledPluginNames.get(pluginName);
}
} else {
pluginName = descriptor.getName();
}
message.append(
getDisabledPlugins().contains(pluginId.getIdString())
? IdeBundle.message("error.required.plugin.disabled", name, pluginName)
: IdeBundle.message(
"error.required.plugin.not.installed", name, pluginName));
}
it.remove();
return false;
}
return true;
}
});
}
if (!disabledPluginIds.isEmpty()) {
myPlugins2Disable = disabledPluginIds;
myPlugins2Enable = faultyDescriptors;
message.append("<br>");
message.append("<br>").append("<a href=\"" + DISABLE + "\">Disable ");
if (disabledPluginIds.size() == 1) {
final PluginId pluginId2Disable = PluginId.getId(disabledPluginIds.iterator().next());
message.append(
idToDescriptorMap.containsKey(pluginId2Disable)
? idToDescriptorMap.get(pluginId2Disable).getName()
: pluginId2Disable.getIdString());
} else {
message.append("not loaded plugins");
}
message.append("</a>");
boolean possibleToEnable = true;
for (String descriptor : faultyDescriptors) {
if (disabledPluginNames.get(descriptor) == null) {
possibleToEnable = false;
break;
}
}
if (possibleToEnable) {
message
.append("<br>")
.append("<a href=\"" + ENABLE + "\">Enable ")
.append(
faultyDescriptors.size() == 1
? disabledPluginNames.get(faultyDescriptors.iterator().next())
: " all necessary plugins")
.append("</a>");
}
message.append("<br>").append("<a href=\"" + EDIT + "\">Open plugin manager</a>");
}
if (pluginsWithoutIdFound) {
message.append("<br>");
message.append(IdeBundle.message("error.plugins.without.id.found"));
}
if (message.length() > 0) {
message.insert(0, IdeBundle.message("error.problems.found.loading.plugins"));
return message.toString();
}
return null;
}
