1 /*
   2  * $Id$
   3  *
   4  * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved.
   5  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   6  *
   7  * This code is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License version 2 only, as
   9  * published by the Free Software Foundation.  Oracle designates this
  10  * particular file as subject to the "Classpath" exception as provided
  11  * by Oracle in the LICENSE file that accompanied this code.
  12  *
  13  * This code is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16  * version 2 for more details (a copy is included in the LICENSE file that
  17  * accompanied this code).
  18  *
  19  * You should have received a copy of the GNU General Public License version
  20  * 2 along with this work; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  22  *
  23  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  24  * or visit www.oracle.com if you need additional information or have any
  25  * questions.
  26  */
  27 
  28 package com.sun.javatest.tool;
  29 
  30 import java.awt.event.ActionListener;
  31 import java.io.*;
  32 import java.lang.ref.WeakReference;
  33 import java.nio.charset.StandardCharsets;
  34 import java.util.*;
  35 import javax.swing.JMenu;
  36 import javax.swing.JMenuItem;
  37 import javax.swing.event.MenuEvent;
  38 import javax.swing.event.MenuListener;
  39 
  40 import com.sun.javatest.WorkDirectory;
  41 import com.sun.javatest.util.I18NResourceBundle;
  42 
  43 /**
  44  * A class to maintain a history of recently used files. The history is
  45  * maintained in a specified file in a WorkDirectory, and can be
  46  * dynamically added to a menu by means of a Listener class.
  47  * The format of the file is one file per line, with most recently
  48  * added entries appearing first.  Lines beginning with <code>#</code> are ignored.
  49  */
  50 public class FileHistory
  51 {
  52     /**
  53      * Get a shared FileHistory object for a specified file and work directory.
  54      * @param wd The work directory in which the history file is maintained.
  55      * @param name The name of the file within the work direectory's jtData/
  56      * subdirectory.
  57      * @return the specified FileHistory object
  58      */
  59     public static FileHistory getFileHistory(WorkDirectory wd, String name) {
  60         if (cache == null)
  61             cache = new WeakHashMap<>(8);
  62 
  63         // first, get a map for all files in this wd
  64         Map<String, FileHistory> map = cache.get(wd);
  65         if (map == null) {
  66             map = new HashMap<>(8);
  67             cache.put(wd, map);
  68         }
  69 
  70         // then, get the FileHistory for the specified file
  71         FileHistory h = map.get(name);
  72         if (h == null) {
  73             h = new FileHistory(wd, name);
  74             map.put(name, h);
  75         }
  76 
  77         return h;
  78     }
  79 
  80 
  81     /**
  82      * Get a shared FileHistory object for a specified file and path to work directory.
  83      * @param wdFile The path th work directory in which the history file is maintained.
  84      * @param name The name of the file within the work direectory's jtData/
  85      * subdirectory.
  86      * @return the specified FileHistory object
  87      */
  88     public static FileHistory getFileHistory(File wdFile, String name) {
  89         if (cache == null)
  90             cache = new WeakHashMap<>(8);
  91 
  92         if (!WorkDirectory.isWorkDirectory(wdFile))
  93             return null;
  94 
  95         // let's find in the cache work dir corresponding to the path
  96         Iterator it = cache.keySet().iterator();
  97         WorkDirectory wd = null;
  98         while (it.hasNext()) {
  99             WorkDirectory tempWD = ((WorkDirectory)it.next());
 100             if (tempWD.getRoot().equals(wdFile)) {
 101                 wd = tempWD;
 102                 break;
 103             }
 104         }
 105         if (wd != null)
 106             return FileHistory.getFileHistory(wd, name);
 107         else
 108             return null;
 109     }
 110 
 111     /**
 112      * Add a new file to the history.
 113      * The file in the work directory for this history will be updated.
 114      * @param file the file to be added to the history
 115      */
 116     public void add(File file) {
 117         ensureEntriesUpToDate();
 118 
 119         file = file.getAbsoluteFile();
 120         entries.remove(file);
 121         entries.add(0, file);
 122 
 123         writeEntries();
 124     }
 125 
 126     /**
 127      * Get the most recent entries from the history. Only entries for
 128      * files that exist on this system are returned. Thus the history
 129      * can accommodate files for different systems, which will likely not
 130      * exist on all systems on which the history is used.
 131      * @param count the number of most recent, existing files
 132      * to be returned.
 133      * @return an array of the most recent, existing entries
 134      */
 135     public File[] getRecentEntries(int count) {
 136         ensureEntriesUpToDate();
 137 
 138         // scan the entries, skipping those which do not exist,
 139         // collecting up to count entries. Non-existent entries are
 140         // skipped but not deleted because they might be for other
 141         // platforms.
 142         Vector<File> v = new Vector<>();
 143         for (int i = 0; i < entries.size() && v.size() < count; i++) {
 144             File f = entries.elementAt(i);
 145             if (f.exists())
 146                 v.add(f);
 147         }
 148         File[] e = new File[v.size()];
 149         v.copyInto(e);
 150 
 151         return e;
 152     }
 153 
 154     /**
 155      * Get the latest valid entry from a file history object. An entry
 156      * is valid if it identifies a file that exists on the current system.
 157      * @return the latest valid entry from afile history object, or null
 158      * if none found.
 159      */
 160     public File getLatestEntry() {
 161         ensureEntriesUpToDate();
 162 
 163         // scan the entries, skipping those which do not exist,
 164         // looking for the first entry. Non-existent entries are
 165         // skipped but not deleted because they might be for other
 166         // platforms.
 167         for (int i = 0; i < entries.size(); i++) {
 168             File f = entries.elementAt(i);
 169             if (f.exists())
 170                 return f;
 171         }
 172 
 173         return null;
 174     }
 175 
 176     public File getRelativeLatestEntry(String newRoot, String oldRoot) {
 177         ensureEntriesUpToDate();
 178 
 179         for (int i = 0; i < entries.size(); i++) {
 180             File f = entries.elementAt(i);
 181             if (f.exists()) {
 182                 return f;
 183             } else {
 184                 String sf = f.getPath();
 185                 String[] diff = WorkDirectory.getDiffInPaths(newRoot, oldRoot);
 186                 if (diff != null) {
 187                     File toCheck = new File(diff[0] + sf.substring(diff[1].length()));
 188                     if (toCheck.exists()) {
 189                         return toCheck;
 190                     }
 191                 }
 192 
 193             }
 194         }
 195         return null;
 196     }
 197 
 198 
 199     private FileHistory(WorkDirectory workDir, String name) {
 200         workDirRef = new WeakReference<>(workDir); // just used for logging errors
 201         this.name = name;
 202         historyFile = workDir.getSystemFile(name);
 203     }
 204 
 205     private void ensureEntriesUpToDate() {
 206         if (entries == null || historyFile.lastModified() > historyFileLastModified)
 207             readEntries();
 208     }
 209 
 210     private void readEntries() {
 211         if (entries == null)
 212             entries = new Vector<>();
 213         else
 214             entries.clear();
 215 
 216         if (historyFile.exists()) {
 217             try {
 218                 BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(historyFile), StandardCharsets.UTF_8));
 219                 String line;
 220                 while ((line = br.readLine()) != null) {
 221                     String p = line.trim();
 222                     if (p.length() == 0 || p.startsWith("#"))
 223                         continue;
 224                     entries.add(new File(p));
 225                 }
 226                 br.close();
 227             }
 228             catch (IOException e) {
 229                 WorkDirectory workDir = workDirRef.get();
 230                 workDir.log(i18n, "fh.cantRead", new Object[] { name, e } );
 231             }
 232 
 233             historyFileLastModified = historyFile.lastModified();
 234         }
 235     }
 236 
 237     private void writeEntries() {
 238         try {
 239             BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(historyFile), StandardCharsets.UTF_8));
 240             bw.write("# Configuration File History");
 241             bw.newLine();
 242             bw.write("# written at " + (new Date()));
 243             bw.newLine();
 244             for (int i = 0; i < entries.size(); i++) {
 245                 bw.write(entries.elementAt(i).toString());
 246                 bw.newLine();
 247             }
 248             bw.close();
 249         }
 250         catch (IOException e) {
 251             WorkDirectory workDir = workDirRef.get();
 252             workDir.log(i18n, "fh.cantWrite", new Object[] { name, e } );
 253         }
 254 
 255         historyFileLastModified = historyFile.lastModified();
 256     }
 257 
 258 
 259     /**
 260      * A class that will dynamically add the latest entries for a
 261      * FileHistory onto a menu. To do this, an instance of this class
 262      * should be added to the menu with
 263      * {@link javax.swing.JMenu#addMenuListener addMenuListener}.
 264      */
 265     public static class Listener implements MenuListener {
 266         /**
 267          * Create a Listener that can be used to dynamically add the
 268          * latest entries from a FileHistory onto a menu.  The dynamic
 269          * entries will be added to the end of the menu when it is
 270          * selected. Any previous values added by this listener
 271          * will automatically be removed.
 272          * @param l An ActionListener that will be notified when
 273          * any of the dynamic menu entries are invoked. When this
 274          * action listener is notified, the action command will be
 275          * the path of the file. The corresponding File object will
 276          * be registered on the source as a client property named
 277          * FILE.
 278          */
 279         public Listener(ActionListener l) {
 280             this(null, -1, l);
 281         }
 282 
 283         /**
 284          * Create a Listener that can be used to dynamically add the
 285          * latest entries from a FileHistory onto a menu.
 286          * Any previous values added by this listener will automatically
 287          * be removed.
 288          * @param o The position in the menu at which to insert the
 289          * dynamic entries.
 290          * @param l An ActionListener that will be notified when
 291          * any of the dynamic menu entries are invoked. When this
 292          * action listener is notified, the action command will be
 293          * the path of the file. The corresponding File object will
 294          * be registered on the source as a client property named
 295          * FILE.
 296          */
 297         public Listener(int o, ActionListener l) {
 298             this(null, o, l);
 299         }
 300 
 301         /**
 302          * Create a Listener that can be used to dynamically add the
 303          * latest entries from a FileHistory onto a menu.
 304          * Any previous values added by this listener will automatically
 305          * be removed.
 306          * @param h The FileHistory from which to determine the
 307          * entries to be added.
 308          * @param o The position in the menu at which to insert the
 309          * dynamic entries.
 310          * @param l An ActionListener that will be notified when
 311          * any of the dynamic menu entries are invoked. When this
 312          * action listener is notified, the action command will be
 313          * the path of the file. The corresponding File object will
 314          * be registered on the source as a client property named
 315          * FILE.
 316          */
 317         public Listener(FileHistory h, int o, ActionListener l) {
 318             history = h;
 319             offset = o;
 320             clientListener = l;
 321         }
 322 
 323         /**
 324          * Get the FileHistory object from which to obtain the dynamic menu
 325          * entries.
 326          * @return the FileHistory object from which to obtain the dynamic menu
 327          * entries
 328          * @see #setFileHistory
 329          */
 330         public FileHistory getFileHistory() {
 331             return history;
 332         }
 333 
 334         /**
 335          * Specify the FileHistory object from which to obtain the dynamic menu
 336          * entries.
 337          * @param h the FileHistory object from which to obtain the dynamic menu
 338          * entries
 339          * @see #getFileHistory
 340          */
 341         public void setFileHistory(FileHistory h) {
 342             history = h;
 343         }
 344 
 345         public void menuSelected(MenuEvent e) {
 346             // Add the recent entries, or a disabled marker if none
 347             JMenu menu = (JMenu) (e.getSource());
 348             File[] entries = (history == null ? null : history.getRecentEntries(5));
 349             if (entries == null || entries.length == 0) {
 350                 JMenuItem noEntries = new JMenuItem(i18n.getString("fh.empty"));
 351                 noEntries.putClientProperty(FILE_HISTORY, this);
 352                 noEntries.setEnabled(false);
 353                 if (offset < 0)
 354                     menu.add(noEntries);
 355                 else
 356                     menu.insert(noEntries, offset);
 357             }
 358             else {
 359                 for (int i = 0; i < entries.length; i++) {
 360                     JMenuItem mi = new JMenuItem(i + " " + entries[i].getPath());
 361                     mi.setActionCommand(entries[i].getPath());
 362                     mi.addActionListener(clientListener);
 363                     mi.putClientProperty(FILE, entries[i]);
 364                     mi.putClientProperty(FILE_HISTORY, this);
 365                     mi.setMnemonic('0' + i);
 366                     if (offset < 0)
 367                         menu.add(mi);
 368                     else
 369                         menu.insert(mi, offset + i);
 370                 }
 371             }
 372         }
 373 
 374         public void menuDeselected(MenuEvent e) {
 375             removeDynamicEntries((JMenu) (e.getSource()));
 376         }
 377 
 378         public void menuCanceled(MenuEvent e) {
 379             removeDynamicEntries((JMenu) (e.getSource()));
 380         }
 381 
 382         private void removeDynamicEntries(JMenu menu) {
 383             // Clear out any old menu items previously added by this
 384             // menu listener; remove them from bottom up because
 385             // removing an item affects index of subsequent items
 386             for (int i = menu.getItemCount() -1; i >= 0; i--) {
 387                 JMenuItem mi = menu.getItem(i);
 388                 if (mi != null && mi.getClientProperty(FILE_HISTORY) == this)
 389                     menu.remove(mi);
 390             }
 391         }
 392 
 393         private FileHistory history;
 394         private int offset;
 395         private ActionListener clientListener;
 396     }
 397 
 398     private WeakReference<WorkDirectory> workDirRef;
 399     private String name;
 400     private File historyFile;
 401     private long historyFileLastModified;
 402     private Vector<File> entries;
 403 
 404     /**
 405      * The name of the client property used to access the File that identifies
 406      * which dynamically added menu entry has been selected.
 407      * @see Listener
 408      */
 409     public static final String FILE = "file";
 410 
 411     private static WeakHashMap<WorkDirectory, Map<String, FileHistory>> cache;
 412     private static final String FILE_HISTORY = "fileHistory";
 413     private static I18NResourceBundle i18n = I18NResourceBundle.getBundleForClass(FileHistory.class);
 414 
 415 }