plugins/cvs/cvs-plugin/src/com/intellij/cvsSupport2/impl/CvsServicesImpl.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.impl;
  17
  18 import com.intellij.CvsBundle;
  19 import com.intellij.cvsSupport2.config.CvsApplicationLevelConfiguration;
  20 import com.intellij.cvsSupport2.config.CvsRootConfiguration;
  21 import com.intellij.cvsSupport2.config.DateOrRevisionSettings;
  22 import com.intellij.cvsSupport2.connections.CvsConnectionSettings;
  23 import com.intellij.cvsSupport2.connections.IDEARootFormatter;
  24 import com.intellij.cvsSupport2.connections.pserver.PServerLoginProvider;
  25 import com.intellij.cvsSupport2.cvsExecution.CvsOperationExecutor;
  26 import com.intellij.cvsSupport2.cvsExecution.CvsOperationExecutorCallback;
  27 import com.intellij.cvsSupport2.cvshandlers.CommandCvsHandler;
  28 import com.intellij.cvsSupport2.cvsoperations.cvsCheckOut.CheckoutProjectOperation;
  29 import com.intellij.cvsSupport2.cvsoperations.cvsContent.GetFileContentOperation;
  30 import com.intellij.cvsSupport2.cvsoperations.dateOrRevision.RevisionOrDate;
  31 import com.intellij.cvsSupport2.cvsoperations.dateOrRevision.RevisionOrDateImpl;
  32 import com.intellij.cvsSupport2.cvsoperations.dateOrRevision.SimpleRevision;
  33 import com.intellij.cvsSupport2.history.ComparableVcsRevisionOnOperation;
  34 import com.intellij.openapi.components.ApplicationComponent;
  35 import com.intellij.openapi.cvsIntegration.CvsModule;
  36 import com.intellij.openapi.cvsIntegration.CvsRepository;
  37 import com.intellij.openapi.cvsIntegration.CvsResult;
  38 import com.intellij.openapi.cvsIntegration.CvsServices;
  39 import com.intellij.openapi.diagnostic.Logger;
  40 import com.intellij.openapi.fileEditor.FileEditorManager;
  41 import com.intellij.openapi.fileEditor.OpenFileDescriptor;
  42 import com.intellij.openapi.project.Project;
  43 import com.intellij.openapi.vcs.AbstractVcsHelper;
  44 import com.intellij.openapi.vcs.vfs.VcsFileSystem;
  45 import com.intellij.openapi.vcs.vfs.VcsVirtualFile;
  46 import org.netbeans.lib.cvsclient.command.KeywordSubstitution;
  47
  48 import java.io.File;
  49 import java.io.IOException;
  50 import java.util.List;
  51
  52 /**
  53  * author: lesya
  54  */
  55 public class CvsServicesImpl extends CvsServices implements ApplicationComponent {
  56
  57   private static final Logger LOG = Logger.getInstance("#com.intellij.cvsSupport2.impl.CvsServicesImpl");
  58
  59   public CvsModule[] chooseModules(Project project,
  60                                    boolean allowRootSelection,
  61                                    boolean allowMultipleSelection,
  62                                    boolean allowFilesSelection, String title, String selectModulePageTitle) {
  63     ModuleChooser moduleChooser = new ModuleChooser(project,
  64                                                     allowFilesSelection,
  65                                                     allowMultipleSelection,
  66                                                     allowRootSelection,
  67                                                     title,
  68                                                     selectModulePageTitle);
  69     moduleChooser.show();
  70
  71     if (!moduleChooser.isOK()) return null;
  72
  73     return moduleChooser.getSelectedModules();
  74   }
  75
  76   public CvsRepository[] getConfiguredRepositories() {
  77     List configurations = CvsApplicationLevelConfiguration.getInstance().CONFIGURATIONS;
  78     CvsRepository[] result = new CvsRepository[configurations.size()];
  79     for (int i = 0; i < configurations.size(); i++) {
  80       result[i] = ((CvsRootConfiguration)configurations.get(i)).createCvsRepository();
  81     }
  82     return result;
  83   }
  84
  85   private ComparableVcsRevisionOnOperation createCvsVersionOn(CvsModule module, Project project) {
  86     final CvsRootConfiguration rootConfiguration = CvsApplicationLevelConfiguration.getInstance()
  87       .getConfigurationForCvsRoot(module.getRepository()
  88         .getStringRepresentation());
  89     CvsConnectionSettings env = new IDEARootFormatter(rootConfiguration).createConfiguration();
  90
  91     GetFileContentOperation operation = new GetFileContentOperation(new File(module.getPathInCvs()),
  92                                                                     env, new SimpleRevision(module.getRevision())
  93     );
  94
  95     return new ComparableVcsRevisionOnOperation(operation, project);
  96
  97   }
  98
  99   public void showDifferencesForFiles(CvsModule first, CvsModule second, Project project) throws Exception {
 100     AbstractVcsHelper.getInstance(project).showDifferences(
 101       createCvsVersionOn(first, project),
 102       createCvsVersionOn(second, project),
 103       new File(first.getPathInCvs()));
 104   }
 105
 106   public String getScrambledPasswordForPServerCvsRoot(String cvsRoot) {
 107     return PServerLoginProvider.getInstance()
 108       .getScrambledPasswordForCvsRoot(cvsRoot);
 109   }
 110
 111   public String getComponentName() {
 112     return "CvsServices";
 113   }
 114
 115   public void initComponent() { }
 116
 117   public void disposeComponent() {
 118   }
 119
 120   public boolean saveRepository(CvsRepository repository) {
 121     CvsApplicationLevelConfiguration configuration = CvsApplicationLevelConfiguration.getInstance();
 122     CvsRootConfiguration config = CvsRootConfiguration.createOn(repository);
 123     if (configuration.CONFIGURATIONS.contains(config)) return false;
 124     configuration.CONFIGURATIONS.add(config);
 125     return configuration.CONFIGURATIONS.contains(config);
 126   }
 127
 128   public void openInEditor(Project project, CvsModule cvsFile) {
 129     CvsRepository repository = cvsFile.getRepository();
 130     RevisionOrDate revisionOrDate = RevisionOrDateImpl.createOn(new DateOrRevisionSettings().updateFrom(repository.getDateOrRevision()));
 131
 132     GetFileContentOperation operation = new GetFileContentOperation(new File(cvsFile.getPathInCvs()),
 133                                                                     CvsRootConfiguration.createOn(repository),
 134                                                                     revisionOrDate
 135     );
 136
 137     ComparableVcsRevisionOnOperation revision = new ComparableVcsRevisionOnOperation(operation,
 138                                                                                      project);
 139
 140     VcsVirtualFile vcsVirtualFile = new VcsVirtualFile(cvsFile.getPathInCvs(),
 141                                                        revision,
 142                                                        VcsFileSystem.getInstance());
 143     OpenFileDescriptor openFileDescriptor = new OpenFileDescriptor(project, vcsVirtualFile);
 144     FileEditorManager.getInstance(project).openTextEditor(openFileDescriptor, false);
 145   }
 146
 147   public byte[] getFileContent(Project project, CvsModule cvsFile) throws IOException {
 148     final GetFileContentOperation operation = new GetFileContentOperation(new File(cvsFile.getPathInCvs()),
 149                                                                           CvsRootConfiguration.createOn(cvsFile.getRepository()),
 150                                                                           new SimpleRevision(cvsFile.getRevision())
 151     );
 152
 153     final CvsOperationExecutor executor = new CvsOperationExecutor(project);
 154     executor.performActionSync(new CommandCvsHandler(CvsBundle.message("operation.name.load.file.content"), operation, false),
 155                                CvsOperationExecutorCallback.EMPTY);
 156
 157     if (!executor.hasNoErrors()) throw new RuntimeException(executor.getFirstError());
 158     if (operation.isDeleted()) throw new IOException(CvsBundle.message("exception.text.revision.has.been.deleted"));
 159     return operation.getFileBytes();
 160   }
 161
 162   public CvsResult checkout(String[] modules,
 163                             File checkoutTo,
 164                             String directory,
 165                             boolean makeNewFilesReadOnly,
 166                             boolean pruneEmptyDirectories,
 167                             Object keywordSubstitution,
 168                             Project project,
 169                             CvsRepository repository) {
 170     LOG.assertTrue(modules.length > 0);
 171     CheckoutProjectOperation operation = new CheckoutProjectOperation(modules,
 172                                                                       CvsRootConfiguration.createOn(repository),
 173                                                                       makeNewFilesReadOnly,
 174                                                                       checkoutTo,
 175                                                                       directory,
 176                                                                       pruneEmptyDirectories,
 177                                                                       (KeywordSubstitution)keywordSubstitution);
 178     final CvsOperationExecutor executor = new CvsOperationExecutor(project);
 179     executor.performActionSync(new CommandCvsHandler(CvsBundle.message("operation.name.checkout"), operation, true),
 180                                CvsOperationExecutorCallback.EMPTY);
 181     return executor.getResult();
 182   }
 183
 184 }