import java.util.Map;

    @Override

    public void afterCommitReplace (GitHookContext originalContext, GitHookContext newContext, Map<String, String> mapping) {

        delegate.afterChangesetReplace(newContext.getFiles(), mapping, "GIT");

    }

import org.netbeans.libs.git.GitClient.RebaseOperationType;

import org.netbeans.libs.git.GitRebaseResult;

            "rebase", //NOI18N // creates new head and branches

    public GitRebaseResult rebase (final RebaseOperationType operation, final String upstream, final ProgressMonitor monitor) throws GitException.AuthorizationException, GitException {

        return new CommandInvoker().runMethod(new Callable<GitRebaseResult>() {

            @Override

            public GitRebaseResult call () throws Exception {

                return delegate.rebase(operation, upstream, monitor);

            }

        }, "rebase"); //NOI18N

    }

import javax.swing.JButton;

import org.netbeans.libs.git.GitBranch;

import org.netbeans.libs.git.GitClient.RebaseOperationType;

import org.netbeans.libs.git.GitRevisionInfo;

import org.netbeans.libs.git.GitTransportUpdate;

import org.netbeans.modules.git.ui.rebase.RebaseAction;

import org.openide.DialogDisplayer;

import org.openide.NotifyDescriptor;

import org.openide.awt.Mnemonics;

                if (branchId == null || currentHeadId == null) {

                    nextAction = new Merge(); // just for sure

                } else if (!branchId.equals(currentHeadId)) {

                    GitRevisionInfo info = client.getCommonAncestor(new String[] { currentHeadId, branchId }, GitUtils.NULL_PROGRESS_MONITOR);

                    if (info == null || !(info.getRevision().equals(branchId) || info.getRevision().equals(currentHeadId))) {

                        // ask

                        return askForNextAction();

                    } else if (info.getRevision().equals(currentHeadId)) {

                        // FF merge

                        nextAction = new Merge();

                    }                    

                }

            } catch (GitException ex) {

                LOG.log(Level.INFO, null, ex);

import org.netbeans.modules.git.ui.rebase.RebaseAction;

            item = new JMenuItem();

            action = (Action) SystemAction.get(RebaseAction.class);

            Utils.setAcceleratorBindings(Annotator.ACTIONS_PATH_PREFIX, action);

            Actions.connect(item, action, false);

            menu.add(item);

            item = menu.add(SystemActionBridge.createAction(SystemAction.get(RebaseAction.class), NbBundle.getMessage(RebaseAction.class, "LBL_RebaseAction_PopupName"), lkp)); //NOI18N

            org.openide.awt.Mnemonics.setLocalizedText(item, item.getText());

/*

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

 *

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

 */

package org.netbeans.modules.git.ui.rebase;

import java.io.BufferedReader;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.FileReader;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.concurrent.Callable;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.swing.JButton;

import org.netbeans.libs.git.GitClient.RebaseOperationType;

import org.netbeans.libs.git.GitException;

import org.netbeans.libs.git.GitRebaseResult;

import org.netbeans.libs.git.GitRepositoryState;

import org.netbeans.libs.git.GitRevisionInfo;

import org.netbeans.libs.git.SearchCriteria;

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

import org.netbeans.modules.git.Git;

import org.netbeans.modules.git.client.GitClient;

import org.netbeans.modules.git.client.GitClientExceptionHandler;

import org.netbeans.modules.git.client.GitProgressSupport;

import org.netbeans.modules.git.ui.actions.GitAction;

import org.netbeans.modules.git.ui.actions.SingleRepositoryAction;

import org.netbeans.modules.git.ui.conflicts.ResolveConflictsExecutor;

import org.netbeans.modules.git.ui.output.OutputLogger;

import org.netbeans.modules.git.utils.GitUtils;

import org.netbeans.modules.git.utils.ResultProcessor;

import org.openide.util.NbBundle;

import org.netbeans.modules.git.ui.repository.RepositoryInfo;

import org.netbeans.modules.versioning.hooks.GitHook;

import org.netbeans.modules.versioning.hooks.GitHookContext;

import org.netbeans.modules.versioning.hooks.VCSHooks;

import org.netbeans.modules.versioning.spi.VCSContext;

import org.netbeans.modules.versioning.util.FileUtils;

import org.openide.DialogDisplayer;

import org.openide.NotifyDescriptor;

import org.openide.awt.ActionID;

import org.openide.awt.ActionRegistration;

import org.openide.awt.Mnemonics;

/**

 *

 * @author Ondrej Vrabec

 */

@ActionID(id = "org.netbeans.modules.git.ui.rebase.RebaseAction", category = "Git")

@ActionRegistration(displayName = "#LBL_RebaseAction_Name")

@NbBundle.Messages({

    "LBL_RebaseAction_Name=&Rebase...", "LBL_RebaseAction_PopupName=Rebase..."

})

public class RebaseAction extends SingleRepositoryAction {

    private static final Logger LOG = Logger.getLogger(RebaseAction.class.getName());

    private static final String NETBEANS_REBASE_ORIGHEAD = "netbeans-rebase.orighead"; //NOI18N

    private static final String NETBEANS_REBASE_UPSTREAM = "netbeans-rebase.upstream"; //NOI18N

    private static final String NETBEANS_REBASE_ONTO = "netbeans-rebase.onto"; //NOI18N

    private static final String REBASE_MERGE_DIR = "rebase-merge"; //NOI18N

    @Override

    protected void performAction (File repository, File[] roots, VCSContext context) {

        RepositoryInfo info = RepositoryInfo.getInstance(repository);

        info.refresh();

        rebase(repository, info);

    }

    @NbBundle.Messages({

        "# {0} - repository state", "MSG_RebaseAction_rebaseNotAllowed=Rebase is not allowed in this state: {0}",

        "CTL_RebaseAction.continueButton.text=C&ontinue",

        "CTL_RebaseAction.continueButton.TTtext=Continue the interrupted rebase",

        "CTL_RebaseAction.abortButton.text=Abo&rt",

        "CTL_RebaseAction.abortButton.TTtext=Abort the interrupted rebase",

        "CTL_RebaseAction.skipButton.text=&Skip",

        "CTL_RebaseAction.skipButton.TTtext=Skip the current commit and continue the interrupted rebase",

        "LBL_Rebase.rebasingState.title=Unfinished Rebase",

        "# {0} - repository name", "MSG_Rebase.rebasingState.text=Repository {0} is in the middle of an unfinished rebase.\n"

            + "Do you want to continue or abort the unfinished rebase\n"

            + "or skip the current commit from the rebase?"

    })

    private void rebase (File repository, RepositoryInfo info) {

        GitRepositoryState state = info.getRepositoryState();

        if (state == GitRepositoryState.SAFE) {

            // should start

        } else if (state == GitRepositoryState.REBASING) {

            // abort or continue?

            JButton btnContinue = new JButton();

            Mnemonics.setLocalizedText(btnContinue, Bundle.CTL_RebaseAction_continueButton_text());

            btnContinue.setToolTipText(Bundle.CTL_RebaseAction_continueButton_TTtext());

            JButton btnAbort = new JButton();

            Mnemonics.setLocalizedText(btnAbort, Bundle.CTL_RebaseAction_abortButton_text());

            btnAbort.setToolTipText(Bundle.CTL_RebaseAction_abortButton_TTtext());

            JButton btnSkip = new JButton();

            Mnemonics.setLocalizedText(btnSkip, Bundle.CTL_RebaseAction_skipButton_text());

            btnSkip.setToolTipText(Bundle.CTL_RebaseAction_skipButton_TTtext());

            Map<Object, RebaseOperationType> operations = new HashMap<Object, RebaseOperationType>();

            operations.put(btnContinue, RebaseOperationType.CONTINUE);

            operations.put(btnSkip, RebaseOperationType.SKIP);

            operations.put(btnAbort, RebaseOperationType.ABORT);

            Object value = DialogDisplayer.getDefault().notify(new NotifyDescriptor(

                    Bundle.MSG_Rebase_rebasingState_text(repository.getName()),

                    Bundle.LBL_Rebase_rebasingState_title(),

                    NotifyDescriptor.YES_NO_CANCEL_OPTION,

                    NotifyDescriptor.QUESTION_MESSAGE,

                    new Object[] { btnContinue, btnSkip, btnAbort, NotifyDescriptor.CANCEL_OPTION }, 

                    btnContinue));

            RebaseOperationType op = operations.get(value);

            if (op != null) {

                finishRebase(repository, op);

            }

        } else {

            GitClientExceptionHandler.annotate(Bundle.MSG_RebaseAction_rebaseNotAllowed(state));

        }

    }

    @NbBundle.Messages("MSG_RebaseAction_progress=Rebasing...")

    private void finishRebase (final File repository, final RebaseOperationType op) {

        GitProgressSupport supp = new GitProgressSupport() {

            @Override

            protected void perform () {

                try {

                    GitUtils.runWithoutIndexing(new Callable<Void>() {

                        @Override

                        public Void call () throws Exception {

                            String origHead = getRebaseFileContent(repository, NETBEANS_REBASE_ORIGHEAD);

                            String onto = getOnto(repository);

                            String upstream = getRebaseFileContent(repository, NETBEANS_REBASE_UPSTREAM);

                            GitClient client = getClient();

                            RebaseResultProcessor rrp = new RebaseResultProcessor(client, repository, onto, upstream, origHead,

                                    getProgressSupport());

                            RebaseOperationType nextAction = op;

                            while (nextAction != null && !isCanceled()) {

                                GitRebaseResult result = client.rebase(nextAction, onto, getProgressMonitor());

                                rrp.processResult(result);

                                nextAction = rrp.getNextAction();

                            }

                            return null;

                        }

                    });

                } catch (GitException ex) {

                    GitClientExceptionHandler.notifyException(ex, true);

                } finally {

                    setDisplayName(NbBundle.getMessage(GitAction.class, "LBL_Progress.RefreshingStatuses")); //NOI18N

                    Git.getInstance().getFileStatusCache().refreshAllRoots(Collections.<File, Collection<File>>singletonMap(repository, Git.getInstance().getSeenRoots(repository)));

                    GitUtils.headChanged(repository);

                }

            }

            private GitProgressSupport getProgressSupport () {

                return this;

            }

        };

        supp.start(Git.getInstance().getRequestProcessor(repository), repository, Bundle.MSG_RebaseAction_progress());

    }

    @NbBundle.Messages({

        "MSG_RebaseAction.noMergeStrategies=Cannot continue rebase. It was probably started externally but without "

            + "the merging algorithm (\"-m\" option) which is the only supported option in the NetBeans IDE.\n"

            + "Please use the external tool you started rebase with to finish it."

    })

    private static String getRebaseFileContent (File repository, String filename) throws GitException {

        File rebaseFolder = new File(GitUtils.getGitFolderForRoot(repository), REBASE_MERGE_DIR);

        if (rebaseFolder.exists()) {

            File file = new File(rebaseFolder, filename);

            if (file.canRead()) {

                BufferedReader br = null;

                try {

                    br = new BufferedReader(new FileReader(file));

                    return br.readLine();

                } catch (IOException ex) {

                    LOG.log(Level.FINE, null, ex);

                } finally {

                    if (br != null) {

                        try {

                            br.close();

                        } catch (IOException ex) {}

                    }

                }

            }

        } else {

            throw new GitException(Bundle.MSG_RebaseAction_noMergeStrategies());

        }

        return null;

    }

    private static String getOnto (File repository) throws GitException {

        String onto = getRebaseFileContent(repository, NETBEANS_REBASE_ONTO);

        if (onto == null) {

            onto = getRebaseFileContent(repository, "onto-name"); //NOI18N

        }

        if (onto == null) {

            onto = getRebaseFileContent(repository, "onto_name"); //NOI18N

        }

        if (onto == null) {

            onto = getRebaseFileContent(repository, "onto"); //NOI18N

        }

        return onto;

    }

    public static class RebaseResultProcessor extends ResultProcessor {

        private final OutputLogger logger;

        private final String onto;

        private final String origHead;

        private final String upstream;

        private RebaseOperationType nextAction;

        private final GitProgressSupport supp;

        public RebaseResultProcessor (GitClient client, File repository, String onto, String upstream, String origHead,

                GitProgressSupport supp) {

            super(client, repository, onto, supp.getProgressMonitor());

            this.origHead = origHead;

            this.onto = onto;

            this.upstream = upstream;

            this.logger = supp.getLogger();

            this.supp = supp;

        }

        @NbBundle.Messages({

            "# {0} - rebase status", "MSG_RebaseAction.result=Rebase Result: {0}\n",

            "# {0} - head commit id", "MSG_RebaseAction.result.aborted=Rebase aborted and the current HEAD reset to {0}\n",

            "MSG_RebaseAction.result.conflict=Rebase interrupted because of conflicts in:\n",

            "# {0} - head commit id", "MSG_RebaseAction.result.ok=Rebase successfully finished and HEAD now points to {0}:\n",

            "# {0} - rebase target revision", "MSG_RebaseAction.result.alreadyUpToDate=HEAD already in sync with {0}"

        })

        public void processResult (GitRebaseResult result) {

            nextAction = null;

            StringBuilder sb = new StringBuilder(Bundle.MSG_RebaseAction_result(result.getRebaseStatus().toString()));

            GitRevisionInfo info;

            try {

                info = client.log(GitUtils.HEAD, GitUtils.NULL_PROGRESS_MONITOR);

            } catch (GitException ex) {

                GitClientExceptionHandler.notifyException(ex, true);

                return;

            }

            persistNBConfig();

            switch (result.getRebaseStatus()) {

                case ABORTED:

                    sb.append(Bundle.MSG_RebaseAction_result_aborted(info.getRevision()));

                    GitUtils.printInfo(sb, info);

                    break;

                case FAILED:

                case CONFLICTS:

                    if (LOG.isLoggable(Level.FINE)) {

                        LOG.log(Level.FINE, "Local modifications in WT during rebase: {0} - {1}", new Object[] { repository, result.getFailures() }); //NOI18N

                    }

                    try {

                        if (resolveLocalChanges(result.getFailures().toArray(new File[result.getFailures().size()]))) {

                            nextAction = RebaseOperationType.BEGIN;

                        }

                    } catch (GitException ex) {

                        GitClientExceptionHandler.notifyException(ex, true);

                    }

                    break;

                case NOTHING_TO_COMMIT:

                    nextAction = resolveNothingToCommit();

                    break;

                case FAST_FORWARD:

                case OK:

                    sb.append(Bundle.MSG_RebaseAction_result_ok(info.getRevision()));

                    GitUtils.printInfo(sb, info);

                    updatePushHooks();

                    break;

                case STOPPED:

                    sb.append(Bundle.MSG_RebaseAction_result_conflict());

                    printConflicts(sb, result.getConflicts());

                    nextAction = resolveRebaseConflicts(result.getConflicts());

                    break;

                case UP_TO_DATE:

                    sb.append(Bundle.MSG_RebaseAction_result_alreadyUpToDate(onto));

                    break;

            }

            logger.output(sb.toString());

        }

        public RebaseOperationType getNextAction () {

            return nextAction;

        }

        @NbBundle.Messages({

            "LBL_RebaseResultProcessor.abortButton.text=&Abort",

            "LBL_RebaseResultProcessor.abortButton.TTtext=Abort the interrupted rebase and reset back to the original commit.",

            "LBL_RebaseResultProcessor.resolveButton.text=&Resolve",

            "LBL_RebaseResultProcessor.resolveButton.TTtext=Files in conflict will be opened in a Resolve Conflict dialog.",

            "LBL_RebaseResultProcessor.resolveConflicts=Resolve Conflicts",

            "MSG_RebaseResultProcessor.resolveConflicts=Rebase produced unresolved conflicts.\n"

                + "You can resolve them manually or review them in the Versioning view\n"

                + "or completely abort the rebase.",

            "LBL_RebaseResultProcessor.revertButton.text=&Revert",

            "LBL_RebaseResultProcessor.revertButton.TTtext=Revert local changes to the state in the HEAD and removes unversioned files.",

            "LBL_RebaseResultProcessor.reviewButton.text=Re&view",

            "LBL_RebaseResultProcessor.reviewButton.TTtext=Opens the Versioning view and lists the conflicted files.",

            "MSG_Rebase.resolving=Resolving conflicts..."

        })

        private RebaseOperationType resolveRebaseConflicts (Collection<File> conflicts) {

            RebaseOperationType action = null;

            JButton abort = new JButton();

            Mnemonics.setLocalizedText(abort, Bundle.LBL_RebaseResultProcessor_abortButton_text());

            abort.setToolTipText(Bundle.LBL_RebaseResultProcessor_abortButton_TTtext());

            JButton resolve = new JButton();

            Mnemonics.setLocalizedText(resolve, Bundle.LBL_RebaseResultProcessor_resolveButton_text());

            resolve.setToolTipText(Bundle.LBL_RebaseResultProcessor_resolveButton_TTtext());

            JButton review = new JButton();

            Mnemonics.setLocalizedText(review, Bundle.LBL_RebaseResultProcessor_reviewButton_text());

            review.setToolTipText(Bundle.LBL_RebaseResultProcessor_reviewButton_TTtext());

            Object o = DialogDisplayer.getDefault().notify(new NotifyDescriptor(

                    Bundle.MSG_RebaseResultProcessor_resolveConflicts(),

                    Bundle.LBL_RebaseResultProcessor_resolveConflicts(),

                    NotifyDescriptor.OK_CANCEL_OPTION, NotifyDescriptor.QUESTION_MESSAGE,

                    new Object[] { resolve, review, abort, NotifyDescriptor.CANCEL_OPTION }, resolve));

            if (o == review) {

                openInVersioningView(conflicts);

            } else if (o == resolve) {

                GitProgressSupport supp = new ResolveConflictsExecutor(conflicts.toArray(new File[conflicts.size()]));

                supp.start(Git.getInstance().getRequestProcessor(repository), repository, Bundle.MSG_Rebase_resolving());

            } else if (o == abort) {

                action = RebaseOperationType.ABORT;

            }

            return action;

        }

        @NbBundle.Messages({

            "LBL_RebaseResultProcessor.nothingToCommit=Nothing to Commit",

            "MSG_RebaseResultProcessor.nothingToCommit=No modifications to commit for the current rebase step.\n"

                + "Do you want to skip the commit from the rebase and continue?",

            "LBL_RebaseResultProcessor.skipButton.text=&Skip",

            "LBL_RebaseResultProcessor.skipButton.TTtext=Skip the commit and continue rebase."

        })

        private RebaseOperationType resolveNothingToCommit () {

            RebaseOperationType action = null;

            JButton abort = new JButton();

            Mnemonics.setLocalizedText(abort, Bundle.LBL_RebaseResultProcessor_abortButton_text());

            abort.setToolTipText(Bundle.LBL_RebaseResultProcessor_abortButton_TTtext());

            JButton skip = new JButton();

            Mnemonics.setLocalizedText(skip, Bundle.LBL_RebaseResultProcessor_skipButton_text());

            skip.setToolTipText(Bundle.LBL_RebaseResultProcessor_skipButton_TTtext());

            Object o = DialogDisplayer.getDefault().notify(new NotifyDescriptor(

                    Bundle.MSG_RebaseResultProcessor_nothingToCommit(),

                    Bundle.LBL_RebaseResultProcessor_nothingToCommit(),

                    NotifyDescriptor.OK_CANCEL_OPTION, NotifyDescriptor.QUESTION_MESSAGE,

                    new Object[] { skip, abort, NotifyDescriptor.CANCEL_OPTION }, skip));

            if (o == skip) {

                action = RebaseOperationType.SKIP;

            } else if (o == abort) {

                action = RebaseOperationType.ABORT;

            }

            return action;

        }

        private void persistNBConfig () {

            if (onto != null && upstream != null && origHead != null) {

                File rebaseFolder = new File(GitUtils.getGitFolderForRoot(repository), REBASE_MERGE_DIR);

                if (rebaseFolder.canWrite()) {

                    try {

                        FileUtils.copyStreamToFile(new ByteArrayInputStream(onto.getBytes()), new File(rebaseFolder, NETBEANS_REBASE_ONTO));

                        FileUtils.copyStreamToFile(new ByteArrayInputStream(upstream.getBytes()), new File(rebaseFolder, NETBEANS_REBASE_UPSTREAM));

                        FileUtils.copyStreamToFile(new ByteArrayInputStream(origHead.getBytes()), new File(rebaseFolder, NETBEANS_REBASE_ORIGHEAD));

                    } catch (IOException ex) {

                        LOG.log(Level.INFO, null, ex);

                    }

                }

            }

        }

        @NbBundle.Messages("MSG_RebaseAction.updatingHooks=updating push hooks")

        private void updatePushHooks () {

            if (onto != null && upstream != null && origHead != null) {

                Collection<GitHook> hooks = VCSHooks.getInstance().getHooks(GitHook.class);

                if (!hooks.isEmpty() && !pm.isCanceled()) {

                    supp.setProgress(Bundle.MSG_RebaseAction_updatingHooks());

                    try {

                        GitHookContext.LogEntry[] originalEntries = getEntries(client, upstream, origHead, pm);

                        if (pm.isCanceled()) {

                            return;

                        }

                        GitHookContext.LogEntry[] newEntries = getEntries(client, onto, GitUtils.HEAD, pm);

                        if (pm.isCanceled()) {

                            return;

                        }

                        Map<String, String> mapping = findChangesetMapping(originalEntries, newEntries);

                        for (GitHook gitHook : hooks) {

                            gitHook.afterCommitReplace(

                                    new GitHookContext(new File[] { repository }, null, originalEntries),

                                    new GitHookContext(new File[] { repository }, null, newEntries),

                                    mapping);

                        }

                    } catch (GitException ex) {

                        LOG.log(Level.INFO, null, ex);

                    }

                }

            }

        }

    }

    private static Map<String, String> findChangesetMapping (GitHookContext.LogEntry[] originalEntries, GitHookContext.LogEntry[] newEntries) {

        Map<String, String> mapping = new HashMap<String, String>(originalEntries.length);

        for (GitHookContext.LogEntry original : originalEntries) {

            boolean found = false;

            for (GitHookContext.LogEntry newEntry : newEntries) {

                if (original.getChangeset().equals(newEntry.getChangeset()) || (

                        original.getDate().equals(newEntry.getDate())

                        && original.getAuthor().equals(newEntry.getAuthor())

                        && original.getMessage().equals(newEntry.getMessage()))) {

                    // is it really the same commit???

                    mapping.put(original.getChangeset(), newEntry.getChangeset());

                    found = true;

                    break;

                }

            }

            if (!found) {

                // delete ????

                mapping.put(original.getChangeset(), null);

            }

        }

        return mapping;

    }

    private static GitHookContext.LogEntry[] getEntries (GitClient client, String revisionFrom, String revisionTo,

            ProgressMonitor pm) throws GitException {

        SearchCriteria crit = new SearchCriteria();

        crit.setRevisionFrom(revisionFrom);

        crit.setRevisionTo(revisionTo);

        GitRevisionInfo[] log = client.log(crit, pm);

        return convertToEntries(log);

    }    

    private static GitHookContext.LogEntry[] convertToEntries (GitRevisionInfo[] messages) {

        List<GitHookContext.LogEntry> entries = new ArrayList<GitHookContext.LogEntry>(messages.length);

        for (GitRevisionInfo msg : messages) {

            entries.add(new GitHookContext.LogEntry(

                    msg.getFullMessage(),

                    msg.getAuthor().toString(),

                    msg.getRevision(),

                    new Date(msg.getCommitTime())));

        }

        return entries.toArray(new GitHookContext.LogEntry[entries.size()]);

    }

}

    public void afterCommitReplace (GitHookContext originalContext, GitHookContext newContext,

            Map<String, String> changesetMapping) {

    }