/**
  * Returns a RefModel for the refs/meta/gitblit/tickets branch in the repository. If the branch
  * can not be found, null is returned.
  *
  * @return a refmodel for the gitblit tickets branch or null
  */
 private RefModel getTicketsBranch(Repository db) {
   List<RefModel> refs = JGitUtils.getRefs(db, "refs/");
   Ref oldRef = null;
   for (RefModel ref : refs) {
     if (ref.reference.getName().equals(BRANCH)) {
       return ref;
     } else if (ref.reference.getName().equals("refs/gitblit/tickets")) {
       oldRef = ref.reference;
     }
   }
   if (oldRef != null) {
     // rename old ref to refs/meta/gitblit/tickets
     RefRename cmd;
     try {
       cmd = db.renameRef(oldRef.getName(), BRANCH);
       cmd.setRefLogIdent(new PersonIdent("Gitblit", "gitblit@localhost"));
       cmd.setRefLogMessage("renamed " + oldRef.getName() + " => " + BRANCH);
       Result res = cmd.rename();
       switch (res) {
         case RENAMED:
           log.info(db.getDirectory() + " " + cmd.getRefLogMessage());
           return getTicketsBranch(db);
         default:
           log.error(
               "failed to rename " + oldRef.getName() + " => " + BRANCH + " (" + res.name() + ")");
       }
     } catch (IOException e) {
       log.error("failed to rename tickets branch", e);
     }
   }
   return null;
 }
예제 #2
0
  @Test
  public void logAllCommits() throws Exception {
    List<RevCommit> commits = new ArrayList<RevCommit>();
    Git git = Git.wrap(db);

    writeTrashFile("Test.txt", "Hello world");
    git.add().addFilepattern("Test.txt").call();
    commits.add(git.commit().setMessage("initial commit").call());

    git.branchCreate().setName("branch1").call();
    Ref checkedOut = git.checkout().setName("branch1").call();
    assertEquals("refs/heads/branch1", checkedOut.getName());
    writeTrashFile("Test1.txt", "Hello world!");
    git.add().addFilepattern("Test1.txt").call();
    commits.add(git.commit().setMessage("branch1 commit").call());

    checkedOut = git.checkout().setName("master").call();
    assertEquals("refs/heads/master", checkedOut.getName());
    writeTrashFile("Test2.txt", "Hello world!!");
    git.add().addFilepattern("Test2.txt").call();
    commits.add(git.commit().setMessage("branch1 commit").call());

    Iterator<RevCommit> log = git.log().all().call().iterator();
    assertTrue(log.hasNext());
    assertTrue(commits.contains(log.next()));
    assertTrue(log.hasNext());
    assertTrue(commits.contains(log.next()));
    assertTrue(log.hasNext());
    assertTrue(commits.contains(log.next()));
    assertFalse(log.hasNext());
  }
  private void revalidate(RepositorySelection repoSelection, List<Ref> branches, Ref head) {
    if (repoSelection.equals(validatedRepoSelection)
        && branches.equals(validatedSelectedBranches)
        && head.equals(validatedHEAD)) {
      checkPage();
      return;
    }

    if (!repoSelection.equals(validatedRepoSelection)) {
      validatedRepoSelection = repoSelection;
      // update repo-related selection only if it changed
      final String n = validatedRepoSelection.getURI().getHumanishName();
      setDescription(NLS.bind(UIText.CloneDestinationPage_description, n));
      directoryText.setText(
          new File(ResourcesPlugin.getWorkspace().getRoot().getRawLocation().toFile(), n)
              .getAbsolutePath());
    }

    validatedSelectedBranches = branches;
    validatedHEAD = head;

    initialBranch.removeAll();
    final Ref actHead = head;
    int newix = 0;
    for (final Ref r : branches) {
      String name = r.getName();
      if (name.startsWith(Constants.R_HEADS)) name = name.substring((Constants.R_HEADS).length());
      if (actHead != null && actHead.getName().equals(r.getName()))
        newix = initialBranch.getItemCount();
      initialBranch.add(name);
    }
    initialBranch.select(newix);
    checkPage();
  }
예제 #4
0
  @Override
  public void create() {
    super.create();
    setTitle(UIText.BranchRenameDialog_Title);
    String oldName = branchToRename.getName();
    String prefix;
    if (oldName.startsWith(Constants.R_HEADS)) prefix = Constants.R_HEADS;
    else if (oldName.startsWith(Constants.R_REMOTES)) prefix = Constants.R_REMOTES;
    else prefix = null;
    String shortName = null;
    if (prefix != null) {
      shortName = Repository.shortenRefName(branchToRename.getName());
      setMessage(NLS.bind(UIText.BranchRenameDialog_Message, shortName));
    } else setErrorMessage(NLS.bind(UIText.BranchRenameDialog_WrongPrefixErrorMessage, oldName));

    if (shortName != null) {
      name.setText(shortName);
      name.setSelection(0, shortName.length());
    }

    final IInputValidator inputValidator =
        ValidationUtils.getRefNameInputValidator(repository, prefix, true);
    name.addModifyListener(
        new ModifyListener() {
          public void modifyText(ModifyEvent e) {
            String error = inputValidator.isValid(name.getText());
            setErrorMessage(error);
            getButton(OK).setEnabled(error == null);
          }
        });

    getButton(OK).setEnabled(false);
  }
예제 #5
0
  private Ref resolve(
      final Ref ref, int depth, String prefix, RefList<LooseRef> loose, RefList<Ref> packed)
      throws IOException {
    if (ref.isSymbolic()) {
      Ref dst = ref.getTarget();

      if (MAX_SYMBOLIC_REF_DEPTH <= depth) return null; // claim it doesn't exist

      // If the cached value can be assumed to be current due to a
      // recent scan of the loose directory, use it.
      if (loose != null && dst.getName().startsWith(prefix)) {
        int idx;
        if (0 <= (idx = loose.find(dst.getName()))) dst = loose.get(idx);
        else if (0 <= (idx = packed.find(dst.getName()))) dst = packed.get(idx);
        else return ref;
      } else {
        dst = readRef(dst.getName(), packed);
        if (dst == null) return ref;
      }

      dst = resolve(dst, depth + 1, prefix, loose, packed);
      if (dst == null) return null;
      return new SymbolicRef(ref.getName(), dst);
    }
    return ref;
  }
예제 #6
0
 private ObjectIdRef doPeel(final Ref leaf) throws MissingObjectException, IOException {
   try (RevWalk rw = new RevWalk(getRepository())) {
     RevObject obj = rw.parseAny(leaf.getObjectId());
     if (obj instanceof RevTag) {
       return new ObjectIdRef.PeeledTag(
           leaf.getStorage(), leaf.getName(), leaf.getObjectId(), rw.peel(obj).copy());
     } else {
       return new ObjectIdRef.PeeledNonTag(leaf.getStorage(), leaf.getName(), leaf.getObjectId());
     }
   }
 }
예제 #7
0
 /**
  * Constructs this page.
  *
  * <p>If a base branch is provided, the drop down will be selected accordingly
  *
  * @param repo the repository
  * @param baseRef the branch or tag to base the new branch on, may be null
  */
 public CreateBranchPage(Repository repo, Ref baseRef) {
   super(CreateBranchPage.class.getName());
   this.myRepository = repo;
   if (baseRef != null) this.myBaseRef = baseRef.getName();
   else this.myBaseRef = null;
   this.myBaseCommit = null;
   this.myValidator =
       ValidationUtils.getRefNameInputValidator(myRepository, Constants.R_HEADS, false);
   if (baseRef != null) this.upstreamConfig = UpstreamConfig.getDefault(repo, baseRef.getName());
   else this.upstreamConfig = UpstreamConfig.NONE;
   setTitle(UIText.CreateBranchPage_Title);
   setMessage(UIText.CreateBranchPage_ChooseBranchAndNameMessage);
 }
예제 #8
0
  // build both the allBranches sorted arrayList and the branches map
  private void buildBranchesMap(int size) throws GitAPIException {

    if (branches != null) {
      System.err.println(
          "GitMIner ( "
              + name
              + " -- "
              + id
              + " ) ERROR : the map of the branches has already been built!");
      return;
    }
    branches = new LinkedHashMap<String, ArrayList<BranchRef>>(size, 1);
    allBranches = new ArrayList<BranchRef>();

    ArrayList<BranchRef> temp = null;
    BranchRef br;
    Ref r;
    ArrayList<Ref> all = (ArrayList<Ref>) git.branchList().setListMode(ListMode.REMOTE).call();
    Iterator<Ref> allBs = all.iterator();
    String bName = "";
    allBranches.ensureCapacity(all.size()); // int j = 0;
    while (allBs.hasNext()) {
        /**/
      // System.err.println("###### Iteration " + (++j));
      r = allBs.next();
      if (!(r.getName().split("/")[2]).equals(bName)) {
        bName = r.getName().split("/")[2]; // getName() format:
        // refs/remotes/<remote-name>/<branch-name>
        if (temp != null) temp.trimToSize();
        temp = new ArrayList<BranchRef>();
        branches.put(bName, temp);
      }
      br = new BranchRef(r);
      temp.add(br);
      allBranches.add(br);
    }
    allBranches.trimToSize();
    Collections.sort(allBranches);
    for (int i = 0; i < allBranches.size(); i++) {
      allBranches.get(i).index = i;
    }
    //  Entry<String, ArrayList<BranchRef>> e;
    //  Iterator<Entry<String, ArrayList<BranchRef>>> eit = branches.entrySet().iterator();
    //  while (eit.hasNext()) {
    //    e = eit.next();
    //    System.out.println("\t" + e.getKey() + ":\n");
    //    printAny(e.getValue(), System.out);
    //  }
    //  printArray(allBranches, System.out);
  }
예제 #9
0
  private Ref resolve(Ref ref, int depth, RefList<Ref> loose) throws IOException {
    if (!ref.isSymbolic()) return ref;

    Ref dst = ref.getTarget();

    if (MAX_SYMBOLIC_REF_DEPTH <= depth) return null; // claim it doesn't exist

    dst = loose.get(dst.getName());
    if (dst == null) return ref;

    dst = resolve(dst, depth + 1, loose);
    if (dst == null) return null;
    return new SymbolicRef(ref.getName(), dst);
  }
예제 #10
0
 /**
  * Make sure a ref is peeled and has the Storage PACKED. If the given ref has this attributes
  * simply return it. Otherwise create a new peeled {@link ObjectIdRef} where Storage is set to
  * PACKED.
  *
  * @param f
  * @return a ref for Storage PACKED having the same name, id, peeledId as f
  * @throws MissingObjectException
  * @throws IOException
  */
 private Ref peeledPackedRef(Ref f) throws MissingObjectException, IOException {
   if (f.getStorage().isPacked() && f.isPeeled()) {
     return f;
   }
   if (!f.isPeeled()) {
     f = peel(f);
   }
   ObjectId peeledObjectId = f.getPeeledObjectId();
   if (peeledObjectId != null) {
     return new ObjectIdRef.PeeledTag(PACKED, f.getName(), f.getObjectId(), peeledObjectId);
   } else {
     return new ObjectIdRef.PeeledNonTag(PACKED, f.getName(), f.getObjectId());
   }
 }
예제 #11
0
  @Test
  public void test() throws Exception {

    GitService git = lookup(GitService.class);

    File gitDir = git.getWorkingDir();
    String tag = "mock-1.0" + System.currentTimeMillis();

    VersionContext context = new VersionContext(0, tag, "test", "test", "test");

    git.setup(context);
    git.pull(context);

    git.clearWorkingDir(context);

    downloadAndExtractTo(tag, gitDir);

    ObjectId objId = git.commit(context);
    git.push(context);

    Collection<Ref> refs = git.lsRemote();
    boolean tagExist = false;
    boolean commitSuccess = false;
    if (refs != null) {
      for (Ref ref : refs) {
        if (ref.getName().equals(REFS_TAGS + tag)) {
          tagExist = true;
        }
        if (ref.getObjectId().getName().equals(objId.getName())) {
          commitSuccess = true;
        }
      }
    }
    Assert.assertTrue(tagExist);
    Assert.assertTrue(commitSuccess);

    git.removeTag(context);

    refs = git.lsRemote();
    tagExist = false;
    if (refs != null) {
      for (Ref ref : refs) {
        if (ref.getName().equals(REFS_TAGS + tag)) {
          tagExist = true;
        }
      }
    }
    Assert.assertFalse(tagExist);
  }
예제 #12
0
 private boolean isLocalBranch(Git git, String branch) throws GitAPIException {
   List<Ref> branches = git.branchList().call();
   for (Ref ref : branches) {
     if (Repository.shortenRefName(ref.getName()).equals(branch)) return true;
   }
   return false;
 }
예제 #13
0
  private Iterable<ChangeData> byCommitsOnBranchNotMergedFromDatabase(
      Repository repo, ReviewDb db, Branch.NameKey branch, List<String> hashes)
      throws OrmException, IOException {
    Set<Change.Id> changeIds = Sets.newHashSetWithExpectedSize(hashes.size());
    String lastPrefix = null;
    for (Ref ref : repo.getRefDatabase().getRefs(RefNames.REFS_CHANGES).values()) {
      String r = ref.getName();
      if ((lastPrefix != null && r.startsWith(lastPrefix))
          || !hashes.contains(ref.getObjectId().name())) {
        continue;
      }
      Change.Id id = Change.Id.fromRef(r);
      if (id == null) {
        continue;
      }
      if (changeIds.add(id)) {
        lastPrefix = r.substring(0, r.lastIndexOf('/'));
      }
    }

    List<ChangeData> cds = new ArrayList<>(hashes.size());
    for (Change c : db.changes().get(changeIds)) {
      if (c.getDest().equals(branch) && c.getStatus() != Change.Status.MERGED) {
        cds.add(changeDataFactory.create(db, c));
      }
    }
    return cds;
  }
예제 #14
0
 private static Ref recreate(final Ref old, final ObjectIdRef leaf) {
   if (old.isSymbolic()) {
     Ref dst = recreate(old.getTarget(), leaf);
     return new SymbolicRef(old.getName(), dst);
   }
   return leaf;
 }
예제 #15
0
  private Iterable<RevCommit> getCommitsFromTag(String treeName) {

    try {

      List<Ref> call = git.tagList().call();
      Iterable<RevCommit> logs = null;

      for (Ref ref : call) {

        if (ref.getName().equals(treeName)) {

          LogCommand log = git.log();
          Ref peeledRef = repository.peel(ref);

          if (peeledRef.getPeeledObjectId() != null) {
            log.add(peeledRef.getPeeledObjectId());
          } else {
            log.add(ref.getObjectId());
          }

          logs = log.call();
          return logs;
        }
      }

      return null;

    } catch (GitAPIException e) {
      throw new VisMinerAPIException(e.getMessage(), e);
    } catch (MissingObjectException e) {
      throw new VisMinerAPIException(e.getMessage(), e);
    } catch (IncorrectObjectTypeException e) {
      throw new VisMinerAPIException(e.getMessage(), e);
    }
  }
예제 #16
0
  private DhtRef doPeel(final Ref leaf) throws MissingObjectException, IOException {
    RevWalk rw = new RevWalk(getRepository());
    try {
      DhtReader ctx = (DhtReader) rw.getObjectReader();
      RevObject obj = rw.parseAny(leaf.getObjectId());
      RefData.Builder d = RefData.newBuilder(((DhtRef) leaf).getRefData());

      ChunkKey oKey = ctx.findChunk(leaf.getObjectId());
      if (oKey != null) d.getTargetBuilder().setChunkKey(oKey.asString());
      else d.getTargetBuilder().clearChunkKey();

      if (obj instanceof RevTag) {
        ObjectId pId = rw.peel(obj);
        d.getPeeledBuilder().setObjectName(pId.name());

        ChunkKey pKey = ctx.findChunk(pId);
        if (pKey != null) d.getPeeledBuilder().setChunkKey(pKey.asString());
        else d.getPeeledBuilder().clearChunkKey();
      } else {
        d.clearPeeled();
      }

      d.setIsPeeled(true);
      d.setSequence(d.getSequence() + 1);
      return new DhtObjectIdRef(leaf.getName(), d.build());
    } finally {
      rw.release();
    }
  }
예제 #17
0
  @Override
  public Map<String, Ref> getRefs(String prefix) throws IOException {
    final RefList<LooseRef> oldLoose = looseRefs.get();
    LooseScanner scan = new LooseScanner(oldLoose);
    scan.scan(prefix);
    final RefList<Ref> packed = getPackedRefs();

    RefList<LooseRef> loose;
    if (scan.newLoose != null) {
      scan.newLoose.sort();
      loose = scan.newLoose.toRefList();
      if (looseRefs.compareAndSet(oldLoose, loose)) modCnt.incrementAndGet();
    } else loose = oldLoose;
    fireRefsChanged();

    RefList.Builder<Ref> symbolic = scan.symbolic;
    for (int idx = 0; idx < symbolic.size(); ) {
      final Ref symbolicRef = symbolic.get(idx);
      final Ref resolvedRef = resolve(symbolicRef, 0, prefix, loose, packed);
      if (resolvedRef != null && resolvedRef.getObjectId() != null) {
        symbolic.set(idx, resolvedRef);
        idx++;
      } else {
        // A broken symbolic reference, we have to drop it from the
        // collections the client is about to receive. Should be a
        // rare occurrence so pay a copy penalty.
        symbolic.remove(idx);
        final int toRemove = loose.find(symbolicRef.getName());
        if (0 <= toRemove) loose = loose.remove(toRemove);
      }
    }
    symbolic.sort();

    return new RefMap(prefix, packed, upcast(loose), symbolic.toRefList());
  }
예제 #18
0
파일: Clone.java 프로젝트: alexkli/jgit
  private void doCheckout(final Ref branch) throws IOException {
    if (branch == null) throw die(CLIText.get().cannotChekoutNoHeadsAdvertisedByRemote);
    if (!Constants.HEAD.equals(branch.getName())) {
      RefUpdate u = db.updateRef(Constants.HEAD);
      u.disableRefLog();
      u.link(branch.getName());
    }

    final RevCommit commit = parseCommit(branch);
    final RefUpdate u = db.updateRef(Constants.HEAD);
    u.setNewObjectId(commit);
    u.forceUpdate();

    DirCache dc = db.lockDirCache();
    DirCacheCheckout co = new DirCacheCheckout(db, dc, commit.getTree());
    co.checkout();
  }
예제 #19
0
 @Override
 protected Result doDelete(Result desiredResult) throws IOException {
   if (getRefDatabase().compareAndRemove(dstRef)) {
     getRefDatabase().removed(dstRef.getName());
     return desiredResult;
   }
   return Result.LOCK_FAILURE;
 }
예제 #20
0
  boolean performClone() {
    final URIish uri = cloneSource.getSelection().getURI();
    setWindowTitle(NLS.bind(UIText.GitCloneWizard_jobName, uri.toString()));
    final boolean allSelected;
    final Collection<Ref> selectedBranches;
    if (validSource.isSourceRepoEmpty()) {
      // fetch all branches of empty repo
      allSelected = true;
      selectedBranches = Collections.emptyList();
    } else {
      allSelected = validSource.isAllSelected();
      selectedBranches = validSource.getSelectedBranches();
    }
    final File workdir = cloneDestination.getDestinationFile();
    final Ref ref = cloneDestination.getInitialBranch();
    final String remoteName = cloneDestination.getRemote();

    boolean created = workdir.exists();
    if (!created) created = workdir.mkdirs();

    if (!created || !workdir.isDirectory()) {
      final String errorMessage =
          NLS.bind(UIText.GitCloneWizard_errorCannotCreate, workdir.getPath());
      ErrorDialog.openError(
          getShell(),
          getWindowTitle(),
          UIText.GitCloneWizard_failed,
          new Status(IStatus.ERROR, Activator.getPluginId(), 0, errorMessage, null));
      // let's give user a chance to fix this minor problem
      return false;
    }

    int timeout =
        Activator.getDefault().getPreferenceStore().getInt(UIPreferences.REMOTE_CONNECTION_TIMEOUT);
    final CloneOperation op =
        new CloneOperation(
            uri,
            allSelected,
            selectedBranches,
            workdir,
            ref != null ? ref.getName() : null,
            remoteName,
            timeout);
    if (gerritConfiguration.configureGerrit()) doGerritConfiguration(remoteName, op);
    UserPasswordCredentials credentials = cloneSource.getCredentials();
    if (credentials != null)
      op.setCredentialsProvider(
          new UsernamePasswordCredentialsProvider(
              credentials.getUser(), credentials.getPassword()));

    alreadyClonedInto = workdir.getPath();

    cloneSource.saveUriInPrefs();
    if (!callerRunsCloneOperation) runAsJob(uri, op);
    else cloneOperation = op;
    return true;
  }
예제 #21
0
  @Override
  protected Result doUpdate(Result desiredResult) throws IOException {
    ObjectIdRef newRef;
    RevObject obj = rw.parseAny(getNewObjectId());
    if (obj instanceof RevTag) {
      newRef =
          new ObjectIdRef.PeeledTag(
              Storage.PACKED, dstRef.getName(), getNewObjectId(), rw.peel(obj).copy());
    } else {
      newRef = new ObjectIdRef.PeeledNonTag(Storage.PACKED, dstRef.getName(), getNewObjectId());
    }

    if (getRefDatabase().compareAndPut(dstRef, newRef)) {
      getRefDatabase().stored(newRef);
      return desiredResult;
    }
    return Result.LOCK_FAILURE;
  }
예제 #22
0
 private List<String> getTags() {
   RevCommit commit = getCommit().getRevCommit();
   Repository repository = getCommit().getRepository();
   List<String> tags = new ArrayList<String>();
   for (Ref tag : repository.getTags().values())
     if (commit.equals(repository.peel(tag).getPeeledObjectId()))
       tags.add(Repository.shortenRefName(tag.getName()));
   Collections.sort(tags);
   return tags;
 }
예제 #23
0
 @NotNull
 public RepositoryStateData getCurrentState(@NotNull GitVcsRoot gitRoot) throws VcsException {
   String refInRoot = gitRoot.getRef();
   String fullRef = GitUtils.expandRef(refInRoot);
   Map<String, String> branchRevisions = new HashMap<String, String>();
   for (Ref ref : getRemoteRefs(gitRoot.getOriginalRoot()).values()) {
     if (!ref.getName().startsWith("ref")) continue;
     if (!gitRoot.isReportTags() && isTag(ref) && !fullRef.equals(ref.getName())) continue;
     branchRevisions.put(ref.getName(), getRevision(ref));
   }
   if (branchRevisions.get(fullRef) == null && !gitRoot.isIgnoreMissingDefaultBranch()) {
     throw new VcsException(
         "Cannot find revision of the default branch '"
             + refInRoot
             + "' of vcs root "
             + LogUtil.describe(gitRoot));
   }
   return RepositoryStateData.createVersionState(fullRef, branchRevisions);
 }
예제 #24
0
  public static void main(String[] args) throws IOException, GitAPIException {
    Repository repository = CookbookHelper.openJGitCookbookRepository();

    List<Ref> refs = new Git(repository).branchList().call();
    for (Ref ref : refs) {
      System.out.println(
          "Branch: " + ref + " " + ref.getName() + " " + ref.getObjectId().getName());

      listReflog(repository, ref);
    }

    List<Ref> call = new Git(repository).tagList().call();
    for (Ref ref : call) {
      System.out.println("Tag: " + ref + " " + ref.getName() + " " + ref.getObjectId().getName());

      listReflog(repository, ref);
    }

    repository.close();
  }
예제 #25
0
 @Override
 protected Result doLink(String target) throws IOException {
   final SymbolicRef newRef =
       new SymbolicRef(dstRef.getName(), new ObjectIdRef.Unpeeled(Storage.NEW, target, null));
   if (getRefDatabase().compareAndPut(dstRef, newRef)) {
     getRefDatabase().stored(newRef);
     if (dstRef.getStorage() == Ref.Storage.NEW) return Result.NEW;
     return Result.FORCED;
   }
   return Result.LOCK_FAILURE;
 }
예제 #26
0
 /**
  * Obtain a modified copy of the cache with a ref stored.
  *
  * <p>This cache instance is not modified by this method.
  *
  * @param ref reference to add or replace.
  * @return a copy of this cache, with the reference added or replaced.
  */
 public RefCache put(Ref ref) {
   RefList<Ref> newIds = this.ids.put(ref);
   RefList<Ref> newSym = this.sym;
   if (ref.isSymbolic()) {
     newSym = newSym.put(ref);
   } else {
     int p = newSym.find(ref.getName());
     if (0 <= p) newSym = newSym.remove(p);
   }
   return new RefCache(newIds, newSym);
 }
예제 #27
0
파일: Clone.java 프로젝트: alexkli/jgit
 private static Ref guessHEAD(final FetchResult result) {
   final Ref idHEAD = result.getAdvertisedRef(Constants.HEAD);
   Ref head = null;
   for (final Ref r : result.getAdvertisedRefs()) {
     final String n = r.getName();
     if (!n.startsWith(Constants.R_HEADS)) continue;
     if (idHEAD == null || head != null) continue;
     if (r.getObjectId().equals(idHEAD.getObjectId())) head = r;
   }
   if (idHEAD != null && head == null) head = idHEAD;
   return head;
 }
예제 #28
0
 public static JSONArray getListEntries(
     TreeWalk treeWalk, Repository repo, Git git, Ref head, String filePath, String projectName)
     throws MissingObjectException, IncorrectObjectTypeException, CorruptObjectException,
         IOException {
   JSONArray contents = new JSONArray();
   do {
     if (treeWalk.isSubtree()) {
       String test = new String(treeWalk.getRawPath());
       if (test.length() /*treeWalk.getPathLength()*/ > filePath.length()) {
         listEntry(
             treeWalk.getNameString(),
             "dir",
             "0",
             treeWalk.getPathString(),
             projectName,
             head.getName(),
             git,
             contents);
       }
       if (test.length() /*treeWalk.getPathLength()*/ <= filePath.length()) {
         treeWalk.enterSubtree();
       }
     } else {
       ObjectId objId = treeWalk.getObjectId(0);
       ObjectLoader loader = repo.open(objId);
       long size = loader.getSize();
       listEntry(
           treeWalk.getNameString(),
           "file",
           Long.toString(size),
           treeWalk.getPathString(),
           projectName,
           head.getName(),
           git,
           contents);
     }
   } while (treeWalk.next());
   return contents;
 }
예제 #29
0
파일: GitUtils.java 프로젝트: snjeza/core
 public static Ref checkout(
     final Git git,
     final Ref localRef,
     final boolean createBranch,
     final SetupUpstreamMode mode,
     final boolean force)
     throws GitAPIException {
   CheckoutCommand checkout = git.checkout();
   checkout.setName(Repository.shortenRefName(localRef.getName()));
   checkout.setForce(force);
   checkout.setUpstreamMode(mode);
   return checkout.call();
 }
예제 #30
0
    private Ref readRef(final TreeMap<String, Ref> avail, final String rn)
        throws TransportException {
      final String s;
      String ref = ROOT_DIR + rn;
      try {
        final BufferedReader br = openReader(ref);
        try {
          s = br.readLine();
        } finally {
          br.close();
        }
      } catch (FileNotFoundException noRef) {
        return null;
      } catch (IOException err) {
        throw new TransportException(getURI(), "read " + ref, err);
      }

      if (s == null) throw new TransportException(getURI(), "Empty ref: " + rn);

      if (s.startsWith("ref: ")) {
        final String target = s.substring("ref: ".length());
        Ref r = avail.get(target);
        if (r == null) r = readRef(avail, target);
        if (r == null) return null;
        r = new Ref(r.getStorage(), rn, r.getObjectId(), r.getPeeledObjectId(), r.isPeeled());
        avail.put(r.getName(), r);
        return r;
      }

      if (ObjectId.isId(s)) {
        final Ref r = new Ref(loose(avail.get(rn)), rn, ObjectId.fromString(s));
        avail.put(r.getName(), r);
        return r;
      }

      throw new TransportException(getURI(), "Bad ref: " + rn + ": " + s);
    }