Java GradleConstants.SYSTEM_ID属性代码示例

@Override
public void setUp() throws Exception {
  super.setUp();

  String basePath = myProject.getBasePath();
  assertNotNull(basePath);
  File baseDir = new File(basePath);
  myAndroidProject = createBasicProject(baseDir, myProject.getName());

  Collection<Variant> variants = myAndroidProject.getVariants();
  Variant selectedVariant = getFirstItem(variants);
  assertNotNull(selectedVariant);
  myIdeaAndroidProject = new IdeaAndroidProject(GradleConstants.SYSTEM_ID, myAndroidProject.getName(), baseDir, myAndroidProject,
                                                selectedVariant.getName(), ARTIFACT_ANDROID_TEST);

  addContentEntry();
  myCustomizer = new ContentRootModuleCustomizer();
}
 

@Override
public void populateModuleExtraModels(@NotNull IdeaModule gradleModule, @NotNull DataNode<ModuleData> ideModule) {
  final BuildScriptClasspathModel buildScriptClasspathModel = resolverCtx.getExtraProject(gradleModule, BuildScriptClasspathModel.class);
  final List<BuildScriptClasspathData.ClasspathEntry> classpathEntries;
  if (buildScriptClasspathModel != null) {
    classpathEntries = ContainerUtil
      .map(buildScriptClasspathModel.getClasspath(), new Function<ClasspathEntryModel, BuildScriptClasspathData.ClasspathEntry>() {
        @Override
        public BuildScriptClasspathData.ClasspathEntry fun(ClasspathEntryModel model) {
          return new BuildScriptClasspathData.ClasspathEntry(model.getClasses(), model.getSources(), model.getJavadoc());
        }
      });
  }
  else {
    classpathEntries = ContainerUtil.emptyList();
  }
  BuildScriptClasspathData buildScriptClasspathData = new BuildScriptClasspathData(GradleConstants.SYSTEM_ID, classpathEntries);
  ideModule.createChild(BuildScriptClasspathData.KEY, buildScriptClasspathData);
}
 

@NotNull
private static DataNode<ProjectData> populateProject(@NotNull IdeaProject project, @NotNull String projectPath) {
  String projectDirPath = ExternalSystemApiUtil.toCanonicalPath(projectPath);

  ProjectData projectData = new ProjectData(GradleConstants.SYSTEM_ID, projectDirPath, projectPath);
  projectData.setName(project.getName());

  // Gradle API doesn't expose project compile output path yet.
  JavaProjectData javaProjectData = new JavaProjectData(GradleConstants.SYSTEM_ID, projectDirPath + "/out");
  javaProjectData.setJdkVersion(project.getJdkName());
  javaProjectData.setLanguageLevel(project.getLanguageLevel().getLevel());

  DataNode<ProjectData> result = new DataNode<ProjectData>(ProjectKeys.PROJECT, projectData, null);
  result.createChild(JavaProjectData.KEY, javaProjectData);
  return result;
}
 

@Override
public void setUp() throws Exception {
  super.setUp();
  File rootDirPath = new File(getProject().getBasePath());
  myDelegate = TestProjects.createFlavorsProject();
  myAndroidProject = new IdeaAndroidProject(GradleConstants.SYSTEM_ID, myDelegate.getName(), rootDirPath, myDelegate, "f1fa-debug",
                                            AndroidProject.ARTIFACT_ANDROID_TEST);
}
 

private void setUpApp() {
  File rootDirPath = new File(myProject.getBasePath());

  AndroidProjectStub project = new AndroidProjectStub("app");
  VariantStub variant = project.addVariant("debug");

  myApp = new IdeaAndroidProject(GradleConstants.SYSTEM_ID, myModule.getName(), rootDirPath, project, variant.getName(),
                                 AndroidProject.ARTIFACT_ANDROID_TEST);
}
 

private void setUpLib() {
  File moduleFilePath = new File(myLibModule.getModuleFilePath());

  AndroidProjectStub project = new AndroidProjectStub("lib");
  project.setIsLibrary(true);
  VariantStub variant = project.addVariant("debug");

  myLib = new IdeaAndroidProject(GradleConstants.SYSTEM_ID, myModule.getName(), moduleFilePath.getParentFile(), project,
                                 variant.getName(), AndroidProject.ARTIFACT_ANDROID_TEST);
}
 

private void setUpIdeaAndroidProject() {
  myAndroidProject = TestProjects.createBasicProject();
  VariantStub variant = myAndroidProject.getFirstVariant();
  assertNotNull(variant);
  IdeaAndroidProject ideaAndroidProject = new IdeaAndroidProject(GradleConstants.SYSTEM_ID, myAndroidProject.getName(),
                                                                 myAndroidProject.getRootDir(), myAndroidProject, variant.getName(),
                                                                 AndroidProject.ARTIFACT_UNIT_TEST);
  myFacet.setIdeaAndroidProject(ideaAndroidProject);
}
 

@NotNull
private static DataNode<ModuleData> createModule(@NotNull String name, boolean isGradleProject) {
  String path = "~/project/" + name;
  ModuleData data = new ModuleData(name, GradleConstants.SYSTEM_ID, StdModuleTypes.JAVA.getId(), name, path, path);
  DataNode<ModuleData> module = new DataNode<ModuleData>(MODULE, data, null);
  if (isGradleProject) {
    List<String> taskNames = Collections.emptyList();
    module.createChild(IDE_GRADLE_PROJECT, new IdeaGradleProject("app", taskNames, ":" + name, null, null));
  }
  return module;
}
 

@NotNull
private static ScalaModelData create(@NotNull ScalaModel scalaModel) {
  ScalaModelData scalaModelData = new ScalaModelData(GradleConstants.SYSTEM_ID);
  scalaModelData.setZincClasspath(scalaModel.getZincClasspath());
  scalaModelData.setScalaClasspath(scalaModel.getScalaClasspath());
  scalaModelData.setScalaCompileOptions(create((scalaModel.getScalaCompileOptions())));
  scalaModelData.setSourceCompatibility(scalaModel.getSourceCompatibility());
  scalaModelData.setTargetCompatibility(scalaModel.getTargetCompatibility());
  return scalaModelData;
}
 

@NotNull
@Override
public ModuleData createModule(@NotNull IdeaModule gradleModule, @NotNull ProjectData projectData) {
  final String moduleName = gradleModule.getName();
  if (moduleName == null) {
    throw new IllegalStateException("Module with undefined name detected: " + gradleModule);
  }

  final String moduleConfigPath = getModuleConfigPath(gradleModule, projectData.getLinkedExternalProjectPath());

  if (ExternalSystemDebugEnvironment.DEBUG_ORPHAN_MODULES_PROCESSING) {
    LOG.info(String.format(
      "Creating module data ('%s') with the external config path: '%s'", gradleModule.getGradleProject().getPath(), moduleConfigPath
    ));
  }

  String gradlePath = gradleModule.getGradleProject().getPath();
  String moduleId = StringUtil.isEmpty(gradlePath) || ":".equals(gradlePath) ? moduleName : gradlePath;
  ModuleData moduleData =
    new ModuleData(moduleId, GradleConstants.SYSTEM_ID, StdModuleTypes.JAVA.getId(), moduleName, moduleConfigPath, moduleConfigPath);

  final ModuleExtendedModel moduleExtendedModel = resolverCtx.getExtraProject(gradleModule, ModuleExtendedModel.class);
  if (moduleExtendedModel != null) {
    moduleData.setGroup(moduleExtendedModel.getGroup());
    moduleData.setVersion(moduleExtendedModel.getVersion());
    moduleData.setArtifacts(moduleExtendedModel.getArtifacts());
  }

  ExternalProject externalProject = resolverCtx.getExtraProject(gradleModule, ExternalProject.class);
  if (externalProject != null) {
    moduleData.setDescription(externalProject.getDescription());
  }
  return moduleData;
}
 

@NotNull
private static Map<String, Pair<DataNode<ModuleData>, IdeaModule>> createModules(
  @NotNull IdeaProject gradleProject,
  @NotNull DataNode<ProjectData> ideProject) throws IllegalStateException
{

  DomainObjectSet<? extends IdeaModule> gradleModules = gradleProject.getModules();
  if (gradleModules == null || gradleModules.isEmpty()) {
    throw new IllegalStateException("No modules found for the target project: " + gradleProject);
  }
  Map<String, Pair<DataNode<ModuleData>, IdeaModule>> result = ContainerUtilRt.newHashMap();
  for (IdeaModule gradleModule : gradleModules) {
    if (gradleModule == null) {
      continue;
    }
    String moduleName = gradleModule.getName();
    if (moduleName == null) {
      throw new IllegalStateException("Module with undefined name detected: " + gradleModule);
    }
    ProjectData projectData = ideProject.getData();
    String moduleConfigPath
      = GradleUtil.getConfigPath(gradleModule.getGradleProject(), ideProject.getData().getLinkedExternalProjectPath());
    ModuleData ideModule = new ModuleData(GradleConstants.SYSTEM_ID,
                                          StdModuleTypes.JAVA.getId(),
                                          moduleName,
                                          projectData.getIdeProjectFileDirectoryPath(),
                                          moduleConfigPath);
    Pair<DataNode<ModuleData>, IdeaModule> previouslyParsedModule = result.get(moduleName);
    if (previouslyParsedModule != null) {
      throw new IllegalStateException(
        String.format("Modules with duplicate name (%s) detected: '%s' and '%s'", moduleName, ideModule, previouslyParsedModule)
      );
    }
    DataNode<ModuleData> moduleDataNode = ideProject.createChild(ProjectKeys.MODULE, ideModule);
    result.put(moduleName, new Pair<DataNode<ModuleData>, IdeaModule>(moduleDataNode, gradleModule));
  }
  return result;
}
 

/**
 * Populates {@link ProjectKeys#CONTENT_ROOT) content roots} of the given ide module on the basis of the information
 * contained at the given gradle module.
 *
 * @param gradleModule    holder of the module information received from the gradle tooling api
 * @param ideModule       corresponding module from intellij gradle plugin domain
 * @throws IllegalArgumentException   if given gradle module contains invalid data
 */
private static void populateContentRoots(@NotNull IdeaModule gradleModule, @NotNull DataNode<ModuleData> ideModule)
  throws IllegalArgumentException
{
  DomainObjectSet<? extends IdeaContentRoot> contentRoots = gradleModule.getContentRoots();
  if (contentRoots == null) {
    return;
  }
  for (IdeaContentRoot gradleContentRoot : contentRoots) {
    if (gradleContentRoot == null) {
      continue;
    }
    File rootDirectory = gradleContentRoot.getRootDirectory();
    if (rootDirectory == null) {
      continue;
    }
    ContentRootData ideContentRoot = new ContentRootData(GradleConstants.SYSTEM_ID, rootDirectory.getAbsolutePath());
    ideModule.getData().setModuleFileDirectoryPath(ideContentRoot.getRootPath());
    populateContentRoot(ideContentRoot, ExternalSystemSourceType.SOURCE, gradleContentRoot.getSourceDirectories());
    populateContentRoot(ideContentRoot, ExternalSystemSourceType.TEST, gradleContentRoot.getTestDirectories());
    Set<File> excluded = gradleContentRoot.getExcludeDirectories();
    if (excluded != null) {
      for (File file : excluded) {
        ideContentRoot.storePath(ExternalSystemSourceType.EXCLUDED, file.getAbsolutePath());
      }
    }
    ideModule.createChild(ProjectKeys.CONTENT_ROOT, ideContentRoot);
  }
}
 

public GradleExternalTaskConfigurationType() {
  super(GradleConstants.SYSTEM_ID);
}
 

@NotNull
private static DataNode<ModuleData> createModule(@NotNull String name) {
  String path = "~/project/" + name;
  ModuleData data = new ModuleData(name, GradleConstants.SYSTEM_ID, StdModuleTypes.JAVA.getId(), name, path, path);
  return new DataNode<ModuleData>(MODULE, data, null);
}
 

public ImportFromGradleControl() {
  super(GradleConstants.SYSTEM_ID, new GradleSettings(ProjectManager.getInstance().getDefaultProject()), getInitialProjectSettings(), true);
}