Java VirtualFile.getNameWithoutExtension方法代码示例

import com.intellij.openapi.vfs.VirtualFile; //导入方法依赖的package包/类
ViewLookupElement(PsiFile psiFile) {
    myFile = psiFile;
    VirtualFile file = psiFile.getVirtualFile();

    if (file.getNameWithoutExtension().contains(".")) {
        myName = file.getName();
        myTail = null;
    } else {
        myName = file.getNameWithoutExtension();
        myTail = "." + file.getExtension();
    }
}
 

import com.intellij.openapi.vfs.VirtualFile; //导入方法依赖的package包/类
@Nullable
@Override
public PsiElement[] getGotoDeclarationTargets(@Nullable PsiElement psiElement, int i, Editor editor) {
    if (psiElement == null) {
        return PsiElement.EMPTY_ARRAY;
    }
    Project project = psiElement.getProject();
    if (!PlatformPatterns
            .psiElement(StringLiteralExpression.class)
            .withLanguage(PhpLanguage.INSTANCE)
            .accepts(psiElement.getContext())
    ) {
        return PsiElement.EMPTY_ARRAY;
    }
    PsiFile containingFile = psiElement.getContainingFile();
    VirtualFile virtualFile = containingFile.getVirtualFile();
    String filename = virtualFile.getNameWithoutExtension();
    String controllerName = CakeUtil.controllerBaseNameFromControllerFileName(filename);
    if (controllerName == null) {
        return PsiElement.EMPTY_ARRAY;
    }

    PsiDirectory appDir = PsiUtil.getAppDirectoryFromFile(containingFile);
    String templatePath = String.format("View/%s/%s.ctp", controllerName, psiElement.getText());
    VirtualFile relativeFile = VfsUtil.findRelativeFile(appDir, templatePath);
    if (relativeFile != null) {
        Collection<VirtualFile> files = new HashSet<>();
        files.add(relativeFile);
        return PsiUtil.convertVirtualFilesToPsiFiles(project, files).toArray(new PsiElement[files.size()]);
    }
    return PsiElement.EMPTY_ARRAY;
}
 

import com.intellij.openapi.vfs.VirtualFile; //导入方法依赖的package包/类
@Nullable
public static String getFileNameWithoutExtension(@NotNull PsiElement psiElement) {
    PsiFile file = psiElement.getContainingFile();
    if (file == null) {
        return null;
    }
    VirtualFile virtualFile = file.getVirtualFile();
    if (virtualFile == null) {
        return null;
    }
    return virtualFile.getNameWithoutExtension();
}
 

import com.intellij.openapi.vfs.VirtualFile; //导入方法依赖的package包/类
public static void deleteWindowDescriptions(@NotNull final Task task, @NotNull final VirtualFile taskDir) {
  for (Map.Entry<String, TaskFile> entry : task.getTaskFiles().entrySet()) {
    String name = entry.getKey();
    VirtualFile virtualFile = taskDir.findFileByRelativePath(name);
    if (virtualFile == null) {
      continue;
    }
    String windowsFileName = virtualFile.getNameWithoutExtension() + EduNames.WINDOWS_POSTFIX;
    VirtualFile parentDir = virtualFile.getParent();
    deleteWindowsFile(parentDir, windowsFileName);
  }
}
 

import com.intellij.openapi.vfs.VirtualFile; //导入方法依赖的package包/类
private boolean isActiveSubtaskTest(VirtualFile virtualFile) {
  if (!(myTask instanceof TaskWithSubtasks)) {
    return true;
  }

  if (!virtualFile.getName().contains(EduNames.SUBTASK_MARKER)) {
    return false;
  }
  String nameWithoutExtension = virtualFile.getNameWithoutExtension();
  int stepMarkerStart = nameWithoutExtension.indexOf(EduNames.SUBTASK_MARKER);
  int stepIndex = Integer.valueOf(nameWithoutExtension.substring(EduNames.SUBTASK_MARKER.length() + stepMarkerStart));
  return stepIndex == ((TaskWithSubtasks)myTask).getActiveSubtaskIndex();
}
 

import com.intellij.openapi.vfs.VirtualFile; //导入方法依赖的package包/类
public static void build(Project project, VirtualFile virtualFile) {
    if (virtualFile == null) return;

    Options options = OptionsHelper.load(project);
    if (options == null) {
        OptionForm.show(project, virtualFile);
        return;
    }
    if (!OptionsHelper.verify(options)) {
        OptionForm.show(project, virtualFile);
        return;
    }

    String apkNameWithoutExtension = virtualFile.getNameWithoutExtension();

    File apkFile = new File(virtualFile.getPath());
    File parentFile = apkFile.getParentFile();
    String tempPath = parentFile + File.separator + "temp";
    String outPath = parentFile + File.separator + "channels";

    ProgressManager.getInstance().run(new Task.Backgroundable(project, "Build Channel") {
        @Override
        public void run(@NotNull ProgressIndicator progressIndicator) {
            log.info("build type -> " + options.buildType);
            if (OptionsHelper.BUILD_TYPE_UPDATE.equals(options.buildType)) {
                updateAndroidManifestXml(progressIndicator, virtualFile, tempPath, options,
                        apkNameWithoutExtension, outPath, apkFile);
            } else if (OptionsHelper.BUILD_TYPE_ADD.equals(options.buildType)) {
                addChannelFileToMETAINF(progressIndicator, options, apkFile, outPath, tempPath,
                        apkNameWithoutExtension);
            } else {
                writeApkComment(progressIndicator, options, apkFile, outPath, tempPath, apkNameWithoutExtension);
            }
        }
    });
}
 

import com.intellij.openapi.vfs.VirtualFile; //导入方法依赖的package包/类
@Override
public void createFileMap(@NotNull VirtualFile file) {
    fileMap.clear();
    VirtualFile parent = file.getParent();
    VirtualFile[] childs = parent.getChildren();
    languages = new String[childs.length];
    int cnt = 0;
    for (VirtualFile each : childs) {
        languages[cnt] = each.getNameWithoutExtension();
        fileMap.put(languages[cnt], each);
        cnt++;
    }
}
 

import com.intellij.openapi.vfs.VirtualFile; //导入方法依赖的package包/类
private static void smartCheck(@NotNull final AnswerPlaceholder placeholder,
                              @NotNull final Project project,
                              @NotNull final VirtualFile answerFile,
                              @NotNull final TaskFile answerTaskFile,
                              @NotNull final TaskFile usersTaskFile,
                              @NotNull final PyStudyTestRunner testRunner,
                              @NotNull final VirtualFile virtualFile,
                              @NotNull final Document usersDocument) {
  VirtualFile fileWindows = null;
  VirtualFile windowCopy = null;
  try {
    final int index = placeholder.getIndex();
    String windowCopyName = answerFile.getNameWithoutExtension() + index + EduNames.WINDOW_POSTFIX + answerFile.getExtension();
    windowCopy = answerFile.copy(project, answerFile.getParent(), windowCopyName);
    final FileDocumentManager documentManager = FileDocumentManager.getInstance();
    final Document windowDocument = documentManager.getDocument(windowCopy);
    if (windowDocument != null) {
      TaskFile windowTaskFile = answerTaskFile.getTask().copy().getTaskFile(StudyUtils.pathRelativeToTask(virtualFile));
      if (windowTaskFile == null) {
        return;
      }
      EduDocumentListener listener = new EduDocumentListener(windowTaskFile);
      windowDocument.addDocumentListener(listener);
      int start = placeholder.getOffset();
      int end = start + placeholder.getRealLength();
      final AnswerPlaceholder userAnswerPlaceholder = usersTaskFile.getAnswerPlaceholders().get(placeholder.getIndex());
      int userStart = userAnswerPlaceholder.getOffset();
      int userEnd = userStart + userAnswerPlaceholder.getRealLength();
      String text = usersDocument.getText(new TextRange(userStart, userEnd));
      windowDocument.replaceString(start, end, text);
      ApplicationManager.getApplication().runWriteAction(() -> documentManager.saveDocument(windowDocument));
      fileWindows = EduUtils.flushWindows(windowTaskFile, windowCopy);
      Process smartTestProcess = testRunner.createCheckProcess(project, windowCopy.getPath());
      final CapturingProcessHandler handler = new CapturingProcessHandler(smartTestProcess, null, windowCopy.getPath());
      final ProcessOutput output = handler.runProcess();
      final Course course = StudyTaskManager.getInstance(project).getCourse();
      if (course != null) {
        boolean res = StudyTestsOutputParser.getTestsOutput(output, course.isAdaptive()).isSuccess();
        StudyTaskManager.getInstance(project).setStatus(userAnswerPlaceholder, res ? StudyStatus.Solved : StudyStatus.Failed);
      }
    }
  }
  catch (ExecutionException | IOException e) {
    LOG.error(e);
  }
  finally {
    StudyUtils.deleteFile(windowCopy);
    StudyUtils.deleteFile(fileWindows);
  }
}