<version major="1" minor="27"/>

            <date day="1" month="7" year="2014"/>

            <author login="ovrabec"/>

            <compatibility addition="yes"/>

            <description>

                <ul>

                    <li>New method GitClient.cherryPick used to cherry-pick commits and apply them in the

                    current branch. The command may interrupt its progress and require some user actions

                    (such as resolve conflicts or commit) and may be continued with different kinds

                    of operation types passed as its arguments.</li>

                    <li>Introduciong new repository state: CHERRY_PICKING and CHERRY_PICKING_RESOLVED

                    marking the states of the repository when a cherry-picking is not finished or

                    it requires resolving conflicts.</li>

                </ul>

            </description>

            <class package="org.netbeans.libs.git" name="GitClient"/>

            <class package="org.netbeans.libs.git" name="GitCherryPickResult"/>

            <class package="org.netbeans.libs.git" name="GitRepositoryState"/>

            <issue number="235267"/>

        </change>

        <change>

            <api name="gitlibrary_api"/>

            <summary>New method for updating a reference (branch) to a new commit id.</summary>

LBL_RepositoryInfo_CherryPicking=Cherry-picking

LBL_RepositoryInfo_CherryPickingResolved=Cherry-picked

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 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 2011 Sun Microsystems, Inc.

 */

package org.netbeans.libs.git;

import java.io.File;

import java.util.Collection;

import java.util.Collections;

import java.util.List;

/**

 * Returned by a git cherry-pick command, represents its result.

 *

 * @author Ondra Vrabec

 * @since 1.27

 */

public final class GitCherryPickResult {

    private final CherryPickStatus status;

    private final List<File> conflicts;

    private final List<File> failures;

    private final GitRevisionInfo currentHead;

    private final List<GitRevisionInfo> cherryPickedCommits;

    /**

     * The status rebase resulted in.

     */

    public enum CherryPickStatus {

        /**

         * Command successfully finished. No action is required.

         */

        OK,

        /**

         * Command was aborted and reset to the original state. No action is

         * required.

         */

        ABORTED,

        /**

         * Failed because a dirty working tree prevents from starting the command.

         * Local modifications preventing from applying commit changes must be 

         * reverted.

         */

        FAILED,

        /**

         * The cherry-picking stopped in a state where it requires a manual commit.

         * E.g. after resolving conflicts client is required to commit the changes

         * before continuing with rebase.

         */

        UNCOMMITTED,

        /**

         * Conflicts when merging the cherry-picked commits.

         * Conflicts must be resolved and the command must be continued/aborted.

         */

        CONFLICTING;

    }

    GitCherryPickResult (CherryPickStatus status, List<File> conflicts, List<File> failures,

            GitRevisionInfo currentHead, List<GitRevisionInfo> cherryPickedCommits) {

        this.status = status;

        this.currentHead = currentHead;

        this.conflicts = conflicts;

        this.failures = failures;

        this.cherryPickedCommits = cherryPickedCommits;

    }

    /**

     * @return result of the cherry-pick command.

     */

    public CherryPickStatus getCherryPickStatus () {

        return status;

    }

    /**

     * @return current HEAD commit after the cherry-pick command.

     */

    public GitRevisionInfo getCurrentHead () {

        return currentHead;

    }

    /**

     * If the cherry-pick started but was unable to finish because of unresolved

     * conflicts then the method returns a collection of such files in conflict.

     * To complete the command you need to resolve the conflicts and continue the

     * unfinished command.

     *

     * @return files in conflict

     */

    public Collection<File> getConflicts () {

        return Collections.unmodifiableList(conflicts);

    }

    /**

     * When the command fails because of local modifications then this method

     * returns a collections of files causing the failure.

     *

     * @return files that cause the cherry-pick to fail.

     */

    public Collection<File> getFailures () {

        return Collections.unmodifiableList(failures);

    }

    /**

     * Returns commits cherry-picked to the current branch by the last run of the 

     * cherry-pick command.

     * 

     * @return array of commits cherry-picked to head.

     */

    public GitRevisionInfo[] getCherryPickedCommits () {

        return cherryPickedCommits.toArray(new GitRevisionInfo[cherryPickedCommits.size()]);

    }

}

    @Override

    public GitCherryPickResult createCherryPickResult (GitCherryPickResult.CherryPickStatus status,

            List<File> conflicts, List<File> failures, GitRevisionInfo head,

            List<GitRevisionInfo> cherryPickedCommits) {

        return new GitCherryPickResult(status, conflicts, failures, head, cherryPickedCommits);

    }

import org.netbeans.libs.git.jgit.commands.CherryPickCommand;

    /**

     * Used as a parameter of {@link #cherryPick(org.netbeans.libs.git.GitClient.CherryPickOperation, java.lang.String[], org.netbeans.libs.git.progress.ProgressMonitor) to set the behavior of the command.

     * @since 1.27

     */

    public enum CherryPickOperation {

        /**

         * A fresh cherry-pick command will be started.

         */

        BEGIN,

        /**

         * Continues an interrupted cherry-pick command after conflicts are resolved.

         */

        CONTINUE {

            @Override

            public String toString () {

                return "--continue"; //NOI18N

            }

        },

        /**

         * Tries to finish cherry-picking the current commit but stops in

         * cherry-picking other scheduled commits.

         */

        QUIT {

            @Override

            public String toString () {

                return "--quit"; //NOI18N

            }

        },

        /**

         * Aborts and resets an interrupted cherry-pick command.

         */

        ABORT {

            @Override

            public String toString () {

                return "--abort"; //NOI18N

            }

        };

    }

    /**

     * Cherry-picks (transplants) selected revisions (commits) onto the current

     * HEAD.

     *

     * @param operation kind of cherry-pick operation you want to perform

     * @param revisions commits you want to cherry-pick. Makes sense only when

     * <code>operation</code> is set to <code>CherryPickOperation.BEGIN</code>

     * otherwise it's meaningless.

     * @param monitor progress monitor

     * @return result of the command

     * @throws GitException an unexpected error occurs

     * @since 1.27

     */

    public GitCherryPickResult cherryPick (CherryPickOperation operation, String[] revisions, ProgressMonitor monitor) throws GitException {

        Repository repository = gitRepository.getRepository();

        CherryPickCommand cmd = new CherryPickCommand(repository, getClassFactory(), revisions, operation, monitor, delegateListener);

        cmd.execute();

        return cmd.getResult();

    }

     * An unfinished cherry-pick. Must resolve or reset before continuing normally

     * @since 1.27

	 */

	CHERRY_PICKING {

            @Override

            public boolean canCheckout () { return false; }

            @Override

            public boolean canResetHead () { return true; }

            @Override

            public boolean canCommit () { return false; }

            @Override

            public String toString () { return Utils.getBundle(GitRepositoryState.class).getString("LBL_RepositoryInfo_CherryPicking"); } //NOI18N

	},

	/**

	 * A cherry-picked commit where all conflicts have been resolved. The index does not

	 * contain any unmerged paths and the repository requires a commit.

     * @since 1.27

	 */

	CHERRY_PICKING_RESOLVED {

            @Override

            public boolean canCheckout () { return true; }

            @Override

            public boolean canResetHead () { return true; }

            @Override

            public boolean canCommit () { return true; }

            @Override

            public String toString () { return Utils.getBundle(GitRepositoryState.class).getString("LBL_RepositoryInfo_CherryPickingResolved"); } //NOI18N

	},

	/**

                case CHERRY_PICKING:

                    return GitRepositoryState.CHERRY_PICKING;

                case CHERRY_PICKING_RESOLVED:

                    return GitRepositoryState.CHERRY_PICKING_RESOLVED;

import org.netbeans.libs.git.GitCherryPickResult;

    public abstract GitCherryPickResult createCherryPickResult (

            GitCherryPickResult.CherryPickStatus status, List<File> conflicts,

            List<File> failures, GitRevisionInfo head, List<GitRevisionInfo> cherryPickedCommits);

        ObjectId commitId = parseObjectId(repository, revision);

        if (commitId == null) {

            throw new GitException.MissingObjectException(revision, GitObjectType.COMMIT);

        }

        return findCommit(repository, commitId, walk);

    }

    public static RevCommit findCommit (Repository repository, ObjectId commitId, RevWalk walk) throws GitException.MissingObjectException, GitException {

MSG_Error_Commit_CannotAmend=Cannot amend a commit in this repository state.

/*

 * 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.BufferedOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.eclipse.jgit.api.CherryPickResult;

import org.eclipse.jgit.api.Git;

import org.eclipse.jgit.api.RebaseCommand.Operation;

import org.eclipse.jgit.api.errors.GitAPIException;

import org.eclipse.jgit.api.errors.JGitInternalException;

import org.eclipse.jgit.lib.Constants;

import org.eclipse.jgit.lib.ObjectId;

import org.eclipse.jgit.lib.ObjectReader;

import org.eclipse.jgit.lib.RebaseTodoFile;

import org.eclipse.jgit.lib.RebaseTodoLine;

import org.eclipse.jgit.lib.Ref;

import org.eclipse.jgit.lib.Repository;

import org.eclipse.jgit.lib.RepositoryState;

import org.eclipse.jgit.merge.ResolveMerger;

import org.eclipse.jgit.revwalk.RevCommit;

import org.eclipse.jgit.revwalk.RevWalk;

import org.eclipse.jgit.util.IO;

import org.eclipse.jgit.util.io.SafeBufferedOutputStream;

import org.netbeans.libs.git.GitCherryPickResult;

import org.netbeans.libs.git.GitClient;

import org.netbeans.libs.git.GitException;

import org.netbeans.libs.git.GitRevisionInfo;

import org.netbeans.libs.git.GitStatus;

import org.netbeans.libs.git.jgit.DelegatingGitProgressMonitor;

import org.netbeans.libs.git.jgit.GitClassFactory;

import org.netbeans.libs.git.jgit.Utils;

import org.netbeans.libs.git.progress.FileListener;

import org.netbeans.libs.git.progress.ProgressMonitor;

import org.netbeans.libs.git.progress.StatusListener;

/**

 *

 * @author ondra

 */

public class CherryPickCommand extends GitCommand {

    private final String[] revisions;

    private GitCherryPickResult result;

    private final ProgressMonitor monitor;

    private final GitClient.CherryPickOperation operation;

    private final FileListener listener;

    private static final String SEQUENCER = "sequencer";

    private static final String SEQUENCER_HEAD = "head";

    private static final String SEQUENCER_TODO = "todo";

    public CherryPickCommand (Repository repository, GitClassFactory gitFactory, String[] revisions,

            GitClient.CherryPickOperation operation, ProgressMonitor monitor, FileListener listener) {

        super(repository, gitFactory, monitor);

        this.revisions = revisions;

        this.operation = operation;

        this.monitor = monitor;

        this.listener = listener;

    }

    @Override

    protected void run () throws GitException {

        Repository repository = getRepository();

        ObjectId originalCommit = getOriginalCommit();

        ObjectId head = getHead();

        List<RebaseTodoLine> steps;

        try {

            switch (operation) {

                case BEGIN:

                    // initialize sequencer and cherry-pick steps if there are

                    // more commits to cherry-pick

                    steps = prepareCommand(head);

                    // apply the selected steps

                    applySteps(steps, false);

                    break;

                case ABORT:

                    // delete the sequencer and reset to the original head

                    if (repository.getRepositoryState() == RepositoryState.CHERRY_PICKING

                            || repository.getRepositoryState() == RepositoryState.CHERRY_PICKING_RESOLVED) {

                        if (originalCommit == null) {

                            // maybe the sequencer is not created in that case simply reset to HEAD

                            originalCommit = head;

                        }

                    }

                    Utils.deleteRecursively(getSequencerFolder());

                    if (originalCommit != null) {

                        ResetCommand reset = new ResetCommand(repository, getClassFactory(),

                                originalCommit.name(), GitClient.ResetType.HARD, new DelegatingGitProgressMonitor(monitor), listener);

                        reset.execute();

                    }

                    result = createCustomResult(GitCherryPickResult.CherryPickStatus.ABORTED);

                    break;

                case QUIT:

                    // used to reset the sequencer only

                    Utils.deleteRecursively(getSequencerFolder());

                    switch (repository.getRepositoryState()) {

                        case CHERRY_PICKING:

                            // unresolved conflicts

                            result = createResult(CherryPickResult.CONFLICT);

                            break;

                        case CHERRY_PICKING_RESOLVED:

                            result = createCustomResult(GitCherryPickResult.CherryPickStatus.UNCOMMITTED);

                            break;

                        default:

                            result = createCustomResult(GitCherryPickResult.CherryPickStatus.OK);

                            break;

                    }

                    break;

                case CONTINUE:

                    switch (repository.getRepositoryState()) {

                        case CHERRY_PICKING:

                            // unresolved conflicts, cannot continue

                            result = createResult(CherryPickResult.CONFLICT);

                            break;

                        case CHERRY_PICKING_RESOLVED:

                            // cannot continue without manual commit

                            result = createCustomResult(GitCherryPickResult.CherryPickStatus.UNCOMMITTED);

                            break;

                        default:

                            // read steps from sequencer and apply them

                            // if sequencer is empty this will be a noop

                            steps = readTodoFile(repository);

                            applySteps(steps, true);

                            break;

                    }

                    break;

                default:

                    throw new IllegalStateException("Unexpected operation " + operation.name());

            }

        } catch (GitAPIException | IOException ex) {

            throw new GitException(ex);

        }

    }

    @Override

    protected String getCommandDescription () {

        StringBuilder sb = new StringBuilder();

        sb.append("git cherry-pick "); //NOI18N

        if (operation == GitClient.CherryPickOperation.BEGIN) {

            for (String rev : revisions) {

                sb.append(rev).append(" "); //NOI18N

            }

        } else {

            sb.append(operation.toString());

        }

        return sb.toString();

    }

    public GitCherryPickResult getResult () {

        return result;

    }

    static Operation getOperation (GitClient.RebaseOperationType operation) {

        return Operation.valueOf(operation.name());

    }

    private void applySteps (List<RebaseTodoLine> steps, boolean skipFirstStep) throws GitAPIException, IOException {

        Repository repository = getRepository();

        ObjectReader or = repository.newObjectReader();

        CherryPickResult res = null;

        boolean skipped = false;

        List<Ref> cherryPickedRefs = new ArrayList<>();

        for (Iterator<RebaseTodoLine> it = steps.iterator(); it.hasNext(); ) {

            RebaseTodoLine step = it.next();

            if (step.getAction() == RebaseTodoLine.Action.PICK) {

                if (skipFirstStep && !skipped) {

                    it.remove();

                    skipped = true;

                    continue;

                }

                Collection<ObjectId> ids = or.resolve(step.getCommit());

                if (ids.size() != 1) {

                    throw new JGitInternalException("Could not resolve uniquely the abbreviated object ID");

                }

                org.eclipse.jgit.api.CherryPickCommand command = new Git(repository).cherryPick();

                command.include(ids.iterator().next());

                res = command.call();

                if (res.getStatus() == CherryPickResult.CherryPickStatus.OK) {

                    it.remove();

                    writeTodoFile(repository, steps);

                    cherryPickedRefs.addAll(res.getCherryPickedRefs());

                } else {

                    break;

                }

            } else {

                it.remove();

            }

        }

        if (res == null) {

            result = createCustomResult(GitCherryPickResult.CherryPickStatus.OK, cherryPickedRefs);

        } else {

            result = createResult(res, cherryPickedRefs);

        }

        if (steps.isEmpty()) {

            // sequencer no longer needed

            Utils.deleteRecursively(getSequencerFolder());

        }

    }

    private GitCherryPickResult createResult (CherryPickResult res) {

        return createResult(res, Collections.<Ref>emptyList());

    }

    private GitCherryPickResult createResult (CherryPickResult res, List<Ref> cherryPickedRefs) {

        GitRevisionInfo currHead = getCurrentHead();

        GitCherryPickResult.CherryPickStatus status = GitCherryPickResult.CherryPickStatus.valueOf(res.getStatus().name());

        List<File> conflicts;

        if (res.getStatus() == CherryPickResult.CherryPickStatus.CONFLICTING) {

            conflicts = getConflicts(currHead);

        } else {

            conflicts = Collections.<File>emptyList();

        }

        List<GitRevisionInfo> commits = toCommits(cherryPickedRefs);

        return getClassFactory().createCherryPickResult(status, conflicts, getFailures(res), currHead, commits);

    }

    private List<GitRevisionInfo> toCommits (List<Ref> cherryPickedRefs) {

        List<GitRevisionInfo> commits = new ArrayList<>(cherryPickedRefs.size());

        Repository repository = getRepository();

        RevWalk walk = new RevWalk(repository);

        for (Ref ref : cherryPickedRefs) {

            try {

                commits.add(getClassFactory().createRevisionInfo(Utils.findCommit(repository,

                        ref.getLeaf().getObjectId(), walk), repository));

            } catch (GitException ex) {

                Logger.getLogger(CherryPickCommand.class.getName()).log(Level.INFO, null, ex);

            }

        }

        return commits;

    }

    private GitRevisionInfo getCurrentHead () {

        GitRevisionInfo currHead;

        Repository repository = getRepository();

        try {

            currHead = getClassFactory().createRevisionInfo(Utils.findCommit(repository, Constants.HEAD), repository);

        } catch (GitException ex) {

            currHead = null;

        }

        return currHead;

    }

    private GitCherryPickResult createCustomResult (GitCherryPickResult.CherryPickStatus status) {

        return createCustomResult(status, Collections.<Ref>emptyList());

    }

    private GitCherryPickResult createCustomResult (GitCherryPickResult.CherryPickStatus status, List<Ref> cherryPickedRefs) {

        return getClassFactory().createCherryPickResult(status, Collections.<File>emptyList(),

                Collections.<File>emptyList(), getCurrentHead(), toCommits(cherryPickedRefs));

    }

    private List<File> getConflicts (GitRevisionInfo info) {

        List<File> conflicts;

        try {

            Repository repository = getRepository();

            Map<File, GitRevisionInfo.GitFileInfo> modifiedFiles = info.getModifiedFiles();

            ConflictCommand cmd = new ConflictCommand(repository, getClassFactory(), modifiedFiles.keySet().toArray(

                    new File[modifiedFiles.keySet().size()]),

                    new DelegatingGitProgressMonitor(monitor),

                    new StatusListener() {

                        @Override

                        public void notifyStatus (GitStatus status) { }

                    });

            cmd.execute();

            Map<File, GitStatus> statuses = cmd.getStatuses();

            conflicts = new ArrayList<>(statuses.size());

            for (Map.Entry<File, GitStatus> e : statuses.entrySet()) {

                if (e.getValue().isConflict()) {

                    conflicts.add(e.getKey());

                }

            }

        } catch (GitException ex) {

            Logger.getLogger(CherryPickCommand.class.getName()).log(Level.INFO, null, ex);

            conflicts = Collections.<File>emptyList();

        }

        return conflicts;

    }

    private List<File> getFailures (CherryPickResult result) {

        List<File> files = new ArrayList<>();

        File workDir = getRepository().getWorkTree();

        if (result.getStatus() == CherryPickResult.CherryPickStatus.FAILED) {

            Map<String, ResolveMerger.MergeFailureReason> obstructions = result.getFailingPaths();

            if (obstructions != null) {

                for (Map.Entry<String, ResolveMerger.MergeFailureReason> failure : obstructions.entrySet()) {

                    files.add(new File(workDir, failure.getKey()));

                }

            }

        }

        return Collections.unmodifiableList(files);

    }

    private File getSequencerFolder () {

        return new File(getRepository().getDirectory(), SEQUENCER);

    }

    private ObjectId getOriginalCommit () throws GitException {

        Repository repository = getRepository();

        File seqHead = new File(getSequencerFolder(), SEQUENCER_HEAD);

        ObjectId originalCommitId = null;

        if (seqHead.canRead()) {

            try {

                byte[] content = IO.readFully(seqHead);

                if (content.length > 0) {

                    originalCommitId = ObjectId.fromString(content, 0);

                }

                if (originalCommitId != null) {

                    originalCommitId = repository.resolve(originalCommitId.getName() + "^{commit}");

                }

            } catch (IOException e) {

            }

        }

        return originalCommitId;

    }

	private ObjectId getHead () throws GitException {

		return Utils.findCommit(getRepository(), Constants.HEAD);

	}

    private List<RebaseTodoLine> prepareCommand (ObjectId head) throws GitException, IOException {

        Repository repository = getRepository();

        ObjectReader or = repository.newObjectReader();

        RevWalk walk = new RevWalk(or);

        List<RevCommit> commits = new ArrayList<>(revisions.length);

        for (String rev : revisions) {

            RevCommit commit = Utils.findCommit(repository, rev, walk);

            commits.add(commit);

        }

        List<RebaseTodoLine> steps = new ArrayList<>(commits.size());

        if (commits.size() == 1) {

            RevCommit commit = commits.get(0);

            steps.add(new RebaseTodoLine(RebaseTodoLine.Action.PICK,

                    or.abbreviate(commit), commit.getShortMessage()));

        } else if (!commits.isEmpty()) {

            File sequencer = getSequencerFolder();

            sequencer.mkdirs();

            try {

                for (RevCommit commit : commits) {

                    steps.add(new RebaseTodoLine(RebaseTodoLine.Action.PICK,

                            or.abbreviate(commit), commit.getShortMessage()));

                }

                writeTodoFile(repository, steps);

                writeFile(new File(sequencer, SEQUENCER_HEAD), head);

            } catch (IOException ex) {

                Utils.deleteRecursively(sequencer);

                throw new GitException(ex);

            }

        }

        return steps;

    }

    private void writeFile (File file, ObjectId id) throws IOException {

        try (BufferedOutputStream bos = new SafeBufferedOutputStream(new FileOutputStream(file))) {

            id.copyTo(bos);

            bos.write('\n');

        }

    }

    private void writeTodoFile (Repository repository, List<RebaseTodoLine> steps) throws IOException {

        File f = new File(repository.getDirectory(), SEQUENCER);

        if (f.canWrite()) {

            RebaseTodoFile todoFile = new RebaseTodoFile(repository);

            todoFile.writeRebaseTodoFile(SEQUENCER + File.separator + SEQUENCER_TODO, steps, false);

        }

    }

    private List<RebaseTodoLine> readTodoFile (Repository repository) throws IOException {

        String path = SEQUENCER + File.separator + SEQUENCER_TODO;

        File f = new File(repository.getDirectory(), path);

        if (f.canRead()) {

            RebaseTodoFile todoFile = new RebaseTodoFile(repository);

            return todoFile.readRebaseTodo(SEQUENCER + File.separator + SEQUENCER_TODO, true);

        }

        return Collections.<RebaseTodoLine>emptyList();

    }

}

import org.eclipse.jgit.api.CherryPickResult;

    public void testCherryPickStatus () {

        for (CherryPickResult.CherryPickStatus status : CherryPickResult.CherryPickStatus.values()) {

            assertNotNull(GitCherryPickResult.CherryPickStatus.valueOf(status.name()));

        }

    }

import org.netbeans.libs.git.jgit.commands.CherryPickTest;

        suite.addTestSuite(CherryPickTest.class);

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

/*

 * 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.

 */

import java.io.File;

import java.io.IOException;

import org.eclipse.jgit.lib.Constants;

import org.eclipse.jgit.lib.ObjectReader;

import org.eclipse.jgit.lib.Repository;

import org.eclipse.jgit.lib.RepositoryState;

import org.eclipse.jgit.revwalk.RevCommit;

import org.netbeans.libs.git.GitCherryPickResult;

import org.netbeans.libs.git.GitClient;

import org.netbeans.libs.git.GitRevisionInfo;

import org.netbeans.libs.git.GitStatus.Status;

import org.netbeans.libs.git.SearchCriteria;

import org.netbeans.libs.git.jgit.AbstractGitTestCase;

import org.netbeans.libs.git.jgit.Utils;

/**

 *

 * @author ondra

 */

public class CherryPickTest extends AbstractGitTestCase {

    private File workDir;

    private Repository repository;

    private static final String BRANCH = "b";

    public CherryPickTest (String testName) throws IOException {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        workDir = getWorkingDirectory();

        repository = getRepository(getLocalGitRepository());

    }

    public void testCherryPickCommit () throws Exception {

        File f = new File(workDir, "f");

        write(f, "init");

        add(f);

        commit(f);

        GitClient client = getClient(workDir);

        client.createBranch(BRANCH, Constants.MASTER, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(BRANCH, true, NULL_PROGRESS_MONITOR);

        write(f, "change on branch");

        add(f);

        GitRevisionInfo c = client.commit(new File[] { f }, "on branch", null, null, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(Constants.MASTER, true, NULL_PROGRESS_MONITOR);

        GitRevisionInfo initCommit = client.log("HEAD", NULL_PROGRESS_MONITOR);

        Thread.sleep(1100);

        GitCherryPickResult res = client.cherryPick(GitClient.CherryPickOperation.BEGIN, new String[] { BRANCH }, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.OK, res.getCherryPickStatus());

        assertEquals(initCommit.getRevision(), res.getCurrentHead().getParents()[0]);

        assertEquals(c.getCommitTime(), res.getCurrentHead().getCommitTime());

        assertEquals(1, res.getCherryPickedCommits().length);

        assertEquals(c.getRevision(), res.getCherryPickedCommits()[0].getRevision());

        assertFalse(new File(workDir, ".git/sequencer").exists());

    }

    public void testCherryPickCommits () throws Exception {

        File f = new File(workDir, "f");

        write(f, "init");

        add(f);

        commit(f);

        File[] roots = new File[] { f };

        GitClient client = getClient(workDir);

        client.createBranch(BRANCH, Constants.MASTER, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(BRANCH, true, NULL_PROGRESS_MONITOR);

        write(f, "change 1 on branch");

        add(f);

        GitRevisionInfo c1 = client.commit(roots, "on branch 1", null, null, NULL_PROGRESS_MONITOR);

        write(f, "change 2 on branch");

        add(f);

        GitRevisionInfo c2 = client.commit(roots, "on branch 2", null, null, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(Constants.MASTER, true, NULL_PROGRESS_MONITOR);

        GitRevisionInfo initCommit = client.log("HEAD", NULL_PROGRESS_MONITOR);

        Thread.sleep(1100);

        GitCherryPickResult res = client.cherryPick(GitClient.CherryPickOperation.BEGIN,

                new String[] { c1.getRevision(), c2.getRevision() }, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.OK, res.getCherryPickStatus());

        SearchCriteria sc = new SearchCriteria();

        sc.setRevisionTo("HEAD");

        GitRevisionInfo[] logs = client.log(sc, NULL_PROGRESS_MONITOR);

        assertEquals(3, logs.length);

        assertEquals(c2.getFullMessage(), logs[0].getFullMessage());

        assertEquals(c2.getCommitTime(), logs[0].getCommitTime());

        assertEquals(c1.getFullMessage(), logs[1].getFullMessage());

        assertEquals(c1.getCommitTime(), logs[1].getCommitTime());

        assertEquals(initCommit.getRevision(), logs[2].getRevision());

        assertEquals(2, res.getCherryPickedCommits().length);

        assertEquals(c1.getRevision(), res.getCherryPickedCommits()[0].getRevision());

        assertEquals(c2.getRevision(), res.getCherryPickedCommits()[1].getRevision());

        assertFalse(new File(workDir, ".git/sequencer").exists());

    }

    public void testCherryPickFailure () throws Exception {

        File f = new File(workDir, "f");

        write(f, "init");

        add(f);

        commit(f);

        File[] roots = new File[] { f };

        GitClient client = getClient(workDir);

        client.createBranch(BRANCH, Constants.MASTER, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(BRANCH, true, NULL_PROGRESS_MONITOR);

        write(f, "change on branch");

        add(f);

        GitRevisionInfo c = client.commit(roots, "on branch", null, null, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(Constants.MASTER, true, NULL_PROGRESS_MONITOR);

        // make modification so cherry-pick cannot start

        write(f, "change in master");

        GitCherryPickResult res = client.cherryPick(GitClient.CherryPickOperation.BEGIN, new String[] { BRANCH }, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.FAILED, res.getCherryPickStatus());

        assertEquals(0, res.getCurrentHead().getParents().length);

    }

    public void testCherryPickCommitsConflictAbort () throws Exception {

        File f = new File(workDir, "f");

        write(f, "init");

        add(f);

        commit(f);

        File[] roots = new File[] { f };

        GitClient client = getClient(workDir);

        client.createBranch(BRANCH, Constants.MASTER, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(BRANCH, true, NULL_PROGRESS_MONITOR);

        write(f, "change 1 on branch");

        add(f);

        GitRevisionInfo c1 = client.commit(roots, "on branch 1", null, null, NULL_PROGRESS_MONITOR);

        write(f, "change 2 on branch");

        add(f);

        GitRevisionInfo c2 = client.commit(roots, "on branch 2", null, null, NULL_PROGRESS_MONITOR);

        write(f, "change 3 on branch");

        add(f);

        GitRevisionInfo c3 = client.commit(roots, "on branch 3", null, null, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(Constants.MASTER, true, NULL_PROGRESS_MONITOR);

        GitRevisionInfo initCommit = client.log("HEAD", NULL_PROGRESS_MONITOR);

        GitCherryPickResult res = client.cherryPick(GitClient.CherryPickOperation.BEGIN,

                new String[] { c1.getRevision(), c3.getRevision() }, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.CONFLICTING, res.getCherryPickStatus());

        assertEquals(initCommit.getRevision(), res.getCurrentHead().getParents()[0]);

        res = client.cherryPick(GitClient.CherryPickOperation.ABORT, null, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.ABORTED, res.getCherryPickStatus());

        assertEquals(initCommit.getRevision(), res.getCurrentHead().getRevision());

        assertStatus(client.getStatus(roots, NULL_PROGRESS_MONITOR), workDir, f, true,

                Status.STATUS_NORMAL, Status.STATUS_NORMAL, Status.STATUS_NORMAL, false);

    }

    public void testCherryPickCommitsConflictQuit () throws Exception {

        File f = new File(workDir, "f");

        write(f, "init");

        add(f);

        commit(f);

        File[] roots = new File[] { f };

        GitClient client = getClient(workDir);

        client.createBranch(BRANCH, Constants.MASTER, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(BRANCH, true, NULL_PROGRESS_MONITOR);

        write(f, "change 1 on branch");

        add(f);

        GitRevisionInfo c1 = client.commit(roots, "on branch 1\nblablabla", null, null, NULL_PROGRESS_MONITOR);

        write(f, "change 2 on branch");

        add(f);

        GitRevisionInfo c2 = client.commit(roots, "on branch 2", null, null, NULL_PROGRESS_MONITOR);

        write(f, "change 3 on branch");

        add(f);

        GitRevisionInfo c3 = client.commit(roots, "on branch 3\nBLABLABLA", null, null, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(Constants.MASTER, true, NULL_PROGRESS_MONITOR);

        GitRevisionInfo initCommit = client.log("HEAD", NULL_PROGRESS_MONITOR);

        GitCherryPickResult res = client.cherryPick(GitClient.CherryPickOperation.BEGIN,

                new String[] { c1.getRevision(), c3.getRevision() }, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.CONFLICTING, res.getCherryPickStatus());

        assertEquals(initCommit.getRevision(), res.getCurrentHead().getParents()[0]);

        ObjectReader or = repository.newObjectReader();

        RevCommit commit = Utils.findCommit(repository, c3.getRevision());

        assertEquals("pick " + or.abbreviate(commit).name() + " " + commit.getShortMessage(),

                read(new File(repository.getDirectory(), "sequencer/todo")));

        res = client.cherryPick(GitClient.CherryPickOperation.QUIT, null, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.CONFLICTING, res.getCherryPickStatus());

        assertEquals(initCommit.getRevision(), res.getCurrentHead().getParents()[0]);

        assertStatus(client.getStatus(roots, NULL_PROGRESS_MONITOR), workDir, f, true,

                Status.STATUS_NORMAL, Status.STATUS_NORMAL, Status.STATUS_NORMAL, true);

        assertEquals(RepositoryState.CHERRY_PICKING, repository.getRepositoryState());

        res = client.cherryPick(GitClient.CherryPickOperation.ABORT, null, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.ABORTED, res.getCherryPickStatus());

        assertEquals(initCommit.getRevision(), res.getCurrentHead().getParents()[0]);

        assertStatus(client.getStatus(roots, NULL_PROGRESS_MONITOR), workDir, f, true,

                Status.STATUS_NORMAL, Status.STATUS_NORMAL, Status.STATUS_NORMAL, false);

    }

    public void testCherryPickCommitConflictResolve () throws Exception {

        File f = new File(workDir, "f");

        write(f, "init");

        add(f);

        commit(f);

        File[] roots = new File[] { f };

        GitClient client = getClient(workDir);

        client.createBranch(BRANCH, Constants.MASTER, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(BRANCH, true, NULL_PROGRESS_MONITOR);

        write(f, "change 1 on branch");

        add(f);

        GitRevisionInfo c1 = client.commit(roots, "on branch 1", null, null, NULL_PROGRESS_MONITOR);

        write(f, "change 2 on branch");

        add(f);

        GitRevisionInfo c2 = client.commit(roots, "on branch 2", null, null, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(Constants.MASTER, true, NULL_PROGRESS_MONITOR);

        GitRevisionInfo initCommit = client.log("HEAD", NULL_PROGRESS_MONITOR);

        GitCherryPickResult res = client.cherryPick(GitClient.CherryPickOperation.BEGIN,

                new String[] { c2.getRevision() }, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.CONFLICTING, res.getCherryPickStatus());

        assertEquals(initCommit.getRevision(), res.getCurrentHead().getRevision());

        assertFalse(new File(repository.getDirectory(), "sequencer").exists());

        write(f, "init\nchange 2 on branch");

        add(f);

        // try continue, should interrupt and ask for commit

        res = client.cherryPick(GitClient.CherryPickOperation.CONTINUE, null, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.UNCOMMITTED, res.getCherryPickStatus());

        assertEquals(initCommit.getRevision(), res.getCurrentHead().getRevision());

        assertFalse(new File(repository.getDirectory(), "sequencer").exists());

        GitRevisionInfo commit = client.commit(new File[0], c2.getFullMessage(), null, null, NULL_PROGRESS_MONITOR);

        assertEquals(c2.getCommitTime(), commit.getCommitTime());

        assertEquals(RepositoryState.SAFE, repository.getRepositoryState());

        assertFalse(new File(repository.getDirectory(), "sequencer").exists());

        res = client.cherryPick(GitClient.CherryPickOperation.CONTINUE, null, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.OK, res.getCherryPickStatus());

    }

    public void testCherryPickCommitsConflictResolve () throws Exception {

        File f = new File(workDir, "f");

        write(f, "init");

        add(f);

        commit(f);

        File[] roots = new File[] { f };

        GitClient client = getClient(workDir);

        client.createBranch(BRANCH, Constants.MASTER, NULL_PROGRESS_MONITOR);

        client.checkoutRevision(BRANCH, true, NULL_PROGRESS_MONITOR);

        write(f, "change 1 on branch");

        add(f);

        GitRevisionInfo c1 = client.commit(roots, "on branch 1", null, null, NULL_PROGRESS_MONITOR);

        write(f, "init\nchange 2 on branch");

        add(f);

        GitRevisionInfo c2 = client.commit(roots, "on branch 2", null, null, NULL_PROGRESS_MONITOR);

        write(f, "init\nchange 3 on branch");

        add(f);

        GitRevisionInfo c3 = client.commit(roots, "on branch 3", null, null, NULL_PROGRESS_MONITOR);

        Thread.sleep(1100);

        client.checkoutRevision(Constants.MASTER, true, NULL_PROGRESS_MONITOR);

        GitRevisionInfo initCommit = client.log("HEAD", NULL_PROGRESS_MONITOR);

        GitCherryPickResult res = client.cherryPick(GitClient.CherryPickOperation.BEGIN,

                new String[] { c2.getRevision(), c3.getRevision() }, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.CONFLICTING, res.getCherryPickStatus());

        assertEquals(initCommit.getRevision(), res.getCurrentHead().getRevision());

        write(f, "init\nchange 2 on branch");

        add(f);

        // try continue, should interrupt and ask for commit

        res = client.cherryPick(GitClient.CherryPickOperation.CONTINUE, null, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.UNCOMMITTED, res.getCherryPickStatus());

        assertEquals(initCommit.getRevision(), res.getCurrentHead().getRevision());

        assertTrue(new File(repository.getDirectory(), "sequencer").exists());

        GitRevisionInfo commit = client.commit(new File[0], c2.getFullMessage(), null, null, NULL_PROGRESS_MONITOR);

        assertEquals(c2.getCommitTime(), commit.getCommitTime());

        assertEquals(RepositoryState.SAFE, repository.getRepositoryState());

        assertTrue(new File(repository.getDirectory(), "sequencer").exists());

        res = client.cherryPick(GitClient.CherryPickOperation.CONTINUE, null, NULL_PROGRESS_MONITOR);

        assertEquals(GitCherryPickResult.CherryPickStatus.OK, res.getCherryPickStatus());

        assertEquals(commit.getRevision(), res.getCurrentHead().getParents()[0]);

        assertEquals(c3.getCommitTime(), res.getCurrentHead().getCommitTime());

        assertFalse(new File(repository.getDirectory(), "sequencer").exists());

        assertEquals(1, res.getCherryPickedCommits().length);

        assertEquals(c3.getRevision(), res.getCherryPickedCommits()[0].getRevision());

    }

}

    public void testCherryPickCommit () throws Exception {

        repository.getConfig().setString("user", null, "name", "John");

        repository.getConfig().setString("user", null, "email", "john@git.com");

        repository.getConfig().save();

        File f = new File(workDir, "f");

        write(f, "init");

        File[] files = new File[] { f };

        add(f);

        commit(f);

        GitClient client = getClient(workDir);

        write(f, "change");

        add(f);

        GitRevisionInfo info = client.commit(files, "change to CherryPick", null, null, NULL_PROGRESS_MONITOR);

        Thread.sleep(1100);

        client.reset("HEAD~1", GitClient.ResetType.MIXED, NULL_PROGRESS_MONITOR);

        repository.writeCherryPickHead(repository.resolve(info.getRevision()));

        // now we are cherry-picking

        // amend is not allowed

        try {

            client.commit(new File[0], info.getFullMessage(), null, null, true, NULL_PROGRESS_MONITOR);

            fail("Amend not allowed");

        } catch (GitException ex) {

            assertEquals(Utils.getBundle(CommitCommand.class).getString("MSG_Error_Commit_CannotAmend"), ex.getMessage());

        }

        // doing commit should preserve authorship of the original commit (info)

        GitRevisionInfo commit = client.commit(new File[0], info.getFullMessage(), null, null, NULL_PROGRESS_MONITOR);

        assertEquals(info.getAuthor(), commit.getAuthor());

        assertEquals(info.getCommitTime(), commit.getCommitTime());

        assertEquals(Utils.findCommit(repository, info.getRevision()).getAuthorIdent().getWhen(),

                Utils.findCommit(repository, commit.getRevision()).getAuthorIdent().getWhen());

    }