wiggle - apply rejected patches and perform word-wise diffs
wiggle [function] [options] file [files]
The main function of wiggle is to apply a patch to a file in a similar
manner to the patch(1) program.
The distinctive difference of wiggle is that it will attempt to apply a
patch even if the "before" part of the patch doesn't match the target
file perfectly. This is achieved by breaking the file and patch into
words and finding the best alignment of words in the file with words in
the patch. Once this alignment has been found, any differences (word-
wise) in the patch are applied to the file as best as possible.
Also, wiggle will (in some cases) detect changes that have already been
applied, and will ignore them.
wiggle ensures that every change in the patch is applied to the target
file somehow. If a particular change cannot be made in the file, the
file is annotated to show where the change should be made in a similar
way to the merge(1) program with the -A option. Each annotation
contains 3 components: a portion of the original file where the change
should be applied, a portion of the patch that couldn't be matched
precisely in the file, and the text that should replace that portion of
the patch. These are separated by lines containing precisely 7
identical characters, either '<', '|', '=', or '>', possibly followed
by a descriptive word. So
Some portion of the original file
text to replace
text to replace it with
indicates that "text to replace" should be replaced by "text to replace
it with" somewhere in the portion of the original file. However wiggle
was not able to find a place to make this change.
wiggle can also produce conflict reports showing only the words that
are involved rather than showing whole lines. In this case the output
One possible usage of wiggle is to run patch to apply some patch, and
to collect a list of rejects by monitoring the error messages from
patch. Then for each file for which a reject was found, run
wiggle --replace originalfile originalfile.rej
Finally each file must be examined to resolve any unresolved conflicts,
and to make sure the applied patch is semantically correct.
Alternately, the original patch file can be fed to the browse mode as
wiggle -B < patchfile
This will allow the changes and conflicts to be inspected and, to some
extent, modified; and then the results can be saved.
The following options are understood by wiggle. Some of these are
explained in more detail in the following sections on MERGE, DIFF,
EXTRACT, and BROWSE.
Select the "merge" function. This is the default function.
Select the "diff" function. This displays the differences
between files. This can be given after --browse (see below) in
which case a patch or diff of two files can be viewed without
Select the "extract" function. This extracts one branch of a
patch or merge file.
Select the "browse" function. This is similar to "merge" (or
"diff") only with a different presentation. Instead of the
result simply being sent to standard output, it is presented
using an ncurses-based GUI so that each hunk of the patch can be
examined to understand what conflicts where involved and what
needed to be ignored in order of the patch to be wiggled in to
Request that all operations and display be word based. This is
the default for the "diff" function.
Request that all operations and display be line based.
De-emphasise white space (space, tab, and newline) is
determining differences and changes.
Normally white space is treated like a word which can be matched
or changed by a patch. When this flag is in force, white space
serves only as a separator between other words and is not
matched itself. The effect of this is that changes in the
amount of white space are not treated as significant.
To be precise, any white space is combined with the preceding
word or, in the case of leading space on a line, with the
following word. However it is not involved in any comparisons
of that word. If a patch deletes a word, the attached white
space is deleted as well. If a patch adds a word, the attached
white space is added as well.
An empty line, or one that contains only blanks, will be treated
as a single word that will match any other blank line, no matter
how many spaces it has.
-b has no effect in --line mode.
Treat the last named file as a patch instead of a file (with
--diff) or a merge (--extract). In merge or browse mode, -p
requires there be exactly one file which is a patch and which
can contain patches to multiple files. The patches are merged
into each file. When used in merge mode, this usage requires
the --replace option as writing lots of merged files to
standard-out is impractical.
When processing a multi-file patch, -p can be followed by a
numeric argument indicating how many file name components should
be stripped from files named in the patch file. If no numeric
argument is given, wiggle will deduce an appropriate number
based what files are present in the filesystem.
Normally the merged output is written to standard-output. With
--replace, the original file is replaced with the merge output.
In browse mode, this instructs wiggle to always save the
resulting merge when exiting.
Rather than writing the result to stdout or to replace the
original file, this requests that the output be written to the
given file. This is only meaningful with --merge or --browse
when given a single merge to browse.
This option overrides -r.
When used with the diff function, swap the files before
calculating the differences. When used with the merge or browse
functions, wiggle attempts to revert changes rather than apply
Normally wiggle will ignore changes in the patch which appear to
already have been applied in the original. With this flag those
changes are reported as conflicts rather than being ignored.
When used with --merge, conflicts that can be wiggled into place
are reported as conflicts with an extra stanza which shows what
the result would be if this flag had not been used. The extra
stanza is introduce with a line containing 7 ampersand (&)
Some portion of the original file
text to replace
text to replace it with
Text that would result from a successful wiggle
If a merge is successful in applying all changes, it will
normally exit with a success status (0), only reporting failure
(1) if a conflict occurred and was annotated. With
--report-wiggles wiggle will also report failure if any changes
had to be wiggled in. This can be useful when wiggle is used
for automatic merges as with git. If any wiggles happen, git
will report the failure, and the results can be examined to
confirm they are acceptable.
Print a simple help message. If given after one of the function
selectors (--merge, --diff, --extract, --browse) help specific
to that function is displayed.
Display the version number of wiggle.
Enable verbose mode. Currently this makes no difference.
Enable quiet mode. This suppresses the message from the merge
function when there are unresolvable conflicts.
wiggle can divide a text into lines or words when performing it's
tasks. A line is simply a string of characters terminated by a
newline. A word is either a maximal contiguous string of alphanumerics
(including underscore), a maximal contiguous string of space or tab
characters, or any other single character.
The merge function modifies a given text by finding all changes between
two other texts and imposing those changes on the given text.
Normally wiggle focuses on which words have changed so as to maximise
the possibility of finding a good match in the given text for the
context of a given change. However it can consider only whole lines
wiggle extracts the three texts that it needs from files listed on the
command line. Either 1, 2, or 3 files may be listed, and any one of
them may be a lone hyphen signifying standard-input.
If one file is given and the -p option is not present, the file is
treated as a merge file, i.e. the output of "merge -A" or "wiggle".
Such a file implicitly contains three streams and these are extracted
If two files are given, then the first simply contains the primary
text, and the second is treated as a patch file (the output of
"diff -u" or "diff -c", or a ".rej" file from patch) and the two other
texts are extracted from that.
If one file is given together with the -p option, the file is treated
as a patch file containing the names of the files that it patches. In
this case multiple merge operations can happen and each takes one
stream from a file named in the patch, and the other two from the patch
itself. The --replace option is required and the results are written
back to the target files.
Finally if three files are listed, they are taken to contain the given
text and the two other texts, in order.
Normally the result of the merge is written to standard-output. If the
-r flag is given, the output is written to a file which replaces the
original given file. In this case the original file is renamed to have
a .porig suffix (for "patched original" which makes sense if you first
use patch to apply a patch, and then use wiggle to wiggle the rejects
Further if the -o option is given with a file name, the output will be
written to that file. In this case no backup is created.
If no errors occur (such as file access errors) wiggle will exit with a
status of 0 if all changes were successfully merged, and with an exit
status of 1 and a brief message if any changes could not be fully
merged and were instead inserted as annotations. However if either
--report-wiggles or --show-wiggles options were given, wiggle will also
exist with status of 1 if any changes had to be wiggled in even though
this was successful.
The merge function can operate in three different modes with respect to
lines or words.
With the --lines option, whole lines are compared and any conflicts are
reported as whole lines that need to be replaced.
With the --words option, individual words are compared and any
conflicts are reported just covering the words affected. This uses the
<<<|||===>>> conflict format.
Without either of these options, a hybrid approach is taken.
Individual words are compared and merged, but when a conflict is found
the whole surrounding line is reported as being in conflict.
wiggle will ensure that every change between the two other texts is
reflected in the result of the merge somehow. There are four different
ways that a change can be reflected.
1 If a change converts A to B and A is found at a suitable place
in the original file, it is replaced with B. This includes the
possibility that B is empty, but not that A is empty.
2 If a change is found which simply adds B and the text
immediately preceding and following the insertion are found
adjacent in the original file in a suitable place, then B is
inserted between those adjacent texts.
3 If a change is found which changes A to B and this appears
(based on context) to align with B in the original, then it is
assumed that this change has already been applied, and the
change is ignored. When this happens, a message reflecting the
number of ignored changes is printed by wiggle. This
optimisation can be suppressed with the -i flag.
4 If a change is found that does not fit any of the above
possibilities, then a conflict is reported as described earlier.
The diff function is provided primarily to allow inspection of the
alignments that wiggle calculated between texts and that it uses for
performing a merge.
The output of the diff function is similar to the unified output of
diff. However while diff does not output long stretches of common
text, wiggle's diff mode outputs everything.
When calculating a word-based alignment (the default), wiggle may need
to show these word-based differences. This is done using an extension
to the unified-diff format. If a line starts with a vertical bar, then
it may contain sections surrounded by special multi-character brackets.
The brackets "<<<++" and "++>>>" surround added text while "<<<--" and
"-->>>" surround removed text.
wiggle can be given the two texts to compare in one of three ways.
If only one file is given, then it is treated as a patch and the two
branches of that patch are compared. This effectively allows a patch
to be refined from a line-based patch to a word-based patch.
If two files are given, then they are normally assumed to be simple
texts to be compared.
If two files are given along with the --patch option, then the second
file is assumed to be a patch and either the first (with -1) or the
second (with -2) branch is extracted and compared with text found in
the first file.
This last option causes wiggle to apply a "best-fit" algorithm for
aligning patch hunks with the file before computing the differences.
This algorithm is used when merging a patch with a file, and its value
can be seen by comparing the difference produced this way with the
difference produced by first extracting one branch of a patch into a
file, and then computing the difference of that file with the main
The extract function of wiggle simply exposes the internal
functionality for extracting one branch of a patch or a merge file.
Precisely one file should be given, and it will be assumed to be a
merge file unless --patch is given, in which case a patch is assumed.
The choice of branch in made by providing one of -1, -2, or -3 with
The browse function of wiggle presents the result of a merge or (with
-d) a diff in a text-based GUI that can be navigated using keystrokes
similar to vi(1) or emacs(1).
The browser allows each of the two or three streams to be viewed
individually with colours used to highlight different sorts of text -
green for added text, red for deleted text etc. It can also show the
patch by itself, the full result of the merge, or the merge and the
The browser provides a number of context-sensitive help pages which can
be accessed by typing '?'
The top right of the GUI will report the type of text under the cursor,
which is also indicated by the colour of the text. Options are
Unchanged, Changed, Unmatched, Extraneous, AlreadyApplied and Conflict.
If the meanings of these are clear a little experimentations should
A limited amount of editing is permitted while in browse mode.
Currently text that is unwanted can be discarded with x. This will
convert a Conflict or Change to Unchanged, and an Unmatched to Changed
(which effectively changes it to the empty string). Similarly a text
can be marked as wanted with c. This will convert a Conflict or
Extraneous to Changed. Using the same key again will revert the
Finally, the uppercase X will revert all changes on the current line.
To make more sweeping changes you can use v which runs an editor,
preferring $VISUAL or $EDITOR if they are set in the environment.
If you make any changes, then wiggle will ask you if you want to save
the changes, even if --replace was not given.
Caution should always be exercised when applying a rejected patch with
wiggle. When patch rejects a patch, it does so for a good reason.
Even though wiggle may be able to find a believable place to apply each
textual change, there is no guarantee that the result is correct in any
semantic sense. The result should always be inspected to make sure it
wiggle --replace file file.rej
This is the normal usage of wiggle and will take any changes in
file.rej that patch could not apply, and merge them into file.
wiggle -dp1 file file.rej
This will perform a word-wise comparison between the file and the
before branch of the diff in file.rej and display the differences.
This allows you to see where a given patch would apply.
wiggle --merge --help
Get help about the merge function of wiggle.
wiggle --browse --patch update.patch
Parse the update.patch file for patches and present a list of patched
files which can be browsed to examine each patch in detail.
wiggle can be integrated with git so that it is used as the default
merge tool and diff tool. This can be achieved by adding the following
lines to .gitconfig in the user's home directory.
name = "Wiggle flexible merging"
driver = wiggle -o %A %A %O %B
recursive = binary
tool = wiggle
cmd = wiggle -B -o $MERGED $LOCAL $BASE $REMOTE
cmd = wiggle -Bd $LOCAL $REMOTE
This will make git mergetool and git difftool use wiggle.
If you want git to always use wiggle for merges (which may be
dangerous), you can add
to an appropriate gitattributes file such as
The name of wiggle was inspired by the following quote.
The problem I find is that I often want to take
(file1+patch) -> file2,
when I don't have file1. But merge tools want to take
(file1|file2) -> file3.
I haven't seen a graphical tool which helps you to wiggle a patch
into a file.
-- Andrew Morton - 2002
- wiggle cannot read the extended unified-diff output that it
produces for --diff --words.
- wiggle cannot read the word-based merge format that it produces
for --merge --words.
- wiggle does not understand unicode and so will treat all non-
ASCII characters much the same as it treats punctuation - it
will treat each one as a separate word. The browser will not
display non-ASCII characters properly.
Neil Brown at Computer Science and Engineering at The University of New
South Wales, Sydney, Australia; and later at SUSE, still in Sydney,
patch(1), diff(1), merge(1), wdiff(1), diff3(1), git-config(1),