plugins/git4idea/src/git4idea/ui/GitTagDialog.java

   1 /*
   2  * Copyright 2000-2008 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 git4idea.ui;
  17
  18 import com.intellij.openapi.project.Project;
  19 import com.intellij.openapi.ui.DialogWrapper;
  20 import com.intellij.openapi.ui.Messages;
  21 import com.intellij.openapi.vcs.VcsException;
  22 import com.intellij.openapi.vfs.VirtualFile;
  23 import com.intellij.ui.DocumentAdapter;
  24 import git4idea.commands.GitHandler;
  25 import git4idea.commands.GitHandlerUtil;
  26 import git4idea.commands.GitSimpleHandler;
  27 import git4idea.commands.StringScanner;
  28 import git4idea.i18n.GitBundle;
  29 import org.jetbrains.annotations.NonNls;
  30
  31 import javax.swing.*;
  32 import javax.swing.event.DocumentEvent;
  33 import java.awt.event.ActionEvent;
  34 import java.awt.event.ActionListener;
  35 import java.io.*;
  36 import java.util.HashSet;
  37 import java.util.List;
  38 import java.util.Set;
  39
  40 /**
  41  * The tag dialog for the git
  42  */
  43 public class GitTagDialog extends DialogWrapper {
  44   /**
  45    * Root panel
  46    */
  47   private JPanel myPanel;
  48   /**
  49    * Git root selector
  50    */
  51   private JComboBox myGitRootComboBox;
  52   /**
  53    * Current branch label
  54    */
  55   private JLabel myCurrentBranch;
  56   /**
  57    * Tag name
  58    */
  59   private JTextField myTagNameTextField;
  60   /**
  61    * Force tag creation checkbox
  62    */
  63   private JCheckBox myForceCheckBox;
  64   /**
  65    * Text area that contains tag message if non-empty
  66    */
  67   private JTextArea myMessageTextArea;
  68   /**
  69    * The name of commit to tag
  70    */
  71   private JTextField myCommitTextField;
  72   /**
  73    * The validate button
  74    */
  75   private JButton myValidateButton;
  76   /**
  77    * The validator for commit text field
  78    */
  79   private final GitReferenceValidator myCommitTextFieldValidator;
  80   /**
  81    * The current project
  82    */
  83   private final Project myProject;
  84   /**
  85    * Existing tags for the project
  86    */
  87   private final Set<String> myExistingTags = new HashSet<String>();
  88   /**
  89    * Prefix for message file name
  90    */
  91   @NonNls private static final String MESSAGE_FILE_PREFIX = "git-tag-message-";
  92   /**
  93    * Suffix for message file name
  94    */
  95   @NonNls private static final String MESSAGE_FILE_SUFFIX = ".txt";
  96   /**
  97    * Encoding for the message file
  98    */
  99   @NonNls private static final String MESSAGE_FILE_ENCODING = "UTF-8";
 100
 101   /**
 102    * A constructor
 103    *
 104    * @param project     a project to select
 105    * @param roots       a git repository roots for the project
 106    * @param defaultRoot a guessed default root
 107    */
 108   public GitTagDialog(Project project, List<VirtualFile> roots, VirtualFile defaultRoot) {
 109     super(project, true);
 110     setTitle(GitBundle.getString("tag.title"));
 111     setOKButtonText(GitBundle.getString("tag.button"));
 112     myProject = project;
 113     GitUIUtil.setupRootChooser(myProject, roots, defaultRoot, myGitRootComboBox, myCurrentBranch);
 114     myGitRootComboBox.addActionListener(new ActionListener() {
 115       public void actionPerformed(final ActionEvent e) {
 116         fetchTags();
 117         validateFields();
 118       }
 119     });
 120     fetchTags();
 121     myTagNameTextField.getDocument().addDocumentListener(new DocumentAdapter() {
 122       protected void textChanged(final DocumentEvent e) {
 123         validateFields();
 124       }
 125     });
 126     myCommitTextFieldValidator = new GitReferenceValidator(project, myGitRootComboBox, myCommitTextField, myValidateButton, new Runnable() {
 127       public void run() {
 128         validateFields();
 129       }
 130     });
 131     myForceCheckBox.addActionListener(new ActionListener() {
 132       public void actionPerformed(final ActionEvent e) {
 133         if (myForceCheckBox.isEnabled()) {
 134           validateFields();
 135         }
 136       }
 137     });
 138     init();
 139     validateFields();
 140   }
 141
 142   /**
 143    * Perform tagging according to selected options
 144    *
 145    * @param exceptions the list where exceptions are collected
 146    */
 147   public void runAction(final List<VcsException> exceptions) {
 148     final String message = myMessageTextArea.getText();
 149     final boolean hasMessage = message.trim().length() != 0;
 150     final File messageFile;
 151     if (hasMessage) {
 152       try {
 153         messageFile = File.createTempFile(MESSAGE_FILE_PREFIX, MESSAGE_FILE_SUFFIX);
 154         messageFile.deleteOnExit();
 155         Writer out = new OutputStreamWriter(new FileOutputStream(messageFile), MESSAGE_FILE_ENCODING);
 156         try {
 157           out.write(message);
 158         }
 159         finally {
 160           out.close();
 161         }
 162       }
 163       catch (IOException ex) {
 164         Messages.showErrorDialog(myProject, GitBundle.message("tag.error.creating.message.file.message", ex.toString()),
 165                                  GitBundle.getString("tag.error.creating.message.file.title"));
 166         return;
 167       }
 168     }
 169     else {
 170       messageFile = null;
 171     }
 172     try {
 173       GitSimpleHandler h = new GitSimpleHandler(myProject, getGitRoot(), GitHandler.TAG);
 174       h.setNoSSH(true);
 175       if (hasMessage) {
 176         h.addParameters("-a");
 177       }
 178       if (myForceCheckBox.isEnabled() && myForceCheckBox.isSelected()) {
 179         h.addParameters("-f");
 180       }
 181       if (hasMessage) {
 182         h.addParameters("-F", messageFile.getAbsolutePath());
 183       }
 184       h.addParameters(myTagNameTextField.getText());
 185       String object = myCommitTextField.getText().trim();
 186       if (object.length() != 0) {
 187         h.addParameters(object);
 188       }
 189       try {
 190         GitHandlerUtil.doSynchronously(h, GitBundle.getString("tagging.title"), h.printableCommandLine());
 191       }
 192       finally {
 193         exceptions.addAll(h.errors());
 194       }
 195     }
 196     finally {
 197       if (messageFile != null) {
 198         //noinspection ResultOfMethodCallIgnored
 199         messageFile.delete();
 200       }
 201     }
 202   }
 203
 204   /**
 205    * Validate dialog fields
 206    */
 207   private void validateFields() {
 208     String text = myTagNameTextField.getText();
 209     if (myExistingTags.contains(text)) {
 210       myForceCheckBox.setEnabled(true);
 211       if (!myForceCheckBox.isSelected()) {
 212         setErrorText(GitBundle.getString("tag.error.tag.exists"));
 213         setOKActionEnabled(false);
 214         return;
 215       }
 216     }
 217     else {
 218       myForceCheckBox.setEnabled(false);
 219       myForceCheckBox.setSelected(false);
 220     }
 221     if (myCommitTextFieldValidator.isInvalid()) {
 222       setErrorText(GitBundle.getString("tag.error.invalid.commit"));
 223       setOKActionEnabled(false);
 224       return;
 225     }
 226     if (text.length() == 0) {
 227       setErrorText(null);
 228       setOKActionEnabled(false);
 229       return;
 230     }
 231     setErrorText(null);
 232     setOKActionEnabled(true);
 233   }
 234
 235   /**
 236    * Fetch tags
 237    */
 238   private void fetchTags() {
 239     myExistingTags.clear();
 240     GitSimpleHandler h = new GitSimpleHandler(myProject, getGitRoot(), GitHandler.TAG);
 241     h.setNoSSH(true);
 242     h.setSilent(true);
 243     String output = GitHandlerUtil.doSynchronously(h, GitBundle.getString("tag.getting.existing.tags"), h.printableCommandLine());
 244     for (StringScanner s = new StringScanner(output); s.hasMoreData();) {
 245       String line = s.line();
 246       if (line.length() == 0) {
 247         continue;
 248       }
 249       myExistingTags.add(line);
 250     }
 251   }
 252
 253   /**
 254    * @return the current git root
 255    */
 256   private VirtualFile getGitRoot() {
 257     return (VirtualFile)myGitRootComboBox.getSelectedItem();
 258   }
 259
 260   /**
 261    * {@inheritDoc}
 262    */
 263   protected JComponent createCenterPanel() {
 264     return myPanel;
 265   }
 266
 267   /**
 268    * {@inheritDoc}
 269    */
 270   @Override
 271   protected String getDimensionServiceKey() {
 272     return getClass().getName();
 273   }
 274
 275   /**
 276    * {@inheritDoc}
 277    */
 278   @Override
 279   protected String getHelpId() {
 280     return "reference.VersionControl.Git.TagFiles";
 281   }
 282 }