utils/MessageBundleChecker.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 import java.io.BufferedReader;
  22 import java.io.File;
  23 import java.io.FileReader;
  24 import java.io.IOException;
  25 import java.util.HashSet;
  26 import java.util.Properties;
  27 import java.util.TreeSet;
  28 import java.util.regex.Pattern;
  29
  30 /**
  31  * This class scans Java source files for calls to MessageManager and reports
  32  * <ul>
  33  * <li>calls using keys not found in Messages.properties</li>
  34  * <li>any unused keys in Messages.properties</li>
  35  * </ul>
  36  * It does not handle dynamically constructed keys, these are reported as
  37  * possible errors for manual inspection. <br>
  38  * For comparing translated bundles with Messages.properties, see i18nAnt.xml
  39  *
  40  * @author gmcarstairs
  41  *
  42  */
  43 public class MessageBundleChecker implements BufferedLineReader.LineCleaner
  44 {
  45   /*
  46    * regex ^"[^"]*"$
  47    * opening quote, closing quote, no quotes in between
  48    */
  49   static Pattern STRING_PATTERN = Pattern.compile("^\"[^\"]*\"$");
  50
  51   /*
  52    * number of text lines to read at a time in order to parse
  53    * code that is split over several lines
  54    */
  55   static int bufferSize = 3;
  56
  57   /*
  58    * resource bundle key is arg0 for these methods
  59    */
  60   static final String METHOD1 = "MessageManager.getString(";
  61
  62   static final String METHOD2 = "MessageManager.formatMessage(";
  63
  64   static final String METHOD3 = "MessageManager.getStringOrReturn(";
  65
  66   /*
  67    * resource bundle key is arg1 for this method
  68    */
  69   static final String JVINIT = "JvSwingUtils.jvInitComponent(";
  70
  71   static final String[] METHODS = { METHOD1, METHOD2, METHOD3, JVINIT };
  72
  73   /*
  74    * root of the Java source folders we want to scan
  75    */
  76   String sourcePath;
  77
  78   /*
  79    * contents of Messages.properties
  80    */
  81   private Properties messages;
  82
  83   /*
  84    * keys from Messages.properties
  85    * we remove entries from here as they are found to be used
  86    * any left over are unused entries
  87    */
  88   private TreeSet<String> messageKeys;
  89
  90   private int javaCount;
  91
  92   private HashSet<String> invalidKeys;
  93
  94   /**
  95    * Runs the scan given the path to the root of Java source directories
  96    *
  97    * @param args
  98    *          [0] path to the source folder to scan
  99    * @param args
 100    *          [1] (optional) read buffer size (default is 3); increasing this
 101    *          may detect more results but will give higher error counts due to
 102    *          double counting of the same code
 103    * @throws IOException
 104    */
 105   public static void main(String[] args) throws IOException
 106   {
 107     if (args.length != 1 && args.length != 2)
 108     {
 109       System.out.println("Usage: <pathToSourceFolder> [readBufferSize]");
 110       return;
 111     }
 112     if (args.length == 2)
 113     {
 114       bufferSize = Integer.valueOf(args[1]);
 115     }
 116     new MessageBundleChecker().doMain(args[0]);
 117   }
 118
 119   /**
 120    * Main method to perform the work
 121    *
 122    * @param srcPath
 123    * @throws IOException
 124    */
 125   private void doMain(String srcPath) throws IOException
 126   {
 127     System.out.println("Scanning " + srcPath
 128             + " for calls to MessageManager");
 129     sourcePath = srcPath;
 130     loadMessages();
 131     File dir = new File(srcPath);
 132     if (!dir.exists())
 133     {
 134       System.out.println(srcPath + " not found");
 135       return;
 136     }
 137     invalidKeys = new HashSet<String>();
 138     if (dir.isDirectory())
 139     {
 140       scanDirectory(dir);
 141     }
 142     else
 143     {
 144       scanFile(dir);
 145     }
 146     reportResults();
 147   }
 148
 149   /**
 150    * Prints out counts to sysout
 151    */
 152   private void reportResults()
 153   {
 154     System.out.println("\nScanned " + javaCount + " source files");
 155     System.out.println("Message.properties has " + messages.size()
 156             + " keys");
 157     System.out.println("Found " + invalidKeys.size()
 158             + " possibly invalid parameter calls");
 159
 160     System.out.println(messageKeys.size()
 161             + " keys not found, either unused or constructed dynamically");
 162     for (String key : messageKeys)
 163     {
 164       System.out.println("    " + key);
 165     }
 166   }
 167
 168   /**
 169    * Scan all files within a directory
 170    *
 171    * @param dir
 172    * @throws IOException
 173    */
 174   private void scanDirectory(File dir) throws IOException
 175   {
 176     File[] files = dir.listFiles();
 177     if (files != null)
 178     {
 179       for (File f : files)
 180       {
 181         if (f.isDirectory())
 182         {
 183           scanDirectory(f);
 184         }
 185         else
 186         {
 187           scanFile(f);
 188         }
 189       }
 190     }
 191   }
 192
 193   /**
 194    * Scan a Java file
 195    *
 196    * @param f
 197    */
 198   private void scanFile(File f) throws IOException
 199   {
 200     String path = f.getPath();
 201     if (!path.endsWith(".java"))
 202     {
 203       return;
 204     }
 205     javaCount++;
 206
 207     /*
 208      * skip class with designed dynamic lookup call
 209      */
 210     if (path.endsWith("gui/JvSwingUtils.java"))
 211     {
 212       return;
 213     }
 214
 215     BufferedReader br = new BufferedReader(new FileReader(f));
 216     BufferedLineReader blr = new BufferedLineReader(br, bufferSize, this);
 217
 218     int lineNo = 0;
 219     String line = blr.read();
 220     while (line != null)
 221     {
 222       lineNo++;
 223       inspectSourceLines(path, lineNo, line);
 224       line = blr.read();
 225     }
 226     br.close();
 227
 228   }
 229
 230   /**
 231    * Look for calls to MessageManager methods, possibly split over two or more
 232    * lines that have been concatenated while parsing the file
 233    *
 234    * @param path
 235    * @param lineNo
 236    * @param line
 237    */
 238   private void inspectSourceLines(String path, int lineNo, String line)
 239   {
 240     String lineNos = String
 241             .format("%d-%d", lineNo, lineNo + bufferSize
 242             - 1);
 243     for (String method : METHODS)
 244     {
 245       int pos = line.indexOf(method);
 246       if (pos == -1)
 247       {
 248         continue;
 249       }
 250
 251       /*
 252        * extract what follows the opening bracket of the method call
 253        */
 254       String methodArgs = line.substring(pos + method.length()).trim();
 255       if ("".equals(methodArgs))
 256       {
 257         /*
 258          * arguments are on next line - catch in the next read loop iteration
 259          */
 260         continue;
 261       }
 262       if (methodArgs.indexOf(",") == -1 && methodArgs.indexOf(")") == -1)
 263       {
 264         /*
 265          * arguments continue on next line - catch in the next read loop iteration
 266          */
 267         continue;
 268       }
 269
 270       if (JVINIT == method && methodArgs.indexOf(",") == -1)
 271       {
 272         /*
 273          * not interested in 1-arg calls to jvInitComponent
 274          */
 275         continue;
 276       }
 277
 278       if (METHOD3 == method)
 279       {
 280         System.out.println(String.format("Dynamic key at %s line %s %s",
 281                 path.substring(sourcePath.length()), lineNos, line));
 282         continue;
 283       }
 284
 285       String messageKey = getMessageKey(method, methodArgs);
 286       if (messageKey == null)
 287       {
 288         System.out.println(String.format("Trouble parsing %s line %s %s",
 289                 path.substring(sourcePath.length()), lineNos, line));
 290         continue;
 291       }
 292
 293       if (!(STRING_PATTERN.matcher(messageKey).matches()))
 294       {
 295         System.out.println(String.format("Dynamic key at %s line %s %s",
 296                 path.substring(sourcePath.length()), lineNos, line));
 297         continue;
 298       }
 299
 300       /*
 301        * strip leading and trailing quote
 302        */
 303       messageKey = messageKey.substring(1, messageKey.length() - 1);
 304
 305       if (!this.messages.containsKey(messageKey))
 306       {
 307         System.out.println(String.format(
 308                 "Unmatched key '%s' at line %s of %s", messageKey, lineNos,
 309                 path.substring(sourcePath.length())));
 310         if (!invalidKeys.contains(messageKey))
 311         {
 312           invalidKeys.add(messageKey);
 313         }
 314       }
 315       messageKeys.remove(messageKey);
 316     }
 317   }
 318
 319   /**
 320    * Helper method to parse out the resource bundle key parameter of a method
 321    * call
 322    *
 323    * @param method
 324    * @param methodArgs
 325    *          the rest of the source line starting with arguments to method
 326    * @return
 327    */
 328   private String getMessageKey(String method, String methodArgs)
 329   {
 330     String key = methodArgs;
 331
 332     /*
 333      * locate second argument if calling jvInitComponent()
 334      */
 335     if (method == JVINIT)
 336     {
 337       int commaLoc = methodArgs.indexOf(",");
 338       if (commaLoc == -1)
 339       {
 340         return null;
 341       }
 342       key = key.substring(commaLoc + 1).trim();
 343     }
 344
 345     /*
 346      * take up to next comma or ) or end of line
 347      */
 348     int commaPos = key.indexOf(",");
 349     int bracePos = key.indexOf(")");
 350     int endPos = commaPos == -1 ? bracePos : (bracePos == -1 ? commaPos
 351             : Math.min(commaPos, bracePos));
 352     if (endPos == -1 && key.length() > 1 && key.endsWith("\""))
 353     {
 354       endPos = key.length();
 355     }
 356
 357     return endPos == -1 ? null : key.substring(0, endPos);
 358   }
 359
 360   /**
 361    * Loads properties from Message.properties
 362    *
 363    * @throws IOException
 364    */
 365   void loadMessages() throws IOException
 366   {
 367     messages = new Properties();
 368     FileReader reader = new FileReader(new File(sourcePath,
 369             "../resources/lang/Messages.properties"));
 370     messages.load(reader);
 371     reader.close();
 372
 373     messageKeys = new TreeSet<String>();
 374     for (Object key : messages.keySet())
 375     {
 376       messageKeys.add((String) key);
 377     }
 378
 379   }
 380
 381   /**
 382    * Remove any trailing comments, change tabs to space, and trim
 383    */
 384   @Override
 385   public String cleanLine(String l)
 386   {
 387     if (l != null)
 388     {
 389       int pos = l.indexOf("//");
 390       if (pos != -1)
 391       {
 392         l = l.substring(0, pos);
 393       }
 394       l = l.replace("\t", " ").trim();
 395     }
 396     return l;
 397   }
 398
 399 }