public List<ShelvedChangeList> importChangeLists(
final Collection<VirtualFile> files, final Consumer<VcsException> exceptionConsumer) {
final List<ShelvedChangeList> result = new ArrayList<ShelvedChangeList>(files.size());
try {
final FilesProgress filesProgress = new FilesProgress(files.size(), "Processing ");
for (VirtualFile file : files) {
filesProgress.updateIndicator(file);
final String description = file.getNameWithoutExtension().replace('_', ' ');
final File patchPath = getPatchPath(description);
final ShelvedChangeList list =
new ShelvedChangeList(
patchPath.getPath(),
description,
new SmartList<ShelvedBinaryFile>(),
file.getTimeStamp());
try {
final List<TextFilePatch> patchesList =
loadPatches(myProject, file.getPath(), new CommitContext());
if (!patchesList.isEmpty()) {
FileUtil.copy(new File(file.getPath()), patchPath);
// add only if ok to read patch
myShelvedChangeLists.add(list);
result.add(list);
}
} catch (IOException e) {
exceptionConsumer.consume(new VcsException(e));
} catch (PatchSyntaxException e) {
exceptionConsumer.consume(new VcsException(e));
}
}
} finally {
notifyStateChanged();
}
return result;
}
public static void selectSdkHome(
@NotNull final SdkType sdkType, @NotNull final Consumer<String> consumer) {
final FileChooserDescriptor descriptor = sdkType.getHomeChooserDescriptor();
if (ApplicationManager.getApplication().isUnitTestMode()) {
Sdk sdk = ProjectJdkTable.getInstance().findMostRecentSdkOfType(sdkType);
if (sdk == null) throw new RuntimeException("No SDK of type " + sdkType + " found");
consumer.consume(sdk.getHomePath());
return;
}
FileChooser.chooseFiles(
descriptor,
null,
getSuggestedSdkRoot(sdkType),
chosen -> {
final String path = chosen.get(0).getPath();
if (sdkType.isValidSdkHome(path)) {
consumer.consume(path);
return;
}
final String adjustedPath = sdkType.adjustSelectedSdkHome(path);
if (sdkType.isValidSdkHome(adjustedPath)) {
consumer.consume(adjustedPath);
}
});
}
@Override
protected void createActions(Consumer<AnAction> actionConsumer) {
actionConsumer.consume(myPresetUserAction);
actionConsumer.consume(myAllAction);
actionConsumer.consume(mySelectMe);
actionConsumer.consume(mySelect);
}
public static boolean isJsonSchema(
@NotNull JsonSchemaExportedDefinitions definitions,
@NotNull VirtualFile key,
@NotNull final String string,
Consumer<String> errorConsumer)
throws IOException {
final JsonSchemaReader reader = new JsonSchemaReader(key);
java.io.StringReader stringReader = new java.io.StringReader(string);
try {
reader.read(stringReader, null);
} catch (Exception e) {
LOG.info(e);
errorConsumer.consume(e.getMessage());
return false;
}
// have two stages so that just syntax errors do not clear cache
stringReader = new java.io.StringReader(string);
try {
reader.read(stringReader, definitions);
} catch (Exception e) {
LOG.info(e);
errorConsumer.consume(e.getMessage());
throw e;
}
return true;
}
private static void addBreakContinue(Consumer<LookupElement> result, PsiElement position) {
PsiLoopStatement loop = PsiTreeUtil.getParentOfType(position, PsiLoopStatement.class);
LookupElement br = createKeyword(position, PsiKeyword.BREAK);
LookupElement cont = createKeyword(position, PsiKeyword.CONTINUE);
TailType tailType;
if (psiElement()
.insideSequence(
true,
psiElement(PsiLabeledStatement.class),
or(
psiElement(PsiFile.class),
psiElement(PsiMethod.class),
psiElement(PsiClassInitializer.class)))
.accepts(position)) {
tailType = TailType.HUMBLE_SPACE_BEFORE_WORD;
} else {
tailType = TailType.SEMICOLON;
}
br = TailTypeDecorator.withTail(br, tailType);
cont = TailTypeDecorator.withTail(cont, tailType);
if (loop != null
&& new InsideElementFilter(new ClassFilter(PsiStatement.class))
.isAcceptable(position, loop)) {
result.consume(br);
result.consume(cont);
}
if (psiElement().inside(PsiSwitchStatement.class).accepts(position)) {
result.consume(br);
}
}
private void processReference(String prefix, SReference ref, Consumer<SReference> consumer) {
if (!(ref instanceof StaticReference)) return;
SNodeId target = ref.getTargetNodeId();
if (!(target instanceof Foreign)) return;
String targetNodeIdStr = target.toString();
boolean found = false;
int idx = targetNodeIdStr.indexOf(prefix);
while (idx >= 0) {
if (idx == 0) {
found = true;
break;
}
char c = targetNodeIdStr.charAt(idx - 1);
if (c == '.' || Character.isLetterOrDigit(c)) {
idx = targetNodeIdStr.indexOf(prefix, idx + 1);
continue;
}
found = true;
break;
}
if (found) {
consumer.consume(ref);
}
}
@Nullable
private <T extends RefElement> T getFromRefTableOrCache(
final PsiElement element,
@NotNull NullableFactory<T> factory,
@Nullable Consumer<T> whenCached) {
PsiAnchor psiAnchor = createAnchor(element);
T result;
synchronized (myRefTable) {
//noinspection unchecked
result = (T) myRefTable.get(psiAnchor);
if (result != null) return result;
if (!isValidPointForReference()) {
// LOG.assertTrue(true, "References may become invalid after process is finished");
return null;
}
result = factory.create();
if (result == null) return null;
myRefTable.put(psiAnchor, result);
mySortedRefs = null;
if (whenCached != null) {
whenCached.consume(result);
}
}
return result;
}
private void processListenerProperties(@NotNull PsiMethod method) {
if (!method.getName().startsWith("add")
|| method.getParameterList().getParametersCount() != 1) return;
final PsiParameter parameter = method.getParameterList().getParameters()[0];
final PsiType type = parameter.getType();
if (!(type instanceof PsiClassType)) return;
final PsiClassType classType = (PsiClassType) type;
final PsiClass listenerClass = classType.resolve();
if (listenerClass == null) return;
final PsiMethod[] listenerMethods = listenerClass.getMethods();
if (!InheritanceUtil.isInheritorOrSelf(listenerClass, myEventListener, true)) return;
for (PsiMethod listenerMethod : listenerMethods) {
final String name = listenerMethod.getName();
if (myPropertyNames.add(name)) {
LookupElementBuilder builder =
LookupElementBuilder.create(
generatePropertyResolveResult(name, listenerMethod, null, null), name)
.withIcon(JetgroovyIcons.Groovy.Property);
myConsumer.consume(builder);
}
}
}
private void walk(
@NotNull Collection<Integer> startNodes,
final boolean goDown,
@NotNull final Consumer<Integer> consumer) {
synchronized (myTempFlags) {
myTempFlags.setAll(false);
for (int start : startNodes) {
if (start < 0) continue;
if (myTempFlags.get(start)) continue;
myTempFlags.set(start, true);
consumer.consume(start);
myDfsUtil.nodeDfsIterator(
start,
new DfsUtil.NextNode() {
@Override
public int fun(int currentNode) {
for (int downNode :
myGraph.getNodes(
currentNode,
goDown ? LiteLinearGraph.NodeFilter.DOWN : LiteLinearGraph.NodeFilter.UP)) {
if (!myTempFlags.get(downNode)) {
myTempFlags.set(downNode, true);
consumer.consume(downNode);
return downNode;
}
}
return NODE_NOT_FOUND;
}
});
}
}
}
public static void updateModel(
@NotNull final Module module, @NotNull Consumer<ModifiableRootModel> task) {
final ModifiableRootModel model =
ApplicationManager.getApplication()
.runReadAction(
new Computable<ModifiableRootModel>() {
@Override
public ModifiableRootModel compute() {
return ModuleRootManager.getInstance(module).getModifiableModel();
}
});
try {
task.consume(model);
doWriteAction(
new Runnable() {
@Override
public void run() {
model.commit();
}
});
} catch (RuntimeException e) {
model.dispose();
throw e;
} catch (Error e) {
model.dispose();
throw e;
}
}
private static void addUnfinishedMethodTypeParameters(
PsiElement position, final Consumer<LookupElement> result) {
final ProcessingContext context = new ProcessingContext();
if (psiElement()
.inside(
psiElement(PsiTypeElement.class)
.afterLeaf(
psiElement()
.withText(">")
.withParent(
psiElement(PsiTypeParameterList.class)
.withParent(PsiErrorElement.class)
.save("typeParameterList"))))
.accepts(position, context)) {
final PsiTypeParameterList list = (PsiTypeParameterList) context.get("typeParameterList");
PsiElement current = list.getParent().getParent();
if (current instanceof PsiField) {
current = current.getParent();
}
if (current instanceof PsiClass) {
for (PsiTypeParameter typeParameter : list.getTypeParameters()) {
result.consume(new JavaPsiClassReferenceElement(typeParameter));
}
}
}
}
@Override
public void setSelected(AnActionEvent e, boolean state) {
if (state) {
myTodoFilterConsumer.consume(myFilter);
// setTodoFilter(myFilter);
}
}
@NotNull
private static <T> PairConsumer<T, Runnable> wrappingProcessor(
@NotNull final Consumer<T> processor) {
return (item, runnable) -> {
runSafely(() -> processor.consume(item));
runnable.run();
};
}
@Nullable
public static Runnable fillCompletionVariants(
final JavaSmartCompletionParameters parameters, final Consumer<LookupElement> result) {
final PsiElement element = parameters.getPosition();
if (JavaSmartCompletionContributor.INSIDE_TYPECAST_EXPRESSION.accepts(element)) return null;
if (JavaKeywordCompletion.isAfterPrimitiveOrArrayType(element)) return null;
final int offset = parameters.getParameters().getOffset();
final PsiJavaCodeReferenceElement reference =
PsiTreeUtil.findElementOfClassAtOffset(
element.getContainingFile(), offset, PsiJavaCodeReferenceElement.class, false);
if (reference != null) {
final ElementFilter filter = getReferenceFilter(element, false);
for (final LookupElement item :
completeFinalReference(element, reference, filter, parameters)) {
result.consume(item);
}
final boolean secondTime = parameters.getParameters().getInvocationCount() >= 2;
final Set<LookupElement> base =
JavaSmartCompletionContributor.completeReference(
element,
reference,
filter,
false,
true,
parameters.getParameters(),
PrefixMatcher.ALWAYS_TRUE);
for (final LookupElement item : new LinkedHashSet<LookupElement>(base)) {
ExpressionLookupItem access = ArrayMemberAccess.getSingleArrayElementAccess(element, item);
if (access != null) {
base.add(access);
PsiType type = access.getType();
if (type != null && parameters.getExpectedType().isAssignableFrom(type)) {
result.consume(access);
}
}
}
if (secondTime) {
return new SlowerTypeConversions(base, element, reference, parameters, result);
}
}
return null;
}
private static <T> Throwable accepts(final Consumer<T> condition, final T actual) {
try {
condition.consume(actual);
return null;
} catch (Throwable e) {
return e;
}
}
private void restoreContext(Context context) {
setDataInternal(context.element, context.text, context.viewRect);
if (myNavigateCallback != null) {
final PsiElement element = context.element.getElement();
if (element != null) {
myNavigateCallback.consume(element);
}
}
}
@Override
public void consume(final String t) {
// User requested execution (enter clicked)
synchronized (myConsumerSemaphore) {
if (myCurrentConsumer != null) {
myCurrentConsumer.consume(t);
}
}
}
public static void getLocalCommittedChanges(
final Project project,
final VirtualFile root,
final Consumer<GitSimpleHandler> parametersSpecifier,
final Consumer<GitCommittedChangeList> consumer,
boolean skipDiffsForMerge)
throws VcsException {
GitSimpleHandler h = new GitSimpleHandler(project, root, GitCommand.LOG);
h.setSilent(true);
h.addParameters(
"--pretty=format:%x04%x01" + GitChangeUtils.COMMITTED_CHANGELIST_FORMAT, "--name-status");
parametersSpecifier.consume(h);
String output = h.run();
LOG.debug("getLocalCommittedChanges output: '" + output + "'");
StringScanner s = new StringScanner(output);
final StringBuilder sb = new StringBuilder();
boolean firstStep = true;
while (s.hasMoreData()) {
final String line = s.line();
final boolean lineIsAStart = line.startsWith("\u0004\u0001");
if ((!firstStep) && lineIsAStart) {
final StringScanner innerScanner = new StringScanner(sb.toString());
sb.setLength(0);
consumer.consume(
GitChangeUtils.parseChangeList(
project, root, innerScanner, skipDiffsForMerge, h, false, false));
}
sb.append(lineIsAStart ? line.substring(2) : line).append('\n');
firstStep = false;
}
if (sb.length() > 0) {
final StringScanner innerScanner = new StringScanner(sb.toString());
sb.setLength(0);
consumer.consume(
GitChangeUtils.parseChangeList(
project, root, innerScanner, skipDiffsForMerge, h, false, false));
}
if (s.hasMoreData()) {
throw new IllegalStateException("More input is avaialble: " + s.line());
}
}
public void processFrameworks(Consumer<Framework> consumer) {
ensureFrameworksLoaded();
for (List<FrameworkInfo> frameworkInfos : myFrameworks.values()) {
for (FrameworkInfo frameworkInfo : frameworkInfos) {
Framework framework = frameworkInfo.getFramework();
if (framework != null) {
consumer.consume(framework);
}
}
}
}
private void doAction(final MyAction action) {
LOG.debug("doAction: START " + action.name());
final MyExitAction[] exitActions;
List<Runnable> toBeCalled = null;
synchronized (myLock) {
final MyState oldState = myState;
myState = myState.transition(action);
if (oldState.equals(myState)) return;
exitActions = MyTransitionAction.getExit(oldState, myState);
LOG.debug("doAction: oldState: " + oldState.name() + ", newState: " + myState.name());
if (LOG.isDebugEnabled() && exitActions != null) {
final String debugExitActions =
StringUtil.join(
exitActions,
new Function<MyExitAction, String>() {
@Override
public String fun(MyExitAction exitAction) {
return exitAction.name();
}
},
" ");
LOG.debug("exit actions: " + debugExitActions);
}
if (exitActions != null) {
for (MyExitAction exitAction : exitActions) {
if (MyExitAction.markStart.equals(exitAction)) {
myWaitingFinishListeners.addAll(myWaitingStartListeners);
myWaitingStartListeners.clear();
} else if (MyExitAction.markEnd.equals(exitAction)) {
toBeCalled = new ArrayList<Runnable>(myWaitingFinishListeners);
myWaitingFinishListeners.clear();
}
}
}
}
if (exitActions != null) {
for (MyExitAction exitAction : exitActions) {
if (MyExitAction.submitRequestToExecutor.equals(exitAction)) {
myAlarm.consume(myWorker);
// myAlarm.addRequest(myWorker, ourDelay);
// ApplicationManager.getApplication().executeOnPooledThread(myWorker);
}
}
}
if (toBeCalled != null) {
for (Runnable runnable : toBeCalled) {
runnable.run();
}
}
LOG.debug("doAction: END " + action.name());
}
static void addCollectConversion(
PsiReferenceExpression ref,
Collection<ExpectedTypeInfo> expectedTypes,
Consumer<LookupElement> consumer) {
final PsiExpression qualifier = ref.getQualifierExpression();
PsiType component =
qualifier == null
? null
: PsiUtil.substituteTypeParameter(
qualifier.getType(), JAVA_UTIL_STREAM_STREAM, 0, true);
if (component == null) return;
JavaPsiFacade facade = JavaPsiFacade.getInstance(ref.getProject());
GlobalSearchScope scope = ref.getResolveScope();
PsiClass list = facade.findClass(JAVA_UTIL_LIST, scope);
PsiClass set = facade.findClass(JAVA_UTIL_SET, scope);
if (facade.findClass(JAVA_UTIL_STREAM_COLLECTORS, scope) == null || list == null || set == null)
return;
boolean hasList = false;
boolean hasSet = false;
for (ExpectedTypeInfo info : expectedTypes) {
PsiType type = info.getDefaultType();
PsiClass expectedClass = PsiUtil.resolveClassInClassTypeOnly(type);
PsiType expectedComponent = PsiUtil.extractIterableTypeParameter(type, true);
if (expectedClass == null
|| expectedComponent == null
|| !TypeConversionUtil.isAssignable(expectedComponent, component)) continue;
if (!hasList && InheritanceUtil.isInheritorOrSelf(list, expectedClass, true)) {
hasList = true;
consumer.consume(new MyLookupElement("toList", type));
}
if (!hasSet && InheritanceUtil.isInheritorOrSelf(set, expectedClass, true)) {
hasSet = true;
consumer.consume(new MyLookupElement("toSet", type));
}
}
}
private void processProperty(
@NotNull PsiMethod method, @NotNull GroovyResolveResult resolveResult) {
if (myIsMap) return;
final LookupElementBuilder lookup =
createPropertyLookupElement(method, resolveResult, myMatcher);
if (lookup != null) {
if (myPropertyNames.add(lookup.getLookupString())) {
myConsumer.consume(lookup);
}
} else if (myEventListener != null) {
processListenerProperties(method);
}
}
private void processPropertyFromField(
@NotNull GrField field, @NotNull GroovyResolveResult resolveResult) {
if (field.getGetters().length != 0
|| field.getSetter() != null
|| !myPropertyNames.add(field.getName())
|| myIsMap) return;
for (LookupElement element :
GroovyCompletionUtil.createLookupElements(resolveResult, false, myMatcher, null)) {
myConsumer.consume(
((LookupElementBuilder) element).withIcon(JetgroovyIcons.Groovy.Property));
}
}
public void processUncheckedNodes(
@NotNull final Consumer<DetectedFrameworkTreeNodeBase> consumer) {
TreeUtil.traverse(
getRoot(),
node -> {
if (node instanceof DetectedFrameworkTreeNodeBase) {
final DetectedFrameworkTreeNodeBase frameworkNode =
(DetectedFrameworkTreeNodeBase) node;
if (!frameworkNode.isChecked()) {
consumer.consume(frameworkNode);
}
}
return true;
});
}
private static void addClassLiteralLookupElement(
@Nullable final PsiType type,
final Consumer<LookupElement> resultSet,
final PsiFile context) {
if (type instanceof PsiClassType
&& PsiUtil.resolveClassInType(type) != null
&& !((PsiClassType) type).hasParameters()
&& !(((PsiClassType) type).resolve() instanceof PsiTypeParameter)) {
try {
resultSet.consume(
AutoCompletionPolicy.NEVER_AUTOCOMPLETE.applyPolicy(
new ClassLiteralLookupElement((PsiClassType) type, context)));
} catch (IncorrectOperationException ignored) {
}
}
}
@Override
protected boolean exec() {
myStatus = Status.STARTED;
try {
myAction.run();
complete(null); // complete manually before calling callback
} catch (Throwable throwable) {
completeExceptionally(throwable);
} finally {
myStatus = Status.EXECUTED;
if (myOnDoneCallback != null) {
myOnDoneCallback.consume(this);
}
}
return true;
}
private static void chooseAndPerform(
Editor editor, List<TestFramework> frameworks, final Consumer<TestFramework> consumer) {
if (frameworks.size() == 1) {
consumer.consume(frameworks.get(0));
return;
}
final JList list = new JBList(frameworks.toArray(new TestFramework[frameworks.size()]));
list.setCellRenderer(
new DefaultListCellRenderer() {
@Override
public Component getListCellRendererComponent(
JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
Component result =
super.getListCellRendererComponent(list, "", index, isSelected, cellHasFocus);
if (value == null) return result;
TestFramework framework = (TestFramework) value;
setIcon(framework.getIcon());
setText(framework.getName());
return result;
}
});
PopupChooserBuilder builder = new PopupChooserBuilder(list);
builder.setFilteringEnabled(
new Function<Object, String>() {
@Override
public String fun(Object o) {
return ((TestFramework) o).getName();
}
});
builder
.setTitle("Choose Framework")
.setItemChoosenCallback(
new Runnable() {
@Override
public void run() {
consumer.consume((TestFramework) list.getSelectedValue());
}
})
.setMovable(true)
.createPopup()
.showInBestPositionFor(editor);
}
public static void selectContentDescriptor(
final @NotNull Editor editor,
@NotNull Collection<RunContentDescriptor> consoles,
String selectDialogTitle,
final Consumer<RunContentDescriptor> descriptorConsumer) {
if (consoles.size() == 1) {
RunContentDescriptor descriptor = consoles.iterator().next();
descriptorConsumer.consume(descriptor);
descriptorToFront(editor, descriptor);
} else if (consoles.size() > 1) {
final JList list = new JBList(consoles);
final Icon icon = DefaultRunExecutor.getRunExecutorInstance().getIcon();
list.setCellRenderer(
new ListCellRendererWrapper<RunContentDescriptor>(list.getCellRenderer()) {
@Override
public void customize(
final JList list,
final RunContentDescriptor value,
final int index,
final boolean selected,
final boolean hasFocus) {
setText(value.getDisplayName());
setIcon(icon);
}
});
final PopupChooserBuilder builder = new PopupChooserBuilder(list);
builder.setTitle(selectDialogTitle);
builder
.setItemChoosenCallback(
new Runnable() {
@Override
public void run() {
final Object selectedValue = list.getSelectedValue();
if (selectedValue instanceof RunContentDescriptor) {
RunContentDescriptor descriptor = (RunContentDescriptor) selectedValue;
descriptorConsumer.consume(descriptor);
descriptorToFront(editor, descriptor);
}
}
})
.createPopup()
.showInBestPositionFor(editor);
}
}
@Override
public ChannelPipeline getPipeline() throws Exception {
ChannelPipeline pipeline =
pipeline(
new HttpRequestDecoder(),
new HttpChunkAggregator(1048576),
new HttpResponseEncoder());
for (Consumer<ChannelPipeline> consumer : pipelineConsumers.compute()) {
try {
consumer.consume(pipeline);
} catch (Throwable e) {
LOG.error(e);
}
}
pipeline.addLast("defaultHandler", defaultHandler);
return pipeline;
}
public DomUIFactoryImpl() {
final Function<DomElement, TableCellEditor> booleanCreator =
new Function<DomElement, TableCellEditor>() {
@Override
public TableCellEditor fun(final DomElement domElement) {
return new BooleanTableCellEditor();
}
};
registerCustomCellEditor(Boolean.class, booleanCreator);
registerCustomCellEditor(boolean.class, booleanCreator);
registerCustomCellEditor(
String.class,
new Function<DomElement, TableCellEditor>() {
@Override
public TableCellEditor fun(final DomElement domElement) {
return new DefaultCellEditor(removeBorder(new JTextField()));
}
});
Consumer<DomUIFactory>[] extensions = Extensions.getExtensions(EXTENSION_POINT_NAME);
for (Consumer<DomUIFactory> extension : extensions) {
extension.consume(this);
}
}
