plugins/cvs/cvs-plugin/src/com/intellij/cvsSupport2/cvsoperations/javacvsSpecificImpls/AdminWriterOnCache.java

/*
 * 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 com.intellij.cvsSupport2.cvsoperations.javacvsSpecificImpls;

import com.intellij.cvsSupport2.CvsUtil;
import com.intellij.cvsSupport2.application.CvsEntriesManager;
import com.intellij.cvsSupport2.config.CvsApplicationLevelConfiguration;
import com.intellij.cvsSupport2.cvsoperations.common.UpdatedFilesManager;
import com.intellij.cvsSupport2.javacvsImpl.ProjectContentInfoProvider;
import com.intellij.cvsSupport2.util.CvsVfsUtil;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
import org.netbeans.lib.cvsclient.CvsRoot;
import org.netbeans.lib.cvsclient.IClientEnvironment;
import org.netbeans.lib.cvsclient.admin.AdminWriter;
import org.netbeans.lib.cvsclient.admin.Entry;
import org.netbeans.lib.cvsclient.admin.IAdminWriter;
import org.netbeans.lib.cvsclient.file.*;
import org.jetbrains.annotations.NotNull;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;

/**
 * author: lesya
 */
public class AdminWriterOnCache implements IAdminWriter {

  private static final Logger LOG = Logger.getInstance("#com.intellij.cvsSupport2.cvsoperations.javacvsSpecificImpls.AdminWriterOnCache");

  private final IAdminWriter myAdminWriter;
  private final CvsEntriesManager myCvsEntriesManager = CvsEntriesManager.getInstance();

  private final UpdatedFilesManager myUpdatedFilesManager;
  private final ProjectContentInfoProvider myProjectContentInfoProvider;

  public AdminWriterOnCache(UpdatedFilesManager updatedFilesManager,
                            ProjectContentInfoProvider projectContentInfoProvider) {
    myUpdatedFilesManager = updatedFilesManager;
    myProjectContentInfoProvider = projectContentInfoProvider;
    myAdminWriter = new AdminWriter(
      CodeStyleSettingsManager.getInstance().getCurrentSettings().getLineSeparator(),
      CvsApplicationLevelConfiguration.getCharset());    
  }

  public void ensureCvsDirectory(DirectoryObject directoryObject,
                                 String repositoryPath,
                                 CvsRoot cvsRoot,
                                 ICvsFileSystem cvsFileSystem) throws IOException {
    if (notUnderCvs(directoryObject, cvsFileSystem)) return;
    myAdminWriter.ensureCvsDirectory(directoryObject, repositoryPath, cvsRoot, cvsFileSystem);
    addDirectoryToParentEntriesFile(directoryObject, cvsFileSystem, cvsRoot.getCvsRoot());
  }

  private boolean notUnderCvs(AbstractFileObject directoryObject, ICvsFileSystem cvsFileSystem) {
    if (directoryObject == null) return false;
    final File directory = cvsFileSystem.getLocalFileSystem().getFile(directoryObject);
    return !myProjectContentInfoProvider.fileIsUnderProject(directory);
  }

  private void addDirectoryToParentEntriesFile(DirectoryObject directoryObject,
                                               ICvsFileSystem cvsFileSystem, String cvsRoot) throws IOException {
    DirectoryObject parentDirectoryObject = directoryObject.getParent();
    if (parentDirectoryObject == null) return;
    File directory = cvsFileSystem.getAdminFileSystem().getFile(directoryObject);
    final File parentDirectory = directory.getParentFile();
    if (parentDirectory == null) return;
    VirtualFile virtualParent = CvsVfsUtil.findFileByIoFile(parentDirectory);
    if (virtualParent == null) return;
    String directoryName = directory.getName();
    Entry entry = myCvsEntriesManager.getEntryFor(virtualParent, directoryName);

    if (entry == null) {
      if (CvsUtil.fileIsUnderCvs(virtualParent)
          && CvsEntriesManager.getInstance().getCvsConnectionSettingsFor(virtualParent)
        .getCvsRootAsString().equals(cvsRoot)) {
        setEntry(parentDirectoryObject,
                 Entry.createDirectoryEntry(directoryName),
                 cvsFileSystem);
      }
    }
  }


  public void setEntry(final DirectoryObject directoryObject, final Entry entry, final ICvsFileSystem cvsFileSystem)
    throws IOException {
    File parent = cvsFileSystem.getLocalFileSystem().getFile(directoryObject);
    if (myUpdatedFilesManager.fileIsNotUpdated(new File(parent, entry.getFileName()))) return;
    if (notUnderCvs(directoryObject, cvsFileSystem)) return;
    myAdminWriter.setEntry(directoryObject, entry, cvsFileSystem);
    VirtualFile virtualParent = CvsVfsUtil.findFileByIoFile(parent);
    Entry existing = myCvsEntriesManager.getEntryFor(virtualParent, entry.getFileName());
    if (existing == null) myUpdatedFilesManager.addNewlyCreatedEntry(entry);
  }

  public void removeEntryForFile(final AbstractFileObject fileObject, final ICvsFileSystem cvsFileSystem)
    throws IOException {
    if (notUnderCvs(fileObject, cvsFileSystem)) return;
    File file = cvsFileSystem.getLocalFileSystem().getFile(fileObject);
    if (myUpdatedFilesManager.fileIsNotUpdated(file)) return;
    myAdminWriter.removeEntryForFile(fileObject, cvsFileSystem);
  }

  public void pruneDirectory(DirectoryObject directoryObject, ICvsFileSystem cvsFileSystem) {
    LOG.error("Cannot be called");
  }

  public void editFile(FileObject fileObject,
                       Entry entry,
                       ICvsFileSystem cvsFileSystem,
                       IFileReadOnlyHandler fileReadOnlyHandler) throws IOException {
    myAdminWriter.editFile(fileObject, entry, cvsFileSystem, fileReadOnlyHandler);
    File editBackupFile = getEditBackupFile(fileObject, cvsFileSystem);
    final File file = cvsFileSystem.getAdminFileSystem().getFile(fileObject);
    editBackupFile.setLastModified(file.lastModified());
  }

  public void uneditFile(FileObject fileObject,
                         ICvsFileSystem cvsFileSystem,
                         IFileReadOnlyHandler fileReadOnlyHandler) throws IOException {
    final File file = cvsFileSystem.getAdminFileSystem().getFile(fileObject);
    final File editBackupFile = getEditBackupFile(fileObject, cvsFileSystem);

    if (!editBackupFile.isFile()) {
      return;
    }

    FileUtil.copy(editBackupFile, file);

    file.setLastModified(editBackupFile.lastModified());
    myAdminWriter.uneditFile(fileObject, cvsFileSystem, fileReadOnlyHandler);
  }

  private static File getEditBackupFile(FileObject fileObject, ICvsFileSystem cvsFileSystem) {
    final File file = cvsFileSystem.getAdminFileSystem().getFile(fileObject);
    return new File(file.getParentFile(), CvsUtil.CVS + File.separatorChar + CvsUtil.BASE + File.separatorChar + file.getName());
  }


  public void setStickyTagForDirectory(DirectoryObject directoryObject, String tag, ICvsFileSystem cvsFileSystem)
    throws IOException {
    myAdminWriter.setStickyTagForDirectory(directoryObject, tag, cvsFileSystem);
    File ioDirectory = cvsFileSystem.getLocalFileSystem().getFile(directoryObject);
    CvsEntriesManager.getInstance().getCvsInfoFor(CvsVfsUtil.findFileByIoFile(ioDirectory)).clearStickyInformation();
  }

  public void setEntriesDotStatic(DirectoryObject directoryObject, boolean set, ICvsFileSystem cvsFileSystem)
    throws IOException {
    myAdminWriter.setEntriesDotStatic(directoryObject, set, cvsFileSystem);
  }

  public void writeTemplateFile(@NotNull DirectoryObject directoryObject,
                                int fileLength,
                                InputStream inputStream,
                                IReaderFactory readerFactory,
                                IClientEnvironment clientEnvironment) throws IOException {
    myAdminWriter.writeTemplateFile(directoryObject, fileLength, inputStream, readerFactory, clientEnvironment);
  }

  public void directoryAdded(@NotNull DirectoryObject directoryObject, ICvsFileSystem cvsFileSystem) throws IOException {
    LOG.assertTrue(directoryObject.getParent() != null, directoryObject.getPath());

    File directory = cvsFileSystem.getLocalFileSystem().getFile(directoryObject);
    if (!myProjectContentInfoProvider.fileIsUnderProject(directory)) return;

    myAdminWriter.directoryAdded(directoryObject, cvsFileSystem);
    File ioDirectory = cvsFileSystem.getLocalFileSystem().getFile(directoryObject);
    CvsEntriesManager.getInstance().getCvsInfoFor(CvsVfsUtil.findFileByIoFile(ioDirectory)).clearAll();
  }
}