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

/*
 * Copyright 2000-2014 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.application;

import com.intellij.CvsBundle;
import com.intellij.cvsSupport2.CvsUtil;
import com.intellij.cvsSupport2.config.CvsApplicationLevelConfiguration;
import com.intellij.cvsSupport2.config.CvsRootConfiguration;
import com.intellij.cvsSupport2.connections.CvsConnectionSettings;
import com.intellij.cvsSupport2.connections.login.CvsLoginWorker;
import com.intellij.cvsSupport2.cvsIgnore.IgnoredFilesInfo;
import com.intellij.cvsSupport2.cvsIgnore.IgnoredFilesInfoImpl;
import com.intellij.cvsSupport2.errorHandling.ErrorRegistry;
import com.intellij.cvsSupport2.javacvsImpl.io.ReadWriteStatistics;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.MessageType;
import com.intellij.openapi.util.Comparing;
import com.intellij.openapi.vcs.ui.VcsBalloonProblemNotifier;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.util.ThreeState;
import org.jetbrains.annotations.Nullable;
import org.netbeans.lib.cvsclient.admin.Entries;
import org.netbeans.lib.cvsclient.admin.Entry;
import org.netbeans.lib.cvsclient.command.CommandException;
import org.netbeans.lib.cvsclient.connection.IConnection;

import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

/**
 * author: lesya
 */
public class CvsInfo {

  private volatile IgnoredFilesInfo myIgnoreFilter;
  private CvsConnectionSettings myConnectionSettings;

  private String myRepository;
  private String myStickyTag;
  private Entries myEntries;

  private boolean myIsLoaded = false;

  private final VirtualFile myParent;
  private static final VirtualFile DUMMY_ROOT = null;

  private boolean myStickyTagIsLoaded = false;

  public CvsInfo(VirtualFile parent) {
    myParent = parent;
  }

  public synchronized CvsConnectionSettings getConnectionSettings() {
    checkIsLoaded();
    return myConnectionSettings;
  }

  private void checkIsLoaded() {

    if (myIsLoaded) return;
    try {
      loadCvsRoot();
      loadEntries();
      loadRepository();
      loadStickyTag();

      if (myRepository != null && myConnectionSettings != null && myConnectionSettings.REPOSITORY != null) {
        myRepository = CvsUtil.getRelativeRepositoryPath(myRepository, myConnectionSettings.REPOSITORY);
      }

      CvsEntriesManager.getInstance().watchForCvsAdminFiles(myParent);
    }
    finally {
      myIsLoaded = true;
    }
  }

  private void loadStickyTag() {
    myStickyTag = CvsUtil.loadStickyTagFrom(getParentFile());
  }

  private void loadRepository() {
    myRepository = CvsUtil.loadRepositoryFrom(getParentFile());
  }

  private void loadCvsRoot() {
    String cvsRoot = CvsUtil.loadRootFrom(getParentFile());
    try {
      if (cvsRoot == null) {
        myConnectionSettings = getAbsentSettings();
      }
      else {
        myConnectionSettings = CvsEntriesManager.getInstance().createConnectionSettingsOn(cvsRoot);
      }
    }
    catch (Exception ex) {
      myConnectionSettings = getAbsentSettings();
    }
  }

  public synchronized IgnoredFilesInfo getIgnoreFilter() {
    checkFilterIsLoaded();
    return myIgnoreFilter;
  }

  private void checkFilterIsLoaded() {
    if (myIgnoreFilter == null) {
      if (myParent == null) {
        myIgnoreFilter = IgnoredFilesInfo.IGNORE_NOTHING;
      }
      else if (CvsEntriesManager.getInstance().fileIsIgnored(myParent)) {
        myIgnoreFilter = IgnoredFilesInfo.IGNORE_ALL;
      }
      else if (!CvsUtil.fileIsUnderCvs(myParent)) {
        myIgnoreFilter = IgnoredFilesInfo.IGNORE_NOTHING;
      }
      else {
        myIgnoreFilter = IgnoredFilesInfoImpl.createForFile(CvsUtil.cvsignoreFileFor(getParentFile()));
      }
    }
  }

  private Entries getCvsEntries() {
    checkIsLoaded();
    return myEntries;
  }

  private void loadEntries() {
    if (!Comparing.equal(myParent, DUMMY_ROOT)) {
      myEntries = createEntriesFor(getParentFile());
    }
    else {
      myEntries = new Entries();
    }
  }

  public synchronized Collection<Entry> getEntries() {
    return new HashSet<Entry>(getCvsEntries().getEntries());
  }

  @Nullable
  private File getParentFile() {
    return myParent == null ? null : new File(myParent.getPath());
  }

  private static Entries createEntriesFor(File parent) {
    Entries entries = CvsUtil.getEntriesIn(new File(parent.getPath()));
    if (entries == null) {
      return new Entries();
    }
    else {
      return entries;
    }
  }


  public void clearFilter() {
    myIgnoreFilter = null;
  }

  public synchronized boolean isLoaded() {
    return myIsLoaded;
  }

  public synchronized Entry setEntryAndReturnReplacedEntry(Entry entry) {
    Entry previousEntry = getEntryNamed(entry.getFileName());
    appendEntry(entry);
    return previousEntry;
  }

  private void appendEntry(Entry newEntry) {
    getCvsEntries().addEntry(newEntry);
  }

  public synchronized void removeEntryNamed(String fileName) {
    removeEntry(fileName);
  }

  private void removeEntry(String fileName) {
    getCvsEntries().removeEntry(fileName);
  }

  public synchronized VirtualFile getKey() {
    return myParent;
  }

  public synchronized Entry getEntryNamed(String name) {
    return getCvsEntries().getEntry(name);
  }

  public synchronized String getRepository() {
    checkIsLoaded();
    return myRepository;
  }

  public synchronized String getStickyTag() {
    checkStickyTagIsLoaded();
    return myStickyTag;
  }

  private void checkStickyTagIsLoaded() {
    if (!myStickyTagIsLoaded){
      loadStickyTag();
      myStickyTagIsLoaded = true;
    }
  }

  public synchronized void cacheAll() {
    checkIsLoaded();
  }

  public synchronized void clearAll() {
    myEntries = null;
    myRepository = null;
    myStickyTagIsLoaded = false;
    myConnectionSettings = null;
    myIsLoaded = false;
  }

  public synchronized void clearStickyInformation() {
    myStickyTagIsLoaded = false;
  }

  private static class CvsConnectionSettingsHolder {
    private static final CvsConnectionSettings ABSENT_SETTINGS = new MyInvalidCvsConnectionSettings();
  }

  public static CvsConnectionSettings getAbsentSettings() {
    return CvsConnectionSettingsHolder.ABSENT_SETTINGS;
  }

  private static class CvsInfoHolder {
    private static final CvsInfo DUMMY = new DummyCvsInfo();
  }

  public static CvsInfo getDummyCvsInfo() {
    return CvsInfoHolder.DUMMY;
  }

  private static class MyInvalidCvsConnectionSettings extends CvsConnectionSettings {
    public MyInvalidCvsConnectionSettings() {
      super(CvsApplicationLevelConfiguration.createNewConfiguration(CvsApplicationLevelConfiguration.getInstance()));
    }

    @Override
    public int getDefaultPort() {
      return 0;
    }

    @Override
    public IConnection createConnection(ReadWriteStatistics statistics) {
      throw new RuntimeException(CvsBundle.message("exception.text.cannot.connect.with.invalid.root"));
    }

    @Override
    protected IConnection createOriginalConnection(ErrorRegistry errorRegistry, CvsRootConfiguration cvsRootConfiguration) {
      throw new RuntimeException(CvsBundle.message("exception.text.cannot.connect.with.invalid.root"));
    }

    @Override
    public CommandException processException(CommandException t) {
      return t;
    }

    @Override
    public void setOffline(boolean offline) {
      throw new RuntimeException(CvsBundle.message("exception.text.cannot.do.setoffline.with.invalid.root"));
    }

    @Override
    public boolean isOffline() {
      return true;
    }

    @Override
    public CvsLoginWorker getLoginWorker(final Project project) {
      return new CvsLoginWorker() {
        @Override
        public boolean promptForPassword() {
          return true;
        }

        @Override
        public ThreeState silentLogin(boolean forceCheck) {
          VcsBalloonProblemNotifier.showOverChangesView(
            project, CvsBundle.message("message.error.invalid.cvs.root", getCvsRootAsString()), MessageType.ERROR);
          return ThreeState.NO;
        }

        @Override
        public void goOffline() {
          setOffline(true);
        }
      };
    }

    @Override
    public boolean isValid() {
      return false;
    }
  }

  @SuppressWarnings({"NonSynchronizedMethodOverridesSynchronizedMethod"})
  private static class DummyCvsInfo extends CvsInfo {
    public DummyCvsInfo() {
      super(null);
    }

    @Override
    public CvsConnectionSettings getConnectionSettings() {
      return getAbsentSettings();
    }

    @Override
    public IgnoredFilesInfo getIgnoreFilter() {
      return IgnoredFilesInfoImpl.EMPTY_FILTER;
    }

    @Override
    public Collection<Entry> getEntries() {
      return new ArrayList<Entry>();
    }

    @Override
    public void clearFilter() {
    }

    @Override
    public boolean isLoaded() {
      return true;
    }

    @Override
    public Entry setEntryAndReturnReplacedEntry(Entry entry) {
      return null;
    }

    @Override
    public void removeEntryNamed(String fileName) {
    }

    @Override
    public VirtualFile getKey() {
      return null;
    }

    @Override
    public Entry getEntryNamed(String name) {
      return null;
    }
  }
}