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

    private static boolean matches(String pattern, String str) {
        if (isAny(pattern)) {
            return true;
        } else if (pattern.endsWith("*")) {
            return str.startsWith(pattern.substring(0, pattern.length() - 1));
        } else {
            return Objects.equals(pattern, str);
        }
    }

                    && Objects.equals(workspace, that.workspace)
                    && Objects.equals(localRepo, that.localRepo)
                    && RepositoryUtils.repositoriesEquals(this.repositories, that.repositories)
                    && Objects.equals(filter, that.filter)
                    && Objects.equals(foreignImports, that.foreignImports);
        }
    }

        this.type = type;
    }

    public boolean include(Artifact artifact) {
        return type.equals(artifact.getType());
    }

    @Override
    public int hashCode() {
        int hash = 17;
        hash = hash * 31 + type.hashCode();
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        // [groupId]:artifactId
        if (selector.contains(":")) {
            String id = ':' + project.getArtifactId();

            if (id.equals(selector)) {
                return true;
            }

            id = project.getGroupId() + id;

            return id.equals(selector);
        }

        // relative path, e.g. "sub", "../sub" or "."
        else if (reactorDirectory != null) {

        if (!pluginArtifact.getGroupId().equals(pluginDescriptor.getGroupId())) {
            errors.add("Plugin's descriptor contains the wrong group ID: " + pluginDescriptor.getGroupId());
        }

        if (!pluginArtifact.getArtifactId().equals(pluginDescriptor.getArtifactId())) {

    /**
     * helper for equals
     */
    private static boolean objectsEqual(Object o1, Object o2) {
        if (o1 == null && o2 == null) {
            return true;
        }
        if (o1 == null || o2 == null) {
            return false; // as they are not both null
        }
        return o1.equals(o2);
    }

                    && Objects.equals(dependencyArtifacts, that.dependencyArtifacts)
                    && Objects.equals(workspace, that.workspace)
                    && Objects.equals(localRepo, that.localRepo)
                    && RepositoryUtils.repositoriesEquals(repositories, that.repositories)
                    && Objects.equals(collect, that.collect)
                    && Objects.equals(resolve, that.resolve)

                return PATH_SEP.equals(";") && !isFamily(FAMILY_NETWARE, actualOsName) && !isWindows;
            case FAMILY_MAC:
                return actualOsName.contains(FAMILY_MAC) || actualOsName.contains(DARWIN);
            case FAMILY_TANDEM:
                return actualOsName.contains("nonstop_kernel");
            case FAMILY_UNIX:
                return PATH_SEP.equals(":")

            return session;
        }

        if (session != null) {
            LocalRepositoryManager lrm = session.getLocalRepositoryManager();
            if (lrm != null && lrm.getRepository().getBasedir().equals(new File(repository.getBasedir()))) {
                return session;
            }
        } else {
            session = new DefaultRepositorySystemSession();
        }

            interpolator.addValueSource(new AbstractValueSource(false) {
                @Override
                public Object getValue(String expression) {
                    if ("basedir".equals(expression) || "project.basedir".equals(expression)) {
                        return basedir.toAbsolutePath().toString();
                    }
                    return null;
                }
            });