下面列出了com.intellij.psi.templateLanguages.TemplateDataLanguageMappings#com.intellij.openapi.fileTypes.StdFileTypes 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
public FluidFileViewProvider(PsiManager manager, VirtualFile file, boolean physical) {
super(manager, file, physical);
Language dataLang = TemplateDataLanguageMappings.getInstance(manager.getProject()).getMapping(file);
if (dataLang == null) {
dataLang = StdFileTypes.HTML.getLanguage();
}
if (dataLang instanceof TemplateLanguage) {
myTemplateDataLanguage = PlainTextLanguage.INSTANCE;
} else {
// The substitutor signals, that a files content should be substituted
Language mySubstitutedLanguage = LanguageSubstitutors.INSTANCE.substituteLanguage(dataLang, file, manager.getProject());
if (mySubstitutedLanguage == FluidLanguage.INSTANCE) {
this.myTemplateDataLanguage = StdFileTypes.HTML.getLanguage();
} else {
this.myTemplateDataLanguage = mySubstitutedLanguage;
}
}
}
public SoyLayeredHighlighter(
@Nullable Project project,
@Nullable VirtualFile virtualFile,
@NotNull EditorColorsScheme colors) {
// Creating main highlighter.
super(new SoySyntaxHighlighter(), colors);
// Highlighter for the outer language.
FileType type = null;
if (project == null || virtualFile == null) {
type = StdFileTypes.PLAIN_TEXT;
} else {
Language language = TemplateDataLanguageMappings.getInstance(project).getMapping(virtualFile);
if (language != null) type = language.getAssociatedFileType();
if (type == null) type = SoyLanguage.getDefaultTemplateLang();
}
SyntaxHighlighter outerHighlighter =
SyntaxHighlighterFactory.getSyntaxHighlighter(type, project, virtualFile);
registerLayer(OTHER, new LayerDescriptor(outerHighlighter, ""));
}
@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 List<DomElement> getFlowsInScope(Project project, GlobalSearchScope searchScope) {
final List<DomElement> result = new ArrayList<>();
final Collection<VirtualFile> files = FileTypeIndex.getFiles(StdFileTypes.XML, searchScope);
final DomManager manager = DomManager.getDomManager(project);
for (VirtualFile file : files) {
final PsiFile xmlFile = PsiManager.getInstance(project).findFile(file);
if (isMuleFile(xmlFile)) {
final DomFileElement<Mule> fileElement = manager.getFileElement((XmlFile) xmlFile, Mule.class);
if (fileElement != null) {
final Mule rootElement = fileElement.getRootElement();
result.addAll(rootElement.getFlows());
result.addAll(rootElement.getSubFlows());
}
}
}
return result;
}
@NotNull
private static List<XmlTag> getGlobalElementsInScope(Project project, GlobalSearchScope searchScope) {
final List<XmlTag> result = new ArrayList<>();
final Collection<VirtualFile> files = FileTypeIndex.getFiles(StdFileTypes.XML, searchScope);
final DomManager manager = DomManager.getDomManager(project);
for (VirtualFile file : files) {
final PsiFile xmlFile = PsiManager.getInstance(project).findFile(file);
if (isMuleFile(xmlFile)) {
final DomFileElement<Mule> fileElement = manager.getFileElement((XmlFile) xmlFile, Mule.class);
if (fileElement != null) {
final Mule rootElement = fileElement.getRootElement();
final XmlTag[] subTags = rootElement.getXmlTag().getSubTags();
for (XmlTag subTag : subTags) {
if (isGlobalElement(subTag)) {
result.add(subTag);
}
}
}
}
}
return result;
}
public static List<XmlTag> findFlowRefsForFlow(@NotNull XmlTag flow) {
List<XmlTag> flowRefs = new ArrayList<>();
final Project project = flow.getProject();
final String flowName = flow.getAttributeValue(MuleConfigConstants.NAME_ATTRIBUTE);
Collection<VirtualFile> vFiles = FileTypeIndex.getFiles(StdFileTypes.XML, ProjectScope.getContentScope(project));
for (VirtualFile virtualFile : vFiles) {
PsiFile psiFile = PsiManager.getInstance(project).findFile(virtualFile);
if (psiFile != null) {
XmlFile xmlFile = (XmlFile) psiFile;
XmlTag mule = xmlFile.getRootTag();
FlowRefsFinder finder = new FlowRefsFinder(flowName);
mule.accept(finder);
flowRefs.addAll(finder.getFlowRefs());
}
}
return flowRefs;
}
@Override
public final void registerDetectors( FacetDetectorRegistry<PolygeneFacetConfiguration> registry )
{
registry.registerOnTheFlyDetector(
StdFileTypes.JAVA, VirtualFileFilter.ALL, new HasPolygeneImportPackageCondition(),
new FacetDetector<PsiFile, PolygeneFacetConfiguration>( "PolygeneFacetDetector" )
{
@Override
public PolygeneFacetConfiguration detectFacet( PsiFile source,
Collection<PolygeneFacetConfiguration> existingConfigurations )
{
if( !existingConfigurations.isEmpty() )
{
return existingConfigurations.iterator().next();
}
return createDefaultConfiguration();
}
}
);
}
public DustLayeredSyntaxHighlighter(@Nullable Project project, @Nullable VirtualFile virtualFile, @NotNull EditorColorsScheme colors) {
// create main highlighter
super(new DustSyntaxHighlighter(), colors);
// highlighter for outer lang
FileType type = null;
if(project == null || virtualFile == null) {
type = StdFileTypes.PLAIN_TEXT;
} else {
Language language = TemplateDataLanguageMappings.getInstance(project).getMapping(virtualFile);
if(language != null) type = language.getAssociatedFileType();
if(type == null) type = StdFileTypes.HTML;
}
SyntaxHighlighter outerHighlighter = SyntaxHighlighter.PROVIDER.create(type, project, virtualFile);
registerLayer(DustTypes.HTML, new LayerDescriptor(outerHighlighter, ""));
}
public static PsiFile createFileFromModel(
String clsQualifiedName, SpecModel model, Project project) {
String fileContent = createFileContentFromModel(clsQualifiedName, model);
return PsiFileFactory.getInstance(project)
.createFileFromText(
StringUtil.getShortName(clsQualifiedName) + ".java", StdFileTypes.JAVA, fileContent);
}
/** Creates new dummy file included in the scope. */
static VirtualFile createDummyFile(Project project) {
final PsiFile dummyFile =
PsiFileFactory.getInstance(project)
.createFileFromText("Dummy.java", StdFileTypes.JAVA, "class Dummy {}");
return include(dummyFile);
}
public static boolean isMuleFile(PsiFile psiFile) {
if (!(psiFile instanceof XmlFile)) {
return false;
}
if (psiFile.getFileType() != StdFileTypes.XML) {
return false;
}
final XmlFile psiFile1 = (XmlFile) psiFile;
final XmlTag rootTag = psiFile1.getRootTag();
return isMuleTag(rootTag);
}
public static boolean isMUnitFile(PsiFile psiFile) {
if (!(psiFile instanceof XmlFile)) {
return false;
}
if (psiFile.getFileType() != StdFileTypes.XML) {
return false;
}
final XmlFile psiFile1 = (XmlFile) psiFile;
final XmlTag rootTag = psiFile1.getRootTag();
if (rootTag == null || !isMuleTag(rootTag)) {
return false;
}
final XmlTag[] munitTags = rootTag.findSubTags(MUNIT_TEST_LOCAL_NAME, rootTag.getNamespaceByPrefix(MUNIT_NAMESPACE));
return munitTags.length > 0;
}
@Nullable
private static XmlTag findGlobalElementInScope(Project project, String elementName, GlobalSearchScope searchScope) {
final Collection<VirtualFile> files = FileTypeIndex.getFiles(StdFileTypes.XML, searchScope);
for (VirtualFile file : files) {
XmlTag flow = findGlobalElementInFile(project, elementName, file);
if (flow != null) {
return flow;
}
}
return null;
}
@Nullable
private static XmlTag findFlowInScope(Project project, String flowName, GlobalSearchScope searchScope) {
final Collection<VirtualFile> files = FileTypeIndex.getFiles(StdFileTypes.XML, searchScope);
for (VirtualFile file : files) {
XmlTag flow = findFlowInFile(project, flowName, file);
if (flow != null) {
return flow;
}
}
return null;
}
@Override
protected SimpleNode[] buildChildren() {
List<SimpleNode> myConfigNodes = new ArrayList<>();
final DomManager manager = DomManager.getDomManager(myProject);
final Collection<VirtualFile> files = FileTypeIndex.getFiles(StdFileTypes.XML, GlobalSearchScope.projectScope(myProject));
for (VirtualFile file : files) {
final PsiFile xmlFile = PsiManager.getInstance(myProject).findFile(file);
if (xmlFile != null) {
// PsiDirectory directory = xmlFile.getParent();
// Module module = ModuleUtilCore.findModuleForPsiElement((PsiElement) (directory == null ? xmlFile : directory));
if (MuleConfigUtils.isMuleFile(xmlFile)) {
final DomFileElement<Mule> fileElement = manager.getFileElement((XmlFile) xmlFile, Mule.class);
if (fileElement != null) {
final Mule rootElement = fileElement.getRootElement();
XmlTag[] subTags = rootElement.getXmlTag().getSubTags();
for (XmlTag nextTag : subTags) {
MuleElementType muleElementType = MuleConfigUtils.getMuleElementTypeFromXmlElement(nextTag);
if (muleElementType != null && //This is a global config file and it has at least one connector
(MuleElementType.CONFIG.equals(muleElementType) || (MuleElementType.TRANSPORT_CONNECTOR.equals(muleElementType)))) {
MuleConfigNode nextConfigNode = new MuleConfigNode(this, xmlFile);
myConfigNodes.add(nextConfigNode);
break;
}
}
}
}
}
}
return myConfigNodes.toArray(new SimpleNode[]{});
}
protected static PsiClass createClassFromTemplate( @NotNull PsiDirectory directory,
@NotNull String className,
@NotNull String templateName,
@NonNls String... parameters )
throws IncorrectOperationException
{
String classFileName = className + "." + StdFileTypes.JAVA.getDefaultExtension();
PsiFile file = createFromTemplateInternal( directory, className, classFileName, templateName, parameters );
return ( (PsiJavaFile) file ).getClasses()[ 0 ];
}
@Override
protected boolean selectSomethingUnderCaret(Editor editor, DataContext dataContext, SelectionModel selectionModel) {
try {
PsiFile psiFile = PsiDocumentManager.getInstance(editor.getProject()).getPsiFile(editor.getDocument());
if (psiFile == null) {// select whole line in plaintext
return super.selectSomethingUnderCaret(editor, dataContext, selectionModel);
}
FileType fileType = psiFile.getFileType();
boolean handled = false;
if (fileType.equals(StdFileTypes.JAVA) && isJavaInstalled()) {
handled = javaHandling(editor, dataContext, selectionModel, psiFile);
}
if (!handled && fileType.equals(StdFileTypes.PROPERTIES)) {
handled = propertiesHandling(editor, dataContext, selectionModel, psiFile);
}
if (!handled && fileType.equals(StdFileTypes.PLAIN_TEXT)) {
handled = super.selectSomethingUnderCaret(editor, dataContext, selectionModel);
}
if (!handled) {
handled = genericHandling(editor, dataContext, selectionModel, psiFile);
}
return handled;
} catch (Exception e) {
LOG.error("please report this, so I can fix it :(", e);
return super.selectSomethingUnderCaret(editor, dataContext, selectionModel);
}
}
private boolean isActionAvailable(AnActionEvent e) {
final VirtualFile file = getVirtualFiles(e);
if (getEventProject(e) != null && file != null) {
final FileType fileType = file.getFileType();
return StdFileTypes.JAVA.equals(fileType);
}
return false;
}
private void processFile(Project project, VirtualFile file) {
if (StdFileTypes.JAVA.equals(file.getFileType())) {
final PsiManager psiManager = PsiManager.getInstance(project);
PsiJavaFile psiFile = (PsiJavaFile) psiManager.findFile(file);
if (psiFile != null) {
process(project, psiFile);
}
}
}
public DustFileViewProvider(PsiManager manager, VirtualFile file, boolean physical) {
super(manager, file, physical);
// get the main language of the file
Language dataLang = TemplateDataLanguageMappings.getInstance(manager.getProject()).getMapping(file);
if (dataLang == null) dataLang = StdFileTypes.HTML.getLanguage();
// some magic?
if (dataLang instanceof TemplateLanguage) {
myTemplateDataLanguage = PlainTextLanguage.INSTANCE;
} else {
myTemplateDataLanguage = LanguageSubstitutors.INSTANCE.substituteLanguage(dataLang, file, manager.getProject());
}
}
@NotNull
@Override
public FileType getFileType() {
return StdFileTypes.XML;
}
public boolean canReformat(PsiFile file) {
return StdFileTypes.JAVA.equals(file.getFileType());
}
@Override
protected LanguageFileType getFileType() {
return StdFileTypes.JAVA;
}
private static boolean containsInternal(VirtualFile file) {
return StdFileTypes.JAVA.equals(file.getFileType()) && file.getUserData(KEY) != null;
}
@SuppressWarnings("SameReturnValue")
public static LanguageFileType getDefaultTemplateLang() {
return StdFileTypes.HTML;
}
public static LanguageFileType getDefaultTemplateLang() {
return StdFileTypes.HTML;
}
@NotNull
@Override
public FileType getFileType()
{
return StdFileTypes.PROPERTIES;
}
@Nullable
@Override
public VirtualFile findClassFile(String fqcn) {
GlobalSearchScope searchScope = module.getModuleRuntimeScope(false);
PsiClass[] psiClasses =
ReadAction.compute(
() ->
JavaPsiFacade.getInstance(project)
.findClasses(getContainingClassName(fqcn), searchScope));
if (psiClasses.length == 0) {
return null;
}
BlazeProjectData projectData =
BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
if (projectData == null) {
return null;
}
// It's possible that there's more than one source file in the project corresponding to
// the same fully-qualified class name, with Blaze choosing the appropriate source to use
// according to some configuration flags. Here we check each of them until we find the one
// that was chosen during Blaze sync.
for (PsiClass psiClass : psiClasses) {
PsiFile psiFile = psiClass.getContainingFile();
if (psiFile == null) {
continue;
}
VirtualFile virtualFile = psiFile.getVirtualFile();
if (virtualFile == null) {
continue;
}
FileType fileType = psiFile.getFileType();
VirtualFile classFile = null;
if (fileType == StdFileTypes.JAVA) {
classFile =
findClassFileForSourceAndRegisterResourcePackage(projectData, virtualFile, fqcn);
} else if (fileType == StdFileTypes.CLASS) {
classFile = findClassFileForIJarClass(projectData, virtualFile, fqcn);
}
if (classFile != null) {
return classFile;
}
}
return null;
}
public static boolean isHtmlFile(PsiFile psiFile) {
return psiFile.getFileType().equals(StdFileTypes.HTML);
}
private XmlFile getDistXml() {
String template = FileTemplateManager.getInstance(project).getInternalTemplate("vector").getText();
return (XmlFile) PsiFileFactory.getInstance(project).createFileFromText(xmlName, StdFileTypes.XML, template);
}