コード例 #1
0
  private static boolean pushCurrentBranch(
      @NotNull Project project,
      @NotNull GitRepository repository,
      @NotNull String remoteName,
      @NotNull String remoteUrl,
      @NotNull String name,
      @NotNull String url) {
    Git git = ServiceManager.getService(Git.class);

    GitLocalBranch currentBranch = repository.getCurrentBranch();
    if (currentBranch == null) {
      GithubNotifications.showErrorURL(
          project,
          "Can't finish GitHub sharing process",
          "Successfully created project ",
          "'" + name + "'",
          " on GitHub, but initial push failed: no current branch",
          url);
      return false;
    }
    GitCommandResult result =
        git.push(repository, remoteName, remoteUrl, currentBranch.getName(), true);
    if (!result.success()) {
      GithubNotifications.showErrorURL(
          project,
          "Can't finish GitHub sharing process",
          "Successfully created project ",
          "'" + name + "'",
          " on GitHub, but initial push failed:<br/>" + result.getErrorOutputAsHtmlString(),
          url);
      return false;
    }
    return true;
  }
コード例 #2
0
  @NotNull
  private static FetchParams getFetchParams(@NotNull GitRepository repository) {
    GitLocalBranch currentBranch = repository.getCurrentBranch();
    if (currentBranch == null) {
      // fetching current branch is called from Update Project and Push, where branch tracking is
      // pre-checked
      String message = "Current branch can't be null here. \nRepository: " + repository;
      LOG.error(message);
      return new FetchParams(GitFetchResult.error(new Exception(message)));
    }
    GitBranchTrackInfo trackInfo = GitBranchUtil.getTrackInfoForBranch(repository, currentBranch);
    if (trackInfo == null) {
      String message =
          "Tracked info is null for branch " + currentBranch + "\n Repository: " + repository;
      LOG.error(message);
      return new FetchParams(GitFetchResult.error(new Exception(message)));
    }

    GitRemote remote = trackInfo.getRemote();
    String url = remote.getFirstUrl();
    if (url == null) {
      String message = "URL is null for remote " + remote.getName();
      LOG.error(message);
      return new FetchParams(GitFetchResult.error(new Exception(message)));
    }

    return new FetchParams(remote, trackInfo.getRemoteBranch(), url);
  }
コード例 #3
0
 /**
  * Returns the tracking information (remote and the name of the remote branch), or null if we are
  * not on a branch.
  */
 @Nullable
 public static GitBranchTrackInfo getTrackInfoForCurrentBranch(@NotNull GitRepository repository) {
   GitLocalBranch currentBranch = repository.getCurrentBranch();
   if (currentBranch == null) {
     return null;
   }
   return GitBranchUtil.getTrackInfoForBranch(repository, currentBranch);
 }
コード例 #4
0
  /** Performs the actual sync/stash needed before attaching. */
  private void syncOrStash() {
    // When the user edits a document in intelliJ, there are spurious updates to the timestamp of
    // the document for an unspecified amount of time (even though there are no real edits).
    // So, we save-all right before we stash to (help) ensure we don't get a conflict dialog.
    // The conflict dialog happens when the timestamps of the document and file are mismatched.
    // So when we do the git operations, we want the document and file timestamps to match exactly.
    BasicAction.saveAll();

    mySourceRepository = mySyncResult.getLocalRepository();

    if (mySyncResult.needsStash() || mySyncResult.needsSync()) {
      if (mySourceRepository.getCurrentBranch() != null) {
        myOriginalBranchName = mySourceRepository.getCurrentBranch().getName();
      } else {
        myOriginalBranchName = mySourceRepository.getCurrentRevision();
      }
    }

    if (mySyncResult.needsStash()) {
      if (!stash()) {
        return;
      }
    }

    if (!Strings.isNullOrEmpty(mySyncResult.getTargetSyncSHA())) {
      // try to check out that revision.
      final GitBrancher brancher = ServiceManager.getService(myProject, GitBrancher.class);
      if (mySourceRepository == null) {
        LOG.error("unexpected null source repo with a target SHA.");
        return;
      }
      assert mySyncResult.getTargetSyncSHA() != null;
      brancher.checkout(
          mySyncResult.getTargetSyncSHA(),
          Collections.singletonList(mySourceRepository),
          new Runnable() {
            @Override
            public void run() {
              refreshAndClose();
            }
          });
    } else {
      refreshAndClose();
    }
  }
  @Nullable
  public static GithubCreatePullRequestWorker createPullRequestWorker(
      @NotNull final Project project, @Nullable final VirtualFile file) {
    Git git = ServiceManager.getService(Git.class);

    GitRepository gitRepository = GithubUtil.getGitRepository(project, file);
    if (gitRepository == null) {
      GithubNotifications.showError(
          project, CANNOT_CREATE_PULL_REQUEST, "Can't find git repository");
      return null;
    }
    gitRepository.update();

    Pair<GitRemote, String> remote = GithubUtil.findGithubRemote(gitRepository);
    if (remote == null) {
      GithubNotifications.showError(
          project, CANNOT_CREATE_PULL_REQUEST, "Can't find GitHub remote");
      return null;
    }
    String remoteName = remote.getFirst().getName();
    String remoteUrl = remote.getSecond();
    GithubFullPath path = GithubUrlUtil.getUserAndRepositoryFromRemoteUrl(remoteUrl);
    if (path == null) {
      GithubNotifications.showError(
          project, CANNOT_CREATE_PULL_REQUEST, "Can't process remote: " + remoteUrl);
      return null;
    }

    GitLocalBranch currentBranch = gitRepository.getCurrentBranch();
    if (currentBranch == null) {
      GithubNotifications.showError(project, CANNOT_CREATE_PULL_REQUEST, "No current branch");
      return null;
    }

    GithubAuthData auth;
    try {
      auth =
          GithubUtil.computeValueInModal(
              project,
              "Access to GitHub",
              new ThrowableConvertor<ProgressIndicator, GithubAuthData, IOException>() {
                @Override
                public GithubAuthData convert(ProgressIndicator indicator) throws IOException {
                  return GithubUtil.getValidAuthDataFromConfig(project, indicator);
                }
              });
    } catch (GithubAuthenticationCanceledException e) {
      return null;
    } catch (IOException e) {
      GithubNotifications.showError(project, CANNOT_CREATE_PULL_REQUEST, e);
      return null;
    }

    return new GithubCreatePullRequestWorker(
        project, git, gitRepository, path, remoteName, remoteUrl, currentBranch.getName(), auth);
  }
コード例 #6
0
  /**
   * Setup remotes combobox. The default remote for the current branch is selected by default. This
   * method gets current branch for the project.
   *
   * @param project the project
   * @param root the git root
   * @param remoteCombobox the combobox to update
   * @param fetchUrl if true, the fetch url is shown instead of push url
   */
  public static void setupRemotes(
      final Project project,
      final VirtualFile root,
      final JComboBox remoteCombobox,
      final boolean fetchUrl) {
    final GitRepository repo = GitRepositoryManager.getInstance(project).getRepositoryForRoot(root);
    assert repo != null : "GitRepository can't be null for root " + root;
    GitBranch gitBranch = repo.getCurrentBranch();

    final String branch = gitBranch != null ? gitBranch.getName() : null;
    setupRemotes(project, root, branch, remoteCombobox, fetchUrl);
  }
  private String makeDescription() {
    String currentBranchOrRev;
    boolean onBranch;
    if (myRepositories.size() > 1) {
      LOG.assertTrue(myBaseBranch != null, "Branches have unexpectedly diverged");
      currentBranchOrRev = myBaseBranch;
      onBranch = true;
    } else {
      GitRepository repository = myInitialRepository;
      if (repository.isOnBranch()) {
        GitBranch currentBranch = repository.getCurrentBranch();
        assert currentBranch != null;
        currentBranchOrRev = currentBranch.getName();
        onBranch = true;
      } else {
        currentBranchOrRev = repository.getCurrentRevision();
        onBranch = false;
      }
    }

    StringBuilder description = new StringBuilder();
    if (onBranch) {
      description.append(
          GitBundle.message(
              "branch.delete.not_fully_merged.description", myBranchToDelete, myBaseBranch));
    } else {
      description.append(
          GitBundle.message(
              "branch.delete.not_fully_merged.description.not_on_branch",
              myBranchToDelete,
              currentBranchOrRev,
              myBaseBranch));
    }
    if (!myMergedToBranches.isEmpty()) {
      String listOfMergedBranches =
          StringUtil.join(
              StringUtil.surround(ArrayUtil.toStringArray(myMergedToBranches), "<b>", "</b>"),
              ", ");
      description.append("<br>");
      if (myMergedToBranches.size() == 1) {
        description.append(
            GitBundle.message(
                "branch.delete.merged_to.one", myBranchToDelete, listOfMergedBranches));
      } else {
        description.append(
            GitBundle.message(
                "branch.delete.merged_to.many", myBranchToDelete, listOfMergedBranches));
      }
    }
    description.append("<br>").append(GitBundle.message("branch.delete.warning", myBranchToDelete));
    return description.toString();
  }
コード例 #8
0
 /**
  * For each root check that the repository is on branch, and this branch is tracking a remote
  * branch, and the remote branch exists. If it is not true for at least one of roots, notify and
  * return false. If branch configuration is OK for all roots, return true.
  */
 private boolean checkTrackedBranchesConfigured() {
   LOG.info("checking tracked branch configuration...");
   for (GitRepository repository : myRepositories) {
     VirtualFile root = repository.getRoot();
     final GitLocalBranch branch = repository.getCurrentBranch();
     if (branch == null) {
       LOG.info("checkTrackedBranchesConfigured: current branch is null in " + repository);
       notifyImportantError(
           myProject,
           "Can't update: no current branch",
           "You are in 'detached HEAD' state, which means that you're not on any branch"
               + rootStringIfNeeded(root)
               + "Checkout a branch to make update possible.");
       return false;
     }
     GitBranchTrackInfo trackInfo = GitBranchUtil.getTrackInfoForBranch(repository, branch);
     if (trackInfo == null) {
       final String branchName = branch.getName();
       LOG.info(
           String.format(
               "checkTrackedBranchesConfigured: no track info for current branch %s in %s",
               branch, repository));
       String recommendedCommand =
           String.format(
               GitVersionSpecialty.KNOWS_SET_UPSTREAM_TO.existsIn(repository.getVcs().getVersion())
                   ? "git branch --set-upstream-to origin/%1$s %1$s"
                   : "git branch --set-upstream %1$s origin/%1$s",
               branchName);
       notifyImportantError(
           myProject,
           "Can't update: no tracked branch",
           "No tracked branch configured for branch "
               + code(branchName)
               + rootStringIfNeeded(root)
               + "To make your branch track a remote branch call, for example,<br/>"
               + "<code>"
               + recommendedCommand
               + "</code>");
       return false;
     }
     myTrackedBranches.put(root, new GitBranchPair(branch, trackInfo.getRemoteBranch()));
   }
   return true;
 }
コード例 #9
0
  private static List<String> getBranchNamesExceptCurrent(GitRepository repository) {
    List<GitBranch> localBranches =
        new ArrayList<GitBranch>(repository.getBranches().getLocalBranches());
    Collections.sort(localBranches);
    List<GitBranch> remoteBranches =
        new ArrayList<GitBranch>(repository.getBranches().getRemoteBranches());
    Collections.sort(remoteBranches);

    if (repository.isOnBranch()) {
      localBranches.remove(repository.getCurrentBranch());
    }

    final List<String> branchNames = new ArrayList<String>();
    for (GitBranch branch : localBranches) {
      branchNames.add(branch.getName());
    }
    for (GitBranch branch : remoteBranches) {
      branchNames.add(branch.getName());
    }
    return branchNames;
  }
コード例 #10
0
  @Override
  public void actionPerformed(final AnActionEvent event) {
    final Project project = event.getProject();
    assert project != null;

    final VirtualFile file = getAffectedFile(event);

    GitRepositoryManager manager = GitUtil.getRepositoryManager(project);
    GitRepository repository = manager.getRepositoryForFile(file);
    assert repository != null;

    GitBranch currentBranch = repository.getCurrentBranch();
    final String head;
    if (currentBranch == null) {
      String currentRevision = repository.getCurrentRevision();
      LOG.assertTrue(
          currentRevision != null,
          "Current revision is null for "
              + repository
              + ". Compare with branch shouldn't be available for fresh repository");
      head = DvcsUtil.getShortHash(currentRevision);
    } else {
      head = currentBranch.getName();
    }
    final List<String> branchNames = getBranchNamesExceptCurrent(repository);

    // prepare and invoke popup
    final JBList list = new JBList(branchNames);

    JBPopupFactory.getInstance()
        .createListPopupBuilder(list)
        .setTitle("Select branch to compare")
        .setItemChoosenCallback(new OnBranchChooseRunnable(project, file, head, list))
        .setAutoselectOnMouseMove(true)
        .createPopup()
        .showInBestPositionFor(event.getDataContext());
  }