| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * 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.android.tools.lint.checks; |
| |
| import static com.android.SdkConstants.ATTR_NAME; |
| import static com.android.SdkConstants.TAG_ARRAY; |
| import static com.android.SdkConstants.TAG_INTEGER_ARRAY; |
| import static com.android.SdkConstants.TAG_STRING_ARRAY; |
| |
| import com.android.annotations.NonNull; |
| import com.android.ide.common.rendering.api.ArrayResourceValue; |
| import com.android.ide.common.rendering.api.ResourceNamespace; |
| import com.android.ide.common.rendering.api.ResourceValue; |
| import com.android.ide.common.resources.ResourceItem; |
| import com.android.ide.common.resources.ResourceRepository; |
| import com.android.ide.common.util.PathString; |
| import com.android.resources.ResourceFolderType; |
| import com.android.resources.ResourceType; |
| import com.android.tools.lint.client.api.LintClient; |
| import com.android.tools.lint.client.api.LintDriver; |
| import com.android.tools.lint.detector.api.Category; |
| import com.android.tools.lint.detector.api.Context; |
| import com.android.tools.lint.detector.api.Implementation; |
| import com.android.tools.lint.detector.api.Issue; |
| import com.android.tools.lint.detector.api.Lint; |
| import com.android.tools.lint.detector.api.Location; |
| import com.android.tools.lint.detector.api.Project; |
| import com.android.tools.lint.detector.api.ResourceXmlDetector; |
| import com.android.tools.lint.detector.api.Scope; |
| import com.android.tools.lint.detector.api.Severity; |
| import com.android.tools.lint.detector.api.XmlContext; |
| import com.android.utils.Pair; |
| import com.google.common.collect.ArrayListMultimap; |
| import com.google.common.collect.Multimap; |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| |
| /** Checks for arrays with inconsistent item counts */ |
| public class ArraySizeDetector extends ResourceXmlDetector { |
| |
| /** Are there differences in how many array elements are declared? */ |
| public static final Issue INCONSISTENT = |
| Issue.create( |
| "InconsistentArrays", |
| "Inconsistencies in array element counts", |
| "When an array is translated in a different locale, it should normally have " |
| + "the same number of elements as the original array. When adding or removing " |
| + "elements to an array, it is easy to forget to update all the locales, and this " |
| + "lint warning finds inconsistencies like these.\n" |
| + "\n" |
| + "Note however that there may be cases where you really want to declare a " |
| + "different number of array items in each configuration (for example where " |
| + "the array represents available options, and those options differ for " |
| + "different layout orientations and so on), so use your own judgement to " |
| + "decide if this is really an error.\n" |
| + "\n" |
| + "You can suppress this error type if it finds false errors in your project.", |
| Category.CORRECTNESS, |
| 7, |
| Severity.WARNING, |
| new Implementation(ArraySizeDetector.class, Scope.RESOURCE_FILE_SCOPE)); |
| |
| private Multimap<File, Pair<String, Integer>> mFileToArrayCount; |
| |
| /** Locations for each array name. Populated during phase 2, if necessary */ |
| private Map<String, Location> mLocations; |
| |
| /** Error messages for each array name. Populated during phase 2, if necessary */ |
| private Map<String, String> mDescriptions; |
| |
| /** Constructs a new {@link ArraySizeDetector} */ |
| public ArraySizeDetector() {} |
| |
| @Override |
| public boolean appliesTo(@NonNull ResourceFolderType folderType) { |
| return folderType == ResourceFolderType.VALUES; |
| } |
| |
| @Override |
| public Collection<String> getApplicableElements() { |
| return Arrays.asList(TAG_ARRAY, TAG_STRING_ARRAY, TAG_INTEGER_ARRAY); |
| } |
| |
| @Override |
| public void beforeCheckRootProject(@NonNull Context context) { |
| if (context.getPhase() == 1) { |
| mFileToArrayCount = ArrayListMultimap.create(30, 5); |
| } |
| } |
| |
| @Override |
| public void afterCheckRootProject(@NonNull Context context) { |
| if (context.getPhase() == 1) { |
| boolean haveAllResources = context.getScope().contains(Scope.ALL_RESOURCE_FILES); |
| if (!haveAllResources) { |
| return; |
| } |
| |
| // Check that all arrays for the same name have the same number of translations |
| |
| LintClient client = context.getClient(); |
| Set<String> alreadyReported = new HashSet<>(); |
| Map<String, Integer> countMap = new HashMap<>(); |
| Map<String, File> fileMap = new HashMap<>(); |
| |
| // Process the file in sorted file order to ensure stable output |
| List<File> keys = new ArrayList<>(mFileToArrayCount.keySet()); |
| Collections.sort(keys); |
| |
| for (File file : keys) { |
| Collection<Pair<String, Integer>> pairs = mFileToArrayCount.get(file); |
| for (Pair<String, Integer> pair : pairs) { |
| String name = pair.getFirst(); |
| |
| if (alreadyReported.contains(name)) { |
| continue; |
| } |
| Integer count = pair.getSecond(); |
| |
| Integer current = countMap.get(name); |
| if (current == null) { |
| countMap.put(name, count); |
| fileMap.put(name, file); |
| } else if (!count.equals(current)) { |
| alreadyReported.add(name); |
| |
| if (mLocations == null) { |
| mLocations = new HashMap<>(); |
| mDescriptions = new HashMap<>(); |
| } |
| mLocations.put(name, null); |
| |
| String thisName = Lint.getFileNameWithParent(client, file); |
| File otherFile = fileMap.get(name); |
| String otherName = Lint.getFileNameWithParent(client, otherFile); |
| String message = |
| String.format( |
| "Array `%1$s` has an inconsistent number of items (%2$d in `%3$s`, %4$d in `%5$s`)", |
| name, count, thisName, current, otherName); |
| mDescriptions.put(name, message); |
| } |
| } |
| } |
| |
| //noinspection VariableNotUsedInsideIf |
| if (mLocations != null) { |
| // Request another scan through the resources such that we can |
| // gather the actual locations |
| context.getDriver().requestRepeat(this, Scope.ALL_RESOURCES_SCOPE); |
| } |
| mFileToArrayCount = null; |
| } else { |
| if (mLocations != null) { |
| List<String> names = new ArrayList<>(mLocations.keySet()); |
| Collections.sort(names); |
| for (String name : names) { |
| Location location = mLocations.get(name); |
| if (location == null) { |
| // Suppressed; see visitElement |
| continue; |
| } |
| // We were prepending locations, but we want to prefer the base folders |
| location = Location.reverse(location); |
| |
| // Make sure we still have a conflict, in case one or more of the |
| // elements were marked with tools:ignore |
| int count = -1; |
| LintDriver driver = context.getDriver(); |
| boolean foundConflict = false; |
| Location curr; |
| for (curr = location; curr != null; curr = curr.getSecondary()) { |
| Object clientData = curr.getClientData(); |
| if (clientData instanceof Node) { |
| Node node = (Node) clientData; |
| if (driver.isSuppressed(null, INCONSISTENT, node)) { |
| continue; |
| } |
| int newCount = Lint.getChildCount(node); |
| if (newCount != count) { |
| if (count == -1) { |
| count = newCount; // first number encountered |
| } else { |
| foundConflict = true; |
| break; |
| } |
| } |
| } else { |
| foundConflict = true; |
| break; |
| } |
| } |
| |
| // Through one or more tools:ignore, there is no more conflict so |
| // ignore this element |
| if (!foundConflict) { |
| continue; |
| } |
| |
| String message = mDescriptions.get(name); |
| context.report(INCONSISTENT, location, message); |
| } |
| } |
| |
| mLocations = null; |
| mDescriptions = null; |
| } |
| } |
| |
| @Override |
| public void visitElement(@NonNull XmlContext context, @NonNull Element element) { |
| int phase = context.getPhase(); |
| |
| Attr attribute = element.getAttributeNode(ATTR_NAME); |
| if (attribute == null || attribute.getValue().isEmpty()) { |
| if (phase != 1) { |
| return; |
| } |
| context.report( |
| INCONSISTENT, |
| element, |
| context.getLocation(element), |
| String.format( |
| "Missing name attribute in `%1$s` declaration", element.getTagName())); |
| } else { |
| String name = attribute.getValue(); |
| if (phase == 1) { |
| if (context.getProject().getReportIssues()) { |
| int childCount = Lint.getChildCount(element); |
| |
| if (!context.getScope().contains(Scope.ALL_RESOURCE_FILES) |
| && context.getClient().supportsProjectResources()) { |
| incrementalCheckCount(context, element, name, childCount); |
| return; |
| } |
| |
| mFileToArrayCount.put(context.file, Pair.of(name, childCount)); |
| } |
| } else { |
| assert phase == 2; |
| if (mLocations.containsKey(name)) { |
| if (context.getDriver().isSuppressed(context, INCONSISTENT, element)) { |
| return; |
| } |
| Location location = context.getLocation(element); |
| location.setData(element); |
| location.setMessage( |
| String.format( |
| "Declaration with array size (%1$d)", |
| Lint.getChildCount(element))); |
| location.setSecondary(mLocations.get(name)); |
| mLocations.put(name, location); |
| } |
| } |
| } |
| } |
| |
| private static void incrementalCheckCount( |
| @NonNull XmlContext context, |
| @NonNull Element element, |
| @NonNull String name, |
| int childCount) { |
| LintClient client = context.getClient(); |
| Project project = context.getMainProject(); |
| ResourceRepository resources = client.getResourceRepository(project, true, false); |
| if (resources == null) { |
| return; |
| } |
| List<ResourceItem> items = |
| resources.getResources(ResourceNamespace.TODO(), ResourceType.ARRAY, name); |
| for (ResourceItem item : items) { |
| PathString source = item.getSource(); |
| if (source != null && Lint.isSameResourceFile(context.file, source.toFile())) { |
| continue; |
| } |
| ResourceValue rv = item.getResourceValue(); |
| if (rv instanceof ArrayResourceValue) { |
| ArrayResourceValue arv = (ArrayResourceValue) rv; |
| if (childCount != arv.getElementCount()) { |
| String thisName = Lint.getFileNameWithParent(client, context.file); |
| assert source != null; |
| String otherName = Lint.getFileNameWithParent(client, source); |
| String message = |
| String.format( |
| "Array `%1$s` has an inconsistent number of items (%2$d in `%3$s`, %4$d in `%5$s`)", |
| name, childCount, thisName, arv.getElementCount(), otherName); |
| |
| context.report(INCONSISTENT, element, context.getLocation(element), message); |
| } |
| } |
| } |
| } |
| } |
