plugins/Copyright/src/com/maddyhome/idea/copyright/actions/AbstractFileProcessor.java

   1 /*
   2  *  Copyright 2000-2007 JetBrains s.r.o.
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *  http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  */
  16
  17 package com.maddyhome.idea.copyright.actions;
  18
  19 import com.intellij.openapi.application.ApplicationManager;
  20 import com.intellij.openapi.application.ModalityState;
  21 import com.intellij.openapi.command.CommandProcessor;
  22 import com.intellij.openapi.diagnostic.Logger;
  23 import com.intellij.openapi.module.Module;
  24 import com.intellij.openapi.module.ModuleManager;
  25 import com.intellij.openapi.progress.ProcessCanceledException;
  26 import com.intellij.openapi.progress.ProgressIndicator;
  27 import com.intellij.openapi.progress.ProgressManager;
  28 import com.intellij.openapi.progress.util.ProgressWindow;
  29 import com.intellij.openapi.project.Project;
  30 import com.intellij.openapi.roots.ModuleRootManager;
  31 import com.intellij.openapi.vfs.ReadonlyStatusHandler;
  32 import com.intellij.openapi.vfs.VirtualFile;
  33 import com.intellij.psi.PsiDirectory;
  34 import com.intellij.psi.PsiFile;
  35 import com.intellij.psi.PsiManager;
  36 import com.intellij.util.IncorrectOperationException;
  37 import com.maddyhome.idea.copyright.CopyrightManager;
  38 import com.maddyhome.idea.copyright.CopyrightProfile;
  39 import com.maddyhome.idea.copyright.util.FileTypeUtil;
  40
  41 import java.util.ArrayList;
  42 import java.util.Arrays;
  43 import java.util.List;
  44
  45 public abstract class AbstractFileProcessor
  46 {
  47     private final Project myProject;
  48     private final Module myModule;
  49     private PsiDirectory directory = null;
  50     private PsiFile file = null;
  51     private PsiFile[] files = null;
  52     private boolean subdirs = false;
  53     private final String message;
  54     private final String title;
  55     private final Runnable postProcess;
  56
  57     protected abstract Runnable preprocessFile(PsiFile psifile) throws IncorrectOperationException;
  58
  59     protected AbstractFileProcessor(Project project, String title, String message)
  60     {
  61         myProject = project;
  62         myModule = null;
  63         directory = null;
  64         subdirs = true;
  65         this.title = title;
  66         this.message = message;
  67         postProcess = null;
  68     }
  69
  70     protected AbstractFileProcessor(Project project, Module module, String title, String message)
  71     {
  72         myProject = project;
  73         myModule = module;
  74         directory = null;
  75         subdirs = true;
  76         this.title = title;
  77         this.message = message;
  78         postProcess = null;
  79     }
  80
  81     protected AbstractFileProcessor(Project project, PsiDirectory dir, boolean subdirs, String title, String message)
  82     {
  83         myProject = project;
  84         myModule = null;
  85         directory = dir;
  86         this.subdirs = subdirs;
  87         this.message = message;
  88         this.title = title;
  89         postProcess = null;
  90     }
  91
  92     protected AbstractFileProcessor(Project project, PsiFile file, String title, String message)
  93     {
  94         myProject = project;
  95         myModule = null;
  96         this.file = file;
  97         this.message = message;
  98         this.title = title;
  99         postProcess = null;
 100     }
 101
 102     protected AbstractFileProcessor(Project project, PsiFile[] files, String title, String message, Runnable runnable)
 103     {
 104         myProject = project;
 105         myModule = null;
 106         this.files = files;
 107         this.message = message;
 108         this.title = title;
 109         postProcess = runnable;
 110     }
 111
 112     public void run()
 113     {
 114         if (directory != null)
 115         {
 116             process(directory, subdirs);
 117         }
 118         else if (files != null)
 119         {
 120             process(files);
 121         }
 122         else if (file != null)
 123         {
 124             process(file);
 125         }
 126         else if (myModule != null)
 127         {
 128             process(myModule);
 129         }
 130         else if (myProject != null)
 131         {
 132             process(myProject);
 133         }
 134     }
 135
 136     private void process(final PsiFile file)
 137     {
 138         final VirtualFile virtualFile = file.getVirtualFile();
 139         assert virtualFile != null;
 140         if (!ReadonlyStatusHandler.getInstance(myProject).ensureFilesWritable(virtualFile).hasReadonlyFiles()) {
 141            final Runnable[] resultRunnable = new Runnable[1];
 142
 143           execute(new Runnable()
 144             {
 145                 public void run()
 146                 {
 147                     try
 148                     {
 149                         resultRunnable[0] = preprocessFile(file);
 150                     }
 151                     catch (IncorrectOperationException incorrectoperationexception)
 152                     {
 153                         logger.error(incorrectoperationexception);
 154                     }
 155                 }
 156             }, new Runnable()
 157               {
 158                   public void run()
 159                   {
 160                       if (resultRunnable[0] != null)
 161                       {
 162                           resultRunnable[0].run();
 163                       }
 164                   }
 165               });
 166         }
 167     }
 168
 169
 170     private Runnable prepareFiles(List<PsiFile> files)
 171     {
 172         ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
 173         String msg = null;
 174         double fraction = 0.0D;
 175         if (indicator != null)
 176         {
 177             msg = indicator.getText();
 178             fraction = indicator.getFraction();
 179             indicator.setText(message);
 180         }
 181
 182         final Runnable[] runnables = new Runnable[files.size()];
 183         for (int i = 0; i < files.size(); i++)
 184         {
 185             PsiFile pfile = files.get(i);
 186             if (pfile == null)
 187             {
 188                 logger.debug("Unexpected null file at " + i);
 189                 continue;
 190             }
 191             if (indicator != null)
 192             {
 193                 if (indicator.isCanceled())
 194                 {
 195                     return null;
 196                 }
 197
 198                 indicator.setFraction((double)i / (double)files.size());
 199             }
 200
 201             if (pfile.isWritable())
 202             {
 203                 try
 204                 {
 205                     runnables[i] = preprocessFile(pfile);
 206                 }
 207                 catch (IncorrectOperationException incorrectoperationexception)
 208                 {
 209                     logger.error(incorrectoperationexception);
 210                 }
 211             }
 212
 213             files.set(i, null);
 214         }
 215
 216         if (indicator != null)
 217         {
 218             indicator.setText(msg);
 219             indicator.setFraction(fraction);
 220         }
 221
 222         return new Runnable()
 223         {
 224             public void run()
 225             {
 226                 ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
 227                 String msg = null;
 228                 double fraction = 0.0D;
 229                 if (indicator != null)
 230                 {
 231                     msg = indicator.getText();
 232                     fraction = indicator.getFraction();
 233                     indicator.setText(message);
 234                 }
 235
 236                 for (int j = 0; j < runnables.length; j++)
 237                 {
 238                     if (indicator != null)
 239                     {
 240                         if (indicator.isCanceled())
 241                         {
 242                             return;
 243                         }
 244
 245                         indicator.setFraction((double)j / (double)runnables.length);
 246                     }
 247
 248                     Runnable runnable = runnables[j];
 249                     if (runnable != null)
 250                     {
 251                         runnable.run();
 252                     }
 253                     runnables[j] = null;
 254                 }
 255
 256                 if (indicator != null)
 257                 {
 258                     indicator.setText(msg);
 259                     indicator.setFraction(fraction);
 260                 }
 261             }
 262         };
 263     }
 264
 265     private void process(final PsiFile[] files)
 266     {
 267         final Runnable[] resultRunnable = new Runnable[1];
 268         execute(new Runnable()
 269         {
 270             public void run()
 271             {
 272                 resultRunnable[0] = prepareFiles(new ArrayList<PsiFile>(Arrays.asList(files)));
 273             }
 274         }, new Runnable()
 275         {
 276             public void run()
 277             {
 278                 if (resultRunnable[0] != null)
 279                 {
 280                     resultRunnable[0].run();
 281                 }
 282             }
 283         });
 284     }
 285
 286     private void process(PsiDirectory dir, boolean subdirs)
 287     {
 288         List<PsiFile> pfiles = new ArrayList<PsiFile>();
 289         findFiles(pfiles, dir, subdirs);
 290         handleFiles(pfiles);
 291     }
 292
 293     private void process(Project project)
 294     {
 295         List<PsiFile> pfiles = new ArrayList<PsiFile>();
 296         findFiles(project, pfiles);
 297         handleFiles(pfiles);
 298     }
 299
 300     private void process(Module module)
 301     {
 302         List<PsiFile> pfiles = new ArrayList<PsiFile>();
 303         findFiles(module, pfiles);
 304         handleFiles(pfiles);
 305     }
 306
 307     private void findFiles(Project project, List<PsiFile> files)
 308     {
 309         Module[] modules = ModuleManager.getInstance(project).getModules();
 310         for (Module module : modules)
 311         {
 312             findFiles(module, files);
 313         }
 314
 315     }
 316
 317     private void findFiles(Module module, List<PsiFile> files)
 318     {
 319         VirtualFile[] roots = ModuleRootManager.getInstance(module).getContentRoots();
 320         for (VirtualFile file : roots)
 321         {
 322             PsiDirectory dir = PsiManager.getInstance(myProject).findDirectory(file);
 323             if (dir != null)
 324             {
 325                 findFiles(files, dir, true);
 326             }
 327         }
 328
 329     }
 330
 331     private void handleFiles(final List<PsiFile> files)
 332     {
 333         final List<VirtualFile> vFiles = new ArrayList<VirtualFile>();
 334         for (PsiFile psiFile : files) {
 335             vFiles.add(psiFile.getVirtualFile());
 336         }
 337         if (!ReadonlyStatusHandler.getInstance(myProject).ensureFilesWritable(vFiles.toArray(new VirtualFile[vFiles.size()])).hasReadonlyFiles()) {
 338             if (!files.isEmpty())
 339             {
 340                 final Runnable[] resultRunnable = new Runnable[1];
 341                 execute(new Runnable()
 342                 {
 343                     public void run()
 344                     {
 345                         resultRunnable[0] = prepareFiles(files);
 346                     }
 347                 }, new Runnable()
 348                 {
 349                     public void run()
 350                     {
 351                         if (resultRunnable[0] != null)
 352                         {
 353                             resultRunnable[0].run();
 354                         }
 355                     }
 356                 });
 357             }
 358         }
 359     }
 360
 361     private static void findFiles(List<PsiFile> files, PsiDirectory directory, boolean subdirs)
 362     {
 363         final Project project = directory.getProject();
 364         PsiFile[] locals = directory.getFiles();
 365         for (PsiFile local : locals)
 366         {
 367             CopyrightProfile opts = CopyrightManager.getInstance(project).getCopyrightOptions(local);
 368              if (opts != null && FileTypeUtil.getInstance().isSupportedFile(local)) {
 369                  files.add(local);
 370              }
 371
 372         }
 373
 374         if (subdirs)
 375         {
 376             PsiDirectory[] dirs = directory.getSubdirectories();
 377             for (PsiDirectory dir : dirs)
 378             {
 379                 findFiles(files, dir, subdirs);
 380             }
 381
 382         }
 383     }
 384
 385     private void execute(final Runnable readAction, final Runnable writeAction)
 386     {
 387         final ProgressWindow progressWindow = new ProgressWindow(true, myProject);
 388         progressWindow.setTitle(title);
 389         progressWindow.setText(message);
 390         final ModalityState modalityState = ModalityState.current();
 391         final Runnable process = new Runnable()
 392         {
 393             public void run()
 394             {
 395                 ApplicationManager.getApplication().runReadAction(readAction);
 396             }
 397         };
 398
 399         Runnable runnable = new Runnable()
 400         {
 401             public void run()
 402             {
 403                 try
 404                 {
 405                     ProgressManager.getInstance().runProcess(process, progressWindow);
 406                 }
 407                 catch (ProcessCanceledException processcanceledexception)
 408                 {
 409                     return;
 410                 }
 411
 412                 ApplicationManager.getApplication().invokeLater(new Runnable()
 413                 {
 414                     public void run()
 415                     {
 416                         CommandProcessor.getInstance().executeCommand(myProject, new Runnable()
 417                         {
 418                             public void run()
 419                             {
 420                                 CommandProcessor.getInstance().markCurrentCommandAsComplex(myProject);
 421                                 try
 422                                 {
 423                                     ApplicationManager.getApplication().runWriteAction(writeAction);
 424                                 }
 425                                 catch (ProcessCanceledException processcanceledexception)
 426                                 {
 427                                     return;
 428                                 }
 429                                 if (postProcess != null)
 430                                 {
 431                                     ApplicationManager.getApplication().invokeLater(postProcess);
 432                                 }
 433                             }
 434                         }, title, null);
 435                     }
 436                 }, modalityState);
 437             }
 438         };
 439
 440         (new Thread(runnable, title)).start();
 441     }
 442
 443     private static final Logger logger = Logger.getInstance(AbstractFileProcessor.class.getName());
 444 }