plugins/cvs/cvs-plugin/src/com/intellij/cvsSupport2/application/CvsStorageSupportingDeletionComponent.java

   1 /*
   2  * Copyright 2000-2009 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 package com.intellij.cvsSupport2.application;
  17
  18 import com.intellij.cvsSupport2.CvsUtil;
  19 import com.intellij.cvsSupport2.CvsVcs2;
  20 import com.intellij.openapi.application.PathManager;
  21 import com.intellij.openapi.command.CommandEvent;
  22 import com.intellij.openapi.command.CommandListener;
  23 import com.intellij.openapi.command.CommandProcessor;
  24 import com.intellij.openapi.components.ServiceManager;
  25 import com.intellij.openapi.diagnostic.Logger;
  26 import com.intellij.openapi.project.Project;
  27 import com.intellij.openapi.util.Key;
  28 import com.intellij.openapi.vcs.AbstractVcs;
  29 import com.intellij.openapi.vcs.ProjectLevelVcsManager;
  30 import com.intellij.openapi.vfs.*;
  31
  32 import java.io.File;
  33
  34 public class CvsStorageSupportingDeletionComponent extends CvsStorageComponent implements CommandListener {
  35   private static final Logger LOG = Logger.getInstance("#" + CvsStorageSupportingDeletionComponent.class.getName());
  36   private Project myProject;
  37
  38   private DeletedCVSDirectoryStorage myDeletedStorage;
  39   private DeleteHandler myDeleteHandler = null;
  40   private AddHandler myAddHandler = null;
  41   private CvsFileOperationsHandler myFileOperationsHandler;
  42
  43   private int myCommandLevel = 0;
  44
  45   private boolean myAnotherProjectCommand = false;
  46   static final Key<AbstractVcs> FILE_VCS = new Key<AbstractVcs>("File VCS");
  47
  48   public void commandStarted(CommandEvent event) {
  49     myCommandLevel++;
  50     if (myCommandLevel == 1) {
  51       myAnotherProjectCommand = (event.getProject() != null) != (event.getProject() == myProject);
  52     }
  53
  54     if (LOG.isDebugEnabled()) {
  55       LOG.debug("Started" + event.getCommandName() + ", commandLevel: " + myCommandLevel);
  56     }
  57   }
  58
  59   public void beforeCommandFinished(CommandEvent event) {
  60
  61   }
  62
  63   public void undoTransparentActionStarted() {
  64   }
  65
  66   public void undoTransparentActionFinished() {
  67   }
  68
  69   public void commandFinished(CommandEvent event) {
  70     myCommandLevel--;
  71     if (myCommandLevel == 0) myAnotherProjectCommand = false;
  72     if (LOG.isDebugEnabled()) {
  73       LOG.debug("Finished" + event.getCommandName() + ", commandLevel: " + myCommandLevel);
  74     }
  75     execute();
  76   }
  77
  78   public void init(Project project, boolean sync) {
  79     myProject = project;
  80     initializeDeletedStorage();
  81     VirtualFileManager.getInstance().addVirtualFileListener(this);
  82     CvsEntriesManager.getInstance().registerAsVirtualFileListener();
  83     CommandProcessor.getInstance().addCommandListener(this);
  84     myFileOperationsHandler = new CvsFileOperationsHandler(project, this);
  85     LocalFileSystem.getInstance().registerAuxiliaryFileOperationsHandler(myFileOperationsHandler);
  86     myIsActive = true;
  87   }
  88
  89   public void dispose() {
  90     VirtualFileManager.getInstance().removeVirtualFileListener(this);
  91     CvsEntriesManager.getInstance().unregisterAsVirtualFileListener();
  92     CommandProcessor.getInstance().removeCommandListener(this);
  93     LocalFileSystem.getInstance().unregisterAuxiliaryFileOperationsHandler(myFileOperationsHandler);
  94     myFileOperationsHandler = null;
  95     myIsActive = false;
  96     myProject = null;
  97   }
  98
  99   public void beforeFileDeletion(VirtualFileEvent event) {
 100   }
 101
 102   public DeleteHandler getDeleteHandler() {
 103     if (myDeleteHandler == null) {
 104       myDeleteHandler = myDeletedStorage.createDeleteHandler(myProject, this);
 105     }
 106     return myDeleteHandler;
 107   }
 108
 109   public void fileDeleted(VirtualFileEvent event) {
 110   }
 111
 112   private boolean shouldProcessEvent(VirtualFileEvent event, boolean parentShouldBeUnderCvs) {
 113     if (myAnotherProjectCommand) return false;
 114     VirtualFile file = event.getFile();
 115     if (disabled(file)) return false;
 116     if (event.isFromRefresh()) return false;
 117     if (isStorageEvent(event)) return false;
 118     if (!isUnderCvsManagedModuleRoot(file)) return false;
 119     return !(parentShouldBeUnderCvs && !parentIsUnderCvs(file));
 120   }
 121
 122   private static boolean isStorageEvent(VirtualFileEvent event) {
 123     return event.getRequestor() instanceof DeletedCVSDirectoryStorage;
 124   }
 125
 126   private static boolean parentIsUnderCvs(VirtualFile file) {
 127     return CvsUtil.fileIsUnderCvs(file.getParent());
 128   }
 129
 130   public void beforeFileMovement(VirtualFileMoveEvent event) {
 131   }
 132
 133   public void fileMoved(VirtualFileMoveEvent event) {
 134     fileCreated(event);
 135   }
 136
 137   private boolean processMoveOrRename() {
 138     return myDeleteHandler != null;
 139   }
 140
 141   private AbstractVcs getFileVcs(VirtualFile file) {
 142     AbstractVcs storedData = file.getUserData(FILE_VCS);
 143     if (storedData != null) {
 144       return storedData;
 145     }
 146     else {
 147       return ProjectLevelVcsManager.getInstance(myProject).getVcsFor(file);
 148     }
 149   }
 150
 151   private boolean isUnderCvsManagedModuleRoot(VirtualFile file) {
 152     return getFileVcs(file) == CvsVcs2.getInstance(myProject);
 153   }
 154
 155   private boolean disabled(VirtualFile file) {
 156     return ProjectLevelVcsManager.getInstance(myProject).getVcsFor(file) !=
 157            CvsVcs2.getInstance(myProject);
 158   }
 159
 160   public void beforePropertyChange(VirtualFilePropertyEvent event) {
 161     if (!event.getPropertyName().equals(VirtualFile.PROP_NAME)) return;
 162     if (!CvsUtil.fileIsUnderCvs(event.getFile())) return;
 163     beforeFileDeletion(event);
 164   }
 165
 166   public void propertyChanged(VirtualFilePropertyEvent event) {
 167     if (processMoveOrRename()) {
 168       fileDeleted(event);
 169       fileCreated(event);
 170     }
 171   }
 172
 173   public void fileCreated(final VirtualFileEvent event) {
 174     if (!shouldProcessEvent(event, false)) return;
 175     final Project project = myProject;
 176     if (project == null) return;    // already disposed
 177
 178     final VirtualFile file = event.getFile();
 179     if (myDeleteHandler != null) {
 180       myDeleteHandler.removeDeletedRoot(file);
 181     }
 182     myDeletedStorage.checkNeedForPurge(VfsUtil.virtualToIoFile(file));
 183     deleteIfAdminDirCreated(file);
 184     getAddHandler().addFile(file);
 185
 186     execute();
 187   }
 188
 189   public AddHandler getAddHandler() {
 190     if (myAddHandler == null) {
 191       myAddHandler = new AddHandler(myProject, this);
 192     }
 193     return myAddHandler;
 194   }
 195
 196   private void execute() {
 197     if (myCommandLevel > 0) return;
 198     //myDeletedStorage.sync();
 199     if (myDeleteHandler != null) myDeleteHandler.execute();
 200     if (myAddHandler != null) myAddHandler.execute();
 201
 202     myDeleteHandler = null;
 203     myAddHandler = null;
 204   }
 205
 206   private void initializeDeletedStorage() {
 207     File storageRoot = getStorageRoot();
 208     storageRoot.mkdirs();
 209     myDeletedStorage = new DeletedCVSDirectoryStorage(storageRoot);
 210   }
 211
 212   private static File getStorageRoot() {
 213     //noinspection HardCodedStringLiteral
 214     return new File(PathManager.getSystemPath(), "CVS-TO-DELETE");
 215   }
 216
 217   public void sync() {
 218     //myDeletedStorage.sync();
 219   }
 220
 221   public static CvsStorageComponent getInstance(Project project) {
 222     return ServiceManager.getService(project, CvsStorageComponent.class);
 223   }
 224
 225   public void deleteIfAdminDirCreated(VirtualFile addedFile) {
 226     myDeletedStorage.deleteIfAdminDirCreated(addedFile);
 227   }
 228 }