Java DependencyScope类代码示例

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
private void configureModuleDependencies(
    @NotNull final HybrisModuleDescriptor moduleDescriptor,
    @NotNull final Module module,
    @NotNull final Collection<Module> allModules,
    @NotNull final Set<HybrisModuleDescriptor> extModules,
    final @NotNull IdeModifiableModelsProvider modifiableModelsProvider
) {
    final ModifiableRootModel rootModel = modifiableModelsProvider.getModifiableRootModel(module);

    for (HybrisModuleDescriptor dependency : moduleDescriptor.getDependenciesTree()) {
        if (moduleDescriptor instanceof OotbHybrisModuleDescriptor) {
            if (extModules.contains(dependency)) {
                continue;
            }
        }

        Optional<Module> targetDependencyModule = findModuleByNameIgnoreCase(allModules, dependency.getName());
        final ModuleOrderEntry moduleOrderEntry = targetDependencyModule.isPresent()
            ? rootModel.addModuleOrderEntry(targetDependencyModule.get())
            : rootModel.addInvalidModuleEntry(dependency.getName());

        moduleOrderEntry.setExported(true);
        moduleOrderEntry.setScope(DependencyScope.COMPILE);
    }
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
public static boolean isExported( Module ijModule, Module child )
{
  for( OrderEntry entry : ModuleRootManager.getInstance( ijModule ).getOrderEntries() )
  {
    if( entry instanceof ModuleOrderEntry )
    {
      final ModuleOrderEntry moduleEntry = (ModuleOrderEntry)entry;
      final DependencyScope scope = moduleEntry.getScope();
      if( !scope.isForProductionCompile() && !scope.isForProductionRuntime() )
      {
        continue;
      }
      final Module module = moduleEntry.getModule();
      if( module != null && module == child )
      {
        return moduleEntry.isExported();
      }
    }
  }
  return false;
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
static Library addProjectLibrary(final Project project, final @Nullable Module module, final String name, final DependencyScope scope,
                                 final VirtualFile[] jars) {
  return new WriteAction<Library>() {
    @Override
    protected void run(@NotNull final Result<Library> result) {
      final Library library = LibraryTablesRegistrar.getInstance().getLibraryTable(project).createLibrary(name);
      final Library.ModifiableModel libraryModel = library.getModifiableModel();
      for (VirtualFile jar : jars) {
        libraryModel.addRoot(jar, OrderRootType.CLASSES);
      }
      libraryModel.commit();
      if (module != null) {
        ModuleRootModificationUtil.addDependency(module, library, scope, false);
      }
      result.setResult(library);
    }
  }.execute().getResultObject();
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
@NotNull
public static List<AndroidFacet> getAndroidLibraryDependencies(@NotNull Module module) {
  final List<AndroidFacet> depFacets = new ArrayList<AndroidFacet>();

  for (OrderEntry orderEntry : ModuleRootManager.getInstance(module).getOrderEntries()) {
    if (orderEntry instanceof ModuleOrderEntry) {
      final ModuleOrderEntry moduleOrderEntry = (ModuleOrderEntry)orderEntry;

      if (moduleOrderEntry.getScope() == DependencyScope.COMPILE) {
        final Module depModule = moduleOrderEntry.getModule();

        if (depModule != null) {
          final AndroidFacet depFacet = AndroidFacet.getInstance(depModule);

          if (depFacet != null && depFacet.isLibraryProject()) {
            depFacets.add(depFacet);
          }
        }
      }
    }
  }
  return depFacets;
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
private void updateDependency(@NotNull Module module,
                              @NotNull IdeModifiableModelsProvider modelsProvider,
                              @NotNull JavaModuleDependency dependency) {
  DependencySetupErrors setupErrors = getSetupErrors(module.getProject());

  String moduleName = dependency.getModuleName();
  Module found = null;
  for (Module m : modelsProvider.getModules()) {
    if (moduleName.equals(m.getName())) {
      found = m;
    }
  }

  final ModifiableRootModel moduleModel = modelsProvider.getModifiableRootModel(module);
  if (found != null) {
    ModuleOrderEntry orderEntry = moduleModel.addModuleOrderEntry(found);
    orderEntry.setExported(true);
    DependencyScope scope = parseScope(dependency.getScope());
    orderEntry.setScope(scope);
    return;
  }
  setupErrors.addMissingModule(moduleName, module.getName(), null);
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
/**
 * Add a library, along with any recursive library dependencies
 */
private static void addLibrary(@NotNull AndroidLibrary library,
                               @NotNull DependencySet dependencies,
                               @NotNull DependencyScope scope,
                               @NotNull Set<File> unique) {
  // We're using the library location as a unique handle rather than the AndroidLibrary instance itself, in case
  // the model just blindly manufactures library instances as it's following dependencies
  File folder = library.getFolder();
  if (unique.contains(folder)) {
    return;
  }
  unique.add(folder);

  LibraryDependency dependency = createLibraryDependency(library, scope);
  dependencies.add(dependency);

  for (AndroidLibrary dependentLibrary : library.getLibraryDependencies()) {
    addLibrary(dependentLibrary, dependencies, scope, unique);
  }
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
public void testExtractFromWithJar() {
  File jarFile = new File("~/repo/guava/guava-11.0.2.jar");

  myVariant.getMainArtifact().getDependencies().addJar(jarFile);
  myVariant.getInstrumentTestArtifact().getDependencies().addJar(jarFile);

  Collection<LibraryDependency> dependencies = Dependency.extractFrom(myIdeaAndroidProject).onLibraries();
  assertEquals(1, dependencies.size());

  LibraryDependency dependency = ContainerUtil.getFirstItem(dependencies);
  assertNotNull(dependency);
  assertEquals("guava-11.0.2", dependency.getName());
  // Make sure that is a "compile" dependency, even if specified as "test".
  assertEquals(DependencyScope.COMPILE, dependency.getScope());

  Collection<String> binaryPaths = dependency.getPaths(LibraryDependency.PathType.BINARY);
  assertEquals(1, binaryPaths.size());
  assertEquals(jarFile.getPath(), ContainerUtil.getFirstItem(binaryPaths));
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
public void testExtractFromWithLibraryAar() {
  String rootDirPath = myAndroidProject.getRootDir().getPath();
  File bundle = new File(rootDirPath, "bundle.aar");
  File libJar = new File(rootDirPath, FileUtil.join("bundle_aar", "library.jar"));
  AndroidLibraryStub library = new AndroidLibraryStub(bundle, libJar);

  myVariant.getMainArtifact().getDependencies().addLibrary(library);
  myVariant.getInstrumentTestArtifact().getDependencies().addLibrary(library);

  Collection<LibraryDependency> dependencies = Dependency.extractFrom(myIdeaAndroidProject).onLibraries();
  assertEquals(1, dependencies.size());

  LibraryDependency dependency = ContainerUtil.getFirstItem(dependencies);
  assertNotNull(dependency);
  assertEquals("bundle", dependency.getName());
  // Make sure that is a "compile" dependency, even if specified as "test".
  assertEquals(DependencyScope.COMPILE, dependency.getScope());

  Collection<String> binaryPaths = dependency.getPaths(LibraryDependency.PathType.BINARY);
  assertEquals(2, binaryPaths.size());
  assertTrue(binaryPaths.contains(libJar.getPath()));
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
public void testExtractFromWithProject() {
  String gradlePath = "abc:xyz:library";
  myVariant.getMainArtifact().getDependencies().addProject(gradlePath);
  myVariant.getInstrumentTestArtifact().getDependencies().addProject(gradlePath);
  Collection<ModuleDependency> dependencies = Dependency.extractFrom(myIdeaAndroidProject).onModules();
  assertEquals(1, dependencies.size());

  ModuleDependency dependency = ContainerUtil.getFirstItem(dependencies);
  assertNotNull(dependency);
  assertEquals(gradlePath, dependency.getGradlePath());
  // Make sure that is a "compile" dependency, even if specified as "test".
  assertEquals(DependencyScope.COMPILE, dependency.getScope());

  LibraryDependency backup = dependency.getBackupDependency();
  assertNull(backup);
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
public void testAddLibrary() {
  LibraryDependency dependency1 = new LibraryDependency("library-1.0.1.jar", DependencyScope.COMPILE);
  dependency1.addPath(LibraryDependency.PathType.BINARY, new File("file1.jar"));
  myDependencies.add(dependency1);

  LibraryDependency dependency2 = new LibraryDependency("library-1.0.1.jar", DependencyScope.TEST);
  dependency2.addPath(LibraryDependency.PathType.BINARY, new File("file2.jar"));
  myDependencies.add(dependency2);

  LibraryDependency dependency3 = new LibraryDependency("library-1.0.1.jar", DependencyScope.COMPILE);
  dependency3.addPath(LibraryDependency.PathType.BINARY, new File("file2.jar"));
  myDependencies.add(dependency3);

  Collection<LibraryDependency> all = myDependencies.onLibraries();
  assertEquals(2, all.size());
  assertTrue(all.contains(dependency1));
  assertTrue(all.contains(dependency3));

  assertFalse(dependency1.getName().equals(dependency3.getName()));
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
@Nullable
private static DependencyScope parseScope(@Nullable IdeaDependencyScope scope) {
  if (scope == null) {
    return null;
  }
  String scopeAsString = scope.getScope();
  if (scopeAsString == null) {
    return null;
  }
  for (DependencyScope dependencyScope : DependencyScope.values()) {
    if (scopeAsString.equalsIgnoreCase(dependencyScope.toString())) {
      return dependencyScope;
    }
  }
  return null;
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
@Nullable
@Override
public DependencyScope getDefaultDependencyScope(@NotNull Library library) {
  if (!(library instanceof LibraryEx)) {
    return null;
  }
  LibraryEx libraryEx = (LibraryEx)library;
  LibraryProperties libraryProperties = libraryEx.getProperties();
  if (libraryProperties == null || !(libraryProperties instanceof RepositoryLibraryProperties)) {
    return null;
  }
  RepositoryLibraryProperties repositoryLibraryProperties = (RepositoryLibraryProperties)libraryProperties;
  RepositoryLibraryDescription libraryDescription = RepositoryLibraryDescription.findDescription(repositoryLibraryProperties);

  return libraryDescription.getSuggestedScope();
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
@NotNull
public String getClasspath(@NotNull MavenProject mavenProject,
                           @Nullable Element manifestConfiguration) {
  StringBuilder classpath = new StringBuilder();
  String classpathPrefix = getClasspathPrefix(manifestConfiguration);
  for (MavenArtifact mavenArtifact : mavenProject.getDependencies()) {
    final DependencyScope scope = MavenModuleImporter.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();
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
public void testAddModuleDependency() throws IOException {
  createTwoModulesPom("m1", "m2");
  VirtualFile m1 = createModulePom("m1", "<groupId>test</groupId>" +
                                         "<artifactId>m1</artifactId>" +
                                         "<version>1</version>");
  createModulePom("m2", "<groupId>test</groupId>" +
                        "<artifactId>m2</artifactId>" +
                        "<version>1</version>");
  importProject();

  Promise<Void> result = getExtension().addModuleDependency(getModule("m1"), getModule("m2"), DependencyScope.COMPILE);
  assertNotNull(result);
  assertHasDependency(m1, "test", "m2");
  waitUntilImported(result);
  assertModuleModuleDeps("m1", "m2");
}
 

import com.intellij.openapi.roots.DependencyScope; //导入依赖的package包/类
static Library addProjectLibrary(final Project project, final @Nullable Module module, final String name, final DependencyScope scope,
                                 final VirtualFile[] jars) {
  return new WriteAction<Library>() {
    @Override
    protected void run(final Result<Library> result) {
      final Library library = LibraryTablesRegistrar.getInstance().getLibraryTable(project).createLibrary(name);
      final Library.ModifiableModel libraryModel = library.getModifiableModel();
      for (VirtualFile jar : jars) {
        libraryModel.addRoot(jar, OrderRootType.CLASSES);
      }
      libraryModel.commit();
      if (module != null) {
        ModuleRootModificationUtil.addDependency(module, library, scope, false);
      }
      result.setResult(library);
    }
  }.execute().getResultObject();
}