Java MavenConstants类代码示例

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
public boolean value(final VirtualFile file) {
  String fileName = file.getName();

  // MavenDomUtil.isProjectFile(PsiFile)
  if (fileName.equals(MavenConstants.POM_XML) || fileName.endsWith(".pom") || fileName.equals(MavenConstants.SUPER_POM_XML)) {
    return true;
  }

  // MavenDomUtil.isProfilesFile(PsiFile)
  if (fileName.equals(MavenConstants.PROFILES_XML)) {
    return true;
  }

  if (fileName.equals(MavenConstants.SETTINGS_XML)) {
    return true;
  }

  return false;
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
public static List<LookupElement> getPhaseVariants(MavenProjectsManager manager) {
  Set<String> goals = new HashSet<String>();
  goals.addAll(MavenConstants.PHASES);

  for (MavenProject mavenProject : manager.getProjects()) {
    for (MavenPlugin plugin : mavenProject.getPlugins()) {
      MavenPluginInfo pluginInfo = MavenArtifactUtil.readPluginInfo(manager.getLocalRepository(), plugin.getMavenId());
      if (pluginInfo != null) {
        for (MavenPluginInfo.Mojo mojo : pluginInfo.getMojos()) {
          goals.add(mojo.getDisplayName());
        }
      }
    }
  }

  List<LookupElement> res = new ArrayList<LookupElement>(goals.size());
  for (String goal : goals) {
    res.add(LookupElementBuilder.create(goal).withIcon(MavenIcons.Phase));
  }

  return res;
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
public static boolean isSettingsFile(PsiFile file) {
  if (!(file instanceof XmlFile)) return false;

  String name = file.getName();
  if (!name.equals(MavenConstants.SETTINGS_XML)) return false;

  XmlTag rootTag = ((XmlFile)file).getRootTag();
  if (rootTag == null || !"settings".equals(rootTag.getName())) return false;

  String xmlns = rootTag.getAttributeValue("xmlns");
  if (xmlns != null) {
    return xmlns.contains("maven");
  }

  boolean hasTag = false;

  for (PsiElement e = rootTag.getFirstChild(); e != null; e = e.getNextSibling()) {
    if (e instanceof XmlTag) {
      if (SUBTAGS_IN_SETTINGS_FILE.contains(((XmlTag)e).getName())) return true;
      hasTag = true;
    }
  }

  return !hasTag;
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
@Override
public boolean isMavenModule(@NotNull final File file) {
    Validate.notNull(file);
    if (file.getAbsolutePath().contains(HybrisConstants.PLATFORM_MODULE_PREFIX)) {
        return false;
    }
    return new File(file, MavenConstants.POM_XML).isFile();
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
private VirtualFile createPomFile(final Project project, final MavenId projectId, final String muleVersion, final VirtualFile root)
{
    return new WriteCommandAction<VirtualFile>(project, "Create Mule Domain Project", PsiFile.EMPTY_ARRAY)
    {
        @Override
        protected void run(@NotNull Result<VirtualFile> result) throws Throwable
        {

            try
            {
                VirtualFile pomFile = root.findOrCreateChildData(this, MavenConstants.POM_XML);
                final Properties templateProps = new Properties();
                templateProps.setProperty("GROUP_ID", projectId.getGroupId());
                templateProps.setProperty("ARTIFACT_ID", projectId.getArtifactId());
                templateProps.setProperty("VERSION", projectId.getVersion());
                templateProps.setProperty("MULE_VERSION", muleVersion);
                final FileTemplateManager manager = FileTemplateManager.getInstance(project);
                final FileTemplate template = manager.getInternalTemplate(MuleFileTemplateDescriptorManager.MULE_DOMAIN_MAVEN_PROJECT);
                final Properties defaultProperties = manager.getDefaultProperties();
                defaultProperties.putAll(templateProps);
                final String text = template.getText(defaultProperties);
                VfsUtil.saveText(pomFile, text);
                result.setResult(pomFile);
            }
            catch (IOException e)
            {
                showError(project, e);
            }
        }
    }.execute().getResultObject();
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
private VirtualFile createModulePomFile(final Project project, final MavenId projectId, final VirtualFile root, final MavenId parentId)
{
    return new WriteCommandAction<VirtualFile>(project, "Create Mule Project", PsiFile.EMPTY_ARRAY)
    {
        @Override
        protected void run(@NotNull Result<VirtualFile> result) throws Throwable
        {
            try
            {
                VirtualFile pomFile = root.findOrCreateChildData(this, MavenConstants.POM_XML);
                final Properties templateProps = new Properties();
                templateProps.setProperty("GROUP_ID", parentId.getGroupId());
                templateProps.setProperty("ARTIFACT_ID", projectId.getArtifactId());
                templateProps.setProperty("PARENT_ID", parentId.getArtifactId());
                templateProps.setProperty("VERSION", parentId.getVersion());

                final FileTemplateManager manager = FileTemplateManager.getInstance(project);
                final FileTemplate template = manager.getInternalTemplate(MuleFileTemplateDescriptorManager.MULE_MAVEN_MODULE);
                final Properties defaultProperties = manager.getDefaultProperties();
                defaultProperties.putAll(templateProps);
                final String text = template.getText(defaultProperties);
                VfsUtil.saveText(pomFile, text);
                result.setResult(pomFile);
            }
            catch (IOException e)
            {
                showError(project, e);
            }
        }
    }.execute().getResultObject();
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
private VirtualFile createPomFile(final Project project, final MavenId projectId, final String muleVersion, final VirtualFile root)
{
    return new WriteCommandAction<VirtualFile>(project, "Create Mule Project", PsiFile.EMPTY_ARRAY)
    {
        @Override
        protected void run(@NotNull Result<VirtualFile> result) throws Throwable
        {

            try
            {
                VirtualFile pomFile = root.findOrCreateChildData(this, MavenConstants.POM_XML);
                final Properties templateProps = new Properties();
                templateProps.setProperty("GROUP_ID", projectId.getGroupId());
                templateProps.setProperty("ARTIFACT_ID", projectId.getArtifactId());
                templateProps.setProperty("VERSION", projectId.getVersion());
                templateProps.setProperty("MULE_VERSION", muleVersion);
                final FileTemplateManager manager = FileTemplateManager.getInstance(project);
                final FileTemplate template = manager.getInternalTemplate(MuleFileTemplateDescriptorManager.MULE_MAVEN_PROJECT);
                final Properties defaultProperties = manager.getDefaultProperties();
                defaultProperties.putAll(templateProps);
                final String text = template.getText(defaultProperties);
                VfsUtil.saveText(pomFile, text);
                result.setResult(pomFile);
            }
            catch (IOException e)
            {
                showError(project, e);
            }
        }
    }.execute().getResultObject();
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
private static boolean containsCompileDependency(Collection<MavenArtifact> dependencies) {
  for (MavenArtifact dependency : dependencies) {
    if (MavenConstants.SCOPE_COMPILE.equals(dependency.getScope())) {
      return true;
    }
  }
  return false;
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
private static void importExternalAndroidLibDependencies(Project project,
                                                         MavenRootModelAdapter rootModelAdapter,
                                                         IdeModifiableModelsProvider modelsProvider,
                                                         MavenProjectsTree mavenTree,
                                                         MavenProject mavenProject,
                                                         Map<MavenProject, String> mavenProject2ModuleName,
                                                         List<MavenProjectsProcessorTask> tasks) {
  final ModifiableRootModel rootModel = rootModelAdapter.getRootModel();
  removeUselessDependencies(rootModel, modelsProvider, mavenProject);

  for (MavenArtifact depArtifact : mavenProject.getDependencies()) {
    if (mavenTree.findProject(depArtifact) != null) {
      continue;
    }
    final String type = depArtifact.getType();

    if (AndroidMavenUtil.APKLIB_DEPENDENCY_AND_PACKAGING_TYPE.equals(type)) {
      final AndroidExternalApklibDependenciesManager.MavenDependencyInfo depInfo =
        AndroidExternalApklibDependenciesManager.MavenDependencyInfo.create(depArtifact);

      final String apklibModuleName = doImportExternalApklibDependency(
        project, modelsProvider, mavenTree, mavenProject,
        mavenProject2ModuleName, tasks, depInfo);

      if (ArrayUtil.find(rootModel.getDependencyModuleNames(), apklibModuleName) < 0) {
        final DependencyScope scope = getApklibModuleDependencyScope(depArtifact);

        if (scope != null) {
          addModuleDependency(modelsProvider, rootModel, apklibModuleName, scope);
        }
      }
    }
    else if (AndroidMavenUtil.AAR_DEPENDENCY_AND_PACKAGING_TYPE.equals(type) &&
             MavenConstants.SCOPE_COMPILE.equals(depArtifact.getScope())) {
      importExternalAarDependency(depArtifact, mavenProject, mavenTree, rootModelAdapter, modelsProvider, project, tasks);
    }
  }
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
@Nullable
private static DependencyScope getApklibModuleDependencyScope(@NotNull MavenArtifact apklibArtifact) {
  final String scope = apklibArtifact.getScope();

  if (MavenConstants.SCOPE_COMPILE.equals(scope)) {
    return DependencyScope.COMPILE;
  }
  else if (MavenConstants.SCOPE_PROVIDED.equals(scope)) {
    return DependencyScope.PROVIDED;
  }
  else if (MavenConstants.SCOPE_TEST.equals(scope)) {
    return DependencyScope.TEST;
  }
  return null;
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
@Override
public void resolve(final Project project,
                    MavenProject mavenProject,
                    NativeMavenProjectHolder nativeMavenProject,
                    MavenEmbedderWrapper embedder,
                    ResolveContext context)
  throws MavenProcessCanceledException {
  final AndroidExternalApklibDependenciesManager adm =
    AndroidExternalApklibDependenciesManager.getInstance(project);

  for (MavenArtifact depArtifact : mavenProject.getDependencies()) {
    final MavenProjectsManager mavenProjectsManager = MavenProjectsManager.getInstance(project);

    if (AndroidMavenUtil.APKLIB_DEPENDENCY_AND_PACKAGING_TYPE.equals(depArtifact.getType()) &&
        mavenProjectsManager.findProject(depArtifact) == null &&
        MavenConstants.SCOPE_COMPILE.equals(depArtifact.getScope())) {

      Set<MavenId> resolvedArtifacts = context.getUserData(RESOLVED_APKLIB_ARTIFACTS_KEY);

      if (resolvedArtifacts == null) {
        resolvedArtifacts = new HashSet<MavenId>();
        context.putUserData(RESOLVED_APKLIB_ARTIFACTS_KEY, resolvedArtifacts);
      }
      if (resolvedArtifacts.add(depArtifact.getMavenId())) {
        doResolveApklibArtifact(project, depArtifact, embedder, mavenProjectsManager, mavenProject.getName(), adm, context);
      }
    }
  }
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
@Nullable
public RESULT_TYPE process(@NotNull MavenGeneralSettings generalSettings,
                           @NotNull VirtualFile projectFile,
                           @Nullable MavenParentDesc parentDesc) {
  VirtualFile superPom = generalSettings.getEffectiveSuperPom();
  if (superPom == null || projectFile.equals(superPom)) return null;

  RESULT_TYPE result = null;

  if (parentDesc == null) {
    return processSuperParent(superPom);
  }

  VirtualFile parentFile = findManagedFile(parentDesc.getParentId());
  if (parentFile != null) {
    result = processManagedParent(parentFile);
  }

  if (result == null) {
    parentFile = projectFile.getParent().findFileByRelativePath(parentDesc.getParentRelativePath());
    if (parentFile != null && parentFile.isDirectory()) {
      parentFile = parentFile.findFileByRelativePath(MavenConstants.POM_XML);
    }
    if (parentFile != null) {
      result = processRelativeParent(parentFile);
    }
  }

  if (result == null) {
    File parentIoFile = MavenArtifactUtil.getArtifactFile(generalSettings.getEffectiveLocalRepository(),
                                                          parentDesc.getParentId(), "pom");
    parentFile = LocalFileSystem.getInstance().findFileByIoFile(parentIoFile);
    if (parentFile != null) {
      result = processRepositoryParent(parentFile);
    }
  }

  return result;
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
private static List<String> collectGoals(MavenProject project) {
  LinkedHashSet<String> result = new LinkedHashSet<String>(); // may contains similar plugins or somethig
  result.addAll(MavenConstants.PHASES);

  for (MavenPlugin each : project.getDeclaredPlugins()) {
    collectGoals(project.getLocalRepository(), each, result);
  }

  return new ArrayList<String>(result);
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
public void fixAfterLoadingFromOldFormat() {
  for (String profile : myEnabledProfilesForXmlSerializer) {
    myProfilesMap.put(profile, true);
  }
  myEnabledProfilesForXmlSerializer.clear();

  File workingDir = getWorkingDirFile();
  if (MavenConstants.POM_XML.equals(workingDir.getName())) {
    setWorkingDirPath(workingDir.getParent());
  }
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
public static boolean isProjectFile(PsiFile file) {
  if (!(file instanceof XmlFile)) return false;

  String name = file.getName();
  return name.equals(MavenConstants.POM_XML) ||
         name.endsWith(".pom") ||
         name.equals(MavenConstants.SUPER_POM_XML);
}