diff options
Diffstat (limited to 'jimfs/src/main/java/com/google/common/jimfs/PathMatchers.java')
-rw-r--r-- | jimfs/src/main/java/com/google/common/jimfs/PathMatchers.java | 96 |
1 files changed, 96 insertions, 0 deletions
diff --git a/jimfs/src/main/java/com/google/common/jimfs/PathMatchers.java b/jimfs/src/main/java/com/google/common/jimfs/PathMatchers.java new file mode 100644 index 0000000..38ba45a --- /dev/null +++ b/jimfs/src/main/java/com/google/common/jimfs/PathMatchers.java @@ -0,0 +1,96 @@ +/* + * Copyright 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.common.jimfs; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Ascii; +import com.google.common.base.MoreObjects; +import com.google.common.collect.ImmutableSet; +import java.nio.file.FileSystem; +import java.nio.file.Path; +import java.nio.file.PathMatcher; +import java.util.regex.Pattern; + +/** + * {@link PathMatcher} factory for any file system. + * + * @author Colin Decker + */ +final class PathMatchers { + + private PathMatchers() {} + + /** + * Gets a {@link PathMatcher} for the given syntax and pattern as specified by {@link + * FileSystem#getPathMatcher}. The {@code separators} string contains the path name element + * separators (one character each) recognized by the file system. For a glob-syntax path matcher, + * any of the given separators will be recognized as a separator in the pattern, and any of them + * will be matched as a separator when checking a path. + */ + // TODO(cgdecker): Should I be just canonicalizing separators rather than matching any separator? + // Perhaps so, assuming Path always canonicalizes its separators + public static PathMatcher getPathMatcher( + String syntaxAndPattern, String separators, ImmutableSet<PathNormalization> normalizations) { + int syntaxSeparator = syntaxAndPattern.indexOf(':'); + checkArgument( + syntaxSeparator > 0, "Must be of the form 'syntax:pattern': %s", syntaxAndPattern); + + String syntax = Ascii.toLowerCase(syntaxAndPattern.substring(0, syntaxSeparator)); + String pattern = syntaxAndPattern.substring(syntaxSeparator + 1); + + switch (syntax) { + case "glob": + pattern = GlobToRegex.toRegex(pattern, separators); + // fall through + case "regex": + return fromRegex(pattern, normalizations); + default: + throw new UnsupportedOperationException("Invalid syntax: " + syntaxAndPattern); + } + } + + private static PathMatcher fromRegex(String regex, Iterable<PathNormalization> normalizations) { + return new RegexPathMatcher(PathNormalization.compilePattern(regex, normalizations)); + } + + /** + * {@code PathMatcher} that matches the {@code toString()} form of a {@code Path} against a regex + * {@code Pattern}. + */ + @VisibleForTesting + static final class RegexPathMatcher implements PathMatcher { + + private final Pattern pattern; + + private RegexPathMatcher(Pattern pattern) { + this.pattern = checkNotNull(pattern); + } + + @Override + public boolean matches(Path path) { + return pattern.matcher(path.toString()).matches(); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this).addValue(pattern).toString(); + } + } +} |