Attachment #132509 for bug #227348

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 227348
Collapse All | Expand All




        
        <change>
            <api name="gitlibrary_api"/>
            <summary>Adding support comparing trees of arbitrary commits</summary>
            <version major="1" minor="9"/>
            <date day="12" month="3" year="2013"/>
            <author login="ovrabec"/>
            <compatibility addition="yes"/>
            <description>
                <ul>
                    <li>Adding a new method GitClient.getStatus(File[], String, ProgressMonitor)
                    allowing an API client to get statuses of local files not just against the HEAD but against
                    an arbitrary commit.</li>
                    <li>Adding a new method GitClient.getStatus(File[], String, String, ProgressMonitor)
                    allowing an API client to get modifications from the Git history. It is similar to
                    GitRevisionInfo.getModifications but returns file statuses between two arbitrary commits
                    and not just a commit and its parent.</li>
                </ul>
            </description>
        </change>
        <change>
            <api name="gitlibrary_api"/>
            <summary>Adding support for rebase to the API</summary>
            <version major="1" minor="8"/>
            <date day="11" month="3" 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.8	4	OpenIDE-Module-Specification-Version: 1.9

Lines 60-65 Link Here

(-)a/libs.git/src/org/netbeans/libs/git/GitClassFactoryImpl.java (+6 lines)
60	import org.eclipse.jgit.transport.URIish;	60	import org.eclipse.jgit.transport.URIish;
61	import org.netbeans.libs.git.GitConflictDescriptor.Type;	61	import org.netbeans.libs.git.GitConflictDescriptor.Type;
62	import org.netbeans.libs.git.GitRevertResult.Status;	62	import org.netbeans.libs.git.GitRevertResult.Status;
		63	import org.netbeans.libs.git.GitRevisionInfo.GitFileInfo;
63	import org.netbeans.libs.git.jgit.GitClassFactory;	64	import org.netbeans.libs.git.jgit.GitClassFactory;
64		65
65	/**	66	/**
Lines 92-97 Link Here
92	}	93	}
93		94
94	@Override	95	@Override
		96	public GitFileInfo createFileInfo (File file, String oldPath, GitFileInfo.Status status, File originalFile, String originalPath) {
		97	return new GitFileInfo(file, oldPath, status, originalFile, originalPath);
		98	}
		99
		100	@Override
95	public GitMergeResult createMergeResult (MergeResult mergeResult, File workTree) {	101	public GitMergeResult createMergeResult (MergeResult mergeResult, File workTree) {
96	return new GitMergeResult(mergeResult, workTree);	102	return new GitMergeResult(mergeResult, workTree);
97	}	103	}

Lines 49-57 Link Here

(-)a/libs.git/src/org/netbeans/libs/git/GitClient.java (-2 / +42 lines)
49	import java.util.List;	49	import java.util.List;
50	import java.util.Map;	50	import java.util.Map;
51	import java.util.Set;	51	import java.util.Set;
		52	import org.eclipse.jgit.lib.Constants;
52	import org.eclipse.jgit.lib.PersonIdent;	53	import org.eclipse.jgit.lib.PersonIdent;
53	import org.eclipse.jgit.lib.Repository;	54	import org.eclipse.jgit.lib.Repository;
54	import org.eclipse.jgit.lib.RepositoryState;	55	import org.eclipse.jgit.lib.RepositoryState;
		56	import org.netbeans.libs.git.GitRevisionInfo.GitFileInfo;
55	import org.netbeans.libs.git.jgit.GitClassFactory;	57	import org.netbeans.libs.git.jgit.GitClassFactory;
56	import org.netbeans.libs.git.jgit.JGitCredentialsProvider;	58	import org.netbeans.libs.git.jgit.JGitCredentialsProvider;
57	import org.netbeans.libs.git.jgit.JGitRepository;	59	import org.netbeans.libs.git.jgit.JGitRepository;
Lines 62-67 Link Here
62	import org.netbeans.libs.git.jgit.commands.CheckoutRevisionCommand;	64	import org.netbeans.libs.git.jgit.commands.CheckoutRevisionCommand;
63	import org.netbeans.libs.git.jgit.commands.CleanCommand;	65	import org.netbeans.libs.git.jgit.commands.CleanCommand;
64	import org.netbeans.libs.git.jgit.commands.CommitCommand;	66	import org.netbeans.libs.git.jgit.commands.CommitCommand;
		67	import org.netbeans.libs.git.jgit.commands.CompareCommand;
65	import org.netbeans.libs.git.jgit.commands.ConflictCommand;	68	import org.netbeans.libs.git.jgit.commands.ConflictCommand;
66	import org.netbeans.libs.git.jgit.commands.CopyCommand;	69	import org.netbeans.libs.git.jgit.commands.CopyCommand;
67	import org.netbeans.libs.git.jgit.commands.CreateBranchCommand;	70	import org.netbeans.libs.git.jgit.commands.CreateBranchCommand;
Lines 603-621 Link Here
603	}	606	}
604		607
605	/**	608	/**
606	* Returns an array of statuses for files under given roots	609	* Compares the working tree with the current HEAD and returns an array of
		610	* statuses for files under given roots
		611	*
607	* @param roots root folders or files to search under	612	* @param roots root folders or files to search under
608	* @return status array	613	* @return status array
609	* @throws GitException an unexpected error occurs	614	* @throws GitException an unexpected error occurs
610	*/	615	*/
611	public Map<File, GitStatus> getStatus (File[] roots, ProgressMonitor monitor) throws GitException {	616	public Map<File, GitStatus> getStatus (File[] roots, ProgressMonitor monitor) throws GitException {
		617	return getStatus(roots, Constants.HEAD, monitor);
		618	}
		619
		620	/**
		621	* Compares working tree with a given revision and returns an array of
		622	* statuses for files under given roots
		623	*
		624	* @param roots root folders or files to search under
		625	* @param revision revision to compare with the working tree. If set
		626	* to <code>null</code> HEAD will be used instead.
		627	* @return status array
		628	* @throws GitException an unexpected error occurs
		629	* @since 1.9
		630	*/
		631	public Map<File, GitStatus> getStatus (File[] roots, String revision, ProgressMonitor monitor) throws GitException {
612	Repository repository = gitRepository.getRepository();	632	Repository repository = gitRepository.getRepository();
613	StatusCommand cmd = new StatusCommand(repository, getClassFactory(), roots, monitor, delegateListener);	633	StatusCommand cmd = new StatusCommand(repository, revision == null ? Constants.HEAD : revision,
		634	roots, getClassFactory(), monitor, delegateListener);
614	cmd.execute();	635	cmd.execute();
615	return cmd.getStatuses();	636	return cmd.getStatuses();
616	}	637	}
617		638
618	/**	639	/**
		640	* Compares two different commit trees and returns an array of file
		641	* modifications between <code>revisionFirst</code> and <code>revisionSecond</code>
		642	*
		643	* @param roots root folders or files to search under
		644	* @param revisionFirst first revision to compare
		645	* @param revisionSecond second revision to compare
		646	* @return status array
		647	* @throws GitException an unexpected error occurs
		648	* @since 1.9
		649	*/
		650	public Map<File, GitFileInfo> getStatus (File[] roots, String revisionFirst, String revisionSecond, ProgressMonitor monitor) throws GitException {
		651	Repository repository = gitRepository.getRepository();
		652	CompareCommand cmd = new CompareCommand(repository, revisionFirst, revisionSecond, roots,
		653	getClassFactory(), monitor);
		654	cmd.execute();
		655	return cmd.getFileDifferences();
		656	}
		657
		658	/**
619	* Returns remote configuration set up for this repository identified by a given remoteName	659	* Returns remote configuration set up for this repository identified by a given remoteName
620	* @param remoteName name under which the remote is stored in repository's config file	660	* @param remoteName name under which the remote is stored in repository's config file
621	* @param monitor progress monitor	661	* @param monitor progress monitor




import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.diff.RenameDetector;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Repository;

import org.eclipse.jgit.treewalk.filter.AndTreeFilter;
import org.eclipse.jgit.treewalk.filter.PathFilter;
import org.eclipse.jgit.treewalk.filter.TreeFilter;
import org.netbeans.libs.git.jgit.Utils;

/**
 * Provides information about a certain commit, usually is returned by 

        RevWalk revWalk = new RevWalk(repository);
        TreeWalk walk = new TreeWalk(repository);
        try {
            List<GitFileInfo> result;
            walk.reset();
            walk.setRecursive(true);
            RevCommit parentCommit = null;

            walk.addTree(revCommit.getTree().getId());
            walk.setFilter(AndTreeFilter.create(TreeFilter.ANY_DIFF, PathFilter.ANY_DIFF));
            if (parentCommit != null) {
                result = Utils.getDiffEntries(repository, walk, GitClassFactoryImpl.getInstance());
                RenameDetector rd = new RenameDetector(repository);
                rd.addAll(entries);
                entries = rd.compute();
                for (DiffEntry e : entries) {
                    GitFileInfo.Status status;
                    File oldFile = null;
                    String oldPath = null;
                    String path = e.getOldPath();
                    if (path == null) {
                        path = e.getNewPath();
                    }
                    switch (e.getChangeType()) {
                        case ADD:
                            status = GitFileInfo.Status.ADDED;
                            path = e.getNewPath();
                            break;
                        case COPY:
                            status = GitFileInfo.Status.COPIED;
                            oldFile = new File(repository.getWorkTree(), e.getOldPath());
                            oldPath = e.getOldPath();
                            path = e.getNewPath();
                            break;
                        case DELETE:
                            status = GitFileInfo.Status.REMOVED;
                            path = e.getOldPath();
                            break;
                        case MODIFY:
                            status = GitFileInfo.Status.MODIFIED;
                            path = e.getOldPath();
                            break;
                        case RENAME:
                            status = GitFileInfo.Status.RENAMED;
                            oldFile = new File(repository.getWorkTree(), e.getOldPath());
                            oldPath = e.getOldPath();
                            path = e.getNewPath();
                            break;
                        default:
                            status = GitFileInfo.Status.UNKNOWN;
                    }
                    if (status == GitFileInfo.Status.RENAMED) {
                        result.add(new GitFileInfo(new File(repository.getWorkTree(), e.getOldPath()), e.getOldPath(), GitFileInfo.Status.REMOVED, null, null));
                    }
                    result.add(new GitFileInfo(new File(repository.getWorkTree(), path), path, status, oldFile, oldPath));
                }
            } else {
                result = new ArrayList<GitFileInfo>();
                while (walk.next()) {
                    result.add(new GitFileInfo(new File(repository.getWorkTree(), walk.getPathString()), walk.getPathString(), GitFileInfo.Status.ADDED, null, null));
                }

Lines 69-74 Link Here

(-)a/libs.git/src/org/netbeans/libs/git/jgit/GitClassFactory.java (+3 lines)
69	import org.netbeans.libs.git.GitRemoteConfig;	69	import org.netbeans.libs.git.GitRemoteConfig;
70	import org.netbeans.libs.git.GitRevertResult;	70	import org.netbeans.libs.git.GitRevertResult;
71	import org.netbeans.libs.git.GitRevisionInfo;	71	import org.netbeans.libs.git.GitRevisionInfo;
		72	import org.netbeans.libs.git.GitRevisionInfo.GitFileInfo;
72	import org.netbeans.libs.git.GitStatus;	73	import org.netbeans.libs.git.GitStatus;
73	import org.netbeans.libs.git.GitStatus.Status;	74	import org.netbeans.libs.git.GitStatus.Status;
74	import org.netbeans.libs.git.GitTag;	75	import org.netbeans.libs.git.GitTag;
Lines 86-91 Link Here
86	public abstract GitBranch createBranch (String name, boolean remote, boolean active, ObjectId id);	87	public abstract GitBranch createBranch (String name, boolean remote, boolean active, ObjectId id);
87		88
88	public abstract GitConflictDescriptor createConflictDescriptor (Type type);	89	public abstract GitConflictDescriptor createConflictDescriptor (Type type);
		90
		91	public abstract GitFileInfo createFileInfo (File file, String oldPath, GitFileInfo.Status status, File originalFile, String originalPath);
89		92
90	public abstract GitMergeResult createMergeResult (MergeResult mergeResult, File workTree);	93	public abstract GitMergeResult createMergeResult (MergeResult mergeResult, File workTree);
91		94

Lines 55-60 Link Here

(-)a/libs.git/src/org/netbeans/libs/git/jgit/Utils.java (+54 lines)
55	import java.util.ResourceBundle;	55	import java.util.ResourceBundle;
56	import java.util.logging.Level;	56	import java.util.logging.Level;
57	import java.util.logging.Logger;	57	import java.util.logging.Logger;
		58	import org.eclipse.jgit.diff.DiffEntry;
		59	import org.eclipse.jgit.diff.RenameDetector;
58	import org.eclipse.jgit.errors.AmbiguousObjectException;	60	import org.eclipse.jgit.errors.AmbiguousObjectException;
59	import org.eclipse.jgit.errors.IncorrectObjectTypeException;	61	import org.eclipse.jgit.errors.IncorrectObjectTypeException;
60	import org.eclipse.jgit.errors.MissingObjectException;	62	import org.eclipse.jgit.errors.MissingObjectException;
Lines 79-84 Link Here
79	import org.netbeans.libs.git.GitBranch;	81	import org.netbeans.libs.git.GitBranch;
80	import org.netbeans.libs.git.GitException;	82	import org.netbeans.libs.git.GitException;
81	import org.netbeans.libs.git.GitObjectType;	83	import org.netbeans.libs.git.GitObjectType;
		84	import org.netbeans.libs.git.GitRevisionInfo;
		85	import org.netbeans.libs.git.GitRevisionInfo.GitFileInfo;
82		86
83	/**	87	/**
84	*	88	*
Lines 119-124 Link Here
119	return filter;	123	return filter;
120	}	124	}
121		125
		126	public static List<GitFileInfo> getDiffEntries (Repository repository, TreeWalk walk, GitClassFactory fac) throws IOException {
		127	List<GitFileInfo> result = new ArrayList<GitFileInfo>();
		128	List<DiffEntry> entries = DiffEntry.scan(walk);
		129	RenameDetector rd = new RenameDetector(repository);
		130	rd.addAll(entries);
		131	entries = rd.compute();
		132	for (DiffEntry e : entries) {
		133	GitRevisionInfo.GitFileInfo.Status status;
		134	File oldFile = null;
		135	String oldPath = null;
		136	String path = e.getOldPath();
		137	if (path == null) {
		138	path = e.getNewPath();
		139	}
		140	switch (e.getChangeType()) {
		141	case ADD:
		142	status = GitRevisionInfo.GitFileInfo.Status.ADDED;
		143	path = e.getNewPath();
		144	break;
		145	case COPY:
		146	status = GitRevisionInfo.GitFileInfo.Status.COPIED;
		147	oldFile = new File(repository.getWorkTree(), e.getOldPath());
		148	oldPath = e.getOldPath();
		149	path = e.getNewPath();
		150	break;
		151	case DELETE:
		152	status = GitRevisionInfo.GitFileInfo.Status.REMOVED;
		153	path = e.getOldPath();
		154	break;
		155	case MODIFY:
		156	status = GitRevisionInfo.GitFileInfo.Status.MODIFIED;
		157	path = e.getOldPath();
		158	break;
		159	case RENAME:
		160	status = GitRevisionInfo.GitFileInfo.Status.RENAMED;
		161	oldFile = new File(repository.getWorkTree(), e.getOldPath());
		162	oldPath = e.getOldPath();
		163	path = e.getNewPath();
		164	break;
		165	default:
		166	status = GitRevisionInfo.GitFileInfo.Status.UNKNOWN;
		167	}
		168	if (status == GitRevisionInfo.GitFileInfo.Status.RENAMED) {
		169	result.add(fac.createFileInfo(new File(repository.getWorkTree(), e.getOldPath()), e.getOldPath(), GitRevisionInfo.GitFileInfo.Status.REMOVED, null, null));
		170	}
		171	result.add(fac.createFileInfo(new File(repository.getWorkTree(), path), path, status, oldFile, oldPath));
		172	}
		173	return result;
		174	}
		175
122	private static Collection<PathFilter> getPathFilters (Collection<String> relativePaths) {	176	private static Collection<PathFilter> getPathFilters (Collection<String> relativePaths) {
123	Collection<PathFilter> filters = new LinkedList<PathFilter>();	177	Collection<PathFilter> filters = new LinkedList<PathFilter>();
124	for (String path : relativePaths) {	178	for (String path : relativePaths) {




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2010 Sun Microsystems, Inc.
 */

package org.netbeans.libs.git.jgit.commands;

import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.treewalk.*;
import org.eclipse.jgit.treewalk.filter.AndTreeFilter;
import org.eclipse.jgit.treewalk.filter.PathFilter;
import org.eclipse.jgit.treewalk.filter.PathFilterGroup;
import org.eclipse.jgit.treewalk.filter.TreeFilter;
import org.netbeans.libs.git.GitException;
import org.netbeans.libs.git.GitRevisionInfo;
import org.netbeans.libs.git.jgit.GitClassFactory;
import org.netbeans.libs.git.jgit.Utils;
import org.netbeans.libs.git.progress.ProgressMonitor;

/**
 *
 * @author ondra
 */
public class CompareCommand extends GitCommand {
    private final LinkedHashMap<File, GitRevisionInfo.GitFileInfo> statuses;
    private final File[] roots;
    private final String revisionFirst;
    private final String revisionSecond;

    public CompareCommand (Repository repository, String revisionFirst, String revisionSecond, File[] roots,
            GitClassFactory gitFactory, ProgressMonitor monitor) {
        super(repository, gitFactory, monitor);
        this.roots = roots;
        this.revisionFirst = revisionFirst;
        this.revisionSecond = revisionSecond;
        statuses = new LinkedHashMap<File, GitRevisionInfo.GitFileInfo>();
    }

    @Override
    protected String getCommandDescription () {
        StringBuilder sb = new StringBuilder("git diff --raw"); //NOI18N
        sb.append(revisionFirst).append(' ').append(revisionSecond);                
        for (File root : roots) {
            sb.append(" ").append(root.getAbsolutePath());
        }
        return sb.toString();
    }

    @Override
    protected boolean prepareCommand () throws GitException {
        return getRepository().getDirectory().exists();
    }

    @Override
    protected void run () throws GitException {
        Repository repository = getRepository();
        TreeWalk walk = new TreeWalk(repository);
        try {
            walk.reset();
            walk.setRecursive(true);
            walk.addTree(Utils.findCommit(repository, revisionFirst).getTree());
            walk.addTree(Utils.findCommit(repository, revisionSecond).getTree());
            Collection<PathFilter> pathFilters = Utils.getPathFilters(repository.getWorkTree(), roots);
            if (pathFilters.isEmpty()) {
                walk.setFilter(AndTreeFilter.create(TreeFilter.ANY_DIFF, PathFilter.ANY_DIFF));
            } else {
                walk.setFilter(AndTreeFilter.create(new TreeFilter[] { 
                    TreeFilter.ANY_DIFF,
                    PathFilter.ANY_DIFF,
                    PathFilterGroup.create(pathFilters)
                }));
            }
            List<GitRevisionInfo.GitFileInfo> infos = Utils.getDiffEntries(repository, walk, getClassFactory());
            for (GitRevisionInfo.GitFileInfo info : infos) {
                statuses.put(info.getFile(), info);
            }
        } catch (IOException ex) {
            throw new GitException(ex);
        } finally {
            walk.release();
        }
    }

    public Map<File, GitRevisionInfo.GitFileInfo> getFileDifferences () {
        return statuses;
    }
}

Lines 49-54 Link Here

(-)a/libs.git/src/org/netbeans/libs/git/jgit/commands/ConflictCommand.java (-1 / +2 lines)
49	import org.eclipse.jgit.dircache.DirCacheEntry;	49	import org.eclipse.jgit.dircache.DirCacheEntry;
50	import org.eclipse.jgit.dircache.DirCacheIterator;	50	import org.eclipse.jgit.dircache.DirCacheIterator;
51	import org.eclipse.jgit.errors.CorruptObjectException;	51	import org.eclipse.jgit.errors.CorruptObjectException;
		52	import org.eclipse.jgit.lib.Constants;
52	import org.eclipse.jgit.lib.Repository;	53	import org.eclipse.jgit.lib.Repository;
53	import org.eclipse.jgit.treewalk.TreeWalk;	54	import org.eclipse.jgit.treewalk.TreeWalk;
54	import org.eclipse.jgit.treewalk.filter.PathFilter;	55	import org.eclipse.jgit.treewalk.filter.PathFilter;
Lines 72-78 Link Here
72	private final File[] roots;	73	private final File[] roots;
73		74
74	public ConflictCommand (Repository repository, GitClassFactory gitFactory, File[] roots, ProgressMonitor monitor, StatusListener listener) {	75	public ConflictCommand (Repository repository, GitClassFactory gitFactory, File[] roots, ProgressMonitor monitor, StatusListener listener) {
75	super(repository, gitFactory, roots, monitor, listener);	76	super(repository, Constants.HEAD, roots, gitFactory, monitor, listener);
76	this.monitor = monitor;	77	this.monitor = monitor;
77	this.listener = listener;	78	this.listener = listener;
78	this.roots = roots;	79	this.roots = roots;

Lines 162-169 Link Here

(-)a/libs.git/src/org/netbeans/libs/git/jgit/commands/RebaseCommand.java (-2 / +2 lines)
162	Repository repository = getRepository();	162	Repository repository = getRepository();
163	GitRevisionInfo info = getClassFactory().createRevisionInfo(currentCommit, repository);	163	GitRevisionInfo info = getClassFactory().createRevisionInfo(currentCommit, repository);
164	Map<File, GitRevisionInfo.GitFileInfo> modifiedFiles = info.getModifiedFiles();	164	Map<File, GitRevisionInfo.GitFileInfo> modifiedFiles = info.getModifiedFiles();
165	StatusCommand cmd = new StatusCommand(repository, getClassFactory(), modifiedFiles.keySet().toArray(	165	StatusCommand cmd = new StatusCommand(repository, Constants.HEAD, modifiedFiles.keySet().toArray(
166	new File[modifiedFiles.keySet().size()]),	166	new File[modifiedFiles.keySet().size()]), getClassFactory(),
167	new DelegatingGitProgressMonitor(monitor),	167	new DelegatingGitProgressMonitor(monitor),
168	new StatusListener() {	168	new StatusListener() {
169	@Override	169	@Override




    private final File[] roots;
    private final ProgressMonitor monitor;
    private final StatusListener listener;
    private final String revision;
    private static final String PROP_TRACK_SYMLINKS = "org.netbeans.libs.git.trackSymLinks"; //NOI18N

    public StatusCommand (Repository repository, String revision, File[] roots, GitClassFactory gitFactory,
            ProgressMonitor monitor, StatusListener listener) {
        super(repository, gitFactory, monitor);
        this.roots = roots;
        this.monitor = monitor;
        this.listener = listener;
        this.revision = revision;
        statuses = new LinkedHashMap<File, GitStatus>();
    }

    @Override
    protected String getCommandDescription () {
        StringBuilder sb = new StringBuilder("git "); //NOI18N
        if (Constants.HEAD.equals(revision)) {
             sb.append("status"); //NOI18N
        } else {
             sb.append("diff --raw"); //NOI18N
        }
        for (File root : roots) {
            sb.append(" ").append(root.getAbsolutePath());
        }

            try {
                String workTreePath = repository.getWorkTree().getAbsolutePath();
                Collection<PathFilter> pathFilters = Utils.getPathFilters(repository.getWorkTree(), roots);
                ObjectId commitId = Utils.parseObjectId(repository, revision);
                Map<String, DiffEntry> renames = detectRenames(repository, cache, commitId);
                TreeWalk treeWalk = new TreeWalk(repository);
                if (!pathFilters.isEmpty()) {
                    treeWalk.setFilter(PathFilterGroup.create(pathFilters));
                }
                treeWalk.setRecursive(false);
                treeWalk.reset();
                if (commitId != null) {
                    treeWalk.addTree(new RevWalk(repository).parseTree(commitId));
                    treeWalk.addTree(new RevWalk(repository).parseTree(headId));
                } else {
                    treeWalk.addTree(new EmptyTreeIterator());
                }

                treeWalk.addTree(new DirCacheIterator(cache));
                // Working directory
                treeWalk.addTree(new FileTreeIterator(repository));
                final int T_COMMIT = 0;
                final int T_INDEX = 1;
                final int T_WORKSPACE = 2;
                String lastPath = null;

                    }
                    lastPath = path;
                    File file = new File(workTreePath + File.separator + path);
                    int mHead = treeWalk.getRawMode(T_COMMIT);
                    int mIndex = treeWalk.getRawMode(T_INDEX);
                    int mWorking = treeWalk.getRawMode(T_WORKSPACE);
                    GitStatus.Status statusHeadIndex;

                        statusHeadIndex = GitStatus.Status.STATUS_ADDED;
                    } else if (mIndex == FileMode.MISSING.getBits() && mHead != FileMode.MISSING.getBits()) {
                        statusHeadIndex = GitStatus.Status.STATUS_REMOVED;
                    } else if (mHead != mIndex || (mIndex != FileMode.TREE.getBits() && !treeWalk.idEqual(T_COMMIT, T_INDEX))) {
                        statusHeadIndex = GitStatus.Status.STATUS_MODIFIED;
                    } else {
                        statusHeadIndex = GitStatus.Status.STATUS_NORMAL;

                                    && (indexEntry == null || !indexEntry.isAssumeValid()) //no update-index --assume-unchanged
                                    // head vs wt can be modified only when head vs index or index vs wt are modified, otherwise it's probably line-endings issue
                                    && (statusIndexWC != GitStatus.Status.STATUS_NORMAL || statusHeadIndex != GitStatus.Status.STATUS_NORMAL)
                                    && !treeWalk.getObjectId(T_COMMIT).equals(fti.getEntryObjectId())))) {
                            statusHeadWC = GitStatus.Status.STATUS_MODIFIED;
                        } else {
                            statusHeadWC = GitStatus.Status.STATUS_NORMAL;

        return statuses;
    }

    private Map<String, DiffEntry> detectRenames (Repository repository, DirCache cache, ObjectId commitId) {
        List<DiffEntry> entries;
        TreeWalk treeWalk = new TreeWalk(repository);
        try {
            treeWalk.setRecursive(true);
            treeWalk.reset();
            if (commitId != null) {
                treeWalk.addTree(new RevWalk(repository).parseTree(commitId));
                treeWalk.addTree(new RevWalk(repository).parseTree(headId));
            } else {
                treeWalk.addTree(new EmptyTreeIterator());
            }




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2010 Sun Microsystems, Inc.
 */

package org.netbeans.libs.git.jgit.commands;

import java.io.File;
import java.io.IOException;
import java.util.Map;
import static junit.framework.Assert.assertEquals;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Repository;
import org.netbeans.libs.git.GitClient;
import org.netbeans.libs.git.GitRevisionInfo;
import org.netbeans.libs.git.GitRevisionInfo.GitFileInfo.Status;
import org.netbeans.libs.git.jgit.AbstractGitTestCase;

/**
 *
 * @author ondra
 */
public class CompareCommitTest extends AbstractGitTestCase {
    private Repository repository;
    private File workDir;

    public CompareCommitTest (String testName) throws IOException {
        super(testName);
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        workDir = getWorkingDirectory();
        repository = getRepository(getLocalGitRepository());
    }
    
    public void testCompareSimple () throws Exception {
        File file = new File(workDir, "file");
        File[] files = new File[] { file };
        write(file, "init\n");
        add(files);
        commit(files);
        
        GitClient client = getClient(workDir);
        String revision1 = client.getBranches(false, NULL_PROGRESS_MONITOR).get(Constants.MASTER).getId();
        write(file, "modification\n");
        add(files);
        GitRevisionInfo revision2 = client.commit(files, "my commit message", null, null, NULL_PROGRESS_MONITOR);
        Map<File, GitRevisionInfo.GitFileInfo> statuses = client.getStatus(files, Constants.HEAD, revision1, NULL_PROGRESS_MONITOR);
        assertEquals(1, statuses.size());
        assertEquals(Status.MODIFIED, statuses.get(file).getStatus());
        
        write(file, "modification 2\n");
        add(files);
        GitRevisionInfo revision3 = client.commit(files, "my commit 3 message", null, null, NULL_PROGRESS_MONITOR);
        statuses = client.getStatus(files, revision1, Constants.HEAD, NULL_PROGRESS_MONITOR);
        assertEquals(1, statuses.size());
        assertEquals(Status.MODIFIED, statuses.get(file).getStatus());
        
        statuses = client.getStatus(files, revision1, revision3.getRevision(), NULL_PROGRESS_MONITOR);
        assertEquals(1, statuses.size());
        assertEquals(Status.MODIFIED, statuses.get(file).getStatus());
        
        statuses = client.getStatus(files, revision2.getRevision(), revision3.getRevision(), NULL_PROGRESS_MONITOR);
        assertEquals(1, statuses.size());
        assertEquals(Status.MODIFIED, statuses.get(file).getStatus());
    }
    
    public void testCompareRevertModification () throws Exception {
        File file = new File(workDir, "file");
        File[] files = new File[] { file };
        write(file, "init\n");
        add(files);
        commit(files);
        
        GitClient client = getClient(workDir);
        String revision1 = client.getBranches(false, NULL_PROGRESS_MONITOR).get(Constants.MASTER).getId();
        write(file, "modification\n");
        add(files);
        GitRevisionInfo revision2 = client.commit(files, "my commit message", null, null, NULL_PROGRESS_MONITOR);
        
        write(file, "init\n");
        add(files);
        GitRevisionInfo revision3 = client.commit(files, "my commit 3 message", null, null, NULL_PROGRESS_MONITOR);
        Map<File, GitRevisionInfo.GitFileInfo> statuses = client.getStatus(files, revision1, Constants.HEAD, NULL_PROGRESS_MONITOR);
        assertTrue(statuses.isEmpty());
    }
    
    public void testCompareSelection () throws Exception {
        File file = new File(workDir, "file");
        File file2 = new File(workDir, "file2");
        File[] files = new File[] { file, file2 };
        write(file, "init\n");
        add(files);
        commit(files);
        
        GitClient client = getClient(workDir);
        String revision1 = client.getBranches(false, NULL_PROGRESS_MONITOR).get(Constants.MASTER).getId();
        write(file, "modification\n");
        add(files);
        GitRevisionInfo revision2 = client.commit(files, "my commit message", null, null, NULL_PROGRESS_MONITOR);
        
        write(file2, "adding file 2\n");
        add(files);
        GitRevisionInfo revision3 = client.commit(files, "adding file 2", null, null, NULL_PROGRESS_MONITOR);
        Map<File, GitRevisionInfo.GitFileInfo> statuses = client.getStatus(new File[] { file }, revision1, revision3.getRevision(), NULL_PROGRESS_MONITOR);
        assertEquals(1, statuses.size());
        assertEquals(Status.MODIFIED, statuses.get(file).getStatus());
        
        statuses = client.getStatus(new File[] { file2 }, revision1, revision3.getRevision(), NULL_PROGRESS_MONITOR);
        assertEquals(1, statuses.size());
        assertEquals(Status.ADDED, statuses.get(file2).getStatus());
        
        statuses = client.getStatus(files, revision1, revision3.getRevision(), NULL_PROGRESS_MONITOR);
        assertEquals(2, statuses.size());
        assertEquals(Status.MODIFIED, statuses.get(file).getStatus());
        assertEquals(Status.ADDED, statuses.get(file2).getStatus());
    }
    
    public void testCompareRename () throws Exception {
        File file = new File(workDir, "file");
        File file2 = new File(workDir, "file2");
        File[] files = new File[] { file, file2 };
        write(file, "files content\n");
        add(files);
        commit(files);
        
        GitClient client = getClient(workDir);
        String revision1 = client.getBranches(false, NULL_PROGRESS_MONITOR).get(Constants.MASTER).getId();
        remove(false, file);
        
        client.commit(files, "removing file", null, null, NULL_PROGRESS_MONITOR);
        
        write(file2, "files content\n");
        add(files);
        GitRevisionInfo revision3 = client.commit(files, "adding file as file2", null, null, NULL_PROGRESS_MONITOR);
        Map<File, GitRevisionInfo.GitFileInfo> statuses = client.getStatus(files, revision1, revision3.getRevision(), NULL_PROGRESS_MONITOR);
        assertEquals(2, statuses.size());
        assertEquals(Status.REMOVED, statuses.get(file).getStatus());
        assertEquals(Status.RENAMED, statuses.get(file2).getStatus());
        assertEquals(file, statuses.get(file2).getOriginalFile());
    }
}




import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import static junit.framework.Assert.assertFalse;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheBuilder;
import org.eclipse.jgit.dircache.DirCacheEntry;
import org.eclipse.jgit.lib.ConfigConstants;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.StoredConfig;
import org.netbeans.libs.git.GitClient;

        // what about isIgnored() here?
        assertStatus(statuses, workDir, ignored, false, Status.STATUS_NORMAL, Status.STATUS_IGNORED, Status.STATUS_ADDED, false, listener);
    }
    
    // diff WT against a commit other than HEAD
    public void testMiscStatusCommit () throws Exception {
        write(new File(workDir, ".gitignore"), "ignored");
        File untracked = new File(workDir, "untracked");
        write(untracked, "untracked");
        File ignored = new File(workDir, "ignored");
        write(ignored, "ignored");
        File added_uptodate = new File(workDir, "added-uptodate");
        write(added_uptodate, "added-uptodate");
        File added_modified = new File(workDir, "added-modified");
        write(added_modified, "added_modified");
        File added_deleted = new File(workDir, "added-deleted");
        write(added_deleted, "added_deleted");

        File uptodate_uptodate = new File(workDir, "uptodate-uptodate");
        write(uptodate_uptodate, "uptodate_uptodate");
        File uptodate_modified = new File(workDir, "uptodate-modified");
        write(uptodate_modified, "uptodate_modified");
        File uptodate_deleted = new File(workDir, "uptodate-deleted");
        write(uptodate_deleted, "uptodate_deleted");

        File modified_uptodate = new File(workDir, "modified-uptodate");
        write(modified_uptodate, "modified_uptodate");
        File modified_modified = new File(workDir, "modified-modified");
        write(modified_modified, "modified_modified");
        File modified_reset = new File(workDir, "modified-reset");
        write(modified_reset, "modified_reset");
        File modified_deleted = new File(workDir, "modified-deleted");
        write(modified_deleted, "modified_deleted");

        // we cannot
        File deleted_uptodate = new File(workDir, "deleted-uptodate");
        write(deleted_uptodate, "deleted_uptodate");
        File deleted_untracked = new File(workDir, "deleted-untracked");
        write(deleted_untracked, "deleted_untracked");
        File deleted_modified = new File(workDir, "deleted-modified");
        write(deleted_modified, "deleted_modified");

        add(uptodate_uptodate, uptodate_modified, uptodate_deleted, modified_uptodate, modified_modified, modified_reset, modified_deleted, deleted_uptodate, deleted_untracked, deleted_modified);
        commit(workDir);
        add(added_uptodate, added_modified, added_deleted);
        write(modified_deleted, "modification modified_deleted");
        write(modified_modified, "modification modified_modified");
        write(modified_reset, "modification modified_reset");
        write(modified_uptodate, "modification modified_uptodate");
        add(modified_deleted, modified_modified, modified_reset, modified_uptodate);
        deleted_uptodate.delete();
        deleted_untracked.delete();
        deleted_modified.delete();
        remove(true, deleted_uptodate, deleted_untracked, deleted_modified);
        write(added_modified, "modification2 added_modified");
        write(uptodate_modified, "modification2 uptodate_modified");
        write(modified_modified, "modification2 modified_modified");
        write(modified_reset, "modified_reset");
        added_deleted.delete();
        modified_deleted.delete();
        uptodate_deleted.delete();
        write(deleted_untracked, "deleted_untracked");
        write(deleted_modified, "deleted_modified\nchange");
        
        GitClient client = getClient(workDir);
        String revId = client.getBranches(false, NULL_PROGRESS_MONITOR).get(Constants.MASTER).getId();
        
        File someFile = new File(workDir, "fileforothercommit");
        write(someFile, "fileforothercommit");
        add(someFile);
        commit(someFile);

        TestStatusListener listener = new TestStatusListener();
        client.addNotificationListener(listener);
        Map<File, GitStatus> statuses = client.getStatus(new File[] { workDir }, Constants.HEAD, NULL_PROGRESS_MONITOR);
        assertFalse(statuses.isEmpty());
        assertStatus(statuses, workDir, untracked, false, Status.STATUS_NORMAL, Status.STATUS_ADDED, Status.STATUS_ADDED, false, listener);
        assertStatus(statuses, workDir, added_uptodate, true, Status.STATUS_ADDED, Status.STATUS_NORMAL, Status.STATUS_ADDED, false, listener);
        assertStatus(statuses, workDir, added_modified, true, Status.STATUS_ADDED, Status.STATUS_MODIFIED, Status.STATUS_ADDED, false, listener);
        assertStatus(statuses, workDir, added_deleted, true, Status.STATUS_ADDED, Status.STATUS_REMOVED, Status.STATUS_NORMAL, false, listener);
        assertStatus(statuses, workDir, uptodate_uptodate, true, Status.STATUS_NORMAL, Status.STATUS_NORMAL, Status.STATUS_NORMAL, false, listener);
        assertStatus(statuses, workDir, uptodate_modified, true, Status.STATUS_NORMAL, Status.STATUS_MODIFIED, Status.STATUS_MODIFIED, false, listener);
        assertStatus(statuses, workDir, uptodate_deleted, true, Status.STATUS_NORMAL, Status.STATUS_REMOVED, Status.STATUS_REMOVED, false, listener);
        assertStatus(statuses, workDir, modified_uptodate, true, Status.STATUS_MODIFIED, Status.STATUS_NORMAL, Status.STATUS_MODIFIED, false, listener);
        assertStatus(statuses, workDir, modified_modified, true, Status.STATUS_MODIFIED, Status.STATUS_MODIFIED, Status.STATUS_MODIFIED, false, listener);
        assertStatus(statuses, workDir, modified_reset, true, Status.STATUS_MODIFIED, Status.STATUS_MODIFIED, Status.STATUS_NORMAL, false, listener);
        assertStatus(statuses, workDir, modified_deleted, true, Status.STATUS_MODIFIED, Status.STATUS_REMOVED, Status.STATUS_REMOVED, false, listener);
        assertStatus(statuses, workDir, deleted_uptodate, true, Status.STATUS_REMOVED, Status.STATUS_NORMAL, Status.STATUS_REMOVED, false, listener);
        assertStatus(statuses, workDir, deleted_untracked, true, Status.STATUS_REMOVED, Status.STATUS_ADDED, Status.STATUS_NORMAL, false, listener);
        assertStatus(statuses, workDir, deleted_modified, true, Status.STATUS_REMOVED, Status.STATUS_ADDED, Status.STATUS_MODIFIED, false, listener);
        assertStatus(statuses, workDir, someFile, true, Status.STATUS_NORMAL, Status.STATUS_NORMAL, Status.STATUS_NORMAL, false, listener);
        // what about isIgnored() here?
        assertStatus(statuses, workDir, ignored, false, Status.STATUS_NORMAL, Status.STATUS_IGNORED, Status.STATUS_ADDED, false, listener);
        
        listener = new TestStatusListener();
        client.addNotificationListener(listener);
        statuses = client.getStatus(new File[] { workDir }, revId, NULL_PROGRESS_MONITOR);
        assertFalse(statuses.isEmpty());
        assertStatus(statuses, workDir, untracked, false, Status.STATUS_NORMAL, Status.STATUS_ADDED, Status.STATUS_ADDED, false, listener);
        assertStatus(statuses, workDir, added_uptodate, true, Status.STATUS_ADDED, Status.STATUS_NORMAL, Status.STATUS_ADDED, false, listener);
        assertStatus(statuses, workDir, added_modified, true, Status.STATUS_ADDED, Status.STATUS_MODIFIED, Status.STATUS_ADDED, false, listener);
        assertStatus(statuses, workDir, added_deleted, true, Status.STATUS_ADDED, Status.STATUS_REMOVED, Status.STATUS_NORMAL, false, listener);
        assertStatus(statuses, workDir, uptodate_uptodate, true, Status.STATUS_NORMAL, Status.STATUS_NORMAL, Status.STATUS_NORMAL, false, listener);
        assertStatus(statuses, workDir, uptodate_modified, true, Status.STATUS_NORMAL, Status.STATUS_MODIFIED, Status.STATUS_MODIFIED, false, listener);
        assertStatus(statuses, workDir, uptodate_deleted, true, Status.STATUS_NORMAL, Status.STATUS_REMOVED, Status.STATUS_REMOVED, false, listener);
        assertStatus(statuses, workDir, modified_uptodate, true, Status.STATUS_MODIFIED, Status.STATUS_NORMAL, Status.STATUS_MODIFIED, false, listener);
        assertStatus(statuses, workDir, modified_modified, true, Status.STATUS_MODIFIED, Status.STATUS_MODIFIED, Status.STATUS_MODIFIED, false, listener);
        assertStatus(statuses, workDir, modified_reset, true, Status.STATUS_MODIFIED, Status.STATUS_MODIFIED, Status.STATUS_NORMAL, false, listener);
        assertStatus(statuses, workDir, modified_deleted, true, Status.STATUS_MODIFIED, Status.STATUS_REMOVED, Status.STATUS_REMOVED, false, listener);
        assertStatus(statuses, workDir, deleted_uptodate, true, Status.STATUS_REMOVED, Status.STATUS_NORMAL, Status.STATUS_REMOVED, false, listener);
        assertStatus(statuses, workDir, deleted_untracked, true, Status.STATUS_REMOVED, Status.STATUS_ADDED, Status.STATUS_NORMAL, false, listener);
        assertStatus(statuses, workDir, deleted_modified, true, Status.STATUS_REMOVED, Status.STATUS_ADDED, Status.STATUS_MODIFIED, false, listener);
        // what about isIgnored() here?
        assertStatus(statuses, workDir, ignored, false, Status.STATUS_NORMAL, Status.STATUS_IGNORED, Status.STATUS_ADDED, false, listener);
        // file somefile was not known in that revision
        assertStatus(statuses, workDir, someFile, true, Status.STATUS_ADDED, Status.STATUS_NORMAL, Status.STATUS_ADDED, false, listener);
    }

    public void testStatusSingleFile () throws Exception {
        File untracked = new File(workDir, "untracked");

Return to bug 227348

Lines 111-116 Link Here

(-)a/libs.git/apichanges.xml (+19 lines)
111		111
112	<change>	112	<change>
113	<api name="gitlibrary_api"/>	113	<api name="gitlibrary_api"/>
		114	<summary>Adding support comparing trees of arbitrary commits</summary>
		115	<version major="1" minor="9"/>
		116	<date day="12" month="3" year="2013"/>
		117	<author login="ovrabec"/>
		118	<compatibility addition="yes"/>
		119	<description>
		120	<ul>
		121	<li>Adding a new method GitClient.getStatus(File[], String, ProgressMonitor)
		122	allowing an API client to get statuses of local files not just against the HEAD but against
		123	an arbitrary commit.</li>
		124	<li>Adding a new method GitClient.getStatus(File[], String, String, ProgressMonitor)
		125	allowing an API client to get modifications from the Git history. It is similar to
		126	GitRevisionInfo.getModifications but returns file statuses between two arbitrary commits
		127	and not just a commit and its parent.</li>
		128	</ul>
		129	</description>
		130	</change>
		131	<change>
		132	<api name="gitlibrary_api"/>
114	<summary>Adding support for rebase to the API</summary>	133	<summary>Adding support for rebase to the API</summary>
115	<version major="1" minor="8"/>	134	<version major="1" minor="8"/>
116	<date day="11" month="3" year="2013"/>	135	<date day="11" month="3" year="2013"/>

Added Link Here

(-)236d21a95856 (+130 lines)
1	/*
2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3	*
4	* Copyright 2010 Oracle and/or its affiliates. All rights reserved.
5	*
6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
7	* Other names may be trademarks of their respective owners.
8	*
9	* The contents of this file are subject to the terms of either the GNU
10	* General Public License Version 2 only ("GPL") or the Common
11	* Development and Distribution License("CDDL") (collectively, the
12	* "License"). You may not use this file except in compliance with the
13	* License. You can obtain a copy of the License at
14	* http://www.netbeans.org/cddl-gplv2.html
15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
16	* specific language governing permissions and limitations under the
17	* License. When distributing the software, include this License Header
18	* Notice in each file and include the License file at
19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
20	* particular file as subject to the "Classpath" exception as provided
21	* by Oracle in the GPL Version 2 section of the License file that
22	* accompanied this code. If applicable, add the following below the
23	* License Header, with the fields enclosed by brackets [] replaced by
24	* your own identifying information:
25	* "Portions Copyrighted [year] [name of copyright owner]"
26	*
27	* If you wish your version of this file to be governed by only the CDDL
28	* or only the GPL Version 2, indicate your decision by adding
29	* "[Contributor] elects to include this software in this distribution
30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
31	* single choice of license, a recipient has the option to distribute
32	* your version of this file under either the CDDL, the GPL Version 2 or
33	* to extend the choice of license to its licensees as provided above.
34	* However, if you add GPL Version 2 code and therefore, elected the GPL
35	* Version 2 license, then the option applies only if the new code is
36	* made subject to such option by the copyright holder.
37	*
38	* Contributor(s):
39	*
40	* Portions Copyrighted 2010 Sun Microsystems, Inc.
41	*/
42
43	package org.netbeans.libs.git.jgit.commands;
44
45	import java.io.File;
46	import java.io.IOException;
47	import java.util.Collection;
48	import java.util.LinkedHashMap;
49	import java.util.List;
50	import java.util.Map;
51	import org.eclipse.jgit.lib.Repository;
52	import org.eclipse.jgit.treewalk.*;
53	import org.eclipse.jgit.treewalk.filter.AndTreeFilter;
54	import org.eclipse.jgit.treewalk.filter.PathFilter;
55	import org.eclipse.jgit.treewalk.filter.PathFilterGroup;
56	import org.eclipse.jgit.treewalk.filter.TreeFilter;
57	import org.netbeans.libs.git.GitException;
58	import org.netbeans.libs.git.GitRevisionInfo;
59	import org.netbeans.libs.git.jgit.GitClassFactory;
60	import org.netbeans.libs.git.jgit.Utils;
61	import org.netbeans.libs.git.progress.ProgressMonitor;
62
63	/**
64	*
65	* @author ondra
66	*/
67	public class CompareCommand extends GitCommand {
68	private final LinkedHashMap<File, GitRevisionInfo.GitFileInfo> statuses;
69	private final File[] roots;
70	private final String revisionFirst;
71	private final String revisionSecond;
72
73	public CompareCommand (Repository repository, String revisionFirst, String revisionSecond, File[] roots,
74	GitClassFactory gitFactory, ProgressMonitor monitor) {
75	super(repository, gitFactory, monitor);
76	this.roots = roots;
77	this.revisionFirst = revisionFirst;
78	this.revisionSecond = revisionSecond;
79	statuses = new LinkedHashMap<File, GitRevisionInfo.GitFileInfo>();
80	}
81
82	@Override
83	protected String getCommandDescription () {
84	StringBuilder sb = new StringBuilder("git diff --raw"); //NOI18N
85	sb.append(revisionFirst).append(' ').append(revisionSecond);
86	for (File root : roots) {
87	sb.append(" ").append(root.getAbsolutePath());
88	}
89	return sb.toString();
90	}
91
92	@Override
93	protected boolean prepareCommand () throws GitException {
94	return getRepository().getDirectory().exists();
95	}
96
97	@Override
98	protected void run () throws GitException {
99	Repository repository = getRepository();
100	TreeWalk walk = new TreeWalk(repository);
101	try {
102	walk.reset();
103	walk.setRecursive(true);
104	walk.addTree(Utils.findCommit(repository, revisionFirst).getTree());
105	walk.addTree(Utils.findCommit(repository, revisionSecond).getTree());
106	Collection<PathFilter> pathFilters = Utils.getPathFilters(repository.getWorkTree(), roots);
107	if (pathFilters.isEmpty()) {
108	walk.setFilter(AndTreeFilter.create(TreeFilter.ANY_DIFF, PathFilter.ANY_DIFF));
109	} else {
110	walk.setFilter(AndTreeFilter.create(new TreeFilter[] {
111	TreeFilter.ANY_DIFF,
112	PathFilter.ANY_DIFF,
113	PathFilterGroup.create(pathFilters)
114	}));
115	}
116	List<GitRevisionInfo.GitFileInfo> infos = Utils.getDiffEntries(repository, walk, getClassFactory());
117	for (GitRevisionInfo.GitFileInfo info : infos) {
118	statuses.put(info.getFile(), info);
119	}
120	} catch (IOException ex) {
121	throw new GitException(ex);
122	} finally {
123	walk.release();
124	}
125	}
126
127	public Map<File, GitRevisionInfo.GitFileInfo> getFileDifferences () {
128	return statuses;
129	}
130	}

Lines 53-58 Link Here

(-)a/libs.git/test/unit/src/org/netbeans/libs/git/jgit/CommandsTestSuite.java (+2 lines)
53	import org.netbeans.libs.git.jgit.commands.CheckoutTest;	53	import org.netbeans.libs.git.jgit.commands.CheckoutTest;
54	import org.netbeans.libs.git.jgit.commands.CleanTest;	54	import org.netbeans.libs.git.jgit.commands.CleanTest;
55	import org.netbeans.libs.git.jgit.commands.CommitTest;	55	import org.netbeans.libs.git.jgit.commands.CommitTest;
		56	import org.netbeans.libs.git.jgit.commands.CompareCommitTest;
56	import org.netbeans.libs.git.jgit.commands.CopyTest;	57	import org.netbeans.libs.git.jgit.commands.CopyTest;
57	import org.netbeans.libs.git.jgit.commands.ExportCommitTest;	58	import org.netbeans.libs.git.jgit.commands.ExportCommitTest;
58	import org.netbeans.libs.git.jgit.commands.ExportDiffTest;	59	import org.netbeans.libs.git.jgit.commands.ExportDiffTest;
Lines 97-102 Link Here
97	suite.addTestSuite(CheckoutTest.class);	98	suite.addTestSuite(CheckoutTest.class);
98	suite.addTestSuite(CleanTest.class);	99	suite.addTestSuite(CleanTest.class);
99	suite.addTestSuite(CommitTest.class);	100	suite.addTestSuite(CommitTest.class);
		101	suite.addTestSuite(CompareCommitTest.class);
100	suite.addTestSuite(CopyTest.class);	102	suite.addTestSuite(CopyTest.class);
101	suite.addTestSuite(ExportCommitTest.class);	103	suite.addTestSuite(ExportCommitTest.class);
102	suite.addTestSuite(ExportDiffTest.class);	104	suite.addTestSuite(ExportDiffTest.class);

Added Link Here

(-)236d21a95856 (+181 lines)
1	/*
2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3	*
4	* Copyright 2010 Oracle and/or its affiliates. All rights reserved.
5	*
6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
7	* Other names may be trademarks of their respective owners.
8	*
9	* The contents of this file are subject to the terms of either the GNU
10	* General Public License Version 2 only ("GPL") or the Common
11	* Development and Distribution License("CDDL") (collectively, the
12	* "License"). You may not use this file except in compliance with the
13	* License. You can obtain a copy of the License at
14	* http://www.netbeans.org/cddl-gplv2.html
15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
16	* specific language governing permissions and limitations under the
17	* License. When distributing the software, include this License Header
18	* Notice in each file and include the License file at
19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
20	* particular file as subject to the "Classpath" exception as provided
21	* by Oracle in the GPL Version 2 section of the License file that
22	* accompanied this code. If applicable, add the following below the
23	* License Header, with the fields enclosed by brackets [] replaced by
24	* your own identifying information:
25	* "Portions Copyrighted [year] [name of copyright owner]"
26	*
27	* If you wish your version of this file to be governed by only the CDDL
28	* or only the GPL Version 2, indicate your decision by adding
29	* "[Contributor] elects to include this software in this distribution
30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
31	* single choice of license, a recipient has the option to distribute
32	* your version of this file under either the CDDL, the GPL Version 2 or
33	* to extend the choice of license to its licensees as provided above.
34	* However, if you add GPL Version 2 code and therefore, elected the GPL
35	* Version 2 license, then the option applies only if the new code is
36	* made subject to such option by the copyright holder.
37	*
38	* Contributor(s):
39	*
40	* Portions Copyrighted 2010 Sun Microsystems, Inc.
41	*/
42
43	package org.netbeans.libs.git.jgit.commands;
44
45	import java.io.File;
46	import java.io.IOException;
47	import java.util.Map;
48	import static junit.framework.Assert.assertEquals;
49	import org.eclipse.jgit.lib.Constants;
50	import org.eclipse.jgit.lib.Repository;
51	import org.netbeans.libs.git.GitClient;
52	import org.netbeans.libs.git.GitRevisionInfo;
53	import org.netbeans.libs.git.GitRevisionInfo.GitFileInfo.Status;
54	import org.netbeans.libs.git.jgit.AbstractGitTestCase;
55
56	/**
57	*
58	* @author ondra
59	*/
60	public class CompareCommitTest extends AbstractGitTestCase {
61	private Repository repository;
62	private File workDir;
63
64	public CompareCommitTest (String testName) throws IOException {
65	super(testName);
66	}
67
68	@Override
69	protected void setUp() throws Exception {
70	super.setUp();
71	workDir = getWorkingDirectory();
72	repository = getRepository(getLocalGitRepository());
73	}
74
75	public void testCompareSimple () throws Exception {
76	File file = new File(workDir, "file");
77	File[] files = new File[] { file };
78	write(file, "init\n");
79	add(files);
80	commit(files);
81
82	GitClient client = getClient(workDir);
83	String revision1 = client.getBranches(false, NULL_PROGRESS_MONITOR).get(Constants.MASTER).getId();
84	write(file, "modification\n");
85	add(files);
86	GitRevisionInfo revision2 = client.commit(files, "my commit message", null, null, NULL_PROGRESS_MONITOR);
87	Map<File, GitRevisionInfo.GitFileInfo> statuses = client.getStatus(files, Constants.HEAD, revision1, NULL_PROGRESS_MONITOR);
88	assertEquals(1, statuses.size());
89	assertEquals(Status.MODIFIED, statuses.get(file).getStatus());
90
91	write(file, "modification 2\n");
92	add(files);
93	GitRevisionInfo revision3 = client.commit(files, "my commit 3 message", null, null, NULL_PROGRESS_MONITOR);
94	statuses = client.getStatus(files, revision1, Constants.HEAD, NULL_PROGRESS_MONITOR);
95	assertEquals(1, statuses.size());
96	assertEquals(Status.MODIFIED, statuses.get(file).getStatus());
97
98	statuses = client.getStatus(files, revision1, revision3.getRevision(), NULL_PROGRESS_MONITOR);
99	assertEquals(1, statuses.size());
100	assertEquals(Status.MODIFIED, statuses.get(file).getStatus());
101
102	statuses = client.getStatus(files, revision2.getRevision(), revision3.getRevision(), NULL_PROGRESS_MONITOR);
103	assertEquals(1, statuses.size());
104	assertEquals(Status.MODIFIED, statuses.get(file).getStatus());
105	}
106
107	public void testCompareRevertModification () throws Exception {
108	File file = new File(workDir, "file");
109	File[] files = new File[] { file };
110	write(file, "init\n");
111	add(files);
112	commit(files);
113
114	GitClient client = getClient(workDir);
115	String revision1 = client.getBranches(false, NULL_PROGRESS_MONITOR).get(Constants.MASTER).getId();
116	write(file, "modification\n");
117	add(files);
118	GitRevisionInfo revision2 = client.commit(files, "my commit message", null, null, NULL_PROGRESS_MONITOR);
119
120	write(file, "init\n");
121	add(files);
122	GitRevisionInfo revision3 = client.commit(files, "my commit 3 message", null, null, NULL_PROGRESS_MONITOR);
123	Map<File, GitRevisionInfo.GitFileInfo> statuses = client.getStatus(files, revision1, Constants.HEAD, NULL_PROGRESS_MONITOR);
124	assertTrue(statuses.isEmpty());
125	}
126
127	public void testCompareSelection () throws Exception {
128	File file = new File(workDir, "file");
129	File file2 = new File(workDir, "file2");
130	File[] files = new File[] { file, file2 };
131	write(file, "init\n");
132	add(files);
133	commit(files);
134
135	GitClient client = getClient(workDir);
136	String revision1 = client.getBranches(false, NULL_PROGRESS_MONITOR).get(Constants.MASTER).getId();
137	write(file, "modification\n");
138	add(files);
139	GitRevisionInfo revision2 = client.commit(files, "my commit message", null, null, NULL_PROGRESS_MONITOR);
140
141	write(file2, "adding file 2\n");
142	add(files);
143	GitRevisionInfo revision3 = client.commit(files, "adding file 2", null, null, NULL_PROGRESS_MONITOR);
144	Map<File, GitRevisionInfo.GitFileInfo> statuses = client.getStatus(new File[] { file }, revision1, revision3.getRevision(), NULL_PROGRESS_MONITOR);
145	assertEquals(1, statuses.size());
146	assertEquals(Status.MODIFIED, statuses.get(file).getStatus());
147
148	statuses = client.getStatus(new File[] { file2 }, revision1, revision3.getRevision(), NULL_PROGRESS_MONITOR);
149	assertEquals(1, statuses.size());
150	assertEquals(Status.ADDED, statuses.get(file2).getStatus());
151
152	statuses = client.getStatus(files, revision1, revision3.getRevision(), NULL_PROGRESS_MONITOR);
153	assertEquals(2, statuses.size());
154	assertEquals(Status.MODIFIED, statuses.get(file).getStatus());
155	assertEquals(Status.ADDED, statuses.get(file2).getStatus());
156	}
157
158	public void testCompareRename () throws Exception {
159	File file = new File(workDir, "file");
160	File file2 = new File(workDir, "file2");
161	File[] files = new File[] { file, file2 };
162	write(file, "files content\n");
163	add(files);
164	commit(files);
165
166	GitClient client = getClient(workDir);
167	String revision1 = client.getBranches(false, NULL_PROGRESS_MONITOR).get(Constants.MASTER).getId();
168	remove(false, file);
169
170	client.commit(files, "removing file", null, null, NULL_PROGRESS_MONITOR);
171
172	write(file2, "files content\n");
173	add(files);
174	GitRevisionInfo revision3 = client.commit(files, "adding file as file2", null, null, NULL_PROGRESS_MONITOR);
175	Map<File, GitRevisionInfo.GitFileInfo> statuses = client.getStatus(files, revision1, revision3.getRevision(), NULL_PROGRESS_MONITOR);
176	assertEquals(2, statuses.size());
177	assertEquals(Status.REMOVED, statuses.get(file).getStatus());
178	assertEquals(Status.RENAMED, statuses.get(file2).getStatus());
179	assertEquals(file, statuses.get(file2).getOriginalFile());
180	}
181	}