Java EnforcerRuleHelper.getLog方法代码示例

import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper; //导入方法依赖的package包/类
private void detectUnmanagedModules(EnforcerRuleHelper helper, MavenProject project) throws ExpressionEvaluationException, EnforcerRuleException {
    Log log = helper.getLog();
    MavenSession session = RuleHelper.getSession(helper);
    List<MavenProject> projects = session.getProjects();
    ImmutableListMultimap managedDependencies = RuleHelper.getManagedDependenciesAsMap(project);

    for (MavenProject mavenProject : projects) {
        if (ruleIsDefinedInProjectOrNotModuleParent(mavenProject, log)) {
            continue;
        }
        String projectIdentifier = RuleHelper.getProjectIdentifier(mavenProject);
        if (!managedDependencies.containsKey(projectIdentifier)) {
            logHeader(log, "manage all modules");
            log.warn("unmanaged project found: " + projectIdentifier);
            failureDetected = true;
        }
    }

    if (failureDetected) {
        throw new EnforcerRuleException("Failing because of unmanaged projects");
    }
}
 

import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper; //导入方法依赖的package包/类
public void execute(EnforcerRuleHelper helper) throws EnforcerRuleException {
    Log log = helper.getLog();

    List<Pattern> excludedPatterns = new ArrayList<Pattern>(excludes.size());
    for (String exclude : excludes) {
        excludedPatterns.add(Pattern.compile(exclude));
    }

    try {
        MavenProject project = (MavenProject) helper.evaluate("${project}");
        List<Artifact> artifactList = project.getAttachedArtifacts();
        for (Artifact artifact : artifactList) {
            String artifactFileName = artifact.getFile().getName();
            log.debug("evaluating artifact [" + artifactFileName + "]");
            for (Pattern pattern : excludedPatterns) {
                if (pattern.matcher(artifactFileName).matches()) {
                    throw new EnforcerRuleException("found banned attached artifact: artifact [" + artifactFileName + "] matched exclude pattern [" + pattern.toString() + "]");
                }
            }
        }

    } catch (ExpressionEvaluationException e) {
        throw new EnforcerRuleException("Unable to lookup expression", e);
    }

}
 

import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper; //导入方法依赖的package包/类
public void execute(EnforcerRuleHelper helper) throws EnforcerRuleException {
    Log log = helper.getLog();

    try {
        // get the various expressions out of the helper.
        MavenProject project = (MavenProject) helper.evaluate("${project}");
        // MavenSession session = (MavenSession) helper.evaluate("${session}");
        // String target = (String) helper.evaluate("${project.build.directory}");
        // String artifactId = (String) helper.evaluate("${project.artifactId}");

        // ArtifactResolver resolver = (ArtifactResolver) helper.getComponent(ArtifactResolver.class);
        // RuntimeInfo rti = (RuntimeInfo) helper.getComponent(RuntimeInfo.class);
        List compileSourceRoots = project.getCompileSourceRoots();

        for (Object compileSourceRoot : compileSourceRoots) {
            String path = (String) compileSourceRoot;
            applyForJavaSourcesInRoot(path, log);
        }
    } catch (ExpressionEvaluationException e) {
        throw new EnforcerRuleException("Unable to lookup an expression " + e.getLocalizedMessage(), e);
    }
}
 

import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper; //导入方法依赖的package包/类
public void execute(EnforcerRuleHelper helper) throws EnforcerRuleException {
    Log log = helper.getLog();

    try {
        MavenProject currentProject = RuleHelper.getSession(helper).getCurrentProject();

        checkForSubmoduleDependencyManagement(currentProject, log);

        if (failureDetected) {
            throw new EnforcerRuleException("Failing because of forbidden dependency management in sub modules");
        }
    } catch (ExpressionEvaluationException e) {
        throw new EnforcerRuleException("Unable to lookup an expression " + e.getLocalizedMessage(), e);
    }
}
 

import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper; //导入方法依赖的package包/类
public void execute(EnforcerRuleHelper helper) throws EnforcerRuleException {
    Log log = helper.getLog();

    try {
        MavenProject project = getProject(helper);

        checkPluginManagementDiffs(project, log);

        if (failureDetected) {
            throw new EnforcerRuleException("Failing because of overridden managed plugins");
        }
    } catch (ExpressionEvaluationException e) {
        throw new EnforcerRuleException("Unable to lookup an expression " + e.getLocalizedMessage(), e);
    }
}
 

import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper; //导入方法依赖的package包/类
/**
 * Execute the rule.
 *
 * @param helper the helper
 * @throws EnforcerRuleException the enforcer rule exception
 */
public void execute( EnforcerRuleHelper helper ) throws EnforcerRuleException
{
    final Log log = helper.getLog();

    Object propValue = getPropertyValue( helper );
    checkPropValueNotBlank( propValue );

    final MavenProject project = getMavenProject( helper );
    log.debug( getRuleName() + ": checking property '" + property + "' for project " + project );

    final MavenProject parent = findDefiningParent( project );

    // fail fast if the defining parent could not be found due to a bug in the rule
    if ( parent == null )
    {
        throw new IllegalStateException( "Failed to find parent POM which defines the current rule" );
    }

    if ( project.equals( parent ) )
    {
        log.debug( getRuleName() + ": skip for property '" + property + "' as " + project + " defines rule." );
    }
    else
    {
        log.debug( "Check configuration defined in " + parent );
        if ( regex == null )
        {
            checkAgainstParentValue( project, parent, helper, propValue );
        }
        else
        {
            checkAgainstRegex( propValue );
        }
    }
}
 

import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper; //导入方法依赖的package包/类
public void execute( EnforcerRuleHelper helper )
    throws EnforcerRuleException
{
    try
    {
        if ( StringUtils.isBlank( encoding ) )
        {
            encoding = (String) helper.evaluate( "${project.build.sourceEncoding}" );
        }
        Log log = helper.getLog();
        if ( encoding.equals( StandardCharsets.US_ASCII.name() ) )
        {
            log.warn( "Encoding US-ASCII is hard to detect. Use UTF-8 or ISO-8859-1" );
        }
        String basedir = (String) helper.evaluate( "${basedir}" );
        DirectoryScanner ds = new DirectoryScanner();
        ds.setBasedir( basedir );
        if ( StringUtils.isNotBlank( includes ) )
        {
            ds.setIncludes( includes.split( "[,\\|]" ) );
        }
        if ( StringUtils.isNotBlank( excludes ) )
        {
            ds.setExcludes( excludes.split( "[,\\|]" ) );
        }
        if ( useDefaultExcludes )
        {
            ds.addDefaultExcludes();
        }
        ds.scan();
        StringBuilder filesInMsg = new StringBuilder();
        for ( String file : ds.getIncludedFiles() )
        {
            String fileEncoding = getEncoding( encoding, new File( basedir, file ), log );
            if ( log.isDebugEnabled() )
            {
                log.debug( file + "==>" + fileEncoding );
            }
            if ( fileEncoding != null && !fileEncoding.equals( encoding ) )
            {
                filesInMsg.append( file );
                filesInMsg.append( "==>" );
                filesInMsg.append( fileEncoding );
                filesInMsg.append( "\n" );
                if ( failFast )
                {
                    throw new EnforcerRuleException( filesInMsg.toString() );
                }
            }
        }
        if ( filesInMsg.length() > 0 )
        {
            throw new EnforcerRuleException( "Files not encoded in " + encoding + ":\n" + filesInMsg );
        }
    }
    catch ( IOException ex )
    {
        throw new EnforcerRuleException( "Reading Files", ex );
    }
    catch ( ExpressionEvaluationException e )
    {
        throw new EnforcerRuleException( "Unable to lookup an expression " + e.getLocalizedMessage(), e );
    }
}
 

import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper; //导入方法依赖的package包/类
@Override
public void execute(EnforcerRuleHelper helper) throws EnforcerRuleException {
  logger = helper.getLog();

  if (reportOnly) {
    logger.info("Flag 'reportOnly' is set. Exceptions from rule will only be reported!");
  }

  if (listMissingArtifacts) {
    logger.info("Flag 'listMissingArtifacts' is set. Transitively used artifacts are resolved.");
    initializeDependencyGraphBuilder(helper);
  }

  if (useClassesFromLastBuild) {
    logger.info("Flag 'useClassesFromLastBuild' is set. Try to use existing output folder.");
  }

  if (suppressTypesFromJavaRuntime) {
    logger.info(
      "Flag 'suppressTypesFromJavaRuntime' is set. Classes available in current Java-runtime will be ignored.");
  }

  initializeArtifactResolver(helper);

  initializeProject(helper);

  final Artifact artifact = resolveArtifact();

  // skip analyzes if the artifact has no associated file..
  if (artifact.getFile() == null) {
    logger.info("Nothing to analyze in '" + artifact.getId() + "'.");
    return;
  }

  // initialize the suppression filter
  filter = new ClassFilter(logger, suppressTypesFromJavaRuntime, regexIgnoredClasses);

  final Repository artifactClassesRepository = ArtifactRepositoryAnalyzer.analyzeArtifacts(logger,
    true,
    filter)
    .analyzeArtifacts(Collections.singleton(artifact));

  final Set<Artifact> dependencies = resolveDirectDependencies(artifact);

  final Repository dependenciesClassesRepository = ArtifactRepositoryAnalyzer.analyzeArtifacts(logger,
    false,
    filter)
    .analyzeArtifacts(dependencies);

  if (logger.isDebugEnabled()) {
    logger.debug("Artifact's type dependencies are: " + artifactClassesRepository.getDependencies());
    logger.debug("Classes defined in direct dependencies are: " + dependenciesClassesRepository.getTypes());
  }

  final Set<String> unresolvedTypes = new HashSet<String>(artifactClassesRepository.getDependencies());
  unresolvedTypes.removeAll(artifactClassesRepository.getTypes());
  unresolvedTypes.removeAll(dependenciesClassesRepository.getTypes());

  // traverse transitive dependencies to find the artifact a certain class is loaded from
  if (unresolvedTypes.isEmpty()) {
    logger.info("No illegal transitive dependencies found in '" + artifact.getId() + "'.");
  } else {
    final String message = buildOutput(artifact, unresolvedTypes);

    writeOutputFile(artifact, message);

    if (reportOnly) {
      logger.error(message);
    } else {
      throw new EnforcerRuleException(message);
    }
  }
}