com.intellij.openapi.roots.DependencyScope Java Examples

private void updateAndroidModuleLibraryDependencies(Module flutterModule) {
  for (final Module module : ModuleManager.getInstance(getProject()).getModules()) {
    if (module != flutterModule) {
      if (null != FacetManager.getInstance(module).findFacet(AndroidFacet.ID, "Android")) {
        Object circularModules = CircularModuleDependenciesDetector.addingDependencyFormsCircularity(module, flutterModule);
        if (circularModules == null) {
          ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
          if (!rootManager.isDependsOn(flutterModule)) {
            JavaProjectModelModifier[] modifiers = JavaProjectModelModifier.EP_NAME.getExtensions(getProject());
            for (JavaProjectModelModifier modifier : modifiers) {
              if (modifier instanceof IdeaProjectModelModifier) {
                modifier.addModuleDependency(module, flutterModule, DependencyScope.COMPILE, false);
              }
            }
          }
        }
      }
    }
  }
}
 

private void updateAndroidModuleLibraryDependencies(Module flutterModule) {
  for (final Module module : ModuleManager.getInstance(getProject()).getModules()) {
    if (module != flutterModule) {
      if (null != FacetManager.getInstance(module).findFacet(AndroidFacet.ID, "Android")) {
        Object circularModules = CircularModuleDependenciesDetector.addingDependencyFormsCircularity(module, flutterModule);
        if (circularModules == null) {
          ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
          if (!rootManager.isDependsOn(flutterModule)) {
            JavaProjectModelModifier[] modifiers = JavaProjectModelModifier.EP_NAME.getExtensions(getProject());
            for (JavaProjectModelModifier modifier : modifiers) {
              if (modifier instanceof IdeaProjectModelModifier) {
                modifier.addModuleDependency(module, flutterModule, DependencyScope.COMPILE, false);
              }
            }
          }
        }
      }
    }
  }
}
 

protected void assertMergedModuleCompileModuleDepScope(String moduleName, String depName) {
  if (isGradleOlderThen_3_4() || isGradleNewerThen_4_5()) {
    assertModuleModuleDepScope(moduleName, depName, DependencyScope.COMPILE);
  }
  else {
    assertModuleModuleDepScope(moduleName, depName, DependencyScope.PROVIDED, DependencyScope.TEST, DependencyScope.RUNTIME);
  }
}
 

static Library addProjectLibrary(final Project project, final @javax.annotation.Nullable Module module, final String name, final DependencyScope scope, final VirtualFile[] jars) {
  return WriteAction.compute(() -> {
    final Library library = LibraryTablesRegistrar.getInstance().getLibraryTable(project).createLibrary(name);
    final Library.ModifiableModel libraryModel = library.getModifiableModel();
    for (VirtualFile jar : jars) {
      libraryModel.addRoot(jar, BinariesOrderRootType.getInstance());
    }
    libraryModel.commit();
    if (module != null) {
      ModuleRootModificationUtil.addDependency(module, library, scope, false);
    }
    return library;
  });
}
 

@Nullable
private static DependencyScope getDefaultScope(Library item) {
  for (LibraryDependencyScopeSuggester suggester : LibraryDependencyScopeSuggester.EP_NAME.getExtensions()) {
    DependencyScope scope = suggester.getDefaultDependencyScope(item);
    if (scope != null) {
      return scope;
    }
  }
  return null;
}
 

public UsageInModuleClasspath(@Nonnull StructureConfigurableContext context,
                              @Nonnull ModuleProjectStructureElement containingElement,
                              ProjectStructureElement sourceElement,
                              @Nullable DependencyScope scope) {
  myContext = context;
  myContainingElement = containingElement;
  myScope = scope;
  myModule = containingElement.getModule();
  mySourceElement = sourceElement;
}
 

private static void collectDependentModules(final Module module, Set<Module> modules, ArtifactEditorContext context) {
  if (!modules.add(module)) return;
  
  for (OrderEntry entry : context.getModulesProvider().getRootModel(module).getOrderEntries()) {
    if (entry instanceof ModuleOrderEntry) {
      final ModuleOrderEntry moduleEntry = (ModuleOrderEntry)entry;
      final Module dependency = moduleEntry.getModule();
      final DependencyScope scope = moduleEntry.getScope();
      if (dependency != null && scope.isForProductionRuntime()) {
        collectDependentModules(dependency, modules, context);
      }
    }
  }
}
 

@Override
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
  final ClasspathTableItem<?> item = myItems.get(rowIndex);
  if (columnIndex == EXPORT_COLUMN) {
    item.setExported(((Boolean)aValue).booleanValue());
  }
  else if (columnIndex == SCOPE_COLUMN && aValue instanceof DependencyScope) {
    item.setScope((DependencyScope) aValue);
  }
}
 

@Nonnull
@Override
public ModuleLibraryOrderEntryImpl loadOrderEntry(@Nonnull Element element, @Nonnull ModuleRootLayer moduleRootLayer) throws InvalidDataException {
  boolean exported = element.getAttributeValue(EXPORTED_ATTR) != null;
  DependencyScope scope = DependencyScope.readExternal(element);
  Library library = LibraryTableImplUtil.loadLibrary(element, (ModuleRootLayerImpl)moduleRootLayer);
  return new ModuleLibraryOrderEntryImpl(library, (ModuleRootLayerImpl)moduleRootLayer, exported, scope, false);
}
 

@Nonnull
@Override
public ModuleOrderEntryImpl loadOrderEntry(@Nonnull Element element, @Nonnull ModuleRootLayer moduleRootLayer) throws InvalidDataException {
  String moduleName = element.getAttributeValue(MODULE_NAME_ATTR);
  if (moduleName == null) {
    throw new InvalidDataException();
  }
  DependencyScope dependencyScope = DependencyScope.readExternal(element);
  boolean exported = element.getAttributeValue(EXPORTED_ATTR) != null;
  boolean productionOnTestDependency = element.getAttributeValue(PRODUCTION_ON_TEST_ATTRIBUTE) != null;
  return new ModuleOrderEntryImpl(moduleName, (ModuleRootLayerImpl)moduleRootLayer, dependencyScope, exported, productionOnTestDependency);
}
 

@Nonnull
@Override
public LibraryOrderEntryImpl loadOrderEntry(@Nonnull Element element, @Nonnull ModuleRootLayer moduleRootLayer) throws InvalidDataException {
  String name = element.getAttributeValue(NAME_ATTR);
  if (name == null) {
    throw new InvalidDataException();
  }

  String level = element.getAttributeValue(LEVEL_ATTR, LibraryTablesRegistrar.PROJECT_LEVEL);
  DependencyScope dependencyScope = DependencyScope.readExternal(element);
  boolean exported = element.getAttributeValue(EXPORTED_ATTR) != null;
  return new LibraryOrderEntryImpl(name, level, (ModuleRootLayerImpl)moduleRootLayer, dependencyScope, exported, false);
}
 

@Override
public Class getColumnClass(int column) {
  if (column == EXPORT_COLUMN) {
    return Boolean.class;
  }
  if (column == SCOPE_COLUMN) {
    return DependencyScope.class;
  }
  if (column == ITEM_COLUMN) {
    return ClasspathTableItem.class;
  }
  return super.getColumnClass(column);
}
 

protected void assertMergedModuleCompileLibDepScope(String moduleName, String depName) {
  if (isGradleOlderThen_3_4() || isGradleNewerThen_4_5()) {
    assertModuleLibDepScope(moduleName, depName, DependencyScope.COMPILE);
  }
  else {
    assertModuleLibDepScope(moduleName, depName, DependencyScope.PROVIDED, DependencyScope.TEST, DependencyScope.RUNTIME);
  }
}
 

@Nullable
@Override
public String getPresentableLocationInElement() {
  return myScope != null && myScope != DependencyScope.COMPILE ? "[" + StringUtil.decapitalize(myScope.getDisplayName()) + "]" : null;
}
 

@Nullable
public final DependencyScope getScope() {
  return myEntry instanceof ExportableOrderEntry ? ((ExportableOrderEntry)myEntry).getScope() : null;
}
 

public final void setScope(DependencyScope scope) {
  if (myEntry instanceof ExportableOrderEntry) {
    ((ExportableOrderEntry)myEntry).setScope(scope);
  }
}
 

protected Library addProjectLibrary(final @javax.annotation.Nullable Module module, final String name, final DependencyScope scope,
                                    final VirtualFile... jars) {
  return PackagingElementsTestCase.addProjectLibrary(myProject, module, name, scope, jars);
}
 

protected Library addProjectLibrary(final @Nullable Module module, final String name, final VirtualFile... jars) {
  return addProjectLibrary(module, name, DependencyScope.COMPILE, jars);
}
 

protected Library addProjectLibrary(final @Nullable Module module, final String name, final DependencyScope scope, final VirtualFile... jars) {
  return addProjectLibrary(myProject, module, name, scope, jars);
}
 

protected Library addProjectLibrary(final @javax.annotation.Nullable Module module, final String name, final VirtualFile... jars) {
  return addProjectLibrary(module, name, DependencyScope.COMPILE, jars);
}
 

public void setScope(DependencyScope scope) {
  myScope = scope;
}
 

@Override
@Nonnull
public DependencyScope getScope() {
  return myScope;
}
 

@Nonnull
DependencyScope getScope();
 

public static void addLibraryDependency(Module module, Library library) {
  final ModifiableRootModel modifiableModel = ModuleRootManager.getInstance(module).getModifiableModel();
  final DependencyScope defaultScope = LibraryDependencyScopeSuggester.getDefaultScope(library);
  modifiableModel.addLibraryEntry(library).setScope(defaultScope);
  modifiableModel.commit();
}
 

protected void assertModuleModuleDepScope(String moduleName, String depName, DependencyScope scope) {
  ModuleOrderEntry dep = getModuleModuleDep(moduleName, depName);
  assertEquals(scope, dep.getScope());
}
 

protected void assertModuleLibDepScope(String moduleName, String depName, DependencyScope scope) {
  LibraryOrderEntry dep = getModuleLibDep(moduleName, depName);
  assertEquals(scope, dep.getScope());
}