protected final void collectModels(
IFile dir,
String package_,
String relativePath,
Map<String, String> options,
Collection<SModel> models) {
if (FileSystem.getInstance().isFileIgnored(dir.getName())) return;
if (!dir.isDirectory()) return;
List<IFile> files = dir.getChildren();
options.put(ModelFactory.OPTION_PACKAGE, package_);
for (IFile file : files) {
String fileName = file.getName();
String extension = FileUtil.getExtension(fileName);
if (extension == null) continue;
ModelFactory modelFactory = PersistenceFacade.getInstance().getModelFactory(extension);
if (modelFactory == null || file.isDirectory()) continue;
FileDataSource source = new FileDataSource(file, this);
options.put(ModelFactory.OPTION_RELPATH, combinePath(relativePath, fileName));
String fileNameWE = FileUtil.getNameWithoutExtension(fileName);
options.put(
ModelFactory.OPTION_MODELNAME,
package_ != null
? (package_.isEmpty() ? fileNameWE : package_ + "." + fileNameWE)
: null);
try {
SModel model = modelFactory.load(source, Collections.unmodifiableMap(options));
((SModelBase) model).setModelRoot(this);
models.add(model);
} catch (UnsupportedDataSourceException ex) {
/* model factory registration problem: ignore */
}
}
options.put(ModelFactory.OPTION_RELPATH, relativePath);
for (FolderModelFactory factory : PersistenceRegistry.getInstance().getFolderModelFactories()) {
for (DataSource dataSource : factory.createDataSources(this, dir)) {
SModel model = factory.load(dataSource, Collections.unmodifiableMap(options));
((SModelBase) model).setModelRoot(this);
models.add(model);
}
}
for (IFile childDir : files) {
if (childDir.isDirectory()) {
String name = childDir.getName();
String innerPackage =
package_ != null && JavaNameUtil.isJavaIdentifier(name)
? (package_.isEmpty() ? name : package_ + "." + name)
: null;
String innerPath = combinePath(relativePath, name);
collectModels(childDir, innerPackage, innerPath, options, models);
}
}
}
private <T> void readModuleDescriptorsFromFolder(
IFile file,
Set<IFile> excludes,
List<T> result,
boolean refreshFiles,
DescriptorReader<T> reader) {
if (!needProcess(file, excludes)) return;
if (refreshFiles) {
FileSystem.getInstance().refresh(file);
}
// if this is a jar dir, we need to go to modules sub dir or check for META-INF/module.xml
// if this is just good old plain directory, we check every file in it
if (file.getPath().endsWith(JAR + JAR_SEPARATOR)) {
IFile moduleXml = file.getDescendant(META_INF).getDescendant(MODULE_XML);
if (moduleXml.exists() && !moduleXml.isDirectory()) {
ModuleDescriptor moduleDescriptor = loadModuleDescriptor(moduleXml);
if (moduleDescriptor != null) {
T descriptor = reader.read(new ModuleHandle(moduleXml, moduleDescriptor));
if (descriptor != null) {
result.add(descriptor);
}
}
} else {
IFile dirInJar = file.getDescendant(MODULES_DIR);
if (dirInJar.exists() && dirInJar.isDirectory()) {
readModuleDescriptorsFromFolder(dirInJar, excludes, result, refreshFiles, reader);
}
}
} else {
// first, we read from files
// this way all modules roots, sources/classes folders are in excludes and we do not even go
// into them
List<IFile> children = file.getChildren();
ArrayList<IFile> folders = new ArrayList<IFile>();
for (IFile child : children) {
if (!child.isDirectory()) {
readModuleDescriptorsFromFile(child, excludes, result, refreshFiles, reader);
} else {
folders.add(child);
}
}
// now read from folders
for (IFile child : folders) {
readModuleDescriptorsFromFolder(child, excludes, result, refreshFiles, reader);
}
}
}
@Override
public void findTargets(
TargetKind kind,
Collection<SModel> scope,
Consumer<NavigationTarget> consumer,
Consumer<SModel> processedConsumer) {
final ID<Integer, List<SNodeDescriptor>> indexName = RootNodeNameIndex.NAME;
final FileBasedIndex fileBasedIndex = FileBasedIndex.getInstance();
for (SModel sm : scope) {
if (sm instanceof EditableSModel && ((EditableSModel) sm).isChanged()) {
continue;
}
DataSource source = sm.getSource();
if (!(source instanceof FileDataSource)) {
continue;
}
IFile modelFile = ((FileDataSource) source).getFile();
String ext = FileUtil.getExtension(modelFile.getName());
if (ext == null
|| modelFile.isDirectory()
|| !(supportedExtensions.contains(ext.toLowerCase()))) {
continue;
}
VirtualFile vf = VirtualFileUtils.getVirtualFile(modelFile);
if (vf == null) continue; // e.g. model was deleted
int fileId = FileBasedIndex.getFileId(vf);
ConcreteFilesGlobalSearchScope fileScope =
new ConcreteFilesGlobalSearchScope(Collections.singleton(vf));
List<List<SNodeDescriptor>> descriptors =
fileBasedIndex.getValues(indexName, fileId, fileScope);
if (descriptors.isEmpty()) continue;
boolean needToLoad = false;
for (NavigationTarget snd : descriptors.get(0)) {
PropertyConstraintsDescriptor descriptor =
ConceptRegistry.getInstance()
.getConstraintsDescriptor(snd.getConcept().getQualifiedName())
.getProperty(SNodeUtil.property_INamedConcept_name);
if (descriptor instanceof BasePropertyConstraintsDescriptor
&& !((BasePropertyConstraintsDescriptor) descriptor).isGetterDefault()) {
needToLoad = true;
break;
}
}
if (!needToLoad) {
for (SNodeDescriptor desc : descriptors.get(0)) {
consumer.consume(desc);
}
processedConsumer.consume(sm);
}
}
}
private <T> void readModuleDescriptors(
IFile file,
Set<IFile> excludes,
List<T> result,
boolean refreshFiles,
DescriptorReader<T> reader) {
if (!needProcess(file, excludes)) return;
if (refreshFiles) {
FileSystem.getInstance().refresh(file);
}
if (file.isDirectory()) {
readModuleDescriptorsFromFolder(file, excludes, result, refreshFiles, reader);
} else {
readModuleDescriptorsFromFile(file, excludes, result, refreshFiles, reader);
}
}
boolean isModuleFile(IFile file) {
return !file.isDirectory() && DescriptorIOFacade.getInstance().fromFileType(file) != null;
}
private <T> MultiMap<SModel, T> findCandidates(
Collection<SModel> models,
Set<T> elems,
Consumer<SModel> processedModels,
Function<T, UsageEntry> id) {
// get all files in scope
final ManyToManyMap<SModel, VirtualFile> scopeFiles = new ManyToManyMap<SModel, VirtualFile>();
for (final SModel sm : models) {
if (sm instanceof EditableSModel && ((EditableSModel) sm).isChanged()) {
continue;
}
DataSource source = sm.getSource();
// these are data sources this participant knows about
if (!(source instanceof FileDataSource || source instanceof FilePerRootDataSource)) {
continue;
}
/*
This is a tmp fix for MPS-24151. See the issue to learn about the correct fix
*/
if (!(sm instanceof DefaultSModelDescriptor)) {
continue;
}
Collection<IFile> modelFiles = getDataSourceFiles(source);
for (IFile modelFile : modelFiles) {
String ext = FileUtil.getExtension(modelFile.getName());
if (ext == null || modelFile.isDirectory()) {
continue;
}
VirtualFile vf = VirtualFileUtils.getOrCreateVirtualFile(modelFile);
if (vf == null) {
LogManager.getLogger(MPSModelsFastFindSupport.class)
.warn(
String.format(
"Model %s: virtual file not found for model file. Model file: %s",
sm.getName(), modelFile.getPath()));
continue;
}
processedModels.consume(sm);
scopeFiles.addLink(sm, vf);
}
}
// filter files with usages
ConcreteFilesGlobalSearchScope allFiles =
new ConcreteFilesGlobalSearchScope(scopeFiles.getSecond());
// process indexes
MultiMap<SModel, T> result = new SetBasedMultiMap<SModel, T>();
for (T elem : elems) {
UsageEntry entry = id.apply(elem);
Collection<VirtualFile> matchingFiles;
try {
matchingFiles = MPSModelsIndexer.getContainingFiles(entry, allFiles);
} catch (ProcessCanceledException ce) {
matchingFiles = Collections.emptyList();
}
// back-transform
for (VirtualFile file : matchingFiles) {
for (SModel m : scopeFiles.getBySecond(file)) {
result.putValue(m, elem);
}
}
}
return result;
}
@Override
public void dispose() {
CodeOrchestraGenerateManager codeOrchestraGenerateManager =
myProcessor.getProject().getComponent(CodeOrchestraGenerateManager.class);
CodeOrchestraGenerationContext currentContext =
codeOrchestraGenerateManager.getCurrentContext();
List<String> relativeAssetsPaths;
if (currentContext == null) {
relativeAssetsPaths = Collections.emptyList();
} else {
relativeAssetsPaths = currentContext.getRelativeAssetsPaths();
}
Set<IFile> directories = new HashSet<IFile>();
// RF-826
// directories.add(myOutputDir);
directories.add(myCachesOutputDir);
for (IFile f : mySavedFiles) {
// RE-3231
if (f instanceof IdeaFile) {
IdeaFile ideaFile = (IdeaFile) f;
// RE-3635
if (ideaFile.getName().endsWith(TraceInfoCache.TRACE_FILE_NAME)) {
continue;
}
}
directories.add(f.getParent());
}
// clear garbage
final List<IFile> filesToDelete = new ArrayList<IFile>();
for (IFile dir : directories) {
for (IFile outputDirectoryFile : dir.getChildren()) {
if (outputDirectoryFile.isDirectory()) continue;
if (mySavedFiles.contains(outputDirectoryFile)) continue;
if (outputDirectoryFile instanceof IdeaFile) {
IdeaFile ideaFile = (IdeaFile) outputDirectoryFile;
// Ignore assets
for (String relativeAssetsPath : relativeAssetsPaths) {
if (ideaFile.getPath().endsWith(relativeAssetsPath)) {
continue;
}
}
// Ignore debug file
if (ASDebugGenFile.FILE_NAME.equals(ideaFile.getName())) {
continue;
}
// Ignore generated model digest file
if (ideaFile.getName().endsWith(".generated")) {
continue;
}
}
filesToDelete.add(outputDirectoryFile);
}
}
myProcessor.filesToDelete(filesToDelete);
myProcessor.invalidateModel(myModelDescriptor);
}