* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.file.pattern;

public interface PathMatcher {
    /**
     * Returns the minimum number of segments a path must have to satisfy this matcher.
     */
    int getMinSegments();

    /**

        private final PathMatcher pathMatcher;

        public DefaultPatternMatcher(boolean partialMatchDirs, PathMatcher pathMatcher) {
            this.partialMatchDirs = partialMatchDirs;
            this.pathMatcher = pathMatcher;
        }

        @VisibleForTesting
        PathMatcher getPathMatcher() {
            return pathMatcher;
        }

        @Override

        ImmutableSet.Builder<PathMatcher> builder = ImmutableSet.builder();
        for (String ignore : ignores) {
            PathMatcher matcher = PatternMatcherFactory.compile(true, ignore);
            builder.add(matcher);
        }
        this.ignoreMatchers = builder.build();
    }

    private boolean shouldBeIgnored(String[] relativePath) {
        for (PathMatcher ignoreSpec : ignoreMatchers) {

		Name: k,
		HeaderMatchSpecifier: &routepb.HeaderMatcher_StringMatch{
			StringMatch: StringMatcherExact(v, true),
		},
	}
}

// PathMatcher creates a path matcher for a path.
func PathMatcher(path string) *matcher.PathMatcher {
	return &matcher.PathMatcher{
		Rule: &matcher.PathMatcher_Path{
			Path: StringMatcher(path),
		},
	}

		Name   string
		V      string
		Expect *matcher.PathMatcher
	}{
		{
			Name: "exact match",
			V:    "/productpage",
			Expect: &matcher.PathMatcher{
				Rule: &matcher.PathMatcher_Path{
					Path: StringMatcherExact("/productpage", false),
				},
			},
		},
		{
			Name: "prefix match",
			V:    "/prefix*",
			Expect: &matcher.PathMatcher{
				Rule: &matcher.PathMatcher_Path{

 */

package org.gradle.api.internal.file.pattern;

public class FixedStepPathMatcher implements PathMatcher {
    private final PatternStep step;
    private final PathMatcher next;
    private final int minSegments;
    private final int maxSegments;

    public FixedStepPathMatcher(PatternStep step, PathMatcher next) {
        this.step = step;
        this.next = next;
        minSegments = 1 + next.getMinSegments();

        return predicates.stream().noneMatch(p -> p.test(artifact));
    }

    private static Predicate<Artifact> toPredicate(Exclusion exclusion) {
        PathMatcher groupId = FileSystems.getDefault().getPathMatcher("glob:" + exclusion.getGroupId());
        PathMatcher artifactId = FileSystems.getDefault().getPathMatcher("glob:" + exclusion.getArtifactId());

 * limitations under the License.
 */

package org.gradle.api.internal.file.pattern;

public class GreedyPathMatcher implements PathMatcher {
    private final PathMatcher next;

    public GreedyPathMatcher(PathMatcher next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "{greedy next: " + next + "}";
    }

    @Override

package org.gradle.api.internal.file.pattern

import spock.lang.Specification

class GreedyPathMatcherTest extends Specification {
    def "calculates min and max number of segments"() {
        def next = Stub(PathMatcher) {
            getMinSegments() >> 2
            getMaxSegments() >> 3
        }
        def matcher = new GreedyPathMatcher(next)

        expect:
        matcher.minSegments == 2

package org.gradle.api.internal.file.pattern

import spock.lang.Specification

class FixedStepPathMatcherTest extends Specification {
    def "calculates min and max number of segments"() {
        def next = Stub(PathMatcher) {
            getMinSegments() >> 2
            getMaxSegments() >> 3
        }
        def matcher = new FixedStepPathMatcher(Stub(PatternStep), next)

        expect:
        matcher.minSegments == 3