Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
21,100 | boolean (String name) { if (StringUtil.isEmptyOrSpaces(name)) return false; if (name.equals(MavenId.UNKNOWN_VALUE)) return false; for (int i = 0; i < name.length(); i++) { char ch = name.charAt(i); if (!(Character.isDigit(ch) || Character.isLetter(ch) || ch == '-' || ch == '_' || ch == '.')) { return false; } } return true; } | isValidName |
21,101 | String () { if (existingName != null) return existingName; return getDefaultModuleName(project); } | calcOriginalName |
21,102 | String () { if (existingName != null) return existingName; if (number == -1) return originalName; String result = originalName + " (" + (number + 1) + ")"; if (!hasDuplicatedGroup && !groupId.isEmpty()) { result += " (" + groupId + ")"; } return result; } | getResultName |
21,103 | int (NameItem o) { return project.getPath().compareToIgnoreCase(o.project.getPath()); } | compareTo |
21,104 | String () { return myDefaultClassifier; } | getDefaultClassifier |
21,105 | String () { return myDefaultExtension; } | getDefaultExtension |
21,106 | void (MavenProject mavenProject, PairConsumer<String, JpsModuleSourceRootType<?>> result) { MavenPlugin plugin = mavenProject.findPlugin(myPluginGroupID, myPluginArtifactID); if (plugin != null) { GroovyPluginConfigurator.Companion.collectGroovyFolders(plugin, true).forEach(path -> { result.consume(path, JavaSourceRootType.SOURCE); }); GroovyPluginConfigurator.Companion.collectGroovyFolders(plugin, false).forEach(path -> { result.consume(path, JavaSourceRootType.TEST_SOURCE); }); } } | collectSourceRoots |
21,107 | void (MavenProject mavenProject, List<String> result) { MavenPlugin plugin = mavenProject.findPlugin(myPluginGroupID, myPluginArtifactID); if (plugin != null) { result.addAll(GroovyPluginConfigurator.Companion.collectIgnoredFolders(mavenProject, plugin)); } } | collectExcludedFolders |
21,108 | void (boolean isNewlyCreatedModule) { myDelegate.init(isNewlyCreatedModule); } | init |
21,109 | ModifiableRootModel () { return myDelegate.getRootModel(); } | getRootModel |
21,110 | Module () { return myDelegate.getModule(); } | getModule |
21,111 | void () { myDelegate.clearSourceFolders(); } | clearSourceFolders |
21,112 | void (String path, JavaSourceRootType rootType, boolean ifNotEmpty) { myDelegate.addGeneratedJavaSourceFolder(path, rootType, ifNotEmpty); } | addGeneratedJavaSourceFolder |
21,113 | void (String path, JavaSourceRootType rootType) { myDelegate.addGeneratedJavaSourceFolder(path, rootType); } | addGeneratedJavaSourceFolder |
21,114 | boolean (@NotNull File f) { return myDelegate.hasRegisteredSourceSubfolder(f); } | hasRegisteredSourceSubfolder |
21,115 | SourceFolder (File folder) { return myDelegate.getSourceFolder(folder); } | getSourceFolder |
21,116 | boolean (File f) { return myDelegate.isAlreadyExcluded(f); } | isAlreadyExcluded |
21,117 | void (String path) { myDelegate.addExcludedFolder(path); } | addExcludedFolder |
21,118 | void (String path, boolean under, boolean unregisterSources) { myDelegate.unregisterAll(path, under, unregisterSources); } | unregisterAll |
21,119 | boolean (String sourceRootPath) { return myDelegate.hasCollision(sourceRootPath); } | hasCollision |
21,120 | void (String production, String test) { myDelegate.useModuleOutput(production, test); } | useModuleOutput |
21,121 | Path (String path) { return myDelegate.toPath(path); } | toPath |
21,122 | void (@NotNull String moduleName, @NotNull DependencyScope scope, boolean testJar) { myDelegate.addModuleDependency(moduleName, scope, testJar); } | addModuleDependency |
21,123 | Module (String moduleName) { return myDelegate.findModuleByName(moduleName); } | findModuleByName |
21,124 | void (MavenArtifact artifact, DependencyScope scope) { myDelegate.addSystemDependency(artifact, scope); } | addSystemDependency |
21,125 | LibraryOrderEntry (MavenArtifact artifact, DependencyScope scope, IdeModifiableModelsProvider provider, MavenProject project) { return myDelegate.addLibraryDependency(artifact, scope, provider, project); } | addLibraryDependency |
21,126 | Library (@NotNull MavenArtifact artifact) { return myDelegate.findLibrary(artifact); } | findLibrary |
21,127 | void (LanguageLevel level) { myDelegate.setLanguageLevel(level); } | setLanguageLevel |
21,128 | boolean (Library library) { String[] classRoots = library.getUrls( OrderRootType.CLASSES); if (classRoots.length != 1) return true; String classes = classRoots[0]; if (!classes.endsWith("!/")) return true; int dotPos = classes.lastIndexOf("/", classes.length() - 2 /* trim ending !/ */); if (dotPos == -1) return true; String pathToJar = classes.substring(0, dotPos); if (hasUserPaths(OrderRootType.SOURCES, library, pathToJar)) { return true; } if (hasUserPaths(JavadocOrderRootType.getInstance(), library, pathToJar)) { return true; } return false; } | isChangedByUser |
21,129 | boolean (OrderRootType rootType, Library library, String pathToJar) { String[] sources = library.getUrls(rootType); for (String each : sources) { if (!FileUtil.startsWith(each, pathToJar)) return true; } return false; } | hasUserPaths |
21,130 | boolean (@Nullable Library library) { return library != null && MavenArtifact.isMavenLibrary(library.getName()); } | isMavenLibrary |
21,131 | ProjectModelExternalSource () { return ExternalProjectSystemRegistry.getInstance().getSourceById(SerializationConstants.MAVEN_EXTERNAL_SOURCE_ID); } | getMavenExternalSource |
21,132 | OrderEntry (@NotNull Module m, @NotNull MavenArtifact artifact) { String name = artifact.getLibraryName(); for (OrderEntry each : ModuleRootManager.getInstance(m).getOrderEntries()) { if (each instanceof LibraryOrderEntry && name.equals(((LibraryOrderEntry)each).getLibraryName())) { return each; } } return null; } | findLibraryEntry |
21,133 | MavenArtifact (@NotNull MavenProject project, @Nullable Library library) { if (library == null) return null; String name = library.getName(); if (!MavenArtifact.isMavenLibrary(name)) return null; for (MavenArtifact each : project.getDependencies()) { if (each.getLibraryName().equals(name)) return each; } return null; } | findArtifact |
21,134 | List<MavenProjectsProcessorTask> () { MavenLog.LOG.info("Importing Maven project using Legacy API"); List<MavenProjectsProcessorTask> postTasks = new ArrayList<>(); boolean hasChanges; StructuredIdeActivity activity = MavenImportCollector.LEGACY_IMPORT.started(myProject); // in the case projects are changed during importing we must memorise them myAllProjects = new LinkedHashSet<>(myProjectsTree.getProjects()); myAllProjects.addAll(myProjectsToImportWithChanges.keySet()); // some projects may already have been removed from the tree hasChanges = deleteIncompatibleModules(); myProjectsToImportWithChanges = collectProjectsToImport(myProjectsToImportWithChanges); mapMavenProjectsToModulesAndNames(); if (myProject.isDisposed()) return null; final boolean projectsHaveChanges = projectsToImportHaveChanges(myProjectsToImportWithChanges.values()); final List<MavenLegacyModuleImporter.ExtensionImporter> extensionImporters = new ArrayList<>(); if (projectsHaveChanges) { hasChanges = true; StructuredIdeActivity createModulesPhase = MavenImportCollector.LEGACY_CREATE_MODULES_PHASE.startedWithParent(myProject, activity); extensionImporters.addAll(importModules()); if (!MavenUtil.isMavenUnitTestModeEnabled()) { scheduleRefreshResolvedArtifacts(postTasks, myProjectsToImportWithChanges.keySet()); } createModulesPhase.finished(); } if (myProject.isDisposed()) return null; List<Module> obsoleteModules = collectObsoleteModules(); boolean isDeleteObsoleteModules = isDeleteObsoleteModules(obsoleteModules); hasChanges |= isDeleteObsoleteModules; if (hasChanges) { StructuredIdeActivity deleteObsoletePhase = MavenImportCollector.LEGACY_DELETE_OBSOLETE_PHASE.startedWithParent(myProject, activity); MavenUtil.invokeAndWaitWriteAction(myProject, () -> { ProjectRootManagerEx.getInstanceEx(myProject).mergeRootsChangesDuring(() -> { setMavenizedModules(obsoleteModules, false); List<Module> toDelete = new ArrayList<>(); if (myPreviewModule != null) { toDelete.add(myPreviewModule); myPreviewModule = null; } if (isDeleteObsoleteModules) { toDelete.addAll(obsoleteModules); } deleteModules(toDelete); removeUnusedProjectLibraries(); myModelsProvider.commit(); if (projectsHaveChanges) { removeOutdatedCompilerConfigSettings(myProject); } if (projectsHaveChanges) { setMavenizedModules(ContainerUtil.map(myProjectsToImportWithChanges.keySet(), myMavenProjectToModule::get), true); } }); }); deleteObsoletePhase.finished(); StructuredIdeActivity importersPhase = MavenImportCollector.LEGACY_IMPORTERS_PHASE.startedWithParent(myProject, activity); importExtensions(myProject, myIdeModifiableModelsProvider, extensionImporters, postTasks, importersPhase); importersPhase.finished(); } else { finalizeImport(obsoleteModules); } activity.finished(() -> List.of(MavenImportCollector.NUMBER_OF_MODULES.with(myMavenProjectToModule.size()))); return postTasks; } | importProject |
21,135 | boolean (Collection<MavenProjectChanges> changes) { for (MavenProjectChanges each : changes) { if (each.hasChanges()) return true; } return false; } | projectsToImportHaveChanges |
21,136 | boolean () { final Pair<List<Pair<MavenProject, Module>>, List<Pair<MavenProject, Module>>> incompatible = collectIncompatibleModulesWithProjects(); final List<Pair<MavenProject, Module>> incompatibleMavenized = incompatible.first; final List<Pair<MavenProject, Module>> incompatibleNotMavenized = incompatible.second; if (incompatibleMavenized.isEmpty() && incompatibleNotMavenized.isEmpty()) return false; boolean changed = false; // For already mavenized modules the type may change because maven project plugins were resolved and MavenImporter asked to create a module of a different type. // In such cases we must change module type silently. for (Pair<MavenProject, Module> each : incompatibleMavenized) { myFileToModuleMapping.remove(each.first.getFile()); myModuleModel.disposeModule(each.second); changed = true; } if (incompatibleNotMavenized.isEmpty()) return changed; final int[] result = new int[]{Messages.OK}; if (!ApplicationManager.getApplication().isHeadlessEnvironment()) { MavenUtil.invokeAndWait(myProject, myModelsProvider.getModalityStateForQuestionDialogs(), () -> { String message = MavenProjectBundle.message("maven.import.incompatible.modules", incompatibleNotMavenized.size(), formatProjectsWithModules(incompatibleNotMavenized)); String[] options = { MavenProjectBundle.message("maven.import.incompatible.modules.recreate"), MavenProjectBundle.message("maven.import.incompatible.modules.ignore") }; result[0] = Messages.showOkCancelDialog(myProject, message, MavenProjectBundle.message("maven.project.import.title"), options[0], options[1], Messages.getQuestionIcon()); }); } if (result[0] == Messages.OK) { for (Pair<MavenProject, Module> each : incompatibleNotMavenized) { myFileToModuleMapping.remove(each.first.getFile()); myModuleModel.disposeModule(each.second); } changed = true; } else { myProjectsTree.setIgnoredState(MavenUtil.collectFirsts(incompatibleNotMavenized), true, true); } return changed; } | deleteIncompatibleModules |
21,137 | String (List<Pair<MavenProject, Module>> projectsWithModules) { return StringUtil.join(projectsWithModules, each -> { MavenProject project = each.first; Module module = each.second; return ModuleType.get(module).getName() + " '" + module.getName() + "' for Maven project " + project.getMavenId().getDisplayString(); }, "<br>"); } | formatProjectsWithModules |
21,138 | void (@NotNull List<Module> modules) { for (Module each : modules) { if (!each.isDisposed()) { myModuleModel.disposeModule(each); } } } | deleteModules |
21,139 | void (boolean answer) { answerToDeleteObsoleteModulesQuestion = answer; } | setAnswerToDeleteObsoleteModulesQuestion |
21,140 | Boolean () { return answerToDeleteObsoleteModulesQuestion; } | getAnswerToDeleteObsoleteModulesQuestion |
21,141 | boolean (@NotNull List<Module> obsoleteModules) { if (obsoleteModules.isEmpty()) { return false; } String message = MavenProjectBundle.message("maven.import.message.delete.obsolete", formatModules(obsoleteModules)); MavenLog.LOG.warn("Asking about deleting obsolete modules. " + message); if (null != answerToDeleteObsoleteModulesQuestion) { var delete = answerToDeleteObsoleteModulesQuestion; MavenLog.LOG.warn("This should only happen in tests. Delete obsolete modules: " + delete); answerToDeleteObsoleteModulesQuestion = null; return delete; } if (!ApplicationManager.getApplication().isHeadlessEnvironment() || MavenUtil.isMavenUnitTestModeEnabled()) { final int[] result = new int[1]; MavenUtil.invokeAndWait(myProject, myModelsProvider.getModalityStateForQuestionDialogs(), () -> result[0] = Messages.showYesNoDialog(myProject, message, MavenProjectBundle.message("maven.project.import.title"), Messages.getQuestionIcon())); if (result[0] == Messages.NO) { return false; } } return true; } | isDeleteObsoleteModules |
21,142 | List<Module> () { List<Module> remainingModules = new ArrayList<>(); Collections.addAll(remainingModules, myModuleModel.getModules()); for (MavenProject each : selectProjectsToImport(myAllProjects)) { remainingModules.remove(myMavenProjectToModule.get(each)); } List<Module> obsolete = new ArrayList<>(); final MavenProjectsManager manager = MavenProjectsManager.getInstance(myProject); for (Module each : remainingModules) { if (manager.isMavenizedModule(each) && myPreviewModule != each) { obsolete.add(each); } } return obsolete; } | collectObsoleteModules |
21,143 | String (final Collection<Module> modules) { StringBuilder res = new StringBuilder(); int i = 0; for (Module module : modules) { res.append('\'').append(module.getName()).append("'\n"); if (++i > 20) break; } if (i > 20) { res.append("\n ... and other ").append(modules.size() - 20).append(" modules"); } return res.toString(); } | formatModules |
21,144 | void () { for (MavenProject each : myAllProjects) { Module module = myFileToModuleMapping.get(each.getFile()); if (module != null) { myMavenProjectToModule.put(each, module); } } Map<VirtualFile, String> existingMavenProjectToModuleName = new HashMap<>(); for (var projectToModule : myMavenProjectToModule.entrySet()) { var module = projectToModule.getValue(); if (null != module) { existingMavenProjectToModuleName.put(projectToModule.getKey().getFile(), module.getName()); } } myMavenProjectToModuleName.putAll(MavenModuleNameMapper.mapModuleNames(myAllProjects, existingMavenProjectToModuleName)); MavenModulePathMapper.resolveModulePaths(myAllProjects, myMavenProjectToModule, myMavenProjectToModuleName, myMavenProjectToModulePath, myImportingSettings.getDedicatedModuleDir()); } | mapMavenProjectsToModulesAndNames |
21,145 | boolean (MavenProject project) { Module existingModule = myMavenProjectToModule.get(project); if (existingModule != null && existingModule != myPreviewModule) { myCreatedModules.add(existingModule); // compatibility with workspace importer return false; } final String path = myMavenProjectToModulePath.get(project); String moduleName = ModulePath.Companion.getModuleNameByFilePath(path); // for some reason newModule opens the existing iml file, so we // have to remove it beforehand. deleteExistingImlFile(path); deleteExistingModuleByName(moduleName); final Module module = myModuleModel.newModule(path, project.getModuleType().getId()); myMavenProjectToModule.put(project, module); myCreatedModules.add(module); return true; } | ensureModuleCreated |
21,146 | void (final String name) { Module module = myModuleModel.findModuleByName(name); if (module != null) { myModuleModel.disposeModule(module); } } | deleteExistingModuleByName |
21,147 | void (final String path) { MavenUtil.invokeAndWaitWriteAction(myProject, new Runnable() { @Override public void run() { try { VirtualFile file = LocalFileSystem.getInstance().refreshAndFindFileByPath(path); if (file != null) file.delete(this); } catch (IOException e) { MavenLog.LOG.warn("Cannot delete existing iml file: " + path, e); } } }); } | deleteExistingImlFile |
21,148 | void () { try { VirtualFile file = LocalFileSystem.getInstance().refreshAndFindFileByPath(path); if (file != null) file.delete(this); } catch (IOException e) { MavenLog.LOG.warn("Cannot delete existing iml file: " + path, e); } } | run |
21,149 | MavenLegacyModuleImporter (@NotNull Module module, @NotNull MavenProject mavenProject, @NotNull MavenProjectChanges changes) { return new MavenLegacyModuleImporter(module, myProjectsTree, mavenProject, myMavenProjectToModuleName, myImportingSettings, myModelsProvider); } | createModuleImporter |
21,150 | boolean () { Set<Library> unusedLibraries = new HashSet<>(); Collections.addAll(unusedLibraries, myModelsProvider.getAllLibraries()); for (ModuleRootModel eachModel : collectModuleModels()) { for (OrderEntry eachEntry : eachModel.getOrderEntries()) { if (eachEntry instanceof LibraryOrderEntry) { unusedLibraries.remove(((LibraryOrderEntry)eachEntry).getLibrary()); } } } boolean removed = false; for (Library each : unusedLibraries) { if (!isDisposed(each) && MavenRootModelAdapter.isMavenLibrary(each)) { if (!MavenRootModelAdapter.isChangedByUser(each)) { myModelsProvider.removeLibrary(each); removed = true; } else { MavenImportCollector.HAS_USER_MODIFIED_IMPORTED_LIBRARY.log(myProject); } } } return removed; } | removeUnusedProjectLibraries |
21,151 | boolean (Library library) { return library instanceof LibraryEx && ((LibraryEx)library).isDisposed(); } | isDisposed |
21,152 | Collection<ModuleRootModel> () { Map<Module, ModuleRootModel> rootModels = new HashMap<>(); for (MavenProject each : myProjectsToImportWithChanges.keySet()) { Module module = myMavenProjectToModule.get(each); ModifiableRootModel rootModel = myModelsProvider.getModifiableRootModel(module); rootModels.put(module, rootModel); } for (Module each : myModuleModel.getModules()) { if (rootModels.containsKey(each)) continue; rootModels.put(each, myModelsProvider.getModifiableRootModel(each)); } return rootModels.values(); } | collectModuleModels |
21,153 | List<Module> () { return myCreatedModules; } | createdModules |
21,154 | Module[] () { return ArrayUtil.remove(modelsProvider.getModules(), myPreviewModule); } | getModules |
21,155 | VirtualFile[] (Module module) { return modelsProvider.getContentRoots(module); } | getContentRoots |
21,156 | MavenPlugin (@NotNull MavenProject mavenProject) { return mavenProject.findPlugin("org.codehaus.mojo", "build-helper-maven-plugin"); } | findPlugin |
21,157 | void (@NotNull MavenProject mavenProject, @NotNull String goal, @NotNull Consumer<String> addFolder) { final MavenPlugin plugin = findPlugin(mavenProject); if (plugin != null) { addBuilderHelperPaths(plugin, goal, addFolder); } } | addBuilderHelperPaths |
21,158 | void (@NotNull MavenPlugin plugin, @NotNull String goal, @NotNull Consumer<String> addFolder) { for (MavenPlugin.Execution execution : plugin.getExecutions()) { if (execution.getGoals().contains(goal)) { final Element configurationElement = execution.getConfigurationElement(); if (configurationElement != null) { final Element sourcesElement = configurationElement.getChild("sources"); if (sourcesElement != null) { for (Element element : sourcesElement.getChildren()) { addFolder.accept(element.getTextTrim()); } } } } } } | addBuilderHelperPaths |
21,159 | void (@NotNull MavenProject mavenProject, @NotNull String goal, @NotNull Consumer<String> addFolder) { final MavenPlugin plugin = findPlugin(mavenProject); if (plugin != null) { addBuilderHelperResourcesPaths(plugin, goal, addFolder); } } | addBuilderHelperResourcesPaths |
21,160 | void (@NotNull MavenPlugin plugin, @NotNull String goal, @NotNull Consumer<String> addFolder) { for (MavenPlugin.Execution execution : plugin.getExecutions()) { if (execution.getGoals().contains(goal)) { final Element configurationElement = execution.getConfigurationElement(); if (configurationElement != null) { final Element sourcesElement = configurationElement.getChild("resources"); if (sourcesElement != null) { for (Element element : sourcesElement.getChildren()) { Element directory = element.getChild("directory"); if (directory != null) addFolder.accept(directory.getTextTrim()); } } } } } } | addBuilderHelperResourcesPaths |
21,161 | ManifestImporter (@NotNull String packaging) { for (ManifestImporter importer : EXTENSION_POINT_NAME.getExtensions()) { if (importer.isApplicable(packaging)) { return importer; } } return new DefaultManifestImporter(); } | getManifestImporter |
21,162 | String (@NotNull MavenProject mavenProject, @Nullable Element manifestConfiguration) { StringBuilder classpath = new StringBuilder(); String classpathPrefix = getClasspathPrefix(manifestConfiguration); for (MavenArtifact mavenArtifact : mavenProject.getDependencies()) { final DependencyScope scope = MavenLegacyModuleImporter.selectScope(mavenArtifact.getScope()); if (scope.isForProductionCompile() || scope.isForProductionRuntime()) { if (classpath.length() > 0) { classpath.append(" "); } classpath.append(classpathPrefix); String artifactFileName = mavenArtifact.getArtifactId() + "-" + mavenArtifact.getVersion() + "." + mavenArtifact.getExtension(); classpath.append(doGetClasspathItem(mavenProject, mavenArtifact, artifactFileName)); } } return classpath.toString(); } | getClasspath |
21,163 | boolean (String packaging) { return true; } | isApplicable |
21,164 | String (@NotNull MavenProject mavenProject, @NotNull MavenArtifact mavenArtifact, @NotNull String artifactFileName) { return artifactFileName; } | doGetClasspathItem |
21,165 | void (List<Module> obsoleteModules) { MavenUtil.invokeAndWaitWriteAction(myProject, () -> setMavenizedModules(obsoleteModules, false)); MavenUtil.invokeAndWaitWriteAction(myProject, () -> myModelsProvider.dispose()); } | finalizeImport |
21,166 | void (final Collection<Module> modules, final boolean mavenized) { ApplicationManager.getApplication().assertWriteAccessAllowed(); EntityStorage initialStorage = WorkspaceModel.getInstance(myProject).getCurrentSnapshot(); MutableEntityStorage storageBuilder = MutableEntityStorage.from(initialStorage.toSnapshot()); for (Module module : modules) { if (module.isDisposed()) continue; ExternalSystemModulePropertyManager modulePropertyManager = ExternalSystemModulePropertyManager.getInstance(module); if (modulePropertyManager instanceof ExternalSystemModulePropertyManagerBridge && module instanceof ModuleBridge && ((ModuleBridge)module).getDiff() == null) { ((ExternalSystemModulePropertyManagerBridge)modulePropertyManager).setMavenized(mavenized, null, storageBuilder); } else { modulePropertyManager.setMavenized(mavenized); } } WorkspaceModel.getInstance(myProject).updateProjectModel("Set mavenized modules", builder -> { builder.addDiff(storageBuilder); return null; }); } | setMavenizedModules |
21,167 | ProjectCoordinate (Module module) { if (!ExternalSystemModulePropertyManager.getInstance(module).isMavenized()) { return null; } MavenProject mavenProject = MavenProjectsManager.getInstance(module.getProject()).findProject(module); if (mavenProject != null) { MavenId mavenId = mavenProject.getMavenId(); return new ProjectId(mavenId.getGroupId(), mavenId.getArtifactId(), mavenId.getVersion()); } return null; } | findProjectId |
21,168 | void (final Project project, final boolean updateTargetFoldersOnly) { final MavenProjectsManager manager = MavenProjectsManager.getInstance(project); final MavenImportingSettings settings = manager.getImportingSettings(); WriteAction.run(() -> { List<ModifiableRootModel> rootModels = new ArrayList<>(); for (Module each : ModuleManager.getInstance(project).getModules()) { MavenProject mavenProject = manager.findProject(each); if (mavenProject == null) continue; MavenRootModelAdapter a = new MavenRootModelAdapter( new MavenRootModelAdapterLegacyImpl(mavenProject, each, ProjectDataManager.getInstance().createModifiableModelsProvider(project))); new MavenLegacyFoldersImporter(mavenProject, settings, a).config(updateTargetFoldersOnly); ModifiableRootModel model = a.getRootModel(); if (model.isChanged()) { rootModels.add(model); } else { model.dispose(); } } if (!rootModels.isEmpty()) { ModifiableModelCommitter.multiCommit(rootModels, ModuleManager.getInstance(rootModels.get((0)).getProject()).getModifiableModel()); } }); } | updateProjectFolders |
21,169 | void () { config(false); } | config |
21,170 | void (boolean updateTargetFoldersOnly) { if (!updateTargetFoldersOnly) { if (!myImportingSettings.isKeepSourceFolders()) { myModel.clearSourceFolders(); } configSourceFolders(); configOutputFolders(); } configGeneratedFolders(); if (!updateTargetFoldersOnly) { if (!FileUtil.namesEqual("pom", myMavenProject.getFile().getNameWithoutExtension()) && MavenUtil.streamPomFiles(myModel.getModule().getProject(), myMavenProject.getDirectoryFile()).skip(1).findAny().isPresent()) { generateNewContentRoots(false); } else { generateNewContentRoots(true); } } configExcludedFolders(); } | config |
21,171 | void () { myModel.clearSourceFolders(); myModel.useModuleOutput(null, null); configExcludedAggregatorFolders(); } | configMainAndTestAggregator |
21,172 | void (StandardMavenModuleType type) { if (!myImportingSettings.isKeepSourceFolders()) { myModel.clearSourceFolders(); } boolean isTest = type == StandardMavenModuleType.TEST_ONLY; Map<String, JpsModuleSourceRootType<?>> sourceFolders = isTest ? getTestSourceFolders(myMavenProject) : getMainSourceFolders(myMavenProject); java.nio.file.Path contentRootPath = java.nio.file.Path.of(myMavenProject.getDirectory(), "src", isTest ? "test" : "main"); String defaultContentRoot = contentRootPath.toString(); boolean containDefaultContentRoot = false; for (String path : sourceFolders.keySet()) { if (!containDefaultContentRoot) { containDefaultContentRoot = path.contains(defaultContentRoot); } } sourceFolders.forEach((p, t) -> myModel.addSourceFolder(p, t)); configOutputFolders(isTest); configGeneratedFolders(isTest); generateNewContentRoots(containDefaultContentRoot ? contentRootPath : null); } | configMainAndTest |
21,173 | void () { Map<String, JpsModuleSourceRootType<?>> sourceFolders = getSourceFolders(myMavenProject); sourceFolders.forEach((p, t) -> myModel.addSourceFolder(p, t)); } | configSourceFolders |
21,174 | boolean (String canonicalPath, Map<String, ?> addedPaths) { for (String existing : addedPaths.keySet()) { if (VfsUtilCore.isEqualOrAncestor(existing, canonicalPath) || VfsUtilCore.isEqualOrAncestor(canonicalPath, existing)) { return true; } } return false; } | alreadyAdded |
21,175 | void (MavenProject mavenProject, MultiMap<JpsModuleSourceRootType<?>, String> roots) { roots.putValues(JavaSourceRootType.SOURCE, mavenProject.getSources()); for (MavenImporter each : MavenImporter.getSuitableImporters(mavenProject)) { each.collectSourceRoots(mavenProject, (s, type) -> roots.putValue(type, s)); } for (MavenResource each : mavenProject.getResources()) { roots.putValue(JavaResourceRootType.RESOURCE, each.getDirectory()); } BuildHelperMavenPluginUtil.addBuilderHelperPaths(mavenProject, "add-source", path -> roots.putValue(JavaSourceRootType.SOURCE, path)); BuildHelperMavenPluginUtil.addBuilderHelperResourcesPaths(mavenProject, "add-resource", path -> roots.putValue(JavaResourceRootType.RESOURCE, path)); } | addMainSourcePath |
21,176 | void (MavenProject mavenProject, MultiMap<JpsModuleSourceRootType<?>, String> roots) { roots.putValues(JavaSourceRootType.TEST_SOURCE, mavenProject.getTestSources()); for (MavenResource each : mavenProject.getTestResources()) { roots.putValue(JavaResourceRootType.TEST_RESOURCE, each.getDirectory()); } BuildHelperMavenPluginUtil.addBuilderHelperPaths(mavenProject, "add-test-source", path -> roots.putValue(JavaSourceRootType.TEST_SOURCE, path)); BuildHelperMavenPluginUtil.addBuilderHelperResourcesPaths(mavenProject, "add-test-resource", path -> roots.putValue(JavaResourceRootType.TEST_RESOURCE, path)); } | addTestSourcePath |
21,177 | void () { if (myImportingSettings.isUseMavenOutput()) { myModel.useModuleOutput(myMavenProject.getOutputDirectory(), myMavenProject.getTestOutputDirectory()); } String buildDirPath = myModel.toPath(myMavenProject.getBuildDirectory()).getPath(); String outputDirPath = myModel.toPath(myMavenProject.getOutputDirectory()).getPath(); if ((!VfsUtilCore.isEqualOrAncestor(buildDirPath, outputDirPath))) { myModel.addExcludedFolder(myMavenProject.getOutputDirectory()); } String testOutputDirPath = myModel.toPath(myMavenProject.getTestOutputDirectory()).getPath(); if ((!VfsUtilCore.isEqualOrAncestor(buildDirPath, testOutputDirPath))) { myModel.addExcludedFolder(myMavenProject.getTestOutputDirectory()); } } | configOutputFolders |
21,178 | void (boolean test) { if (myImportingSettings.isUseMavenOutput()) { if (test) { myModel.useModuleOutput("", myMavenProject.getTestOutputDirectory()); } else { myModel.useModuleOutput(myMavenProject.getOutputDirectory(), ""); } } String buildDirPath = myModel.toPath(myMavenProject.getBuildDirectory()).getPath(); String outputDirPath = myModel.toPath(myMavenProject.getOutputDirectory()).getPath(); if (test) { String testOutputDirPath = myModel.toPath(myMavenProject.getTestOutputDirectory()).getPath(); if ((!VfsUtilCore.isEqualOrAncestor(buildDirPath, testOutputDirPath))) { myModel.addExcludedFolder(myMavenProject.getTestOutputDirectory()); } } else { if ((!VfsUtilCore.isEqualOrAncestor(buildDirPath, outputDirPath))) { myModel.addExcludedFolder(myMavenProject.getOutputDirectory()); } } } | configOutputFolders |
21,179 | void () { File targetDir = new File(myMavenProject.getBuildDirectory()); String generatedDir = myMavenProject.getGeneratedSourcesDirectory(false); String generatedDirTest = myMavenProject.getGeneratedSourcesDirectory(true); myModel.unregisterAll(targetDir.getPath(), false, false); if (myImportingSettings.getGeneratedSourcesFolder() != MavenImportingSettings.GeneratedSourcesFolder.IGNORE) { myModel.addGeneratedJavaSourceFolder(myMavenProject.getAnnotationProcessorDirectory(true), JavaSourceRootType.TEST_SOURCE); myModel.addGeneratedJavaSourceFolder(myMavenProject.getAnnotationProcessorDirectory(false), JavaSourceRootType.SOURCE); } File[] targetChildren = targetDir.listFiles(); if (targetChildren != null) { for (File f : targetChildren) { if (!f.isDirectory()) continue; if (FileUtil.pathsEqual(generatedDir, f.getPath())) { configGeneratedSourceFolder(f, JavaSourceRootType.SOURCE); } else if (FileUtil.pathsEqual(generatedDirTest, f.getPath())) { configGeneratedSourceFolder(f, JavaSourceRootType.TEST_SOURCE); } } } } | configGeneratedFolders |
21,180 | void (boolean test) { File targetDir = new File(myMavenProject.getBuildDirectory()); String generatedDir = test ? myMavenProject.getGeneratedSourcesDirectory(true) : myMavenProject.getGeneratedSourcesDirectory(false); myModel.unregisterAll(targetDir.getPath(), false, false); if (myImportingSettings.getGeneratedSourcesFolder() != MavenImportingSettings.GeneratedSourcesFolder.IGNORE) { if (test) { myModel.addGeneratedJavaSourceFolder(myMavenProject.getAnnotationProcessorDirectory(true), JavaSourceRootType.TEST_SOURCE); } else { myModel.addGeneratedJavaSourceFolder(myMavenProject.getAnnotationProcessorDirectory(false), JavaSourceRootType.SOURCE); } } File[] targetChildren = targetDir.listFiles(); if (targetChildren != null) { for (File f : targetChildren) { if (!f.isDirectory()) continue; if (!test && FileUtil.pathsEqual(generatedDir, f.getPath())) { configGeneratedSourceFolder(f, JavaSourceRootType.SOURCE); } else if (test && FileUtil.pathsEqual(generatedDir, f.getPath())) { configGeneratedSourceFolder(f, JavaSourceRootType.TEST_SOURCE); } } } } | configGeneratedFolders |
21,181 | void (boolean orphansOnly) { Map<String, SourceFolder> sourceFoldersMap = new TreeMap<>(FileUtil::comparePaths); for (String sourceRootUrl : myModel.getSourceRootUrls(true)) { String sourceRootPath = FileUtil.toSystemDependentName(VfsUtilCore.urlToPath(sourceRootUrl)); SourceFolder sourceFolder = myModel.getSourceFolder(new File(sourceRootPath)); if (sourceFolder != null) { sourceFoldersMap.put(sourceRootUrl, sourceFolder); } } ModifiableRootModel rootModel = myModel.getRootModel(); if (orphansOnly) { for (ContentEntry contentEntry : rootModel.getContentEntries()) { sourceFoldersMap.keySet().removeIf(root -> FileUtil.isAncestor(contentEntry.getUrl(), root, false)); } } else { for (ContentEntry contentEntry : rootModel.getContentEntries()) { rootModel.removeContentEntry(contentEntry); } } Set<String> topLevelSourceFolderUrls = new HashSet<>(); for (String sourceRoot : sourceFoldersMap.keySet()) { if (!ContainerUtil.exists(topLevelSourceFolderUrls, root -> FileUtil.isAncestor(root, sourceRoot, false))) { topLevelSourceFolderUrls.add(sourceRoot); } } setContentRootData(topLevelSourceFolderUrls, rootModel, sourceFoldersMap); } | generateNewContentRoots |
21,182 | void (@Nullable java.nio.file.Path defaultContentRootPath) { Map<String, SourceFolder> sourceFoldersMap = new TreeMap<>(FileUtil::comparePaths); for (String sourceRootUrl : myModel.getSourceRootUrls(true)) { String sourceRootPath = FileUtil.toSystemDependentName(VfsUtilCore.urlToPath(sourceRootUrl)); SourceFolder sourceFolder = myModel.getSourceFolder(new File(sourceRootPath)); if (sourceFolder != null) { sourceFoldersMap.put(sourceRootUrl, sourceFolder); } } ModifiableRootModel rootModel = myModel.getRootModel(); for (ContentEntry contentEntry : rootModel.getContentEntries()) { rootModel.removeContentEntry(contentEntry); } Set<String> topLevelSourceFolderUrls = new HashSet<>(); if (defaultContentRootPath != null) { String defaultContentRootUrl = MavenUtil.toPath(myMavenProject, defaultContentRootPath.toString()).toUrl().getUrl(); topLevelSourceFolderUrls.add(defaultContentRootUrl); } for (String sourceRoot : sourceFoldersMap.keySet()) { if (!ContainerUtil.exists(topLevelSourceFolderUrls, root -> FileUtil.isAncestor(root, sourceRoot, false))) { topLevelSourceFolderUrls.add(sourceRoot); } } setContentRootData(topLevelSourceFolderUrls, rootModel, sourceFoldersMap); } | generateNewContentRoots |
21,183 | void (Set<String> topLevelSourceFolderUrls, ModifiableRootModel rootModel, Map<String, SourceFolder> sourceFoldersMap) { for (String sourceFolderUrl : topLevelSourceFolderUrls) { if (isAlreadyContentRoot(sourceFolderUrl, rootModel.getProject())) continue; ContentEntry contentEntry = rootModel.addContentEntry(sourceFolderUrl); for (Map.Entry<String, SourceFolder> entry : sourceFoldersMap.entrySet()) { if (FileUtil.isAncestor(sourceFolderUrl, entry.getKey(), false)) { SourceFolder oldSourceFolder = entry.getValue(); SourceFolder newSourceFolder = contentEntry.addSourceFolder(oldSourceFolder.getUrl(), oldSourceFolder.getRootType()); newSourceFolder.setPackagePrefix(oldSourceFolder.getPackagePrefix()); } } } } | setContentRootData |
21,184 | boolean (String sourceFolderUrl, Project project) { URL url = VfsUtilCore.convertToURL(sourceFolderUrl); if (url == null) return false; VirtualFile sourceFolder = VfsUtil.findFileByURL(url); if (sourceFolder == null) return false; MavenProjectsManager mavenProjectsManager = MavenProjectsManager.getInstance(project); MavenProject containingProject = ReadAction.compute(() -> mavenProjectsManager.findContainingProject(sourceFolder)); if (containingProject != null) { Module module = ReadAction.compute(() -> mavenProjectsManager.findModule(containingProject)); if (module == null) return false; for (ContentEntry contentEntry : ModuleRootManager.getInstance(module).getContentEntries()) { if (contentEntry.getUrl().equals(sourceFolderUrl)) { return true; } } } return false; } | isAlreadyContentRoot |
21,185 | void () { File targetDir = new File(myMavenProject.getBuildDirectory()); String generatedDir = myMavenProject.getGeneratedSourcesDirectory(false); String generatedDirTest = myMavenProject.getGeneratedSourcesDirectory(true); File[] targetChildren = targetDir.listFiles(); if (targetChildren != null) { for (File f : targetChildren) { if (!f.isDirectory()) continue; if (!FileUtil.pathsEqual(generatedDir, f.getPath()) && !FileUtil.pathsEqual(generatedDirTest, f.getPath())) { if (myImportingSettings.isExcludeTargetFolder()) { if (myModel.hasRegisteredSourceSubfolder(f)) continue; if (myModel.isAlreadyExcluded(f)) continue; myModel.addExcludedFolder(f.getPath()); // is supported in workspace import? } } } } List<String> facetExcludes = new NotNullList<>(); for (MavenImporter each : MavenImporter.getSuitableImporters(myMavenProject)) { each.collectExcludedFolders(myMavenProject, facetExcludes); } for (String eachFolder : facetExcludes) { myModel.unregisterAll(eachFolder, true, true); myModel.addExcludedFolder(eachFolder); } if (myImportingSettings.isExcludeTargetFolder()) { myModel.addExcludedFolder(targetDir.getPath()); } } | configExcludedFolders |
21,186 | void () { File targetDir = new File(myMavenProject.getBuildDirectory()); List<String> facetExcludes = new NotNullList<>(); for (MavenImporter each : MavenImporter.getSuitableImporters(myMavenProject)) { each.collectExcludedFolders(myMavenProject, facetExcludes); } for (String eachFolder : facetExcludes) { myModel.unregisterAll(eachFolder, true, true); myModel.addExcludedFolder(eachFolder); } if (myImportingSettings.isExcludeTargetFolder()) { myModel.addExcludedFolder(targetDir.getPath()); } } | configExcludedAggregatorFolders |
21,187 | void (@NotNull File targetDir, final JavaSourceRootType rootType) { switch (myImportingSettings.getGeneratedSourcesFolder()) { case GENERATED_SOURCE_FOLDER -> myModel.addGeneratedJavaSourceFolder(targetDir.getPath(), rootType); case SUBFOLDER -> addAllSubDirsAsGeneratedSources(targetDir, rootType); case AUTODETECT -> { Collection<JavaModuleSourceRoot> sourceRoots = JavaSourceRootDetectionUtil.suggestRoots(targetDir); for (JavaModuleSourceRoot root : sourceRoots) { if (FileUtil.filesEqual(targetDir, root.getDirectory())) { myModel.addGeneratedJavaSourceFolder(targetDir.getPath(), rootType); return; } addAsGeneratedSourceFolder(root.getDirectory(), rootType); } addAllSubDirsAsGeneratedSources(targetDir, rootType); } case IGNORE -> { // Ignore. } } } | configGeneratedSourceFolder |
21,188 | void (@NotNull File dir, final JavaSourceRootType rootType) { SourceFolder folder = myModel.getSourceFolder(dir); if (!myModel.hasRegisteredSourceSubfolder(dir) || folder != null && !isGenerated(folder)) { myModel.addGeneratedJavaSourceFolder(dir.getPath(), rootType); } } | addAsGeneratedSourceFolder |
21,189 | boolean (@NotNull SourceFolder folder) { JavaSourceRootProperties properties = folder.getJpsElement().getProperties(JavaModuleSourceRootTypes.SOURCES); return properties != null && properties.isForGeneratedSources(); } | isGenerated |
21,190 | void (@NotNull File dir, final JavaSourceRootType rootType) { for (File f : getChildren(dir)) { if (f.isDirectory()) { addAsGeneratedSourceFolder(f, rootType); } } } | addAllSubDirsAsGeneratedSources |
21,191 | File[] (File dir) { File[] result = dir.listFiles(); return result == null ? ArrayUtilRt.EMPTY_FILE_ARRAY : result; } | getChildren |
21,192 | boolean (MavenProject mavenProject) { return true; } | isApplicable |
21,193 | boolean () { return true; } | isMigratedToConfigurator |
21,194 | void (@NotNull MavenWorkspaceConfigurator.MutableModelContext context) { Map<MavenId, List<String>> mavenProjectToModuleNamesCache = new HashMap<>(); for (MavenProjectWithModules<ModuleEntity> each : SequencesKt.asIterable(context.getMavenProjectsWithModules())) { List<String> moduleNames = ContainerUtil.mapNotNull(each.getModules(), it -> it.getType().getContainsCode() ? it.getModule().getName() : null); mavenProjectToModuleNamesCache.put(each.getMavenProject().getMavenId(), moduleNames); } var changedOnlyProjects = SequencesKt.mapNotNull(context.getMavenProjectsWithModules(), it -> { return it.getChanges().hasChanges() ? it.getMavenProject() : null; }); var map = new HashMap<MavenProject, List<String>>(); collectProcessorModuleNames(SequencesKt.asIterable(changedOnlyProjects), moduleName -> mavenProjectToModuleNamesCache.get(moduleName), map); ANNOTATION_PROCESSOR_MODULE_NAMES.set(context, map); } | beforeModelApplied |
21,195 | void (@NotNull IdeModifiableModelsProvider modifiableModelsProvider, @NotNull Module module, @NotNull MavenRootModelAdapter rootModel, @NotNull MavenProjectsTree mavenModel, @NotNull MavenProject mavenProject, @NotNull MavenProjectChanges changes, @NotNull Map<MavenProject, String> mavenProjectToModuleName, @NotNull List<MavenProjectsProcessorTask> postTasks) { Element config = getConfig(mavenProject, "annotationProcessorPaths"); if (config == null) return; String annotationTargetDir = mavenProject.getAnnotationProcessorDirectory(false); // directory must exist before compilation start to be recognized as source root new File(rootModel.toPath(annotationTargetDir).getPath()).mkdirs(); rootModel.addGeneratedJavaSourceFolder(annotationTargetDir, JavaSourceRootType.SOURCE, false); Map<MavenProject, List<String>> map = ANNOTATION_PROCESSOR_MODULE_NAMES.get(modifiableModelsProvider, new HashMap<>()); collectProcessorModuleNames(List.of(mavenProject), mavenId -> { MavenProject mavenArtifact = mavenModel.findProject(mavenId); if (mavenArtifact == null) return null; String moduleName = mavenProjectToModuleName.get(mavenArtifact); if (moduleName == null) return null; return List.of(moduleName); }, map); ANNOTATION_PROCESSOR_MODULE_NAMES.set(modifiableModelsProvider, map); } | process |
21,196 | void (Iterable<MavenProject> projects, Function<@NotNull MavenId, @Nullable List<String>> moduleNameByProjectId, Map<MavenProject, List<String>> result) { for (var mavenProject : projects) { if (!shouldEnableAnnotationProcessors(mavenProject)) continue; Element config = getConfig(mavenProject, "annotationProcessorPaths"); if (config == null) continue; for (MavenArtifactInfo info : getProcessorArtifactInfos(config)) { var mavenId = new MavenId(info.getGroupId(), info.getArtifactId(), info.getVersion()); var processorModuleNames = moduleNameByProjectId.apply(mavenId); if (processorModuleNames != null) { result.computeIfAbsent(mavenProject, __ -> new ArrayList<>()).addAll(processorModuleNames); } } } } | collectProcessorModuleNames |
21,197 | void (@NotNull MavenWorkspaceConfigurator.AppliedModelContext context) { Map<String, Module> nameToModuleCache = new HashMap<>(); for (MavenProjectWithModules<Module> each : SequencesKt.asIterable(context.getMavenProjectsWithModules())) { for (ModuleWithType<Module> moduleWithType : each.getModules()) { Module module = moduleWithType.getModule(); nameToModuleCache.put(module.getName(), module); } } Function<@NotNull String, @Nullable Module> moduleByName = moduleName -> nameToModuleCache.get(moduleName); Map<MavenProject, List<String>> perProjectProcessorModuleNames = ANNOTATION_PROCESSOR_MODULE_NAMES.get(context, Map.of()); var changedOnly = SequencesKt.filter(context.getMavenProjectsWithModules(), it -> it.getChanges().hasChanges()); var projectWithModules = SequencesKt.map(changedOnly, it -> { List<String> processorModuleNames = perProjectProcessorModuleNames.getOrDefault(it.getMavenProject(), List.of()); return new MavenProjectWithProcessorModules(it.getMavenProject(), it.getModules(), processorModuleNames); }); configureProfiles(context.getProject(), context.getMavenProjectsTree(), SequencesKt.asIterable(projectWithModules), moduleByName); } | afterModelApplied |
21,198 | void (Module module, MavenProject mavenProject, MavenProjectChanges changes, IdeModifiableModelsProvider modifiableModelsProvider) { var processorModuleNames = ANNOTATION_PROCESSOR_MODULE_NAMES.get(modifiableModelsProvider, Map.of()).getOrDefault(mavenProject, List.of()); var moduleWithType = new ModuleWithType<Module>() { @Override public Module getModule() { return module; } @NotNull @Override public MavenModuleType getType() { return StandardMavenModuleType.SINGLE_MODULE; } }; var projectWithModules = new MavenProjectWithProcessorModules(mavenProject, List.of(moduleWithType), processorModuleNames); configureProfiles(module.getProject(), MavenProjectsManager.getInstance(module.getProject()).getProjectsTree(), List.of(projectWithModules), moduleName -> modifiableModelsProvider.findIdeModule(moduleName)); } | postProcess |
21,199 | Module () { return module; } | getModule |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.