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);
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
public PsiElement resolve() {
  VirtualFile baseDir = myPsiFile.getVirtualFile().getParent();
  String relPath = FileUtil.toSystemIndependentName(myText + "/" + MavenConstants.POM_XML);
  VirtualFile file = baseDir.findFileByRelativePath(relPath);

  if (file == null) return null;

  return getPsiFile(file);
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
public static String calcRelativeModulePath(VirtualFile parentPom, VirtualFile modulePom) {
  String result = MavenDomUtil.calcRelativePath(parentPom.getParent(), modulePom);
  int to = result.length() - ("/" + MavenConstants.POM_XML).length();
  if (to < 0) {
    // todo IDEADEV-35440
    throw new RuntimeException("Filed to calculate relative path for:" +
                               "\nparentPom: " + parentPom + "(valid: " + parentPom.isValid() + ")" +
                               "\nmodulePom: " + modulePom + "(valid: " + modulePom.isValid() + ")" +
                               "\nequals:" + parentPom.equals(modulePom));
  }
  return result.substring(0, to);
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
@Override
protected Collection<String> getValues(@NotNull ConvertContext context, @NotNull MavenProject project) {
  Set<String> scopes = project.getSupportedDependencyScopes();

  boolean isDependencyManagement = context.getInvocationElement().getParentOfType(MavenDomDependencyManagement.class, false) != null;
  if (isDependencyManagement) scopes.add(MavenConstants.SCOPE_IMPORT);

  return scopes;
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
@Override
public PsiFile fromString(@Nullable @NonNls String s, ConvertContext context) {
  if (StringUtil.isEmptyOrSpaces(s)) return null;

  VirtualFile contextFile = context.getFile().getVirtualFile();
  if (contextFile == null) return null;

  VirtualFile f = contextFile.getParent().findFileByRelativePath(s);
  if (f == null) return null;

  if (f.isDirectory()) f = f.findChild(MavenConstants.POM_XML);
  if (f == null) return null;

  return context.getPsiManager().findFile(f);
}
 

import org.jetbrains.idea.maven.model.MavenConstants; //导入依赖的package包/类
private int getStandardGoalOrder(String goal) {
  if (standardGoalOrder == null) {
    standardGoalOrder = new THashMap<String, Integer>();
    int i = 0;
    for (String aGoal : MavenConstants.PHASES) {
      standardGoalOrder.put(aGoal, i++);
    }
  }
  Integer order = standardGoalOrder.get(goal);
  return order != null ? order.intValue() : standardGoalOrder.size();
}