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

            <date day="25" month="6" year="2014"/>

            <author login="ovrabec"/>

            <compatibility addition="yes"/>

            <description>

                <ul>

                    <li>Git client accepts the parameter telling the merge command how

                    to proceed with regard to fast-forward commits. Users may require

                    either to enforce or to completely eliminate (and always create a merge commit)

                    fast-forward merges.</li>

                    <li>Git Repository instance allows users to query for the current default fast-forward

                    option via a new getter method.</li>

                </ul>

            </description>

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

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

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

            <issue number="245236"/>

        </change>

        <change>

            <api name="gitlibrary_api"/>

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

import org.netbeans.libs.git.GitRepository.FastForwardOption;

        return merge(revision, null, monitor);

    }

    /**

     * Merges a given revision with the current head.

     * @param revision id of a revision to merge.

     * @param fastForward option telling merge to enforce or disable fast forward merges.

     * @param monitor progress monitor

     * @return result of the merge

     * @throws GitException.CheckoutConflictException there are local modifications in Working Tree, merge fails in such a case

     * @throws GitException an unexpected error occurs

     * @since 1.26

     */

    public GitMergeResult merge (String revision, FastForwardOption fastForward, ProgressMonitor monitor) throws GitException.CheckoutConflictException, GitException {

        /**

         * Fast forward merge cannot be executed, a commit is needed.

         * @since 1.26

         */

        ABORTED {

            @Override

            public String toString() {

                return "Aborted";

            }

        },

import org.eclipse.jgit.api.MergeCommand;

import org.eclipse.jgit.merge.MergeConfig;

    /**

     * Option specifying how to deal with merges and merge commits. Required by

     * {@link GitClient#merge(java.lang.String, org.netbeans.libs.git.GitRepository.FastForwardOption, org.netbeans.libs.git.progress.ProgressMonitor)}.

     * To get the repository's default value, get it with {@link #getDefaultFastForwardOption()}.

     *

     * @since 1.26

     */

    public enum FastForwardOption {

        /**

         * Merge will not create a new commit if possible and only update the

         * branch reference to the merged commit. This will usually happen if

         * the merged commit is a descendant of the branch's head commit.

         */

        FAST_FORWARD {

            @Override

            public String toString () {

                return "--ff"; //NOI18N

            }

        },

        /**

         * Merge will fail if fast forward is impossible, no merge commit will

         * be created under any circumstances.

         */

        FAST_FORWARD_ONLY {

            @Override

            public String toString () {

                return "--ff-only"; //NOI18N

            }

        },

        /**

         * Will always create a merge commit even if fast forward were possible.

         */

        NO_FAST_FORWARD {

            @Override

            public String toString () {

                return "--no-ff"; //NOI18N

            }

        };

    }

        getRepository();

        return createClient(gitRepository);

    }

    /**

     * Parses the repository configuration file and returns the default fast-forward merge

     * option set for the repository and its current branch.

     * 

     * @return the default fast-forward option for the current repository and the active branch.

     * @throws GitException an error occurs

     * @since 1.26

     */

    public FastForwardOption getDefaultFastForwardOption () throws GitException {

        JGitRepository repository = getRepository();

        repository.increaseClientUsage();

        try {

            MergeConfig cfg = MergeConfig.getConfigForCurrentBranch(repository.getRepository());

            MergeCommand.FastForwardMode mode = cfg.getFastForwardMode();

            switch (mode) {

                case FF_ONLY:

                    return FastForwardOption.FAST_FORWARD_ONLY;

                case NO_FF:

                    return FastForwardOption.NO_FAST_FORWARD;

                default:

                    return FastForwardOption.FAST_FORWARD;

            }

        } finally {

            repository.decreaseClientUsage();

        }

    }

    private synchronized JGitRepository getRepository () {

import org.netbeans.libs.git.GitRepository.FastForwardOption;

    private final FastForwardOption ffOption;

        this.ffOption = ffOption;

        setFastForward(command);

    private void setFastForward (org.eclipse.jgit.api.MergeCommand cmd) {

        if (ffOption == null) {

            // will fall back on the config default

            return;

        }

        switch (ffOption) {

            case FAST_FORWARD:

                cmd.setFastForward(org.eclipse.jgit.api.MergeCommand.FastForwardMode.FF);

                break;

            case FAST_FORWARD_ONLY:

                cmd.setFastForward(org.eclipse.jgit.api.MergeCommand.FastForwardMode.FF_ONLY);

                break;

            case NO_FAST_FORWARD:

                cmd.setFastForward(org.eclipse.jgit.api.MergeCommand.FastForwardMode.NO_FF);

                break;

        }

    }

import org.netbeans.libs.git.GitRepository;

    public void testMergeNoFastForward () throws Exception {

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

        write(f, "init");

        add(f);

        commit(f);

        GitClient client = getClient(workDir);

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

        client.checkoutRevision(BRANCH_NAME, true, NULL_PROGRESS_MONITOR);

        write(f, BRANCH_NAME);

        add(f);

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

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

        assertEquals("init", read(f));

        GitMergeResult result = client.merge(BRANCH_NAME, NULL_PROGRESS_MONITOR);

        assertEquals(MergeStatus.FAST_FORWARD, result.getMergeStatus());

        assertEquals(BRANCH_NAME, read(f));

        SearchCriteria crit = new SearchCriteria();

        crit.setRevisionTo(Constants.MASTER);

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

        assertEquals(2, logs.length);

        assertEquals(logs[0].getRevision(), info.getRevision());

        // continue working on branch

        client.checkoutRevision(BRANCH_NAME, true, NULL_PROGRESS_MONITOR);

        remove(false, f);

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

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

        assertEquals(BRANCH_NAME, read(f));

        result = client.merge(BRANCH_NAME, GitRepository.FastForwardOption.NO_FAST_FORWARD, NULL_PROGRESS_MONITOR);

        assertEquals(MergeStatus.MERGED, result.getMergeStatus());

        assertFalse(f.exists());

        crit = new SearchCriteria();

        crit.setRevisionTo(Constants.MASTER);

        logs = client.log(crit, NULL_PROGRESS_MONITOR);

        assertEquals(4, logs.length);

        assertEquals(2, logs[0].getParents().length);

    }

    public void testMergeFFOnly () throws Exception {

        File f1 = new File(workDir, "file1");

        File f2 = new File(workDir, "file2");

        write(f1, "init");

        write(f2, "init");

        add(f1, f2);

        commit(f1, f2);

        GitClient client = getClient(workDir);

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

        client.checkoutRevision(BRANCH_NAME, true, NULL_PROGRESS_MONITOR);

        write(f1, BRANCH_NAME);

        add(f1);

        client.commit(new File[] { f1 }, "change on branch", null, null, NULL_PROGRESS_MONITOR);

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

        write(f2, "another change");

        add(f2);

        client.commit(new File[] { f2 }, "change on master", null, null, NULL_PROGRESS_MONITOR);

        GitMergeResult result = client.merge(BRANCH_NAME, GitRepository.FastForwardOption.FAST_FORWARD_ONLY, NULL_PROGRESS_MONITOR);

        // no merge commits allowed => FAIL

        assertEquals(MergeStatus.ABORTED, result.getMergeStatus());

        // test also config files

        assertEquals(GitRepository.FastForwardOption.FAST_FORWARD, GitRepository.getInstance(workDir).getDefaultFastForwardOption());

        StoredConfig cfg = repo.getConfig();

        cfg.setEnum(ConfigConstants.CONFIG_KEY_MERGE, null,

                    ConfigConstants.CONFIG_KEY_FF, org.eclipse.jgit.api.MergeCommand.FastForwardMode.Merge.ONLY);

        cfg.save();

        assertEquals(GitRepository.FastForwardOption.FAST_FORWARD_ONLY, GitRepository.getInstance(workDir).getDefaultFastForwardOption());

        result = client.merge(BRANCH_NAME, NULL_PROGRESS_MONITOR);

        // no merge commits allowed => FAIL

        assertEquals(MergeStatus.ABORTED, result.getMergeStatus());

        result = client.merge(BRANCH_NAME, GitRepository.FastForwardOption.FAST_FORWARD, NULL_PROGRESS_MONITOR);

        // merge commits allowed => OK

        assertEquals(MergeStatus.MERGED, result.getMergeStatus());

    }