com.intellij.codeInsight.CodeSmellInfo Java Examples

public CodeSmellInfo[] inspectCode(final String path, String fileContent) {
    final CodeSmellInfo[][] resultsWrapper = new CodeSmellInfo[1][];
    UIUtil.invokeAndWaitIfNeeded(new Runnable() {
        @Override
        public void run() {
            final PsiFile targetPsiFile = EmbeditorUtil.findTargetFile(path);
            Project project = targetPsiFile.getProject();
            if (targetPsiFile != null) {
                List<VirtualFile> virtualFiles = new ArrayList<VirtualFile>();
                virtualFiles.add(EmbeditorUtil.createDummyVirtualFile(project, fileContent, targetPsiFile));
                List<CodeSmellInfo> problems = CodeSmellDetector.getInstance(project).findCodeSmells(virtualFiles);
                resultsWrapper[0] = problems.toArray(new CodeSmellInfo[problems.size()]);
            }
        }
    });
    return resultsWrapper[0];
}
 

private ReturnResult processFoundCodeSmells(final List<CodeSmellInfo> codeSmells, @Nullable CommitExecutor executor) {
  int errorCount = collectErrors(codeSmells);
  int warningCount = codeSmells.size() - errorCount;
  String commitButtonText = executor != null ? executor.getActionText() : myCheckinPanel.getCommitActionName();
  if (commitButtonText.endsWith("...")) {
    commitButtonText = commitButtonText.substring(0, commitButtonText.length()-3);
  }

  final int answer = Messages.showYesNoCancelDialog(myProject,
    VcsBundle.message("before.commit.files.contain.code.smells.edit.them.confirm.text", errorCount, warningCount),
    VcsBundle.message("code.smells.error.messages.tab.name"), VcsBundle.message("code.smells.review.button"),
    commitButtonText, CommonBundle.getCancelButtonText(), UIUtil.getWarningIcon());
  if (answer == 0) {
    CodeSmellDetector.getInstance(myProject).showCodeSmellErrors(codeSmells);
    return ReturnResult.CLOSE_WINDOW;
  }
  else if (answer == 2 || answer == -1) {
    return ReturnResult.CANCEL;
  }
  else {
    return ReturnResult.COMMIT;
  }
}
 

@NeovimHandler("IntellijCodeSmell")
public Problem[] intellijCodeSmell(final String path, final List<String> lines) {
    final String fileContent = String.join("\n", lines);
    List<Problem> retval = new ArrayList<Problem>();
    CodeSmellInfo[] smells = mEmbeditorRequestHandler.inspectCode(path, fileContent);
    for (CodeSmellInfo smell : smells) {
        retval.add(new Problem(smell.getStartLine(), smell.getStartColumn(), smell.getDescription()));
    }
    return retval.toArray(new Problem[]{});
}
 

private static int collectErrors(final List<CodeSmellInfo> codeSmells) {
  int result = 0;
  for (CodeSmellInfo codeSmellInfo : codeSmells) {
    if (codeSmellInfo.getSeverity() == HighlightSeverity.ERROR) result++;
  }
  return result;
}
 

@Nonnull
private List<CodeSmellInfo> findCodeSmells(@Nonnull final VirtualFile file, @Nonnull final ProgressIndicator progress) {
  final List<CodeSmellInfo> result = Collections.synchronizedList(new ArrayList<CodeSmellInfo>());

  final DaemonCodeAnalyzerImpl codeAnalyzer = (DaemonCodeAnalyzerImpl)DaemonCodeAnalyzer.getInstance(myProject);
  final ProgressIndicator daemonIndicator = new DaemonProgressIndicator();
  ((ProgressIndicatorEx)progress).addStateDelegate(new AbstractProgressIndicatorExBase() {
    @Override
    public void cancel() {
      super.cancel();
      daemonIndicator.cancel();
    }
  });
  ProgressManager.getInstance().runProcess(new Runnable() {
    @Override
    public void run() {
      DumbService.getInstance(myProject).runReadActionInSmartMode(new Runnable() {
        @Override
        public void run() {
          final PsiFile psiFile = PsiManager.getInstance(myProject).findFile(file);
          final Document document = FileDocumentManager.getInstance().getDocument(file);
          if (psiFile == null || document == null) {
            return;
          }
          List<HighlightInfo> infos = codeAnalyzer.runMainPasses(psiFile, document, daemonIndicator);
          convertErrorsAndWarnings(infos, result, document);
        }
      });
    }
  }, daemonIndicator);

  return result;
}
 

private void convertErrorsAndWarnings(@Nonnull Collection<HighlightInfo> highlights,
                                      @Nonnull List<CodeSmellInfo> result,
                                      @Nonnull Document document) {
  for (HighlightInfo highlightInfo : highlights) {
    final HighlightSeverity severity = highlightInfo.getSeverity();
    if (SeverityRegistrar.getSeverityRegistrar(myProject).compare(severity, HighlightSeverity.WARNING) >= 0) {
      result.add(new CodeSmellInfo(document, getDescription(highlightInfo),
                                   new TextRange(highlightInfo.startOffset, highlightInfo.endOffset), severity));
    }
  }
}
 

private void executeMakeInUIThread(final VirtualFileEvent event) {
    if(project.isInitialized() && !project.isDisposed() && project.isOpen()) {
        final CompilerManager compilerManager = CompilerManager.getInstance(project);
        if(!compilerManager.isCompilationActive() &&
            !compilerManager.isExcludedFromCompilation(event.getFile()) // &&
        ) {
            // Check first if there are no errors in the code
            CodeSmellDetector codeSmellDetector = CodeSmellDetector.getInstance(project);
            boolean isOk = true;
            if(codeSmellDetector != null) {
                List<CodeSmellInfo> codeSmellInfoList = codeSmellDetector.findCodeSmells(Arrays.asList(event.getFile()));
                for(CodeSmellInfo codeSmellInfo: codeSmellInfoList) {
                    if(codeSmellInfo.getSeverity() == HighlightSeverity.ERROR) {
                        isOk = false;
                        break;
                    }
                }
            }
            if(isOk) {
                // Changed file found in module. Make it.
                final ToolWindow tw = ToolWindowManager.getInstance(project).getToolWindow(ToolWindowId.MESSAGES_WINDOW);
                final boolean isShown = tw != null && tw.isVisible();
                compilerManager.compile(
                    new VirtualFile[]{event.getFile()},
                    new CompileStatusNotification() {
                        @Override
                        public void finished(boolean b, int i, int i1, CompileContext compileContext) {
                            if (tw != null && tw.isVisible()) {
                                // Close / Hide the Build Message Window after we did the build if it wasn't shown
                                if(!isShown) {
                                    tw.hide(null);
                                }
                            }
                        }
                    }
                );
            } else {
                MessageManager messageManager = ComponentProvider.getComponent(project, MessageManager.class);
                if(messageManager != null) {
                    messageManager.sendErrorNotification(
                        "server.update.file.change.with.error",
                        event.getFile()
                    );
                }
            }
        }
    }
}
 

@Override
public void showCodeSmellErrors(@Nonnull final List<CodeSmellInfo> smellList) {
  Collections.sort(smellList, new Comparator<CodeSmellInfo>() {
    @Override
    public int compare(final CodeSmellInfo o1, final CodeSmellInfo o2) {
      return o1.getTextRange().getStartOffset() - o2.getTextRange().getStartOffset();
    }
  });

  ApplicationManager.getApplication().invokeLater(new Runnable() {
    @Override
    public void run() {
      if (myProject.isDisposed()) return;
      if (smellList.isEmpty()) {
        return;
      }

      final VcsErrorViewPanel errorTreeView = new VcsErrorViewPanel(myProject);
      AbstractVcsHelperImpl helper = (AbstractVcsHelperImpl)AbstractVcsHelper.getInstance(myProject);
      helper.openMessagesView(errorTreeView, VcsBundle.message("code.smells.error.messages.tab.name"));

      FileDocumentManager fileManager = FileDocumentManager.getInstance();

      for (CodeSmellInfo smellInfo : smellList) {
        final VirtualFile file = fileManager.getFile(smellInfo.getDocument());
        final OpenFileDescriptor navigatable =
                new OpenFileDescriptor(myProject, file, smellInfo.getStartLine(), smellInfo.getStartColumn());
        final String exportPrefix = NewErrorTreeViewPanel.createExportPrefix(smellInfo.getStartLine() + 1);
        final String rendererPrefix =
                NewErrorTreeViewPanel.createRendererPrefix(smellInfo.getStartLine() + 1, smellInfo.getStartColumn() + 1);
        if (smellInfo.getSeverity() == HighlightSeverity.ERROR) {
          errorTreeView.addMessage(MessageCategory.ERROR, new String[]{smellInfo.getDescription()}, file.getPresentableUrl(), navigatable,
                                   exportPrefix, rendererPrefix, null);
        }
        else {//if (smellInfo.getSeverity() == HighlightSeverity.WARNING) {
          errorTreeView.addMessage(MessageCategory.WARNING, new String[]{smellInfo.getDescription()}, file.getPresentableUrl(),
                                   navigatable, exportPrefix, rendererPrefix, null);
        }

      }
    }
  });

}
 

/**
 * Performs pre-checkin code analysis on the specified files.
 *
 * @param files the files to analyze.
 * @return the list of problems found during the analysis.
 * @throws ProcessCanceledException if the analysis was cancelled by the user.
 * @since 5.1
 */
@Nonnull
public abstract List<CodeSmellInfo> findCodeSmells(@Nonnull List<VirtualFile> files) throws ProcessCanceledException;
 

/**
 * Shows the specified list of problems found during pre-checkin code analysis in a Messages pane.
 *
 * @param smells the problems to show.
 * @since 5.1
 */
public abstract void showCodeSmellErrors(@Nonnull List<CodeSmellInfo> smells);