lint/libs/lint-checks/src/main/java/com/android/tools/lint/checks/TypoDetector.java - platform/tools/base - Git at Google

 /*
  * 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_LOCALE;
 import static com.android.SdkConstants.ATTR_TRANSLATABLE;
 import static com.android.SdkConstants.FD_RES_VALUES;
 import static com.android.SdkConstants.TAG_PLURALS;
 import static com.android.SdkConstants.TAG_STRING;
 import static com.android.SdkConstants.TAG_STRING_ARRAY;
 import static com.android.SdkConstants.TOOLS_URI;
 import static com.android.tools.lint.checks.TypoLookup.isLetter;
 import static com.google.common.base.Objects.equal;

 import com.android.annotations.NonNull;
 import com.android.annotations.Nullable;
 import com.android.ide.common.resources.configuration.LocaleQualifier;
 import com.android.resources.ResourceFolderType;
 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.LintUtils;
 import com.android.tools.lint.detector.api.Location;
 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.Speed;
 import com.android.tools.lint.detector.api.TextFormat;
 import com.android.tools.lint.detector.api.XmlContext;
 import com.google.common.base.Charsets;

 import org.w3c.dom.Attr;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;

 /**
  * Check which looks for likely typos in Strings.
  * <p>
  * TODO:
  * <ul>
  * <li> Add check of Java String literals too!
  * <li> Add support for <b>additional</b> languages. The typo detector is now
  *      multilingual and looks for typos-*locale*.txt files to use. However,
  *      we need to seed it with additional typo databases. I did some searching
  *      and came up with some alternatives. Here's the strategy I used:
  *      Used Google Translate to translate "Wikipedia Common Misspellings", and
  *      then I went to google.no, google.fr etc searching with that translation, and
  *      came up with what looks like wikipedia language local lists of typos.
  *      This is how I found the Norwegian one for example:
  *      <br>
  *         http://no.wikipedia.org/wiki/Wikipedia:Liste_over_alminnelige_stavefeil/Maskinform
  *      <br>
  *     Here are some additional possibilities not yet processed:
  *      <ul>
  *        <li> French: http://fr.wikipedia.org/wiki/Wikip%C3%A9dia:Liste_de_fautes_d'orthographe_courantes
  *            (couldn't find a machine-readable version there?)
  *         <li> Swedish:
  *              http://sv.wikipedia.org/wiki/Wikipedia:Lista_%C3%B6ver_vanliga_spr%C3%A5kfel
  *              (couldn't find a machine-readable version there?)
  *        <li> German
  *              http://de.wikipedia.org/wiki/Wikipedia:Liste_von_Tippfehlern/F%C3%BCr_Maschinen
  *       </ul>
  * <li> Consider also digesting files like
  *       http://sv.wikipedia.org/wiki/Wikipedia:AutoWikiBrowser/Typos
  *       See http://en.wikipedia.org/wiki/Wikipedia:AutoWikiBrowser/User_manual.
  * </ul>
  */
 public class TypoDetector extends ResourceXmlDetector {
     @Nullable private TypoLookup mLookup;
     @Nullable private String mLastLanguage;
     @Nullable private String mLastRegion;
     @Nullable private String mLanguage;
     @Nullable private String mRegion;

     /** The main issue discovered by this detector */
     public static final Issue ISSUE = Issue.create(
             "Typos", //$NON-NLS-1$
             "Spelling error",

             "This check looks through the string definitions, and if it finds any words " +
             "that look like likely misspellings, they are flagged.",
             Category.MESSAGES,
             7,
             Severity.WARNING,
             new Implementation(
                     TypoDetector.class,
                     Scope.RESOURCE_FILE_SCOPE));

     /** Constructs a new detector */
     public TypoDetector() {
     }

     @Override
     public boolean appliesTo(@NonNull ResourceFolderType folderType) {
         return folderType == ResourceFolderType.VALUES;
     }

     /** Look up the locale and region from the given parent folder name and store it
      * in {@link #mLanguage} and {@link #mRegion} */
     private void initLocale(@NonNull String parent) {
         mLanguage = null;
         mRegion = null;

         if (parent.equals(FD_RES_VALUES)) {
             return;
         }

         LocaleQualifier locale = LintUtils.getLocale(parent);
         if (locale != null) {
             mLanguage = locale.getLanguage();
             mRegion = locale.hasRegion() ? locale.getRegion() : null;
         }
     }

     @Override
     public void beforeCheckFile(@NonNull Context context) {
         initLocale(context.file.getParentFile().getName());
         if (mLanguage == null) {
             // Check to see if the user has specified the language for this folder
             // using a tools:locale attribute
             if (context instanceof XmlContext) {
                 Element root = ((XmlContext) context).document.getDocumentElement();
                 if (root != null) {
                     String locale = root.getAttributeNS(TOOLS_URI, ATTR_LOCALE);
                     if (locale != null && !locale.isEmpty()) {
                         initLocale(FD_RES_VALUES + '-' + locale);
                     }
                 }
             }

             if (mLanguage == null) {
                 mLanguage = "en"; //$NON-NLS-1$
             }
         }

         if (!equal(mLastLanguage, mLanguage) || !equal(mLastRegion, mRegion)) {
             mLookup = TypoLookup.get(context.getClient(), mLanguage, mRegion);
             mLastLanguage = mLanguage;
             mLastRegion = mRegion;
         }
     }

     @NonNull
     @Override
     public Speed getSpeed() {
         return Speed.NORMAL;
     }

     @Override
     public Collection<String> getApplicableElements() {
         return Arrays.asList(
                 TAG_STRING,
                 TAG_STRING_ARRAY,
                 TAG_PLURALS
         );
     }

     @Override
     public void visitElement(@NonNull XmlContext context, @NonNull Element element) {
         if (mLookup == null) {
             return;
         }

         visit(context, element, element);
     }

     private void visit(XmlContext context, Element parent, Node node) {
         if (node.getNodeType() == Node.TEXT_NODE) {
             // TODO: Figure out how to deal with entities
             check(context, parent, node, node.getNodeValue());
         } else {
             NodeList children = node.getChildNodes();
             for (int i = 0, n = children.getLength(); i < n; i++) {
                 visit(context, parent, children.item(i));
             }
         }
     }

     private void check(XmlContext context, Element element, Node node, String text) {
         int max = text.length();
         int index = 0;
         int lastWordBegin = -1;
         int lastWordEnd = -1;
         boolean checkedTypos = false;

         for (; index < max; index++) {
             char c = text.charAt(index);
             if (!Character.isWhitespace(c)) {
                 if (c == '@' || (c == '?')) {
                     // Don't look for typos in resource references; they are not
                     // user visible anyway
                     return;
                 }
                 break;
             }
         }

         while (index < max) {
             for (; index < max; index++) {
                 char c = text.charAt(index);
                 if (c == '\\') {
                     index++;
                 } else if (Character.isLetter(c)) {
                     break;
                 }
             }
             if (index >= max) {
                 return;
             }
             int begin = index;
             for (; index < max; index++) {
                 char c = text.charAt(index);
                 if (c == '\\') {
                     index++;
                     break;
                 } else if (!Character.isLetter(c)) {
                     break;
                 } else if (text.charAt(index) >= 0x80) {
                     // Switch to UTF-8 handling for this string
                     if (checkedTypos) {
                         // If we've already checked words we may have reported typos
                         // so create a substring from the current word and on.
                         byte[] utf8Text = text.substring(begin).getBytes(Charsets.UTF_8);
                         check(context, element, node, utf8Text, 0, utf8Text.length, text, begin);
                     } else {
                         // If all we've done so far is skip whitespace (common scenario)
                         // then no need to substring the text, just re-search with the
                         // UTF-8 routines
                         byte[] utf8Text = text.getBytes(Charsets.UTF_8);
                         check(context, element, node, utf8Text, 0, utf8Text.length, text, 0);
                     }
                     return;
                 }
             }

             int end = index;
             checkedTypos = true;
             assert mLookup != null;
             List<String> replacements = mLookup.getTypos(text, begin, end);
             if (replacements != null && isTranslatable(element)) {
                 reportTypo(context, node, text, begin, replacements);
             }

             checkRepeatedWords(context, element, node, text, lastWordBegin, lastWordEnd, begin,
                     end);

             lastWordBegin = begin;
             lastWordEnd = end;
             index = end + 1;
         }
     }

     private static void checkRepeatedWords(XmlContext context, Element element, Node node,
             String text, int lastWordBegin, int lastWordEnd, int begin, int end) {
         if (lastWordBegin != -1 && end - begin == lastWordEnd - lastWordBegin
                 && end - begin > 1) {
             // See whether we have a repeated word
             boolean different = false;
             for (int i = lastWordBegin, j = begin; i < lastWordEnd; i++, j++) {
                 if (text.charAt(i) != text.charAt(j)) {
                     different = true;
                     break;
                 }
             }
             if (!different && onlySpace(text, lastWordEnd, begin) && isTranslatable(element)) {
                 reportRepeatedWord(context, node, text, lastWordBegin, begin, end);
             }
         }
     }

     private static boolean onlySpace(String text, int fromInclusive, int toExclusive) {
         for (int i = fromInclusive; i < toExclusive; i++) {
             if (!Character.isWhitespace(text.charAt(i))) {
                 return false;
             }
         }

         return true;
     }

     private void check(XmlContext context, Element element, Node node, byte[] utf8Text,
             int byteStart, int byteEnd, String text, int charStart) {
         int lastWordBegin = -1;
         int lastWordEnd = -1;
         int index = byteStart;
         while (index < byteEnd) {
             // Find beginning of word
             while (index < byteEnd) {
                 byte b = utf8Text[index];
                 if (b == '\\') {
                     index++;
                     charStart++;
                     if (index < byteEnd) {
                         b = utf8Text[index];
                     }
                 } else if (isLetter(b)) {
                     break;
                 }
                 index++;
                 if ((b & 0x80) == 0 || (b & 0xC0) == 0xC0) {
                     // First characters in UTF-8 are always ASCII (0 high bit) or 11XXXXXX
                     charStart++;
                 }
             }

             if (index >= byteEnd) {
                 return;
             }
             int charEnd = charStart;
             int begin = index;

             // Find end of word. Unicode has the nice property that even 2nd, 3rd and 4th
             // bytes won't match these ASCII characters (because the high bit must be set there)
             while (index < byteEnd) {
                 byte b = utf8Text[index];
                 if (b == '\\') {
                     index++;
                     charEnd++;
                     if (index < byteEnd) {
                         b = utf8Text[index++];
                         if ((b & 0x80) == 0 || (b & 0xC0) == 0xC0) {
                             charEnd++;
                         }
                     }
                     break;
                 } else if (!isLetter(b)) {
                     break;
                 }
                 index++;
                 if ((b & 0x80) == 0 || (b & 0xC0) == 0xC0) {
                     // First characters in UTF-8 are always ASCII (0 high bit) or 11XXXXXX
                     charEnd++;
                 }
             }

             int end = index;
             List<String> replacements = mLookup.getTypos(utf8Text, begin, end);
             if (replacements != null && isTranslatable(element)) {
                 reportTypo(context, node, text, charStart, replacements);
             }

             checkRepeatedWords(context, element, node, text, lastWordBegin, lastWordEnd, charStart,
                     charEnd);

             lastWordBegin = charStart;
             lastWordEnd = charEnd;
             charStart = charEnd;
         }
     }

     private static boolean isTranslatable(Element element) {
         Attr translatable = element.getAttributeNode(ATTR_TRANSLATABLE);
         return translatable == null || Boolean.valueOf(translatable.getValue());
     }

     /** Report the typo found at the given offset and suggest the given replacements */
     private static void reportTypo(XmlContext context, Node node, String text, int begin,
             List<String> replacements) {
         if (replacements.size() < 2) {
             return;
         }

         String typo = replacements.get(0);
         String word = text.substring(begin, begin + typo.length());

         String first = null;
         String message;

         boolean isCapitalized = Character.isUpperCase(word.charAt(0));
         StringBuilder sb = new StringBuilder(40);
         for (int i = 1, n = replacements.size(); i < n; i++) {
             String replacement = replacements.get(i);
             if (first == null) {
                 first = replacement;
             }
             if (sb.length() > 0) {
                 sb.append(" or ");
             }
             sb.append('"');
             if (isCapitalized) {
                 sb.append(Character.toUpperCase(replacement.charAt(0)));
                 sb.append(replacement.substring(1));
             } else {
                 sb.append(replacement);
             }
             sb.append('"');
         }

         if (first != null && first.equalsIgnoreCase(word)) {
             if (first.equals(word)) {
                 return;
             }
             message = String.format(
                     "\"%1$s\" is usually capitalized as \"%2$s\"",
                     word, first);
         } else {
             message = String.format(
                     "\"%1$s\" is a common misspelling; did you mean %2$s ?",
                     word, sb.toString());
         }

         int end = begin + word.length();
         context.report(ISSUE, node, context.getLocation(node, begin, end), message);
     }

     /** Reports a repeated word */
     private static void reportRepeatedWord(XmlContext context, Node node, String text,
             int lastWordBegin,
             int begin, int end) {
         String message = String.format(
                 "Repeated word \"%1$s\" in message: possible typo",
                 text.substring(begin, end));
         Location location = context.getLocation(node, lastWordBegin, end);
         context.report(ISSUE, node, location, message);
     }

     /** Returns the suggested replacements, if any, for the given typo. The error
      * message <b>must</b> be one supplied by lint.
      *
      * @param errorMessage the error message
      * @param format the format of the error message
      * @return a list of replacement words suggested by the error message
      */
     @Nullable
     public static List<String> getSuggestions(@NonNull String errorMessage,
             @NonNull TextFormat format) {
         errorMessage = format.toText(errorMessage);

         // The words are all in quotes; the first word is the misspelling,
         // the other words are the suggested replacements
         List<String> words = new ArrayList<String>();
         // Skip the typo
         int index = errorMessage.indexOf('"');
         index = errorMessage.indexOf('"', index + 1);
         index++;

         while (true) {
             index = errorMessage.indexOf('"', index);
             if (index == -1) {
                 break;
             }
             index++;
             int start = index;
             index = errorMessage.indexOf('"', index);
             if (index == -1) {
                 index = errorMessage.length();
             }
             words.add(errorMessage.substring(start, index));
             index++;
         }

         return words;
     }

     /**
      * Returns the typo word in the error message from this detector
      *
      * @param errorMessage the error message produced earlier by this detector
      * @param format the format of the error message
      * @return the typo
      */
     @Nullable
     public static String getTypo(@NonNull String errorMessage, @NonNull TextFormat format) {
         errorMessage = format.toText(errorMessage);
         // The words are all in quotes
         int index = errorMessage.indexOf('"');
         int start = index + 1;
         index = errorMessage.indexOf('"', start);
         if (index != -1) {
             return errorMessage.substring(start, index);
         }

         return null;
     }
 }
	/*
	* 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_LOCALE;
	import static com.android.SdkConstants.ATTR_TRANSLATABLE;
	import static com.android.SdkConstants.FD_RES_VALUES;
	import static com.android.SdkConstants.TAG_PLURALS;
	import static com.android.SdkConstants.TAG_STRING;
	import static com.android.SdkConstants.TAG_STRING_ARRAY;
	import static com.android.SdkConstants.TOOLS_URI;
	import static com.android.tools.lint.checks.TypoLookup.isLetter;
	import static com.google.common.base.Objects.equal;

	import com.android.annotations.NonNull;
	import com.android.annotations.Nullable;
	import com.android.ide.common.resources.configuration.LocaleQualifier;
	import com.android.resources.ResourceFolderType;
	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.LintUtils;
	import com.android.tools.lint.detector.api.Location;
	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.Speed;
	import com.android.tools.lint.detector.api.TextFormat;
	import com.android.tools.lint.detector.api.XmlContext;
	import com.google.common.base.Charsets;

	import org.w3c.dom.Attr;
	import org.w3c.dom.Element;
	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.List;

	/**
	* Check which looks for likely typos in Strings.
	* <p>
	* TODO:
	* <ul>
	* <li> Add check of Java String literals too!
	* <li> Add support for <b>additional</b> languages. The typo detector is now
	* multilingual and looks for typos-locale.txt files to use. However,
	* we need to seed it with additional typo databases. I did some searching
	* and came up with some alternatives. Here's the strategy I used:
	* Used Google Translate to translate "Wikipedia Common Misspellings", and
	* then I went to google.no, google.fr etc searching with that translation, and
	* came up with what looks like wikipedia language local lists of typos.
	* This is how I found the Norwegian one for example:
	* <br>
	* http://no.wikipedia.org/wiki/Wikipedia:Liste_over_alminnelige_stavefeil/Maskinform
	* <br>
	* Here are some additional possibilities not yet processed:
	* <ul>
	* <li> French: http://fr.wikipedia.org/wiki/Wikip%C3%A9dia:Liste_de_fautes_d'orthographe_courantes
	* (couldn't find a machine-readable version there?)
	* <li> Swedish:
	* http://sv.wikipedia.org/wiki/Wikipedia:Lista_%C3%B6ver_vanliga_spr%C3%A5kfel
	* (couldn't find a machine-readable version there?)
	* <li> German
	* http://de.wikipedia.org/wiki/Wikipedia:Liste_von_Tippfehlern/F%C3%BCr_Maschinen
	* </ul>
	* <li> Consider also digesting files like
	* http://sv.wikipedia.org/wiki/Wikipedia:AutoWikiBrowser/Typos
	* See http://en.wikipedia.org/wiki/Wikipedia:AutoWikiBrowser/User_manual.
	* </ul>
	*/
	public class TypoDetector extends ResourceXmlDetector {
	@Nullable private TypoLookup mLookup;
	@Nullable private String mLastLanguage;
	@Nullable private String mLastRegion;
	@Nullable private String mLanguage;
	@Nullable private String mRegion;

	/** The main issue discovered by this detector */
	public static final Issue ISSUE = Issue.create(
	"Typos", //$NON-NLS-1$
	"Spelling error",

	"This check looks through the string definitions, and if it finds any words " +
	"that look like likely misspellings, they are flagged.",
	Category.MESSAGES,
	7,
	Severity.WARNING,
	new Implementation(
	TypoDetector.class,
	Scope.RESOURCE_FILE_SCOPE));

	/** Constructs a new detector */
	public TypoDetector() {
	}

	@Override
	public boolean appliesTo(@NonNull ResourceFolderType folderType) {
	return folderType == ResourceFolderType.VALUES;
	}

	/** Look up the locale and region from the given parent folder name and store it
	* in {@link #mLanguage} and {@link #mRegion} */
	private void initLocale(@NonNull String parent) {
	mLanguage = null;
	mRegion = null;

	if (parent.equals(FD_RES_VALUES)) {
	return;
	}

	LocaleQualifier locale = LintUtils.getLocale(parent);
	if (locale != null) {
	mLanguage = locale.getLanguage();
	mRegion = locale.hasRegion() ? locale.getRegion() : null;
	}
	}

	@Override
	public void beforeCheckFile(@NonNull Context context) {
	initLocale(context.file.getParentFile().getName());
	if (mLanguage == null) {
	// Check to see if the user has specified the language for this folder
	// using a tools:locale attribute
	if (context instanceof XmlContext) {
	Element root = ((XmlContext) context).document.getDocumentElement();
	if (root != null) {
	String locale = root.getAttributeNS(TOOLS_URI, ATTR_LOCALE);
	if (locale != null && !locale.isEmpty()) {
	initLocale(FD_RES_VALUES + '-' + locale);
	}
	}
	}

	if (mLanguage == null) {
	mLanguage = "en"; //$NON-NLS-1$
	}
	}

	if (!equal(mLastLanguage, mLanguage) \|\| !equal(mLastRegion, mRegion)) {
	mLookup = TypoLookup.get(context.getClient(), mLanguage, mRegion);
	mLastLanguage = mLanguage;
	mLastRegion = mRegion;
	}
	}

	@NonNull
	@Override
	public Speed getSpeed() {
	return Speed.NORMAL;
	}

	@Override
	public Collection<String> getApplicableElements() {
	return Arrays.asList(
	TAG_STRING,
	TAG_STRING_ARRAY,
	TAG_PLURALS
	);
	}

	@Override
	public void visitElement(@NonNull XmlContext context, @NonNull Element element) {
	if (mLookup == null) {
	return;
	}

	visit(context, element, element);
	}

	private void visit(XmlContext context, Element parent, Node node) {
	if (node.getNodeType() == Node.TEXT_NODE) {
	// TODO: Figure out how to deal with entities
	check(context, parent, node, node.getNodeValue());
	} else {
	NodeList children = node.getChildNodes();
	for (int i = 0, n = children.getLength(); i < n; i++) {
	visit(context, parent, children.item(i));
	}
	}
	}

	private void check(XmlContext context, Element element, Node node, String text) {
	int max = text.length();
	int index = 0;
	int lastWordBegin = -1;
	int lastWordEnd = -1;
	boolean checkedTypos = false;

	for (; index < max; index++) {
	char c = text.charAt(index);
	if (!Character.isWhitespace(c)) {
	if (c == '@' \|\| (c == '?')) {
	// Don't look for typos in resource references; they are not
	// user visible anyway
	return;
	}
	break;
	}
	}

	while (index < max) {
	for (; index < max; index++) {
	char c = text.charAt(index);
	if (c == '\\') {
	index++;
	} else if (Character.isLetter(c)) {
	break;
	}
	}
	if (index >= max) {
	return;
	}
	int begin = index;
	for (; index < max; index++) {
	char c = text.charAt(index);
	if (c == '\\') {
	index++;
	break;
	} else if (!Character.isLetter(c)) {
	break;
	} else if (text.charAt(index) >= 0x80) {
	// Switch to UTF-8 handling for this string
	if (checkedTypos) {
	// If we've already checked words we may have reported typos
	// so create a substring from the current word and on.
	byte[] utf8Text = text.substring(begin).getBytes(Charsets.UTF_8);
	check(context, element, node, utf8Text, 0, utf8Text.length, text, begin);
	} else {
	// If all we've done so far is skip whitespace (common scenario)
	// then no need to substring the text, just re-search with the
	// UTF-8 routines
	byte[] utf8Text = text.getBytes(Charsets.UTF_8);
	check(context, element, node, utf8Text, 0, utf8Text.length, text, 0);
	}
	return;
	}
	}

	int end = index;
	checkedTypos = true;
	assert mLookup != null;
	List<String> replacements = mLookup.getTypos(text, begin, end);
	if (replacements != null && isTranslatable(element)) {
	reportTypo(context, node, text, begin, replacements);
	}

	checkRepeatedWords(context, element, node, text, lastWordBegin, lastWordEnd, begin,
	end);

	lastWordBegin = begin;
	lastWordEnd = end;
	index = end + 1;
	}
	}

	private static void checkRepeatedWords(XmlContext context, Element element, Node node,
	String text, int lastWordBegin, int lastWordEnd, int begin, int end) {
	if (lastWordBegin != -1 && end - begin == lastWordEnd - lastWordBegin
	&& end - begin > 1) {
	// See whether we have a repeated word
	boolean different = false;
	for (int i = lastWordBegin, j = begin; i < lastWordEnd; i++, j++) {
	if (text.charAt(i) != text.charAt(j)) {
	different = true;
	break;
	}
	}
	if (!different && onlySpace(text, lastWordEnd, begin) && isTranslatable(element)) {
	reportRepeatedWord(context, node, text, lastWordBegin, begin, end);
	}
	}
	}

	private static boolean onlySpace(String text, int fromInclusive, int toExclusive) {
	for (int i = fromInclusive; i < toExclusive; i++) {
	if (!Character.isWhitespace(text.charAt(i))) {
	return false;
	}
	}

	return true;
	}

	private void check(XmlContext context, Element element, Node node, byte[] utf8Text,
	int byteStart, int byteEnd, String text, int charStart) {
	int lastWordBegin = -1;
	int lastWordEnd = -1;
	int index = byteStart;
	while (index < byteEnd) {
	// Find beginning of word
	while (index < byteEnd) {
	byte b = utf8Text[index];
	if (b == '\\') {
	index++;
	charStart++;
	if (index < byteEnd) {
	b = utf8Text[index];
	}
	} else if (isLetter(b)) {
	break;
	}
	index++;
	if ((b & 0x80) == 0 \|\| (b & 0xC0) == 0xC0) {
	// First characters in UTF-8 are always ASCII (0 high bit) or 11XXXXXX
	charStart++;
	}
	}

	if (index >= byteEnd) {
	return;
	}
	int charEnd = charStart;
	int begin = index;

	// Find end of word. Unicode has the nice property that even 2nd, 3rd and 4th
	// bytes won't match these ASCII characters (because the high bit must be set there)
	while (index < byteEnd) {
	byte b = utf8Text[index];
	if (b == '\\') {
	index++;
	charEnd++;
	if (index < byteEnd) {
	b = utf8Text[index++];
	if ((b & 0x80) == 0 \|\| (b & 0xC0) == 0xC0) {
	charEnd++;
	}
	}
	break;
	} else if (!isLetter(b)) {
	break;
	}
	index++;
	if ((b & 0x80) == 0 \|\| (b & 0xC0) == 0xC0) {
	// First characters in UTF-8 are always ASCII (0 high bit) or 11XXXXXX
	charEnd++;
	}
	}

	int end = index;
	List<String> replacements = mLookup.getTypos(utf8Text, begin, end);
	if (replacements != null && isTranslatable(element)) {
	reportTypo(context, node, text, charStart, replacements);
	}

	checkRepeatedWords(context, element, node, text, lastWordBegin, lastWordEnd, charStart,
	charEnd);

	lastWordBegin = charStart;
	lastWordEnd = charEnd;
	charStart = charEnd;
	}
	}

	private static boolean isTranslatable(Element element) {
	Attr translatable = element.getAttributeNode(ATTR_TRANSLATABLE);
	return translatable == null \|\| Boolean.valueOf(translatable.getValue());
	}

	/** Report the typo found at the given offset and suggest the given replacements */
	private static void reportTypo(XmlContext context, Node node, String text, int begin,
	List<String> replacements) {
	if (replacements.size() < 2) {
	return;
	}

	String typo = replacements.get(0);
	String word = text.substring(begin, begin + typo.length());

	String first = null;
	String message;

	boolean isCapitalized = Character.isUpperCase(word.charAt(0));
	StringBuilder sb = new StringBuilder(40);
	for (int i = 1, n = replacements.size(); i < n; i++) {
	String replacement = replacements.get(i);
	if (first == null) {
	first = replacement;
	}
	if (sb.length() > 0) {
	sb.append(" or ");
	}
	sb.append('"');
	if (isCapitalized) {
	sb.append(Character.toUpperCase(replacement.charAt(0)));
	sb.append(replacement.substring(1));
	} else {
	sb.append(replacement);
	}
	sb.append('"');
	}

	if (first != null && first.equalsIgnoreCase(word)) {
	if (first.equals(word)) {
	return;
	}
	message = String.format(
	"\"%1$s\" is usually capitalized as \"%2$s\"",
	word, first);
	} else {
	message = String.format(
	"\"%1$s\" is a common misspelling; did you mean %2$s ?",
	word, sb.toString());
	}

	int end = begin + word.length();
	context.report(ISSUE, node, context.getLocation(node, begin, end), message);
	}

	/** Reports a repeated word */
	private static void reportRepeatedWord(XmlContext context, Node node, String text,
	int lastWordBegin,
	int begin, int end) {
	String message = String.format(
	"Repeated word \"%1$s\" in message: possible typo",
	text.substring(begin, end));
	Location location = context.getLocation(node, lastWordBegin, end);
	context.report(ISSUE, node, location, message);
	}

	/** Returns the suggested replacements, if any, for the given typo. The error
	* message <b>must</b> be one supplied by lint.
	*
	* @param errorMessage the error message
	* @param format the format of the error message
	* @return a list of replacement words suggested by the error message
	*/
	@Nullable
	public static List<String> getSuggestions(@NonNull String errorMessage,
	@NonNull TextFormat format) {
	errorMessage = format.toText(errorMessage);

	// The words are all in quotes; the first word is the misspelling,
	// the other words are the suggested replacements
	List<String> words = new ArrayList<String>();
	// Skip the typo
	int index = errorMessage.indexOf('"');
	index = errorMessage.indexOf('"', index + 1);
	index++;

	while (true) {
	index = errorMessage.indexOf('"', index);
	if (index == -1) {
	break;
	}
	index++;
	int start = index;
	index = errorMessage.indexOf('"', index);
	if (index == -1) {
	index = errorMessage.length();
	}
	words.add(errorMessage.substring(start, index));
	index++;
	}

	return words;
	}

	/**
	* Returns the typo word in the error message from this detector
	*
	* @param errorMessage the error message produced earlier by this detector
	* @param format the format of the error message
	* @return the typo
	*/
	@Nullable
	public static String getTypo(@NonNull String errorMessage, @NonNull TextFormat format) {
	errorMessage = format.toText(errorMessage);
	// The words are all in quotes
	int index = errorMessage.indexOf('"');
	int start = index + 1;
	index = errorMessage.indexOf('"', start);
	if (index != -1) {
	return errorMessage.substring(start, index);
	}

	return null;
	}
	}