static void logPlugins() {
List<String> loadedBundled = new ArrayList<String>();
List<String> disabled = new ArrayList<String>();
List<String> loadedCustom = new ArrayList<String>();
for (IdeaPluginDescriptor descriptor : ourPlugins) {
final String version = descriptor.getVersion();
String s = descriptor.getName() + (version != null ? " (" + version + ")" : "");
if (descriptor.isEnabled()) {
if (descriptor.isBundled() || SPECIAL_IDEA_PLUGIN.equals(descriptor.getName()))
loadedBundled.add(s);
else loadedCustom.add(s);
} else {
disabled.add(s);
}
}
Collections.sort(loadedBundled);
Collections.sort(loadedCustom);
Collections.sort(disabled);
getLogger().info("Loaded bundled plugins: " + StringUtil.join(loadedBundled, ", "));
if (!loadedCustom.isEmpty()) {
getLogger().info("Loaded custom plugins: " + StringUtil.join(loadedCustom, ", "));
}
if (!disabled.isEmpty()) {
getLogger().info("Disabled plugins: " + StringUtil.join(disabled, ", "));
}
}
private static boolean checkDependants(
final IdeaPluginDescriptor pluginDescriptor,
final Function<PluginId, IdeaPluginDescriptor> pluginId2Descriptor,
final Condition<PluginId> check,
final Set<PluginId> processed) {
processed.add(pluginDescriptor.getPluginId());
final PluginId[] dependentPluginIds = pluginDescriptor.getDependentPluginIds();
final Set<PluginId> optionalDependencies =
new HashSet<PluginId>(Arrays.asList(pluginDescriptor.getOptionalDependentPluginIds()));
for (final PluginId dependentPluginId : dependentPluginIds) {
if (processed.contains(dependentPluginId)) continue;
// TODO[yole] should this condition be a parameter?
if (isModuleDependency(dependentPluginId)
&& (ourAvailableModules.isEmpty()
|| ourAvailableModules.contains(dependentPluginId.getIdString()))) {
continue;
}
if (!optionalDependencies.contains(dependentPluginId)) {
if (!check.value(dependentPluginId)) {
return false;
}
final IdeaPluginDescriptor dependantPluginDescriptor =
pluginId2Descriptor.fun(dependentPluginId);
if (dependantPluginDescriptor != null
&& !checkDependants(dependantPluginDescriptor, pluginId2Descriptor, check, processed)) {
return false;
}
}
}
return true;
}
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;
}
@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;
}