@Test
  public void testUpdateTrackingBranchIfSpecifiedInRemoteRefUpdate() throws Exception {
    // Commit on repository 2
    //		RevCommit commit = repository2.addAndCommit(project, new File(workdir2, "test.txt"), "Commit
    // in repository 2");
    System.out.println(repository2.getBranch());
    new Git(repository2).checkout().setName("refs/heads/test").call();
    System.out.println(repository2.getBranch());
    ArrayList<String> files = new ArrayList<String>();
    File file = new File(workdir2, "test.txt");
    FileUtils.createNewFile(file);
    repositoryUtil.appendFileContent(file, "create file of test.txt in repository 2");
    files.add(repositoryUtil.getRepoRelativePath(file.getAbsolutePath()));

    AddToIndexOperation trop = new AddToIndexOperation(files, repository2);
    trop.execute();

    CommitOperation cop =
        new CommitOperation(repository2, files, files, AUTHOR, COMMITTER, "Commit in repository 2");
    cop.execute();
    // We want to push from repository 2 to 1 (because repository 2 already
    // has tracking set up)
    //		URIish remote = repository1.getUri();
    URIish remote = new URIish("file:///" + repository1.getDirectory().toString());

    String trackingRef = "refs/remotes/origin/master";
    RemoteRefUpdate update =
        new RemoteRefUpdate(repository2, "HEAD", "refs/heads/master", false, trackingRef, null);
    PushOperationSpecification spec = new PushOperationSpecification();
    spec.addURIRefUpdates(remote, Arrays.asList(update));

    PushOperation push = new PushOperation(repository2, spec, false, 0);
    push.execute();

    PushOperationResult result = push.getOperationResult();
    PushResult pushResult = result.getPushResult(remote);
    TrackingRefUpdate trf = pushResult.getTrackingRefUpdate(trackingRef);
    System.out.println(trf.getLocalName());
    System.out.println(trf.getRemoteName());
    assertNotNull(
        "Expected result to have tracking ref update",
        pushResult.getTrackingRefUpdate(trackingRef));

    ObjectId trackingId = repository2.resolve(trackingRef);
    assertEquals("Expected tracking branch to be updated", cop.getCommit().getId(), trackingId);
    new Git(repository1).checkout().setName("refs/heads/master").call();
    File testFile = new File(workdir2, repositoryUtil.getRepoRelativePath(file.getAbsolutePath()));
    assertTrue(testFile.exists());
  }
  // 2. Get branch/commit hash for the source repo - the actual source code
  @Test
  public void existsIn() throws IOException {
    // final String repo = "binrepo-devex";
    //  final String repo = "search_raptor_binary";
    // String githubUrl = "https://github.scm.corp.ebay.com/api/v3";
    // String accessToken = "1cf7d9792235b8592eda18bd7dcc2de37f99b3bc";

    final String path = "D:\\dev\\devex\\binrepo-devex\\.git";

    File gitDir = new File(path);
    org.eclipse.jgit.lib.Repository repository =
        new org.eclipse.jgit.storage.file.FileRepository(gitDir);
    String branch = repository.getBranch();
    System.out.println(branch);

    RevWalk revWalk = new RevWalk(repository);
    // Pop the most recent commit off from RevWalk
    // RevCommit commit = revWalk.next(); returns null :-(
    // System.out.println(commit);

    ObjectId resolve = repository.resolve(Constants.HEAD);
    RevCommit commit = revWalk.parseCommit(resolve);
    String commitHash = commit.getName();
    System.out.println(commitHash + "\t" + commit.getFullMessage());

    // RefDatabase refDatabase = repository.getRefDatabase();

  }
 private String getBranch(final Repository repository) throws IOException {
   if (this.branch != null) {
     return this.branch;
   } else {
     return repository.getBranch();
   }
 }
 private static String getCurrentBranch(Repository repository) throws CoreException {
   String branch = null;
   try {
     branch = repository.getBranch();
   } catch (IOException e) {
     throw new CoreException(
         createStatus(
             e, "Could not get current branch on repository \"{0}\"", repository.toString()));
   }
   return branch;
 }
  /**
   * Push from repository1 "master" into "test" of repository2.
   *
   * @throws Exception
   */
  @Test
  public void testPush() throws Exception {
    // push from repository1 to repository2
    System.out.println(repository2.getBranch());
    PushOperation pop = createPushOperation();
    pop.execute();
    assertEquals(
        org.eclipse.jgit.transport.RemoteRefUpdate.Status.UP_TO_DATE,
        getStatus(pop.getOperationResult()));
    System.out.println(pop.toString());
    ArrayList<String> files = new ArrayList<String>();

    File file = new File(workdir, "file2.txt");
    FileUtils.createNewFile(file);
    repositoryUtil.appendFileContent(file, "new file");
    files.add(repositoryUtil.getRepoRelativePath(file.getAbsolutePath()));

    AddToIndexOperation trop = new AddToIndexOperation(files, repository1);
    trop.execute();

    CommitOperation cop =
        new CommitOperation(repository1, files, files, AUTHOR, COMMITTER, "added files");
    cop.execute();

    pop = createPushOperation();
    pop.execute();
    assertEquals(
        org.eclipse.jgit.transport.RemoteRefUpdate.Status.OK, getStatus(pop.getOperationResult()));
    System.out.println(pop.toString());
    try {
      // assert that we cannot run this again
      pop.execute();
      fail("Expected Exception not thrown");
    } catch (IllegalStateException e) {
      // expected
    }

    pop = createPushOperation();
    pop.execute();
    assertEquals(
        org.eclipse.jgit.transport.RemoteRefUpdate.Status.UP_TO_DATE,
        getStatus(pop.getOperationResult()));
    System.out.println(pop.toString());
    File testFile = new File(workdir2, repositoryUtil.getRepoRelativePath(file.getAbsolutePath()));
    assertFalse(testFile.exists());
    testFile = new File(workdir, repositoryUtil.getRepoRelativePath(file.getAbsolutePath()));
    assertTrue(testFile.exists());

    // check out test and verify the file is there
    new Git(repository2).checkout().setName("refs/heads/test").call();
    testFile = new File(workdir2, repositoryUtil.getRepoRelativePath(file.getAbsolutePath()));
    assertTrue(testFile.exists());
  }
Beispiel #6
0
  protected void doPull() throws MojoExecutionException {
    // CredentialsProvider cp = getCredentials();
    CredentialsProvider cp = null;
    try {
      Repository repository = git.getRepository();
      StoredConfig config = repository.getConfig();
      String url = config.getString("remote", "origin", "url");
      if (Strings.isNullOrBlank(url)) {
        getLog()
            .info(
                "No remote repository defined for the git repository at "
                    + getGitBuildPathDescription()
                    + " so not doing a pull");
        return;
      }
      String branch = repository.getBranch();
      String mergeUrl = config.getString("branch", branch, "merge");
      if (Strings.isNullOrBlank(mergeUrl)) {
        getLog()
            .info(
                "No merge spec for branch."
                    + branch
                    + ".merge in the git repository at "
                    + getGitBuildPathDescription()
                    + " so not doing a pull");
        return;
      }
      getLog()
          .info(
              "Performing a pull in git repository "
                  + getGitBuildPathDescription()
                  + " on remote URL: "
                  + url);

      git.pull().setCredentialsProvider(cp).setRebase(true).call();
    } catch (Throwable e) {
      String credText = "";
      if (cp instanceof UsernamePasswordCredentialsProvider) {}
      String message =
          "Failed to pull from the remote git repo with credentials "
              + cp
              + " due: "
              + e.getMessage()
              + ". This exception is ignored.";
      getLog().error(message, e);
      throw new MojoExecutionException(message, e);
    }
  }
Beispiel #7
0
  private List<String> branchesToBeDelete(List<String> branchesList) {
    List<String> result = new ArrayList<>();
    Repository repo = null;
    Map<String, List<String>> branchesMap = new HashMap<>();
    for (String branch : branchesList) {
      List<String> values = null;
      if (!branchesMap.containsKey(branch.subSequence(0, 10))) {
        values = new ArrayList<>();
        values.add(branch);
        branchesMap.put(branch.subSequence(0, 10).toString(), values);
      } else if (!branchesMap.get(branch.subSequence(0, 10)).contains(branch)) {
        values = branchesMap.get(branch.subSequence(0, 10));
        values.add(branch);
        branchesMap.put(branch.subSequence(0, 10).toString(), values);
      }
    }
    List<CommitItem> allBranches = CollectorApi.getCommitItemContainer().getAll();
    for (CommitItem branch : allBranches) {
      if (branchesMap.containsKey(branch.getBranchDescriptor().getNewBranch().subSequence(0, 10))) {
        branchesMap.remove(branch.getBranchDescriptor().getNewBranch().subSequence(0, 10));
      }
    }
    for (String key : branchesMap.keySet()) {
      result.addAll(branchesMap.get(key));
    }

    try {
      repo =
          new FileRepository(VerigreenNeededLogic.properties.getProperty("git.repositoryLocation"));
      if (result.contains(repo.getBranch())) {
        _jgit.checkout(VerigreenNeededLogic.VerigreenMap.get("_protectedBranches"), false, false);
      }
    } catch (IOException e) {
      VerigreenLogger.get()
          .error(
              getClass().getName(),
              RuntimeUtils.getCurrentMethodName(),
              String.format(
                  "Failed creating git repository for path [%s]",
                  VerigreenNeededLogic.properties.getProperty("git.repositoryLocation")),
              e);
    }

    return result;
  }
  // 2. Get branch/commit hash for the source repo - the actual source code
  @Test
  public void existsIn2() throws IOException {
    final String repo = "binrepo-devex";
    //  final String repo = "search_raptor_binary";
    // String githubUrl = "https://github.scm.corp.ebay.com/api/v3";
    // String accessToken = "1cf7d9792235b8592eda18bd7dcc2de37f99b3bc";

    final String path = "D:\\dev\\devex\\.binrepo-devex\\.git";

    File gitDir = new File(path);
    org.eclipse.jgit.lib.Repository repository =
        new org.eclipse.jgit.storage.file.FileRepository(gitDir);
    String branch = repository.getBranch();
    System.out.println("Branch=" + branch);
    final Map<String, Ref> allRefs = repository.getAllRefs();
    for (String s : allRefs.keySet()) {
      System.out.println("Here" + s);
    }

    RevWalk revWalk = new RevWalk(repository);
    ObjectId resolve = repository.resolve(Constants.HEAD);
    RevCommit commitRev = revWalk.parseCommit(resolve);
    String commitHash = commitRev.getName();
    System.out.println(commitHash + "\t" + commitRev.getFullMessage());

    Git binaryRepo = Git.open(gitDir);

    final ListBranchCommand listBranchCommand = binaryRepo.branchList();
    System.out.println(listBranchCommand.getRepository().getFullBranch());
    // get "status"
    final StatusCommand statusCommand = binaryRepo.status();
    Collection<String> toadd = GitUtils.getFilesToStage(statusCommand);
    for (String s : toadd) {
      System.out.println("To be added:" + s);
    }

    // add files to "staging"
    if (toadd.size() > 0) {
      AddCommand addCmd = binaryRepo.add();
      for (String file : toadd) {
        addCmd.addFilepattern(file);
      }

      try {
        addCmd.call();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }

    final StoredConfig config = repository.getConfig();
    String url = config.getString("remote", "origin", "url");
    if (url != null) {
      System.out.println("Origin comes from " + url);
    }

    // commit
    final CommitCommand commit = binaryRepo.commit();
    String msg = "Saving Repo:%s Branch:%s CommitHash:%s Time:%s";
    final String formattedMsg = String.format(msg, repo, branch, commitHash, new Date().toString());
    commit.setMessage(formattedMsg);
    try {
      commit.call();
    } catch (Exception e) {
      e.printStackTrace();
    }

    // push to origin now
    final PushCommand push = binaryRepo.push();
    final String remote = push.getRemote();
    System.out.println("Remote to push to:'" + remote + "'");
    try {
      push.call();
    } catch (Exception e) {
      e
          .printStackTrace(); // To change body of catch statement use File | Settings | File
                              // Templates.
    }
  }
  public String getProjectVersion(File repoDir) throws IOException, GitAPIException {
    Git git = Git.open(repoDir);
    Repository repo = git.getRepository();

    // Find base commit between current branch and "master":
    String branch = repo.getBranch();
    RevCommit base = CommitUtils.getBase(repo, "master", branch);
    CommitCountFilter count = new CommitCountFilter();
    CommitFinder finder = new CommitFinder(repo).setFilter(count);
    finder.findBetween(branch, base);
    long commitsSinceBase = count.getCount();

    // Find tags in "master" before base commit:
    RevWalk rw = new RevWalk(repo);
    rw.markStart(base);
    rw.setRetainBody(false);
    Ref master = repo.getRef("master");
    List<Ref> masterAsList = Arrays.asList(master);
    List<Ref> tags = git.tagList().call();
    Map<RevCommit, Ref> masterTags = new HashMap<RevCommit, Ref>();
    for (Ref tag : tags) {
      tag = repo.peel(tag);
      ObjectId commitID = tag.getPeeledObjectId();
      if (commitID == null) continue;
      RevCommit commit = rw.parseCommit(commitID);
      // Only remember tags reachable from "master":
      if (!RevWalkUtils.findBranchesReachableFrom(commit, rw, masterAsList).isEmpty()) {
        masterTags.put(commit, tag);
      }
    }

    // Find the shortest distance in commits between base tag in "master":
    long commitsBetweenBaseAndTag = Long.MAX_VALUE;
    String tagName = "";
    for (RevCommit tagCommit : masterTags.keySet()) {
      count.reset();
      finder.findBetween(base, tagCommit);
      if (count.getCount() < commitsBetweenBaseAndTag) {
        commitsBetweenBaseAndTag = count.getCount();
        tagName = masterTags.get(tagCommit).getName();
      }
    }
    if (commitsBetweenBaseAndTag == Long.MAX_VALUE) {
      // If no tag, get total number of commits:
      commitsBetweenBaseAndTag = repo.getRefDatabase().getRefs("").size();
    }
    long commitsSinceLastMasterTag = commitsSinceBase + commitsBetweenBaseAndTag;

    // Construct version string:
    String version = branch.equals("master") ? "" : (branch + "-");
    if (tagName.startsWith("refs/tags/")) {
      tagName = tagName.substring("refs/tags/".length());
    }
    // v1.1 -> 1.1
    if (tagName.matches("v\\d+.*")) {
      tagName = tagName.substring(1);
    }
    if (tagName.isEmpty()) {
      version = "0";
    }
    version += tagName + ((!tagonly) ? "." + commitsSinceLastMasterTag : "");

    return version;
  }
  public void updateBinaryRepository() throws IOException, GitException, MapServiceException {

    // 1. Check if repository exists remotely [email protected]/Binary/Repo_Binary.git
    // find the name of the "source repository"
    final String repoUrl = getSourceRemoteUrl();

    // find where ".git" folder is found
    // SourceRepository = D:\dev\devex\binrepo-devex
    // BinaryRepository = D:\dev\devex\.binrepo-devex
    final File srcRepoDir = sourceRepository.getDirectory();
    final File sourceDir = srcRepoDir.getParentFile();

    final String sourceRepoFolder = srcRepoDir.getParentFile().getCanonicalPath();

    final File parent = srcRepoDir.getParentFile().getParentFile();
    final File binaryRepoDir = new File(parent, "." + srcRepoDir.getParentFile().getName());
    System.out.println(
        "SourceRepository = "
            + sourceRepoFolder
            + "\nBinaryRepository = "
            + binaryRepoDir.getCanonicalPath());

    // 2. Get branch/commit hash for the source repo - the actual source code
    final org.eclipse.jgit.lib.Repository repository =
        new org.eclipse.jgit.storage.file.FileRepository(srcRepoDir);
    final String branch = repository.getBranch();

    final RevWalk revWalk = new RevWalk(repository);
    final ObjectId resolve = repository.resolve(Constants.HEAD);
    final RevCommit commit = revWalk.parseCommit(resolve);
    String commitHash = commit.getName();
    System.out.println("CommitHash:" + commitHash + "\tMessage:" + commit.getFullMessage());

    // 3. Call the BinRepo service and check if a corresponding BinRepo entry exists
    final String url =
        getUrlForFindByRepoBranchCommit()
            + "repourl="
            + URLEncoder.encode(repoUrl, UTF_8)
            + "&branch="
            + URLEncoder.encode(branch, UTF_8)
            + "&commitid="
            + URLEncoder.encode(commitHash, UTF_8);
    System.out.println("svc url : " + url);

    WebResource webResource = client.resource(url);

    boolean noContent = false;
    BinRepoBranchCommitDO binRepoBranchCommitDO1 = null;

    try {
      binRepoBranchCommitDO1 =
          webResource.accept(MediaType.APPLICATION_JSON).get(BinRepoBranchCommitDO.class);
    } catch (UniformInterfaceException e) {
      int statusCode = e.getResponse().getClientResponseStatus().getStatusCode();
      System.out.println("Service Status Code : " + statusCode);
      noContent =
          (statusCode == 204 || statusCode == 404); // HTTP 204 is NO CONTENT which is ok for us
    } catch (Exception e) { // Catch-all to deal with network problems etc.
      e.printStackTrace();
    }

    System.out.println(
        binRepoBranchCommitDO1 != null
            ? binRepoBranchCommitDO1.toString()
            : "Resource not found on server");

    // 4. If not copy all the target folders from the source repo to the binary repo - root to root
    // copy of artifacts
    if (noContent) {
      System.out.println(
          "Source Directory:'"
              + sourceDir.getCanonicalPath()
              + "' Destination Directory:'"
              + binaryRepoDir.getCanonicalPath()
              + "'");
      FileUtil.copyBinaries(sourceDir, binaryRepoDir);
    }

    // 5. Call git status to get the delta (Use StatusCommand and refine it)
    Git binaryRepo;
    try {
      binaryRepo = Git.open(binaryRepoDir);
    } catch (IOException e) {
      throw new GitException("Unable to open repository" + binaryRepoDir, e);
    }

    // get "status"
    final StatusCommand statusCommand = binaryRepo.status();
    // TODO: RGIROTI Ask Nambi if we should actually filter this to only add .class files and
    // nothing else
    Collection<String> filesToStage = GitUtils.getFilesToStage(statusCommand);
    /*for (String file : filesToStage) {
        System.out.println("File to be added:" + file);
    }*/

    // add files to "staging" - if there is nothing to stage none of the other operations make any
    // sense at all
    if (filesToStage.size() > 0) {
      final AddCommand addCmd = binaryRepo.add();
      for (String file : filesToStage) {
        addCmd.addFilepattern(file);
      }
      final String[] filesArr = filesToStage.toArray(new String[filesToStage.size()]);
      final String files = StringUtils.join(filesArr, ",");
      try {
        addCmd.call();
      } catch (Exception e) {
        throw new GitException("Unable to add files to repository" + files, e);
      }

      // 6. Commit the changes to local and call push after that (use JGit API for this)
      // 6a. COmmit message should use format "Saving url:branch:commit:UTC time"
      // commit
      final CommitCommand commitCommand = binaryRepo.commit();
      String msg = "Saving Repo:%s Branch:%s CommitHash:%s Time:%s";
      final String formattedMsg =
          String.format(msg, repoUrl, branch, commitHash, new Date().toString());
      commitCommand.setMessage(formattedMsg);
      String commitHashBinRepo;
      try {
        final RevCommit call = commitCommand.call();
        commitHashBinRepo = call.getName();
      } catch (Exception e) {
        throw new GitException("Unable to read commit hash from commit command", e);
      }

      // push to origin now
      final PushCommand push = binaryRepo.push();
      final String remote = push.getRemote();
      final String remoteBranch = push.getRepository().getBranch();
      System.out.println("Remote to push to:'" + remote + "'");
      try {
        push.call();
      } catch (Exception e) {
        throw new GitException("Unable to push to remote", e);
      }

      // Calculate the remote url for binary repository
      String binRepoUrl = calculateBinaryRepositoryUrl();

      // 7. Call the BinRepo service and create a new entity for this change - repoUrl, branch, and
      // commit
      System.out.println(
          "Update Bin Repo Service with the new changes - POST new object to service");
      final BinRepoBranchCommitDO binRepoBranchCommitDO =
          newInstance(repoUrl, branch, commitHash, binRepoUrl, remoteBranch, commitHashBinRepo);
      webResource = client.resource(getUrlForPost());

      BinRepoBranchCommitDO postedDO = null;
      try {
        postedDO =
            webResource
                .accept(MediaType.APPLICATION_XML)
                .post(BinRepoBranchCommitDO.class, binRepoBranchCommitDO);
      } catch (UniformInterfaceException e) {
        int statusCode = e.getResponse().getClientResponseStatus().getStatusCode();
        System.out.println("status code: " + statusCode);
        throw new MapServiceException("Unable to register the commit details in update binrepo", e);
      }
      System.out.println(postedDO != null ? postedDO.toString() : "Post failed");
    }
  }
  private void testPushToOrigin(boolean useRemote) throws Exception {
    Activator.getDefault().getRepositoryUtil().addConfiguredRepository(clonedRepositoryFile);
    shareProjects(clonedRepositoryFile);

    Repository repository = lookupRepository(clonedRepositoryFile);
    // add the configuration for push
    repository
        .getConfig()
        .setString("remote", "origin", "push", "refs/heads/*:refs/remotes/origin/*");
    repository.getConfig().save();

    // make sure to have a "new" branch name so that the
    // dialog will return with a corresponding message
    String currentBranch = repository.getBranch();
    new Git(repository)
        .branchRename()
        .setOldName(currentBranch)
        .setNewName("" + System.currentTimeMillis())
        .call();

    SWTBotTree tree = getOrOpenView().bot().tree();
    tree.select(0);

    TestUtil.waitForJobs(50, 5000);
    selectNode(tree, useRemote, false);

    runPush(tree);

    String destinationString = clonedRepositoryFile.getParentFile().getName() + " - " + "origin";
    String dialogTitle = NLS.bind(UIText.PushResultDialog_title, destinationString);

    // first time: expect new branch
    SWTBotShell confirmed = bot.shell(dialogTitle);
    SWTBotTreeItem[] treeItems = confirmed.bot().tree().getAllItems();
    boolean newBranch = false;
    for (SWTBotTreeItem item : treeItems) {
      newBranch = item.getText().contains(UIText.PushResultTable_statusOkNewBranch);
      if (newBranch) break;
    }
    confirmed.close();
    assertTrue("New branch expected", newBranch);
    // second time: expect up to date
    selectNode(tree, useRemote, false);

    runPush(tree);

    confirmed = bot.shell(dialogTitle);
    treeItems = confirmed.bot().tree().getAllItems();
    boolean uptodate = false;
    for (SWTBotTreeItem item : treeItems) {
      uptodate = item.getText().contains(UIText.PushResultTable_statusUpToDate);
      if (uptodate) break;
    }
    confirmed.close();
    assertTrue("Up to date expected", uptodate);
    // touch and run again: expect new branch
    String objectIdBefore =
        repository.getRef(repository.getFullBranch()).getLeaf().getObjectId().name();
    objectIdBefore = objectIdBefore.substring(0, 7);
    touchAndSubmit(null);

    SWTBotTree updatedTree = getOrOpenView().bot().tree();
    updatedTree.select(0);
    selectNode(updatedTree, useRemote, false);

    runPush(updatedTree);

    confirmed = bot.shell(dialogTitle);
    treeItems = confirmed.bot().tree().getAllItems();
    newBranch = false;
    for (SWTBotTreeItem item : treeItems) {
      newBranch = item.getText().contains(objectIdBefore);
      if (newBranch) break;
    }
    confirmed.close();
    assertTrue("New branch expected", newBranch);
  }
  public StyledString getStyledText(Object element) {
    if (!(element instanceof RepositoryTreeNode)) return null;

    RepositoryTreeNode node = (RepositoryTreeNode) element;

    try {
      switch (node.getType()) {
        case REPO:
          Repository repository = (Repository) node.getObject();
          File directory = repository.getDirectory();
          StyledString string = new StyledString(directory.getParentFile().getName());
          string.append(
              " - " + directory.getAbsolutePath(), StyledString.QUALIFIER_STYLER); // $NON-NLS-1$
          String branch = repository.getBranch();
          if (repository.getRepositoryState() != RepositoryState.SAFE)
            branch += " - " + repository.getRepositoryState().getDescription(); // $NON-NLS-1$
          string.append(
              " [" + branch + "]", StyledString.DECORATIONS_STYLER); // $NON-NLS-1$//$NON-NLS-2$
          return string;
        case ADDITIONALREF:
          Ref ref = (Ref) node.getObject();
          // shorten the name
          StyledString refName = new StyledString(Repository.shortenRefName(ref.getName()));
          if (ref.isSymbolic()) {
            refName.append(" - ", StyledString.QUALIFIER_STYLER); // $NON-NLS-1$
            refName.append(ref.getLeaf().getName(), StyledString.QUALIFIER_STYLER);
            refName.append(" - ", StyledString.QUALIFIER_STYLER); // $NON-NLS-1$
            refName.append(
                ObjectId.toString(ref.getLeaf().getObjectId()), StyledString.QUALIFIER_STYLER);
          } else {
            refName.append(" - ", StyledString.QUALIFIER_STYLER); // $NON-NLS-1$
            refName.append(ObjectId.toString(ref.getObjectId()), StyledString.QUALIFIER_STYLER);
          }
          return refName;
        case WORKINGDIR:
          StyledString dirString = new StyledString(UIText.RepositoriesView_WorkingDir_treenode);
          dirString.append(" - ", StyledString.QUALIFIER_STYLER); // $NON-NLS-1$
          if (node.getRepository().isBare()) {
            dirString.append(
                UIText.RepositoriesViewLabelProvider_BareRepositoryMessage,
                StyledString.QUALIFIER_STYLER);
          } else {
            dirString.append(
                node.getRepository().getWorkTree().getAbsolutePath(),
                StyledString.QUALIFIER_STYLER);
          }
          return dirString;
        case PUSH:
          // fall through
        case FETCH:
          // fall through
        case FILE:
          // fall through
        case FOLDER:
          // fall through
        case BRANCHES:
          // fall through
        case LOCAL:
          // fall through
        case REMOTETRACKING:
          // fall through
        case BRANCHHIERARCHY:
          // fall through
        case TAGS:
          // fall through;
        case ADDITIONALREFS:
          // fall through
        case REMOTES:
          // fall through
        case REMOTE:
          // fall through
        case ERROR:
          // fall through
        case REF:
          // fall through
        case TAG:
          {
            String label = getSimpleText(node);
            if (label != null) return new StyledString(label);
          }
      }
    } catch (IOException e) {
      Activator.logError(e.getMessage(), e);
    }

    return null;
  }