/*
* 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;
import static com.android.SdkConstants.DOT_XML;
import static com.android.SdkConstants.VALUE_NONE;
import static com.android.tools.lint.LintCliFlags.ERRNO_ERRORS;
import static com.android.tools.lint.LintCliFlags.ERRNO_EXISTS;
import static com.android.tools.lint.LintCliFlags.ERRNO_HELP;
import static com.android.tools.lint.LintCliFlags.ERRNO_INVALID_ARGS;
import static com.android.tools.lint.LintCliFlags.ERRNO_SUCCESS;
import static com.android.tools.lint.LintCliFlags.ERRNO_USAGE;
import static com.android.tools.lint.detector.api.LintUtils.endsWith;
import static com.android.tools.lint.detector.api.TextFormat.TEXT;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.tools.lint.checks.BuiltinIssueRegistry;
import com.android.tools.lint.client.api.Configuration;
import com.android.tools.lint.client.api.IssueRegistry;
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.Issue;
import com.android.tools.lint.detector.api.LintUtils;
import com.android.tools.lint.detector.api.Location;
import com.android.tools.lint.detector.api.Project;
import com.android.tools.lint.detector.api.Severity;
import com.android.tools.lint.detector.api.TextFormat;
import com.android.utils.SdkUtils;
import com.google.common.annotations.Beta;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Command line driver for the lint framework
* <p>
* <b>NOTE: This is not a public or final API; if you rely on this be prepared
* to adjust your code for the next tools release.</b>
*/
@Beta
public class Main {
static final int MAX_LINE_WIDTH = 78;
private static final String ARG_ENABLE = "--enable"; //$NON-NLS-1$
private static final String ARG_DISABLE = "--disable"; //$NON-NLS-1$
private static final String ARG_CHECK = "--check"; //$NON-NLS-1$
private static final String ARG_IGNORE = "--ignore"; //$NON-NLS-1$
private static final String ARG_LIST_IDS = "--list"; //$NON-NLS-1$
private static final String ARG_SHOW = "--show"; //$NON-NLS-1$
private static final String ARG_QUIET = "--quiet"; //$NON-NLS-1$
private static final String ARG_FULL_PATH = "--fullpath"; //$NON-NLS-1$
private static final String ARG_SHOW_ALL = "--showall"; //$NON-NLS-1$
private static final String ARG_HELP = "--help"; //$NON-NLS-1$
private static final String ARG_NO_LINES = "--nolines"; //$NON-NLS-1$
private static final String ARG_HTML = "--html"; //$NON-NLS-1$
private static final String ARG_SIMPLE_HTML= "--simplehtml"; //$NON-NLS-1$
private static final String ARG_XML = "--xml"; //$NON-NLS-1$
private static final String ARG_TEXT = "--text"; //$NON-NLS-1$
private static final String ARG_CONFIG = "--config"; //$NON-NLS-1$
private static final String ARG_URL = "--url"; //$NON-NLS-1$
private static final String ARG_VERSION = "--version"; //$NON-NLS-1$
private static final String ARG_EXIT_CODE = "--exitcode"; //$NON-NLS-1$
private static final String ARG_CLASSES = "--classpath"; //$NON-NLS-1$
private static final String ARG_SOURCES = "--sources"; //$NON-NLS-1$
private static final String ARG_RESOURCES = "--resources"; //$NON-NLS-1$
private static final String ARG_LIBRARIES = "--libraries"; //$NON-NLS-1$
private static final String ARG_NO_WARN_2 = "--nowarn"; //$NON-NLS-1$
// GCC style flag names for options
private static final String ARG_NO_WARN_1 = "-w"; //$NON-NLS-1$
private static final String ARG_WARN_ALL = "-Wall"; //$NON-NLS-1$
private static final String ARG_ALL_ERROR = "-Werror"; //$NON-NLS-1$
private static final String PROP_WORK_DIR = "com.android.tools.lint.workdir"; //$NON-NLS-1$
private LintCliFlags mFlags = new LintCliFlags();
private IssueRegistry mGlobalRegistry;
/** Creates a CLI driver */
public Main() {
}
/**
* Runs the static analysis command line driver
*
* @param args program arguments
*/
public static void main(String[] args) {
new Main().run(args);
}
/**
* Runs the static analysis command line driver
*
* @param args program arguments
*/
@SuppressWarnings("UnnecessaryLocalVariable")
public void run(String[] args) {
if (args.length < 1) {
printUsage(System.err);
System.exit(ERRNO_USAGE);
}
// When running lint from the command line, warn if the project is a Gradle project
// since those projects may have custom project configuration that the command line
// runner won't know about.
LintCliClient client = new LintCliClient(mFlags) {
@NonNull
@Override
protected Project createProject(@NonNull File dir, @NonNull File referenceDir) {
Project project = super.createProject(dir, referenceDir);
if (project.isGradleProject()) {
@SuppressWarnings("SpellCheckingInspection")
String message = String.format("\"`%1$s`\" is a Gradle project. To correctly "
+ "analyze Gradle projects, you should run \"`gradlew :lint`\" instead.",
project.getName());
Location location = Location.create(project.getDir());
Context context = new Context(mDriver, project, project, project.getDir());
if (context.isEnabled(IssueRegistry.LINT_ERROR) &&
!getConfiguration(project, null).isIgnored(context,
IssueRegistry.LINT_ERROR, location, message)) {
report(context,
IssueRegistry.LINT_ERROR,
project.getConfiguration(null).getSeverity(
IssueRegistry.LINT_ERROR), location, message,
TextFormat.RAW);
}
}
return project;
}
@NonNull
@Override
public Configuration getConfiguration(@NonNull final Project project,
@Nullable LintDriver driver) {
if (project.isGradleProject()) {
// Don't report any issues when analyzing a Gradle project from the
// non-Gradle runner; they are likely to be false, and will hide the real
// problem reported above
return new CliConfiguration(getConfiguration(), project, true) {
@NonNull
@Override
public Severity getSeverity(@NonNull Issue issue) {
return issue == IssueRegistry.LINT_ERROR
? Severity.FATAL : Severity.IGNORE;
}
@Override
public boolean isIgnored(@NonNull Context context, @NonNull Issue issue,
@Nullable Location location, @NonNull String message) {
// If you've deliberately ignored IssueRegistry.LINT_ERROR
// don't flag that one either
if (issue == IssueRegistry.LINT_ERROR && new LintCliClient(mFlags).isSuppressed(
IssueRegistry.LINT_ERROR)) {
return true;
}
return issue != IssueRegistry.LINT_ERROR;
}
};
}
return super.getConfiguration(project, driver);
}
};
// Mapping from file path prefix to URL. Applies only to HTML reports
String urlMap = null;
List<File> files = new ArrayList<File>();
for (int index = 0; index < args.length; index++) {
String arg = args[index];
if (arg.equals(ARG_HELP)
|| arg.equals("-h") || arg.equals("-?")) { //$NON-NLS-1$ //$NON-NLS-2$
if (index < args.length - 1) {
String topic = args[index + 1];
if (topic.equals("suppress") || topic.equals("ignore")) {
printHelpTopicSuppress();
System.exit(ERRNO_HELP);
} else {
System.err.println(String.format("Unknown help topic \"%1$s\"", topic));
System.exit(ERRNO_INVALID_ARGS);
}
}
printUsage(System.out);
System.exit(ERRNO_HELP);
} else if (arg.equals(ARG_LIST_IDS)) {
IssueRegistry registry = getGlobalRegistry(client);
// Did the user provide a category list?
if (index < args.length - 1 && !args[index + 1].startsWith("-")) { //$NON-NLS-1$
String[] ids = args[++index].split(",");
for (String id : ids) {
if (registry.isCategoryName(id)) {
// List all issues with the given category
String category = id;
for (Issue issue : registry.getIssues()) {
// Check prefix such that filtering on the "Usability" category
// will match issue category "Usability:Icons" etc.
if (issue.getCategory().getName().startsWith(category) ||
issue.getCategory().getFullName().startsWith(category)) {
listIssue(System.out, issue);
}
}
} else {
System.err.println("Invalid category \"" + id + "\".\n");
displayValidIds(registry, System.err);
System.exit(ERRNO_INVALID_ARGS);
}
}
} else {
displayValidIds(registry, System.out);
}
System.exit(ERRNO_SUCCESS);
} else if (arg.equals(ARG_SHOW)) {
IssueRegistry registry = getGlobalRegistry(client);
// Show specific issues?
if (index < args.length - 1 && !args[index + 1].startsWith("-")) { //$NON-NLS-1$
String[] ids = args[++index].split(",");
for (String id : ids) {
if (registry.isCategoryName(id)) {
// Show all issues in the given category
String category = id;
for (Issue issue : registry.getIssues()) {
// Check prefix such that filtering on the "Usability" category
// will match issue category "Usability:Icons" etc.
if (issue.getCategory().getName().startsWith(category) ||
issue.getCategory().getFullName().startsWith(category)) {
describeIssue(issue);
System.out.println();
}
}
} else if (registry.isIssueId(id)) {
describeIssue(registry.getIssue(id));
System.out.println();
} else {
System.err.println("Invalid id or category \"" + id + "\".\n");
displayValidIds(registry, System.err);
System.exit(ERRNO_INVALID_ARGS);
}
}
} else {
showIssues(registry);
}
System.exit(ERRNO_SUCCESS);
} else if (arg.equals(ARG_FULL_PATH)
|| arg.equals(ARG_FULL_PATH + "s")) { // allow "--fullpaths" too
mFlags.setFullPath(true);
} else if (arg.equals(ARG_SHOW_ALL)) {
mFlags.setShowEverything(true);
} else if (arg.equals(ARG_QUIET) || arg.equals("-q")) {
mFlags.setQuiet(true);
} else if (arg.equals(ARG_NO_LINES)) {
mFlags.setShowSourceLines(false);
} else if (arg.equals(ARG_EXIT_CODE)) {
mFlags.setSetExitCode(true);
} else if (arg.equals(ARG_VERSION)) {
printVersion(client);
System.exit(ERRNO_SUCCESS);
} else if (arg.equals(ARG_URL)) {
if (index == args.length - 1) {
System.err.println("Missing URL mapping string");
System.exit(ERRNO_INVALID_ARGS);
}
String map = args[++index];
// Allow repeated usage of the argument instead of just comma list
if (urlMap != null) {
urlMap = urlMap + ',' + map;
} else {
urlMap = map;
}
} else if (arg.equals(ARG_CONFIG)) {
if (index == args.length - 1 || !endsWith(args[index + 1], DOT_XML)) {
System.err.println("Missing XML configuration file argument");
System.exit(ERRNO_INVALID_ARGS);
}
File file = getInArgumentPath(args[++index]);
if (!file.exists()) {
System.err.println(file.getAbsolutePath() + " does not exist");
System.exit(ERRNO_INVALID_ARGS);
}
mFlags.setDefaultConfiguration(file);
} else if (arg.equals(ARG_HTML) || arg.equals(ARG_SIMPLE_HTML)) {
if (index == args.length - 1) {
System.err.println("Missing HTML output file name");
System.exit(ERRNO_INVALID_ARGS);
}
File output = getOutArgumentPath(args[++index]);
// Get an absolute path such that we can ask its parent directory for
// write permission etc.
output = output.getAbsoluteFile();
if (output.isDirectory() ||
(!output.exists() && output.getName().indexOf('.') == -1)) {
if (!output.exists()) {
boolean mkdirs = output.mkdirs();
if (!mkdirs) {
log(null, "Could not create output directory %1$s", output);
System.exit(ERRNO_EXISTS);
}
}
try {
MultiProjectHtmlReporter reporter =
new MultiProjectHtmlReporter(client, output);
if (arg.equals(ARG_SIMPLE_HTML)) {
reporter.setSimpleFormat(true);
}
mFlags.getReporters().add(reporter);
} catch (IOException e) {
log(e, null);
System.exit(ERRNO_INVALID_ARGS);
}
continue;
}
if (output.exists()) {
boolean delete = output.delete();
if (!delete) {
System.err.println("Could not delete old " + output);
System.exit(ERRNO_EXISTS);
}
}
if (output.getParentFile() != null && !output.getParentFile().canWrite()) {
System.err.println("Cannot write HTML output file " + output);
System.exit(ERRNO_EXISTS);
}
try {
HtmlReporter htmlReporter = new HtmlReporter(client, output);
if (arg.equals(ARG_SIMPLE_HTML)) {
htmlReporter.setSimpleFormat(true);
}
mFlags.getReporters().add(htmlReporter);
} catch (IOException e) {
log(e, null);
System.exit(ERRNO_INVALID_ARGS);
}
} else if (arg.equals(ARG_XML)) {
if (index == args.length - 1) {
System.err.println("Missing XML output file name");
System.exit(ERRNO_INVALID_ARGS);
}
File output = getOutArgumentPath(args[++index]);
// Get an absolute path such that we can ask its parent directory for
// write permission etc.
output = output.getAbsoluteFile();
if (output.exists()) {
boolean delete = output.delete();
if (!delete) {
System.err.println("Could not delete old " + output);
System.exit(ERRNO_EXISTS);
}
}
if (output.getParentFile() != null && !output.getParentFile().canWrite()) {
System.err.println("Cannot write XML output file " + output);
System.exit(ERRNO_EXISTS);
}
try {
mFlags.getReporters().add(new XmlReporter(client, output));
} catch (IOException e) {
log(e, null);
System.exit(ERRNO_INVALID_ARGS);
}
} else if (arg.equals(ARG_TEXT)) {
if (index == args.length - 1) {
System.err.println("Missing text output file name");
System.exit(ERRNO_INVALID_ARGS);
}
Writer writer = null;
boolean closeWriter;
String outputName = args[++index];
if (outputName.equals("stdout")) { //$NON-NLS-1$
//noinspection IOResourceOpenedButNotSafelyClosed
writer = new PrintWriter(System.out, true);
closeWriter = false;
} else {
File output = getOutArgumentPath(outputName);
// Get an absolute path such that we can ask its parent directory for
// write permission etc.
output = output.getAbsoluteFile();
if (output.exists()) {
boolean delete = output.delete();
if (!delete) {
System.err.println("Could not delete old " + output);
System.exit(ERRNO_EXISTS);
}
}
if (output.getParentFile() != null && !output.getParentFile().canWrite()) {
System.err.println("Cannot write text output file " + output);
System.exit(ERRNO_EXISTS);
}
try {
//noinspection IOResourceOpenedButNotSafelyClosed
writer = new BufferedWriter(new FileWriter(output));
} catch (IOException e) {
log(e, null);
System.exit(ERRNO_INVALID_ARGS);
}
closeWriter = true;
}
mFlags.getReporters().add(new TextReporter(client, mFlags, writer, closeWriter));
} else if (arg.equals(ARG_DISABLE) || arg.equals(ARG_IGNORE)) {
if (index == args.length - 1) {
System.err.println("Missing categories or id's to disable");
System.exit(ERRNO_INVALID_ARGS);
}
IssueRegistry registry = getGlobalRegistry(client);
String[] ids = args[++index].split(",");
for (String id : ids) {
if (registry.isCategoryName(id)) {
// Suppress all issues with the given category
String category = id;
for (Issue issue : registry.getIssues()) {
// Check prefix such that filtering on the "Usability" category
// will match issue category "Usability:Icons" etc.
if (issue.getCategory().getName().startsWith(category) ||
issue.getCategory().getFullName().startsWith(category)) {
mFlags.getSuppressedIds().add(issue.getId());
}
}
} else if (!registry.isIssueId(id)) {
System.err.println("Invalid id or category \"" + id + "\".\n");
displayValidIds(registry, System.err);
System.exit(ERRNO_INVALID_ARGS);
} else {
mFlags.getSuppressedIds().add(id);
}
}
} else if (arg.equals(ARG_ENABLE)) {
if (index == args.length - 1) {
System.err.println("Missing categories or id's to enable");
System.exit(ERRNO_INVALID_ARGS);
}
IssueRegistry registry = getGlobalRegistry(client);
String[] ids = args[++index].split(",");
for (String id : ids) {
if (registry.isCategoryName(id)) {
// Enable all issues with the given category
String category = id;
for (Issue issue : registry.getIssues()) {
if (issue.getCategory().getName().startsWith(category) ||
issue.getCategory().getFullName().startsWith(category)) {
mFlags.getEnabledIds().add(issue.getId());
}
}
} else if (!registry.isIssueId(id)) {
System.err.println("Invalid id or category \"" + id + "\".\n");
displayValidIds(registry, System.err);
System.exit(ERRNO_INVALID_ARGS);
} else {
mFlags.getEnabledIds().add(id);
}
}
} else if (arg.equals(ARG_CHECK)) {
if (index == args.length - 1) {
System.err.println("Missing categories or id's to check");
System.exit(ERRNO_INVALID_ARGS);
}
Set<String> checkedIds = mFlags.getExactCheckedIds();
if (checkedIds == null) {
checkedIds = new HashSet<String>();
mFlags.setExactCheckedIds(checkedIds);
}
IssueRegistry registry = getGlobalRegistry(client);
String[] ids = args[++index].split(",");
for (String id : ids) {
if (registry.isCategoryName(id)) {
// Check all issues with the given category
String category = id;
for (Issue issue : registry.getIssues()) {
// Check prefix such that filtering on the "Usability" category
// will match issue category "Usability:Icons" etc.
if (issue.getCategory().getName().startsWith(category) ||
issue.getCategory().getFullName().startsWith(category)) {
checkedIds.add(issue.getId());
}
}
} else if (!registry.isIssueId(id)) {
System.err.println("Invalid id or category \"" + id + "\".\n");
displayValidIds(registry, System.err);
System.exit(ERRNO_INVALID_ARGS);
} else {
checkedIds.add(id);
}
}
} else if (arg.equals(ARG_NO_WARN_1) || arg.equals(ARG_NO_WARN_2)) {
mFlags.setIgnoreWarnings(true);
} else if (arg.equals(ARG_WARN_ALL)) {
mFlags.setCheckAllWarnings(true);
} else if (arg.equals(ARG_ALL_ERROR)) {
mFlags.setWarningsAsErrors(true);
} else if (arg.equals(ARG_CLASSES)) {
if (index == args.length - 1) {
System.err.println("Missing class folder name");
System.exit(ERRNO_INVALID_ARGS);
}
String paths = args[++index];
for (String path : LintUtils.splitPath(paths)) {
File input = getInArgumentPath(path);
if (!input.exists()) {
System.err.println("Class path entry " + input + " does not exist.");
System.exit(ERRNO_INVALID_ARGS);
}
List<File> classes = mFlags.getClassesOverride();
if (classes == null) {
classes = new ArrayList<File>();
mFlags.setClassesOverride(classes);
}
classes.add(input);
}
} else if (arg.equals(ARG_SOURCES)) {
if (index == args.length - 1) {
System.err.println("Missing source folder name");
System.exit(ERRNO_INVALID_ARGS);
}
String paths = args[++index];
for (String path : LintUtils.splitPath(paths)) {
File input = getInArgumentPath(path);
if (!input.exists()) {
System.err.println("Source folder " + input + " does not exist.");
System.exit(ERRNO_INVALID_ARGS);
}
List<File> sources = mFlags.getSourcesOverride();
if (sources == null) {
sources = new ArrayList<File>();
mFlags.setSourcesOverride(sources);
}
sources.add(input);
}
} else if (arg.equals(ARG_RESOURCES)) {
if (index == args.length - 1) {
System.err.println("Missing resource folder name");
System.exit(ERRNO_INVALID_ARGS);
}
String paths = args[++index];
for (String path : LintUtils.splitPath(paths)) {
File input = getInArgumentPath(path);
if (!input.exists()) {
System.err.println("Resource folder " + input + " does not exist.");
System.exit(ERRNO_INVALID_ARGS);
}
List<File> resources = mFlags.getResourcesOverride();
if (resources == null) {
resources = new ArrayList<File>();
mFlags.setResourcesOverride(resources);
}
resources.add(input);
}
} else if (arg.equals(ARG_LIBRARIES)) {
if (index == args.length - 1) {
System.err.println("Missing library folder name");
System.exit(ERRNO_INVALID_ARGS);
}
String paths = args[++index];
for (String path : LintUtils.splitPath(paths)) {
File input = getInArgumentPath(path);
if (!input.exists()) {
System.err.println("Library " + input + " does not exist.");
System.exit(ERRNO_INVALID_ARGS);
}
List<File> libraries = mFlags.getLibrariesOverride();
if (libraries == null) {
libraries = new ArrayList<File>();
mFlags.setLibrariesOverride(libraries);
}
libraries.add(input);
}
} else if (arg.startsWith("--")) {
System.err.println("Invalid argument " + arg + "\n");
printUsage(System.err);
System.exit(ERRNO_INVALID_ARGS);
} else {
String filename = arg;
File file = getInArgumentPath(filename);
if (!file.exists()) {
System.err.println(String.format("%1$s does not exist.", filename));
System.exit(ERRNO_EXISTS);
}
files.add(file);
}
}
if (files.isEmpty()) {
System.err.println("No files to analyze.");
System.exit(ERRNO_INVALID_ARGS);
} else if (files.size() > 1
&& (mFlags.getClassesOverride() != null
|| mFlags.getSourcesOverride() != null
|| mFlags.getLibrariesOverride() != null
|| mFlags.getResourcesOverride() != null)) {
System.err.println(String.format(
"The %1$s, %2$s, %3$s and %4$s arguments can only be used with a single project",
ARG_SOURCES, ARG_CLASSES, ARG_LIBRARIES, ARG_RESOURCES));
System.exit(ERRNO_INVALID_ARGS);
}
List<Reporter> reporters = mFlags.getReporters();
if (reporters.isEmpty()) {
//noinspection VariableNotUsedInsideIf
if (urlMap != null) {
System.err.println(String.format(
"Warning: The %1$s option only applies to HTML reports (%2$s)",
ARG_URL, ARG_HTML));
}
reporters.add(new TextReporter(client, mFlags,
new PrintWriter(System.out, true), false));
} else {
//noinspection VariableNotUsedInsideIf
if (urlMap != null) {
for (Reporter reporter : reporters) {
if (!reporter.isSimpleFormat()) {
reporter.setBundleResources(true);
}
}
if (!urlMap.equals(VALUE_NONE)) {
Map<String, String> map = new HashMap<String, String>();
String[] replace = urlMap.split(","); //$NON-NLS-1$
for (String s : replace) {
// Allow ='s in the suffix part
int index = s.indexOf('=');
if (index == -1) {
System.err.println(
"The URL map argument must be of the form 'path_prefix=url_prefix'");
System.exit(ERRNO_INVALID_ARGS);
}
String key = s.substring(0, index);
String value = s.substring(index + 1);
map.put(key, value);
}
for (Reporter reporter : reporters) {
reporter.setUrlMap(map);
}
}
}
}
try {
// Not using mGlobalRegistry; LintClient will do its own registry merging
// also including project rules.
int exitCode = client.run(new BuiltinIssueRegistry(), files);
System.exit(exitCode);
} catch (IOException e) {
log(e, null);
System.exit(ERRNO_INVALID_ARGS);
}
}
private IssueRegistry getGlobalRegistry(LintCliClient client) {
if (mGlobalRegistry == null) {
mGlobalRegistry = client.addCustomLintRules(new BuiltinIssueRegistry());
}
return mGlobalRegistry;
}
/**
* Converts a relative or absolute command-line argument into an input file.
*
* @param filename The filename given as a command-line argument.
* @return A File matching filename, either absolute or relative to lint.workdir if defined.
*/
private static File getInArgumentPath(String filename) {
File file = new File(filename);
if (!file.isAbsolute()) {
File workDir = getLintWorkDir();
if (workDir != null) {
File file2 = new File(workDir, filename);
if (file2.exists()) {
try {
file = file2.getCanonicalFile();
} catch (IOException e) {
file = file2;
}
}
}
}
return file;
}
/**
* Converts a relative or absolute command-line argument into an output file.
* <p/>
* The difference with {@code getInArgumentPath} is that we can't check whether the
* a relative path turned into an absolute compared to lint.workdir actually exists.
*
* @param filename The filename given as a command-line argument.
* @return A File matching filename, either absolute or relative to lint.workdir if defined.
*/
private static File getOutArgumentPath(String filename) {
File file = new File(filename);
if (!file.isAbsolute()) {
File workDir = getLintWorkDir();
if (workDir != null) {
File file2 = new File(workDir, filename);
try {
file = file2.getCanonicalFile();
} catch (IOException e) {
file = file2;
}
}
}
return file;
}
/**
* Returns the File corresponding to the system property or the environment variable
* for {@link #PROP_WORK_DIR}.
* This property is typically set by the SDK/tools/lint[.bat] wrapper.
* It denotes the path where the command-line client was originally invoked from
* and can be used to convert relative input/output paths.
*
* @return A new File corresponding to {@link #PROP_WORK_DIR} or null.
*/
@Nullable
private static File getLintWorkDir() {
// First check the Java properties (e.g. set using "java -jar ... -Dname=value")
String path = System.getProperty(PROP_WORK_DIR);
if (path == null || path.isEmpty()) {
// If not found, check environment variables.
path = System.getenv(PROP_WORK_DIR);
}
if (path != null && !path.isEmpty()) {
return new File(path);
}
return null;
}
private static void printHelpTopicSuppress() {
System.out.println(wrap(TextFormat.RAW.convertTo(getSuppressHelp(), TextFormat.TEXT)));
}
static String getSuppressHelp() {
// \\u00a0 is a non-breaking space
final String NBSP = "\u00a0\u00a0\u00a0\u00a0";
return
"Lint errors can be suppressed in a variety of ways:\n" +
"\n" +
"1. With a `@SuppressLint` annotation in the Java code\n" +
"2. With a `tools:ignore` attribute in the XML file\n" +
"3. With ignore flags specified in the `build.gradle` file, " +
"as explained below\n" +
"4. With a `lint.xml` configuration file in the project\n" +
"5. With a `lint.xml` configuration file passed to lint " +
"via the " + ARG_CONFIG + " flag\n" +
"6. With the " + ARG_IGNORE + " flag passed to lint.\n" +
"\n" +
"To suppress a lint warning with an annotation, add " +
"a `@SuppressLint(\"id\")` annotation on the class, method " +
"or variable declaration closest to the warning instance " +
"you want to disable. The id can be one or more issue " +
"id's, such as `\"UnusedResources\"` or `{\"UnusedResources\"," +
"\"UnusedIds\"}`, or it can be `\"all\"` to suppress all lint " +
"warnings in the given scope.\n" +
"\n" +
"To suppress a lint warning in an XML file, add a " +
"`tools:ignore=\"id\"` attribute on the element containing " +
"the error, or one of its surrounding elements. You also " +
"need to define the namespace for the tools prefix on the " +
"root element in your document, next to the `xmlns:android` " +
"declaration:\n" +
"`xmlns:tools=\"http://schemas.android.com/tools\"`\n" +
"\n" +
"To suppress a lint warning in a `build.gradle` file, add a " +
"section like this:\n" +
"\n" +
"android {\n" +
NBSP + "lintOptions {\n" +
NBSP + NBSP + "disable 'TypographyFractions','TypographyQuotes'\n" +
NBSP + "}\n" +
"}\n" +
"\n" +
"Here we specify a comma separated list of issue id's after the " +
"disable command. You can also use `warning` or `error` instead " +
"of `disable` to change the severity of issues.\n" +
"\n" +
"To suppress lint warnings with a configuration XML file, " +
"create a file named `lint.xml` and place it at the root " +
"directory of the project in which it applies.\n" +
"\n" +
"The format of the `lint.xml` file is something like the " +
"following:\n" +
"\n" +
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<lint>\n" +
NBSP + "<!-- Disable this given check in this project -->\n" +
NBSP + "<issue id=\"IconMissingDensityFolder\" severity=\"ignore\" />\n" +
"\n" +
NBSP + "<!-- Ignore the ObsoleteLayoutParam issue in the given files -->\n" +
NBSP + "<issue id=\"ObsoleteLayoutParam\">\n" +
NBSP + NBSP + "<ignore path=\"res/layout/activation.xml\" />\n" +
NBSP + NBSP + "<ignore path=\"res/layout-xlarge/activation.xml\" />\n" +
NBSP + "</issue>\n" +
"\n" +
NBSP + "<!-- Ignore the UselessLeaf issue in the given file -->\n" +
NBSP + "<issue id=\"UselessLeaf\">\n" +
NBSP + NBSP + "<ignore path=\"res/layout/main.xml\" />\n" +
NBSP + "</issue>\n" +
"\n" +
NBSP + "<!-- Change the severity of hardcoded strings to \"error\" -->\n" +
NBSP + "<issue id=\"HardcodedText\" severity=\"error\" />\n" +
"</lint>\n" +
"\n" +
"To suppress lint checks from the command line, pass the " + ARG_IGNORE + " " +
"flag with a comma separated list of ids to be suppressed, such as:\n" +
"`$ lint --ignore UnusedResources,UselessLeaf /my/project/path`\n" +
"\n" +
"For more information, see " +
"http://g.co/androidstudio/suppressing-lint-warnings\n";
}
private static void printVersion(LintCliClient client) {
String revision = client.getRevision();
if (revision != null) {
System.out.println(String.format("lint: version %1$s", revision));
} else {
System.out.println("lint: unknown version");
}
}
private static void displayValidIds(IssueRegistry registry, PrintStream out) {
List<Category> categories = registry.getCategories();
out.println("Valid issue categories:");
for (Category category : categories) {
out.println(" " + category.getFullName());
}
out.println();
List<Issue> issues = registry.getIssues();
out.println("Valid issue id's:");
for (Issue issue : issues) {
listIssue(out, issue);
}
}
private static void listIssue(PrintStream out, Issue issue) {
out.print(wrapArg("\"" + issue.getId() + "\": " + issue.getBriefDescription(TEXT)));
}
private static void showIssues(IssueRegistry registry) {
List<Issue> issues = registry.getIssues();
List<Issue> sorted = new ArrayList<Issue>(issues);
Collections.sort(sorted, new Comparator<Issue>() {
@Override
public int compare(Issue issue1, Issue issue2) {
int d = issue1.getCategory().compareTo(issue2.getCategory());
if (d != 0) {
return d;
}
d = issue2.getPriority() - issue1.getPriority();
if (d != 0) {
return d;
}
return issue1.getId().compareTo(issue2.getId());
}
});
System.out.println("Available issues:\n");
Category previousCategory = null;
for (Issue issue : sorted) {
Category category = issue.getCategory();
if (!category.equals(previousCategory)) {
String name = category.getFullName();
System.out.println(name);
for (int i = 0, n = name.length(); i < n; i++) {
System.out.print('=');
}
System.out.println('\n');
previousCategory = category;
}
describeIssue(issue);
System.out.println();
}
}
private static void describeIssue(Issue issue) {
System.out.println(issue.getId());
for (int i = 0; i < issue.getId().length(); i++) {
System.out.print('-');
}
System.out.println();
System.out.println(wrap("Summary: " + issue.getBriefDescription(TEXT)));
System.out.println("Priority: " + issue.getPriority() + " / 10");
System.out.println("Severity: " + issue.getDefaultSeverity().getDescription());
System.out.println("Category: " + issue.getCategory().getFullName());
if (!issue.isEnabledByDefault()) {
System.out.println("NOTE: This issue is disabled by default!");
System.out.println(String.format("You can enable it by adding %1$s %2$s", ARG_ENABLE,
issue.getId()));
}
System.out.println();
System.out.println(wrap(issue.getExplanation(TEXT)));
List<String> moreInfo = issue.getMoreInfo();
if (!moreInfo.isEmpty()) {
System.out.println("More information: ");
for (String uri : moreInfo) {
System.out.println(uri);
}
}
}
static String wrapArg(String explanation) {
// Wrap arguments such that the wrapped lines are not showing up in the left column
return wrap(explanation, MAX_LINE_WIDTH, " ");
}
static String wrap(String explanation) {
return wrap(explanation, MAX_LINE_WIDTH, "");
}
static String wrap(String explanation, int lineWidth, String hangingIndent) {
return SdkUtils.wrap(explanation, lineWidth, hangingIndent);
}
private static void printUsage(PrintStream out) {
// TODO: Look up launcher script name!
String command = "lint"; //$NON-NLS-1$
out.println("Usage: " + command + " [flags] <project directories>\n");
out.println("Flags:\n");
printUsage(out, new String[] {
ARG_HELP, "This message.",
ARG_HELP + " <topic>", "Help on the given topic, such as \"suppress\".",
ARG_LIST_IDS, "List the available issue id's and exit.",
ARG_VERSION, "Output version information and exit.",
ARG_EXIT_CODE, "Set the exit code to " + ERRNO_ERRORS + " if errors are found.",
ARG_SHOW, "List available issues along with full explanations.",
ARG_SHOW + " <ids>", "Show full explanations for the given list of issue id's.",
"", "\nEnabled Checks:",
ARG_DISABLE + " <list>", "Disable the list of categories or " +
"specific issue id's. The list should be a comma-separated list of issue " +
"id's or categories.",
ARG_ENABLE + " <list>", "Enable the specific list of issues. " +
"This checks all the default issues plus the specifically enabled issues. The " +
"list should be a comma-separated list of issue id's or categories.",
ARG_CHECK + " <list>", "Only check the specific list of issues. " +
"This will disable everything and re-enable the given list of issues. " +
"The list should be a comma-separated list of issue id's or categories.",
ARG_NO_WARN_1 + ", " + ARG_NO_WARN_2, "Only check for errors (ignore warnings)",
ARG_WARN_ALL, "Check all warnings, including those off by default",
ARG_ALL_ERROR, "Treat all warnings as errors",
ARG_CONFIG + " <filename>", "Use the given configuration file to " +
"determine whether issues are enabled or disabled. If a project contains " +
"a lint.xml file, then this config file will be used as a fallback.",
"", "\nOutput Options:",
ARG_QUIET, "Don't show progress.",
ARG_FULL_PATH, "Use full paths in the error output.",
ARG_SHOW_ALL, "Do not truncate long messages, lists of alternate locations, etc.",
ARG_NO_LINES, "Do not include the source file lines with errors " +
"in the output. By default, the error output includes snippets of source code " +
"on the line containing the error, but this flag turns it off.",
ARG_HTML + " <filename>", "Create an HTML report instead. If the filename is a " +
"directory (or a new filename without an extension), lint will create a " +
"separate report for each scanned project.",
ARG_URL + " filepath=url", "Add links to HTML report, replacing local " +
"path prefixes with url prefix. The mapping can be a comma-separated list of " +
"path prefixes to corresponding URL prefixes, such as " +
"C:\\temp\\Proj1=http://buildserver/sources/temp/Proj1. To turn off linking " +
"to files, use " + ARG_URL + " " + VALUE_NONE,
ARG_SIMPLE_HTML + " <filename>", "Create a simple HTML report",
ARG_XML + " <filename>", "Create an XML report instead.",
"", "\nProject Options:",
ARG_RESOURCES + " <dir>", "Add the given folder (or path) as a resource directory " +
"for the project. Only valid when running lint on a single project.",
ARG_SOURCES + " <dir>", "Add the given folder (or path) as a source directory for " +
"the project. Only valid when running lint on a single project.",
ARG_CLASSES + " <dir>", "Add the given folder (or jar file, or path) as a class " +
"directory for the project. Only valid when running lint on a single project.",
ARG_LIBRARIES + " <dir>", "Add the given folder (or jar file, or path) as a class " +
"library for the project. Only valid when running lint on a single project.",
"", "\nExit Status:",
"0", "Success.",
Integer.toString(ERRNO_ERRORS), "Lint errors detected.",
Integer.toString(ERRNO_USAGE), "Lint usage.",
Integer.toString(ERRNO_EXISTS), "Cannot clobber existing file.",
Integer.toString(ERRNO_HELP), "Lint help.",
Integer.toString(ERRNO_INVALID_ARGS), "Invalid command-line argument.",
});
}
private static void printUsage(PrintStream out, String[] args) {
int argWidth = 0;
for (int i = 0; i < args.length; i += 2) {
String arg = args[i];
argWidth = Math.max(argWidth, arg.length());
}
argWidth += 2;
StringBuilder sb = new StringBuilder(20);
for (int i = 0; i < argWidth; i++) {
sb.append(' ');
}
String indent = sb.toString();
String formatString = "%1$-" + argWidth + "s%2$s"; //$NON-NLS-1$
for (int i = 0; i < args.length; i += 2) {
String arg = args[i];
String description = args[i + 1];
if (arg.isEmpty()) {
out.println(description);
} else {
out.print(wrap(String.format(formatString, arg, description),
MAX_LINE_WIDTH, indent));
}
}
}
public void log(
@Nullable Throwable exception,
@Nullable String format,
@Nullable Object... args) {
System.out.flush();
if (!mFlags.isQuiet()) {
// Place the error message on a line of its own since we're printing '.' etc
// with newlines during analysis
System.err.println();
}
if (format != null) {
System.err.println(String.format(format, args));
}
if (exception != null) {
exception.printStackTrace();
}
}
}