Merge remote-tracking branch 'origin/master'
authorKirill Likhodedov <Kirill.Likhodedov@jetbrains.com>
Fri, 27 Jan 2012 14:28:11 +0000 (18:28 +0400)
committerKirill Likhodedov <Kirill.Likhodedov@jetbrains.com>
Fri, 27 Jan 2012 14:28:11 +0000 (18:28 +0400)
plugins/git4idea/src/git4idea/branch/GitCheckoutOperation.java
plugins/git4idea/src/git4idea/checkin/GitCheckinHandlerFactory.java
plugins/git4idea/src/git4idea/checkin/GitUserNameNotDefinedDialog.java [new file with mode: 0644]
plugins/git4idea/src/git4idea/config/GitConfigUtil.java
plugins/git4idea/src/git4idea/config/GitVersionSpecialty.java
plugins/git4idea/tests/git4idea/branch/GitBranchOperationsTest.java
plugins/git4idea/tests/git4idea/test/GitExec.java

index 53fbe2b7397d85ed8f6a17c98ac413076f8318d6..966e26487b5d6adc523f0d5e83285032bdc16035 100644 (file)
@@ -57,6 +57,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
 
 import static git4idea.commands.GitMessageWithFilesDetector.Event.LOCAL_CHANGES_OVERWRITTEN_BY_CHECKOUT;
 import static git4idea.commands.GitMessageWithFilesDetector.Event.UNTRACKED_FILES_OVERWRITTEN_BY;
+import static git4idea.util.GitUIUtil.code;
 
 /**
  * Represents {@code git checkout} operation.
@@ -244,15 +245,33 @@ public class GitCheckoutOperation extends GitBranchOperation {
 
   @Override
   protected void rollback() {
-    GitCompoundResult compoundResult = new GitCompoundResult(myProject);
+    GitCompoundResult checkoutResult = new GitCompoundResult(myProject);
+    GitCompoundResult deleteResult = new GitCompoundResult(myProject);
     for (GitRepository repository : getSuccessfulRepositories()) {
       GitCommandResult result = Git.checkout(repository, myPreviousBranch, null);
-      compoundResult.append(repository, result);
+      checkoutResult.append(repository, result);
+      if (result.success() && myNewBranch != null) {
+        /*
+          force delete is needed, because we create new branch from branch other that the current one
+          e.g. being on master create newBranch from feature,
+          then rollback => newBranch is not fully merged to master (although it is obviously fully merged to feature).
+         */
+        deleteResult.append(repository, Git.branchDelete(repository, myNewBranch, true));
+      }
       refresh(repository);
     }
-    if (!compoundResult.totalSuccess()) {
-      GitUIUtil.notify(GitVcs.IMPORTANT_ERROR_NOTIFICATION, myProject, "Error during rolling checkout back",
-                       compoundResult.getErrorOutputWithReposIndication(), NotificationType.ERROR, null);
+    if (!checkoutResult.totalSuccess() || !deleteResult.totalSuccess()) {
+      StringBuilder message = new StringBuilder();
+      if (!checkoutResult.totalSuccess()) {
+        message.append("Errors during checking out ").append(myPreviousBranch).append(": ");
+        message.append(checkoutResult.getErrorOutputWithReposIndication());
+      }
+      if (!deleteResult.totalSuccess()) {
+        message.append("Errors during deleting ").append(code(myNewBranch)).append(": ");
+        message.append(deleteResult.getErrorOutputWithReposIndication());
+      }
+      GitUIUtil.notify(GitVcs.IMPORTANT_ERROR_NOTIFICATION, myProject, "Error during rollback",
+                       message.toString(), NotificationType.ERROR, null);
     }
   }
 
@@ -412,7 +431,7 @@ public class GitCheckoutOperation extends GitBranchOperation {
   private static void refresh(GitRepository... repositories) {
     for (GitRepository repository : repositories) {
       refreshRoot(repository);
-      repository.update(GitRepository.TrackedTopic.ALL_CURRENT);
+      // repository state will be auto-updated with this VFS refresh => no need to call GitRepository#update().
     }
   }
   
index 7dc57461ec12786adfb17a34f869412ec0824b5a..733862975ef5c581c94750f3d7383ef21fbd4ffe 100644 (file)
  */
 package git4idea.checkin;
 
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.Messages;
+import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vcs.CheckinProjectPanel;
+import com.intellij.openapi.vcs.ProjectLevelVcsManager;
+import com.intellij.openapi.vcs.VcsException;
 import com.intellij.openapi.vcs.changes.CommitExecutor;
 import com.intellij.openapi.vcs.checkin.CheckinHandler;
 import com.intellij.openapi.vcs.checkin.VcsCheckinHandlerFactory;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.PairConsumer;
 import git4idea.GitVcs;
+import git4idea.config.GitConfigUtil;
+import git4idea.config.GitVersion;
+import git4idea.config.GitVersionSpecialty;
 import git4idea.i18n.GitBundle;
 import git4idea.repo.GitRepository;
 import git4idea.repo.GitRepositoryManager;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.*;
+
 /**
  * Prohibits commiting with an empty messages.
  * @author Kirill Likhodedov
 */
 public class GitCheckinHandlerFactory extends VcsCheckinHandlerFactory {
+  
+  private static final Logger LOG = Logger.getInstance(GitCheckinHandlerFactory.class);
+
   public GitCheckinHandlerFactory() {
     super(GitVcs.getKey());
   }
@@ -54,17 +67,127 @@ public class GitCheckinHandlerFactory extends VcsCheckinHandlerFactory {
 
     @Override
     public ReturnResult beforeCheckin(@Nullable CommitExecutor executor, PairConsumer<Object, Object> additionalDataConsumer) {
-      // empty commit message check
-      if (myPanel.getCommitMessage().trim().isEmpty()) {
-        Messages.showMessageDialog(myPanel.getComponent(), GitBundle.message("git.commit.message.empty"),
-                                   GitBundle.message("git.commit.message.empty.title"), Messages.getErrorIcon());
+      if (emptyCommitMessage()) {
         return ReturnResult.CANCEL;
       }
       
-      if (!commitOrCommitAndPush(executor)) {
+      ReturnResult result = checkUserName();
+      if (result != ReturnResult.COMMIT) {
+        return result;
+      }
+
+      if (commitOrCommitAndPush(executor)) {
+        return warnAboutDetachedHeadIfNeeded();
+      }
+      return ReturnResult.COMMIT;
+    }
+
+    private ReturnResult checkUserName() {
+      Project project = myPanel.getProject();
+      GitVcs vcs = GitVcs.getInstance(project);
+      assert vcs != null;
+
+      Collection<VirtualFile> notDefined = new ArrayList<VirtualFile>();
+      Map<VirtualFile, Pair<String, String>> defined = new HashMap<VirtualFile, Pair<String, String>>();
+      Collection<VirtualFile> allRoots = new ArrayList<VirtualFile>(Arrays.asList(
+        ProjectLevelVcsManager.getInstance(project).getRootsUnderVcs(vcs)));
+
+      Collection<VirtualFile> affectedRoots = myPanel.getRoots();
+      for (VirtualFile root : affectedRoots) {
+        try {
+          Pair<String, String> nameAndEmail = getUserNameAndEmailFromGitConfig(project, root);
+          String name = nameAndEmail.getFirst();
+          String email = nameAndEmail.getSecond();
+          if (name == null || email == null) {
+            notDefined.add(root);
+          }
+          else {
+            defined.put(root, nameAndEmail);
+          }
+        }
+        catch (VcsException e) {
+          LOG.error("Couldn't get user.name and user.email for root " + root, e);
+          // doing nothing - let commit with possibly empty user.name/email
+        }
+      }
+      
+      if (notDefined.isEmpty()) {
+        return ReturnResult.COMMIT;
+      }
+
+      GitVersion version = vcs.getVersion();
+      if (System.getenv("HOME") == null && GitVersionSpecialty.DOESNT_DEFINE_HOME_ENV_VAR.existsIn(version)) {
+        Messages.showErrorDialog(project,
+                                 "You are using Git " + version + " which doesn't define %HOME% environment variable properly.\n" +
+                                 "Consider updating Git to a newer version " +
+                                 "or define %HOME% to point to the place where the global .gitconfig is stored \n" +
+                                 "(it is usually %USERPROFILE% or %HOMEDRIVE%%HOMEPATH%).",
+                                 "HOME Variable Is Not Defined");
+        return ReturnResult.CANCEL;
+      }
+
+      if (defined.isEmpty() && allRoots.size() > affectedRoots.size()) {
+        allRoots.removeAll(affectedRoots);
+        for (VirtualFile root : allRoots) {
+          try {
+            Pair<String, String> nameAndEmail = getUserNameAndEmailFromGitConfig(project, root);
+            String name = nameAndEmail.getFirst();
+            String email = nameAndEmail.getSecond();
+            if (name != null && email != null) {
+              defined.put(root, nameAndEmail);
+              break;
+            }
+          }
+          catch (VcsException e) {
+            LOG.error("Couldn't get user.name and user.email for root " + root, e);
+            // doing nothing - not critical not to find the values for other roots not affected by commit
+          }
+        }
+      }
+
+      GitUserNameNotDefinedDialog dialog = new GitUserNameNotDefinedDialog(project, notDefined, affectedRoots, defined);
+      dialog.show();
+      if (dialog.isOK()) {
+        try {
+          if (dialog.isGlobal()) {
+            GitConfigUtil.setValue(project, notDefined.iterator().next(), GitConfigUtil.USER_NAME, dialog.getUserName(), "--global");
+            GitConfigUtil.setValue(project, notDefined.iterator().next(), GitConfigUtil.USER_EMAIL, dialog.getUserEmail(), "--global");
+          }
+          else {
+            for (VirtualFile root : notDefined) {
+              GitConfigUtil.setValue(project, root, GitConfigUtil.USER_NAME, dialog.getUserName());
+              GitConfigUtil.setValue(project, root, GitConfigUtil.USER_EMAIL, dialog.getUserEmail());
+            }
+          }
+        }
+        catch (VcsException e) {
+          String message = "Couldn't set user.name and user.email";
+          LOG.error(message, e);
+          Messages.showErrorDialog(myPanel.getComponent(), message);
+          return ReturnResult.CANCEL;
+        }
         return ReturnResult.COMMIT;
       }
+      return ReturnResult.CLOSE_WINDOW;
+    }
+    
+    @NotNull
+    private Pair<String, String> getUserNameAndEmailFromGitConfig(@NotNull Project project, @NotNull VirtualFile root) throws VcsException {
+      String name = GitConfigUtil.getValue(project, root, GitConfigUtil.USER_NAME);
+      String email = GitConfigUtil.getValue(project, root, GitConfigUtil.USER_EMAIL);
+      return Pair.create(name, email);
+    }
+    
+    private boolean emptyCommitMessage() {
+      if (myPanel.getCommitMessage().trim().isEmpty()) {
+        Messages.showMessageDialog(myPanel.getComponent(), GitBundle.message("git.commit.message.empty"),
+                                   GitBundle.message("git.commit.message.empty.title"), Messages.getErrorIcon());
+        return true;
+      }
+      return false;
+    }
 
+    private ReturnResult warnAboutDetachedHeadIfNeeded() {
       // Warning: commit on a detached HEAD
       DetachedRoot detachedRoot = getDetachedRoot();
       if (detachedRoot == null) {
@@ -90,7 +213,7 @@ public class GitCheckinHandlerFactory extends VcsCheckinHandlerFactory {
       }
 
       final int choice = Messages.showOkCancelDialog(myPanel.getComponent(), "<html>" + message + "</html>", title,
-                                             "Cancel", "Commit", Messages.getWarningIcon());
+                                                     "Cancel", "Commit", Messages.getWarningIcon());
       if (choice == 1) {
         return ReturnResult.COMMIT;
       } else {
diff --git a/plugins/git4idea/src/git4idea/checkin/GitUserNameNotDefinedDialog.java b/plugins/git4idea/src/git4idea/checkin/GitUserNameNotDefinedDialog.java
new file mode 100644 (file)
index 0000000..05ed716
--- /dev/null
@@ -0,0 +1,176 @@
+/*
+ * Copyright 2000-2012 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 git4idea.checkin;
+
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.ui.DialogWrapper;
+import com.intellij.openapi.util.Pair;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.ui.components.JBCheckBox;
+import com.intellij.ui.components.JBLabel;
+import com.intellij.util.SystemProperties;
+import com.intellij.util.ui.GridBag;
+import com.intellij.util.ui.UIUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+
+import static com.intellij.openapi.util.text.StringUtil.isEmptyOrSpaces;
+import static com.intellij.util.ui.UIUtil.DEFAULT_HGAP;
+import static com.intellij.util.ui.UIUtil.DEFAULT_VGAP;
+
+/**
+ * @author Kirill Likhodedov
+ */
+class GitUserNameNotDefinedDialog extends DialogWrapper {
+
+  @NotNull private final Collection<VirtualFile> myRootsWithUndefinedProps;
+  @NotNull private final Collection<VirtualFile> myAllRootsAffectedByCommit;
+  @Nullable private final Pair<String,String> myProposedValues;
+
+  private JTextField myNameTextField;
+  private JTextField myEmailTextField;
+  private JBCheckBox myGlobalCheckbox;
+
+  GitUserNameNotDefinedDialog(@NotNull Project project,
+                                        @NotNull Collection<VirtualFile> rootsWithUndefinedProps, 
+                                        @NotNull Collection<VirtualFile> allRootsAffectedByCommit,
+                                        @NotNull Map<VirtualFile, Pair<String, String>> rootsWithDefinedProps) {
+    super(project, false);
+    myRootsWithUndefinedProps = rootsWithUndefinedProps;
+    myAllRootsAffectedByCommit = allRootsAffectedByCommit;
+
+    myProposedValues = calcProposedValues(rootsWithDefinedProps);
+
+    setTitle("Git User Name Is Not Defined");
+    setOKButtonText("Set and Commit");
+    
+    init();
+  }
+
+  @Override
+  protected ValidationInfo doValidate() {
+    String message = "You have to specify user name and email for Git";
+    if (isEmptyOrSpaces(getUserName())) {
+      return new ValidationInfo(message, myNameTextField);
+    }
+    if (isEmptyOrSpaces(getUserEmail())) {
+      return new ValidationInfo(message, myEmailTextField);
+    }
+    return null;
+  }
+
+  @Override
+  public JComponent getPreferredFocusedComponent() {
+    return myNameTextField;
+  }
+
+  @Nullable
+  private static Pair<String, String> calcProposedValues(Map<VirtualFile, Pair<String, String>> rootsWithDefinedProps) {
+    if (rootsWithDefinedProps.isEmpty()) {
+      return null;
+    }
+    Iterator<Map.Entry<VirtualFile,Pair<String,String>>> iterator = rootsWithDefinedProps.entrySet().iterator();
+    Pair<String, String> firstValue = iterator.next().getValue();
+    while (iterator.hasNext()) {
+      // nothing to propose if there are different values set in different repositories
+      if (!firstValue.equals(iterator.next().getValue())) {
+        return null;
+      }
+    }
+    return firstValue;
+  }
+
+  @Override
+  protected JComponent createCenterPanel() {
+    
+    JLabel icon = new JLabel(UIUtil.getWarningIcon(), SwingConstants.LEFT);
+    JLabel description = new JLabel(getMessageText());
+    
+    myNameTextField = new JTextField(20);
+    JBLabel nameLabel = new JBLabel("Name: ");
+    nameLabel.setDisplayedMnemonic('n');
+    nameLabel.setLabelFor(myNameTextField);
+
+    myEmailTextField = new JTextField(20);
+    JBLabel emailLabel = new JBLabel("E-mail: ");
+    emailLabel.setDisplayedMnemonic('e');
+    emailLabel.setLabelFor(myEmailTextField);
+
+    if (myProposedValues != null) {
+      myNameTextField.setText(myProposedValues.getFirst());
+      myEmailTextField.setText(myProposedValues.getSecond());
+    }
+    else {
+      myNameTextField.setText(SystemProperties.getUserName());
+    }
+
+    myGlobalCheckbox = new JBCheckBox("Set properties globally", true);
+    myGlobalCheckbox.setMnemonic('g');
+
+    JPanel rootPanel = new JPanel(new GridBagLayout());
+    GridBag g = new GridBag()
+      .setDefaultInsets(new Insets(0, 0, DEFAULT_VGAP, DEFAULT_HGAP))
+      .setDefaultAnchor(GridBagConstraints.LINE_START)
+      .setDefaultFill(GridBagConstraints.HORIZONTAL);
+    
+    rootPanel.add(description, g.nextLine().next().coverLine(3).pady(DEFAULT_HGAP));
+    rootPanel.add(icon, g.nextLine().next().coverColumn(3));
+    rootPanel.add(nameLabel, g.next().fillCellNone().insets(new Insets(0, 6, DEFAULT_VGAP, DEFAULT_HGAP)));
+    rootPanel.add(myNameTextField, g.next());
+    rootPanel.add(emailLabel, g.nextLine().next().next().fillCellNone().insets(new Insets(0, 6, DEFAULT_VGAP, DEFAULT_HGAP)));
+    rootPanel.add(myEmailTextField, g.next());
+    rootPanel.add(myGlobalCheckbox, g.nextLine().next().next().coverLine(2));
+
+    return rootPanel;
+  }
+
+  @Override
+  protected JComponent createNorthPanel() {
+    return null;
+  }
+
+  @NotNull
+  private String getMessageText() {
+    if (myAllRootsAffectedByCommit.size() == myRootsWithUndefinedProps.size()) {
+      return "";
+    }
+    String text = "Git user.name and user.email properties are not defined in " + StringUtil.pluralize("root", myRootsWithUndefinedProps.size()) + "<br/>";
+    for (VirtualFile root : myRootsWithUndefinedProps) {
+      text += root.getPresentableUrl() + "<br/>";
+    }
+    return "<html>" + text + "</html>";
+  }
+
+  public String getUserName() {
+    return myNameTextField.getText();
+  }
+
+  public String getUserEmail() {
+    return myEmailTextField.getText();
+  }
+
+  public boolean isGlobal() {
+    return myGlobalCheckbox.isSelected();
+  }
+
+}
index 0e42072e25056b4eb1ca832107cbcc44924c46b1..465559ed3193f8d1550b70197fd54c9330005a1c 100644 (file)
@@ -35,6 +35,7 @@ import java.util.Map;
  */
 public class GitConfigUtil {
   public static final String USER_NAME = "user.name";
+  public static final String USER_EMAIL = "user.email";
 
   /**
    * A private constructor for utility class
@@ -240,11 +241,12 @@ public class GitConfigUtil {
    * @param value   the value to set
    * @throws VcsException if there is a problem with running git
    */
-  public static void setValue(Project project, VirtualFile root, String key, String value) throws VcsException {
+  public static void setValue(Project project, VirtualFile root, String key, String value, String... additionalParameters) throws VcsException {
     GitSimpleHandler h = new GitSimpleHandler(project, root, GitCommand.CONFIG);
     h.setNoSSH(true);
     h.setSilent(true);
     h.ignoreErrorCode(1);
+    h.addParameters(additionalParameters);
     h.addParameters(key, value);
     h.run();
   }
index b59570d461fd8300b3767e42948dba24fb67f03d..cc3d67b8480917fd6f89ed1865e8121fe03cb288 100644 (file)
@@ -15,6 +15,7 @@
  */
 package git4idea.config;
 
+import com.intellij.openapi.util.SystemInfo;
 import org.jetbrains.annotations.NotNull;
 
 /**
@@ -74,10 +75,16 @@ public enum GitVersionSpecialty {
    */
   KNOWS_STATUS_PORCELAIN {
     @Override
-    public boolean existsIn(@NotNull GitVersion
-    version) {
+    public boolean existsIn(@NotNull GitVersion version) {
       return version.isLaterOrEqual(new GitVersion(1, 7, 0, 0));
     }
+  },
+
+  DOESNT_DEFINE_HOME_ENV_VAR {
+    @Override
+    public boolean existsIn(@NotNull GitVersion version) {
+      return SystemInfo.isWindows && version.isOlderOrEqual(new GitVersion(1, 7, 0, 2));
+    }
   };
 
   public abstract boolean existsIn(@NotNull GitVersion version);
index d9b6bc5a21d30f8b872e7005f5460e69388bfede..d10e26f0f00011131fc0a204087c95b57ff2f56e 100644 (file)
@@ -16,7 +16,6 @@ import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory;
 import com.intellij.testFramework.fixtures.TempDirTestFixture;
 import com.intellij.util.ui.UIUtil;
 import com.intellij.vcsUtil.VcsUtil;
-import git4idea.GitBranch;
 import git4idea.GitVcs;
 import git4idea.repo.GitRepository;
 import git4idea.test.GitTestScenarioGenerator;
@@ -41,6 +40,7 @@ import java.util.Collection;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import static git4idea.test.GitExec.*;
+import static git4idea.util.GitUIUtil.getShortRepositoryName;
 import static org.testng.Assert.*;
 
 /**
@@ -340,6 +340,20 @@ public class GitBranchOperationsTest extends AbstractVcsTestCase  {
                    "<br/>You may rollback (checkout back to master) not to let branches diverge.",
                   "Rollback", "Don't rollback");
   }
+  
+  @Test
+  public void rollback_checkout_branch_as_new_branch_should_delete_branches() throws Exception {
+    prepareBranchForSimpleCheckout();
+    GitTestScenarioGenerator.prepareUnmergedFiles(myCommunity);
+    myMessageManager.nextAnswer(Messages.OK);
+    doCheckout("feature", "newBranch");
+    assertMessage(GitBranchOperation.UNMERGED_FILES_ERROR_TITLE);
+    assertBranch("master");
+    for (GitRepository repository : myRepositories) {
+      assertFalse(branch(repository).contains("newBranch"), "Branch newBranch wasn't deleted from repository " + getShortRepositoryName(
+        repository));
+    }
+  }
 
   private static void prepareLocalChangesAndBranchWithSameModifiedFilesWithoutConflicts(GitRepository repository) throws IOException {
     create(repository, "local.txt", "initial content\n");
@@ -494,16 +508,16 @@ public class GitBranchOperationsTest extends AbstractVcsTestCase  {
     doCheckout.invoke(processor, new EmptyProgressIndicator(), branchName, newBranch);
   }
 
-  private void assertBranch(String branch) {
+  private void assertBranch(String branch) throws IOException {
     for (GitRepository repository : myRepositories) {
       assertBranch(repository, branch);
     }
   }
 
-  private static void assertBranch(GitRepository repository, String branchName) {
-    GitBranch currentBranch = repository.getCurrentBranch();
+  private static void assertBranch(GitRepository repository, String branchName) throws IOException {
+    String currentBranch = currentBranch(repository);
     assertNotNull(currentBranch);
-    assertEquals(currentBranch.getName(), branchName);
+    assertEquals(currentBranch, branchName, "Expected " + branchName + " in [" + getShortRepositoryName(repository) + "]");
   }
 
   private void assertNotify(NotificationType type, String content) {
index cacf79de5907e514905fa2d0c8206baa5b3034d2..e7c709f79fe2319359a8f85606a237ab98838bc9 100644 (file)
@@ -22,6 +22,7 @@ import com.intellij.testFramework.VfsTestUtil;
 import com.intellij.util.ui.UIUtil;
 import git4idea.repo.GitRepository;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
 import java.io.IOException;
@@ -101,6 +102,17 @@ public class GitExec {
     return run(repository, "branch", params);
   }
 
+  @Nullable
+  public static String currentBranch(@NotNull GitRepository repository) throws IOException {
+    String[] branches = branch(repository).split("\n");
+    for (String branch : branches) {
+      if (branch.trim().startsWith("*")) {
+        return branch.trim().substring(1).trim();
+      }
+    }
+    return null;
+  }
+
   public static void checkout(@NotNull GitRepository repository, String... params) throws IOException {
     run(repository, "checkout", params);
   }