Example usage for org.eclipse.jgit.lib Constants R

Introduction

In this page you can find the example usage for org.eclipse.jgit.lib Constants R_HEADS.

Prototype

String R_HEADS

To view the source code for org.eclipse.jgit.lib Constants R_HEADS.

Click Source Link

Document

Prefix for branch refs

Usage

From source file:com.gitblit.utils.JGitUtils.java

License:Apache License

/**
 * Sets the symbolic ref HEAD to the specified target ref. The
 * HEAD will be detached if the target ref is not a branch.
 *
 * @param repository/* www.  ja v  a 2  s.c o  m*/
 * @param targetRef
 * @return true if successful
 */
public static boolean setHEADtoRef(Repository repository, String targetRef) {
    try {
        // detach HEAD if target ref is not a branch
        boolean detach = !targetRef.startsWith(Constants.R_HEADS);
        RefUpdate.Result result;
        RefUpdate head = repository.updateRef(Constants.HEAD, detach);
        if (detach) { // Tag
            RevCommit commit = getCommit(repository, targetRef);
            head.setNewObjectId(commit.getId());
            result = head.forceUpdate();
        } else {
            result = head.link(targetRef);
        }
        switch (result) {
        case NEW:
        case FORCED:
        case NO_CHANGE:
        case FAST_FORWARD:
            return true;
        default:
            LOGGER.error(MessageFormat.format("{0} HEAD update to {1} returned result {2}",
                    repository.getDirectory().getAbsolutePath(), targetRef, result));
        }
    } catch (Throwable t) {
        error(t, repository, "{0} failed to set HEAD to {1}", targetRef);
    }
    return false;
}

From source file:com.gitblit.utils.JGitUtils.java

License:Apache License

/**
 * Sets the local branch ref to point to the specified commit id.
 *
 * @param repository/*from   w w w . java 2s.  c  o  m*/
 * @param branch
 * @param commitId
 * @return true if successful
 */
public static boolean setBranchRef(Repository repository, String branch, String commitId) {
    String branchName = branch;
    if (!branchName.startsWith(Constants.R_REFS)) {
        branchName = Constants.R_HEADS + branch;
    }

    try {
        RefUpdate refUpdate = repository.updateRef(branchName, false);
        refUpdate.setNewObjectId(ObjectId.fromString(commitId));
        RefUpdate.Result result = refUpdate.forceUpdate();

        switch (result) {
        case NEW:
        case FORCED:
        case NO_CHANGE:
        case FAST_FORWARD:
            return true;
        default:
            LOGGER.error(MessageFormat.format("{0} {1} update to {2} returned result {3}",
                    repository.getDirectory().getAbsolutePath(), branchName, commitId, result));
        }
    } catch (Throwable t) {
        error(t, repository, "{0} failed to set {1} to {2}", branchName, commitId);
    }
    return false;
}

From source file:com.gitblit.utils.JGitUtils.java

License:Apache License

/**
 * Returns the list of local branches in the repository. If repository does
 * not exist or is empty, an empty list is returned.
 *
 * @param repository//from  w ww  . jav a 2  s  . co m
 * @param fullName
 *            if true, /refs/heads/yadayadayada is returned. If false,
 *            yadayadayada is returned.
 * @param maxCount
 *            if < 0, all local branches are returned
 * @return list of local branches
 */
public static List<RefModel> getLocalBranches(Repository repository, boolean fullName, int maxCount) {
    return getRefs(repository, Constants.R_HEADS, fullName, maxCount);
}

From source file:com.gitblit.utils.JGitUtils.java

License:Apache License

/**
 * Tries to merge a commit into a branch.  If there are conflicts, the merge
 * will fail./* w w w .ja  v  a  2 s  . co m*/
 *
 * @param repository
 * @param src
 * @param toBranch
 * @param mergeType
 *            Defines the integration strategy to use for merging.
 * @param committer
 * @param message
 * @return the merge result
 */
public static MergeResult merge(Repository repository, String src, String toBranch, MergeType mergeType,
        PersonIdent committer, String message) {

    if (!toBranch.startsWith(Constants.R_REFS)) {
        // branch ref doesn't start with ref, assume this is a branch head
        toBranch = Constants.R_HEADS + toBranch;
    }

    IntegrationStrategy strategy = IntegrationStrategyFactory.create(mergeType, repository, src, toBranch);
    MergeResult mergeResult = strategy.merge(committer, message);

    if (mergeResult.status != MergeStatus.MERGED) {
        return mergeResult;
    }

    try {
        // Update the integration branch ref
        RefUpdate mergeRefUpdate = repository.updateRef(toBranch);
        mergeRefUpdate.setNewObjectId(strategy.getMergeCommit());
        mergeRefUpdate.setRefLogMessage(strategy.getRefLogMessage(), false);
        mergeRefUpdate.setExpectedOldObjectId(strategy.branchTip);
        RefUpdate.Result rc = mergeRefUpdate.update();
        switch (rc) {
        case FAST_FORWARD:
            // successful, clean merge
            break;
        default:
            mergeResult = new MergeResult(MergeStatus.FAILED, null);
            throw new GitBlitException(MessageFormat.format("Unexpected result \"{0}\" when {1} in {2}",
                    rc.name(), strategy.getOperationMessage(), repository.getDirectory()));
        }
    } catch (IOException e) {
        LOGGER.error("Failed to merge", e);
    }

    return mergeResult;
}

From source file:com.gitblit.wicket.pages.LuceneSearchPage.java

License:Apache License

private void setup(PageParameters params) {
    setupPage("", "");

    // default values
    ArrayList<String> repositories = new ArrayList<String>();
    String query = "";
    boolean allRepos = false;

    int page = 1;
    int pageSize = app().settings().getInteger(Keys.web.itemsPerPage, 50);

    // display user-accessible selections
    UserModel user = GitBlitWebSession.get().getUser();
    List<String> availableRepositories = new ArrayList<String>();
    for (RepositoryModel model : app().repositories().getRepositoryModels(user)) {
        if (model.hasCommits && !ArrayUtils.isEmpty(model.indexedBranches)) {
            availableRepositories.add(model.name);
        }/*ww w  . ja v  a  2  s.  c  o m*/
    }

    if (params != null) {
        String repository = WicketUtils.getRepositoryName(params);
        if (!StringUtils.isEmpty(repository)) {
            repositories.add(repository);
        }

        page = WicketUtils.getPage(params);

        if (!params.get("repositories").isEmpty()) {
            String value = params.get("repositories").toString("");
            List<String> list = StringUtils.getStringsFromValue(value);
            repositories.addAll(list);
        }

        allRepos = params.get("allrepos").toBoolean(false);
        if (allRepos) {
            repositories.addAll(availableRepositories);
        }

        if (!params.get("query").isEmpty()) {
            query = params.get("query").toString("");
        } else {
            String value = WicketUtils.getSearchString(params);
            String type = WicketUtils.getSearchType(params);
            com.gitblit.Constants.SearchType searchType = com.gitblit.Constants.SearchType.forName(type);
            if (!StringUtils.isEmpty(value)) {
                if (searchType == SearchType.COMMIT) {
                    query = "type:" + searchType.name().toLowerCase() + " AND \"" + value + "\"";
                } else {
                    query = searchType.name().toLowerCase() + ":\"" + value + "\"";
                }
            }
        }
    }

    boolean luceneEnabled = app().settings().getBoolean(Keys.web.allowLuceneIndexing, true);
    if (luceneEnabled) {
        if (availableRepositories.size() == 0) {
            info(getString("gb.noIndexedRepositoriesWarning"));
        }
    } else {
        error(getString("gb.luceneDisabled"));
    }

    // enforce user-accessible repository selections
    Set<String> uniqueRepositories = new LinkedHashSet<String>();
    for (String selectedRepository : repositories) {
        if (availableRepositories.contains(selectedRepository)) {
            uniqueRepositories.add(selectedRepository);
        }
    }
    ArrayList<String> searchRepositories = new ArrayList<String>(uniqueRepositories);

    // search form
    final Model<String> queryModel = new Model<String>(query);
    final Model<ArrayList<String>> repositoriesModel = new Model<ArrayList<String>>(searchRepositories);
    final Model<Boolean> allreposModel = new Model<Boolean>(allRepos);
    SessionlessForm<Void> form = new SessionlessForm<Void>("searchForm", getClass()) {

        private static final long serialVersionUID = 1L;

        @Override
        public void onSubmit() {
            String q = queryModel.getObject();
            if (StringUtils.isEmpty(q)) {
                error(getString("gb.undefinedQueryWarning"));
                return;
            }
            if (repositoriesModel.getObject().size() == 0 && !allreposModel.getObject()) {
                error(getString("gb.noSelectedRepositoriesWarning"));
                return;
            }
            PageParameters params = new PageParameters();
            params.add("repositories", StringUtils.flattenStrings(repositoriesModel.getObject()));
            params.add("query", queryModel.getObject());
            params.add("allrepos", allreposModel.getObject());
            LuceneSearchPage page = new LuceneSearchPage(params);
            setResponsePage(page);
        }
    };

    ListMultipleChoice<String> selections = new ListMultipleChoice<String>("repositories", repositoriesModel,
            availableRepositories, new StringChoiceRenderer());
    selections.setMaxRows(8);
    form.add(selections.setEnabled(luceneEnabled));
    form.add(new TextField<String>("query", queryModel).setEnabled(luceneEnabled));
    form.add(new CheckBox("allrepos", allreposModel));
    form.add(new ExternalLink("querySyntax", LUCENE_QUERY_SYNTAX_LINK));
    add(form.setEnabled(luceneEnabled));

    // execute search
    final List<SearchResult> results = new ArrayList<SearchResult>();
    if (!ArrayUtils.isEmpty(searchRepositories) && !StringUtils.isEmpty(query)) {
        results.addAll(app().repositories().search(query, page, pageSize, searchRepositories));
    }

    // results header
    if (results.size() == 0) {
        if (!ArrayUtils.isEmpty(searchRepositories) && !StringUtils.isEmpty(query)) {
            add(new Label("resultsHeader", query).setRenderBodyOnly(true));
            add(new Label("resultsCount", getString("gb.noHits")).setRenderBodyOnly(true));
        } else {
            add(new Label("resultsHeader").setVisible(false));
            add(new Label("resultsCount").setVisible(false));
        }
    } else {
        add(new Label("resultsHeader", query).setRenderBodyOnly(true));
        add(new Label("resultsCount",
                MessageFormat.format(getString("gb.queryResults"), results.get(0).hitId,
                        results.get(results.size() - 1).hitId, results.get(0).totalHits))
                                .setRenderBodyOnly(true));
    }

    // search results view
    ListDataProvider<SearchResult> resultsDp = new ListDataProvider<SearchResult>(results);
    final DataView<SearchResult> resultsView = new DataView<SearchResult>("searchResults", resultsDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<SearchResult> item) {
            final SearchResult sr = item.getModelObject();
            switch (sr.type) {
            case commit: {
                Label icon = WicketUtils.newIcon("type", "icon-refresh");
                WicketUtils.setHtmlTooltip(icon, "commit");
                item.add(icon);
                item.add(new LinkPanel("summary", null, sr.summary, CommitPage.class,
                        WicketUtils.newObjectParameter(sr.repository, sr.commitId)));
                // show tags
                Fragment fragment = new Fragment("tags", "tagsPanel", LuceneSearchPage.this);
                List<String> tags = sr.tags;
                if (tags == null) {
                    tags = new ArrayList<String>();
                }
                ListDataProvider<String> tagsDp = new ListDataProvider<String>(tags);
                final DataView<String> tagsView = new DataView<String>("tag", tagsDp) {
                    private static final long serialVersionUID = 1L;

                    @Override
                    public void populateItem(final Item<String> item) {
                        String tag = item.getModelObject();
                        Component c = new LinkPanel("tagLink", null, tag, TagPage.class,
                                WicketUtils.newObjectParameter(sr.repository, Constants.R_TAGS + tag));
                        WicketUtils.setCssClass(c, "tagRef");
                        item.add(c);
                    }
                };
                fragment.add(tagsView);
                item.add(fragment);
                break;
            }
            case blob: {
                Label icon = WicketUtils.newIcon("type", "icon-file");
                WicketUtils.setHtmlTooltip(icon, "blob");
                item.add(icon);
                item.add(new LinkPanel("summary", null, sr.path, BlobPage.class,
                        WicketUtils.newPathParameter(sr.repository, sr.branch, sr.path)));
                item.add(new Label("tags").setVisible(false));
                break;
            }
            }
            item.add(new Label("fragment", sr.fragment).setEscapeModelStrings(false)
                    .setVisible(!StringUtils.isEmpty(sr.fragment)));
            item.add(new LinkPanel("repository", null, sr.repository, SummaryPage.class,
                    WicketUtils.newRepositoryParameter(sr.repository)));
            if (StringUtils.isEmpty(sr.branch)) {
                item.add(new Label("branch", "null"));
            } else {
                item.add(new LinkPanel("branch", "branch",
                        StringUtils.getRelativePath(Constants.R_HEADS, sr.branch), LogPage.class,
                        WicketUtils.newObjectParameter(sr.repository, sr.branch)));
            }
            item.add(new Label("author", sr.author));
            item.add(WicketUtils.createDatestampLabel("date", sr.date, getTimeZone(), getTimeUtils()));
        }
    };
    add(resultsView.setVisible(results.size() > 0));

    PageParameters pagerParams = new PageParameters();
    pagerParams.add("repositories", StringUtils.flattenStrings(repositoriesModel.getObject()));
    pagerParams.add("query", queryModel.getObject());

    boolean showPager = false;
    int totalPages = 0;
    if (results.size() > 0) {
        totalPages = (results.get(0).totalHits / pageSize) + (results.get(0).totalHits % pageSize > 0 ? 1 : 0);
        showPager = results.get(0).totalHits > pageSize;
    }

    add(new PagerPanel("topPager", page, totalPages, LuceneSearchPage.class, pagerParams)
            .setVisible(showPager));
    add(new PagerPanel("bottomPager", page, totalPages, LuceneSearchPage.class, pagerParams)
            .setVisible(showPager));
}

From source file:com.github.checkstyle.regression.git.DiffParser.java

License:Open Source License

/**
 * Gets a TreeParserPair for the further use.
 * @param repository the repository to parse
 * @param branch     the name of the PR branch
 * @return the TreeParserPair prepared for the further use
 * @throws IOException JGit library exception
 */// w  w  w .  j a va  2  s.  co m
private static TreeParserPair getTreeParserPair(Repository repository, String branch) throws IOException {
    final TreeParserPair returnValue;
    final RevWalk walk = new RevWalk(repository);

    try {
        final RevCommit prCommit = walk
                .parseCommit(repository.exactRef(Constants.R_HEADS + branch).getObjectId());
        final RevCommit masterCommit = walk
                .parseCommit(repository.exactRef(Constants.R_HEADS + "master").getObjectId());
        final RevCommit commonAncestorCommit = getMergeBaseCommit(walk, prCommit, masterCommit);
        walk.dispose();

        returnValue = new TreeParserPair(prepareTreeParser(walk, prCommit),
                prepareTreeParser(walk, commonAncestorCommit));
    } finally {
        walk.close();
    }

    return returnValue;
}

From source file:com.github.checkstyle.regression.internal.GitUtils.java

License:Open Source License

public static void createNewBranchAndCheckout(Repository repository, String branchName) throws GitAPIException {
    try (Git git = new Git(repository)) {
        if (git.branchList().call().stream()
                .anyMatch(ref -> ref.getName().equals(Constants.R_HEADS + branchName))) {
            git.branchDelete().setBranchNames(branchName).setForce(true).call();
        }/*from   ww w .ja va 2s .com*/
        git.branchCreate().setName(branchName).call();
        git.checkout().setName(branchName).call();
    }
}

From source file:com.google.gerrit.acceptance.rest.project.CreateBranchIT.java

License:Apache License

private void assertCreateSucceeds() throws Exception {
    BranchInfo created = branch().create(new BranchInput()).get();
    assertThat(created.ref).isEqualTo(Constants.R_HEADS + branch.getShortName());
}

From source file:com.google.gerrit.httpd.rpc.changedetail.IncludedInDetailFactory.java

License:Apache License

@Override
public IncludedInDetail call()
        throws OrmException, NoSuchChangeException, IOException, InvalidRevisionException {
    control = changeControlFactory.validateFor(changeId);

    final PatchSet patch = db.patchSets().get(control.getChange().currentPatchSetId());
    final Repository repo = repoManager.openRepository(control.getProject().getNameKey());
    try {/* www .  j ava 2 s .co m*/
        final RevWalk rw = new RevWalk(repo);
        try {
            rw.setRetainBody(false);

            final RevCommit rev;
            try {
                rev = rw.parseCommit(ObjectId.fromString(patch.getRevision().get()));
            } catch (IncorrectObjectTypeException err) {
                throw new InvalidRevisionException();
            } catch (MissingObjectException err) {
                throw new InvalidRevisionException();
            }

            detail = new IncludedInDetail();
            detail.setBranches(includedIn(repo, rw, rev, Constants.R_HEADS));
            detail.setTags(includedIn(repo, rw, rev, Constants.R_TAGS));

            return detail;
        } finally {
            rw.release();
        }
    } finally {
        repo.close();
    }
}

From source file:com.google.gerrit.httpd.rpc.project.AddBranch.java

License:Apache License

@Override
public ListBranchesResult call() throws NoSuchProjectException, InvalidNameException, InvalidRevisionException,
        IOException, BranchCreationNotAllowedException {
    final ProjectControl projectControl = projectControlFactory.controlFor(projectName);

    String refname = branchName;//  w w  w .j  av a 2  s. c o  m
    while (refname.startsWith("/")) {
        refname = refname.substring(1);
    }
    if (!refname.startsWith(Constants.R_REFS)) {
        refname = Constants.R_HEADS + refname;
    }
    if (!Repository.isValidRefName(refname)) {
        throw new InvalidNameException();
    }
    if (refname.startsWith(ReceiveCommits.NEW_CHANGE)) {
        throw new BranchCreationNotAllowedException(ReceiveCommits.NEW_CHANGE);
    }

    final Branch.NameKey name = new Branch.NameKey(projectName, refname);
    final RefControl refControl = projectControl.controlForRef(name);
    final Repository repo = repoManager.openRepository(projectName);
    try {
        final ObjectId revid = parseStartingRevision(repo);
        final RevWalk rw = verifyConnected(repo, revid);
        RevObject object = rw.parseAny(revid);

        if (refname.startsWith(Constants.R_HEADS)) {
            // Ensure that what we start the branch from is a commit. If we
            // were given a tag, deference to the commit instead.
            //
            try {
                object = rw.parseCommit(object);
            } catch (IncorrectObjectTypeException notCommit) {
                throw new IllegalStateException(startingRevision + " not a commit");
            }
        }

        if (!refControl.canCreate(rw, object)) {
            throw new IllegalStateException("Cannot create " + refname);
        }

        try {
            final RefUpdate u = repo.updateRef(refname);
            u.setExpectedOldObjectId(ObjectId.zeroId());
            u.setNewObjectId(object.copy());
            u.setRefLogIdent(identifiedUser.newRefLogIdent());
            u.setRefLogMessage("created via web from " + startingRevision, false);
            final RefUpdate.Result result = u.update(rw);
            switch (result) {
            case FAST_FORWARD:
            case NEW:
            case NO_CHANGE:
                replication.scheduleUpdate(name.getParentKey(), refname);
                hooks.doRefUpdatedHook(name, u, identifiedUser.getAccount());
                break;
            default: {
                throw new IOException(result.name());
            }
            }
        } catch (IOException err) {
            log.error("Cannot create branch " + name, err);
            throw err;
        }
    } finally {
        repo.close();
    }

    return listBranchesFactory.create(projectName).call();
}

Example usage for org.eclipse.jgit.lib Constants R_HEADS

Introduction

Prototype

Document

Usage