Java tutorial
// Copyright 2014 The Bazel Authors. All rights reserved. // // 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.devtools.build.lib.syntax; import com.google.common.base.Functions; import com.google.common.base.Splitter; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableList.Builder; import com.google.common.collect.Iterables; import com.google.devtools.build.lib.util.Preconditions; import java.util.List; import javax.annotation.Nullable; /** * Either the arguments to a glob call (the include and exclude lists) or the * contents of a fixed list that was appended to a list of glob results. * (The latter need to be stored by {@link GlobList} in order to fully * reproduce the inputs that created the output list.) * * <p>For example, the expression * <code>glob(['*.java']) + ['x.properties']</code> * will result in two GlobCriteria: one has include = ['*.java'], glob = true * and the other, include = ['x.properties'], glob = false. */ public class GlobCriteria { /** * A list of names or patterns that are included by this glob. They should * consist of characters that are valid in labels in the BUILD language. */ private final ImmutableList<String> include; /** * A list of names or patterns that are excluded by this glob. They should * consist of characters that are valid in labels in the BUILD language. */ private final ImmutableList<String> exclude; /** True if the includes list was passed to glob(), false if not. */ private final boolean glob; /** * Parses criteria from its {@link #toExpression} form. * Package-private for use by tests and GlobList. * @throws IllegalArgumentException if the expression cannot be parsed */ public static GlobCriteria parse(String text) { if (text.startsWith("glob([") && text.endsWith("])")) { int excludeIndex = text.indexOf("], exclude=["); if (excludeIndex == -1) { String listText = text.substring(6, text.length() - 2); return new GlobCriteria(parseList(listText), ImmutableList.<String>of(), true); } else { String listText = text.substring(6, excludeIndex); String excludeText = text.substring(excludeIndex + 12, text.length() - 2); return new GlobCriteria(parseList(listText), parseList(excludeText), true); } } else if (text.startsWith("[") && text.endsWith("]")) { String listText = text.substring(1, text.length() - 1); return new GlobCriteria(parseList(listText), ImmutableList.<String>of(), false); } else { throw new IllegalArgumentException("unrecognized format (not from toExpression?): " + text); } } /** * Constructs a copy of a given glob critera object, with additional exclude patterns added. * * @param base a glob criteria object to copy. Must be an actual glob * @param excludes a list of pattern strings indicating new excludes to provide * @return a new glob criteria object which contains the same parameters as {@code base}, with * the additional patterns in {@code excludes} added. * @throws IllegalArgumentException if {@code base} is not a glob */ public static GlobCriteria createWithAdditionalExcludes(GlobCriteria base, List<String> excludes) { Preconditions.checkArgument(base.isGlob()); return fromGlobCall(base.include, ImmutableList.copyOf(Iterables.concat(base.exclude, excludes))); } /** * Constructs a copy of a fixed list, converted to Strings. */ public static GlobCriteria fromList(Iterable<?> list) { Iterable<String> strings = Iterables.transform(list, Functions.toStringFunction()); return new GlobCriteria(ImmutableList.copyOf(strings), ImmutableList.<String>of(), false); } /** * Constructs a glob call with include and exclude list. * * @param include list of included patterns * @param exclude list of excluded patterns */ public static GlobCriteria fromGlobCall(ImmutableList<String> include, ImmutableList<String> exclude) { return new GlobCriteria(include, exclude, true); } /** * Constructs a glob call with include and exclude list. */ private GlobCriteria(ImmutableList<String> include, ImmutableList<String> exclude, boolean glob) { this.include = include; this.exclude = exclude; this.glob = glob; } /** * Returns the patterns that were included in this {@code glob()} call. */ public ImmutableList<String> getIncludePatterns() { return include; } /** * Returns the patterns that were excluded in this {@code glob()} call. */ public ImmutableList<String> getExcludePatterns() { return exclude; } /** * Returns true if the include list was passed to {@code glob()}, false * if it was a fixed list. If this returns false, the exclude list will * always be empty. */ public boolean isGlob() { return glob; } /** * Returns a String that represents this glob as a BUILD expression. * For example, <code>glob(['abc', 'def'], exclude=['uvw', 'xyz'])</code> * or <code>['foo', 'bar', 'baz']</code>. */ public String toExpression() { StringBuilder sb = new StringBuilder(); if (glob) { sb.append("glob("); } sb.append('['); appendList(sb, include); if (!exclude.isEmpty()) { sb.append("], exclude=["); appendList(sb, exclude); } sb.append(']'); if (glob) { sb.append(')'); } return sb.toString(); } @Override public String toString() { return toExpression(); } /** * Takes a list of Strings, quotes them in single quotes, and appends them to * a StringBuilder separated by a comma and space. This can be parsed back * out by {@link #parseList}. */ private static void appendList(StringBuilder sb, List<String> list) { boolean first = true; for (String content : list) { if (!first) { sb.append(", "); } sb.append('\'').append(content).append('\''); first = false; } } /** * Takes a String in the format created by {@link #appendList} and returns * the original Strings. A null String (which may be returned when Pattern * does not find a match) or the String "" (which will be captured in "[]") * will result in an empty list. */ private static ImmutableList<String> parseList(@Nullable String text) { if (text == null) { return ImmutableList.of(); } Iterable<String> split = Splitter.on(", ").split(text); Builder<String> listBuilder = ImmutableList.builder(); for (String element : split) { if (!element.isEmpty()) { if ((element.length() < 2) || !element.startsWith("'") || !element.endsWith("'")) { throw new IllegalArgumentException("expected a filename or pattern in quotes: " + text); } listBuilder.add(element.substring(1, element.length() - 1)); } } return listBuilder.build(); } }