Attachment #139992 for bug #235882

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 235882
Collapse All | Expand All




        
        <change>
            <api name="gitlibrary_api"/>
            <summary>The log command returns also branches containing the commits from the result.</summary>
            <version major="1" minor="14"/>
            <date day="12" month="9" year="2013"/>
            <author login="ovrabec"/>
            <compatibility addition="yes"/>
            <description>
                <ul>
                <li>Adding a new method GitClient.log (SearchCriteria, boolean, ProgressMonitor)
                    allowing an API client to specify if he wants to know what branches contain
                    the returned commits applying the search criteria. Such information can
                    be used to filter the resulted commits by branches without a need to restart
                    the command again.</li>
                <li>Adding a method GitRevisionInfo.getBranches() returning all branches
                that are known to contain the commit.</li>
                </ul>
            </description>
            <class package="org.netbeans.libs.git" name="GitClient"/>
            <class package="org.netbeans.libs.git" name="GitRevisionInfo"/>
            <issue number="235882"/>
        </change>
        <change>
            <api name="gitlibrary_api"/>
            <summary>Adding a command setting the upstream branch/tracking of local branches</summary>
            <version major="1" minor="12"/>
            <date day="22" month="8" year="2013"/>

Lines 1-4 Link Here

(-)a/libs.git/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.libs.git/1	2	OpenIDE-Module: org.netbeans.libs.git/1
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/libs/git/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/libs/git/Bundle.properties
4	OpenIDE-Module-Specification-Version: 1.13	4	OpenIDE-Module-Specification-Version: 1.14

Lines 129-136 Link Here

(-)a/libs.git/src/org/netbeans/libs/git/GitClassFactoryImpl.java (-2 / +2 lines)
129	}	129	}
130		130
131	@Override	131	@Override
132	public GitRevisionInfo createRevisionInfo (RevCommit commit, Repository repository) {	132	public GitRevisionInfo createRevisionInfo (RevCommit commit, Map<String, GitBranch> affectedBranches, Repository repository) {
133	return new GitRevisionInfo(commit, repository);	133	return new GitRevisionInfo(commit, affectedBranches, repository);
134	}	134	}
135		135
136	@Override	136	@Override

Lines 792-797 Link Here

(-)a/libs.git/src/org/netbeans/libs/git/GitClient.java (-1 / +25 lines)
792		792
793	/**	793	/**
794	* Digs through the repository's history and returns revisions according to the given search criteria.	794	* Digs through the repository's history and returns revisions according to the given search criteria.
		795	* No information about branches is returned, you
		796	* should call {@link #log(org.netbeans.libs.git.SearchCriteria, boolean, org.netbeans.libs.git.progress.ProgressMonitor)}
		797	* if you want to get such knowledge.
795	* @param searchCriteria criteria filtering the returned revisions	798	* @param searchCriteria criteria filtering the returned revisions
796	* @param monitor progress monitor	799	* @param monitor progress monitor
797	* @return revisions that follow the given search criteria	800	* @return revisions that follow the given search criteria
Lines 799-806 Link Here
799	* @throws GitException an unexpected error occurs	802	* @throws GitException an unexpected error occurs
800	*/	803	*/
801	public GitRevisionInfo[] log (SearchCriteria searchCriteria, ProgressMonitor monitor) throws GitException.MissingObjectException, GitException {	804	public GitRevisionInfo[] log (SearchCriteria searchCriteria, ProgressMonitor monitor) throws GitException.MissingObjectException, GitException {
		805	return log(searchCriteria, false, monitor);
		806	}
		807
		808	/**
		809	* Digs through the repository's history and returns revisions according to
		810	* the given search criteria.
		811	*
		812	* @param searchCriteria criteria filtering the returned revisions
		813	* @param fetchBranchInfo if set to <code>true</code> then the command will
		814	* also fetch information ({@link GitRevisionInfo#getBranches()}) about what
		815	* branches contain the individual commits returned by the command. You can
		816	* use that information to filter returned commits by the branches they're
		817	* part of. Also note that the command will take more time to finish.
		818	* @param monitor progress monitor
		819	* @return revisions that follow the given search criteria
		820	* @throws GitException.MissingObjectException revision specified in search
		821	* criteria (or head if no such revision is specified) does not exist
		822	* @throws GitException an unexpected error occurs
		823	*/
		824	public GitRevisionInfo[] log (SearchCriteria searchCriteria, boolean fetchBranchInfo, ProgressMonitor monitor) throws GitException.MissingObjectException, GitException {
802	Repository repository = gitRepository.getRepository();	825	Repository repository = gitRepository.getRepository();
803	LogCommand cmd = new LogCommand(repository, getClassFactory(), searchCriteria, monitor, delegateListener);	826	LogCommand cmd = new LogCommand(repository, getClassFactory(), searchCriteria,
		827	fetchBranchInfo, monitor, delegateListener);
804	cmd.execute();	828	cmd.execute();
805	return cmd.getRevisions();	829	return cmd.getRevisions();
806	}	830	}




import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;

 */
public final class GitRevisionInfo {

    private final RevCommit revCommit;
    private final Repository repository;
    private final Map<String, GitBranch> branches;
    private GitFileInfo[] modifiedFiles;
    private static final Logger LOG = Logger.getLogger(GitRevisionInfo.class.getName());

    GitRevisionInfo (RevCommit commit, Repository repository) {
        this(commit, Collections.<String, GitBranch>emptyMap(), repository);
    }

    GitRevisionInfo (RevCommit commit, Map<String, GitBranch> affectedBranches, Repository repository) {
        this.revCommit = commit;
        this.repository = repository;
        this.branches = Collections.unmodifiableMap(affectedBranches);
    }

    /**

        return parents;
    }
    
    /**
     * @return all branches known to contain this commit.
     */
    public Map<String, GitBranch> getBranches () {
        return branches;
    }
    
    private void listFiles() throws GitException {
        RevWalk revWalk = new RevWalk(repository);
        TreeWalk walk = new TreeWalk(repository);

            walk.release();
        }
    }

    private static Map<String, GitBranch> buildBranches (RevCommit commit, Map<String, GitBranch> branches) {
        Map<String, GitBranch> retval = new LinkedHashMap<>(branches.size());
        
        return retval;
    }
    
    /**
     * Provides information about what happened to a file between two different commits.

Lines 42-47 Link Here

(-)a/libs.git/src/org/netbeans/libs/git/jgit/GitClassFactory.java (-1 / +6 lines)
42	package org.netbeans.libs.git.jgit;	42	package org.netbeans.libs.git.jgit;
43		43
44	import java.io.File;	44	import java.io.File;
		45	import java.util.Collections;
45	import java.util.List;	46	import java.util.List;
46	import java.util.Map;	47	import java.util.Map;
47	import org.eclipse.jgit.api.MergeResult;	48	import org.eclipse.jgit.api.MergeResult;
Lines 103-109 Link Here
103		104
104	public abstract GitRevertResult createRevertResult (GitRevertResult.Status status, GitRevisionInfo createRevisionInfo, List<File> conflicts, List<File> failures);	105	public abstract GitRevertResult createRevertResult (GitRevertResult.Status status, GitRevisionInfo createRevisionInfo, List<File> conflicts, List<File> failures);
105		106
106	public abstract GitRevisionInfo createRevisionInfo (RevCommit commit, Repository repository);	107	public final GitRevisionInfo createRevisionInfo (RevCommit commit, Repository repository) {
		108	return createRevisionInfo(commit, Collections.<String, GitBranch>emptyMap(), repository);
		109	}
		110
		111	public abstract GitRevisionInfo createRevisionInfo (RevCommit commit, Map<String, GitBranch> affectedBranches, Repository repository);
107		112
108	public abstract GitStatus createStatus (boolean tracked, String path, String workTreePath, File file,	113	public abstract GitStatus createStatus (boolean tracked, String path, String workTreePath, File file,
109	Status statusHeadIndex, Status statusIndexWC, Status statusHeadWC,	114	Status statusHeadIndex, Status statusIndexWC, Status statusHeadWC,

Lines 83-88 Link Here

(-)a/libs.git/src/org/netbeans/libs/git/jgit/Utils.java (+8 lines)
83	import org.netbeans.libs.git.GitObjectType;	83	import org.netbeans.libs.git.GitObjectType;
84	import org.netbeans.libs.git.GitRevisionInfo;	84	import org.netbeans.libs.git.GitRevisionInfo;
85	import org.netbeans.libs.git.GitRevisionInfo.GitFileInfo;	85	import org.netbeans.libs.git.GitRevisionInfo.GitFileInfo;
		86	import org.netbeans.libs.git.jgit.commands.ListBranchCommand;
		87	import org.netbeans.libs.git.progress.ProgressMonitor;
86		88
87	/**	89	/**
88	*	90	*
Lines 422-425 Link Here
422	return allBranches.get(remoteName + trackedBranchName);	424	return allBranches.get(remoteName + trackedBranchName);
423	}	425	}
424	}	426	}
		427
		428	public static Map getAllBranches (Repository repository, GitClassFactory fac, ProgressMonitor monitor) throws GitException {
		429	ListBranchCommand cmd = new ListBranchCommand(repository, fac, true, monitor);
		430	cmd.execute();
		431	return cmd.getBranches();
		432	}
425	}	433	}





import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.FollowFilter;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevFlag;
import org.eclipse.jgit.revwalk.RevSort;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.revwalk.filter.AndRevFilter;

    private final List<GitRevisionInfo> revisions;
    private final String revision;
    private final SearchCriteria criteria;
    private final boolean fetchBranchInfo;
    private static final Logger LOG = Logger.getLogger(LogCommand.class.getName());

    public LogCommand (Repository repository, GitClassFactory gitFactory, SearchCriteria criteria,
            boolean fetchBranchInfo, ProgressMonitor monitor, RevisionInfoListener listener) {
        super(repository, gitFactory, monitor);
        this.monitor = monitor;
        this.listener = listener;
        this.criteria = criteria;
        this.fetchBranchInfo = fetchBranchInfo;
        this.revision = null;
        this.revisions = new LinkedList<>();
    }
    
    public LogCommand (Repository repository, GitClassFactory gitFactory, String revision, ProgressMonitor monitor, RevisionInfoListener listener) {

        this.monitor = monitor;
        this.listener = listener;
        this.criteria = null;
        this.fetchBranchInfo = false;
        this.revision = revision;
        this.revisions = new LinkedList<>();
    }

    @Override

        } else {
            RevWalk walk = new RevWalk(repository);
            RevWalk fullWalk = new RevWalk(repository);
            Map<String, GitBranch> allBranches;
            Map<String, RevCommit> branchCommits;
            List<RevFlag> branchFlags;
            if (fetchBranchInfo) {
                allBranches = Utils.getAllBranches(repository, getClassFactory(), new DelegatingGitProgressMonitor(monitor));
                branchFlags = new ArrayList<>(allBranches.size());
                branchCommits = new LinkedHashMap<>(allBranches.size());
                for (Map.Entry<String, GitBranch> e : allBranches.entrySet()) {
                    if (e.getKey() != GitBranch.NO_BRANCH) {
                        RevFlag flag = walk.newFlag(e.getKey());
                        branchFlags.add(flag);
                        try {
                            RevCommit branchHeadCommit = walk.parseCommit(repository.resolve(e.getValue().getId()));
                            branchHeadCommit.add(flag);
                            branchHeadCommit.carry(flag);
                            walk.markStart(branchHeadCommit);
                        } catch (IOException ex) {
                            LOG.log(Level.INFO, null, ex);
                        }
                    }
                }
                walk.carry(branchFlags);
            } else {
                allBranches = Collections.<String, GitBranch>emptyMap();
                branchCommits = Collections.<String, RevCommit>emptyMap();
                branchFlags = Collections.<RevFlag>emptyList();
            }
            try {
                RevFlag interestingFlag = walk.newFlag("RESULT_FLAG"); //NOI18N
                walk.carry(interestingFlag);
                String revisionFrom = criteria.getRevisionFrom();
                String revisionTo = criteria.getRevisionTo();
                if (revisionTo != null && revisionFrom != null) {
                    for (RevCommit uninteresting : Utils.findCommit(repository, revisionFrom).getParents()) {
                        walk.markUninteresting(walk.parseCommit(uninteresting));
                    }
                    walk.markStart(markStartCommit(walk.lookupCommit(Utils.findCommit(repository, revisionTo)), interestingFlag));
                } else if (revisionTo != null) {
                    walk.markStart(markStartCommit(walk.lookupCommit(Utils.findCommit(repository, revisionTo)), interestingFlag));
                } else if (revisionFrom != null) {
                    for (RevCommit uninteresting : Utils.findCommit(repository, revisionFrom).getParents()) {
                        walk.markUninteresting(walk.parseCommit(uninteresting));
                    }
                    walk.markStart(markStartCommit(walk.lookupCommit(Utils.findCommit(repository, Constants.HEAD)), interestingFlag));
                } else {
                    ListBranchCommand branchCommand = new ListBranchCommand(repository, getClassFactory(), false, new DelegatingGitProgressMonitor(monitor));
                    branchCommand.execute();

                        return;
                    }
                    for (Map.Entry<String, GitBranch> e : branchCommand.getBranches().entrySet()) {
                        walk.markStart(markStartCommit(walk.lookupCommit(Utils.findCommit(repository, e.getValue().getId())), interestingFlag));
                    }
                }
                applyCriteria(walk, criteria, interestingFlag);
                walk.sort(RevSort.TOPO);
                walk.sort(RevSort.COMMIT_TIME_DESC, true);
                int remaining = criteria.getLimit();

                    if (!applyCriteriaAfter(criteria, commit)) {
                        continue;
                    }
                    addRevision(getClassFactory().createRevisionInfo(fullWalk.parseCommit(commit),
                            getAffectedBranches(commit, allBranches, branchFlags), repository));
                    --remaining;
                }
            } catch (MissingObjectException ex) {

        listener.notifyRevisionInfo(info);
    }

    private void applyCriteria (RevWalk walk, SearchCriteria criteria, final RevFlag partOfResultFlag) {
        File[] files = criteria.getFiles();
        if (files.length > 0) {
            Collection<PathFilter> pathFilters = Utils.getPathFilters(getRepository().getWorkTree(), files);

        } else {
            filter = RevFilter.NO_MERGES;
        }
        filter = AndRevFilter.create(filter, new RevFilter() {

            @Override
            public boolean include (RevWalk walker, RevCommit cmit) {
                return cmit.has(partOfResultFlag);
            }

            @Override
            public RevFilter clone () {
                return this;
            }

            @Override
            public boolean requiresCommitBody () {
                return false;
            }            
            
        });
        
//        String username = criteria.getUsername();
//        if (username != null && !(username = username.trim()).isEmpty()) {

    private boolean applyTo (PersonIdent ident, String pattern) {
        return ident != null && new GitUser(ident.getName(), ident.getEmailAddress()).toString().contains(pattern);
    }

    private RevCommit markStartCommit (RevCommit commit, RevFlag interestingFlag) {
        commit.add(interestingFlag);
        return commit;
    }

    private Map<String, GitBranch> getAffectedBranches (RevCommit commit, Map<String, GitBranch> allBranches,
            List<RevFlag> branchFlags) {
        Map<String, GitBranch> affected = new LinkedHashMap<>(allBranches.size());
        for (RevFlag flag : branchFlags) {
            GitBranch b;
            if (commit.has(flag) && (b = allBranches.get(flag.toString())) != null) {
                affected.put(b.getName(), b);
            }
        }
        return affected;
    }
}




import java.util.Date;
import java.util.Map;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;

        GitRevisionInfo revision4 = client.commit(files, "modification4", null, null, NULL_PROGRESS_MONITOR);
        SearchCriteria crit = new SearchCriteria();
        crit.setRevisionTo(revision4.getRevision());
        GitRevisionInfo[] revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(5, revisions.length);
        assertRevisions(revision4, revisions[0]);
        assertRevisions(revision3, revisions[1]);

        SearchCriteria crit = new SearchCriteria();
        crit.setRevisionFrom(revision2.getRevision());
        crit.setRevisionTo(revision3.getRevision());
        GitRevisionInfo[] revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(2, revisions.length);
        assertRevisions(revision3, revisions[0]);
        assertRevisions(revision2, revisions[1]);

        crit = new SearchCriteria();
        crit.setRevisionFrom(revision2.getRevision());
        crit.setRevisionTo(revision4.getRevision());
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(3, revisions.length);
        assertRevisions(revision4, revisions[0]);
        assertRevisions(revision3, revisions[1]);

        GitRevisionInfo revisionB2 = client.commit(files, "modificationOnB-2", null, null, NULL_PROGRESS_MONITOR);
        SearchCriteria crit = new SearchCriteria();
        crit.setRevisionTo("A");
        GitRevisionInfo[] revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(4, revisions.length);
        assertRevisions(revisionA2, revisions[0]);
        assertRevisions(revisionA1, revisions[1]);

        
        crit = new SearchCriteria();
        crit.setRevisionTo("B");
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(4, revisions.length);
        assertRevisions(revisionB2, revisions[0]);
        assertRevisions(revisionB1, revisions[1]);

        assertRevisions(revision0, revisions[3]);
        
        // try both branches, how are the revisions sorted?
        revisions = client.log(new SearchCriteria(), true, NULL_PROGRESS_MONITOR);
        assertEquals(6, revisions.length);
        assertRevisions(revisionB2, revisions[0]);
        assertRevisions(revisionA2, revisions[1]);

        SearchCriteria crit = new SearchCriteria();
        crit.setRevisionFrom(revision2.getRevision());
        crit.setRevisionTo(revision4.getRevision());
        GitRevisionInfo[] revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(3, revisions.length);
        assertRevisions(revision4, revisions[0]);
        assertRevisions(revision3, revisions[1]);

        crit.setRevisionFrom(revision2.getRevision());
        crit.setRevisionTo(revision4.getRevision());
        crit.setLimit(2);
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(2, revisions.length);
        assertRevisions(revision4, revisions[0]);
        assertRevisions(revision3, revisions[1]);

        SearchCriteria crit = new SearchCriteria();
        crit.setFiles(new File[] { f1 });
        crit.setRevisionFrom(revision1.getRevision());
        GitRevisionInfo[] revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(2, revisions.length);
        assertRevisions(revision3, revisions[0]);
        assertRevisions(revision1, revisions[1]);

        crit = new SearchCriteria();
        crit.setFiles(new File[] { f2 });
        crit.setRevisionFrom(revision1.getRevision());
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(2, revisions.length);
        assertRevisions(revision3, revisions[0]);
        assertRevisions(revision2, revisions[1]);

        crit = new SearchCriteria();
        crit.setFiles(files);
        crit.setRevisionFrom(revision1.getRevision());
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(3, revisions.length);
        assertRevisions(revision3, revisions[0]);
        assertRevisions(revision2, revisions[1]);

        crit = new SearchCriteria();
        crit.setFiles(new File[] { f1, f2, f3 });
        crit.setRevisionFrom(revision1.getRevision());
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(4, revisions.length);
        assertRevisions(revision4, revisions[0]);
        assertRevisions(revision3, revisions[1]);

        crit = new SearchCriteria();
        crit.setFiles(new File[] { workDir });
        crit.setRevisionFrom(revision1.getRevision());
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(4, revisions.length);
        assertRevisions(revision4, revisions[0]);
        assertRevisions(revision3, revisions[1]);

        GitRevisionInfo revision2 = client.commit(files, "modification2", null, user1, NULL_PROGRESS_MONITOR);
        
        SearchCriteria crit = new SearchCriteria();
        GitRevisionInfo[] revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(3, revisions.length);
        
        crit = new SearchCriteria();
        crit.setUsername("git-test-user");
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(2, revisions.length);
        assertRevisions(revision2, revisions[0]);
        assertRevisions(revision1, revisions[1]);
        
        crit = new SearchCriteria();
        crit.setUsername("git-test-user@domain.com");
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(2, revisions.length);
        assertRevisions(revision2, revisions[0]);
        assertRevisions(revision1, revisions[1]);
        
        crit = new SearchCriteria();
        crit.setUsername("test-user");
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(2, revisions.length);
        assertRevisions(revision2, revisions[0]);
        assertRevisions(revision1, revisions[1]);
        
        crit = new SearchCriteria();
        crit.setUsername("git-test-user222@domain.com");
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(0, revisions.length);
        
        crit = new SearchCriteria();
        crit.setUsername("git-test-user <git-test-user@domain.com>");
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(2, revisions.length);
        assertRevisions(revision2, revisions[0]);
        assertRevisions(revision1, revisions[1]);

        GitRevisionInfo revision1 = client.commit(files, "modification1\non master", null, null, NULL_PROGRESS_MONITOR);
        
        SearchCriteria crit = new SearchCriteria();
        GitRevisionInfo[] revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(2, revisions.length);
        
        crit = new SearchCriteria();
        crit.setMessage("blablabla");
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(0, revisions.length);
        
        crit = new SearchCriteria();
        crit.setMessage("modification");
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(1, revisions.length);
        assertRevisions(revision1, revisions[0]);
        
        crit = new SearchCriteria();
        crit.setMessage("modification1\non master");
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(1, revisions.length);
        assertRevisions(revision1, revisions[0]);
        
        // see bug #228905
        crit = new SearchCriteria();
        crit.setMessage("on master");
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(1, revisions.length);
        assertRevisions(revision1, revisions[0]);
    }

        
        SearchCriteria crit = new SearchCriteria();
        crit.setRevisionTo("master");
        GitRevisionInfo[] revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(4, revisions.length);
        assertRevisions(revisionMerge, revisions[0]);
        
        crit = new SearchCriteria();
        crit.setIncludeMerges(true);
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(4, revisions.length);
        assertRevisions(revisionMerge, revisions[0]);
        
        crit = new SearchCriteria();
        crit.setIncludeMerges(false);
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(3, revisions.length);
        assertRevisions(revisionMaster, revisions[0]);
        assertRevisions(revisionBranch, revisions[1]);

        SearchCriteria crit = new SearchCriteria();
        crit.setFrom(new Date(revision2.getCommitTime()));
        crit.setTo(new Date(revision3.getCommitTime()));
        GitRevisionInfo[] revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(2, revisions.length);
        assertRevisions(revision3, revisions[0]);
        assertRevisions(revision2, revisions[1]);

        crit = new SearchCriteria();
        crit.setFrom(new Date(revision2.getCommitTime()));
        crit.setTo(new Date(revision3.getCommitTime()));
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(2, revisions.length);
        assertRevisions(revision3, revisions[0]);
        assertRevisions(revision2, revisions[1]);

        crit = new SearchCriteria();
        crit.setFrom(new Date(revision2.getCommitTime()));
        crit.setTo(new Date(revision4.getCommitTime()));
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(3, revisions.length);
        assertRevisions(revision4, revisions[0]);
        assertRevisions(revision3, revisions[1]);

        
        crit = new SearchCriteria();
        crit.setFrom(new Date(revision2.getCommitTime()));
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(3, revisions.length);
        assertRevisions(revision4, revisions[0]);
        assertRevisions(revision3, revisions[1]);

        
        SearchCriteria crit = new SearchCriteria();
        crit.setFiles(new File[] { to });
        GitRevisionInfo[] revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(2, revisions.length);
        assertRevisions(revision3, revisions[0]);
        assertRevisions(revision2, revisions[1]);

        crit = new SearchCriteria();
        crit.setFiles(new File[] { to });
        crit.setFollowRenames(true);
        revisions = client.log(crit, true, NULL_PROGRESS_MONITOR);
        assertEquals(4, revisions.length);
        assertRevisions(revision3, revisions[0]);
        assertRevisions(revision2, revisions[1]);

        assertEquals(GitFileInfo.Status.MODIFIED, modifiedFiles.get(f).getStatus());
        assertEquals(GitFileInfo.Status.MODIFIED, modifiedFiles.get(f2).getStatus());
    }
    
    public void testLogWithBranchInfo () throws Exception {
        File f = new File(workDir, "f");
        File f2 = new File(workDir, "f2");
        write(f, "init");
        write(f2, "init");
        File[] files = new File[] { f, f2 };
        add(files);
        commit(files);
        
        write(f, "modification");
        add(files);
        commit(files);
        
        GitClient client = getClient(workDir);
        SearchCriteria crit = new SearchCriteria();
        crit.setRevisionTo("master");
        GitRevisionInfo[] log = client.log(crit, NULL_PROGRESS_MONITOR);
        for (GitRevisionInfo info : log) {
            // no branch info fetched by this version of the command
            assertEquals(0, info.getBranches().size());
        }
        
        log = client.log(crit, true, NULL_PROGRESS_MONITOR);
        for (GitRevisionInfo info : log) {
            // all commits are from master
            assertEquals(1, info.getBranches().size());
            assertNotNull(info.getBranches().get("master"));
        }
    }
    
    // commit in the middle of a named branch
    public void testLogWithBranchInfoMiddleCommit () throws Exception {
        File f = new File(workDir, "f");
        File f2 = new File(workDir, "f2");
        write(f, "init");
        write(f2, "init");
        File[] files = new File[] { f, f2 };
        add(files);
        GitClient client = getClient(workDir);
        GitRevisionInfo firstCommit = client.commit(files, "initial commit", null, null, NULL_PROGRESS_MONITOR);
        
        client.createBranch("newbranch", "master", NULL_PROGRESS_MONITOR);
        
        write(f, "modification");
        add(files);
        commit(files);
        
        write(f2, "modification");
        add(files);
        commit(files);
        
        SearchCriteria crit = new SearchCriteria();
        crit.setRevisionFrom(firstCommit.getRevision());
        crit.setRevisionTo(firstCommit.getRevision());
        crit.setFiles(new File[] { f });
        GitRevisionInfo info = client.log(crit, true, NULL_PROGRESS_MONITOR)[0];
        // the initial commit is from master and head of newbranch
        assertNotNull(info.getBranches().get("newbranch"));
        assertEquals(2, info.getBranches().size());
    }
    
    public void testLogWithBranchInfoMoreBranches () throws Exception {
        File f = new File(workDir, "f");
        File f2 = new File(workDir, "f2");
        write(f, "init");
        write(f2, "init");
        File[] files = new File[] { f, f2 };
        add(files);
        commit(files);
        
        write(f, "modification");
        add(files);
        commit(files);
                
        GitClient client = getClient(workDir);
        client.createBranch("newbranch", "master", NULL_PROGRESS_MONITOR);
        write(f, "modification on trunk");
        add(files);
        commit(files);
        
        client.checkoutRevision("newbranch", true, NULL_PROGRESS_MONITOR);
        write(f, "modification on branch");
        add(files);
        commit(files);
        
        SearchCriteria crit = new SearchCriteria();
        // log across all branches
        GitRevisionInfo[] log = client.log(crit, true, NULL_PROGRESS_MONITOR);
        // branch commit
        assertEquals(1, log[0].getBranches().size());
        assertNotNull(log[0].getBranches().get("newbranch"));
        // master commit
        assertEquals(1, log[1].getBranches().size());
        assertNotNull(log[1].getBranches().get("master"));
        // common commit
        assertEquals(2, log[2].getBranches().size());
        assertNotNull(log[2].getBranches().get("master"));
        assertNotNull(log[2].getBranches().get("newbranch"));
        // initial commit
        assertEquals(2, log[3].getBranches().size());
        assertNotNull(log[3].getBranches().get("master"));
        assertNotNull(log[3].getBranches().get("newbranch"));
    }

    private void assertRevisions (GitRevisionInfo expected, GitRevisionInfo info) throws GitException {
        assertEquals(expected.getRevision(), info.getRevision());

Return to bug 235882

Lines 111-116 Link Here

(-)a/libs.git/apichanges.xml (+22 lines)
111		111
112	<change>	112	<change>
113	<api name="gitlibrary_api"/>	113	<api name="gitlibrary_api"/>
		114	<summary>The log command returns also branches containing the commits from the result.</summary>
		115	<version major="1" minor="14"/>
		116	<date day="12" month="9" year="2013"/>
		117	<author login="ovrabec"/>
		118	<compatibility addition="yes"/>
		119	<description>
		120	<ul>
		121	<li>Adding a new method GitClient.log (SearchCriteria, boolean, ProgressMonitor)
		122	allowing an API client to specify if he wants to know what branches contain
		123	the returned commits applying the search criteria. Such information can
		124	be used to filter the resulted commits by branches without a need to restart
		125	the command again.</li>
		126	<li>Adding a method GitRevisionInfo.getBranches() returning all branches
		127	that are known to contain the commit.</li>
		128	</ul>
		129	</description>
		130	<class package="org.netbeans.libs.git" name="GitClient"/>
		131	<class package="org.netbeans.libs.git" name="GitRevisionInfo"/>
		132	<issue number="235882"/>
		133	</change>
		134	<change>
		135	<api name="gitlibrary_api"/>
114	<summary>Adding a command setting the upstream branch/tracking of local branches</summary>	136	<summary>Adding a command setting the upstream branch/tracking of local branches</summary>
115	<version major="1" minor="12"/>	137	<version major="1" minor="12"/>
116	<date day="22" month="8" year="2013"/>	138	<date day="22" month="8" year="2013"/>