import git4idea.repo.GitRemote; //导入依赖的package包/类
@Nullable
public static Pair<GitRemote, String> findGithubRemote(@NotNull GitRepository repository) {
  Pair<GitRemote, String> githubRemote = null;
  for (GitRemote gitRemote : repository.getRemotes()) {
    for (String remoteUrl : gitRemote.getUrls()) {
      if (GithubUrlUtil.isGithubUrl(remoteUrl)) {
        final String remoteName = gitRemote.getName();
        if ("github".equals(remoteName) || "origin".equals(remoteName)) {
          return Pair.create(gitRemote, remoteUrl);
        }
        if (githubRemote == null) {
          githubRemote = Pair.create(gitRemote, remoteUrl);
        }
        break;
      }
    }
  }
  return githubRemote;
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
public CloudGitApplication findApplication4Repository() throws ServerRuntimeException {
  final List<String> repositoryUrls = new ArrayList<String>();
  for (GitRemote remote : getRepository().getRemotes()) {
    for (String url : remote.getUrls()) {
      repositoryUrls.add(url);
    }
  }

  return getAgentTaskExecutor().execute(new Computable<CloudGitApplication>() {

    @Override
    public CloudGitApplication compute() {
      return getDeployment().findApplication4Repository(ArrayUtil.toStringArray(repositoryUrls));
    }
  });
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
@NotNull
public static GitPushTarget parse(@NotNull GitRepository repository, @Nullable String remoteName, @NotNull String branchName) throws
                                                                                                                      ParseException {
  if (remoteName == null) {
    throw new ParseException("No remotes defined", -1);
  }

  if (!GitRefNameValidator.getInstance().checkInput(branchName)) {
    throw new ParseException("Invalid destination branch name: " + branchName, -1);
  }

  GitRemote remote = findRemote(repository.getRemotes(), remoteName);
  if (remote == null) {
    LOG.error("Remote [" + remoteName + "] is not found among " + repository.getRemotes());
    throw new ParseException("Invalid remote: " + remoteName, -1);
  }

  GitRemoteBranch existingRemoteBranch = findRemoteBranch(repository, remote, branchName);
  if (existingRemoteBranch != null) {
    return new GitPushTarget(existingRemoteBranch, false);
  }
  GitRemoteBranch rb = new GitStandardRemoteBranch(remote, branchName, GitBranch.DUMMY_HASH);
  return new GitPushTarget(rb, true);
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
@Override
public int compare(@NotNull GitRemoteBranch o1, @NotNull GitRemoteBranch o2) {
  String remoteName1 = o1.getRemote().getName();
  String remoteName2 = o2.getRemote().getName();
  int remoteComparison = remoteName1.compareTo(remoteName2);
  if (remoteComparison != 0) {
    if (remoteName1.equals(GitRemote.ORIGIN_NAME)) {
      return -1;
    }
    if (remoteName2.equals(GitRemote.ORIGIN_NAME)) {
      return 1;
    }
    return remoteComparison;
  }
  return o1.getNameForLocalOperations().compareTo(o2.getNameForLocalOperations());
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
private static GitPushTarget proposeTargetForNewBranch(GitRepository repository, GitLocalBranch currentBranch) {
  Collection<GitRemote> remotes = repository.getRemotes();
  if (remotes.isEmpty()) {
    return null; // TODO need to propose to declare new remote
  }
  else if (remotes.size() == 1) {
    return makeTargetForNewBranch(repository, remotes.iterator().next(), currentBranch);
  }
  else {
    GitRemote remote = GitUtil.getDefaultRemote(remotes);
    if (remote == null) {
      remote = remotes.iterator().next();
    }
    return makeTargetForNewBranch(repository, remote, currentBranch);
  }
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
/**
 * Fetch remote branch
 * {@code git fetch <remote> <params>}
 */
@Override
@NotNull
public GitCommandResult fetch(@NotNull final GitRepository repository,
                              @NotNull final GitRemote remote,
                              @NotNull final List<GitLineHandlerListener> listeners,
                              final String... params) {
  return runCommand(new Computable<GitLineHandler>() {
    @Override
    public GitLineHandler compute() {
      final GitLineHandler h = new GitLineHandler(repository.getProject(), repository.getRoot(), GitCommand.FETCH);
      h.setSilent(false);
      h.setStdoutSuppressed(false);
      h.setUrls(remote.getUrls());
      h.addParameters(remote.getName());
      h.addParameters(params);
      h.addProgressParameter();
      GitVcs vcs = GitVcs.getInstance(repository.getProject());
      if (vcs != null && GitVersionSpecialty.SUPPORTS_FETCH_PRUNE.existsIn(vcs.getVersion())) {
        h.addParameters("--prune");
      }
      addListeners(h, listeners);
      return h;
    }
  });
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
@NotNull
private GitFetchResult fetchAll(@NotNull GitRepository repository, @NotNull GitFetchResult fetchResult) {
  for (GitRemote remote : repository.getRemotes()) {
    String url = remote.getFirstUrl();
    if (url == null) {
      LOG.error("URL is null for remote " + remote.getName());
      continue;
    }
    GitFetchResult res = fetchNatively(repository, remote, null);
    res.addPruneInfo(fetchResult.getPrunedRefs());
    fetchResult = res;
    if (!fetchResult.isSuccess()) {
      break;
    }
  }
  return fetchResult;
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
@NotNull
private static GitFetchResult fetchNatively(@NotNull GitRepository repository, @NotNull GitRemote remote, @Nullable String branch) {
  Git git = ServiceManager.getService(Git.class);
  String[] additionalParams = branch != null ?
                              new String[]{ getFetchSpecForBranch(branch, remote.getName()) } :
                              ArrayUtil.EMPTY_STRING_ARRAY;

  GitFetchPruneDetector pruneDetector = new GitFetchPruneDetector();
  GitCommandResult result = git.fetch(repository, remote,
                                      Collections.<GitLineHandlerListener>singletonList(pruneDetector), additionalParams);

  GitFetchResult fetchResult;
  if (result.success()) {
    fetchResult = GitFetchResult.success();
  }
  else if (result.cancelled()) {
    fetchResult = GitFetchResult.cancel();
  }
  else {
    fetchResult = GitFetchResult.error(result.getErrorOutputAsJoinedString());
  }
  fetchResult.addPruneInfo(pruneDetector.getPrunedRefs());
  return fetchResult;
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
private void setupGetBranches() {
  myGetBranchesButton.setIcon(AllIcons.Actions.Refresh);
  myGetBranchesButton.setEnabled(myRemote.getItemCount() >= 1);
  myGetBranchesButton.addActionListener(new ActionListener() {
    public void actionPerformed(final ActionEvent e) {
      GitRemote selectedItem = (GitRemote)myRemote.getSelectedItem();
      Collection<String> remoteBranches = selectedItem != null ? getRemoteBranches(selectedItem) : null;
      if (remoteBranches != null) {
        myBranchChooser.removeAllElements();
        for (String branch : remoteBranches) {
          myBranchChooser.addElement(branch, false);
        }
      }
    }
  });
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
/**
 * If the current branch is a tracking branch, returns its remote.
 * Otherwise tries to guess: if there is origin, returns origin, otherwise returns the first remote in the list.
 */
@Nullable
private static GitRemote getCurrentOrDefaultRemote(@NotNull GitRepository repository) {
  Collection<GitRemote> remotes = repository.getRemotes();
  if (remotes.isEmpty()) {
    return null;
  }

  GitBranchTrackInfo trackInfo = GitUtil.getTrackInfoForCurrentBranch(repository);
  if (trackInfo != null) {
    return trackInfo.getRemote();
  }
  else {
    GitRemote origin = GitUtil.getDefaultRemote(remotes);
    if (origin != null) {
      return origin;
    }
    else {
      return remotes.iterator().next();
    }
  }
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
/**
 * Create list cell renderer for remotes. It shows both name and url and highlights the default
 * remote for the branch with bold.
 *
 *
 * @param defaultRemote a default remote
 * @return a list cell renderer for virtual files (it renders presentable URL
 */
public ListCellRendererWrapper<GitRemote> getGitRemoteListCellRenderer(final String defaultRemote) {
  return new ListCellRendererWrapper<GitRemote>() {
    @Override
    public void customize(final JList list, final GitRemote remote, final int index, final boolean selected, final boolean hasFocus) {
      final String text;
      if (remote == null) {
        text = GitBundle.getString("util.remote.renderer.none");
      }
      else if (".".equals(remote.getName())) {
        text = GitBundle.getString("util.remote.renderer.self");
      }
      else {
        String key;
        if (defaultRemote != null && defaultRemote.equals(remote.getName())) {
          key = "util.remote.renderer.default";
        }
        else {
          key = "util.remote.renderer.normal";
        }
        text = GitBundle.message(key, remote.getName(), remote.getFirstUrl());
      }
      setText(text);
    }
  };
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
@NotNull
protected static PushSpec<GitPushSource, GitPushTarget> makePushSpec(@NotNull GitRepository repository,
                                                                     @NotNull String from,
                                                                     @NotNull String to) {
  GitLocalBranch source = repository.getBranches().findLocalBranch(from);
  assertNotNull(source);
  GitRemoteBranch target = (GitRemoteBranch)repository.getBranches().findBranchByName(to);
  boolean newBranch;
  if (target == null) {
    int firstSlash = to.indexOf('/');
    GitRemote remote = GitUtil.findRemoteByName(repository, to.substring(0, firstSlash));
    assertNotNull(remote);
    target = new GitStandardRemoteBranch(remote, to.substring(firstSlash + 1), GitBranch.DUMMY_HASH);
    newBranch = true;
  }
  else {
    newBranch = false;
  }
  return new PushSpec<GitPushSource, GitPushTarget>(GitPushSource.create(source), new GitPushTarget(target, newBranch));
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
public static GitRemote getTfGitRemote(@NotNull final GitRepository gitRepository) {
    if (gitRepository == null) {
        throw new IllegalArgumentException();
    }
    GitRemote first = null;
    for (GitRemote gitRemote : gitRepository.getRemotes()) {
        if (isTfGitRemote(gitRemote)) {
            if (gitRemote.getName().equals("origin")) {
                return gitRemote;
            } else if (first == null) {
                first = gitRemote;
            }
        }
    }
    return first;
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
/**
 * This method for now assumes the default branch name is master
 * <p/>
 * If there is no master, return the first branch on the list or null for empty list
 * <p/>
 * We should get the default branch from TF if necessary, but that's a server call
 */
@Nullable
public static GitRemoteBranch getDefaultBranch(@NotNull final List<GitRemoteBranch> remoteBranches, @NotNull final Collection<GitRemote> tfGitRemotes) {
    if (remoteBranches.isEmpty() || tfGitRemotes.isEmpty()) {
        return null;
    }

    final GitRemote firstTfRemote = tfGitRemotes.iterator().next();

    final String masterBranchName = String.format(MASTER_BRANCH_PATTERN, firstTfRemote.getName());
    for (GitRemoteBranch remoteBranch : remoteBranches) {
        if (remoteBranch.getName().equals(masterBranchName)) {
            return remoteBranch;
        }
    }

    return remoteBranches.get(0);
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
@Override
public void doActionPerformed(@NotNull final AnActionEvent anActionEvent) {
    final Project project = anActionEvent.getRequiredData(CommonDataKeys.PROJECT);
    final VcsFullCommitDetails commit = anActionEvent.getRequiredData(VcsLogDataKeys.VCS_LOG).getSelectedDetails().get(0);

    final GitRepository gitRepository = GitUtil.getRepositoryManager(project).getRepositoryForRoot(commit.getRoot());
    final GitRemote remote = TfGitHelper.getTfGitRemote(gitRepository);

    // guard for null so findbugs doesn't complain
    if (remote == null) {
        return;
    }

    final String remoteUrl = remote.getFirstUrl();
    if (remoteUrl == null) {
        return;
    }

    final URI urlToBrowseTo = UrlHelper.getCommitURI(remoteUrl, commit.getId().toString());
    logger.info("Browsing to url " + urlToBrowseTo.getPath());
    BrowserUtil.browse(urlToBrowseTo);
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    projectMock = Mockito.mock(Project.class);
    gitRepoInfoMock = Mockito.mock(GitRepoInfo.class);
    gitRepositoryMock = Mockito.mock(GitRepository.class);
    diffProviderMock = Mockito.mock(DiffCompareInfoProvider.class);
    observerMock = Mockito.mock(Observer.class);
    applicationProviderMock = Mockito.mock(CreatePullRequestModel.ApplicationProvider.class);
    currentBranch = PRGitObjectMockHelper.createLocalBranch("local");

    tfsRemote = new GitRemote("origin", Arrays.asList("https://mytest.visualstudio.com/DefaultCollection/_git/testrepo"),
            Arrays.asList("https://pushurl"), Collections.<String>emptyList(), Collections.<String>emptyList());

    when(diffProviderMock.getEmptyDiff(gitRepositoryMock)).thenCallRealMethod();
    when(gitRepositoryMock.getInfo()).thenReturn(gitRepoInfoMock);
    when(gitRepositoryMock.getRemotes()).thenReturn(Collections.singletonList(tfsRemote));
    when(gitRepoInfoMock.getCurrentBranch()).thenReturn(currentBranch);
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
@Test
public void targetDropDownOnlyShowsTfRemoteBranches() {
    GitRemoteBranch first = PRGitObjectMockHelper.createRemoteBranch("origin/test1", tfsRemote);
    GitRemoteBranch second = PRGitObjectMockHelper.createRemoteBranch("origin/test2", tfsRemote);
    GitRemoteBranch master = PRGitObjectMockHelper.createRemoteBranch("origin/master", tfsRemote);

    // two remotes, non tfs repo should be filtered out
    GitRemote nonTfsRemote = new GitRemote("origin", Arrays.asList("https://mytest.notvso.com/git/testrepo"),
            Arrays.asList("https://pushurl"), Collections.<String>emptyList(), Collections.<String>emptyList());

    when(gitRepositoryMock.getRemotes()).thenReturn(Arrays.asList(tfsRemote, nonTfsRemote));
    GitRemoteBranch nonTfsMaster = PRGitObjectMockHelper.createRemoteBranch("other/master", nonTfsRemote);
    when(gitRepoInfoMock.getRemoteBranches()).thenReturn(Arrays.asList(
            first, second, master, nonTfsMaster
    ));
    underTest = new CreatePullRequestModel(projectMock, gitRepositoryMock);

    // nonTfsMaster should be filtered out
    assertEquals(3, underTest.getRemoteBranchDropdownModel().getSize());
    for (int i = 0; i < underTest.getRemoteBranchDropdownModel().getSize(); ++i) {
        assertNotEquals(nonTfsMaster, underTest.getRemoteBranchDropdownModel().getElementAt(i));
    }
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
public static
@Nullable
String getPortionOfBitbucketUrl(Collection<GitRemote> remotes, int group) {
    Iterator<GitRemote> remotesIter = remotes.iterator();
    if (!remotesIter.hasNext()) {
        return null;
    }
    GitRemote firstRemote = remotesIter.next();
    String firstUrl = firstRemote.getFirstUrl();
    if (firstUrl != null) {
        Matcher matcher = BITBUCKET_REPO_PATTERN.matcher(firstUrl);
        if (matcher.matches()) {
            //noinspection UnnecessaryLocalVariable
            String value = matcher.group(group);
            return value;
        }
    }
    return null;
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
@NotNull
public GtPushResult push(@NotNull TagsPushSpec pushSpec) {
  Preconditions.checkNotNull(pushSpec);
  GitRepository repository = GitUtil.getRepositoryManager(project).getRepositoryForRoot(pushSpec.gitRoot());
  Optional<GitBranchTrackInfo> trackInfo = Optional.ofNullable(GitUtil.getTrackInfoForCurrentBranch(repository));
  if (trackInfo.isPresent()) {
    GitRemote remote = trackInfo.get().getRemote();
    Optional<String> url = Optional.ofNullable(remote.getFirstUrl());
    if (url.isPresent()) {
      return push(pushSpec, repository, remote, url.get());
    } else {
      return GtPushResult.error(ResBundle.message("message.no.remote.url", remote.getName()));
    }
  } else {
    return GtPushResult.error(ResBundle.getString("message.cannot.push.without.tracking"));
  }
}
 

import git4idea.repo.GitRemote; //导入依赖的package包/类
@Nullable
public static Pair<GitRemote, String> findGithubRemote(@NotNull GitRepository repository) {
  Pair<GitRemote, String> githubRemote = null;
  for (GitRemote gitRemote : repository.getRemotes()) {
    for (String remoteUrl : gitRemote.getUrls()) {
      if (GithubUrlUtil.isGithubUrl(remoteUrl)) {
        final String remoteName = gitRemote.getName();
        if ("github".equals(remoteName) || "origin".equals(remoteName)) {
          return new Pair<GitRemote, String>(gitRemote, remoteUrl);
        }
        if (githubRemote == null) {
          githubRemote = new Pair<GitRemote, String>(gitRemote, remoteUrl);
        }
        break;
      }
    }
  }
  return githubRemote;
}