@Override
    public void navigate(MouseEvent mouseEvent, PsiElement element) {
      PsiElement parent = element.getParent();
      if (!(parent instanceof DotNetVirtualImplementOwner)
          || !OverrideUtil.isAllowForOverride(parent)) {
        return;
      }

      Collection<DotNetVirtualImplementOwner> members =
          OverrideUtil.collectOverridenMembers(((DotNetVirtualImplementOwner) parent));

      if (members.isEmpty()) {
        return;
      }

      if (members.size() == 1) {
        DotNetVirtualImplementOwner firstItem = ContainerUtil.getFirstItem(members);
        if (firstItem instanceof Navigatable) {
          ((Navigatable) firstItem).navigate(true);
        }
      } else {
        PsiElement[] elements = members.toArray(new PsiElement[members.size()]);

        JBPopup popup =
            NavigationUtil.getPsiElementPopup(
                elements,
                new ElementGutterRender(),
                "Open elements (" + elements.length + " " + "items)" + "");
        popup.show(new RelativePoint(mouseEvent));
      }
    }
  private void doUpdateRanges(
      int beforeChangedLine1, int beforeChangedLine2, int linesShift, int beforeTotalLines) {
    List<Range> rangesBeforeChange = new ArrayList<Range>();
    List<Range> rangesAfterChange = new ArrayList<Range>();
    List<Range> changedRanges = new ArrayList<Range>();

    sortRanges(
        beforeChangedLine1,
        beforeChangedLine2,
        linesShift,
        rangesBeforeChange,
        changedRanges,
        rangesAfterChange);

    Range firstChangedRange = ContainerUtil.getFirstItem(changedRanges);
    Range lastChangedRange = ContainerUtil.getLastItem(changedRanges);

    if (firstChangedRange != null && firstChangedRange.getLine1() < beforeChangedLine1) {
      beforeChangedLine1 = firstChangedRange.getLine1();
    }
    if (lastChangedRange != null && lastChangedRange.getLine2() > beforeChangedLine2) {
      beforeChangedLine2 = lastChangedRange.getLine2();
    }

    doUpdateRanges(
        beforeChangedLine1,
        beforeChangedLine2,
        linesShift,
        beforeTotalLines,
        rangesBeforeChange,
        changedRanges,
        rangesAfterChange);
  }
  @Override
  public void customizePainter(
      @NotNull JComponent component,
      @NotNull Collection<VcsRef> references,
      @Nullable VcsLogRefManager manager,
      @NotNull Color background,
      @NotNull Color foreground) {
    FontMetrics metrics = component.getFontMetrics(getReferenceFont());
    myHeight =
        metrics.getHeight()
            + RectanglePainter.TOP_TEXT_PADDING
            + RectanglePainter.BOTTOM_TEXT_PADDING;
    myWidth = 2 * PaintParameters.LABEL_PADDING;

    myLabels = ContainerUtil.newArrayList();
    if (manager == null) return;

    List<VcsRef> sorted = ContainerUtil.sorted(references, manager.getLabelsOrderComparator());

    for (Map.Entry<VcsRefType, Collection<VcsRef>> entry :
        ContainerUtil.groupBy(sorted, VcsRef::getType).entrySet()) {
      VcsRef ref = ObjectUtils.assertNotNull(ContainerUtil.getFirstItem(entry.getValue()));
      String text = ref.getName() + (entry.getValue().size() > 1 ? " +" : "");
      myLabels.add(Pair.create(text, entry.getKey().getBackgroundColor()));

      myWidth +=
          myLabelPainter.calculateSize(text, metrics).getWidth() + PaintParameters.LABEL_PADDING;
    }
  }
 private UnionScope(@NotNull GlobalSearchScope[] scopes) {
   super(
       ContainerUtil.getFirstItem(
           ContainerUtil.mapNotNull(
               scopes,
               new Function<GlobalSearchScope, Project>() {
                 @Override
                 public Project fun(GlobalSearchScope scope) {
                   return scope.getProject();
                 }
               }),
           null));
   if (scopes.length <= 1)
     throw new IllegalArgumentException("Too few scopes: " + Arrays.asList(scopes));
   myScopes = scopes;
   final int[] nested = {0};
   ContainerUtil.process(
       scopes,
       new Processor<GlobalSearchScope>() {
         @Override
         public boolean process(GlobalSearchScope scope) {
           nested[0] =
               Math.max(
                   nested[0],
                   scope instanceof UnionScope ? ((UnionScope) scope).myNestingLevel : 0);
           return true;
         }
       });
   myNestingLevel = 1 + nested[0];
   if (myNestingLevel > 1000) {
     throw new IllegalStateException(
         "Too many scopes combined: " + myNestingLevel + StringUtil.last(toString(), 500, true));
   }
 }
  private static Groups prepareGroups(
      @NotNull VcsLogDataPack dataPack,
      @Nullable Collection<VirtualFile> visibleRoots,
      @Nullable List<List<String>> recentItems) {
    Groups filteredGroups = new Groups();
    Collection<VcsRef> allRefs = dataPack.getRefs().getBranches();
    for (Map.Entry<VirtualFile, Set<VcsRef>> entry :
        VcsLogUtil.groupRefsByRoot(allRefs).entrySet()) {
      VirtualFile root = entry.getKey();
      if (visibleRoots != null && !visibleRoots.contains(root)) continue;
      Collection<VcsRef> refs = entry.getValue();
      VcsLogProvider provider = dataPack.getLogProviders().get(root);
      VcsLogRefManager refManager = provider.getReferenceManager();
      List<RefGroup> refGroups = refManager.group(refs);

      putActionsForReferences(refGroups, filteredGroups);
    }

    if (recentItems != null) {
      for (List<String> recentItem : recentItems) {
        if (recentItem.size() == 1) {
          final String item = ContainerUtil.getFirstItem(recentItem);
          if (filteredGroups.singletonGroups.contains(item)
              || ContainerUtil.find(
                      filteredGroups.expandedGroups.values(), strings -> strings.contains(item))
                  != null) {
            continue;
          }
        }
        filteredGroups.recentGroups.add(recentItem);
      }
    }

    return filteredGroups;
  }
  private void updateActiveTarget(
      @Nullable RunnerAndConfigurationSettings settings, @Nullable ExecutionTarget toSelect) {
    List<ExecutionTarget> suitable =
        settings == null
            ? Collections.singletonList(DefaultExecutionTarget.INSTANCE)
            : getTargetsFor(settings);
    ExecutionTarget toNotify;
    synchronized (myActiveTargetLock) {
      if (toSelect == null) toSelect = myActiveTarget;

      int index = -1;
      if (toSelect != null) {
        index = suitable.indexOf(toSelect);
      } else if (mySavedActiveTargetId != null) {
        for (int i = 0, size = suitable.size(); i < size; i++) {
          if (suitable.get(i).getId().equals(mySavedActiveTargetId)) {
            index = i;
            break;
          }
        }
      }
      toNotify =
          doSetActiveTarget(
              index >= 0
                  ? suitable.get(index)
                  : ContainerUtil.getFirstItem(suitable, DefaultExecutionTarget.INSTANCE));
    }

    if (toNotify != null) {
      myProject.getMessageBus().syncPublisher(TOPIC).activeTargetChanged(toNotify);
    }
  }
 @Nullable
 private String getLatestPackageVersionFromPyPI(@NotNull String packageName) throws IOException {
   LOG.debug("Requesting the latest PyPI version for the package " + packageName);
   final List<String> versions = getPackageVersionsFromPyPI(packageName, true);
   final String latest = ContainerUtil.getFirstItem(versions);
   getPyPIPackages().put(packageName, StringUtil.notNullize(latest));
   return latest;
 }
 @Override
 public PsiElement resolveInner() {
   GlobalSearchScope scope = getSearchScope();
   List<ErlangModule> modules =
       ErlangModuleIndex.getModulesByName(myElement.getProject(), myReferenceName, scope);
   if (modules.size() > 1) {
     ContainerUtil.sort(modules, new ModuleResolutionComparator());
   }
   return ContainerUtil.getFirstItem(modules);
 }
 @NotNull
 private String findPresetHttpUrl() {
   return ObjectUtils.chooseNotNull(
       ContainerUtil.find(
           myUrlsFromCommand,
           url -> {
             String scheme = UriUtil.splitScheme(url).getFirst();
             return scheme.startsWith("http");
           }),
       ContainerUtil.getFirstItem(myUrlsFromCommand));
 }
 @Nullable
 private IProperty getSelectedProperty() {
   final Collection<DefaultMutableTreeNode> selectedNode = getSelectedNodes();
   if (selectedNode.isEmpty()) {
     return null;
   }
   final ResourceBundleEditorViewElement element =
       getSelectedElement(ContainerUtil.getFirstItem(selectedNode));
   return element instanceof ResourceBundlePropertyStructureViewElement
       ? ((ResourceBundlePropertyStructureViewElement) element).getProperty()
       : null;
 }
  @NotNull
  public static <T> Promise<T> chooseDebuggee(
      @NotNull final Collection<T> targets,
      final int selectedIndex,
      @NotNull final Function<T, String> itemToString) {
    if (targets.size() == 1) {
      return Promise.resolve(ContainerUtil.getFirstItem(targets));
    } else if (targets.isEmpty()) {
      return Promise.reject("No tabs to inspect");
    }

    final AsyncPromise<T> result = new AsyncPromise<T>();
    ApplicationManager.getApplication()
        .invokeLater(
            new Runnable() {
              @Override
              public void run() {
                final JBList list = new JBList(targets);
                list.setCellRenderer(
                    new ColoredListCellRenderer() {
                      @Override
                      protected void customizeCellRenderer(
                          JList list, Object value, int index, boolean selected, boolean hasFocus) {
                        //noinspection unchecked
                        append(itemToString.fun((T) value));
                      }
                    });
                if (selectedIndex != -1) {
                  list.setSelectedIndex(selectedIndex);
                }

                JBPopupFactory.getInstance()
                    .createListPopupBuilder(list)
                    .setTitle("Choose Page to Debug")
                    .setItemChoosenCallback(
                        new Runnable() {
                          @Override
                          public void run() {
                            @SuppressWarnings("unchecked")
                            T value = (T) list.getSelectedValue();
                            if (value == null) {
                              result.setError(Promise.createError("No target to inspect"));
                            } else {
                              result.setResult(value);
                            }
                          }
                        })
                    .createPopup()
                    .showInFocusCenter();
              }
            });
    return result;
  }
  private void doUpdateRanges(
      int beforeChangedLine1,
      int beforeChangedLine2,
      int linesShift, // before -> after
      int beforeTotalLines,
      @NotNull List<Range> rangesBefore,
      @NotNull List<Range> changedRanges,
      @NotNull List<Range> rangesAfter) {
    try {
      int vcsTotalLines = getLineCount(myVcsDocument);

      Range lastRangeBefore = ContainerUtil.getLastItem(rangesBefore);
      Range firstRangeAfter = ContainerUtil.getFirstItem(rangesAfter);

      //noinspection UnnecessaryLocalVariable
      int afterChangedLine1 = beforeChangedLine1;
      int afterChangedLine2 = beforeChangedLine2 + linesShift;

      int vcsLine1 = getVcsLine1(lastRangeBefore, beforeChangedLine1);
      int vcsLine2 =
          getVcsLine2(firstRangeAfter, beforeChangedLine2, beforeTotalLines, vcsTotalLines);

      List<Range> newChangedRanges =
          getNewChangedRanges(afterChangedLine1, afterChangedLine2, vcsLine1, vcsLine2);

      shiftRanges(rangesAfter, linesShift);

      if (!changedRanges.equals(newChangedRanges)) {
        replaceRanges(changedRanges, newChangedRanges);

        myRanges =
            new ArrayList<Range>(
                rangesBefore.size() + newChangedRanges.size() + rangesAfter.size());

        myRanges.addAll(rangesBefore);
        myRanges.addAll(newChangedRanges);
        myRanges.addAll(rangesAfter);

        for (Range range : myRanges) {
          if (!range.hasHighlighter()) range.setHighlighter(createHighlighter(range));
        }

        if (myRanges.isEmpty()) {
          markFileUnchanged();
        }
      }
    } catch (ProcessCanceledException ignore) {
    } catch (FilesTooBigForDiffException e1) {
      installAnathema();
      removeHighlightersFromMarkupModel();
    }
  }
  public void testNoParenthesisSurrounderForLambdaParameter() {
    configureByFile(BASE_PATH + getTestName(false) + ".java");

    SurroundDescriptor item =
        ContainerUtil.getFirstItem(
            LanguageSurrounders.INSTANCE.allForLanguage(JavaLanguage.INSTANCE));
    assertNotNull(item);
    SelectionModel selectionModel = getEditor().getSelectionModel();
    PsiElement[] elements =
        item.getElementsToSurround(
            getFile(), selectionModel.getSelectionStart(), selectionModel.getSelectionEnd());
    assertEmpty(elements);
  }
  @Override
  public void actionPerformed(AnActionEvent e) {
    final Project project = getProject(e);
    final ProjectSystemId projectSystemId = getSystemId(e);

    final List<ExternalSystemNode> selectedNodes =
        ExternalSystemDataKeys.SELECTED_NODES.getData(e.getDataContext());

    final ExternalProjectInfo projectInfo;
    final ExternalSystemNode<?> externalSystemNode = ContainerUtil.getFirstItem(selectedNodes);
    if (externalSystemNode == null) {
      projectInfo =
          ContainerUtil.getFirstItem(
              ProjectDataManager.getInstance().getExternalProjectsData(project, projectSystemId));
    } else {
      final ProjectNode projectNode =
          externalSystemNode instanceof ProjectNode
              ? (ProjectNode) externalSystemNode
              : externalSystemNode.findParent(ProjectNode.class);
      assert projectNode != null;

      final ProjectData projectData = projectNode.getData();
      assert projectData != null;
      projectInfo =
          ProjectDataManager.getInstance()
              .getExternalProjectData(
                  project, projectSystemId, projectData.getLinkedExternalProjectPath());
    }

    final ExternalProjectDataSelectorDialog dialog;
    if (projectInfo != null) {
      dialog =
          new ExternalProjectDataSelectorDialog(
              project,
              projectInfo,
              externalSystemNode != null ? externalSystemNode.getData() : null);
      dialog.showAndGet();
    }
  }
  public static void addTypeAndClassifierAndVersion(
      @NotNull InsertionContext context,
      @NotNull MavenDomDependency dependency,
      @NotNull String groupId,
      @NotNull String artifactId) {
    if (!StringUtil.isEmpty(dependency.getVersion().getStringValue())) return;

    Project project = context.getProject();

    if (!isInsideManagedDependency(dependency)) {
      MavenDomProjectModel model =
          DomUtil.<MavenDomProjectModel>getFileElement(dependency).getRootElement();
      MavenDomDependency managedDependency =
          findManagedDependency(model, project, groupId, artifactId);
      if (managedDependency != null) {
        if (dependency.getClassifier().getXmlTag() == null
            && dependency.getType().getXmlTag() == null) {
          String classifier = managedDependency.getClassifier().getRawText();
          if (StringUtil.isNotEmpty(classifier)) {
            dependency.getClassifier().setStringValue(classifier);
          }
          String type = managedDependency.getType().getRawText();
          if (StringUtil.isNotEmpty(type)) {
            dependency.getType().setStringValue(type);
          }
        }
        return;
      }
    }

    MavenProjectIndicesManager manager = MavenProjectIndicesManager.getInstance(project);

    Set<String> versions = manager.getVersions(groupId, artifactId);
    if (versions.size() == 1) {
      dependency.getVersion().setStringValue(ContainerUtil.getFirstItem(versions));
      return;
    }

    dependency.getVersion().setStringValue("");

    int versionPosition =
        dependency.getVersion().getXmlTag().getValue().getTextRange().getStartOffset();

    context.getEditor().getCaretModel().moveToOffset(versionPosition);

    if (versions.size() > 0) {
      invokeCompletion(context, CompletionType.BASIC);
    }
  }
 public void testEunitFullErrorPath() {
   FileReferenceFilter compilationErrorFilter =
       new FileReferenceFilter(getProject(), EUNIT_ERROR_PATH);
   File base = new File(getProject().getBaseDir().getPath());
   File file =
       ContainerUtil.getFirstItem(FileUtil.findFilesByMask(Pattern.compile(".*\\.erl"), base));
   VirtualFile vFile = LocalFileSystem.getInstance().findFileByIoFile(file);
   assertNotNull(vFile);
   String canonicalPath = vFile.getCanonicalPath();
   final String consoleOutput =
       "in function bisect_server_test:'-false_test/0-fun-0-'/0 (" + canonicalPath + ", line 14)";
   final Filter.Result result =
       compilationErrorFilter.applyFilter(consoleOutput, consoleOutput.length());
   assertNotNull(result.hyperlinkInfo);
 }
 @NotNull
 @Override
 public Condition<CommitId> getContainedInBranchCondition(
     @NotNull final Collection<CommitId> heads) {
   List<Integer> headIds =
       ContainerUtil.map(
           heads,
           new Function<CommitId, Integer>() {
             @Override
             public Integer fun(CommitId head) {
               return myPermanentCommitsInfo.getNodeId(head);
             }
           });
   if (!heads.isEmpty() && ContainerUtil.getFirstItem(heads) instanceof Integer) {
     final TIntHashSet branchNodes = new TIntHashSet();
     myReachableNodes.walk(
         headIds,
         new Consumer<Integer>() {
           @Override
           public void consume(Integer node) {
             branchNodes.add((Integer) myPermanentCommitsInfo.getCommitId(node));
           }
         });
     return new Condition<CommitId>() {
       @Override
       public boolean value(CommitId commitId) {
         return branchNodes.contains((Integer) commitId);
       }
     };
   } else {
     final Set<CommitId> branchNodes = ContainerUtil.newHashSet();
     myReachableNodes.walk(
         headIds,
         new Consumer<Integer>() {
           @Override
           public void consume(Integer node) {
             branchNodes.add(myPermanentCommitsInfo.getCommitId(node));
           }
         });
     return new Condition<CommitId>() {
       @Override
       public boolean value(CommitId commitId) {
         return branchNodes.contains(commitId);
       }
     };
   }
 }
  private void doTest(@NotNull String fileName, Surrounder surrounder) {
    configureByFile(BASE_PATH + fileName + ".java");

    SurroundDescriptor item =
        ContainerUtil.getFirstItem(
            LanguageSurrounders.INSTANCE.allForLanguage(JavaLanguage.INSTANCE));
    assertNotNull(item);
    SelectionModel selectionModel = getEditor().getSelectionModel();
    PsiElement[] elements =
        item.getElementsToSurround(
            getFile(), selectionModel.getSelectionStart(), selectionModel.getSelectionEnd());
    assertTrue(surrounder.isApplicable(elements));

    SurroundWithHandler.invoke(getProject(), getEditor(), getFile(), surrounder);

    checkResultByFile(BASE_PATH + fileName + "_after.java");
  }
  public boolean checkCanModify(final Collection<PackagingNodeSource> nodeSources) {
    if (nodeSources.isEmpty()) {
      return true;
    }

    if (nodeSources.size() > 1) {
      Messages.showErrorDialog(
          myArtifactsEditor.getMainComponent(),
          "The selected node consist of several elements so it cannot be edited.\nSwitch off 'Show content of elements' checkbox to edit the output layout.");
    } else {
      final PackagingNodeSource source = ContainerUtil.getFirstItem(nodeSources, null);
      if (source != null) {
        Messages.showErrorDialog(
            myArtifactsEditor.getMainComponent(),
            "The selected node belongs to '"
                + source.getPresentableName()
                + "' element so it cannot be edited.\nSwitch off 'Show content of elements' checkbox to edit the output layout.");
      }
    }
    return false;
  }
 @Nullable
 public ResourceBundleEditorViewElement getSelectedElementIfOnlyOne() {
   final Collection<ResourceBundleEditorViewElement> selectedElements = getSelectedElements();
   return selectedElements.size() == 1 ? ContainerUtil.getFirstItem(selectedElements) : null;
 }
 @Nullable
 private String getLatestPackageVersionFromAdditionalRepositories(@NotNull String packageName)
     throws IOException {
   final List<String> versions = getPackageVersionsFromAdditionalRepositories(packageName);
   return ContainerUtil.getFirstItem(versions);
 }
 @NotNull
 @Override
 public PropertiesFile getDefaultPropertiesFile() {
   return ContainerUtil.getFirstItem(myFiles);
 }
Ejemplo n.º 23
0
  QuickEditHandler(
      Project project,
      @NotNull PsiFile injectedFile,
      final PsiFile origFile,
      Editor editor,
      QuickEditAction action) {
    myProject = project;
    myEditor = editor;
    myAction = action;
    myOrigDocument = editor.getDocument();
    Place shreds = InjectedLanguageUtil.getShreds(injectedFile);
    FileType fileType = injectedFile.getFileType();
    Language language = injectedFile.getLanguage();
    PsiLanguageInjectionHost.Shred firstShred = ContainerUtil.getFirstItem(shreds);

    PsiFileFactory factory = PsiFileFactory.getInstance(project);
    String text = InjectedLanguageManager.getInstance(project).getUnescapedText(injectedFile);
    String newFileName =
        StringUtil.notNullize(language.getDisplayName(), "Injected")
            + " Fragment "
            + "("
            + origFile.getName()
            + ":"
            + firstShred.getHost().getTextRange().getStartOffset()
            + ")"
            + "."
            + fileType.getDefaultExtension();

    // preserve \r\n as it is done in MultiHostRegistrarImpl
    myNewFile = factory.createFileFromText(newFileName, language, text, true, false);
    myNewVirtualFile = ObjectUtils.assertNotNull((LightVirtualFile) myNewFile.getVirtualFile());
    myNewVirtualFile.setOriginalFile(origFile.getVirtualFile());

    assert myNewFile != null : "PSI file is null";
    assert myNewFile.getTextLength() == myNewVirtualFile.getContent().length()
        : "PSI / Virtual file text mismatch";

    myNewVirtualFile.setOriginalFile(origFile.getVirtualFile());
    // suppress possible errors as in injected mode
    myNewFile.putUserData(
        InjectedLanguageUtil.FRANKENSTEIN_INJECTION,
        injectedFile.getUserData(InjectedLanguageUtil.FRANKENSTEIN_INJECTION));
    myNewFile.putUserData(FileContextUtil.INJECTED_IN_ELEMENT, shreds.getHostPointer());
    myNewDocument = PsiDocumentManager.getInstance(project).getDocument(myNewFile);
    assert myNewDocument != null;
    EditorActionManager.getInstance()
        .setReadonlyFragmentModificationHandler(myNewDocument, new MyQuietHandler());
    myOrigCreationStamp =
        myOrigDocument.getModificationStamp(); // store creation stamp for UNDO tracking
    myOrigDocument.addDocumentListener(this, this);
    myNewDocument.addDocumentListener(this, this);
    EditorFactory editorFactory = ObjectUtils.assertNotNull(EditorFactory.getInstance());
    // not FileEditorManager listener because of RegExp checker and alike
    editorFactory.addEditorFactoryListener(
        new EditorFactoryAdapter() {
          int useCount;

          @Override
          public void editorCreated(@NotNull EditorFactoryEvent event) {
            if (event.getEditor().getDocument() != myNewDocument) return;
            useCount++;
          }

          @Override
          public void editorReleased(@NotNull EditorFactoryEvent event) {
            if (event.getEditor().getDocument() != myNewDocument) return;
            if (--useCount > 0) return;
            if (Boolean.TRUE.equals(
                myNewVirtualFile.getUserData(FileEditorManagerImpl.CLOSING_TO_REOPEN))) return;

            Disposer.dispose(QuickEditHandler.this);
          }
        },
        this);

    if ("JAVA".equals(firstShred.getHost().getLanguage().getID())) {
      PsiLanguageInjectionHost.Shred lastShred = ContainerUtil.getLastItem(shreds);
      myAltFullRange =
          myOrigDocument.createRangeMarker(
              firstShred.getHostRangeMarker().getStartOffset(),
              lastShred.getHostRangeMarker().getEndOffset());
      myAltFullRange.setGreedyToLeft(true);
      myAltFullRange.setGreedyToRight(true);

      initGuardedBlocks(shreds);
      myInjectedFile = null;
    } else {
      initMarkers(shreds);
      myAltFullRange = null;
      myInjectedFile = injectedFile;
    }
  }