public void unConfigureModule(@NotNull ModifiableRootModel model) {
    for (OrderEntry orderEntry : model.getOrderEntries()) {
      if (orderEntry instanceof LibraryOrderEntry) {
        LibraryOrderEntry libraryOrderEntry = (LibraryOrderEntry) orderEntry;

        Library library = libraryOrderEntry.getLibrary();
        if (library != null) {
          String libraryName = library.getName();
          if (libraryName != null && libraryName.equals(this.libraryName)) {

            // Dispose attached roots
            Library.ModifiableModel modifiableModel = library.getModifiableModel();
            for (String rootUrl : library.getRootProvider().getUrls(OrderRootType.CLASSES)) {
              modifiableModel.removeRoot(rootUrl, OrderRootType.CLASSES);
            }
            modifiableModel.commit();

            model.getModuleLibraryTable().removeLibrary(library);

            break;
          }
        }
      }
    }
  }
 @Override
 protected void addJUnitDefaultLib(
     ModifiableRootModel rootModel, String junitName, ExpandMacroToPathMap macroMap) {
   final Library library =
       rootModel.getModuleLibraryTable().getModifiableModel().createLibrary(junitName);
   final Library.ModifiableModel modifiableModel = library.getModifiableModel();
   modifiableModel.addRoot(getJunitClsUrl(junitName.contains("4")), OrderRootType.CLASSES);
   modifiableModel.commit();
 }
  protected void createLibrary(ModifiableRootModel model, final String name, final String path) {
    final Library.ModifiableModel modifiableModel =
        model.getModuleLibraryTable().createLibrary(name).getModifiableModel();
    final VirtualFile home =
        LocalFileSystem.getInstance().refreshAndFindFileByPath(PathManager.getHomePath() + path);

    modifiableModel.addRoot(home, OrderRootType.CLASSES);
    modifiableModel.commit();
  }
 @Override
 public void configureModule(
     @NotNull Module module,
     @NotNull ModifiableRootModel model,
     @Nullable ContentEntry contentEntry) {
   Library library = model.getModuleLibraryTable().createLibrary(libraryName);
   Library.ModifiableModel modifiableModel = library.getModifiableModel();
   modifiableModel.addRoot(VfsUtil.getUrlForLibraryRoot(libraryFile), libraryRootType);
   modifiableModel.commit();
 }
 protected Module createModule(final String name) {
   final Module module = super.createModule(name);
   final ModifiableRootModel model = ModuleRootManager.getInstance(module).getModifiableModel();
   final LibraryTable.ModifiableModel modifiableModel =
       model.getModuleLibraryTable().getModifiableModel();
   final Library library = modifiableModel.createLibrary("junit");
   final Library.ModifiableModel libModel = library.getModifiableModel();
   libModel.addRoot(
       VfsUtil.getUrlForLibraryRoot(new File(PathUtil.getJarPathForClass(Before.class))),
       OrderRootType.CLASSES);
   libModel.commit();
   model.commit();
   return module;
 }
  @Override
  protected void addModuleLibrary(
      ModifiableRootModel rootModel,
      Element element,
      boolean exported,
      String libName,
      String url,
      String srcUrl,
      ExpandMacroToPathMap macroMap) {
    final Library library =
        rootModel.getModuleLibraryTable().getModifiableModel().createLibrary(libName);
    final Library.ModifiableModel modifiableModel = library.getModifiableModel();
    modifiableModel.addRoot(url, OrderRootType.CLASSES);
    if (srcUrl != null) {
      modifiableModel.addRoot(srcUrl, OrderRootType.SOURCES);
    }
    EJavadocUtil.appendJavadocRoots(element, rootModel, myCurrentRoots, modifiableModel);
    modifiableModel.commit();

    setLibraryEntryExported(rootModel, exported, library);
  }
Пример #7
0
 public Library createOrGetXtendJavaLibrary(
     final ModifiableRootModel rootModel, final Module module) {
   LibraryTablesRegistrar _instance = LibraryTablesRegistrar.getInstance();
   Project _project = module.getProject();
   LibraryTable _libraryTable = _instance.getLibraryTable(_project);
   Library[] _libraries = _libraryTable.getLibraries();
   LibraryTablesRegistrar _instance_1 = LibraryTablesRegistrar.getInstance();
   LibraryTable _libraryTable_1 = _instance_1.getLibraryTable();
   Library[] _libraries_1 = _libraryTable_1.getLibraries();
   final Iterable<Library> libraryTable =
       Iterables.<Library>concat(
           ((Iterable<? extends Library>) Conversions.doWrapArray(_libraries)),
           ((Iterable<? extends Library>) Conversions.doWrapArray(_libraries_1)));
   final Function1<Library, Boolean> _function =
       new Function1<Library, Boolean>() {
         @Override
         public Boolean apply(final Library it) {
           String _name = it.getName();
           boolean _startsWith = false;
           if (_name != null) {
             _startsWith = _name.startsWith(XtendLibraryDescription.XTEND_LIBRARY_NAME);
           }
           return Boolean.valueOf(_startsWith);
         }
       };
   final Iterable<Library> xtendLibs = IterableExtensions.<Library>filter(libraryTable, _function);
   boolean _isEmpty = IterableExtensions.isEmpty(xtendLibs);
   boolean _not = (!_isEmpty);
   if (_not) {
     final Function1<Library, Boolean> _function_1 =
         new Function1<Library, Boolean>() {
           @Override
           public Boolean apply(final Library it) {
             String _name = it.getName();
             return Boolean.valueOf(
                 Objects.equal(_name, XtendLibraryDescription.XTEND_LIBRARY_NAME));
           }
         };
     boolean _exists = IterableExtensions.<Library>exists(xtendLibs, _function_1);
     if (_exists) {
       final Function1<Library, Boolean> _function_2 =
           new Function1<Library, Boolean>() {
             @Override
             public Boolean apply(final Library it) {
               String _name = it.getName();
               return Boolean.valueOf(
                   Objects.equal(_name, XtendLibraryDescription.XTEND_LIBRARY_NAME));
             }
           };
       return IterableExtensions.<Library>findFirst(xtendLibs, _function_2);
     } else {
       return IterableExtensions.<Library>head(xtendLibs);
     }
   } else {
     final NewLibraryConfiguration libDescr = this.xtendLibDescr.createLibraryDescription();
     LibraryTable _moduleLibraryTable = rootModel.getModuleLibraryTable();
     final LibraryTable.ModifiableModel model = _moduleLibraryTable.getModifiableModel();
     String _defaultLibraryName = libDescr.getDefaultLibraryName();
     final Library createdLib = model.createLibrary(_defaultLibraryName);
     final Library.ModifiableModel libModel = createdLib.getModifiableModel();
     HashMap<OrderRootType, List<String>> _libraryRoots = this.xtendLibDescr.libraryRoots();
     final Procedure2<OrderRootType, List<String>> _function_3 =
         new Procedure2<OrderRootType, List<String>>() {
           @Override
           public void apply(final OrderRootType type, final List<String> roots) {
             final Procedure1<String> _function =
                 new Procedure1<String>() {
                   @Override
                   public void apply(final String it) {
                     libModel.addRoot(it, type);
                   }
                 };
             IterableExtensions.<String>forEach(roots, _function);
           }
         };
     MapExtensions.<OrderRootType, List<String>>forEach(_libraryRoots, _function_3);
     libModel.commit();
     model.commit();
     return createdLib;
   }
 }
  @Override
  protected Map<OrderEntry, OrderAware> importData(
      @NotNull final Collection<DataNode<LibraryDependencyData>> nodesToImport,
      @NotNull final Module module,
      @NotNull final IdeModifiableModelsProvider modelsProvider) {
    // The general idea is to import all external project library dependencies and module libraries
    // which don't present at the
    // ide side yet and remove all project library dependencies and module libraries which present
    // at the ide but not at
    // the given collection.
    // The trick is that we should perform module settings modification inside try/finally block
    // against target root model.
    // That means that we need to prepare all necessary data, obtain a model and modify it as
    // necessary.
    final Map<Set<String> /* library paths */, LibraryDependencyData> moduleLibrariesToImport =
        ContainerUtilRt.newHashMap();
    final Map<String /* library name + scope */, LibraryDependencyData> projectLibrariesToImport =
        ContainerUtilRt.newHashMap();
    final Set<LibraryDependencyData> toImport = ContainerUtilRt.newLinkedHashSet();
    final Map<OrderEntry, OrderAware> orderEntryDataMap = ContainerUtil.newLinkedHashMap();

    boolean hasUnresolved = false;
    for (DataNode<LibraryDependencyData> dependencyNode : nodesToImport) {
      LibraryDependencyData dependencyData = dependencyNode.getData();
      LibraryData libraryData = dependencyData.getTarget();
      hasUnresolved |= libraryData.isUnresolved();
      switch (dependencyData.getLevel()) {
        case MODULE:
          Set<String> paths = ContainerUtilRt.newHashSet();
          for (String path : libraryData.getPaths(LibraryPathType.BINARY)) {
            paths.add(
                ExternalSystemApiUtil.toCanonicalPath(path) + dependencyData.getScope().name());
          }
          moduleLibrariesToImport.put(paths, dependencyData);
          toImport.add(dependencyData);
          break;
        case PROJECT:
          projectLibrariesToImport.put(
              libraryData.getInternalName() + dependencyData.getScope().name(), dependencyData);
          toImport.add(dependencyData);
      }
    }

    final boolean finalHasUnresolved = hasUnresolved;

    final ModifiableRootModel modifiableRootModel = modelsProvider.getModifiableRootModel(module);
    LibraryTable moduleLibraryTable = modifiableRootModel.getModuleLibraryTable();
    syncExistingAndRemoveObsolete(
        modelsProvider,
        moduleLibrariesToImport,
        projectLibrariesToImport,
        toImport,
        orderEntryDataMap,
        modifiableRootModel,
        finalHasUnresolved);
    // Import missing library dependencies.
    if (!toImport.isEmpty()) {
      importMissing(
          modelsProvider,
          toImport,
          orderEntryDataMap,
          modifiableRootModel,
          moduleLibraryTable,
          module);
    }
    return orderEntryDataMap;
  }
  public void testModuleLibraries() throws Exception {
    File moduleFile = new File(getTestRoot(), "test.iml");
    Module module = createModule(moduleFile);
    final ModuleRootManagerImpl moduleRootManager =
        (ModuleRootManagerImpl) ModuleRootManager.getInstance(module);
    final ModifiableRootModel rootModel = moduleRootManager.getModifiableModel();
    final LibraryTable moduleLibraryTable = rootModel.getModuleLibraryTable();

    final Library unnamedLibrary = moduleLibraryTable.createLibrary();
    final File unnamedLibClasses = new File(getTestRoot(), "unnamedLibClasses");
    final VirtualFile unnamedLibClassesRoot =
        LocalFileSystem.getInstance().findFileByIoFile(unnamedLibClasses);
    final Library.ModifiableModel libraryModifyableModel = unnamedLibrary.getModifiableModel();
    libraryModifyableModel.addRoot(unnamedLibClassesRoot.getUrl(), OrderRootType.CLASSES);

    final Library namedLibrary = moduleLibraryTable.createLibrary("namedLibrary");
    final File namedLibClasses = new File(getTestRoot(), "namedLibClasses");
    final VirtualFile namedLibClassesRoot =
        LocalFileSystem.getInstance().findFileByIoFile(namedLibClasses);
    final Library.ModifiableModel namedLibraryModel = namedLibrary.getModifiableModel();
    namedLibraryModel.addRoot(namedLibClassesRoot.getUrl(), OrderRootType.CLASSES);

    ApplicationManager.getApplication()
        .runWriteAction(
            new Runnable() {
              @Override
              public void run() {
                libraryModifyableModel.commit();
                namedLibraryModel.commit();
              }
            });

    final Iterator libraryIterator = moduleLibraryTable.getLibraryIterator();
    assertEquals(libraryIterator.next(), unnamedLibrary);
    assertEquals(libraryIterator.next(), namedLibrary);

    ApplicationManager.getApplication()
        .runWriteAction(
            new Runnable() {
              @Override
              public void run() {
                rootModel.commit();
              }
            });
    final Element element = new Element("root");
    moduleRootManager.getState().writeExternal(element);
    assertElementEquals(
        element,
        "<root inherit-compiler-output=\"true\">"
            + "<exclude-output />"
            + "<orderEntry type=\"sourceFolder\" forTests=\"false\" />"
            + "<orderEntry type=\"module-library\">"
            + "<library>"
            + "<CLASSES><root url=\"file://$MODULE_DIR$/unnamedLibClasses\" /></CLASSES>"
            + "<JAVADOC />"
            + "<SOURCES />"
            + "</library>"
            + "</orderEntry>"
            + "<orderEntry type=\"module-library\">"
            + "<library name=\"namedLibrary\">"
            + "<CLASSES><root url=\"file://$MODULE_DIR$/namedLibClasses\" /></CLASSES>"
            + "<JAVADOC />"
            + "<SOURCES />"
            + "</library>"
            + "</orderEntry>"
            + "</root>",
        module);
  }