wiggle - Online sa Cloud

PROGRAMA:

NAME

wiggle - ilapat ang mga tinanggihang patch at magsagawa ng mga pagkakaiba sa salita

SINOPSIS

kumalas [pagpapaandar] [mga pagpipilian] file [mga file]

DESCRIPTION

Ang pangunahing pag-andar ng kumalas ay maglapat ng patch sa isang file sa katulad na paraan sa
magtagpi(1) programa.

Ang natatanging pagkakaiba ng kumalas ay ang pagtatangka nitong maglapat ng isang patch kahit na ang
"bago" bahagi ng patch ay hindi ganap na tumutugma sa target na file. Ito ay nakamit ng
pagsira ng file at pag-patch sa mga salita at paghahanap ng pinakamahusay na pagkakahanay ng mga salita sa file
na may mga salita sa patch. Kapag nahanap na ang pagkakahanay na ito, anumang pagkakaiba (salita-wise)
sa patch ay inilapat sa file hangga't maaari.

Gayundin, kumalas ay (sa ilang mga kaso) makakakita ng mga pagbabago na nailapat na, at gagawin
wag mo silang pansinin.

kumalas Tinitiyak na ang bawat pagbabago sa patch ay inilapat sa target na file kahit papaano. Kung ang
Ang partikular na pagbabago ay hindi maaaring gawin sa file, ang file ay naka-annotate upang ipakita kung saan ang
pagbabago ay dapat gawin sa katulad na paraan sa pagsamahin(1) programa kasama ang -A opsyon. Bawat isa
Ang anotasyon ay naglalaman ng 3 bahagi: isang bahagi ng orihinal na file kung saan dapat ang pagbabago
ilapat, isang bahagi ng patch na hindi maitugma nang eksakto sa file, at ang
text na dapat palitan ang bahaging iyon ng patch. Ang mga ito ay pinaghihiwalay ng mga linya
naglalaman ng eksaktong 7 magkaparehong mga character, alinman sa '<', '|', '=', o '>', posibleng
sinusundan ng salitang naglalarawan. Kaya
<<<<<<<< natagpuan
Ilang bahagi ng orihinal na file
||||||| inaasahan
papalitan ng text
=======
teksto upang palitan ito ng
>>>>>>> kapalit
ay nagpapahiwatig na ang "tekstong papalitan" ay dapat palitan ng "tekstong palitan ito" sa isang lugar
sa bahagi ng orihinal na file. Gayunpaman kumalas ay hindi nakahanap ng lugar na gagawin
itong pagbabago.

kumalas maaari ding gumawa ng mga ulat ng salungatan na nagpapakita lamang ng mga salita na kasangkot sa halip
kaysa sa pagpapakita ng buong linya. Sa kasong ito ang output ay mukhang:
<<<---orihinal|||luma===bago--->>>

Isang posibleng paggamit ng kumalas ay tumakbo magtagpi upang ilapat ang ilang patch, at upang mangolekta ng isang listahan ng
tinatanggihan sa pamamagitan ng pagsubaybay sa mga mensahe ng error mula sa patch. Pagkatapos para sa bawat file kung saan a
ang pagtanggi ay natagpuan, tumakbo
wiggle --replace originalfile originalfile.rej

Sa wakas, dapat suriin ang bawat file upang malutas ang anumang hindi nalutas na mga salungatan, at upang matiyak
semantically tama ang inilapat na patch.

Bilang kahalili, ang orihinal na patch file ay maaaring ibigay sa browse mode bilang
kumawag -B < patchfile

Ito ay magbibigay-daan sa mga pagbabago at salungatan na masuri at, sa ilang lawak, mabago;
at pagkatapos ay mai-save ang mga resulta.

Opsyon
Ang mga sumusunod na opsyon ay naiintindihan ng kumalas. Ang ilan sa mga ito ay ipinaliwanag sa higit pa
detalye sa mga sumusunod na seksyon sa MERGE, DIFF, EXTRACT, at BROWSE.

-m, --pagsamahin
Piliin ang function na "pagsamahin". Ito ang default na function.

-d, --diff
Piliin ang function na "diff". Ipinapakita nito ang mga pagkakaiba sa pagitan ng mga file. Maaari itong
ibibigay pagkatapos --browse (tingnan sa ibaba) kung saan ang isang patch o diff ng dalawang file ay maaaring
matingnan nang wala ang mga orihinal.

-x, --extract
Piliin ang function na "extract". Kinukuha nito ang isang sangay ng isang patch o merge na file.

-B, --browse
Piliin ang function na "browse". Ito ay katulad ng "pagsamahin" (o "diff") lamang sa a
magkaibang presentasyon. Sa halip na ang resulta ay ipinadala lamang sa pamantayan
output, ito ay ipinakita gamit ang isang ncurses-based na GUI upang ang bawat hunk ng patch
maaaring suriin upang maunawaan kung anong mga salungatan kung saan kasangkot at kung ano ang kailangan
hindi pinansin upang mai-wiggle ang patch sa lugar.

-w, --mga salita
Hilingin na ang lahat ng mga operasyon at display ay batay sa salita. Ito ang default para sa
"diff" function.

-l, --mga linya
Hilingin na ang lahat ng mga operasyon at display ay batay sa linya.

-b, --ignore-blangko
Ang de-emphasize ng white space (space, tab, at newline) ay ang pagtukoy ng mga pagkakaiba at
mga pagbabago.

Karaniwan ang puting espasyo ay itinuturing na parang isang salita na maaaring itugma o baguhin ng a
patch. Kapag ang watawat na ito ay may bisa, ang puting espasyo ay nagsisilbi lamang bilang isang separator sa pagitan
ibang mga salita at hindi tumutugma sa sarili nito. Ang epekto nito ay ang mga pagbabago sa
ang dami ng puting espasyo ay hindi itinuturing na makabuluhan.

Upang maging tumpak, ang anumang puting espasyo ay pinagsama sa naunang salita o, sa kaso
ng nangungunang espasyo sa isang linya, na may sumusunod na salita. Gayunpaman, hindi ito kasali sa
anumang paghahambing ng salitang iyon. Kung ang isang patch ay nagtatanggal ng isang salita, ang nakalakip na puting espasyo
tinatanggal din. Kung ang isang patch ay nagdaragdag ng isang salita, ang nakalakip na puting espasyo ay idaragdag bilang
mabuti.

Ang isang walang laman na linya, o isa na naglalaman lamang ng mga blangko, ay ituturing bilang isang salita
na tutugma sa anumang iba pang blangkong linya, gaano man karaming mga puwang ang mayroon ito.

-b walang epekto sa --linya mode.

-p, --tagpi
Tratuhin ang huling pinangalanang file bilang isang patch sa halip na isang file (na may --diff) o isang merge
(--extract). Sa pagsamahin or browse fashion, -p nangangailangan ng eksaktong isang file na
ay isang patch at maaaring maglaman ng mga patch sa maraming file. Ang mga patch ay pinagsama
sa bawat file. Kapag ginamit sa pagsamahin mode, ang paggamit na ito ay nangangailangan ng --palitan opsyon
dahil ang pagsulat ng maraming pinagsamang mga file sa standard-out ay hindi praktikal.

Kapag nagpoproseso ng multi-file na patch, -p maaaring sundan ng isang numeric na argumento
na nagpapahiwatig kung gaano karaming mga bahagi ng pangalan ng file ang dapat alisin sa mga file na pinangalanan sa
patch file. Kung walang ibinigay na numeric na argumento, kumalas maghihinuha ng angkop
base sa numero kung anong mga file ang naroroon sa filesystem.

-r, --palitan
Karaniwan ang pinagsamang output ay nakasulat sa standard-output. Sa --palitan, ang
ang orihinal na file ay pinalitan ng merge na output. Sa browse mode, ito ay nagtuturo
kumalas para laging i-save ang resultang pagsasama kapag lalabas.

-o, --output=
Sa halip na isulat ang resulta sa stdout o palitan ang orihinal na file, ito
humihiling na ang output ay isulat sa ibinigay na file. Ito ay makabuluhan lamang
sa --pagsamahin or --browse kapag binigyan ng isang pagsasama para mag-browse.

Ino-override ang opsyong ito -r.

-R, --baligtad
Kapag ginamit kasama ng Diff function, palitan ang mga file bago kalkulahin ang
pagkakaiba. Kapag ginamit kasama ng pagsamahin or browse mga function, kumalas pagtatangka upang
ibalik ang mga pagbabago sa halip na ilapat ang mga ito.

-i, --huwag pansinin
Karaniwang babalewalain ng wiggle ang mga pagbabago sa patch na tila nangyari na
inilapat sa orihinal. Sa flag na ito, ang mga pagbabagong iyon ay iniulat bilang mga salungatan
kaysa hindi papansinin.

-W, --show-wiggles
Kapag ginamit sa --pagsamahin, ang mga salungatan na maaaring i-wiggle sa lugar ay iniulat bilang
sumasalungat sa isang karagdagang saknong na nagpapakita kung ano ang magiging resulta kung ang bandilang ito
ay hindi ginamit. Ang dagdag na saknong ay introduce na may linyang naglalaman ng 7
ampersand (&) mga character kaya:
<<<<<<<< natagpuan
Ilang bahagi ng orihinal na file
||||||| inaasahan
papalitan ng text
=======
teksto upang palitan ito ng
&&&&&&& resolution
Text na magreresulta mula sa isang matagumpay na pag-wiggle
>>>>>>> kapalit

--ulat-wiggles
Kung ang isang pagsasanib ay matagumpay sa paglalapat ng lahat ng mga pagbabago, karaniwan itong lalabas na may a
katayuan ng tagumpay (0), ang pag-uulat lamang ng pagkabigo (1) kung may nangyaring salungatan at nangyari
annotated. Sa --ulat-wiggles kumalas mag-uulat din ng kabiguan kung may mga pagbabago
kinailangang i-wiggle in. Maaari itong maging kapaki-pakinabang kapag kumalas ay ginagamit para sa mga awtomatikong pagsasanib
tulad ng sa pumunta. Kung may mga pag-urong mangyari, pumunta ay mag-uulat ng kabiguan, at ang mga resulta
maaaring suriin upang kumpirmahin na sila ay katanggap-tanggap.

-h, - Tumulong
Mag-print ng simpleng mensahe ng tulong. Kung ibinigay pagkatapos ng isa sa mga tagapili ng function
(--pagsamahin, --diff, --extract, --browse) tulong na partikular sa function na iyon ay ipinapakita.

-V, --bersyon
Ipakita ang numero ng bersyon ng kumalas.

-v, --verbose
Paganahin ang verbose mode. Sa kasalukuyan, wala itong pinagkaiba.

-q, --tahimik
Paganahin ang quiet mode. Pinipigilan nito ang mensahe mula sa merge function kapag naroon
ay hindi malulutas na mga salungatan.

Mga salita
kumalas maaaring hatiin ang isang teksto sa mga linya o salita kapag nagsasagawa ng mga gawain. Simple lang ang isang linya
isang string ng mga character na winakasan ng isang bagong linya. Ang isang salita ay alinman sa pinakamataas na magkadikit
string ng alphanumerics (kabilang ang underscore), isang pinakamataas na magkadikit na string ng espasyo o
mga character sa tab, o anumang iba pang solong character.

Sumanib
Binabago ng merge function ang isang naibigay na text sa pamamagitan ng paghahanap ng lahat ng pagbabago sa pagitan ng dalawa pang text
at pagpapataw ng mga pagbabagong iyon sa ibinigay na teksto.

Karaniwan kumalas nakatutok sa kung aling mga salita ang nagbago upang mapakinabangan ang posibilidad ng
paghahanap ng magandang tugma sa ibinigay na teksto para sa konteksto ng isang ibinigay na pagbabago. Gayunpaman maaari itong
isaalang-alang lamang ang buong linya sa halip.

kumalas kinukuha ang tatlong teksto na kailangan nito mula sa mga file na nakalista sa command line.
Maaaring nakalista ang alinman sa 1, 2, o 3 file, at ang alinman sa mga ito ay maaaring isang solong gitling na nagpapahiwatig
karaniwang-input.

Kung ang isang file ay ibinigay at ang -p ang opsyon ay wala, ang file ay itinuturing bilang a pagsamahin
file, ibig sabihin, ang output ng "merge -A" o "wiggle". Ang nasabing file ay tahasang naglalaman ng tatlo
stream at ang mga ito ay kinuha at inihambing.

Kung ang dalawang file ay ibinigay, ang una ay naglalaman lamang ng pangunahing teksto, at ang pangalawa ay
itinuturing bilang isang patch file (ang output ng "diff -u" o "diff -c", o isang ".rej" na file mula sa
magtagpi) at ang dalawang iba pang mga teksto ay kinuha mula doon.

Kung ang isang file ay ibinigay kasama ng -p opsyon, ang file ay itinuturing bilang isang patch file
naglalaman ng mga pangalan ng mga file na tina-patch nito. Sa kasong ito, maramihang merge operations
maaaring mangyari at bawat isa ay kumukuha ng isang stream mula sa isang file na pinangalanan sa patch, at ang iba pang dalawa
mula sa patch mismo. Ang --palitan ang opsyon ay kinakailangan at ang mga resulta ay isusulat pabalik
sa mga target na file.

Sa wakas kung tatlong mga file ang nakalista, dadalhin sila upang maglaman ng ibinigay na teksto at ang dalawa
iba pang mga teksto, sa pagkakasunud-sunod.

Karaniwan ang resulta ng pagsasanib ay nakasulat sa standard-output. Kung ang -r ang bandila ay ibinigay,
ang output ay nakasulat sa isang file na pumapalit sa orihinal na ibinigay na file. Sa kasong ito ang
ang orihinal na file ay pinalitan ng pangalan upang magkaroon ng a .porig suffix (para sa "na-patch na orihinal" na may katuturan
kung una mong gagamitin magtagpi upang maglapat ng isang patch, at pagkatapos ay gamitin kumalas upang i-wiggle ang mga tinatanggihan).

Dagdag pa kung ang -o Ang pagpipilian ay ibinigay na may isang pangalan ng file, ang output ay isusulat doon
file. Sa kasong ito, walang ginawang backup.

Kung walang nangyaring mga error (tulad ng mga error sa pag-access ng file) kumalas lalabas na may status na 0 kung lahat
matagumpay na pinagsama ang mga pagbabago, at may exit status na 1 at isang maikling mensahe kung mayroon
ang mga pagbabago ay hindi maaaring ganap na pagsamahin at sa halip ay ipinasok bilang mga anotasyon. Gayunpaman kung
alinman sa --ulat-wiggles or --show-wiggles ibinigay ang mga pagpipilian, kumalas magkakaroon din ng kasama
status ng 1 kung anumang pagbabago ang kailangang i-wiggle in kahit na ito ay matagumpay.

Maaaring gumana ang merge function sa tatlong magkakaibang mga mode na may kinalaman sa mga linya o salita.

Kasama ang --mga linya opsyon, ang buong linya ay inihahambing at anumang mga salungatan ay iniuulat bilang buo
mga linyang kailangang palitan.

Kasama ang --mga salita opsyon, ang mga indibidwal na salita ay inihahambing at anumang mga salungatan ay iniulat nang makatarungan
sumasaklaw sa mga salitang apektado. Ito ay gumagamit ng <<<|||===>>> conflict format.

Kung wala ang alinman sa mga opsyong ito, isang hybrid na diskarte ang kinukuha. Ang mga indibidwal na salita ay
inihambing at pinagsanib, ngunit kapag natagpuan ang isang salungatan ay iniuulat ang buong nakapaligid na linya
bilang magkasalungatan.

kumalas titiyakin na ang bawat pagbabago sa pagitan ng dalawa pang teksto ay makikita sa
resulta ng pagsasanib kahit papaano. Mayroong apat na magkakaibang paraan kung saan maaaring magkaroon ng pagbabago
nasasalamin.

1 Kung ang isang pagbabago ay magbabalik-loob A sa B at A ay matatagpuan sa isang angkop na lugar sa orihinal
file, ito ay pinalitan ng B. Kabilang dito ang posibilidad na B ay walang laman, ngunit
hindi iyan A walang laman.

2 Kung may nakitang pagbabago na nagdaragdag lamang B at ang teksto kaagad na nauuna at
kasunod ng pagpasok ay matatagpuan sa tabi ng orihinal na file sa isang angkop
lugar, pagkatapos B ay ipinasok sa pagitan ng mga katabing teksto.

3 Kung may nakitang pagbabago na nagbabago A sa B at ito ay lilitaw (batay sa konteksto) sa
nakahanay sa B sa orihinal, pagkatapos ay ipinapalagay na ang pagbabagong ito ay nangyari na
inilapat, at binabalewala ang pagbabago. Kapag nangyari ito, isang mensahe na sumasalamin sa
bilang ng mga binalewalang pagbabago ay ini-print ni kumalas. Ang pag-optimize na ito ay maaaring
pinigilan sa -i bandila.

4 Kung may nakitang pagbabago na hindi umaangkop sa alinman sa mga posibilidad sa itaas, a
ang salungatan ay iniulat tulad ng inilarawan sa itaas.

DIFF
Ang diff function ay pangunahing ibinibigay upang payagan ang inspeksyon ng mga alignment na iyon kumalas
kinakalkula sa pagitan ng mga teksto at na ginagamit nito para sa pagsasagawa ng isang pagsasanib.

Ang output ng diff function ay katulad ng pinag-isang output ng diff. Gayunpaman habang
Ang diff ay hindi naglalabas ng mahahabang bahagi ng karaniwang teksto, kumalasAng diff mode ay naglalabas ng lahat.

Kapag nagkalkula ng word-based alignment (ang default), kumalas maaaring kailanganing ipakita ang mga salitang ito-
batay sa mga pagkakaiba. Ginagawa ito gamit ang isang extension sa unified-diff na format. Kung isang linya
nagsisimula sa isang patayong bar, pagkatapos ay maaari itong maglaman ng mga seksyon na napapalibutan ng mga espesyal na multi-
mga bracket ng character. Ang mga bracket na "<<<<++" at "++>>>" ay nakapalibot ay nagdagdag ng teksto habang "<<<--"
at "-->>>" surround inalis na text.

kumalas maaaring ibigay ang dalawang teksto upang ihambing sa isa sa tatlong paraan.

Kung isang file lamang ang ibinigay, ito ay ituturing bilang isang patch at ang dalawang sangay nito
inihambing ang patch. Ito ay epektibong nagbibigay-daan sa isang patch na mapino mula sa isang line-based na patch
sa isang patch na nakabatay sa salita.

Kung binigay ang dalawang file, karaniwang ipinapalagay na mga simpleng teksto ang ihahambing.

Kung ang dalawang file ay ibinigay kasama ang --patch na opsyon, pagkatapos ay ang pangalawang file ay ipinapalagay na
maging isang patch at alinman sa una (na may -1) o ang pangalawa (na may -2) na sangay ay nakuha at
kumpara sa text na natagpuan sa unang file.

Ang huling opsyon na ito ay sanhi kumalas para maglapat ng "best-fit" na algorithm para sa pag-align ng mga patch hunks
gamit ang file bago kalkulahin ang mga pagkakaiba. Ginagamit ang algorithm na ito kapag pinagsama ang a
patch na may isang file, at ang halaga nito ay makikita sa pamamagitan ng paghahambing ng pagkakaiba na ginawa sa ganitong paraan
na may pagkakaiba na ginawa sa pamamagitan ng unang pagkuha ng isang sangay ng isang patch sa isang file, at
pagkatapos ay i-compute ang pagkakaiba ng file na iyon sa pangunahing file.

MAGBABAGO
Ang extract function ng kumalas inilalantad lamang ang panloob na pag-andar para sa pag-extract
isang sangay ng isang patch o isang merge file.

Eksaktong isang file ang dapat ibigay, at ito ay ipagpalagay na isang merge file maliban kung
--tagpi ay ibinigay, kung saan ang isang patch ay ipinapalagay.

Ang pagpili ng sangay sa ginawa sa pamamagitan ng pagbibigay ng isa sa -1, -2, O -3 na may malinaw na kahulugan.

MABUTI
Ang browse function ng kumalas nagpapakita ng resulta ng isang pagsasanib o (sa -d) isang pagkakaiba sa a
text-based na GUI na maaaring i-navigate gamit ang mga keystroke na katulad ng vi(1) o emacsNa (1).

Ang browser ay nagbibigay-daan sa bawat isa sa dalawa o tatlong stream na tingnan nang isa-isa
mga kulay na ginagamit upang i-highlight ang iba't ibang uri ng teksto - berde para sa idinagdag na teksto, pula para sa tinanggal
text at iba pa. Maaari rin nitong ipakita ang patch nang mag-isa, ang buong resulta ng pagsasanib, o ang
merge at ang patch na magkatabi.

Nagbibigay ang browser ng ilang page ng tulong na sensitibo sa konteksto na maaaring ma-access ng
nagta-type '?'

Ang kanang tuktok ng GUI ay mag-uulat ng uri ng teksto sa ilalim ng cursor, na ganoon din
ipinahihiwatig ng kulay ng teksto. Ang mga Pagpipilian ay Hindi Nagbabago, Binago, Walang Katumbas,
Extraneous, Nailapat na at Conflict. Kung ang mga kahulugan ng mga ito ay malinaw ng kaunti
dapat makatulong ang mga eksperimento.

Ang isang limitadong halaga ng pag-edit ay pinahihintulutan habang nasa browse mode. Kasalukuyang text iyon
ang hindi gusto ay maaaring itapon sa x. Iko-convert nito ang Conflict o Change to Unchanged,
at isang Unmatched to Changed (na epektibong binabago ito sa walang laman na string). Ganun din
ang isang teksto ay maaaring mamarkahan bilang gusto c. Ito ay magko-convert ng Conflict o Extraneous sa
Nagbago. Ang paggamit muli ng parehong key ay ibabalik ang pagbabago.

Panghuli, ang uppercase X ay ibabalik ang lahat ng mga pagbabago sa kasalukuyang linya.

Para makagawa ng mas malawak na pagbabago na magagamit mo v na nagpapatakbo ng isang editor, mas pinipili $VISUAL or
$ EDITOR kung sila ay nakatakda sa kapaligiran.

Kung gagawa ka ng anumang mga pagbabago, tatanungin ka ng wiggle kung gusto mong i-save ang mga pagbabago, kahit na
--palitan hindi binigay.

BABALA

Dapat palaging mag-ingat kapag nag-aaplay ng tinanggihang patch na may kumalas. Kailan magtagpi
tinatanggihan ang isang patch, ginagawa ito para sa isang magandang dahilan. Kahit na kumalas maaaring makahanap ng a
mapagkakatiwalaang lugar upang ilapat ang bawat pagbabago sa teksto, walang garantiya na ang resulta ay
tama sa anumang semantikong kahulugan. Ang resulta ay dapat palaging siniyasat upang matiyak na ito ay
iwasto.

HALIMBAWA

kumalas --palitan file file.rej
Ito ang normal na paggamit ng kumalas at kukuha ng anumang pagbabago file.rej na magtagpi maaari
hindi nalalapat, at pagsamahin ang mga ito sa file.

kumalas -dp1 file file.rej
Magsasagawa ito ng word-wise na paghahambing sa pagitan ng file at ang bago sangay ng
pagkakaiba sa file.rej at ipakita ang mga pagkakaiba. Nagbibigay-daan ito sa iyo na makita kung saan ang ibinigay na patch
mag-aaplay.

kumalas --pagsamahin - Tumulong
Humingi ng tulong tungkol sa merge function ng kumalas.

kumalas --browse --tagpi update.patch
I-parse ang update.patch file para sa mga patch at magpakita ng listahan ng mga naka-patch na file na maaaring
na-browse upang suriin ang bawat patch nang detalyado.

kumalas maaaring isama sa pumunta upang magamit ito bilang default na tool sa pagsasama at diff
kasangkapan. Ito ay maaaring makamit sa pamamagitan ng pagdaragdag ng mga sumusunod na linya sa .gitconfig sa bahay ng gumagamit
direktoryo.
[pagsamahin ang "kawag-kawag"]
name = "Wiggle flexible merging"
driver = wiggle -o %A %A %O %B
recursive = binary
[pagsamahin]
kasangkapan = kumawag-kawag
[mergetool "wiggle"]
cmd = wiggle -B -o $MIGAD $LOCAL $BASE $REMOTE
[difftool "wiggle"]
cmd = wiggle -Bd $LOCAL $REMOTE
Gagawin ito pumunta mergetool at pumunta difftool gamitin kumalas.

Kung nais mong pumunta para laging gamitin kumalas para sa mga pagsasanib (na maaaring mapanganib), maaari mong idagdag
* pagsamahin=kawag-kawag
sa isang angkop gitattributes file tulad ng $HOME/.config/git/attributes.

QUOTE

Ang pangalan ng kumalas ay inspirasyon ng sumusunod na quote.

Ang problemang nakita ko ay madalas kong gustong kunin
(file1+patch) -> file2,
kapag wala akong file1. Ngunit nais na kunin ang mga tool sa pagsamahin
(file1|file2) -> file3.
Wala akong nakitang graphical na tool na tumutulong sa iyo na i-wiggle ang isang patch
sa isang file.
-- Andrew Morton - 2002

MGA PAGKAKAKULANG

- kumalas hindi mabasa ang pinalawig na unified-diff na output na ginagawa nito para sa --diff
--mga salita.

- kumalas hindi mabasa ang word-based na merge na format na ginagawa nito para sa --merge
--mga salita.

- kumalas ay hindi naiintindihan ang unicode at sa gayon ay ituturing ang lahat ng hindi ASCII na mga character
katulad ng pagtrato nito sa bantas - ituturing nito ang bawat isa bilang isang hiwalay na salita. Ang
hindi ipapakita ng browser nang maayos ang mga hindi ASCII na character.

Gumamit ng wiggle online gamit ang mga serbisyo ng onworks.net