@Override protected PsiFile createExpressionCodeFragment(@NotNull Project project, @NotNull String text, @Nullable PsiElement context, boolean isPhysical) { return PsiFileFactory.getInstance(project).createFileFromText("dlv-debug.txt", PlainTextLanguage.INSTANCE, text); } }
public ProtoElementFactory(Project project) { this.project = project; factory = PsiFileFactory.getInstance(project); }
@NotNull private ProtoPsiFileRoot createProtoFromText(String text) { PsiFile file = factory.createFileFromText("tmp.proto", ProtoLanguage.INSTANCE, text); Preconditions.checkState(file instanceof ProtoPsiFileRoot, "Expected result of type %s but got %s", ProtoPsiFileRoot.class, file.getClass()); return (ProtoPsiFileRoot) file; } }
@Nonnull @Provides @Singleton public PsiFileFactory provideFileFactory(@Nonnull Project project) { return PsiFileFactory.getInstance(project); }
@NotNull @CheckReturnValue public String format(@Nonnull String text) { final String name = Extensions.append(NAME, fileType); final PsiFile file = fileFactory.createFileFromText(name, fileType, text); final CodeStyleManager styleManager = CodeStyleManager.getInstance(file.getProject()); styleManager.reformat(file); return file.getText(); } }
@NotNull private static GoFile createFileFromText(@NotNull Project project, @NotNull String text) { return (GoFile)PsiFileFactory.getInstance(project).createFileFromText("a.go", GoLanguage.INSTANCE, text); }
public static PsiFile createFile(Project project, String text) { String fileName = "a.g4"; // random name but must be .g4 PsiFileFactoryImpl factory = (PsiFileFactoryImpl)PsiFileFactory.getInstance(project); return factory.createFileFromText(fileName, ANTLRv4Language.INSTANCE, text, false, false); }
@Override protected void run(@NotNull Result<PsiFile> result) throws Throwable { final PsiPackage packageElement = directoryService.getPackage(directory); if (packageElement == null) { throw new InvalidDirectoryException("Target directory does not provide a package"); } final String fileName = Extensions.append(name, StdFileTypes.JAVA); final PsiFile found = directory.findFile(fileName); if (found != null) { throw new ClassAlreadyExistsException("Class '" + name + "'already exists in " + packageElement.getName()); } final String packageName = packageElement.getQualifiedName(); final String className = Extensions.remove(this.name, StdFileTypes.JAVA); try { final String java = converter.convert(packageName, className, json); final PsiFile classFile = fileFactory.createFileFromText(fileName, JavaFileType.INSTANCE, java); CodeStyleManager.getInstance(classFile.getProject()).reformat(classFile); JavaCodeStyleManager.getInstance(classFile.getProject()).optimizeImports(classFile); final PsiFile created = (PsiFile) directory.add(classFile); result.setResult(created); } catch (IOException e) { throw new ClassCreationException("Failed to create new class from JSON", e); } } }
@NotNull private static BallerinaFile createFileFromText(@NotNull Project project, @NotNull String text) { return (BallerinaFile) PsiFileFactory.getInstance(project).createFileFromText("a.bal", BallerinaLanguage.INSTANCE, text); }
@Inject public NewClassCommandAction(@Nonnull Project project, @Nonnull @Assisted("Name") String name, @Nonnull @Assisted("Json") String json, @Nonnull @Assisted PsiDirectory directory, @Nonnull @Assisted JavaConverter converter) { super(project); this.fileFactory = PsiFileFactory.getInstance(project); this.directoryService = JavaDirectoryService.getInstance(); this.name = Preconditions.checkNotNull(name); this.json = Preconditions.checkNotNull(json); this.directory = Preconditions.checkNotNull(directory); this.converter = Preconditions.checkNotNull(converter); }
@Contract(pure = true) @NotNull public static ElixirFile createFile(@NotNull final Project project, @NotNull final String text) { String filename = "dummy." + ElixirFileType.INSTANCE.getDefaultExtension(); return (ElixirFile) PsiFileFactory.getInstance(project).createFileFromText( filename, ElixirFileType.INSTANCE, text ); }
public static PsiElement createLeafFromText(Project project, PsiElement context, String text, IElementType type) { PsiFileFactoryImpl factory = (PsiFileFactoryImpl)PsiFileFactory.getInstance(project); PsiElement el = factory.createElementFromText(text, ANTLRv4Language.INSTANCE, type, context); return PsiTreeUtil.getDeepestFirst(el); // forces parsing of file!! // start rule depends on root passed in }
/** * Changes the element's text to a new value * * @param entry element to be changed * @param range range within the element * @param newContent new element text * @return changed element * * @throws IncorrectOperationException if something goes wrong */ @Override public IgnoreEntry handleContentChange(@NotNull IgnoreEntry entry, @NotNull TextRange range, String newContent) throws IncorrectOperationException { if (!(entry.getLanguage() instanceof IgnoreLanguage)) { return entry; } IgnoreLanguage language = (IgnoreLanguage) entry.getLanguage(); IgnoreFileType fileType = (IgnoreFileType) language.getAssociatedFileType(); assert fileType != null; PsiFile file = PsiFileFactory.getInstance(entry.getProject()) .createFileFromText(language.getFilename(), fileType, range.replace(entry.getText(), newContent)); IgnoreEntry newEntry = PsiTreeUtil.findChildOfType(file, IgnoreEntry.class); assert newEntry != null; return (IgnoreEntry) entry.replace(newEntry); }
public static PsiElement createLeafFromText(Project project, Language language, PsiElement context, String text, IElementType type) { PsiFileFactoryImpl factory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project); PsiElement el = factory.createElementFromText(text, language, type, context); if ( el==null ) return null; return PsiTreeUtil.getDeepestFirst(el); // forces parsing of file!! // start rule depends on root passed in }
/** * Creates new Gitignore file or uses an existing one. * * @param directory working directory * @return file */ @Nullable public PsiFile createFromTemplate(final PsiDirectory directory) throws IncorrectOperationException { final String filename = fileType.getIgnoreLanguage().getFilename(); final PsiFile currentFile = directory.findFile(filename); if (currentFile != null) { return currentFile; } final PsiFileFactory factory = PsiFileFactory.getInstance(directory.getProject()); final IgnoreLanguage language = fileType.getIgnoreLanguage(); String content = StringUtil.join(TEMPLATE_NOTE, Constants.NEWLINE); if (language.isSyntaxSupported() && !IgnoreBundle.Syntax.GLOB.equals(language.getDefaultSyntax())) { content = StringUtil.join( content, IgnoreBundle.Syntax.GLOB.getPresentation(), Constants.NEWLINE, Constants.NEWLINE ); } final PsiFile file = factory.createFileFromText(filename, fileType, content); return (PsiFile) directory.add(file); } }
@Nullable protected PsiFile createFile(@NotNull String name, @NotNull String text, @NotNull ParserDefinition definition) { Language language = definition.getFileNodeType().getLanguage(); Init.addKeyedExtension(LanguageParserDefinitions.INSTANCE, language, definition, getProject()); return ((PsiFileFactoryImpl)PsiFileFactory.getInstance(myProject)).trySetupPsiForFile(new LightVirtualFile(name, language, text), language, true, false); }
protected static String buildStubTreeText(@NotNull Project project, @NotNull VirtualFile file, @NotNull String fileContent, boolean checkErrors) throws IOException { String path = file.getPath(); PsiFile psi = PsiFileFactory.getInstance(project).createFileFromText(file.getName(), file.getFileType(), fileContent); if (checkErrors) { assertFalse(path + " contains error elements", DebugUtil.psiToString(psi, true).contains("PsiErrorElement")); } String full = DebugUtil.stubTreeToString(GoFileElementType.INSTANCE.getBuilder().buildStubTree(psi)); psi.putUserData(IndexingDataKeys.VIRTUAL_FILE, file); FileContentImpl content = new FileContentImpl(file, fileContent, file.getCharset()); PsiFile psiFile = content.getPsiFile(); String fast = DebugUtil.stubTreeToString(GoFileElementType.INSTANCE.getBuilder().buildStubTree(psiFile)); if (!Comparing.strEqual(full, fast)) { System.err.println(path); UsefulTestCase.assertSameLines(full, fast); } return fast; }
public static PsiFile createFile(Project project, Language language, String text) { LanguageFileType ftype = language.getAssociatedFileType(); if ( ftype==null ) return null; String ext = ftype.getDefaultExtension(); String fileName = "___fubar___."+ext; // random name but must have correct extension PsiFileFactoryImpl factory = (PsiFileFactoryImpl)PsiFileFactory.getInstance(project); return factory.createFileFromText(fileName, language, text, false, false); } }
PsiFileFactory factory = PsiFileFactory.getInstance(getManager().getProject()); PsiFile mirror = factory.createFileFromText( fileName, ElixirLanguage.INSTANCE,
private static PsiFile createDummyFile(Project myProject, String text) { final PsiFileFactory factory = PsiFileFactory.getInstance(myProject); final String name = "dummy." + MonkeyFileType.INSTANCE.getDefaultExtension(); final LightVirtualFile virtualFile = new LightVirtualFile(name, MonkeyFileType.INSTANCE, text); final PsiFile psiFile = ((PsiFileFactoryImpl) factory).trySetupPsiForFile(virtualFile, MonkeyLanguage.INSTANCE, false, true); assert psiFile != null; return psiFile; } }