Examples with EclipseClasspathReader org.jetbrains.idea.eclipse.conversion.EclipseClasspathReader used on opensource projects

Example 1 with EclipseClasspathReader

use of org.jetbrains.idea.eclipse.conversion.EclipseClasspathReader in project intellij-community by JetBrains.

the class EclipseClasspathConverter method readClasspath.

@Override
public void readClasspath(@NotNull ModifiableRootModel model) throws IOException {
    try {
        CachedXmlDocumentSet fileSet = getFileSet();
        String path = fileSet.getParent(EclipseXml.PROJECT_FILE);
        Element classpath = null;
        if (!fileSet.exists(EclipseXml.PROJECT_FILE)) {
            classpath = fileSet.load(EclipseXml.CLASSPATH_FILE, false);
            if (classpath == null) {
                return;
            }
            path = fileSet.getParent(EclipseXml.CLASSPATH_FILE);
        }
        EclipseClasspathReader classpathReader = new EclipseClasspathReader(path, module.getProject(), null);
        classpathReader.init(model);
        if (classpath == null) {
            classpath = fileSet.load(EclipseXml.CLASSPATH_FILE, false);
        }
        if (classpath == null) {
            EclipseClasspathReader.setOutputUrl(model, path + "/bin");
        } else {
            classpathReader.readClasspath(model, classpath);
        }
        Element eml = fileSet.load(model.getModule().getName() + EclipseXml.IDEA_SETTINGS_POSTFIX, false);
        if (eml == null) {
            model.getModuleExtension(CompilerModuleExtension.class).setExcludeOutput(false);
        } else {
            new IdeaSpecificSettings().readIdeaSpecific(eml, model, null, null);
        }
    } catch (JDOMException e) {
        throw new IOException(e);
    }
}

Example 2 with EclipseClasspathReader

use of org.jetbrains.idea.eclipse.conversion.EclipseClasspathReader in project intellij-community by JetBrains.

the class EclipseImlTest method doTest.

protected static void doTest(final String relativePath, final Project project) throws Exception {
    final String path = project.getBaseDir().getPath() + relativePath;
    final File classpathFile = new File(path, EclipseXml.DOT_CLASSPATH_EXT);
    String fileText = FileUtil.loadFile(classpathFile).replaceAll("\\$ROOT\\$", project.getBaseDir().getPath());
    if (!SystemInfo.isWindows) {
        fileText = fileText.replaceAll(EclipseXml.FILE_PROTOCOL + "/", EclipseXml.FILE_PROTOCOL);
    }
    String communityLib = FileUtil.toSystemIndependentName(PathManagerEx.findFileUnderCommunityHome("lib").getAbsolutePath());
    fileText = fileText.replaceAll("\\$" + JUNIT + "\\$", communityLib);
    final Element classpathElement = JdomKt.loadElement(fileText);
    final Module module = WriteCommandAction.runWriteCommandAction(null, (Computable<Module>) () -> ModuleManager.getInstance(project).newModule(new File(path) + File.separator + EclipseProjectFinder.findProjectName(path) + ModuleManagerImpl.IML_EXTENSION, StdModuleTypes.JAVA.getId()));
    final ModifiableRootModel rootModel = ModuleRootManager.getInstance(module).getModifiableModel();
    EclipseClasspathReader classpathReader = new EclipseClasspathReader(path, project, null);
    classpathReader.init(rootModel);
    classpathReader.readClasspath(rootModel, classpathElement);
    ApplicationManager.getApplication().runWriteAction(rootModel::commit);
    final Element actualImlElement = new Element("root");
    ((ModuleRootManagerImpl) ModuleRootManager.getInstance(module)).getState().writeExternal(actualImlElement);
    PathMacros.getInstance().setMacro(JUNIT, communityLib);
    PathMacroManager.getInstance(module).collapsePaths(actualImlElement);
    PathMacroManager.getInstance(project).collapsePaths(actualImlElement);
    PathMacros.getInstance().removeMacro(JUNIT);
    assertThat(actualImlElement).isEqualTo(Paths.get(project.getBaseDir().getPath(), "expected", "expected.iml"));
}

Example 3 with EclipseClasspathReader

use of org.jetbrains.idea.eclipse.conversion.EclipseClasspathReader in project intellij-community by JetBrains.

the class EclipseImportBuilder method commit.

@Override
public List<Module> commit(final Project project, ModifiableModuleModel model, ModulesProvider modulesProvider, ModifiableArtifactModel artifactModel) {
    final Collection<String> unknownLibraries = new TreeSet<>();
    final Collection<String> unknownJdks = new TreeSet<>();
    final Set<String> refsToModules = new HashSet<>();
    final List<Module> result = new ArrayList<>();
    final Map<Module, Set<String>> module2NatureNames = new HashMap<>();
    try {
        final ModifiableModuleModel moduleModel = model != null ? model : ModuleManager.getInstance(project).getModifiableModel();
        final ModifiableRootModel[] rootModels = new ModifiableRootModel[getParameters().projectsToConvert.size()];
        final Set<File> files = new HashSet<>();
        final Set<String> moduleNames = new THashSet<>(getParameters().projectsToConvert.size());
        for (String path : getParameters().projectsToConvert) {
            String modulesDirectory = getParameters().converterOptions.commonModulesDirectory;
            if (modulesDirectory == null) {
                modulesDirectory = path;
            }
            final String moduleName = EclipseProjectFinder.findProjectName(path);
            moduleNames.add(moduleName);
            final File imlFile = new File(modulesDirectory + File.separator + moduleName + ModuleManagerImpl.IML_EXTENSION);
            if (imlFile.isFile()) {
                files.add(imlFile);
            }
            final File emlFile = new File(modulesDirectory + File.separator + moduleName + EclipseXml.IDEA_SETTINGS_POSTFIX);
            if (emlFile.isFile()) {
                files.add(emlFile);
            }
        }
        if (!files.isEmpty()) {
            final int resultCode = Messages.showYesNoCancelDialog(ApplicationNamesInfo.getInstance().getFullProductName() + " module files found:\n" + StringUtil.join(files, file -> file.getPath(), "\n") + ".\n Would you like to reuse them?", "Module Files Found", Messages.getQuestionIcon());
            if (resultCode != Messages.YES) {
                if (resultCode == Messages.NO) {
                    final LocalFileSystem localFileSystem = LocalFileSystem.getInstance();
                    for (File file : files) {
                        final VirtualFile virtualFile = localFileSystem.findFileByIoFile(file);
                        if (virtualFile != null) {
                            ApplicationManager.getApplication().runWriteAction(new ThrowableComputable<Void, IOException>() {

                                @Override
                                public Void compute() throws IOException {
                                    virtualFile.delete(this);
                                    return null;
                                }
                            });
                        } else {
                            FileUtil.delete(file);
                        }
                    }
                } else {
                    return result;
                }
            }
        }
        int idx = 0;
        for (String path : getParameters().projectsToConvert) {
            String modulesDirectory = getParameters().converterOptions.commonModulesDirectory;
            if (modulesDirectory == null) {
                modulesDirectory = path;
            }
            final Module module = moduleModel.newModule(modulesDirectory + "/" + EclipseProjectFinder.findProjectName(path) + ModuleManagerImpl.IML_EXTENSION, StdModuleTypes.JAVA.getId());
            result.add(module);
            final Set<String> natures = collectNatures(path);
            if (natures.size() > 0) {
                module2NatureNames.put(module, natures);
            }
            final ModifiableRootModel rootModel = ModuleRootManager.getInstance(module).getModifiableModel();
            rootModels[idx++] = rootModel;
            final File classpathFile = new File(path, EclipseXml.DOT_CLASSPATH_EXT);
            final EclipseClasspathReader classpathReader = new EclipseClasspathReader(path, project, getParameters().projectsToConvert, moduleNames);
            classpathReader.init(rootModel);
            if (classpathFile.exists()) {
                Element classpathElement = JDOMUtil.load(classpathFile);
                classpathReader.readClasspath(rootModel, unknownLibraries, unknownJdks, refsToModules, getParameters().converterOptions.testPattern, classpathElement);
            } else {
                EclipseClasspathReader.setOutputUrl(rootModel, path + "/bin");
            }
            ClasspathStorage.setStorageType(rootModel, getParameters().linkConverted ? JpsEclipseClasspathSerializer.CLASSPATH_STORAGE_ID : ClassPathStorageUtil.DEFAULT_STORAGE);
            if (model != null) {
                ApplicationManager.getApplication().runWriteAction(() -> rootModel.commit());
            }
        }
        if (model == null) {
            ApplicationManager.getApplication().runWriteAction(() -> ModifiableModelCommitter.multiCommit(rootModels, moduleModel));
        }
    } catch (Exception e) {
        LOG.error(e);
    }
    scheduleNaturesImporting(project, module2NatureNames);
    createEclipseLibrary(project, unknownLibraries, IdeaXml.ECLIPSE_LIBRARY);
    StringBuilder message = new StringBuilder();
    refsToModules.removeAll(getParameters().existingModuleNames);
    for (String path : getParameters().projectsToConvert) {
        final String projectName = EclipseProjectFinder.findProjectName(path);
        if (projectName != null) {
            refsToModules.remove(projectName);
            getParameters().existingModuleNames.add(projectName);
        }
    }
    if (!refsToModules.isEmpty()) {
        message.append("Unknown modules detected");
        for (String module : refsToModules) {
            message.append("\n").append(module);
        }
    }
    if (!unknownJdks.isEmpty()) {
        if (message.length() > 0) {
            message.append("\nand jdks");
        } else {
            message.append("Imported project refers to unknown jdks");
        }
        for (String unknownJdk : unknownJdks) {
            message.append("\n").append(unknownJdk);
        }
    }
    if (!unknownLibraries.isEmpty()) {
        final StringBuilder buf = new StringBuilder();
        buf.append("<html><body>");
        buf.append(EclipseBundle.message("eclipse.import.warning.undefinded.libraries"));
        for (String name : unknownLibraries) {
            buf.append("<br>").append(name);
        }
        if (model == null) {
            buf.append("<br><b>Please export Eclipse user libraries and import them now from resulted .userlibraries file</b>");
            buf.append("</body></html>");
            final FileChooserDescriptor descriptor = new FileChooserDescriptor(true, false, false, false, false, false) {

                @Override
                public boolean isFileSelectable(VirtualFile file) {
                    return super.isFileSelectable(file) && Comparing.strEqual(file.getExtension(), "userlibraries");
                }
            };
            descriptor.setDescription(buf.toString());
            descriptor.setTitle(getTitle());
            final VirtualFile selectedFile = FileChooser.chooseFile(descriptor, project, project.getBaseDir());
            if (selectedFile != null) {
                try {
                    EclipseUserLibrariesHelper.readProjectLibrariesContent(selectedFile, project, unknownLibraries);
                } catch (Exception e) {
                    LOG.error(e);
                }
            }
        }
    }
    if (message.length() > 0) {
        Messages.showErrorDialog(project, message.toString(), getTitle());
    }
    return result;
}

Example 4 with EclipseClasspathReader

use of org.jetbrains.idea.eclipse.conversion.EclipseClasspathReader in project intellij-community by JetBrains.

the class EclipseClasspathTest method setUpModule.

static Module setUpModule(final String path, @NotNull final Project project) throws Exception {
    final File classpathFile = new File(path, EclipseXml.DOT_CLASSPATH_EXT);
    String fileText = FileUtil.loadFile(classpathFile).replaceAll("\\$ROOT\\$", project.getBaseDir().getPath());
    if (!SystemInfo.isWindows) {
        fileText = fileText.replaceAll(EclipseXml.FILE_PROTOCOL + "/", EclipseXml.FILE_PROTOCOL);
    }
    final Element classpathElement = JDOMUtil.load(fileText);
    final Module module = WriteCommandAction.runWriteCommandAction(null, (Computable<Module>) () -> {
        String imlPath = path + "/" + EclipseProjectFinder.findProjectName(path) + ModuleManagerImpl.IML_EXTENSION;
        return ModuleManager.getInstance(project).newModule(imlPath, StdModuleTypes.JAVA.getId());
    });
    ModuleRootModificationUtil.updateModel(module, model -> {
        try {
            EclipseClasspathReader classpathReader = new EclipseClasspathReader(path, project, null);
            classpathReader.init(model);
            classpathReader.readClasspath(model, classpathElement);
            new EclipseClasspathStorageProvider().assertCompatible(model);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    });
    return module;
}