return false;
        }

        boolean active = ensureAtLeastOneNonNull(os);

        String actualOsName = context.getSystemProperties().get("os.name").toLowerCase(Locale.ENGLISH);
        String actualOsArch = context.getSystemProperties().get("os.arch").toLowerCase(Locale.ENGLISH);
        String actualOsVersion = context.getSystemProperties().get("os.version").toLowerCase(Locale.ENGLISH);

            s = new File(new File(basedir, s).toURI().normalize()).getAbsolutePath();
        }

        return s;
    }

    private String stripBasedirToken(String s) {
        if (s != null) {
            String basedirExpr = null;
            for (String expression : BASEDIR_EXPRESSIONS) {
                if (s.startsWith(expression)) {
                    basedirExpr = expression;
                    break;

    }

    private static int getRelationOrder(String value, RangeValue rangeValue, boolean isLeft) {
        if (rangeValue.value.isEmpty()) {
            return isLeft ? 1 : -1;
        }

        value = FILTER_1.matcher(value).replaceAll("");

        List<String> valueTokens = new ArrayList<>(Arrays.asList(FILTER_2.split(value)));

 */
final class PluginsMetadata extends MavenMetadata {
    static final class PluginInfo {
        final String groupId;

        private final String artifactId;

        private final String goalPrefix;

        private final String name;

        PluginInfo(String groupId, String artifactId, String goalPrefix, String name) {
            this.groupId = groupId;
            this.artifactId = artifactId;

        assertEquals(expectedNode, resolvedNode, "Resolution node");
    }

    protected Artifact createArtifact(String id, String version) throws InvalidVersionSpecificationException {
        return createArtifact(id, version, Artifact.SCOPE_COMPILE);
    }

    protected Artifact createArtifact(String id, String version, String scope)
            throws InvalidVersionSpecificationException {

            }
        }
        return null;
    }

    private boolean isProjectContext(String context) {
        return context != null && context.startsWith("project");
    }

    private static boolean isAny(String str) {
        return "*".equals(str);
    }

    private static boolean matches(String pattern, String str) {
        if (isAny(pattern)) {
            return true;

    public boolean isSnapshot(String version) {
        return checkSnapshot(version);
    }

    public static boolean checkSnapshot(String version) {
        return version.endsWith(SNAPSHOT) || SNAPSHOT_TIMESTAMP.matcher(version).matches();
    }

    @Override
    public VersionConstraint parseVersionConstraint(String constraint) {
        requireNonNull(constraint, "constraint");

        }
    }

    private Collection<String> toScopes(String classpath) {
        Collection<String> scopes = Collections.emptyList();

        if (classpath != null && !classpath.isEmpty()) {
            if (Artifact.SCOPE_COMPILE.equals(classpath)) {
                scopes = Arrays.asList(Artifact.SCOPE_COMPILE, Artifact.SCOPE_SYSTEM, Artifact.SCOPE_PROVIDED);

    private String originalMessage;

    public PluginConfigurationException(PluginDescriptor pluginDescriptor, String originalMessage) {
        super(originalMessage);
        this.pluginDescriptor = pluginDescriptor;
        this.originalMessage = originalMessage;
    }

    public PluginConfigurationException(PluginDescriptor pluginDescriptor, String originalMessage, Throwable cause) {

/**
 * @since 3.0
 */
// TODO The configuration for the lifecycle needs to be externalized so that I can use the annotations properly for the
// wiring and reference and external source for the lifecycle configuration.
@Named
@Singleton
public class DefaultLifecycles {
    public static final String[] STANDARD_LIFECYCLES = {"clean", "default", "site", "wrapper"};

    private final Logger logger = LoggerFactory.getLogger(getClass());