Reporter.java

/*
 * 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.CURRENT_PLATFORM;
import static com.android.SdkConstants.DOT_9PNG;
import static com.android.SdkConstants.DOT_PNG;
import static com.android.SdkConstants.PLATFORM_LINUX;
import static com.android.SdkConstants.UTF_8;
import static com.android.tools.lint.detector.api.LintUtils.endsWith;
import static java.io.File.separatorChar;

import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.tools.lint.checks.AccessibilityDetector;
import com.android.tools.lint.checks.AlwaysShowActionDetector;
import com.android.tools.lint.checks.ApiDetector;
import com.android.tools.lint.checks.AppCompatCallDetector;
import com.android.tools.lint.checks.ByteOrderMarkDetector;
import com.android.tools.lint.checks.CommentDetector;
import com.android.tools.lint.checks.DetectMissingPrefix;
import com.android.tools.lint.checks.DosLineEndingDetector;
import com.android.tools.lint.checks.DuplicateResourceDetector;
import com.android.tools.lint.checks.GradleDetector;
import com.android.tools.lint.checks.GridLayoutDetector;
import com.android.tools.lint.checks.HardcodedValuesDetector;
import com.android.tools.lint.checks.IncludeDetector;
import com.android.tools.lint.checks.InefficientWeightDetector;
import com.android.tools.lint.checks.JavaPerformanceDetector;
import com.android.tools.lint.checks.ManifestDetector;
import com.android.tools.lint.checks.MissingClassDetector;
import com.android.tools.lint.checks.MissingIdDetector;
import com.android.tools.lint.checks.NamespaceDetector;
import com.android.tools.lint.checks.ObsoleteLayoutParamsDetector;
import com.android.tools.lint.checks.PropertyFileDetector;
import com.android.tools.lint.checks.PxUsageDetector;
import com.android.tools.lint.checks.ScrollViewChildDetector;
import com.android.tools.lint.checks.SecurityDetector;
import com.android.tools.lint.checks.SharedPrefsDetector;
import com.android.tools.lint.checks.SignatureOrSystemDetector;
import com.android.tools.lint.checks.SupportAnnotationDetector;
import com.android.tools.lint.checks.TextFieldDetector;
import com.android.tools.lint.checks.TextViewDetector;
import com.android.tools.lint.checks.TitleDetector;
import com.android.tools.lint.checks.TranslationDetector;
import com.android.tools.lint.checks.TypoDetector;
import com.android.tools.lint.checks.TypographyDetector;
import com.android.tools.lint.checks.UseCompoundDrawableDetector;
import com.android.tools.lint.checks.UselessViewDetector;
import com.android.tools.lint.checks.Utf8Detector;
import com.android.tools.lint.checks.WrongCallDetector;
import com.android.tools.lint.checks.WrongCaseDetector;
import com.android.tools.lint.detector.api.Issue;
import com.android.utils.SdkUtils;
import com.google.common.annotations.Beta;
import com.google.common.collect.Sets;
import com.google.common.io.ByteStreams;
import com.google.common.io.Closer;
import com.google.common.io.Files;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

/** A reporter is an output generator for lint warnings
 * <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 abstract class Reporter {
    protected final LintCliClient mClient;
    protected final File mOutput;
    protected String mTitle = "Lint Report";
    protected boolean mSimpleFormat;
    protected boolean mBundleResources;
    protected Map<String, String> mUrlMap;
    protected File mResources;
    protected final Map<File, String> mResourceUrl = new HashMap<File, String>();
    protected final Map<String, File> mNameToFile = new HashMap<String, File>();
    protected boolean mDisplayEmpty = true;

    /**
     * Write the given warnings into the report
     *
     * @param errorCount the number of errors
     * @param warningCount the number of warnings
     * @param issues the issues to be reported
     * @throws IOException if an error occurs
     */
    public abstract void write(int errorCount, int warningCount, List<Warning> issues)
            throws IOException;

    protected Reporter(LintCliClient client, File output) {
        mClient = client;
        mOutput = output;
    }

    /**
     * Sets the report title
     *
     * @param title the title of the report
     */
    public void setTitle(String title) {
        mTitle = title;
    }

    /** @return the title of the report */
    public String getTitle() {
        return mTitle;
    }

    /**
     * Sets whether the report should bundle up resources along with the HTML report.
     * This implies a non-simple format (see {@link #setSimpleFormat(boolean)}).
     *
     * @param bundleResources if true, copy images into a directory relative to
     *            the report
     */
    public void setBundleResources(boolean bundleResources) {
        mBundleResources = bundleResources;
        mSimpleFormat = false;
    }

    /**
     * Sets whether the report should use simple formatting (meaning no JavaScript,
     * embedded images, etc).
     *
     * @param simpleFormat whether the formatting should be simple
     */
    public void setSimpleFormat(boolean simpleFormat) {
        mSimpleFormat = simpleFormat;
    }

    /**
     * Returns whether the report should use simple formatting (meaning no JavaScript,
     * embedded images, etc).
     *
     * @return whether the report should use simple formatting
     */
    public boolean isSimpleFormat() {
        return mSimpleFormat;
    }


    String getUrl(File file) {
        if (mBundleResources && !mSimpleFormat) {
            String url = getRelativeResourceUrl(file);
            if (url != null) {
                return url;
            }
        }

        if (mUrlMap != null) {
            String path = file.getAbsolutePath();
            // Perform the comparison using URLs such that we properly escape spaces etc.
            String pathUrl = encodeUrl(path);
            for (Map.Entry<String, String> entry : mUrlMap.entrySet()) {
                String prefix = entry.getKey();
                String prefixUrl = encodeUrl(prefix);
                if (pathUrl.startsWith(prefixUrl)) {
                    String relative = pathUrl.substring(prefixUrl.length());
                    return entry.getValue() + relative;
                }
            }
        }

        if (file.isAbsolute()) {
            String relativePath = getRelativePath(mOutput.getParentFile(), file);
            if (relativePath != null) {
                relativePath = relativePath.replace(separatorChar, '/');
                return encodeUrl(relativePath);
            }
        }

        try {
            return SdkUtils.fileToUrlString(file);
        } catch (MalformedURLException e) {
            return null;
        }
    }

    /** Encodes the given String as a safe URL substring, escaping spaces etc */
    static String encodeUrl(String url) {
        try {
            url = url.replace('\\', '/');
            return URLEncoder.encode(url, UTF_8).replace("%2F", "/");         //$NON-NLS-1$
        } catch (UnsupportedEncodingException e) {
            // This shouldn't happen for UTF-8
            System.err.println("Invalid string " + e.getLocalizedMessage());
            return url;
        }
    }

    /** Set mapping of path prefixes to corresponding URLs in the HTML report */
    public void setUrlMap(@Nullable Map<String, String> urlMap) {
        mUrlMap = urlMap;
    }

    /** Gets a pointer to the local resource directory, if any */
    File getResourceDir() {
        if (mResources == null && mBundleResources) {
            mResources = computeResourceDir();
            if (mResources == null) {
                mBundleResources = false;
            }
        }

        return mResources;
    }

    /** Finds/creates the local resource directory, if possible */
    File computeResourceDir() {
        String fileName = mOutput.getName();
        int dot = fileName.indexOf('.');
        if (dot != -1) {
            fileName = fileName.substring(0, dot);
        }

        File resources = new File(mOutput.getParentFile(), fileName + "_files"); //$NON-NLS-1$
        if (!resources.exists() && !resources.mkdir()) {
            resources = null;
        }

        return resources;
    }

    /** Returns a URL to a local copy of the given file, or null */
    protected String getRelativeResourceUrl(File file) {
        String resource = mResourceUrl.get(file);
        if (resource != null) {
            return resource;
        }

        String name = file.getName();
        if (!endsWith(name, DOT_PNG) || endsWith(name, DOT_9PNG)) {
            return null;
        }

        // Attempt to make local copy
        File resourceDir = getResourceDir();
        if (resourceDir != null) {
            String base = file.getName();

            File path = mNameToFile.get(base);
            if (path != null && !path.equals(file)) {
                // That filename already exists and is associated with a different path:
                // make a new unique version
                for (int i = 0; i < 100; i++) {
                    base = '_' + base;
                    path = mNameToFile.get(base);
                    if (path == null || path.equals(file)) {
                        break;
                    }
                }
            }

            File target = new File(resourceDir, base);
            try {
                Files.copy(file, target);
            } catch (IOException e) {
                return null;
            }
            return resourceDir.getName() + '/' + encodeUrl(base);
        }
        return null;
    }

    /** Returns a URL to a local copy of the given resource, or null. There is
     * no filename conflict resolution. */
    protected String addLocalResources(URL url) throws IOException {
        // Attempt to make local copy
        File resourceDir = computeResourceDir();
        if (resourceDir != null) {
            String base = url.getFile();
            base = base.substring(base.lastIndexOf('/') + 1);
            mNameToFile.put(base, new File(url.toExternalForm()));

            File target = new File(resourceDir, base);
            Closer closer = Closer.create();
            try {
                FileOutputStream output = closer.register(new FileOutputStream(target));
                InputStream input = closer.register(url.openStream());
                ByteStreams.copy(input, output);
            } catch (Throwable e) {
                closer.rethrow(e);
            } finally {
                closer.close();
            }
            return resourceDir.getName() + '/' + encodeUrl(base);
        }
        return null;
    }

    // Based on similar code in com.intellij.openapi.util.io.FileUtilRt
    @Nullable
    static String getRelativePath(File base, File file) {
        if (base == null || file == null) {
            return null;
        }
        if (!base.isDirectory()) {
            base = base.getParentFile();
            if (base == null) {
                return null;
            }
        }
        if (base.equals(file)) {
            return ".";
        }

        final String filePath = file.getAbsolutePath();
        String basePath = base.getAbsolutePath();

        // TODO: Make this return null if we go all the way to the root!

        basePath = !basePath.isEmpty() && basePath.charAt(basePath.length() - 1) == separatorChar
                ? basePath : basePath + separatorChar;

        // Whether filesystem is case sensitive. Technically on OSX you could create a
        // sensitive one, but it's not the default.
        boolean caseSensitive = CURRENT_PLATFORM == PLATFORM_LINUX;
        Locale l = Locale.getDefault();
        String basePathToCompare = caseSensitive ? basePath : basePath.toLowerCase(l);
        String filePathToCompare = caseSensitive ? filePath : filePath.toLowerCase(l);
        if (basePathToCompare.equals(!filePathToCompare.isEmpty()
                && filePathToCompare.charAt(filePathToCompare.length() - 1) == separatorChar
                ? filePathToCompare : filePathToCompare + separatorChar)) {
            return ".";
        }
        int len = 0;
        int lastSeparatorIndex = 0;
        // bug in inspection; see http://youtrack.jetbrains.com/issue/IDEA-118971
        //noinspection ConstantConditions
        while (len < filePath.length() && len < basePath.length()
                && filePathToCompare.charAt(len) == basePathToCompare.charAt(len)) {
            if (basePath.charAt(len) == separatorChar) {
                lastSeparatorIndex = len;
            }
            len++;
        }
        if (len == 0) {
            return null;
        }

        StringBuilder relativePath = new StringBuilder();
        for (int i = len; i < basePath.length(); i++) {
            if (basePath.charAt(i) == separatorChar) {
                relativePath.append("..");
                relativePath.append(separatorChar);
            }
        }
        relativePath.append(filePath.substring(lastSeparatorIndex + 1));
        return relativePath.toString();
    }

    /**
     * Returns whether this report should display info (such as a path to the report) if
     * no issues were found
     */
    public boolean isDisplayEmpty() {
        return mDisplayEmpty;
    }

    /**
     * Sets whether this report should display info (such as a path to the report) if
     * no issues were found
     */
    public void setDisplayEmpty(boolean displayEmpty) {
        mDisplayEmpty = displayEmpty;
    }

    private static Set<Issue> sAdtFixes;
    private static Set<Issue> sStudioFixes;

    /** Tools known to have quickfixes for lint */
    enum QuickfixHandler {
        /** Android Studio or IntelliJ */
        STUDIO,
        /** Eclipse */
        ADT;

        public boolean hasAutoFix(Issue issue) {
            return Reporter.hasAutoFix(this, issue);
        }
    }

    /**
     * Returns true if the given issue has an automatic IDE fix.
     *
     * @param tool the name of the tool to be checked
     * @param issue the issue to be checked
     * @return true if the given tool is known to have an automatic fix for the
     *         given issue
     */
    public static boolean hasAutoFix(@NonNull QuickfixHandler tool, Issue issue) {
        if (tool == QuickfixHandler.ADT) {
            if (sAdtFixes == null) {
                sAdtFixes = Sets.newHashSet(
                        InefficientWeightDetector.INEFFICIENT_WEIGHT,
                        AccessibilityDetector.ISSUE,
                        InefficientWeightDetector.BASELINE_WEIGHTS,
                        HardcodedValuesDetector.ISSUE,
                        UselessViewDetector.USELESS_LEAF,
                        UselessViewDetector.USELESS_PARENT,
                        PxUsageDetector.PX_ISSUE,
                        TextFieldDetector.ISSUE,
                        SecurityDetector.EXPORTED_SERVICE,
                        DetectMissingPrefix.MISSING_NAMESPACE,
                        ScrollViewChildDetector.ISSUE,
                        ObsoleteLayoutParamsDetector.ISSUE,
                        TypographyDetector.DASHES,
                        TypographyDetector.ELLIPSIS,
                        TypographyDetector.FRACTIONS,
                        TypographyDetector.OTHER,
                        TypographyDetector.QUOTES,
                        UseCompoundDrawableDetector.ISSUE,
                        ApiDetector.UNSUPPORTED,
                        ApiDetector.INLINED,
                        TypoDetector.ISSUE,
                        ManifestDetector.ALLOW_BACKUP,
                        MissingIdDetector.ISSUE,
                        TranslationDetector.MISSING,
                        DosLineEndingDetector.ISSUE
                );
            }
            return sAdtFixes.contains(issue);
        } else if (tool == QuickfixHandler.STUDIO) {
            // List generated by AndroidLintInspectionToolProviderTest in tools/adt/idea;
            // set LIST_ISSUES_WITH_QUICK_FIXES to true
            if (sStudioFixes == null) {
                sStudioFixes = Sets.newHashSet(
                        AccessibilityDetector.ISSUE,
                        AlwaysShowActionDetector.ISSUE,
                        ApiDetector.INLINED,
                        ApiDetector.UNSUPPORTED,
                        AppCompatCallDetector.ISSUE,
                        ByteOrderMarkDetector.BOM,
                        CommentDetector.STOP_SHIP,
                        DetectMissingPrefix.MISSING_NAMESPACE,
                        DuplicateResourceDetector.TYPE_MISMATCH,
                        GradleDetector.COMPATIBILITY,
                        GradleDetector.DEPENDENCY,
                        GradleDetector.DEPRECATED,
                        GradleDetector.PLUS,
                        GradleDetector.REMOTE_VERSION,
                        GradleDetector.STRING_INTEGER,
                        GridLayoutDetector.ISSUE,
                        IncludeDetector.ISSUE,
                        InefficientWeightDetector.BASELINE_WEIGHTS,
                        InefficientWeightDetector.INEFFICIENT_WEIGHT,
                        InefficientWeightDetector.ORIENTATION,
                        JavaPerformanceDetector.USE_VALUE_OF,
                        ManifestDetector.ALLOW_BACKUP,
                        ManifestDetector.APPLICATION_ICON,
                        ManifestDetector.MIPMAP,
                        ManifestDetector.MOCK_LOCATION,
                        ManifestDetector.TARGET_NEWER,
                        MissingClassDetector.INNERCLASS,
                        MissingIdDetector.ISSUE,
                        NamespaceDetector.RES_AUTO,
                        ObsoleteLayoutParamsDetector.ISSUE,
                        PropertyFileDetector.ESCAPE,
                        PropertyFileDetector.HTTP,
                        PxUsageDetector.DP_ISSUE,
                        PxUsageDetector.PX_ISSUE,
                        ScrollViewChildDetector.ISSUE,
                        SecurityDetector.EXPORTED_SERVICE,
                        SharedPrefsDetector.ISSUE,
                        SignatureOrSystemDetector.ISSUE,
                        SupportAnnotationDetector.CHECK_PERMISSION,
                        SupportAnnotationDetector.CHECK_RESULT,
                        TextFieldDetector.ISSUE,
                        TextViewDetector.SELECTABLE,
                        TitleDetector.ISSUE,
                        TypoDetector.ISSUE,
                        TypographyDetector.DASHES,
                        TypographyDetector.ELLIPSIS,
                        TypographyDetector.FRACTIONS,
                        TypographyDetector.OTHER,
                        TypographyDetector.QUOTES,
                        UselessViewDetector.USELESS_LEAF,
                        Utf8Detector.ISSUE,
                        WrongCallDetector.ISSUE,
                        WrongCaseDetector.WRONG_CASE
                );
            }
            return sStudioFixes.contains(issue);
        }

        return false;
    }
}