private void doLoadForksFromGithub(@NotNull ProgressIndicator indicator) throws IOException {
    GithubRepoDetailed repo =
        GithubUtil.runTask(
            myProject,
            myAuthHolder,
            indicator,
            new ThrowableConvertor<GithubConnection, GithubRepoDetailed, IOException>() {
              @NotNull
              @Override
              public GithubRepoDetailed convert(@NotNull GithubConnection connection)
                  throws IOException {
                return GithubApiUtil.getDetailedRepoInfo(
                    connection, myPath.getUser(), myPath.getRepository());
              }
            });

    doAddFork(repo, indicator);
    if (repo.getParent() != null) {
      doAddFork(repo.getParent(), indicator);
    }
    if (repo.getSource() != null) {
      doAddFork(repo.getSource(), indicator);
    }

    mySource = repo.getSource() == null ? repo.getFullPath() : repo.getSource().getFullPath();
  }
 @Nullable
 private List<GithubFullPath> getAvailableForks(@NotNull ProgressIndicator indicator) {
   try {
     List<GithubFullPath> forks =
         ContainerUtil.map(
             GithubUtil.runTask(
                 myProject,
                 myAuthHolder,
                 indicator,
                 new ThrowableConvertor<GithubConnection, List<GithubRepo>, IOException>() {
                   @NotNull
                   @Override
                   public List<GithubRepo> convert(@NotNull GithubConnection connection)
                       throws IOException {
                     return GithubApiUtil.getForks(
                         connection, mySource.getUser(), mySource.getRepository());
                   }
                 }),
             new Function<GithubRepo, GithubFullPath>() {
               @Override
               public GithubFullPath fun(GithubRepo repo) {
                 return repo.getFullPath();
               }
             });
     if (!forks.contains(mySource)) return ContainerUtil.append(forks, mySource);
     return forks;
   } catch (IOException e) {
     GithubNotifications.showWarning(myProject, "Can't load available forks", e);
     return null;
   }
 }
  public boolean checkAction(@Nullable final BranchInfo branch) {
    if (branch == null) {
      GithubNotifications.showWarningDialog(
          myProject, CANNOT_CREATE_PULL_REQUEST, "Target branch is not selected");
      return false;
    }

    DiffInfo info;
    try {
      info =
          GithubUtil.computeValueInModal(
              myProject,
              "Collecting diff data...",
              new ThrowableConvertor<ProgressIndicator, DiffInfo, IOException>() {
                @Override
                public DiffInfo convert(ProgressIndicator indicator) throws IOException {
                  return GithubUtil.runInterruptable(
                      indicator,
                      new ThrowableComputable<DiffInfo, IOException>() {
                        @Override
                        public DiffInfo compute() throws IOException {
                          return getDiffInfo(branch);
                        }
                      });
                }
              });
    } catch (IOException e) {
      GithubNotifications.showError(myProject, "Can't collect diff data", e);
      return true;
    }
    if (info == null) {
      return true;
    }

    ForkInfo fork = branch.getForkInfo();

    String localBranchName = "'" + myCurrentBranch + "'";
    String targetBranchName = "'" + fork.getRemoteName() + "/" + branch.getRemoteName() + "'";
    if (info.getInfo().getBranchToHeadCommits(myGitRepository).isEmpty()) {
      return GithubNotifications.showYesNoDialog(
          myProject,
          "Do you want to proceed anyway?",
          "Empty pull request: the branch "
              + localBranchName
              + " is fully merged to the branch "
              + targetBranchName);
    }
    if (!info.getInfo().getHeadToBranchCommits(myGitRepository).isEmpty()) {
      return GithubNotifications.showYesNoDialog(
          myProject,
          "Do you want to proceed anyway?",
          "The branch "
              + targetBranchName
              + " is not fully merged to the branch "
              + localBranchName);
    }

    return true;
  }
  private void doConfigureRemote(@NotNull ForkInfo fork) {
    if (fork.getRemoteName() != null) return;

    GithubFullPath path = fork.getPath();
    String url = GithubUrlUtil.getCloneUrl(path);

    if (GithubUtil.addGithubRemote(myProject, myGitRepository, path.getUser(), url)) {
      fork.setRemoteName(path.getUser());
    }
  }
 public void configureRemote(@NotNull final ForkInfo fork) {
   GithubUtil.computeValueInModal(
       myProject,
       "Creating remote..",
       false,
       new Consumer<ProgressIndicator>() {
         @Override
         public void consume(ProgressIndicator indicator) {
           doConfigureRemote(fork);
         }
       });
 }
 @Override
 protected void doOKAction() {
   final String login = myGithubLoginPanel.getLogin();
   final String password = myGithubLoginPanel.getPassword();
   if (GithubUtil.checkCredentials(myProject, login, password)) {
     final GithubSettings settings = GithubSettings.getInstance();
     settings.setLogin(login);
     settings.setPassword(password);
     super.doOKAction();
   } else {
     setErrorText("Cannot login with given credentials");
   }
 }
  @Nullable
  @Override
  public AuthData getAuthData(@NotNull String url) {
    if (!GithubUtil.isGithubUrl(url)) {
      return null;
    }

    GithubSettings settings = GithubSettings.getInstance();
    String login = settings.getLogin();
    if (StringUtil.isEmptyOrSpaces(login)) {
      return null;
    }

    return new AuthData(login, settings.getPassword());
  }
 @Nullable
 private String doLoadDefaultBranch(
     @NotNull final GithubFullPath fork, @NotNull ProgressIndicator indicator) throws IOException {
   GithubRepo repo =
       GithubUtil.runTask(
           myProject,
           myAuthHolder,
           indicator,
           new ThrowableConvertor<GithubConnection, GithubRepo, IOException>() {
             @Override
             public GithubRepo convert(@NotNull GithubConnection connection) throws IOException {
               return GithubApiUtil.getDetailedRepoInfo(
                   connection, fork.getUser(), fork.getRepository());
             }
           });
   return repo.getDefaultBranch();
 }
  @Nullable
  private ForkInfo findRepositoryByUser(
      @NotNull final ProgressIndicator indicator, @NotNull final String user) {
    for (ForkInfo fork : myForks) {
      if (StringUtil.equalsIgnoreCase(user, fork.getPath().getUser())) {
        return fork;
      }
    }

    try {
      GithubRepo repo =
          GithubUtil.runTask(
              myProject,
              myAuthHolder,
              indicator,
              new ThrowableConvertor<GithubConnection, GithubRepo, IOException>() {
                @Nullable
                @Override
                public GithubRepo convert(@NotNull GithubConnection connection) throws IOException {
                  try {
                    GithubRepoDetailed target =
                        GithubApiUtil.getDetailedRepoInfo(
                            connection, user, mySource.getRepository());
                    if (target.getSource() != null
                        && StringUtil.equals(
                            target.getSource().getUserName(), mySource.getUser())) {
                      return target;
                    }
                  } catch (IOException ignore) {
                    // such repo may not exist
                  }

                  return GithubApiUtil.findForkByUser(
                      connection, mySource.getUser(), mySource.getRepository(), user);
                }
              });

      if (repo == null) return null;
      return doAddFork(repo, indicator);
    } catch (IOException e) {
      GithubNotifications.showError(myProject, "Can't find repository", e);
      return null;
    }
  }
  @Nullable
  public ForkInfo showTargetDialog() {
    if (myAvailableForks == null) {
      myAvailableForks =
          GithubUtil.computeValueInModal(
              myProject,
              myCurrentBranch,
              new Convertor<ProgressIndicator, List<GithubFullPath>>() {
                @Override
                public List<GithubFullPath> convert(ProgressIndicator indicator) {
                  return getAvailableForks(indicator);
                }
              });
    }

    Convertor<String, ForkInfo> getForkPath =
        new Convertor<String, ForkInfo>() {
          @Nullable
          @Override
          public ForkInfo convert(@NotNull final String user) {
            return GithubUtil.computeValueInModal(
                myProject,
                "Access to GitHub",
                new Convertor<ProgressIndicator, ForkInfo>() {
                  @Nullable
                  @Override
                  public ForkInfo convert(ProgressIndicator indicator) {
                    return findRepositoryByUser(indicator, user);
                  }
                });
          }
        };
    GithubSelectForkDialog dialog =
        new GithubSelectForkDialog(myProject, myAvailableForks, getForkPath);
    DialogManager.show(dialog);
    if (!dialog.isOK()) {
      return null;
    }
    return dialog.getPath();
  }
  public void showDiffDialog(@Nullable final BranchInfo branch) {
    if (branch == null) {
      GithubNotifications.showWarningDialog(
          myProject, "Can't Show Diff", "Target branch is not selected");
      return;
    }

    DiffInfo info;
    try {
      info =
          GithubUtil.computeValueInModal(
              myProject,
              "Collecting diff data...",
              new ThrowableConvertor<ProgressIndicator, DiffInfo, IOException>() {
                @Override
                public DiffInfo convert(ProgressIndicator indicator) throws IOException {
                  return GithubUtil.runInterruptable(
                      indicator,
                      new ThrowableComputable<DiffInfo, IOException>() {
                        @Override
                        public DiffInfo compute() throws IOException {
                          return getDiffInfo(branch);
                        }
                      });
                }
              });
    } catch (IOException e) {
      GithubNotifications.showError(myProject, "Can't collect diff data", e);
      return;
    }
    if (info == null) {
      GithubNotifications.showErrorDialog(myProject, "Can't Show Diff", "Can't collect diff data");
      return;
    }

    GitCompareBranchesDialog dialog =
        new GitCompareBranchesDialog(
            myProject, info.getTo(), info.getFrom(), info.getInfo(), myGitRepository, true);
    dialog.show();
  }
  @NotNull
  public Couple<String> getDefaultDescriptionMessage(@NotNull final BranchInfo branch) {
    Couple<String> message = branch.getDefaultMessage();
    if (message != null) return message;

    if (branch.getForkInfo().getRemoteName() == null) {
      return getSimpleDefaultDescriptionMessage(branch);
    }

    return GithubUtil.computeValueInModal(
        myProject,
        "Collecting additional data...",
        false,
        new Convertor<ProgressIndicator, Couple<String>>() {
          @Override
          public Couple<String> convert(ProgressIndicator o) {
            String localBranch = myCurrentBranch;
            String targetBranch =
                branch.getForkInfo().getRemoteName() + "/" + branch.getRemoteName();
            try {
              List<VcsCommitMetadata> commits =
                  GitHistoryUtils.readLastCommits(
                      myProject, myGitRepository.getRoot(), localBranch, targetBranch);
              if (commits == null) return getSimpleDefaultDescriptionMessage(branch);

              VcsCommitMetadata localCommit = commits.get(0);
              VcsCommitMetadata targetCommit = commits.get(1);

              if (localCommit.getParents().contains(targetCommit.getId())) {
                return Couple.of(localCommit.getSubject(), localCommit.getFullMessage());
              }
              return getSimpleDefaultDescriptionMessage(branch);
            } catch (VcsException e) {
              GithubNotifications.showWarning(myProject, "Can't collect additional data", e);
              return getSimpleDefaultDescriptionMessage(branch);
            }
          }
        });
  }
 @NotNull
 private List<String> loadBranches(
     @NotNull final GithubFullPath fork, @NotNull ProgressIndicator indicator) throws IOException {
   return ContainerUtil.map(
       GithubUtil.runTask(
           myProject,
           myAuthHolder,
           indicator,
           new ThrowableConvertor<GithubConnection, List<GithubBranch>, IOException>() {
             @Override
             public List<GithubBranch> convert(@NotNull GithubConnection connection)
                 throws IOException {
               return GithubApiUtil.getRepoBranches(
                   connection, fork.getUser(), fork.getRepository());
             }
           }),
       new Function<GithubBranch, String>() {
         @Override
         public String fun(@NotNull GithubBranch branch) {
           return branch.getName();
         }
       });
 }
  @Nullable
  private GithubPullRequest doCreatePullRequest(
      @NotNull ProgressIndicator indicator,
      @NotNull final BranchInfo branch,
      @NotNull final String title,
      @NotNull final String description) {
    final ForkInfo fork = branch.getForkInfo();

    final String head = myPath.getUser() + ":" + myCurrentBranch;
    final String base = branch.getRemoteName();

    try {
      return GithubUtil.runTask(
          myProject,
          myAuthHolder,
          indicator,
          new ThrowableConvertor<GithubConnection, GithubPullRequest, IOException>() {
            @NotNull
            @Override
            public GithubPullRequest convert(@NotNull GithubConnection connection)
                throws IOException {
              return GithubApiUtil.createPullRequest(
                  connection,
                  fork.getPath().getUser(),
                  fork.getPath().getRepository(),
                  title,
                  description,
                  head,
                  base);
            }
          });
    } catch (IOException e) {
      GithubNotifications.showError(myProject, CANNOT_CREATE_PULL_REQUEST, e);
      return null;
    }
  }
  @Nullable
  public static GithubCreatePullRequestWorker create(
      @NotNull final Project project, @Nullable final VirtualFile file) {
    return GithubUtil.computeValueInModal(
        project,
        "Loading data...",
        new Convertor<ProgressIndicator, GithubCreatePullRequestWorker>() {
          @Override
          public GithubCreatePullRequestWorker convert(ProgressIndicator indicator) {
            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;
            }

            GithubAuthDataHolder authHolder;
            try {
              authHolder = GithubUtil.getValidAuthDataHolderFromConfig(project, indicator);
            } catch (IOException e) {
              GithubNotifications.showError(project, CANNOT_CREATE_PULL_REQUEST, e);
              return null;
            }

            GithubCreatePullRequestWorker worker =
                new GithubCreatePullRequestWorker(
                    project,
                    git,
                    gitRepository,
                    authHolder,
                    path,
                    remoteName,
                    remoteUrl,
                    currentBranch.getName());

            try {
              worker.initForks(indicator);
            } catch (IOException e) {
              GithubNotifications.showError(project, CANNOT_CREATE_PULL_REQUEST, e);
              return null;
            }

            return worker;
          }
        });
  }