Java Code Examples for com.intellij.openapi.project.Project

public void showHint(Project project) {
  Course course = StudyTaskManager.getInstance(project).getCourse();
  if (course == null) {
    return;
  }
  StudyState studyState = new StudyState(StudyUtils.getSelectedStudyEditor(project));
  if (!studyState.isValid()) {
    return;
  }
  PsiFile file = PsiManager.getInstance(project).findFile(studyState.getVirtualFile());
  final Editor editor = studyState.getEditor();
  int offset = editor.getCaretModel().getOffset();
  AnswerPlaceholder answerPlaceholder = studyState.getTaskFile().getAnswerPlaceholder(offset);
  if (file == null) {
    return;
  }
  EduUsagesCollector.hintShown();

  final StudyToolWindow hintComponent = getHint(project, answerPlaceholder).getStudyToolWindow();
  hintComponent.setPreferredSize(new Dimension(400, 150));
  showHintPopUp(project, studyState, editor, hintComponent);
}
 

public static void showTestResultsToolWindow(@NotNull final Project project, @NotNull final String message) {
  ApplicationManager.getApplication().invokeLater(() -> {
    final ToolWindowManager toolWindowManager = ToolWindowManager.getInstance(project);
    ToolWindow window = toolWindowManager.getToolWindow(StudyTestResultsToolWindowFactoryKt.ID);
    if (window == null) {
      toolWindowManager.registerToolWindow(StudyTestResultsToolWindowFactoryKt.ID, true, ToolWindowAnchor.BOTTOM);
      window = toolWindowManager.getToolWindow(StudyTestResultsToolWindowFactoryKt.ID);
      new StudyTestResultsToolWindowFactory().createToolWindowContent(project, window);
    }

    final Content[] contents = window.getContentManager().getContents();
    for (Content content : contents) {
      final JComponent component = content.getComponent();
      if (component instanceof ConsoleViewImpl) {
        ((ConsoleViewImpl)component).clear();
        ((ConsoleViewImpl)component).print(message, ConsoleViewContentType.ERROR_OUTPUT);
        window.setAvailable(true,null);
        window.show(null);
      }
    }
  });
}
 

private static void showMessage(final Project project, final MessageType messageType, final String format, final Object[] args) {
    StatusBar statusBar = windowManager.getStatusBar(project);
    if(statusBar == null || statusBar.getComponent() == null){
        return;
    }
    String message = String.format(format, args);
    jbPopupFactory.createHtmlTextBalloonBuilder(message, messageType, null)
                .setFadeoutTime(7500)
                .createBalloon()
                .show(RelativePoint.getNorthEastOf(statusBar.getComponent()), Balloon.Position.atRight);

    if(messageType == MessageType.INFO){
        log.info(message);
    }
    else if(messageType == MessageType.WARNING) {
        log.warn(message);
    }
    else{
        log.debug(message);
    }
}
 

@Override
protected MultiMap<PsiFile, ClassNode> computeChildren(@Nullable PsiFile psiFile) {
    MultiMap<PsiFile, ClassNode> children = new MultiMap<>();
    children.putValue(aggregateRoot.getContainingFile(), new AggregateRootNode(this, aggregateRoot));
    Project project = getProject();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass entityInterface = javaPsiFacade.findClass(ENTITY_INTERFACE, GlobalSearchScope.allScope(project));
        PsiClass valueObjectInterface = javaPsiFacade.findClass(VO_INTERFACE, GlobalSearchScope.allScope(project));
        if (entityInterface != null && valueObjectInterface != null) {
            for (PsiClass psiClass : psiPackage.getClasses(GlobalSearchScope.allScope(project))) {
                if (psiClass.isInheritor(entityInterface, true) && !psiClass.equals(aggregateRoot)) {
                    children.putValue(psiClass.getContainingFile(), new EntityNode(this, psiClass));
                } else if (psiClass.isInheritor(valueObjectInterface, true)) {
                    children.putValue(psiClass.getContainingFile(), new ValueObjectNode(this, psiClass));
                }
            }
        }
    }
    return children;
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(final boolean incompleteCode) {
    Project project = myElement.getProject();
    final String enumLiteralJavaModelName = myElement.getText().replaceAll("\"", "").toUpperCase();

    final PsiShortNamesCache psiShortNamesCache = PsiShortNamesCache.getInstance(project);
    final PsiField[] javaEnumLiteralFields = psiShortNamesCache.getFieldsByName(
        enumLiteralJavaModelName, GlobalSearchScope.allScope(project)
    );

    final Set<PsiField> enumFields = stream(javaEnumLiteralFields)
        .filter(literal -> literal.getParent() != null)
        .filter(literal -> literal.getParent() instanceof ClsClassImpl)
        .filter(literal -> ((ClsClassImpl) literal.getParent()).isEnum())
        .collect(Collectors.toSet());

    return PsiElementResolveResult.createResults(enumFields);
}
 

@Override
public PsiDirectory createLessonContent(@NotNull Project project, @NotNull Lesson lesson, @Nullable IdeView view, @NotNull PsiDirectory parentDirectory) {
  NewModuleAction newModuleAction = new NewModuleAction();
  String courseDirPath = parentDirectory.getVirtualFile().getPath();
  Module utilModule = ModuleManager.getInstance(project).findModuleByName(EduIntelliJNames.UTIL);
  if (utilModule == null) {
    return null;
  }
  newModuleAction.createModuleFromWizard(project, null, new AbstractProjectWizard("", project, "") {
    @Override
    public StepSequence getSequence() {
      return null;
    }

    @Override
    public ProjectBuilder getProjectBuilder() {
      return new EduLessonModuleBuilder(courseDirPath, lesson, utilModule);
    }
  });
  return parentDirectory.findSubdirectory(EduNames.LESSON + lesson.getIndex());
}
 

public ApplicationDictionaryImpl(@NotNull Project project, @NotNull XmlFile dictionaryXmlFile,
                                 @NotNull String applicationName, @Nullable File applicationBundleFile) {
  this.project = project;
  this.dictionaryFile = dictionaryXmlFile.getVirtualFile();
  readDictionaryFromXmlFile(dictionaryXmlFile);
  this.applicationName = applicationName;
  if (applicationBundleFile != null) {
    this.applicationBundleFile = applicationBundleFile;
    setIconFromBundle(applicationBundleFile);
  }
  if (StringUtil.isEmpty(dictionaryName))
    dictionaryName = this.applicationName;
  LOG.info("Dictionary [" + dictionaryName + "] for application [" + this.applicationName + "] " +
          "initialized In project[" + project.getName() + "] " + " Commands: " + dictionaryCommandMap.size() +
          ". " + "Classes: " + dictionaryClassMap.size());
}
 

@Override
public void createToolWindowContent(@NotNull final Project project, @NotNull ToolWindow toolWindow) {
    SimpleToolWindowPanel panel = new SimpleToolWindowPanel(false, true);

    BsConsole console = new BsConsole(project);
    panel.setContent(console.getComponent());

    ActionToolbar toolbar = console.createToolbar();
    panel.setToolbar(toolbar.getComponent());

    Content content = ContentFactory.SERVICE.getInstance().createContent(panel, "", true);
    toolWindow.getContentManager().addContent(content);

    // Start compiler
    BsCompiler bsc = BucklescriptProjectComponent.getInstance(project).getCompiler();
    if (bsc != null) {
        bsc.addListener(new BsOutputListener(project));
        ProcessHandler handler = bsc.getHandler();
        if (handler == null) {
            console.print("Bsb not found, check the event logs.", ERROR_OUTPUT);
        } else {
            console.attachToProcess(handler);
        }
        bsc.startNotify();
    }
}
 

@Nullable
public static StudyToolWindow getStudyToolWindow(@NotNull final Project project) {
  if (project.isDisposed()) return null;

  ToolWindow toolWindow = ToolWindowManager.getInstance(project).getToolWindow(StudyToolWindowFactory.STUDY_TOOL_WINDOW);
  if (toolWindow != null) {
    Content[] contents = toolWindow.getContentManager().getContents();
    for (Content content: contents) {
      JComponent component = content.getComponent();
      if (component != null && component instanceof StudyToolWindow) {
        return (StudyToolWindow)component;
      }
    }
  }
  return null;
}
 

@Override
protected void addCompletions(@NotNull CompletionParameters parameters, ProcessingContext context, @NotNull CompletionResultSet result) {
    String namespace = parameters.getPosition().getPrevSibling().getPrevSibling().getText();

    Project project = parameters.getOriginalFile().getProject();
    Collection<TSFnDeclStmt> functions = TSUtil.getFunctionList(project);

    for (TSFnDeclStmt function : functions) {
        if (function.getFunctionType() == TSFunctionType.GLOBAL)
            continue;
        if (namespace != null && !function.getNamespace().equalsIgnoreCase(namespace))
            continue;

        result.addElement(
                LookupElementBuilder.create(function.getFunctionName())
                        .withCaseSensitivity(false)
                        .withPresentableText(function.getNamespace() + "::" + function.getFunctionName())
                        .withTailText(function.getArgList())
                        .withInsertHandler(TSCaseCorrectingInsertHandler.INSTANCE)
        );
    }
}
 

/**
 * Inserts the string generated by {@link #generateString()} at the caret(s) in the editor.
 *
 * @param event the performed action
 */
@Override
public final void actionPerformed(final AnActionEvent event) {
    final Editor editor = event.getData(CommonDataKeys.EDITOR);
    if (editor == null) {
        return;
    }
    final Project project = event.getData(CommonDataKeys.PROJECT);
    final Document document = editor.getDocument();
    final CaretModel caretModel = editor.getCaretModel();

    final Runnable replaceCaretSelections = () -> caretModel.getAllCarets().forEach(caret -> {
        final int start = caret.getSelectionStart();
        final int end = caret.getSelectionEnd();

        final String string = generateString();
        final int newEnd = start + string.length();

        document.replaceString(start, end, string);
        caret.setSelection(start, newEnd);
    });

    WriteCommandAction.runWriteCommandAction(project, replaceCaretSelections);
}
 

@Nullable
@Override
public MetadataNode findDeepestExactMatch(Project project, Module module,
    List<String> containerElements) {
  if (moduleNameToSanitisedRootSearchIndex.containsKey(module.getName())) {
    String[] pathSegments =
        containerElements.stream().flatMap(element -> stream(toPathSegments(element)))
            .toArray(String[]::new);
    MetadataNode searchStartNode = moduleNameToSanitisedRootSearchIndex.get(module.getName())
        .get(MetadataNode.sanitize(pathSegments[0]));
    if (searchStartNode != null) {
      if (pathSegments.length > 1) {
        return searchStartNode.findDeepestMatch(pathSegments, 1, true);
      }
      return searchStartNode;
    }
  }
  return null;
}
 

@NotNull
public static PsiElement[] getIconDefinitionElements(@NotNull Project project, @NotNull String identifier) {
    Map<VirtualFile, IconStub> iconDefinitionByIdentifier = getIconDefinitionByIdentifier(project, identifier);
    if (iconDefinitionByIdentifier.size() > 0) {
        return iconDefinitionByIdentifier
                .keySet()
                .stream()
                .map(virtualFile -> {
                    IconStub iconStub = iconDefinitionByIdentifier.get(virtualFile);
                    PsiFile file = PsiManager.getInstance(project).findFile(virtualFile);
                    return file != null ? file.findElementAt(iconStub.getTextRange().getStartOffset()) : null;
                })
                .filter(Objects::nonNull)
                .toArray(PsiElement[]::new);
    }

    return new PsiElement[0];
}
 

public void addAnnotation(Project project) {
    for (FieldEntity entity : getFieldList()) {
        entity.addAnnotation(project);
    }

    editTableAnnotation(project, tablePsiAnnotation, getSelectedEntities().size() == 0);

    PsiJavaFile javaFile = (PsiJavaFile) psiClass.getContainingFile();
    Utils.saveDocument(javaFile);

    Utils.addImport(project, javaFile, null, AormConstants.tableQName, AormConstants.columnQName);
    Utils.optimizeImport(project, psiClass);

    CodeStyleManager.getInstance(project).reformat(psiClass);
    Utils.saveDocument(psiClass.getContainingFile());
}
 

@Override
public void actionPerformed(AnActionEvent e) {
    final Project project = e.getRequiredData(CommonDataKeys.PROJECT);
    final Editor editor = e.getRequiredData(CommonDataKeys.EDITOR);
    final PsiFile psiFile = e.getRequiredData(CommonDataKeys.PSI_FILE);
    
    CommandProcessor.getInstance().executeCommand(project, () -> {
        try {
            MultiHighlightHandler.invoke(project, editor, psiFile);
        } catch (IndexNotReadyException ex) {
            DumbService.getInstance(project)
                    .showDumbModeNotification("MultiHighlight requires indices "
                            + "and cannot be performed until they are built");
        }
    }, "MultiHighlight", null);
}
 

public List<PsiElement> getGeneratedPsiElements(Project project) {
    PsiClass classFromText =
            JavaPsiFacade.getInstance(project).getElementFactory().createClassFromText(
                    new ValueClass(variables, sourceClass).asString(), null);
    classFromText.setName(sourceClass.getName());

    List<PsiElement> result = new ArrayList<>();
    Stream.of(classFromText.getAllFields()).forEach(psiField -> result.add(psiField));
    Stream.of(classFromText.getInnerClasses()).forEach(psiClass -> result.add(psiClass));
    Stream.of(classFromText.getMethods()).forEach(psiClass -> result.add(psiClass)); // getMethod contains all constructors
    return result;
}
 

private Builder(@NotNull Project project, @Nonnull Json2JavaBundle bundle) {
    this.project = project;
    this.bundle = bundle;
    this.nameValidator = new NullValidator();
    this.jsonValidator = new NullValidator();
    this.actionListener = new ActionListener() {
    };
}
 

@Override
public void actionPerformed(AnActionEvent e) {
    Project project = PsiUtil.getProject(e);
    DumbService dumbService = DumbService.getInstance(project);
    if (dumbService.isDumb()) {
        dumbService.showDumbModeNotification(CodeGenBundle.message("codegen.plugin.is.not.available.during.indexing"));
        return;
    }

    Iterator<DbElement> iterator = DatabaseView.getSelectedElements(e.getDataContext(), DbElement.class).iterator();

    List<DbTable> tables = new ArrayList<>();
    while (iterator.hasNext()) {
        DbElement table = iterator.next();
        if (table instanceof DbTable) {
            tables.add((DbTable) table);
        }
    }

    ColumnEditorFrame frame = new ColumnEditorFrame();
    frame.newColumnEditorByDb(new IdeaContext(project), tables);
    frame.setSize(800, 550);
    frame.setLocationRelativeTo(null);
    frame.setAlwaysOnTop(true);
    frame.setResizable(false);
    frame.setVisible(true);
}
 

@Override
public void actionPerformed(AnActionEvent e) {
    final Project project = e.getProject();
    if (project == null) {
        return;
    }
    new CodeStyleManager(project.getBasePath()).sync();
}
 

void TransformToPng() {
  Project project = MPSDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext());
  String filegv = ProjectBaseDirectory.getInstance(project).getBaseDir().getCanonicalPath() + "/graphviz/visualiser.gv";
  String filepng = ProjectBaseDirectory.getInstance(project).getBaseDir().getCanonicalPath() + "/graphviz/visualiser.png";
  String[] commandarray = {"/bin/sh", "-c", "neato " + "-Tpng " + filegv + " > " + filepng};
  System.out.println("Running command");
  String result = ExecuteCommand(commandarray);
  System.out.println("Command executed with result" + result);
}
 

@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
    PsiElement item = descriptor.getPsiElement();

    PsiElement context = item.getContext();
    if (context instanceof ArrayCreationExpression) {
        ArrayCreationExpression params = (ArrayCreationExpression) item.getParent();

        PsiUtil.deleteArrayElement(item);

        if (!params.getHashElements().iterator().hasNext()) {
            if (params.getPrevSibling() instanceof PsiWhiteSpace) {
                params.getPrevSibling().delete();
            }
            params.getPrevSibling().delete();
            params.delete();
        }
    }
    if (context instanceof ParameterList && context.getParent() instanceof FunctionReference) {
        FunctionReference functionReference = (FunctionReference) context.getParent();
        if (functionReference.getName() != null && functionReference.getName().equals("compact")) {
            PsiUtil.deleteFunctionParam(item);

            if (functionReference.getParameters().length == 0) {
                PsiUtil.deleteFunctionParam(functionReference);
            }
        }
    }
}
 

@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
    final PsiElement element = descriptor.getPsiElement().getParent();
    PsiDirectory directory;
    String path = null;

    if (element instanceof StringLiteralExpression) {
        path = ((StringLiteralExpression) element).getContents();
    }

    if (path == null) {
        return;
    }

    if (path.startsWith("/")) {
        directory = ViewsUtil.getRootDirectory(element);
        path = path.substring(1);
    } else {
        directory = ViewsUtil.getContextDirectory(element);
    }

    if (directory == null) {
        return;
    }

    while (directory != null && path.contains("/")) {
        final String subdirectory = path.substring(0, path.indexOf('/'));
        path = path.substring(path.indexOf('/') + 1);

        directory = directory.findSubdirectory(subdirectory);
    }

    if (directory != null) {
        if (!path.contains(".")) {
            path = path + ".php";
        }

        final PsiFile viewPsiFile = directory.createFile(path);
        FileEditorManager.getInstance(project).openFile(viewPsiFile.getVirtualFile(), true);

        final FileTemplate[] templates = FileTemplateManager.getDefaultInstance().getTemplates(FileTemplateManager.DEFAULT_TEMPLATES_CATEGORY);
        FileTemplate template = null;
        for (FileTemplate fileTemplate : templates) {
            if (fileTemplate.getName().equals("PHP File")) {
                template = fileTemplate;
                break;
            }
        }

        if (template != null && viewPsiFile.getViewProvider().getDocument() != null) {
            final Properties properties = FileTemplateManager.getDefaultInstance().getDefaultProperties();
            template.setLiveTemplateEnabled(true);
            template.setReformatCode(true);
            try {
                viewPsiFile.getViewProvider().getDocument().insertString(0, template.getText(properties));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
 

void setListeners(@NotNull Project project, @NotNull Map<FilterType, Boolean> selectionMap, @NotNull List<SelectionCheckbox> checkBoxMenuItems) {
    removeListeners();
    addItemListener(e -> {
        selectionMap.entrySet().forEach(booleanEntry -> booleanEntry.setValue(isSelected()));

        for (JBCheckBoxMenuItem i : checkBoxMenuItems) {
            if (i.isSelected() != isSelected()) {
                i.doClick(0);
            }
        }
        MessageBus messageBus = project.getMessageBus();
        messageBus.syncPublisher(Events.ON_SCAN_FILTER_CHANGE).update();
    });
}
 

private static void searchSelection(Editor editor, Project project) {
    final SelectionModel selectionModel = editor.getSelectionModel();
    if (!selectionModel.hasSelection()) {
        selectionModel.selectWordAtCaret(false);
    }
    
    final String text = selectionModel.getSelectedText();
    if (text == null) {
        return;
    }
    
    if (editor instanceof EditorWindow) {
        // highlightUsages selection in the whole editor, not injected fragment only
        editor = ((EditorWindow) editor).getDelegate();
    }
    
    EditorSearchSession oldSearch = EditorSearchSession.get(editor);
    if (oldSearch != null) {
        if (oldSearch.hasMatches()) {
            String oldText = oldSearch.getTextInField();
            if (!oldSearch.getFindModel().isRegularExpressions()) {
                oldText = StringUtil.escapeToRegexp(oldText);
                oldSearch.getFindModel().setRegularExpressions(true);
            }
            
            String newText = oldText + '|' + StringUtil.escapeToRegexp(text);
            oldSearch.setTextInField(newText);
            return;
        }
    }
    
    EditorSearchSession.start(editor, project).getFindModel().setRegularExpressions(false);
}
 

public void update(AnActionEvent event) {
    Project project = getEventProject(event);
    if (project == null) {
        this.setStatus(event, false);
        return;
    }

    if (DumbService.isDumb(project)) {
        this.setStatus(event, false);
        return;
    }

    this.setStatus(event, ExtensionUtility.getExtensionDirectory(event) != null);
}
 

private static void showBalloon(@NotNull final Project project, @NotNull final MessageType messageType) {
  BalloonBuilder balloonBuilder =
    JBPopupFactory.getInstance().createHtmlTextBalloonBuilder("You can start again now", messageType, null);
  final Balloon balloon = balloonBuilder.createBalloon();
  StudyEditor selectedStudyEditor = StudyUtils.getSelectedStudyEditor(project);
  assert selectedStudyEditor != null;
  balloon.show(StudyUtils.computeLocation(selectedStudyEditor.getEditor()), Balloon.Position.above);
  Disposer.register(project, balloon);
}
 

public static PsiDirectory getSubDir(Project project, VirtualFile vf) {
    if (vf.isDirectory()) {
        return PsiManager.getInstance(project).findDirectory(vf);
    } else {
        return getSubDir(project, vf.getParent());
    }
}
 

public void setEmptyText(@NotNull Project project) {
  if (StudyTaskManager.getInstance(project).getToolWindowMode() == StudyToolWindowMode.EDITING) {
    mySplitPane.setFirstComponent(myContentPanel);
    StudyTaskManager.getInstance(project).setTurnEditingMode(true);
  }
  setTaskText(EMPTY_TASK_TEXT, project);
}
 

@NotNull
public static Collection<PsiFile> convertVirtualFilesToPsiFiles(@NotNull Project project, @NotNull Collection<VirtualFile> files) {

    Collection<PsiFile> psiFiles = new HashSet<>();
    PsiManager psiManager = PsiManager.getInstance(project);

    for (VirtualFile file : files) {
        PsiFile psiFile = psiManager.findFile(file);
        if(psiFile != null) {
            psiFiles.add(psiFile);
        }
    }

    return psiFiles;
}
 

@Override
@Nullable
protected PsiDirectory createItemDir(@NotNull final Project project, @NotNull final StudyItem item,
                                  @Nullable final IdeView view, @NotNull final PsiDirectory parentDirectory,
                                  @NotNull final Course course) {
  EduPluginConfigurator configurator = EduPluginConfigurator.INSTANCE.forLanguage(course.getLanguageById());
  if (configurator == null) {
    return null;
  }
  return configurator.createLessonContent(project, (Lesson)item, view, parentDirectory);
}
 

public static PsiJavaDirectoryImpl getJavaDir(Project project, VirtualFile vf) {
    PsiDirectory dir = Utils.getSubDir(project, vf);
    if (dir instanceof PsiJavaDirectoryImpl) {
        return (PsiJavaDirectoryImpl) dir;
    }
    return null;
}
 

@Nullable
public static Editor getSelectedEditor(@NotNull final Project project) {
  final StudyEditor studyEditor = getSelectedStudyEditor(project);
  if (studyEditor != null) {
    return studyEditor.getEditor();
  }
  return null;
}
 

public BpDiagramDataModel(final Project project, final BpGraphNode rootBpGraphNode) {
    super(project, ServiceManager.getService(BpDiagramProvider.class));

    for (BpGraphNode bpGraphNode : rootBpGraphNode.getNodesMap().values()) {
        final BpDiagramFileNode bpDiagramFileNode = new BpDiagramFileNode(bpGraphNode);

        this.nodesMap.put(bpGraphNode.getGenericAction().getId(), bpDiagramFileNode);
    }
}
 

@Nullable
@Override
public String fetchExternalDocumentation(Project project, PsiElement psiElement, List<String> list)
{
    if (!CompletionPreloader.isRocConfigFile(psiElement.getContainingFile()))
    {
        return null;
    }

    String qualifiedName = list.get(0);
    SettingContainer completions = CompletionPreloader.getCompletions();

    Setting setting = completions.getSetting(qualifiedName);

    if (setting == null)
    {
        return "Just a container. Try looking at the sub-nodes instead.";
    }

    String description = escapeHtml(setting.getDescription());
    String descriptionTemplate = "<p>%s</p>";
    String documentation = String.format(descriptionTemplate, description);

    String defaultValue = escapeHtml(setting.getDefaultValue());

    if (defaultValue.length() == 0)
    {
        return documentation;
    }

    String defaultValueTemplate = "<p>Default value: %s</p>";
    String defaultValueDocumentation = String.format(defaultValueTemplate, defaultValue);

    return documentation.concat(defaultValueDocumentation);
}
 

@Before
@Override
public void setUp() throws Exception {
    super.setUp();
    final Project project = getProject();
    final PsiManager psiManager = PsiManager.getInstance(project);
    underTest = new PsiTypeConverter(psiManager);
}
 

public SwitchSubtaskPopupStep(@Nullable String title,
                              List<Integer> values,
                              @NotNull TaskWithSubtasks task,
                              @NotNull Project project) {
  super(title, values);
  myTask = task;
  myProject = project;
}
 

@Override
public void configure(@Nonnull Binder binder) {
    binder.bind(Project.class)
            .toInstance(project);

    // Binding InputValidator related classes
    binder.bind(InputValidator.class)
            .annotatedWith(Name.NAME_VALIDATOR.annotation())
            .to(NameValidator.class);
    binder.bind(InputValidator.class)
            .annotatedWith(Name.JSON_VALIDATOR.annotation())
            .to(JsonValidator.class);
    binder.bind(InputValidator.class)
            .annotatedWith(Name.CLASS_PREFIX_VALIDATOR.annotation())
            .to(ClassPrefixValidator.class);
    binder.bind(InputValidator.class)
            .annotatedWith(Name.CLASS_SUFFIX_VALIDATOR.annotation())
            .to(ClassSuffixValidator.class);

    // Binding NamePolicy classes
    binder.bind(NamePolicy.class)
            .annotatedWith(Name.CLASS_NAME_POLICY.annotation())
            .to(ClassNamePolicy.class);
    binder.bind(NamePolicy.class)
            .annotatedWith(Name.FIELD_NAME_POLICY.annotation())
            .to(FieldNamePolicy.class);
    binder.bind(NamePolicy.class)
            .annotatedWith(Name.METHOD_NAME_POLICY.annotation())
            .to(MethodNamePolicy.class);
    binder.bind(NamePolicy.class)
            .annotatedWith(Name.PARAMETER_NAME_POLICY.annotation())
            .to(ParameterNamePolicy.class);

    // Binding other classes
    binder.bind(Json2JavaBundle.class)
            .toInstance(Json2JavaBundle.getInstance());

    // Installation factory modules
    binder.install(new FactoryModuleBuilder().build(CommandActionFactory.class));
}
 

@Override
public void update(@NotNull AnActionEvent e) {
  e.getPresentation().setEnabledAndVisible(false);
  final IdeView view = e.getData(LangDataKeys.IDE_VIEW);
  final Project project = e.getData(CommonDataKeys.PROJECT);
  if (view == null || project == null) {
    return;
  }
  final Course course = StudyTaskManager.getInstance(project).getCourse();
  if (course == null || !(course instanceof RemoteCourse)) {
    return;
  }
  if (!course.getCourseMode().equals(CCUtils.COURSE_MODE)) return;
  final PsiDirectory[] directories = view.getDirectories();
  if (directories.length == 0 || directories.length > 1) {
    return;
  }

  final PsiDirectory lessonDir = directories[0];
  if (lessonDir == null || !lessonDir.getName().contains("lesson")) {
    return;
  }
  final Lesson lesson = course.getLesson(lessonDir.getName());
  if (lesson != null && ((RemoteCourse)course).getId() > 0) {
    e.getPresentation().setEnabledAndVisible(true);
    if (lesson.getId() <= 0) {
      e.getPresentation().setText("Upload Lesson to Stepik");
    }
  }
}
 

@Override
public void update(@NotNull AnActionEvent e) {
  Presentation presentation = e.getPresentation();
  Project project = e.getProject();
  presentation.setEnabledAndVisible(project != null && CCUtils.isCourseCreator(project));
  if (project != null) {
    final Course course = StudyTaskManager.getInstance(project).getCourse();
    if (course instanceof RemoteCourse) {
      presentation.setText("Update Course on Stepik");
    }
  }
}
 

public void actionPerformed(final AnActionEvent e) {
  DataContext dataContext = e.getDataContext();
  final IdeView view = LangDataKeys.IDE_VIEW.getData(dataContext);
  if (view == null) return;
  final PsiDirectory[] directories = view.getDirectories();

  PsiDirectory currentDirectory = directories.length > 0 ? directories[0] : null;
  final Project project = e.getData(CommonDataKeys.PROJECT);
  if (project == null) return;

  VirtualFile directoryFile = currentDirectory != null ? currentDirectory.getVirtualFile() : project.getBaseDir();
  openLoadDirectoryDialog(project, directoryFile, null);
}
 

protected PhpCreateFileFromTemplateDataProvider getDataProvider(@NotNull Project project, @NotNull PsiDirectory dir, @Nullable PsiFile file) {
    PhpNewTemplateClassDialog dialog = new PhpNewTemplateClassDialog(project, dir);

    if (!dialog.showAndGet()) {
        return null;
    }

    return dialog;
}
 

public static boolean canRenameOrMove(DataContext dataContext) {
  Project project = CommonDataKeys.PROJECT.getData(dataContext);
  PsiElement element = CommonDataKeys.PSI_ELEMENT.getData(dataContext);
  if (element == null || project == null) {
    return false;
  }
  Course course = StudyTaskManager.getInstance(project).getCourse();
  if (course == null || !EduNames.STUDY.equals(course.getCourseMode())) {
    return false;
  }

  return !isRenameableOrMoveable(project, course, element);
}
 

public void actionPerformed(AnActionEvent e) {
    Project project = e.getProject();
    if(project != null) {
        String messageId = "actions.detect.namespace.roots.no.new.roots.detected";

        if (PhpPsr4NamespaceRootDetector.detectNamespaceRoots(project)) {
            messageId = "actions.detect.namespace.roots.finished";
        }

        PhpPsr4NamespaceNotifier.showNotificationByMessageId(project, messageId);
    }
}
 

@Override
protected void updateDocumentHook(Document document, Project project, String lang, String key, String value, TranslationTableModel model) {
    if (!document.isWritable()) {
        return;
    }
    YAMLFile yamlFile = (YAMLFile) PsiDocumentManager.getInstance(project).getPsiFile(document);
    if (yamlFile != null) {
        try {
            for (String eachLang : languages) {
                String value0;
                String key0;
                if (eachLang.equalsIgnoreCase(lang)) {
                    key0 = lang + "." + key;
                    value0 = value;
                } else {
                    key0 = eachLang + "." + key;
                    value0 = "";
                }
                YAMLKeyValue yamlKeyValue = yamlUtil.createI18nRecord(yamlFile, key0, value0);
                model.addElement(eachLang, yamlKeyValue, key);
            }
            PsiDocumentManager.getInstance(project).commitDocument(document);

        } catch (IncorrectOperationException e) {

        }
    }
}
 

private void notifyImportNotFinishedYet(@NotNull Project project) {

        final String notificationTitle = refresh
            ? message("project.refresh.notification.title")
            : message("project.import.notification.title");

        NotificationUtil.NOTIFICATION_GROUP.createNotification(
            notificationTitle,
            message("import.or.refresh.process.not.finished.yet"),
            NotificationType.INFORMATION,
            null
        ).notify(project);
    }
 

public void createAndAddVirtualEnv(Project project, PyNewProjectSettings settings) {
  final ProjectSdksModel model = PyConfigurableInterpreterList.getInstance(project).getModel();
  Course course = StudyTaskManager.getInstance(project).getCourse();
  if (course == null) {
    return;
  }
  final String baseSdk = getBaseSdk(course);

  if (baseSdk != null) {
    final PyPackageManager packageManager = PyPackageManager.getInstance(new PyDetectedSdk(baseSdk));
    try {
      final String path = packageManager.createVirtualEnv(project.getBasePath() + "/.idea/VirtualEnvironment", false);
      AbstractCreateVirtualEnvDialog.setupVirtualEnvSdk(path, true, new AbstractCreateVirtualEnvDialog.VirtualEnvCallback() {
        @Override
        public void virtualEnvCreated(Sdk createdSdk, boolean associateWithProject) {
          settings.setSdk(createdSdk);
          model.addSdk(createdSdk);
          try {
            model.apply();
          }
          catch (ConfigurationException exception) {
            LOG.error("Error adding created virtual env " + exception.getMessage());
          }
          if (associateWithProject) {
            SdkAdditionalData additionalData = createdSdk.getSdkAdditionalData();
            if (additionalData == null) {
              additionalData = new PythonSdkAdditionalData(PythonSdkFlavor.getFlavor(createdSdk.getHomePath()));
              ((ProjectJdkImpl)createdSdk).setSdkAdditionalData(additionalData);
            }
            ((PythonSdkAdditionalData)additionalData).associateWithNewProject();
          }
        }
      });
    }
    catch (ExecutionException e) {
      LOG.warn("Failed to create virtual env " + e.getMessage());
    }
  }
}
 

@Override
protected void updateDocumentHook(Document document, Project project, String lang, String key, String value, TranslationTableModel model) {
    if (!document.isWritable()) {
        return;
    }
    PsiFile psiFile = PsiDocumentManager.getInstance(project).getPsiFile(document);
    if (psiFile != null) {
        YAMLKeyValue yamlKeyValue = yamlUtil.createI18nRecord((YAMLFile) psiFile, key, value);
        model.addElement(lang, yamlKeyValue, key);
        PsiDocumentManager.getInstance(project).commitDocument(document);
    }
}
 

private static void tryToRenameTaskFile(PsiFile file, String oldName) {
  final PsiDirectory taskDir = file.getContainingDirectory();
  final Project project = file.getProject();
  Course course = StudyTaskManager.getInstance(project).getCourse();
  if (course == null) {
    return;
  }
  if (taskDir == null || !taskDir.getName().contains(EduNames.TASK)) {
    return;
  }
  PsiDirectory lessonDir = taskDir.getParent();
  if (lessonDir == null || !lessonDir.getName().contains(EduNames.LESSON)) {
    return;
  }
  Lesson lesson = course.getLesson(lessonDir.getName());
  if (lesson == null) {
    return;
  }
  Task task = lesson.getTask(taskDir.getName());
  if (task == null) {
    return;
  }
  Map<String, TaskFile> taskFiles = task.getTaskFiles();
  TaskFile taskFile = task.getTaskFile(oldName);
  if (taskFile == null) {
    return;
  }
  taskFiles.remove(oldName);
  taskFiles.put(StudyUtils.pathRelativeToTask(file.getVirtualFile()), taskFile);
}
 

public static void nameTaskFileAfterContainingClass(@NotNull Task task,
                                                    @NotNull TaskFile taskFile,
                                                    @NotNull Project project) {
  Language language = task.getLesson().getCourse().getLanguageById();
  if (language.getAssociatedFileType() == null) {
    LOG.warn("Cannot rename task file. Unable to find associated file type for language: " + language.getID());
    return;
  }
  task.getTaskFiles().remove(taskFile.name);
  taskFile.name = publicClassName(project, taskFile, language.getAssociatedFileType()) + "." + language.getAssociatedFileType().getDefaultExtension();
  task.taskFiles.put(taskFile.name, taskFile);
}
 

@Override
public void invoke(Project project,
                   PsiFile file,
                   PsiElement startElement,
                   PsiElement endElement) {
    PsiJavaFile packageInfoFile = getOrCreatePackageInfoFile(file);
    if (packageInfoFile != null) {
        addAnnotationToPackageInfo(project, packageInfoFile);
    }
}
 

public static void navigateToFirstFailedAnswerPlaceholder(@NotNull final Editor editor, @NotNull final TaskFile taskFile) {
  final Project project = editor.getProject();
  if (project == null) return;
  for (AnswerPlaceholder answerPlaceholder : taskFile.getActivePlaceholders()) {
    if (answerPlaceholder.getStatus() != StudyStatus.Failed) {
      continue;
    }
    navigateToAnswerPlaceholder(editor, answerPlaceholder);
    break;
  }
}
 

protected void fillCompletionResultSet(@NotNull CompletionResultSet completionResultSet, @NotNull Project project) {
    for(Map.Entry<String, String> entry : EnvironmentVariablesApi.getAllKeyValues(project).entrySet()) {
        LookupElementBuilder lockup = LookupElementBuilder.create(entry.getKey());

        if(StringUtils.isNotEmpty(entry.getValue())) {
            lockup = lockup.withTailText(" = " + entry.getValue(), true);
        }

        completionResultSet.addElement(PrioritizedLookupElement.withPriority(lockup, 100));
    }
}
 

@NotNull
@Override
public String[] getNames(Project project, boolean includeNonProjectItems) {
    List<GCMTypeDeclaration> properties = GCMUtil.findProperties(project);
    List<String> names = new ArrayList<String>(properties.size());
    for (GCMTypeDeclaration property : properties) {
        if (property != null && property.getName() != null && property.getName().length() > 0) {
            names.add(property.getName());
        }
    }
    return names.toArray(new String[names.size()]);
}
 

/**
 * This fires once when a project is opened.  The hook is used to setup a watch for .git/HEAD changes.
 *
 * @return The project title to use for the given project.
 */
@Override
public String getProjectTitle(@NotNull Project project) {
  String branchName = null;
  try {
    VirtualFile headFile = watchThisProject(project);
    branchName = determineBranchName(headFile);
  } catch (Exception e) {
    // ignore...
  }
  return createProjectTitle(project, branchName);
}
 

private void removeRedundantAnnotationsInPackage(Project project, PsiFile[] files, PsiAnnotation annotation) {
    if (!removeRedundantAnnotations)
    {
        return;
    }

    List<String> redundantAnnotations = nullable
            ? NullableNotNullManager.getInstance(project).getNullables()
            : NullableNotNullManager.getInstance(project).getNotNulls();

    Set<PsiAnnotation.TargetType> targetsForDefaultAnnotation = targetTypesForDefault(annotation);
    if (targetsForDefaultAnnotation == null) {
        return;
    }

    for (PsiFile file : files) {
        if (file instanceof PsiJavaFile) {
            JavaElementVisitor visitor = new JavaElementVisitor() {
                @Override
                public void visitMethod(@Nonnull PsiMethod method) {
                    removeRedundantAnnotations(method, redundantAnnotations, targetsForDefaultAnnotation);
                }

                @Override
                public void visitParameter(@Nonnull PsiParameter parameter) {
                    removeRedundantAnnotations(parameter, redundantAnnotations, targetsForDefaultAnnotation);
                }

                @Override
                public void visitField(@Nonnull PsiField field) {
                    removeRedundantAnnotations(field, redundantAnnotations, targetsForDefaultAnnotation);
                }

                @Override
                public void visitLocalVariable(@Nonnull PsiLocalVariable variable) {
                    super.visitLocalVariable(variable);
                }
            };

            PsiRecursiveElementWalkingVisitor recursiveVisitor = new PsiRecursiveElementWalkingVisitor() {
                @Override
                public void visitElement(@Nonnull PsiElement element) {
                    element.accept(visitor);

                    super.visitElement(element);
                }
            };

            file.accept(recursiveVisitor);

            JavaCodeStyleManager.getInstance(project).optimizeImports(file);
        }
    }
}
 

public void moduleRemoved( Project project, Module module )
{
  ManProject.manProjectFrom( project ).reset();
}
 

@NotNull
@Override
public Lexer createLexer(Project project) {
    return new LexerAdapter(RmlTypes.INSTANCE);
}
 

@NotNull
public PsiParser createParser(final Project project) {
    return new CrystalParser();
}
 

public static void codeFormat(Project project, PsiElement element) {
    CodeStyleManager.getInstance(project).reformat(element);
}
 

public ModuleDepDiagramDataModel(final Project project, final DiagramProvider<ModuleDepDiagramItem> provider) {
    super(project, provider);
}