plugins/svn4idea/src/org/jetbrains/idea/svn/SvnRecursiveStatusWalker.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2009 JetBrains s.r.o.
  *
  * 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 org.jetbrains.idea.svn;

 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vcs.FilePath;
 import com.intellij.openapi.vcs.FilePathImpl;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.Processor;
 import com.intellij.vcsUtil.VcsUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.idea.svn.api.Depth;
 import org.jetbrains.idea.svn.commandLine.SvnBindException;
 import org.jetbrains.idea.svn.status.Status;
 import org.jetbrains.idea.svn.status.StatusClient;
 import org.jetbrains.idea.svn.status.StatusConsumer;
 import org.jetbrains.idea.svn.status.StatusType;
 import org.tmatesoft.svn.core.SVNErrorCode;
 import org.tmatesoft.svn.core.SVNException;
 import org.tmatesoft.svn.core.internal.wc.SVNFileUtil;
 import org.tmatesoft.svn.core.wc.SVNRevision;

 import java.io.File;
 import java.util.LinkedList;

 public class SvnRecursiveStatusWalker {
   private static final Logger LOG = Logger.getInstance("#org.jetbrains.idea.svn.SvnRecursiveStatusWalker");
   private final StatusWalkerPartner myPartner;
   private final SvnVcs myVcs;
   private final Project myProject;
   private final StatusReceiver myReceiver;
   private final LinkedList<MyItem> myQueue;
   private final MyHandler myHandler;

   public SvnRecursiveStatusWalker(final SvnVcs vcs, final StatusReceiver receiver, final StatusWalkerPartner partner) {
     myVcs = vcs;
     myProject = vcs.getProject();
     myReceiver = receiver;
     myPartner = partner;
     myQueue = new LinkedList<MyItem>();
     myHandler = new MyHandler();
   }

   public void go(final FilePath rootPath, final Depth depth) throws SvnBindException {
     final MyItem root = createItem(rootPath, depth, false);
     myQueue.add(root);

     while (! myQueue.isEmpty()) {
       myPartner.checkCanceled();

       final MyItem item = myQueue.removeFirst();
       final FilePath path = item.getPath();
       final File ioFile = path.getIOFile();

       if (path.isDirectory()) {
         myHandler.setCurrentItem(item);
         try {
           final StatusClient client = item.getClient();
           client.doStatus(ioFile, SVNRevision.WORKING, item.getDepth(), false, false, true, true, myHandler, null);
           myHandler.checkIfCopyRootWasReported(null, ioFile);
         }
         catch (SvnBindException e) {
           handleStatusException(item, path, e);
         }
       } else {
         try {
           final Status status = item.getClient().doStatus(ioFile, false);
           myReceiver.process(path, status);
         }
         catch (SvnBindException e) {
           handleStatusException(item, path, e);
         }
         catch (SVNException e) {
           handleStatusException(item, path, new SvnBindException(e));
         }
       }
     }
   }

   private void handleStatusException(MyItem item, FilePath path, SvnBindException e) throws SvnBindException {
     if (e.contains(SVNErrorCode.WC_NOT_DIRECTORY) || e.contains(SVNErrorCode.WC_NOT_FILE)) {
       final VirtualFile virtualFile = path.getVirtualFile();
       if (virtualFile != null) {
         if (! myPartner.isIgnoredByVcs(virtualFile)) {
           // self is unversioned
           myReceiver.processUnversioned(virtualFile);

           if (virtualFile.isDirectory()) {
             processRecursively(virtualFile, item.getDepth());
           }
         }
       }
     } else {
       throw e;
     }
   }

   private static class MyItem {
     @NotNull private final FilePath myPath;
     @NotNull private final Depth myDepth;
     @NotNull private final StatusClient myStatusClient;
     private final boolean myIsInnerCopyRoot;

     private MyItem(@NotNull FilePath path, @NotNull Depth depth, boolean isInnerCopyRoot, @NotNull StatusClient statusClient) {
       myPath = path;
       myDepth = depth;
       myStatusClient = statusClient;
       myIsInnerCopyRoot = isInnerCopyRoot;
     }

     @NotNull
     public FilePath getPath() {
       return myPath;
     }

     @NotNull
     public Depth getDepth() {
       return myDepth;
     }

     @NotNull
     public StatusClient getClient() {
       return myStatusClient;
     }

     public boolean isIsInnerCopyRoot() {
       return myIsInnerCopyRoot;
     }
   }

   private void processRecursively(final VirtualFile vFile, final Depth prevDepth) {
     if (Depth.EMPTY.equals(prevDepth)) return;
     if (myPartner.isIgnoredIdeaLevel(vFile)) {
       myReceiver.processIgnored(vFile);
       return;
     }
     final Depth newDepth = Depth.INFINITY.equals(prevDepth) ? Depth.INFINITY : Depth.EMPTY;

     final File ioFile = new File(vFile.getPath());
     final Processor<File> processor;
     final Processor<File> directoryFilter;
     final Ref<File> lastIgnored = new Ref<File>();
     final Processor<File> checkDirProcessor = new Processor<File>() {
       @Override
       public boolean process(File file) {
         final FilePathImpl path = new FilePathImpl(file, true);
         path.refresh();
         path.hardRefresh();
         VirtualFile vf = path.getVirtualFile();
         if (vf != null && myPartner.isIgnoredIdeaLevel(vf)) {
           lastIgnored.set(file);
           myReceiver.processIgnored(vf);
           return true;
         }
         if (file.isDirectory() && new File(file, SVNFileUtil.getAdminDirectoryName()).exists()) {
           final MyItem childItem = createItem(path, newDepth, true);
           myQueue.add(childItem);
         } else if (vf != null) {
           myReceiver.processUnversioned(vf);
         }
         return true;
       }
     };
     if (Depth.EMPTY.equals(newDepth)) {
       // just process immediate children - so only root directory itself should satisfy filter
       directoryFilter = new Processor<File>() {
         @Override
         public boolean process(File file) {
           return FileUtil.filesEqual(ioFile, file);
         }
       };
       processor = new Processor<File>() {
         @Override
         public boolean process(File file) {
           // TODO: check if we should still call checkDirProcessor() here - or we really could not check ignore settings but just call
           // TODO: myReceiver.processUnversioned() for all immediate children
           // here we deal only with immediate children - so ignored on IDEA level for children is not important
           return FileUtil.filesEqual(ioFile, file) || checkDirProcessor.process(file);
         }
       };
     } else {
       directoryFilter = new Processor<File>() {
         @Override
         public boolean process(File file) {
           return ! Comparing.equal(lastIgnored, file) && (myQueue.isEmpty() || ! FileUtil.filesEqual(myQueue.getLast().getPath().getIOFile(), file));
         }
       };
       processor = checkDirProcessor;
     }
     FileUtil.processFilesRecursively(ioFile, processor, directoryFilter);
   }

   @NotNull
   private MyItem createItem(@NotNull FilePath path, @NotNull Depth depth, boolean isInnerCopyRoot) {
     StatusClient statusClient =
       myVcs.getFactory(path.getIOFile()).createStatusClient(myPartner.getFileProvider(), myPartner.getEventHandler());

     return new MyItem(path, depth, isInnerCopyRoot, statusClient);
   }

   private class MyHandler implements StatusConsumer {
     private MyItem myCurrentItem;
     private boolean myMetCurrentItem;

     public void setCurrentItem(MyItem currentItem) {
       myCurrentItem = currentItem;
       myMetCurrentItem = false;
     }

     public void checkIfCopyRootWasReported(@Nullable final Status ioFileStatus, final File ioFile) {
       File itemFile = myCurrentItem.getPath().getIOFile();
       if (! myMetCurrentItem && FileUtil.filesEqual(ioFile, itemFile)) {
         myMetCurrentItem = true;
         Status statusInner;
         try {
           statusInner = ioFileStatus != null ? ioFileStatus : myCurrentItem.getClient().doStatus(itemFile, false);
         }
         catch (SvnBindException e) {
           LOG.info(e);
           statusInner = null;
         }
         if (statusInner == null)  return;

         final StatusType status = statusInner.getNodeStatus();
         final VirtualFile vf = myCurrentItem.getPath().getVirtualFile();
         if (StatusType.STATUS_IGNORED.equals(status)) {
           if (vf != null) {
             myReceiver.processIgnored(vf);
           }
           return;
         }
         if (StatusType.STATUS_UNVERSIONED.equals(status) || StatusType.UNKNOWN.equals(status)) {
           if (vf != null) {
             myReceiver.processUnversioned(vf);
             processRecursively(vf, myCurrentItem.getDepth());
           }
           return;
         }
         if (StatusType.OBSTRUCTED.equals(status) || StatusType.STATUS_NONE.equals(status)) {
           return;
         }
         if (vf != null) {
           if (myCurrentItem.isIsInnerCopyRoot()) {
             myReceiver.processCopyRoot(vf, statusInner.getURL(), myVcs.getWorkingCopyFormat(ioFile), statusInner.getRepositoryRootURL());
           } else {
             myReceiver.bewareRoot(vf, statusInner.getURL());
           }
         }
       }
     }

     @Override
     public void consume(final Status status) throws SVNException {
       myPartner.checkCanceled();
       final File ioFile = status.getFile();
       checkIfCopyRootWasReported(status, ioFile);

       final VirtualFile vFile = getVirtualFile(ioFile);
       if (vFile != null) {
         final Boolean excluded = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
           @Override
           public Boolean compute() {
             if (myProject.isDisposed()) return null;
             return myPartner.isIgnoredByVcs(vFile);
           }
         });
         if (Boolean.TRUE.equals(excluded)) return;
       }
       if (myProject.isDisposed()) throw new ProcessCanceledException();

       if ((vFile != null) && (status.is(StatusType.STATUS_UNVERSIONED))) {
         if (vFile.isDirectory()) {
           if (FileUtil.filesEqual(myCurrentItem.getPath().getIOFile(), ioFile)) {
             //myReceiver.processUnversioned(vFile);
             //processRecursively(vFile, myCurrentItem.getDepth());
           } else {
             final MyItem childItem = createItem(new FilePathImpl(vFile), Depth.INFINITY, true);
             myQueue.add(childItem);
           }
         } else {
           myReceiver.processUnversioned(vFile);
         }
       } else {
         final FilePath path = VcsUtil.getFilePath(ioFile, status.getKind().isDirectory());
         myReceiver.process(path, status);
       }
     }
   }

   private static VirtualFile getVirtualFile(File ioFile) {
     final LocalFileSystem lfs = LocalFileSystem.getInstance();
     VirtualFile vFile = lfs.findFileByIoFile(ioFile);
     if (vFile == null) {
       vFile = lfs.refreshAndFindFileByIoFile(ioFile);
     }
     return vFile;
   }
 }
	/*
	* Copyright 2000-2009 JetBrains s.r.o.
	*
	* 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 org.jetbrains.idea.svn;

	import com.intellij.openapi.application.ApplicationManager;
	import com.intellij.openapi.diagnostic.Logger;
	import com.intellij.openapi.progress.ProcessCanceledException;
	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.util.Comparing;
	import com.intellij.openapi.util.Computable;
	import com.intellij.openapi.util.Ref;
	import com.intellij.openapi.util.io.FileUtil;
	import com.intellij.openapi.vcs.FilePath;
	import com.intellij.openapi.vcs.FilePathImpl;
	import com.intellij.openapi.vfs.LocalFileSystem;
	import com.intellij.openapi.vfs.VirtualFile;
	import com.intellij.util.Processor;
	import com.intellij.vcsUtil.VcsUtil;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;
	import org.jetbrains.idea.svn.api.Depth;
	import org.jetbrains.idea.svn.commandLine.SvnBindException;
	import org.jetbrains.idea.svn.status.Status;
	import org.jetbrains.idea.svn.status.StatusClient;
	import org.jetbrains.idea.svn.status.StatusConsumer;
	import org.jetbrains.idea.svn.status.StatusType;
	import org.tmatesoft.svn.core.SVNErrorCode;
	import org.tmatesoft.svn.core.SVNException;
	import org.tmatesoft.svn.core.internal.wc.SVNFileUtil;
	import org.tmatesoft.svn.core.wc.SVNRevision;

	import java.io.File;
	import java.util.LinkedList;

	public class SvnRecursiveStatusWalker {
	private static final Logger LOG = Logger.getInstance("#org.jetbrains.idea.svn.SvnRecursiveStatusWalker");
	private final StatusWalkerPartner myPartner;
	private final SvnVcs myVcs;
	private final Project myProject;
	private final StatusReceiver myReceiver;
	private final LinkedList<MyItem> myQueue;
	private final MyHandler myHandler;

	public SvnRecursiveStatusWalker(final SvnVcs vcs, final StatusReceiver receiver, final StatusWalkerPartner partner) {
	myVcs = vcs;
	myProject = vcs.getProject();
	myReceiver = receiver;
	myPartner = partner;
	myQueue = new LinkedList<MyItem>();
	myHandler = new MyHandler();
	}

	public void go(final FilePath rootPath, final Depth depth) throws SvnBindException {
	final MyItem root = createItem(rootPath, depth, false);
	myQueue.add(root);

	while (! myQueue.isEmpty()) {
	myPartner.checkCanceled();

	final MyItem item = myQueue.removeFirst();
	final FilePath path = item.getPath();
	final File ioFile = path.getIOFile();

	if (path.isDirectory()) {
	myHandler.setCurrentItem(item);
	try {
	final StatusClient client = item.getClient();
	client.doStatus(ioFile, SVNRevision.WORKING, item.getDepth(), false, false, true, true, myHandler, null);
	myHandler.checkIfCopyRootWasReported(null, ioFile);
	}
	catch (SvnBindException e) {
	handleStatusException(item, path, e);
	}
	} else {
	try {
	final Status status = item.getClient().doStatus(ioFile, false);
	myReceiver.process(path, status);
	}
	catch (SvnBindException e) {
	handleStatusException(item, path, e);
	}
	catch (SVNException e) {
	handleStatusException(item, path, new SvnBindException(e));
	}
	}
	}
	}

	private void handleStatusException(MyItem item, FilePath path, SvnBindException e) throws SvnBindException {
	if (e.contains(SVNErrorCode.WC_NOT_DIRECTORY) \|\| e.contains(SVNErrorCode.WC_NOT_FILE)) {
	final VirtualFile virtualFile = path.getVirtualFile();
	if (virtualFile != null) {
	if (! myPartner.isIgnoredByVcs(virtualFile)) {
	// self is unversioned
	myReceiver.processUnversioned(virtualFile);

	if (virtualFile.isDirectory()) {
	processRecursively(virtualFile, item.getDepth());
	}
	}
	}
	} else {
	throw e;
	}
	}

	private static class MyItem {
	@NotNull private final FilePath myPath;
	@NotNull private final Depth myDepth;
	@NotNull private final StatusClient myStatusClient;
	private final boolean myIsInnerCopyRoot;

	private MyItem(@NotNull FilePath path, @NotNull Depth depth, boolean isInnerCopyRoot, @NotNull StatusClient statusClient) {
	myPath = path;
	myDepth = depth;
	myStatusClient = statusClient;
	myIsInnerCopyRoot = isInnerCopyRoot;
	}

	@NotNull
	public FilePath getPath() {
	return myPath;
	}

	@NotNull
	public Depth getDepth() {
	return myDepth;
	}

	@NotNull
	public StatusClient getClient() {
	return myStatusClient;
	}

	public boolean isIsInnerCopyRoot() {
	return myIsInnerCopyRoot;
	}
	}

	private void processRecursively(final VirtualFile vFile, final Depth prevDepth) {
	if (Depth.EMPTY.equals(prevDepth)) return;
	if (myPartner.isIgnoredIdeaLevel(vFile)) {
	myReceiver.processIgnored(vFile);
	return;
	}
	final Depth newDepth = Depth.INFINITY.equals(prevDepth) ? Depth.INFINITY : Depth.EMPTY;

	final File ioFile = new File(vFile.getPath());
	final Processor<File> processor;
	final Processor<File> directoryFilter;
	final Ref<File> lastIgnored = new Ref<File>();
	final Processor<File> checkDirProcessor = new Processor<File>() {
	@Override
	public boolean process(File file) {
	final FilePathImpl path = new FilePathImpl(file, true);
	path.refresh();
	path.hardRefresh();
	VirtualFile vf = path.getVirtualFile();
	if (vf != null && myPartner.isIgnoredIdeaLevel(vf)) {
	lastIgnored.set(file);
	myReceiver.processIgnored(vf);
	return true;
	}
	if (file.isDirectory() && new File(file, SVNFileUtil.getAdminDirectoryName()).exists()) {
	final MyItem childItem = createItem(path, newDepth, true);
	myQueue.add(childItem);
	} else if (vf != null) {
	myReceiver.processUnversioned(vf);
	}
	return true;
	}
	};
	if (Depth.EMPTY.equals(newDepth)) {
	// just process immediate children - so only root directory itself should satisfy filter
	directoryFilter = new Processor<File>() {
	@Override
	public boolean process(File file) {
	return FileUtil.filesEqual(ioFile, file);
	}
	};
	processor = new Processor<File>() {
	@Override
	public boolean process(File file) {
	// TODO: check if we should still call checkDirProcessor() here - or we really could not check ignore settings but just call
	// TODO: myReceiver.processUnversioned() for all immediate children
	// here we deal only with immediate children - so ignored on IDEA level for children is not important
	return FileUtil.filesEqual(ioFile, file) \|\| checkDirProcessor.process(file);
	}
	};
	} else {
	directoryFilter = new Processor<File>() {
	@Override
	public boolean process(File file) {
	return ! Comparing.equal(lastIgnored, file) && (myQueue.isEmpty() \|\| ! FileUtil.filesEqual(myQueue.getLast().getPath().getIOFile(), file));
	}
	};
	processor = checkDirProcessor;
	}
	FileUtil.processFilesRecursively(ioFile, processor, directoryFilter);
	}

	@NotNull
	private MyItem createItem(@NotNull FilePath path, @NotNull Depth depth, boolean isInnerCopyRoot) {
	StatusClient statusClient =
	myVcs.getFactory(path.getIOFile()).createStatusClient(myPartner.getFileProvider(), myPartner.getEventHandler());

	return new MyItem(path, depth, isInnerCopyRoot, statusClient);
	}

	private class MyHandler implements StatusConsumer {
	private MyItem myCurrentItem;
	private boolean myMetCurrentItem;

	public void setCurrentItem(MyItem currentItem) {
	myCurrentItem = currentItem;
	myMetCurrentItem = false;
	}

	public void checkIfCopyRootWasReported(@Nullable final Status ioFileStatus, final File ioFile) {
	File itemFile = myCurrentItem.getPath().getIOFile();
	if (! myMetCurrentItem && FileUtil.filesEqual(ioFile, itemFile)) {
	myMetCurrentItem = true;
	Status statusInner;
	try {
	statusInner = ioFileStatus != null ? ioFileStatus : myCurrentItem.getClient().doStatus(itemFile, false);
	}
	catch (SvnBindException e) {
	LOG.info(e);
	statusInner = null;
	}
	if (statusInner == null) return;

	final StatusType status = statusInner.getNodeStatus();
	final VirtualFile vf = myCurrentItem.getPath().getVirtualFile();
	if (StatusType.STATUS_IGNORED.equals(status)) {
	if (vf != null) {
	myReceiver.processIgnored(vf);
	}
	return;
	}
	if (StatusType.STATUS_UNVERSIONED.equals(status) \|\| StatusType.UNKNOWN.equals(status)) {
	if (vf != null) {
	myReceiver.processUnversioned(vf);
	processRecursively(vf, myCurrentItem.getDepth());
	}
	return;
	}
	if (StatusType.OBSTRUCTED.equals(status) \|\| StatusType.STATUS_NONE.equals(status)) {
	return;
	}
	if (vf != null) {
	if (myCurrentItem.isIsInnerCopyRoot()) {
	myReceiver.processCopyRoot(vf, statusInner.getURL(), myVcs.getWorkingCopyFormat(ioFile), statusInner.getRepositoryRootURL());
	} else {
	myReceiver.bewareRoot(vf, statusInner.getURL());
	}
	}
	}
	}

	@Override
	public void consume(final Status status) throws SVNException {
	myPartner.checkCanceled();
	final File ioFile = status.getFile();
	checkIfCopyRootWasReported(status, ioFile);

	final VirtualFile vFile = getVirtualFile(ioFile);
	if (vFile != null) {
	final Boolean excluded = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
	@Override
	public Boolean compute() {
	if (myProject.isDisposed()) return null;
	return myPartner.isIgnoredByVcs(vFile);
	}
	});
	if (Boolean.TRUE.equals(excluded)) return;
	}
	if (myProject.isDisposed()) throw new ProcessCanceledException();

	if ((vFile != null) && (status.is(StatusType.STATUS_UNVERSIONED))) {
	if (vFile.isDirectory()) {
	if (FileUtil.filesEqual(myCurrentItem.getPath().getIOFile(), ioFile)) {
	//myReceiver.processUnversioned(vFile);
	//processRecursively(vFile, myCurrentItem.getDepth());
	} else {
	final MyItem childItem = createItem(new FilePathImpl(vFile), Depth.INFINITY, true);
	myQueue.add(childItem);
	}
	} else {
	myReceiver.processUnversioned(vFile);
	}
	} else {
	final FilePath path = VcsUtil.getFilePath(ioFile, status.getKind().isDirectory());
	myReceiver.process(path, status);
	}
	}
	}

	private static VirtualFile getVirtualFile(File ioFile) {
	final LocalFileSystem lfs = LocalFileSystem.getInstance();
	VirtualFile vFile = lfs.findFileByIoFile(ioFile);
	if (vFile == null) {
	vFile = lfs.refreshAndFindFileByIoFile(ioFile);
	}
	return vFile;
	}
	}