├── README.md
├── .gitignore
├── src
    ├── diffy.app.src
    ├── diffy_term.erl
    ├── diffy_simple_patch.erl
    └── diffy.erl
├── rebar.config
├── Makefile
├── LICENSE
└── test
    └── diffy_tests.erl


/README.md:
--------------------------------------------------------------------------------
1 | # Diffy
2 | 
3 | Moved to https://github.com/zotonic/diffy
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | rebar
 2 | ebin
 3 | .eunit
 4 | deps
 5 | *.o
 6 | *.beam
 7 | *.plt
 8 | erl_crash.dump
 9 | tags
10 | 


--------------------------------------------------------------------------------
/src/diffy.app.src:
--------------------------------------------------------------------------------
1 | {application, diffy,
2 |   [
3 |     {description, "Diff, match patch implementation."},
4 |     {vsn, "0.1"},
5 |     {registered, []},
6 |     {applications, [kernel, stdlib]},
7 |     {env, []}
8 | ]}.
9 | 


--------------------------------------------------------------------------------
/rebar.config:
--------------------------------------------------------------------------------
1 | {erl_opts, [debug_info, warn_unused_vars, warn_shadow_vars]}.
2 | {deps, [
3 | 	{z_stdlib, ".*", {git, "git://github.com/zotonic/z_stdlib.git", {branch, "0.x"}}},
4 | 
5 | 	%% For testing
6 | 	{proper, "", {git, "git://github.com/manopapad/proper.git", {branch, "master"}}}
7 | ]}.
8 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | PROJECT = diffy 
 2 | REBAR := $(shell which rebar 2>/dev/null || echo ./rebar)
 3 | REBAR_URL := https://github.com/downloads/basho/rebar/rebar
 4 | DIALYZER = dialyzer
 5 | 
 6 | all: compile
 7 | 
 8 | ./rebar:
 9 | 	erl -noshell -s inets start -s ssl start \
10 |         -eval '{ok, saved_to_file} = httpc:request(get, {"$(REBAR_URL)", []}, [], [{stream, "./rebar"}])' \
11 |         -s inets stop -s init stop
12 | 	chmod +x ./rebar
13 | 	
14 | compile: rebar
15 | 	$(REBAR) compile
16 | 
17 | eunit: rebar
18 | 	$(REBAR) get-dep compile
19 | 	$(REBAR) eunit -v skip_deps=true
20 | 
21 | clean: rebar
22 | 	$(REBAR) clean
23 | 
24 | distclean: 
25 | 	rm $(REBAR)
26 | 
27 | 
28 | # dializer 
29 | 
30 | build-plt:
31 | 	@$(DIALYZER) --build_plt --output_plt .$(PROJECT).plt \
32 | 		--apps erts kernel stdlib -r deps
33 | 
34 | dialyze:
35 | 	@$(DIALYZER) -pa deps/*/ebin --src src --plt .$(PROJECT).plt --no_native \
36 | 		-Werror_handling -Wrace_conditions -Wunmatched_returns 
37 | 


--------------------------------------------------------------------------------
/src/diffy_term.erl:
--------------------------------------------------------------------------------
 1 | %% @author Maas-Maarten Zeeman <mmzeeman@xs4all.nl>
 2 | %% @copyright 2014 Maas-Maarten Zeeman
 3 | %%
 4 | %% @doc Diffy, an erlang diff match and patch implementation 
 5 | %%      Adapted from diffy.erl for simple diff on a list of Erlang terms
 6 | %%
 7 | %% Copyright 2014-2015 Maas-Maarten Zeeman, Marc Worrell
 8 | %%
 9 | %% Licensed under the Apache License, Version 2.0 (the "License");
10 | %% you may not use this file except in compliance with the License.
11 | %% You may obtain a copy of the License at
12 | %% 
13 | %%     http://www.apache.org/licenses/LICENSE-2.0
14 | %% 
15 | %% Unless required by applicable law or agreed to in writing, software
16 | %% distributed under the License is distributed on an "AS IS" BASIS,
17 | %% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 | %% See the License for the specific language governing permissions and
19 | %% limitations under the License.
20 | %% Erlang diff-match-patch implementation
21 | 
22 | -module(diffy_term).
23 | 
24 | -export([
25 |     diff/2
26 | ]).
27 | 
28 | -type diff_op() :: delete | equal | insert.
29 | -type diff() :: {diff_op(), unicode:unicode_binary()}.
30 | -type diffs() :: list(diff()).
31 | 
32 | -export_type([diffs/0]).
33 | 
34 | -spec diff(list(), list()) -> diffy:diffs().
35 | diff(A, A) ->
36 |     [{equal, A}];
37 | diff(A, []) ->
38 |     [{delete, A}];
39 | diff([], B) ->
40 |     [{insert, B}];
41 | diff(A, B) when is_list(A), is_list(B) ->
42 |     {Dict0, N} = term_dict(A, dict:new(), 0),
43 |     {Dict, _N} = term_dict(B, Dict0, N),
44 |     Diff = diffy:diff(map_terms(A, Dict), map_terms(B, Dict)),
45 |     unmap_diff(Diff, Dict).
46 | 
47 | term_dict([], D, N) ->
48 |     {D, N};
49 | term_dict([T|Ts], D, N) ->
50 |     case dict:is_key(T, D) of
51 |         true ->
52 |             term_dict(Ts, D, N);
53 |         false ->
54 |             D1 = dict:store(T, N, D),
55 |             term_dict(Ts, D1, N+1)
56 |     end.
57 | 
58 | map_terms(A, Dict) ->
59 |     T = [ dict:fetch(K, Dict) || K <- A ],
60 |     unicode:characters_to_binary(T).
61 | 
62 | unmap_diff(Ds, Dict) ->
63 |     RDict = dict:from_list([ {N,T} || {T,N} <- dict:to_list(Dict) ]),
64 |     [ unmap_diff_1(D, RDict) || D <- Ds ].
65 | 
66 | unmap_diff_1({Op, B}, RDict) ->
67 |     Cs = unicode:characters_to_list(B),
68 |     {Op, [ dict:fetch(C, RDict) || C <- Cs ]}.
69 | 
70 | 
71 | 
72 | -ifdef(TEST).
73 | 
74 | -include_lib("eunit/include/eunit.hrl").
75 | 
76 | diffy_term_test() ->
77 |     ?assertEqual(
78 |         [{equal,[a]}],
79 |         diffy_term:diff([a], [a])),
80 |     ?assertEqual(
81 |         [{insert,[a]}],
82 |         diffy_term:diff([], [a])),
83 |     ?assertEqual(
84 |         [{delete,[a]}],
85 |         diffy_term:diff([a], [])),
86 |     ?assertEqual(
87 |         [{equal,[a]},{insert,[e]},{equal,[b,c,d]},{delete,[e]}],
88 |         diffy_term:diff([a,b,c,d,e], [a,e,b,c,d])),
89 |     ok.
90 | 
91 | 
92 | -endif.
93 | 
94 | 
95 | 


--------------------------------------------------------------------------------
/src/diffy_simple_patch.erl:
--------------------------------------------------------------------------------
  1 | %% @author Maas-Maarten Zeeman <mmzeeman@xs4all.nl>
  2 | %% @copyright 2014 Maas-Maarten Zeeman
  3 | %%
  4 | %% @doc Diffy, an erlang diff match and patch implementation 
  5 | %%
  6 | %% Copyright 2014 Maas-Maarten Zeeman
  7 | %%
  8 | %% Licensed under the Apache License, Version 2.0 (the "License");
  9 | %% you may not use this file except in compliance with the License.
 10 | %% You may obtain a copy of the License at
 11 | %% 
 12 | %%     http://www.apache.org/licenses/LICENSE-2.0
 13 | %% 
 14 | %% Unless required by applicable law or agreed to in writing, software
 15 | %% distributed under the License is distributed on an "AS IS" BASIS,
 16 | %% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 17 | %% See the License for the specific language governing permissions and
 18 | %% limitations under the License.
 19 | %% Erlang diff-match-patch implementation
 20 | 
 21 | -module(diffy_simple_patch).
 22 | 
 23 | -export([make_patch/1, apply_patch/2]).
 24 | 
 25 | 
 26 | %% Make a simple patch with edit operations.
 27 | %%
 28 | make_patch(Diffs) ->
 29 |     make_patch(Diffs, []).
 30 | 
 31 | %% @doc Make a simple patch. Removes the data from equal and delete 
 32 | %% operations and replaces it with a line and char count.
 33 | make_patch([], [{copy, _}]) ->
 34 |     [];
 35 | make_patch([], Acc) ->
 36 |     lists:reverse(Acc);
 37 | make_patch([{insert, _}=H|Rest], Acc) ->
 38 |     make_patch(Rest, [H|Acc]);
 39 | make_patch([{Op, Data}|Rest], Acc) ->
 40 |     make_patch(Rest, [{patch_op(Op), size(Data)}|Acc]).
 41 | 
 42 | patch_op(delete) -> skip;
 43 | patch_op(equal) -> copy.
 44 | 
 45 | % @doc Use the SourceText to reconstruct the destination text.
 46 | apply_patch(SourceText, Diffs) ->
 47 |     apply_patch(SourceText, 0, Diffs, []).
 48 | 
 49 | apply_patch(_SourceText, _Idx, [], Acc) ->
 50 |     erlang:iolist_to_binary(lists:reverse(Acc));
 51 | apply_patch(SourceText, Idx, [{insert, Data}|Rest], Acc) ->
 52 |     apply_patch(SourceText, Idx, Rest, [Data|Acc]);
 53 | 
 54 | %% New simple interface, just use the binary length.
 55 | apply_patch(SourceText, Idx, [{copy, BinLen}|Rest], Acc) when Idx + BinLen =< size(SourceText) ->
 56 |     <<_:Idx/binary, Data:BinLen/binary, _Rest/binary>> = SourceText,
 57 |     apply_patch(SourceText, Idx+BinLen, Rest, [Data|Acc]);
 58 | apply_patch(SourceText, Idx, [{skip, BinLen}|Rest], Acc) when Idx + BinLen =< size(SourceText) ->
 59 |     apply_patch(SourceText, Idx+BinLen, Rest, Acc);
 60 | 
 61 | %% Old interface which counts lines and remaining chars.
 62 | apply_patch(SourceText, Idx, [{copy, Lines, Chars}|Rest], Acc) ->
 63 |     LineData = get_lines(SourceText, Idx, Lines),
 64 |     CharData = get_chars(SourceText, Idx+size(LineData), Chars),
 65 |     %% Get the data from the source-text.
 66 |     apply_patch(SourceText, Idx+size(LineData)+size(CharData), Rest, [CharData, LineData|Acc]);
 67 | apply_patch(SourceText, Idx, [{skip, Lines, Chars}|Rest], Acc) ->
 68 |     LineData = get_lines(SourceText, Idx, Lines),
 69 |     CharData = get_chars(SourceText, Idx+size(LineData), Chars),
 70 |     %% Advance the index
 71 |     apply_patch(SourceText, Idx+size(LineData)+size(CharData), Rest, Acc).
 72 | 
 73 | %% Get the data from N lines.
 74 | get_lines(Source, Idx, Lines) ->
 75 |     get_lines(Source, Idx, Lines, <<>>).
 76 | 
 77 | get_lines(_Source, _Idx, 0, Acc) ->
 78 |     Acc;
 79 | get_lines(Source, Idx, Lines, Acc) ->
 80 |     case binary:match(Source, <<"\n">>, [{scope, {Idx, size(Source) - Idx}}]) of
 81 |         nomatch ->
 82 |             Acc;
 83 |         {Start, _} ->
 84 |             LineSize = Start-Idx+1,
 85 |             <<_:Idx/binary, Line:LineSize/binary, _Rest/binary>> = Source,
 86 |             get_lines(Source, Start+1, Lines-1, <<Acc/binary, Line/binary>>)
 87 |     end.
 88 | 
 89 | %% @doc Get the chardata for NChars from Source.
 90 | get_chars(Source, Idx, Chars) ->
 91 |     get_chars(Source, Idx, Chars, <<>>).
 92 | 
 93 | get_chars(_Source, _Idx, 0, CharData) ->
 94 |     CharData;
 95 | get_chars(Source, Idx, Chars, CharData) ->
 96 |     <<_:Idx/binary, C/utf8, _/binary>> = Source,
 97 |     S = size(<<C/utf8>>),
 98 |     get_chars(Source, Idx+S, Chars-1, <<CharData/binary, C/utf8>>).
 99 | 
100 | 
101 | %%
102 | %% Tests
103 | %%
104 | 
105 | -ifdef(TEST).
106 | 
107 | -include_lib("eunit/include/eunit.hrl").
108 | 
109 | make_patch_test() ->
110 |     ?assertEqual([], make_patch([])),
111 |     ?assertEqual([], make_patch([{equal, <<"foo">>}])),
112 |     ?assertEqual([{copy, 4}, {insert, <<"test">>}], 
113 |             make_patch([{equal, <<"foo\n">>}, {insert, <<"test">>}])),
114 | 
115 |     ok.
116 | 
117 | get_lines_test() ->
118 |     ?assertEqual(<<"hoi\n">>, get_lines(<<"hoi\n">>, 0, 1)),
119 |     ?assertEqual(<<"hoi\n\n">>, get_lines(<<"hoi\n\n">>, 0, 2)),
120 |     ?assertEqual(<<"oi\n\n">>, get_lines(<<"hoi\n\n">>, 1, 2)),
121 |     ok.
122 | 
123 | get_chars_test() ->
124 |     ?assertEqual(<<"h">>, get_chars(<<"hoi\n">>, 0, 1)),
125 |     ?assertEqual(<<"oi">>, get_chars(<<"hoi\n">>, 1, 2)),
126 |     ?assertEqual(<<"i\n">>, get_chars(<<"hoi\n">>, 2, 2)),
127 |     ok.
128 | 
129 | apply_patch_test() ->
130 |     A = <<"the cat\n\n   is in the hat\n">>,
131 |     B = <<"the rabbit eats\n\n a carrot\n  in the hat\n">>,
132 | 
133 |     Diffs = diffy:diff(A, B),
134 |     CDiffs = diffy:cleanup_efficiency(Diffs),
135 |     Patch = make_patch(CDiffs),
136 | 
137 |     %% Check if the transformation worked.
138 |     %%
139 |     ?assertEqual(B, erlang:iolist_to_binary(apply_patch(A, Patch))),
140 | 
141 |     ok.
142 | 
143 | 
144 | -endif.
145 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "{}"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright {yyyy} {name of copyright owner}
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 
203 | 


--------------------------------------------------------------------------------
/test/diffy_tests.erl:
--------------------------------------------------------------------------------
  1 | %% @author Maas-Maarten Zeeman <mmzeeman@xs4all.nl>
  2 | %% @copyright 2014 Maas-Maarten Zeeman
  3 | %%
  4 | %% @doc Diffy, an erlang diff match and patch implementation 
  5 | %%
  6 | %% Copyright 2014 Maas-Maarten Zeeman
  7 | %%
  8 | %% Licensed under the Apache License, Version 2.0 (the "License");
  9 | %% you may not use this file except in compliance with the License.
 10 | %% You may obtain a copy of the License at
 11 | %% 
 12 | %%     http://www.apache.org/licenses/LICENSE-2.0
 13 | %% 
 14 | %% Unless required by applicable law or agreed to in writing, software
 15 | %% distributed under the License is distributed on an "AS IS" BASIS,
 16 | %% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 17 | %% See the License for the specific language governing permissions and
 18 | %% limitations under the License.
 19 | %% Erlang diff-match-patch implementation
 20 | 
 21 | -module(diffy_tests).
 22 | 
 23 | -include_lib("proper/include/proper.hrl").
 24 | -include_lib("eunit/include/eunit.hrl").
 25 | 
 26 | %%
 27 | %% Properties
 28 | %%
 29 | 
 30 | prop_cleanup_merge() ->
 31 |     ?FORALL(Diffs, diffy:diffs(),
 32 |         begin
 33 |             SourceText = diffy:source_text(Diffs),
 34 |             DestinationText = diffy:destination_text(Diffs),
 35 | 
 36 |             CleanDiffs = cleanup_merge(Diffs),
 37 | 
 38 |             SourceText == diffy:source_text(CleanDiffs) andalso
 39 |             DestinationText == diffy:destination_text(CleanDiffs)
 40 |         end).
 41 | 
 42 | prop_cleanup_efficiency() ->
 43 |     ?FORALL(Diffs, diffy:diffs(),
 44 |         begin
 45 |             SourceText = diffy:source_text(Diffs),
 46 |             DestinationText = diffy:destination_text(Diffs),
 47 | 
 48 |             EfficientDiffs = cleanup_efficiency(Diffs),
 49 | 
 50 |             SourceText == diffy:source_text(EfficientDiffs) andalso
 51 |             DestinationText == diffy:destination_text(EfficientDiffs)
 52 |         end).
 53 | 
 54 | html_like() ->
 55 |     proper_types:resize(200,
 56 |                         list(frequency([{80, range($a, $z)},       % letters
 57 |                                         {20, oneof(["&amp;", "&gt;", "<script>", "<br />", "<p>", "</p>", "<div>", "</div>"])}, % tags
 58 |                                         {2, range(16#80, 16#7FF)}, % a couple of 2-byte unicode chars
 59 |                                         {2, range($0, $9)},        % numbers
 60 |                                         {2, $\s},                  % whitespace
 61 |                                         {4,  $\n},                 % linebreaks
 62 |                                         {2, oneof([$., $-, $!, $?, $,])}   % punctuation
 63 |                                        ]))).
 64 | 
 65 | prop_make_diff() ->
 66 |     ?FORALL({S, D}, {html_like(), html_like()},
 67 |         begin
 68 |             SourceText = unicode:characters_to_binary(lists:flatten(S), utf32, utf8),
 69 |             DestinationText = unicode:characters_to_binary(lists:flatten(D), utf32, utf8),
 70 | 
 71 |             Patches = diffy:diff(SourceText, DestinationText),
 72 | 
 73 |             SourceText == diffy:source_text(Patches) andalso DestinationText == diffy:destination_text(Patches)
 74 |         end).
 75 | 
 76 | prop_inner_diff() ->
 77 |     ?FORALL({OP, IO, IN, OS}, {html_like(), html_like(), html_like(), html_like()},
 78 |         begin
 79 |             OuterPrefix = unicode:characters_to_binary(lists:flatten(OP), utf32, utf8),
 80 |             InnerOld = unicode:characters_to_binary(lists:flatten(IO), utf32, utf8),
 81 |             InnerNew = unicode:characters_to_binary(lists:flatten(IN), utf32, utf8),
 82 |             OuterSuffix = unicode:characters_to_binary(lists:flatten(OS), utf32, utf8),
 83 | 
 84 |             SourceText = <<OuterPrefix/binary, InnerOld/binary, OuterSuffix/binary>>,
 85 |             DestinationText = <<OuterPrefix/binary, InnerNew/binary, OuterSuffix/binary>>,
 86 | 
 87 |             Patches = diffy:diff(SourceText, DestinationText),
 88 | 
 89 |             SourceText == diffy:source_text(Patches) andalso DestinationText == diffy:destination_text(Patches)
 90 |         end).
 91 | 
 92 | %%
 93 | %% Tests
 94 | %%
 95 | 
 96 | pretty_html_test() ->
 97 |     ?assertEqual(<<>>, pretty_html([])),
 98 |     ?assertEqual(<<"<span>>test</span>">>, pretty_html([{equal, <<"test">>}])),
 99 |     ?assertEqual(<<"<del style='background:#ffe6e6;'>foo</del><span>>test</span>">>, 
100 |         pretty_html([{delete, <<"foo">>}, {equal, <<"test">>}])),
101 |     ?assertEqual(<<"<ins style='background:#e6ffe6;'>foo</ins><span>>test</span>">>, 
102 |         pretty_html([{insert, <<"foo">>}, {equal, <<"test">>}])),
103 |     ok.
104 | 
105 | source_text_test() ->
106 |     ?assertEqual(<<"fruit flies like a banana">>, 
107 |         diffy:source_text([{equal,<<"fruit flies ">>}, {delete,<<"lik">>}, {equal,<<"e">>},
108 |             {insert,<<"at">>}, {equal,<<" a banana">>}])),
109 |     ok.
110 | 
111 | destination_text_test() ->
112 |     ?assertEqual(<<"fruit flies eat a banana">>, 
113 |         diffy:destination_text([{equal,<<"fruit flies ">>}, {delete,<<"lik">>}, {equal,<<"e">>},
114 |             {insert,<<"at">>}, {equal,<<" a banana">>}])),
115 |     ok.
116 | 
117 | 
118 | levenshtein_test() ->
119 |     ?assertEqual(0, diffy:levenshtein([])),
120 |     ?assertEqual(5, diffy:levenshtein([{equal,<<"fruit flies ">>}, {delete,<<"lik">>}, 
121 |         {equal,<<"e">>}, {insert,<<"at">>}, {equal,<<" a banana">>}])),
122 | 
123 |     % Levenshtein with trailing equality.
124 |     ?assertEqual(4, diffy:levenshtein([{delete, <<"abc">>}, {insert, <<"1234">>}, {equal, <<"xyz">>}])),
125 |     % Levenshtein with leading equality.
126 |     ?assertEqual(4, diffy:levenshtein([{equal, <<"xyz">>}, {delete, <<"abc">>}, {insert, <<"1234">>}])),
127 |     % Levenshtein with middle equality.
128 |     ?assertEqual(7, diffy:levenshtein([{delete, <<"abc">>}, {equal, <<"xyz">>}, {insert, <<"1234">>}])),
129 | 
130 |     ok.
131 | 
132 | make_patch_test() ->
133 | 	%% No patches...
134 | 	?assertEqual([], diffy:make_patch([])),
135 | 
136 | 	%% Source and destination text is the same.
137 | 	% ?assertEqual([], diffy:make_patch(<<>>, <<"abc">>)),
138 | 
139 | 	%% Source and destination text is the same.
140 | 	% ?assertEqual([], diffy:make_patch(<<"abc">>, <<"abc">>)),
141 | 
142 | 	ok.
143 |  
144 | cleanup_merge_test() ->
145 |     % no change..
146 |     ?assertEqual([], cleanup_merge([])),
147 | 
148 |     % no change
149 |     ?assertEqual([{equal, <<"a">>}, {delete, <<"b">>}, {insert, <<"c">>}], 
150 |         cleanup_merge([{equal, <<"a">>}, {delete, <<"b">>}, {insert, <<"c">>}])),
151 | 
152 |     % Merge equalities
153 |     ?assertEqual([{equal, <<"abc">>}], 
154 |         cleanup_merge([{equal, <<"a">>}, {equal, <<"b">>}, {equal, <<"c">>}])),
155 |     ?assertEqual([{delete, <<"abc">>}], 
156 |         cleanup_merge([{delete, <<"a">>}, {delete, <<"b">>}, {delete, <<"c">>}])),
157 |     ?assertEqual([{insert, <<"abc">>}], 
158 |         cleanup_merge([{insert, <<"a">>}, {insert, <<"b">>}, {insert, <<"c">>}])),
159 | 
160 |     % Merge interweaves before equal operations
161 |     ?assertEqual([{delete, <<"ac">>}, {insert, <<"bd">>}, {equal, <<"ef">>}], 
162 |         cleanup_merge([{delete, <<"a">>}, {insert, <<"b">>}, {delete, <<"c">>}, {insert, <<"d">>}, 
163 |             {equal, <<"e">>}, {equal, <<"f">>}])),
164 | 
165 |     % Prefix and suffix detection with equalities.
166 |     ?assertEqual([{equal, <<"xa">>}, {delete, <<"d">>}, {insert, <<"b">>}, {equal, <<"cy">>}], 
167 |         cleanup_merge([{equal, <<"x">>}, {delete, <<"a">>}, {insert, <<"abc">>}, {delete, <<"dc">>}, {equal, <<"y">>}])),
168 | 
169 |     % Slide left edit
170 |     ?assertEqual([{insert, <<"ab">>}, {equal, <<"ac">>}],
171 |         cleanup_merge([{equal, <<"a">>}, {insert, <<"ba">>}, {equal, <<"c">>}])),
172 | 
173 |     % Slide right edit
174 |     ?assertEqual([{equal, <<"ca">>}, {insert, <<"ba">>}],
175 |         cleanup_merge([{equal, <<"c">>}, {insert, <<"ab">>}, {equal, <<"a">>}])),
176 | 
177 |     % Slide edit left recursive.
178 |     ?assertEqual([{delete, <<"abc">>}, {equal, <<"acx">>}],
179 |         cleanup_merge([{equal, <<"a">>}, {delete, <<"b">>}, {equal, <<"c">>}, {delete, <<"ac">>}, {equal, <<"x">>}])),
180 | 
181 |     % Slide edit right recursive
182 |     ?assertEqual([{equal, <<"xca">>}, {delete, <<"cba">>}],
183 |         cleanup_merge([{equal, <<"x">>}, {delete, <<"ca">>}, {equal, <<"c">>}, {delete, <<"b">>}, {equal, <<"a">>}])),
184 | 
185 |     ok.
186 | 
187 | cleanup_merge_prop_test() ->
188 |     ?assertEqual(true, proper:quickcheck(prop_cleanup_merge(), [{numtests, 500}, {to_file, user}])),
189 |     ok.
190 | 
191 | cleanup_semantic_test() ->
192 |     % No diffs case
193 |     ?assertEqual([], cleanup_semantic([])),
194 | 
195 |     % No elimination #1.
196 |     ?assertEqual([{delete, <<"ab">>}, {insert, <<"cd">>}, {equal, <<"12">>}, {delete, <<"e">>}],
197 |         cleanup_semantic([{delete, <<"ab">>}, {insert, <<"cd">>}, {equal, <<"12">>}, {delete, <<"e">>}])),
198 | 
199 |     % No elimination #2. 
200 |     ?assertEqual([{delete, <<"abc">>}, {insert, <<"ABC">>}, {equal, <<"1234">>}, {delete, <<"wxyz">>}], 
201 |         cleanup_semantic([{delete, <<"abc">>}, {insert, <<"ABC">>}, {equal, <<"1234">>}, {delete, <<"wxyz">>}])),
202 | 
203 |     % % Simple elimination.
204 |     % ?assertEqual([{delete, <<"abc">>}, {insert, <<"b">>}], 
205 |     %     cleanup_semantic([{delete, <<"a">>}, {equal, <<"b">>}, {delete, <<"c">>}])),
206 | 
207 |     % % Multiple eliminations.
208 |     % ?assertEqual([{delete, <<"AB_AB">>}, {insert, <<"1A2_1A2">>}], 
209 |     %     cleanup_semantic([{insert, <<"1">>}, {equal, <<"A">>}, {delete, <<"B">>}, {insert, <<"2">>}, 
210 |     %         {equal, <<"_">>}, {insert, <<"1">>}, {equal, <<"A">>}, {delete, <<"B">>}, {insert, <<"2">>}])),
211 | 
212 |     ok.
213 | 
214 | cleanup_efficiency_prop_test() ->
215 |     ?assertEqual(true, proper:quickcheck(prop_cleanup_efficiency(), [{numtests, 500}, {to_file, user}])),
216 |     ok.
217 | 
218 | random_diffs_prop_test() ->
219 |     ?assertEqual(true, proper:quickcheck(prop_make_diff(), [{numtests, 500}, {to_file, user}])),
220 |     ok.
221 | 
222 | random_inner_diff_prop_test() ->
223 |     ?assertEqual(true, proper:quickcheck(prop_inner_diff(), [{numtests, 500}, {to_file, user}])),
224 |     ok.
225 | 
226 | cleanup_efficiency_test() ->
227 |     % Null case
228 |     ?assertEqual([], cleanup_semantic([])),
229 | 
230 |     % No elimination.
231 |     Diffs = [{delete, <<"ab">>}, {insert, <<"12">>}, {equal, <<"wxyz">>}, {delete, <<"cd">>}, {insert, <<"34">>}],
232 |     ?assertEqual(Diffs, cleanup_efficiency(Diffs)),
233 | 
234 |     % Four-edit elimination
235 |     ?assertEqual([{delete, <<"abxyzcd">>}, {insert, <<"12xyz34">>}], 
236 |         cleanup_efficiency([{delete, <<"ab">>}, {insert, <<"12">>}, {equal, <<"xyz">>}, {delete, <<"cd">>}, {insert, <<"34">>}])),
237 | 
238 |     % Three-edit elimination
239 |     ?assertEqual([{insert, <<"12x34">>}, {delete, <<"xcd">>}], 
240 |         cleanup_efficiency([{insert, <<"12">>}, {equal, <<"x">>}, {delete, <<"cd">>}, {insert, <<"34">>}])),
241 | 
242 |     % Backpass elimination
243 |     ?assertEqual([{delete, <<"abxyzcd">>}, {insert, <<"12xy34z56">>}],
244 |         cleanup_efficiency([{delete, <<"ab">>}, {insert, <<"12">>}, {equal, <<"xy">>}, {insert, <<"34">>}, 
245 |             {equal, <<"z">>}, {delete, <<"cd">>}, {insert, <<"56">>}])),
246 | 
247 |     ok.
248 | 
249 | text_size_test() ->
250 |     ?assertEqual(0, diffy:text_size(<<>>)),
251 |     ?assertEqual(3, diffy:text_size(<<"aap">>)),
252 |     ?assertEqual(3, diffy:text_size(<<"aap">>)),
253 |     ?assertEqual(4, diffy:text_size(<<229/utf8, 228/utf8, 246/utf8, 251/utf8>>)),
254 |     ?assertEqual(4, diffy:text_size(<<1046/utf8, 1011/utf8, 1022/utf8, 127/utf8>>)),
255 | 
256 |     %% Bad utf-8 input results in a badarg.
257 |     ?assertError(badarg, diffy:text_size(<<149,157,112,8>>)),
258 | 
259 |     ok.
260 | 
261 | diff_test() ->
262 |     %% No input, no diff
263 |     ?assertEqual([], diffy:diff(<<>>, <<>>)),
264 | 
265 |     %% Texts are equal
266 |     ?assertEqual([{equal, <<"String">>}], diffy:diff(<<"String">>, <<"String">>)),
267 | 
268 |     %% Insert and delete
269 |     ?assertEqual([{insert, <<"test">>}], diffy:diff(<<>>, <<"test">>)),
270 |     ?assertEqual([{delete, <<"test">>}], diffy:diff(<<"test">>, <<>>)),
271 | 
272 |     %% Longtext inside short text
273 |     ?assertEqual([{insert, <<"a-">>}, {equal, <<"test">>}, {insert, <<"-b">>}], 
274 |         diffy:diff(<<"test">>, <<"a-test-b">>)),
275 |     ?assertEqual([{delete, <<"a-">>}, {equal, <<"test">>}, {delete, <<"-b">>}], 
276 |         diffy:diff(<<"a-test-b">>, <<"test">>)),
277 | 
278 |     %% Single char insertions
279 |     ?assertEqual([{delete,<<"x">>},{insert,<<"test">>}],
280 |         diffy:diff(<<"x">>, <<"test">>)),
281 |     ?assertEqual([{delete, <<"test">>},{insert, <<"x">>}],
282 |         diffy:diff(<<"test">>, <<"x">>)),
283 | 
284 |     ?assertEqual([{equal, <<"a">>}, {delete, <<"b">>}, {insert, <<"c">>}],
285 |         diffy:diff(<<"ab">>, <<"ac">>)),
286 |     ?assertEqual([{delete, <<"a">>}, {insert, <<"c">>}, {equal, <<"b">>}],
287 |         diffy:diff(<<"ab">>, <<"cb">>)),
288 | 
289 |     ?assertEqual([{equal, <<"t">>},
290 |                   {insert, <<"e">>},
291 |                   {equal, <<"st">>}], diffy:diff(<<"tst">>, <<"test">>)),
292 | 
293 |     ?assertEqual([{equal,<<"cat ">>}, {insert,<<"mouse dog ">>}], 
294 |                  diffy:diff(<<"cat ">>,
295 |                             <<"cat mouse dog ">>)),
296 |     ok.
297 | 
298 | 
299 | %%
300 | %% Helpers
301 | %%
302 | 
303 | pretty_html(Diffs) ->
304 |     iolist_to_binary(diffy:pretty_html(Diffs)).
305 | 
306 | cleanup_efficiency(Diffs) ->
307 |     diffy:cleanup_efficiency(Diffs).
308 | 
309 | cleanup_semantic(Diffs) ->
310 |     diffy:cleanup_semantic(Diffs).
311 | 
312 | cleanup_merge(Diffs) ->
313 |     diffy:cleanup_merge(Diffs).
314 | 


--------------------------------------------------------------------------------
/src/diffy.erl:
--------------------------------------------------------------------------------
   1 | %% @author Maas-Maarten Zeeman <mmzeeman@xs4all.nl>
   2 | %% @copyright 2014-2019 Maas-Maarten Zeeman
   3 | %%
   4 | %% @doc Diffy, an erlang diff match and patch implementation 
   5 | %%
   6 | %% Copyright 2014-2019 Maas-Maarten Zeeman
   7 | %%
   8 | %% Licensed under the Apache License, Version 2.0 (the "License");
   9 | %% you may not use this file except in compliance with the License.
  10 | %% You may obtain a copy of the License at
  11 | %% 
  12 | %%     http://www.apache.org/licenses/LICENSE-2.0
  13 | %% 
  14 | %% Unless required by applicable law or agreed to in writing, software
  15 | %% distributed under the License is distributed on an "AS IS" BASIS,
  16 | %% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 | %% See the License for the specific language governing permissions and
  18 | %% limitations under the License.
  19 | %% Erlang diff-match-patch implementation
  20 | 
  21 | -module(diffy).
  22 | 
  23 | -export([
  24 |     diff/2,
  25 |     diff_bisect/2,
  26 |     diff_linemode/2,
  27 | 
  28 |     pretty_html/1,
  29 | 
  30 |     source_text/1,
  31 |     destination_text/1,
  32 | 
  33 |     cleanup_merge/1,
  34 |     cleanup_semantic/1,
  35 | 
  36 |     cleanup_efficiency/1,
  37 |     cleanup_efficiency/2,
  38 | 
  39 |     levenshtein/1,
  40 | 
  41 |     make_patch/1,
  42 |     make_patch/2,
  43 | 
  44 |     text_size/1,
  45 | 
  46 |     split_pre_and_suffix/2,
  47 |     unique_match/2
  48 | ]).
  49 | 
  50 | -type diff_op() :: delete | equal | insert.
  51 | -type diff() :: {diff_op(), unicode:unicode_binary()}.
  52 | -type diffs() :: list(diff()).
  53 | 
  54 | -export_type([diffs/0]).
  55 | 
  56 | -define(PATCH_MARGIN, 4).
  57 | -define(PATCH_MAX_PATCH_LEN, 32).
  58 | 
  59 | -define(MATCH_MAXBITS, 31).
  60 | 
  61 | -define(IS_INS_OR_DEL(Op), (Op =:= insert orelse Op =:= delete)).
  62 | 
  63 | -record(bisect_state, {
  64 |     k1start = 0, k1end = 0,
  65 |     k2start = 0, k2end = 0,
  66 |     v1,
  67 |     v2
  68 | }).
  69 | 
  70 | -record(patch, {
  71 |     diffs = [],
  72 | 
  73 |     start1 = 0,
  74 |     start2 = 0,
  75 | 
  76 |     length1 = 0,
  77 |     length2 = 0
  78 | }).
  79 | 
  80 | % @doc Compute the difference between two binary texts
  81 | %
  82 | -spec diff(unicode:unicode_binary(), unicode:unicode_binary()) -> diffs().
  83 | diff(Text1, Text2) ->
  84 |     diff(Text1, Text2, true).
  85 | 
  86 | diff(<<>>, <<>>, _CheckLines) ->
  87 |     [];
  88 | diff(Text1, Text2, _CheckLines) when Text1 =:= Text2 ->
  89 |     [{equal, Text1}];
  90 | diff(Text1, Text2, CheckLines) ->
  91 |     {Prefix, MText1, MText2, Suffix} = split_pre_and_suffix(Text1, Text2),
  92 | 
  93 |     Diffs = compute_diff(MText1, MText2, CheckLines),
  94 | 
  95 |     Diffs1 = case Suffix of
  96 |         <<>> -> Diffs;
  97 |         _ -> Diffs ++ [{equal, Suffix}]
  98 |     end,
  99 | 
 100 |     Diffs2 = case Prefix of 
 101 |         <<>> -> Diffs1;
 102 |         _ -> [{equal, Prefix} | Diffs1]
 103 |     end,
 104 | 
 105 |     cleanup_merge(Diffs2).
 106 | 
 107 | %% This assumes Text1 and Text2 don't have a common prefix
 108 | compute_diff(<<>>, NewText, _CheckLines) ->
 109 |     [{insert, NewText}];
 110 | compute_diff(OldText, <<>>, _CheckLines) ->
 111 |     [{delete, OldText}];
 112 | compute_diff(OldText, NewText, CheckLines) ->
 113 |     OldStNew = size(OldText) < size(NewText),
 114 | 
 115 |     {ShortText, LongText} = case OldStNew of
 116 |         true -> {OldText, NewText};
 117 |         false -> {NewText, OldText}
 118 |     end,
 119 | 
 120 |     case binary:match(LongText, ShortText) of
 121 |         {Start, Length} ->
 122 |             <<Pre:Start/binary, _:Length/binary, Suf/binary>> = LongText,
 123 |             Op = diff_op(OldStNew),
 124 |             [{Op, Pre}, {equal, ShortText}, {Op, Suf}]; 
 125 |         nomatch ->
 126 |             case single_char(ShortText) of
 127 |                 true ->
 128 |                     [{delete, OldText}, {insert, NewText}];
 129 |                 false ->
 130 |                     try_half_match(OldText, NewText, CheckLines)
 131 |              end
 132 |     end.
 133 | 
 134 | diff_op(true) -> insert;
 135 | diff_op(false) -> delete.
 136 | 
 137 | %% Check if we can do a half-match diff, if not, try line or bisect diff.  
 138 | try_half_match(OldText, NewText, CheckLines) ->
 139 |     case half_match(OldText, NewText) of
 140 |         {half_match, A1, A2, B1, B2, Common} ->
 141 |             Diffs1 = diff(A1, B1, CheckLines),
 142 |             Diffs2 = diff(A2, B2, CheckLines),
 143 |             Diffs1 ++ [{equal, Common} | Diffs2];
 144 |         undefined ->
 145 |             compute_diff1(OldText, NewText, CheckLines)
 146 |     end.
 147 | 
 148 | %% Check if we can do a half-match diff, returns undefined if it is not advantageous.
 149 | half_match(A, B) ->
 150 |     AGtB = size(A) > size(B),
 151 |     {Short, Long} = case AGtB of
 152 |         true -> {B, A};
 153 |         false -> {A, B}
 154 |     end,
 155 | 
 156 |     case text_smaller_than(Long, 4) orelse size(Short) * 2 < size(Long) of
 157 |         true ->
 158 |             %% No point in looking.
 159 |             undefined;
 160 |         false ->
 161 |             %% Note: this could split through a utf8 byte sequence.
 162 |             Hm1 = half_match_i(Long, Short, (size(Long) + 3) div 4),
 163 |             Hm2 = half_match_i(Long, Short, (size(Long) + 1) div 2),
 164 | 
 165 |             %% Select the longest half-match.
 166 |             Hm = case {Hm1, Hm2} of
 167 |                 {undefined, undefined} -> 
 168 |                     undefined;
 169 |                 {undefined, _} -> 
 170 |                     Hm2;
 171 |                 {_, undefined} -> 
 172 |                     Hm1;
 173 |                 {{half_match, _, _, _, _, C1}, {half_match, _, _, _, _, C2}} when size(C1) > size(C2) ->
 174 |                     Hm1;
 175 |                 {_, _} ->
 176 |                     Hm2
 177 |             end,
 178 | 
 179 |             %% Swap values if A was smaller than B
 180 |             case Hm of
 181 |                 undefined -> undefined;
 182 |                 {half_match, T1A, T1B, T2A, T2B, MidCommon} ->
 183 |                     case AGtB of
 184 |                         true -> Hm;
 185 |                         false ->
 186 |                             {half_match, T2A, T2B, T1A, T1B, MidCommon}
 187 |                     end
 188 |             end
 189 |     end.
 190 | 
 191 | 
 192 | % Find the best common overlap at location I.
 193 | half_match_i(Long, Short, I) ->
 194 |     {NewI, Seed} = seed(Long, I),
 195 |     case Seed of
 196 |         <<>> -> 
 197 |             undefined;
 198 |         _ ->
 199 |             best_common(Long, Short, Seed, NewI, 0, 
 200 |                 undefined, undefined, undefined, undefined, <<>>) 
 201 |     end.
 202 | 
 203 | 
 204 | %% Find the best common overlap inside two texts.
 205 | best_common(Long, Short, Seed, SeedLoc, Start, 
 206 |         BestLongA, BestLongB, BestShortA, BestShortB, BestCommon) ->
 207 |     %% Check if we can find a match for Seed2 inside the shorttext.
 208 |     case binary:match(Short, Seed, [{scope, {Start, size(Short)-Start}}]) of
 209 |         nomatch -> 
 210 |             case size(BestCommon) * 2 >= size(Long) of
 211 |                 false -> 
 212 |                     undefined;
 213 |                 true -> 
 214 |                     {half_match, BestLongA, BestLongB, BestShortA, BestShortB, BestCommon}
 215 |             end;
 216 |         {MatchStart, _} ->
 217 |             %% Because the seed is already at utf-8 boundaries this will work.
 218 |             <<LongPre:SeedLoc/binary, LongPost/binary>> = Long,
 219 |             <<ShortPre:MatchStart/binary, ShortPost/binary>> = Short,
 220 | 
 221 |             %% Note: This is a split on a utf8-char boundary.
 222 |             Suffix = common_suffix(LongPre, ShortPre),
 223 |             Prefix = common_prefix(LongPost, ShortPost),
 224 | 
 225 | 	    PrefixSize = size(Prefix),
 226 | 	    SuffixSize = size(Suffix),
 227 | 
 228 |             case size(BestCommon) < PrefixSize + SuffixSize of
 229 |                 true ->
 230 |                     %% We have a new best common match
 231 |                     NewBestCommon = <<Suffix/binary, Prefix/binary>>,
 232 | 
 233 | 		    A = SeedLoc - SuffixSize,
 234 | 		    <<NewBestLongA:A/binary, _/binary>> = LongPre,
 235 | 		    <<_:PrefixSize/binary, NewBestLongB/binary>> = LongPost,
 236 | 
 237 | 		    B = MatchStart - SuffixSize,
 238 | 		    <<NewBestShortA:B/binary, _/binary>> = ShortPre,
 239 | 		    <<_:PrefixSize/binary, NewBestShortB/binary>> = ShortPost,
 240 | 
 241 |                     best_common(Long, Short, Seed, SeedLoc, next_char(Short, MatchStart), 
 242 |                         NewBestLongA, NewBestLongB, NewBestShortA, NewBestShortB, NewBestCommon);
 243 |                 false ->
 244 |                     best_common(Long, Short, Seed, SeedLoc, next_char(Short, MatchStart), 
 245 |                         BestLongA, BestLongB, BestShortA, BestShortB, BestCommon)
 246 |             end
 247 |     end.
 248 | 
 249 | %% @doc Return the position of the next character.
 250 | next_char(Bin, Pos) ->
 251 |     <<_:Pos/binary, C/utf8, _Rest/binary>> = Bin,
 252 |     %% The next char is at binary position...
 253 |     Pos + size(<<C/utf8>>). 
 254 | 
 255 | %% 
 256 | seed(Long, Start) ->
 257 |     SeedSize = size(Long) div 4,
 258 | 
 259 |     %% Note, need to split on utf8 character boundary here.
 260 |     <<_Pre:Start/binary, Seed:SeedSize/binary, _Post/binary>> = Long,
 261 | 
 262 |     %% Utf-8 repair the seed's head and tail. 
 263 |     {Pre, Seed1} = repair_head(Seed),
 264 |     {Seed2, _} = repair_tail(Seed1),
 265 | 
 266 |     %% return the start position of the seed and the seed itself.
 267 |     {Start - size(Pre), Seed2}.
 268 | 
 269 | 
 270 | %% Line diff
 271 | compute_diff1(Text1, Text2, true) ->
 272 |     diff_linemode(Text1, Text2);
 273 | compute_diff1(Text1, Text2, false) when size(Text1) > 100 orelse size(Text2) > 100 ->
 274 |     diff_linemode(Text1, Text2);
 275 | compute_diff1(Text1, Text2, false) ->
 276 |     diff_bisect(Text1, Text2).
 277 | 
 278 | 
 279 | %% Compute diff in linemode
 280 | diff_linemode(Text1, Text2) ->
 281 |     {CharText1, CharText2, Lines} = lines_to_chars(Text1, Text2),
 282 |     Diffs = diff(CharText1, CharText2, false),
 283 | 
 284 |     %% Transform the diffs back to lines.
 285 |     Diffs1 = chars_to_lines(Diffs, Lines),
 286 | 
 287 |     Cleaned = cleanup_merge(Diffs1),
 288 |     cleanup_line_diff(Cleaned, <<>>, <<>>, [], []).
 289 | 
 290 | 
 291 | %% Cleanup after a line based diff.
 292 | %%
 293 | cleanup_line_diff([], _, _, TmpAcc, Acc) ->
 294 |     lists:reverse(TmpAcc ++ Acc);
 295 | 
 296 | %% Concatenate the text found in insert and delete operations.
 297 | cleanup_line_diff([{insert, Data}=I|Rest], DeleteData, InsertData, TmpAcc, Acc) ->
 298 |     cleanup_line_diff(Rest, DeleteData, <<InsertData/binary, Data/binary>>, [I|TmpAcc], Acc);
 299 | cleanup_line_diff([{delete, Data}=D|Rest], DeleteData, InsertData, TmpAcc, Acc) ->
 300 |     cleanup_line_diff(Rest, <<DeleteData/binary, Data/binary>>, InsertData, [D|TmpAcc], Acc);
 301 | 
 302 | %% Found an equal without a leading insert and delete operations. Just pass
 303 | %% the operations
 304 | cleanup_line_diff([{equal, _}=E|Rest], DeleteData, InsertData, TmpAcc, Acc) 
 305 | 	when DeleteData =:= <<>> orelse InsertData =:= <<>> ->
 306 |     Acc1 = TmpAcc ++ Acc,
 307 |     cleanup_line_diff(Rest, <<>>, <<>>, [], [E|Acc1]);
 308 | 
 309 | %% Found leading insert and delete data, diff the texts and replace the operations.
 310 | cleanup_line_diff([{equal, _}=E|Rest], DeleteData, InsertData, _TmpAcc, Acc) ->
 311 |     %% rediff the delete and insert data.
 312 |     Diffs = diff(DeleteData, InsertData, false),
 313 |     Acc1 = lists:reverse(Diffs) ++ Acc,
 314 |     cleanup_line_diff(Rest, <<>>, <<>>, [], [E|Acc1]).
 315 | 
 316 | 
 317 | %% Diff lines
 318 | lines_to_chars(Text1, Text2) ->
 319 |     {CharText1, NextChar, Lines1, Dict1} = lines_to_chars(Text1, 0, <<>>, 0, [], dict:new()),
 320 |     {CharText2, _, Lines2, _Dict2} = lines_to_chars(Text2, 0, <<>>, NextChar, Lines1, Dict1),
 321 | 
 322 |     {CharText1, CharText2, lists:reverse(Lines2)}.
 323 | 
 324 | % Transform each unique line into a single char
 325 | lines_to_chars(Text, Idx, CharText, NextChar, Lines, D) when Idx >= size(Text) ->
 326 |     {CharText, NextChar, Lines, D};
 327 | lines_to_chars(Text, Idx, CharText, NextChar, Lines, D) ->
 328 |     case binary:match(Text, <<"\n">>, [{scope, {Idx, size(Text)-Idx}}]) of
 329 |         nomatch ->
 330 |             <<_:Idx/binary, Line/binary>> = Text,
 331 |             {Char, NextChar1, Lines1, D1} = insert_line(Line, Lines, D, NextChar),
 332 |             CharText1 = <<CharText/binary, Char/utf8>>,
 333 |             {CharText1, NextChar1, Lines1, D1};
 334 |         {Start, _} ->
 335 |             LineLength = Start - Idx + 1,
 336 |             <<_:Idx/binary, Line:LineLength/binary, _/binary>> = Text,
 337 | 
 338 |             {Char, NextChar1, Lines1, D1} = insert_line(Line, Lines, D, NextChar),
 339 |             CharText1 = <<CharText/binary, Char/utf8>>,
 340 | 
 341 |             lines_to_chars(Text, Idx + LineLength, CharText1, NextChar1, Lines1, D1) 
 342 |     end.
 343 | 
 344 | insert_line(Line, Lines, Dict, NextChar) ->
 345 |     case dict:find(Line, Dict) of
 346 |         {ok, Char} ->
 347 |             {Char, NextChar, Lines, Dict};
 348 |         error ->
 349 |             {NextChar, NextChar+1, [Line|Lines], dict:store(Line, NextChar, Dict)}
 350 |     end.
 351 | 
 352 | %%
 353 | chars_to_lines(Diffs, Lines) when is_list(Lines) ->
 354 |     A = array:from_list(Lines),
 355 |     chars_to_lines(Diffs, A, []).
 356 | 
 357 | chars_to_lines([], _A, Acc) ->
 358 |     lists:reverse(Acc);
 359 | chars_to_lines([{Op, Data}|Rest], LineArray, Acc) ->
 360 |     Data1 = << <<(array:get(C, LineArray))/binary>> || <<C/utf8>> <= Data >>,
 361 |     chars_to_lines(Rest, LineArray, [{Op, Data1}|Acc]).
 362 | 
 363 | 
 364 | % Find the 'middle snake' of a diff, split the problem in two
 365 | %%      and return the recursively constructed diff.
 366 | %%      See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.
 367 | %%
 368 | %%    Args:
 369 | %%      text1: Old string to be diffed.
 370 | %%      text2: New string to be diffed.
 371 | %%      deadline: Time at which to bail if not yet complete.
 372 | %%
 373 | %%    Returns:
 374 | %%      Array of diff tuples.
 375 | %%    """
 376 | diff_bisect(A, B) when is_binary(A) andalso is_binary(B) ->
 377 |     ArrA = array_from_binary(A),
 378 |     ArrB = array_from_binary(B),
 379 |     try compute_diff_bisect1(ArrA, ArrB, array:size(ArrA), array:size(ArrB)) of
 380 |         no_overlap -> [{delete, A}, {insert, B}] 
 381 |     catch
 382 |         throw:{overlap, A1, B1, X, Y} ->
 383 |             diff_bisect_split(A1, B1, X, Y)
 384 |     end.
 385 | 
 386 | compute_diff_bisect1(A, B, M, N) ->
 387 |     %% TODO, add deadline... 
 388 |     
 389 |     MaxD = int_ceil((M + N) / 2),
 390 | 
 391 |     VOffset = MaxD,
 392 |     VLength = 2 * MaxD,
 393 | 
 394 |     V1 = array:set(VOffset + 1, 0, array:new(VLength, [{default, -1}])),
 395 |     
 396 |     Delta = M - N,
 397 | 
 398 |     % If the total number of characters is odd, then the front path will
 399 |     % collide with the reverse path.
 400 |     Front = (Delta rem 2 =/= 0),
 401 | 
 402 |     %% {K1Start, K1End, K2Start, K2End, V1, V2}
 403 |     State = #bisect_state{v1=V1, v2=V1},
 404 | 
 405 |     %% Loops
 406 |     for(0, MaxD, fun(D, S1) ->
 407 |         %% Walk the front path one step
 408 |         S3 = for(-D + S1#bisect_state.k1start, D + 1 - S1#bisect_state.k1end, 2, fun(K1, S2) ->
 409 |             K1Offset = VOffset + K1,
 410 | 
 411 |             X1 = case K1 =:= -D orelse (K1 =/= D andalso 
 412 |                     (array:get(K1Offset-1, S2#bisect_state.v1) < array:get(K1Offset+1, S2#bisect_state.v1))) of
 413 |                 true -> array:get(K1Offset + 1, S2#bisect_state.v1);
 414 |                 false -> array:get(K1Offset - 1, S2#bisect_state.v1) + 1
 415 |             end,
 416 | 
 417 |             Y1 = X1 - K1,
 418 |             {X1_1, Y1_1} = match_front(X1, Y1, A, M, B, N),
 419 |             S2_1 = S2#bisect_state{v1=array:set(K1Offset, X1_1, S2#bisect_state.v1)},
 420 |  
 421 |             if 
 422 |                 X1_1 > M -> 
 423 |                     % Ran off the right of the graph...
 424 |                     V = S2_1#bisect_state.k1end + 2,
 425 |                     {continue, S2_1#bisect_state{k1end=V}};
 426 |                 Y1_1 > N ->
 427 |                     % Ran off the bottom of the graph...
 428 |                     V = S2_1#bisect_state.k1start + 2,
 429 |                     {continue, S2_1#bisect_state{k1start=V}};
 430 |                 Front =:= true ->
 431 |                     K2Offset = VOffset + Delta - K1,
 432 |                     case K2Offset < 0 orelse K2Offset >= VLength of
 433 |                         true -> {continue, S2_1};
 434 |                         false ->
 435 |                             V2AtOffset = array:get(K2Offset, S2_1#bisect_state.v2),
 436 |                             case V2AtOffset =/= -1 of
 437 |                                 true ->
 438 |                                     % Mirror x2 onto top-left coordinate system.
 439 |                                     X2 = M - V2AtOffset,
 440 |                                     if 
 441 |                                         X1_1 >= X2 ->
 442 |                                             % Overlap detected
 443 |                                             throw({overlap, A, B, X1_1, Y1_1});
 444 |                                         true ->
 445 |                                             {continue, S2_1}
 446 |                                     end;
 447 |                                 false -> {continue, S2_1}
 448 |                             end
 449 |                     end;
 450 |                 true -> {continue, S2_1}
 451 |             end
 452 |         end, S1),
 453 | 
 454 |         %% Walk the reverse path one step. (verdacht hetzelfde als het ding hierboven...)
 455 |         S5 = for(-D + S3#bisect_state.k2start, D + 1 - S3#bisect_state.k2end, 2, fun(K2, S4) ->
 456 |             K2Offset = VOffset + K2,
 457 |             X2 = case K2 =:= -D orelse (K2 =/= D andalso 
 458 |                         array:get(K2Offset-1, S4#bisect_state.v2) < array:get(K2Offset+1, S4#bisect_state.v2)) of
 459 |                 true -> 
 460 |                     array:get(K2Offset + 1, S4#bisect_state.v2);
 461 |                 false -> 
 462 |                     array:get(K2Offset - 1, S4#bisect_state.v2) + 1
 463 |             end,
 464 | 
 465 |             Y2 = X2 - K2,
 466 | 
 467 |             {X2_1, Y2_1} = match_reverse(X2, Y2, A, M, B, N),
 468 |             S4_1 = S4#bisect_state{v2=array:set(K2Offset, X2_1, S4#bisect_state.v2)},
 469 | 
 470 |             if 
 471 |                 X2_1 > M -> 
 472 |                     % Ran off the right of the graph...
 473 |                     V = S4_1#bisect_state.k2end + 2,
 474 |                     {continue, S4_1#bisect_state{k2end=V}};
 475 |                 Y2_1 > N ->
 476 |                     % Ran off the bottom of the graph...
 477 |                     V = S4_1#bisect_state.k2start + 2,
 478 |                     {continue, S4_1#bisect_state{k2start=V}};
 479 |                 Front =:= false ->
 480 |                     K1Offset = VOffset + Delta - K2,
 481 |                     case K1Offset < 0 orelse K1Offset >= VLength of
 482 |                         true -> {continue, S4_1};
 483 |                         false ->
 484 |                             V1AtOffset = array:get(K1Offset, S4_1#bisect_state.v1),
 485 |                             case V1AtOffset =/= -1 of
 486 |                                 true ->
 487 |                                     X1 = V1AtOffset,
 488 |                                     Y1 = VOffset + X1 - K1Offset,
 489 |                                     if 
 490 |                                         % Mirror x2 onto top-left coordinate system.
 491 |                                         X1 >= M - X2_1 ->
 492 |                                             % Overlap detected
 493 |                                             throw({overlap, A, B, X1, Y1});
 494 |                                         true ->
 495 |                                             {continue, S4_1}
 496 |                                     end;
 497 |                                 false -> {continue, S4_1}
 498 |                             end
 499 |                     end;
 500 |                 true -> {continue, S4_1}
 501 |             end
 502 |         end, S3),
 503 |         {continue, S5}
 504 |     end, State),
 505 | 
 506 |     no_overlap.
 507 | 
 508 | % @doc Split A and B and process the parts.
 509 | diff_bisect_split(A, B, X, Y) ->
 510 |     A1 = binary_from_array(0, X, A),
 511 |     A2 = binary_from_array(0, Y, B),
 512 | 
 513 |     B1 = binary_from_array(X, array:size(A), A),
 514 |     B2 = binary_from_array(Y, array:size(B), B),
 515 | 
 516 |     Diffs = diff(A1, A2, false),
 517 |     DiffsB = diff(B1, B2, false),
 518 | 
 519 |     Diffs ++ DiffsB.
 520 | 
 521 | % @doc Convert the diffs into a pretty html report
 522 | -spec pretty_html(diffs()) -> iolist().
 523 | pretty_html(Diffs) ->
 524 |     pretty_html(Diffs, []).
 525 | 
 526 | pretty_html([], Acc) ->
 527 |     lists:reverse(Acc);
 528 | pretty_html([{Op, Data}|T], Acc) ->
 529 |     Text = z_html:escape(Data),
 530 |     HTML = case Op of
 531 |         insert ->
 532 |             [<<"<ins style='background:#e6ffe6;'>">>, Text, <<"</ins>">>];
 533 |         delete ->
 534 |             [<<"<del style='background:#ffe6e6;'>">>, Text, <<"</del>">>];
 535 |         equal ->
 536 |             [<<"<span>>">>, Text, <<"</span>">>]
 537 |     end,
 538 |     pretty_html(T, [HTML|Acc]).
 539 | 
 540 | % @doc Compute the source text from a list of diffs.
 541 | source_text(Diffs) ->
 542 |     source_text(Diffs, <<>>).
 543 | 
 544 | source_text([], Acc) ->
 545 |     Acc;
 546 | source_text([{insert, _Data}|T], Acc) ->
 547 |     source_text(T, Acc);
 548 | source_text([{_Op, Data}|T], Acc) ->
 549 |     source_text(T, <<Acc/binary, Data/binary>>).
 550 |     
 551 | 
 552 | % @doc Compute the destination text from a list of diffs.
 553 | destination_text(Diffs) ->
 554 |     destination_text(Diffs, <<>>).
 555 |     
 556 | destination_text([], Acc) -> 
 557 |     Acc;
 558 | destination_text([{delete, _Data}|T], Acc) ->
 559 |     destination_text(T, Acc);
 560 | destination_text([{_Op, Data}|T], Acc) ->
 561 |     destination_text(T, <<Acc/binary, Data/binary>>).
 562 |     
 563 | % @doc Compute the Levenshtein distance, the number of inserted, deleted or substituted characters.
 564 | levenshtein(Diffs) ->
 565 |     levenshtein(Diffs, 0, 0, 0).
 566 | 
 567 | levenshtein([], Insertions, Deletions, Levenshtein) ->
 568 |     Levenshtein + max(Insertions, Deletions);
 569 | levenshtein([{insert, Data}|T], Insertions, Deletions, Levenshtein) ->
 570 |     levenshtein(T, Insertions+text_size(Data), Deletions, Levenshtein);
 571 | levenshtein([{delete, Data}|T], Insertions, Deletions, Levenshtein) ->
 572 |     levenshtein(T, Insertions, Deletions+text_size(Data), Levenshtein);
 573 | levenshtein([{equal, _Data}|T], Insertions, Deletions, Levenshtein) ->
 574 |     levenshtein(T, 0, 0, Levenshtein+max(Insertions, Deletions)).
 575 | 
 576 | 
 577 | %@ @doc Cleanup diffs. 
 578 | % Remove empty operations, merge equal opearations, edits before equal operation and common prefix operations.
 579 | %
 580 | -spec cleanup_merge(diffs()) -> diffs().
 581 | cleanup_merge(Diffs) ->
 582 |     cleanup_merge(Diffs, []). 
 583 | 
 584 | %% Done
 585 | cleanup_merge([], Acc) ->
 586 |     lists:reverse(Acc);
 587 | %% Remove operations without data.
 588 | cleanup_merge([{_Op, <<>>}|T], Acc) ->
 589 |     cleanup_merge(T, Acc);
 590 | %% Merge data from equal operations
 591 | cleanup_merge([{Op2, Data2}|T], [{Op1, Data1}|Acc]) when Op1 =:= Op2 ->
 592 |     cleanup_merge(T, [{Op1, <<Data1/binary, Data2/binary>>}|Acc]);
 593 | %% Cleanup edits before equal operation
 594 | cleanup_merge([{Op1, Data1}|T], [{Op2, _}=I, {Op3, Data3}|Acc]) when Op1 =/= Op2 andalso Op1 =:= Op3 andalso Op2 =/= equal andalso Op3 =/= equal ->
 595 |     cleanup_merge(T, [I, {Op3, <<Data3/binary, Data1/binary>>}|Acc]);
 596 | %% Check if Op1Data and Op2Data have common prefixes.
 597 | cleanup_merge([{equal, E1}|T], [{Op1, Op1Data}, {Op2, Op2Data}, {equal, E2}|Acc]) when Op1 =/= Op2 andalso Op1 =/= equal andalso Op2 =/= equal ->
 598 |     {Prefix, Op1DataD, Op2DataD, Suffix} = split_pre_and_suffix(Op1Data, Op2Data),
 599 |     cleanup_merge(T, [{equal, <<Suffix/binary, E1/binary>>}, 
 600 |         {Op1, Op1DataD}, {Op2, Op2DataD}, {equal, <<E2/binary, Prefix/binary>>}|Acc]);
 601 | %% Check for slide left and slide right edits
 602 | cleanup_merge([{equal, E1}=H|T], [{Op, I}, {equal, E2}|AccTail]=Acc) when Op =:= insert orelse Op =:= delete ->
 603 |     case is_suffix(E2, I) of
 604 |         false ->
 605 |             case is_prefix(E1, I) of
 606 |                 false ->
 607 |                     cleanup_merge(T, [H|Acc]);
 608 |                 true ->
 609 |                     P = size(E1),
 610 |                     <<_:P/binary, Post/binary>> = I,
 611 |                     cleanup_merge([{equal, <<E2/binary, E1/binary>>}, {Op, <<Post/binary, E1/binary>>}|T], AccTail)
 612 |             end;
 613 |         true ->
 614 |             R = size(I) - size(E2),
 615 |             <<Pre:R/binary,  Post/binary>> = I,
 616 |             cleanup_merge([{Op, <<E2/binary, Pre/binary>>}, {equal, <<Post/binary, E1/binary>>}|T], AccTail)
 617 |     end;
 618 | cleanup_merge([H|T], Acc) ->
 619 |     cleanup_merge(T, [H|Acc]).
 620 | 
 621 | % @doc Do semantic cleanup of diffs
 622 | %
 623 | -spec cleanup_semantic(diffs()) -> diffs().
 624 | cleanup_semantic(Diffs) ->
 625 |     cleanup_semantic(Diffs, []).
 626 | 
 627 | cleanup_semantic([], Acc) ->
 628 |     lists:reverse(Acc);
 629 | cleanup_semantic([H|T], Acc) ->
 630 |     cleanup_semantic(T, [H|Acc]).
 631 | 
 632 | % @doc Do efficiency cleanup of diffs.
 633 | %
 634 | -spec cleanup_efficiency(diffs()) -> diffs().
 635 | cleanup_efficiency(Diffs) ->
 636 |     cleanup_efficiency(Diffs, 4).
 637 | 
 638 | cleanup_efficiency(Diffs, EditCost) ->
 639 |     cleanup_efficiency(Diffs, false, EditCost, []).
 640 | 
 641 | %% Done.
 642 | cleanup_efficiency([], Changed, _EditCost, Acc) ->
 643 |     Diffs = lists:reverse(Acc),
 644 |     case Changed of
 645 |         false -> Diffs;
 646 |         true -> cleanup_merge(Diffs)
 647 |     end;
 648 | %% Any equality which is surrounded on both sides by an insertion and deletion need less then 
 649 | %% EditCost characters for it to be advantageous to split.
 650 | cleanup_efficiency([{O1, _}=A, {equal, XY}=E, {O2, _}=B | T], Changed, EditCost, Acc) when 
 651 |         O1 =/= O2 andalso ?IS_INS_OR_DEL(O1) andalso ?IS_INS_OR_DEL(O2) ->
 652 |     case text_smaller_than(XY, EditCost) of
 653 |         true ->
 654 |             %% Split
 655 |             Del = {delete, XY},
 656 |             Ins = {insert, XY},
 657 | 
 658 |             cleanup_efficiency([Ins, B | T], true, EditCost, [Del, A | Acc]);
 659 |         false ->
 660 |             %% Equal is big enough, move A and equal out of the way.
 661 |             cleanup_efficiency([B | T], Changed, EditCost, [E, A |Acc])
 662 |     end;
 663 | %% Any equality which is surrounded on one side by an existing insertion and deletion and on the 
 664 | %% other side by an exisiting insertion or deletion needs by less than half C characters long for it 
 665 | %% to be advantagous to split.
 666 | cleanup_efficiency([{O1, _}=A, {O2, _}=B, {equal, X}=E, {O3, _}=C | T], Changed, EditCost, Acc) when
 667 |     O1 =/= O2 andalso ?IS_INS_OR_DEL(O1) andalso ?IS_INS_OR_DEL(O2) andalso ?IS_INS_OR_DEL(O3) ->
 668 |     case text_smaller_than(X, EditCost div 2 + 1) of
 669 |         true ->
 670 |             %% Split
 671 |             Del = {delete, X},
 672 |             Ins = {insert, X},
 673 |             cleanup_efficiency([Ins, C | T], true, EditCost, [Del, B, A | Acc]);
 674 |         false ->
 675 |             %% Equal is big enough, move delete and equal out of the way.
 676 |             cleanup_efficiency([B, E, C | T], Changed, EditCost, [A |Acc])
 677 |     end;
 678 | cleanup_efficiency([H|T], Changed, EditCost, Acc) ->
 679 |     cleanup_efficiency(T, Changed, EditCost, [H|Acc]).
 680 | 
 681 | 
 682 | % @doc Return true iff the text is smaller than specified 
 683 | text_smaller_than(_, 0) ->
 684 |     false;
 685 | text_smaller_than(<<>>, _Size) ->
 686 |     true;
 687 | text_smaller_than(<<_C/utf8, Rest/binary>>, Size) when Size > 0 ->
 688 |     text_smaller_than(Rest, Size-1);
 689 | text_smaller_than(<<_C, Rest/binary>>, Size) when Size > 0 ->
 690 |     %% Illegal utf-8 string, just count this as a single character and continue
 691 |     text_smaller_than(Rest, Size-1).
 692 | 
 693 | % @doc create a patch from a list of diffs
 694 | make_patch(Diffs) when is_list(Diffs) ->
 695 |     %% Reconstruct the source-text from the diffs.
 696 |     make_patch(Diffs, source_text(Diffs)).
 697 | 
 698 | % @doc create a patch from the source and destination texts
 699 | make_patch(SourceText, DestinationText) when is_binary(SourceText) andalso is_binary(DestinationText) ->
 700 |     Diffs = diff(SourceText, DestinationText),
 701 |     Diffs1 = cleanup_semantic(Diffs),
 702 |     Diffs2 = cleanup_efficiency(Diffs1),
 703 |     make_patch(Diffs2, SourceText);
 704 | 
 705 | % @doc Creata a patch from a list of diffs and the source text.
 706 | make_patch(Diffs, SourceText) when is_list(Diffs) andalso is_binary(SourceText) ->
 707 |     make_patch(Diffs, SourceText, SourceText, 0, 0, [#patch{}]).
 708 | 
 709 | make_patch([], _PrePatchText, _PostPatchText, _Count1, _Count2, [Patch|Rest]=Patches) ->
 710 |     case Patch#patch.diffs of
 711 |         [] -> 
 712 |             lists:reverse(Rest);
 713 |         _ -> 
 714 |             lists:reverse(Patches)
 715 |     end;
 716 |     
 717 | make_patch([{insert, Data}=D|T], PrePatchText, PostPatchText, Count1, Count2, [Patch|Rest]) ->
 718 |     Diffs = [D|Patch#patch.diffs],
 719 |     Size = size(Data),
 720 | 
 721 |     L = Patch#patch.length2 + Size,
 722 |     P = Patch#patch{diffs=Diffs, length2=L},
 723 | 
 724 |     %% Insert the text into the postpatch text.
 725 |     <<Pre:Count2/binary, Post/binary>> = PostPatchText,
 726 |     NewPostPatchText = <<Pre/binary, Data/binary, Post/binary>>,
 727 | 
 728 |     make_patch(T, PrePatchText, NewPostPatchText, Count1, Count2+Size, [P|Rest]);
 729 | 
 730 | make_patch([{delete, Data}=D|T], PrePatchText, PostPatchText, Count1, Count2, [Patch|Rest]) ->
 731 |     Diffs = [D|Patch#patch.diffs],
 732 |     Size = size(Data),
 733 | 
 734 |     L = Patch#patch.length1 + Size,
 735 |     P = Patch#patch{diffs=Diffs, length1=L},
 736 | 
 737 |     %% Remove the piece of text.
 738 |     <<Pre:Count2/binary, _:Size/binary, Post/binary>> = PostPatchText,
 739 |     NewPostPatchText = <<Pre/binary, Post/binary>>,
 740 |     
 741 |     make_patch(T, PrePatchText, NewPostPatchText, Count1+Size, Count2, [P|Rest]);
 742 | 
 743 | make_patch([{equal, Data}|T], PrePatchText, PostPatchText, Count1, Count2, [Patch|Rest]) ->
 744 |     Diffs = Patch#patch.diffs,
 745 |     Size = size(Data),
 746 | 
 747 |     case Size >= 2 * ?PATCH_MARGIN of
 748 |         true ->
 749 |             case Diffs of
 750 |                 [] ->
 751 |                     throw(not_yet);
 752 |                 _ ->
 753 |                     % Time for a new patch.
 754 |                     throw(not_yet)
 755 |             end;
 756 |         false ->
 757 |             throw(not_yet)
 758 |     end,
 759 | 
 760 |     L1 = Patch#patch.length1 + Size,
 761 |     L2 = Patch#patch.length2 + Size,
 762 |     
 763 |     P = Patch#patch{diffs=Diffs, length1=L1, length2=L2},
 764 |         
 765 |     make_patch(T, PrePatchText, PostPatchText, Count1+Size, Count2+Size, [P|Rest]).
 766 | 
 767 |     
 768 | % @doc Returns true iff Pattern is a unique match inside Text.
 769 | unique_match(Pattern, Text) ->
 770 |     TextSize = size(Text),
 771 |     case binary:match(Text, Pattern) of
 772 |         nomatch -> 
 773 |             error(nomatch);
 774 |         {Start, Length} when Start + 1 + Length < TextSize ->
 775 |             %% We have a match, and we can search..
 776 |             case binary:match(Text, Pattern, [{scope, {Start+1, TextSize-Start-1}}]) of
 777 |                 nomatch -> true;
 778 |                 {_, _} -> false
 779 |             end;
 780 |         {_, _} ->
 781 |             true
 782 |     end.
 783 | 
 784 | 
 785 | %%
 786 | %% Helpers
 787 | %%
 788 | 
 789 | % @doc Return true iff binary is a single character.
 790 | single_char(<<>>) -> false;
 791 | single_char(<<_C/utf8>>) -> true;
 792 | single_char(Bin) when is_binary(Bin) -> false.
 793 | 
 794 | % @doc Return true iff A is a prefix of B
 795 | is_prefix(A, B) when size(A) > size(B) ->
 796 |     false;
 797 | is_prefix(A, B) ->
 798 |     size(A) =:= binary:longest_common_prefix([A,B]).
 799 | 
 800 | % @doc Return true iff A is a suffix of B
 801 | is_suffix(A, B) when size(A) > size(B) ->
 802 |     false;
 803 | is_suffix(A, B) ->
 804 |     size(A) =:= binary:longest_common_suffix([A, B]).
 805 | 
 806 | %
 807 | match_front(X1, Y1, A, M, B, N) when X1 < M andalso Y1 < N ->
 808 |     case array:get(X1, A) =:= array:get(Y1, B) of
 809 |         true -> 
 810 | 	    match_front(X1+1, Y1+1, A, M, B, N);
 811 |         false -> 
 812 | 	    {X1, Y1}
 813 |     end;
 814 | match_front(X1, Y1, _, _, _, _) ->
 815 |     {X1, Y1}.
 816 | 
 817 | %
 818 | match_reverse(X1, Y1, A, M, B, N) when X1 < M andalso Y1 < N ->
 819 |     case array:get(M-X1-1, A) =:= array:get(N-Y1-1, B) of
 820 |         true -> 
 821 | 	    match_reverse(X1+1, Y1+1, A, M, B, N);
 822 |         false -> 
 823 | 	    {X1, Y1}
 824 |     end;
 825 | match_reverse(X1, Y1, _, _, _, _) ->
 826 |     {X1, Y1}.
 827 | 
 828 | 
 829 | %% Implementation of the for statement
 830 | for(From, To, Fun, State) ->
 831 |     for(From, To, 1, Fun, State).
 832 | 
 833 | for(From, To, _Step, _Fun, State) when From >= To ->
 834 |     State;
 835 | for(From, To, Step, Fun, State) ->
 836 |     case Fun(From, State) of
 837 |         {continue, S1} -> 
 838 |             for(From + Step, To, Step, Fun, S1);
 839 |         {break, S1} ->
 840 |             S1
 841 |     end.
 842 |         
 843 | split_pre_and_suffix(Text1, Text2) ->
 844 |     Prefix = common_prefix(Text1, Text2),
 845 |     PrefixLen = size(Prefix),
 846 | 
 847 |     <<_:PrefixLen/binary, TailText1/binary>> = Text1,
 848 |     <<_:PrefixLen/binary, TailText2/binary>> = Text2,
 849 | 
 850 |     Suffix = common_suffix(TailText1, TailText2),
 851 |     SuffixLen = size(Suffix),
 852 | 
 853 |     MiddleText1 = binary:part(TailText1, 0, size(TailText1) - SuffixLen), 
 854 |     MiddleText2 = binary:part(TailText2, 0, size(TailText2) - SuffixLen), 
 855 | 
 856 |     {Prefix, MiddleText1, MiddleText2, Suffix}.
 857 | 
 858 |     
 859 | % @doc Return the common prefix of Text1 and Text2. (utf8 aware)
 860 | common_prefix(Text1, Text2) ->
 861 |     Length = binary:longest_common_prefix([Text1, Text2]),
 862 |     Prefix = binary:part(Text1, 0, Length),
 863 |     
 864 |     %% Utf-8 repair the tail of the prefix. It could contain a half utf-9 char.
 865 |     {Prefix1, _} = repair_tail(Prefix),
 866 |     Prefix1.
 867 | 
 868 | % @doc Return the common prefix of Text1 and Text2 (utf8 aware)
 869 | common_suffix(Text1, Text2) ->
 870 |     Length = binary:longest_common_suffix([Text1, Text2]),
 871 |     Suffix = binary:part(Text1, size(Text1), -Length),
 872 | 
 873 |     %% Utf-8 repair the head of the suffix. Could contain a half utf8 char
 874 |     {_, Suffix1} = repair_head(Suffix),
 875 |     Suffix1.
 876 | 
 877 | 
 878 | % @doc Count the number of characters in a utf8 binary.
 879 | text_size(Text) when is_binary(Text) ->
 880 |     text_size(Text, 0).
 881 | 
 882 | text_size(<<>>, Count) ->
 883 |     Count;
 884 | text_size(<<_C/utf8, Rest/binary>>, Count) ->
 885 |     text_size(Rest, Count+1);
 886 | text_size(_, _) ->
 887 |     error(badarg).
 888 | 
 889 | %%
 890 | %% Array utilities
 891 | %%
 892 | 
 893 | % @doc Create an array from a utf8 binary.
 894 | array_from_binary(Bin) when is_binary(Bin) ->
 895 |     array_from_binary(Bin, 0, array:new()).
 896 | 
 897 | array_from_binary(<<>>, _N, Array) ->
 898 |     array:fix(Array);
 899 | array_from_binary(<<C/utf8, Rest/binary>>, N, Array) ->
 900 |     array_from_binary(Rest, N+1, array:set(N, C, Array)).
 901 | 
 902 | % @doc Create a binary from an array containing unicode characters.
 903 | binary_from_array(Start, End, Array) ->
 904 |     binary_from_array(Start, End, Array, <<>>).
 905 |     
 906 | binary_from_array(N, End, Array, Acc) when N < End ->
 907 |     C = array:get(N, Array),
 908 |     binary_from_array(N+1, End, Array, <<Acc/binary, C/utf8>>);
 909 | binary_from_array(_, _, _, Acc) ->
 910 |     Acc.
 911 | 
 912 | %% @doc Checks the trailing bytes for utf8 prefix bytes.
 913 | repair_tail(<<>>) ->
 914 |     {<<>>, <<>>};
 915 | %% Checks 
 916 | repair_tail(Bin) ->
 917 |     Size = size(Bin),
 918 |     Size1 = Size-1, Size2 = Size-2, Size3 = Size-3, Size4 = Size-4,
 919 |     case Bin of
 920 |         %% Valid 1 -byte
 921 |         <<_:Size1/binary, 2#0:1, _A:7>> ->
 922 |              {Bin, <<>>}; 
 923 |         %% Invalid 1-byte
 924 |         <<Pre:Size1/binary, 2#110:3, A:5>> ->
 925 |             {Pre, <<2#110:3, A:5>>};
 926 |         <<Pre:Size1/binary, 2#1110:4, A:4>> ->
 927 |             {Pre, <<2#1110:4, A:4>>};
 928 |         <<Pre:Size1/binary, 2#11110:5, A:3>> ->
 929 |             {Pre, <<2#11110:5, A:3>>};
 930 | 
 931 |         %% Valid 2-byte ending
 932 |         <<_:Size2/binary, 2#110:3, _A:5, 2#10:2, _B:6>> ->
 933 |              {Bin, <<>>};
 934 |         %% Invalid 2-byte ending
 935 |         <<Pre:Size2/binary, 2#1110:4, A:4, 2#10:2, B:6>> ->
 936 |             {Pre, <<2#1110:4, A:4, 2#10:2, B:6>>};
 937 |         <<Pre:Size2/binary, 2#11110:5, A:3, 2#10:2, B:6>> ->
 938 |             {Pre, <<2#11110:5, A:3, 2#10:2, B:6>>};
 939 | 
 940 |         %% Valid 3-byte ending
 941 |         <<_:Size3/binary, 2#1110:4, _A:4,  2#10:2, _B:6,  2#10:2, _C:6>> ->
 942 |              {Bin, <<>>};
 943 |         %% Invalid 3-byte ending
 944 |         <<Pre:Size4/binary, 2#11110:5, A:3,  2#10:2, B:6, 2#10:2, C:6>> ->
 945 |             {Pre, <<2#11110:5, A:3, 2#10:2, B:6, 2#10:2, C:6>>};
 946 | 
 947 |         %% Valid 4-byte ending
 948 |         <<_:Size4/binary, 2#11110:5, _A:3,  2#10:2, _B:6,   2#10:2, _C:6,  2#10:2, _D:6>> ->
 949 |              {Bin, <<>>};
 950 | 
 951 |         %% Illegal utf-8 sequence.
 952 |         _ ->
 953 | 	    %% Can't repair it, just return
 954 | 	    {Bin, <<>>}
 955 |     end.
 956 | 
 957 | % @doc Checks the beginning of a binary and strips of partial utf-8 encoded bytes.
 958 | repair_head(<<>>) ->
 959 |     {<<>>, <<>>};
 960 | % valid 1-byte beginning
 961 | repair_head(<<2#0:1, _A:7, _Rest/binary>>=Bin) ->
 962 |     {<<>>, Bin};
 963 | % valid 4-byte beginning
 964 | repair_head(<<2#11110:5, _A:3,  2#10:2, _B:6, 2#10:2, _C:6,  2#10:2, _D:6, _Rest/binary>>=Bin) ->
 965 |     {<<>>, Bin};
 966 | % valid 3-byte beginning
 967 | repair_head(<<2#1110:4, _A:4,  2#10:2, _B:6,  2#10:2, _C:6, _Rest/binary>>=Bin) ->
 968 |     {<<>>, Bin};
 969 | % invalid 3-byte beginning
 970 | repair_head(<<2#10:2, A:6, 2#10:2, B:6, 2#10:2, C:6, Rest/binary>>) ->
 971 |     {<<2#10:2, A:6, 2#10:2, B:6, 2#10:2, C:6>>, Rest};
 972 | % valid 2-byte beginning
 973 | repair_head(<<2#110:3, _A:5, 2#10:2, _B:6, _Rest/binary>>=Bin) ->
 974 |     {<<>>, Bin};
 975 | % invalid 2-byte beginnings
 976 | repair_head(<<2#10:2, A:6, 2#10:2, B:6, Rest/binary>>) ->
 977 |     {<<2#10:2, A:6, 2#10:2, B:6>>, Rest};
 978 | % invalid 1-byte beginning
 979 | repair_head(<<2#10:2, A:6, Rest/binary>>) ->
 980 |     {<<2#10:2, A:6>>, Rest};
 981 | repair_head(Bin) ->
 982 |     %% Illegal sequence, can't repair it.
 983 |     {<<>>, Bin}.
 984 | 
 985 | 
 986 | %% This function can go away when we support OTP 20 and up.
 987 | %%
 988 | int_ceil(Number) ->
 989 |     T = trunc(Number),
 990 |     case (Number - T) of
 991 |         Neg when Neg < 0 -> T;
 992 |         Pos when Pos > 0 -> T + 1;
 993 |         _ -> T
 994 |     end.
 995 | 
 996 | %%
 997 | %% Tests
 998 | %%
 999 | 
1000 | -ifdef(TEST).
1001 | 
1002 | -include_lib("eunit/include/eunit.hrl").
1003 | 
1004 | repair_tail_test() ->
1005 |     ?assertEqual({<<>>, <<>>}, repair_tail(<<>>)),
1006 |     ?assertEqual({<<"aap">>, <<>>}, repair_tail(<<"aap">>)),
1007 |     ?assertEqual({<<200/utf8>>, <<>>}, repair_tail(<<200/utf8>>)),
1008 |     ?assertEqual({<<600/utf8>>, <<>>}, repair_tail(<<600/utf8>>)),
1009 |     ?assertEqual({<<1000/utf8>>, <<>>}, repair_tail(<<1000/utf8>>)),
1010 | 
1011 |     ?assertEqual({<<"aap">>, <<200>>}, repair_tail(<<"aap", 200>>)),
1012 | 
1013 |     ok.
1014 | 
1015 | repair_head_test() -> 
1016 |     ?assertEqual({<<>>, <<>>}, repair_head(<<>>)),
1017 |     ?assertEqual({<<>>, <<"a">>}, repair_head(<<"a">>)),
1018 |     ?assertEqual({<<>>, <<"aap">>}, repair_head(<<"aap">>)),
1019 |     ?assertEqual({<<>>, <<200/utf8>>}, repair_head(<<200/utf8>>)),
1020 |     ?assertEqual({<<>>, <<600/utf8>>}, repair_head(<<600/utf8>>)),
1021 |     ?assertEqual({<<>>, <<1000/utf8>>}, repair_head(<<1000/utf8>>)),
1022 | 
1023 |     %%
1024 |     ?assertEqual({<<2#10:2, 10:6>>, <<"aap">>}, 
1025 |         repair_head(<<2#10:2, 10:6, "aap">>)),
1026 |     ?assertEqual({<<2#10:2, 60:6, 2#10:2, 10:6>>, <<"aap">>}, 
1027 |         repair_head(<<2#10:2, 60:6, 2#10:2, 10:6, "aap">>)),
1028 |     ?assertEqual({<<2#10:2, 60:6, 2#10:2, 10:6, 2#10:2, 13:6>>, <<"aap">>}, 
1029 |         repair_head(<<2#10:2, 60:6, 2#10:2, 10:6, 2#10:2, 13:6, "aap">>)),
1030 | 
1031 |     ok.
1032 |     
1033 | 
1034 | for_test() ->
1035 |     ?assertEqual(9, for(0, 10, fun(I, _N) -> {continue, I} end, undefined)),
1036 |     ?assertEqual(0, for(0, 10, fun(I, _N) -> {break, I} end, undefined)),
1037 |     ok.
1038 | 
1039 | array_test() ->
1040 |     ?assertEqual(20, array:size(array_from_binary(<<"de apen eten bananen">>))),
1041 |     ?assertEqual(<<"broodje aap">>, binary_from_array(0, 11, array_from_binary(<<"broodje aap">>))),
1042 |     ?assertEqual(<<"aa">>, binary_from_array(0, 2, array_from_binary(<<"aap">>))),
1043 |     ?assertEqual(<<"ap">>, binary_from_array(1, 3, array_from_binary(<<"aap">>))),
1044 |     ok.
1045 | 
1046 | diff_utf8_test() ->
1047 |     ?assertEqual([{equal, <<208,174, 208,189, 208,184, 208,186, 208,190, 208,180>>}], 
1048 |         diff(<<208,174,208,189,208,184,208,186,208,190,208,180>>, 
1049 | 	     <<208,174,208,189,208,184,208,186,208,190,208,180>>)),
1050 | 
1051 |     ?assertEqual([{insert, <<208,174,208,189,208,184,208,186,208,190,208,180>>}], 
1052 |         diff(<<>>, <<208,174,208,189,208,184,208,186,208,190,208,180>>)),
1053 |     ?assertEqual([{delete, <<208,174,208,189,208,184,208,186,208,190,208,180>>}], 
1054 |         diff(<<208,174,208,189,208,184,208,186,208,190,208,180>>, <<>>)),
1055 | 
1056 |     ?assertEqual([{equal, <<229/utf8>>},
1057 |                   {delete, <<228/utf8>>},
1058 |                   {equal, <<246/utf8, 251/utf8>>}], 
1059 |          diff(<<229/utf8, 228/utf8, 246/utf8, 251/utf8>>, 
1060 |               <<229/utf8, 246/utf8, 251/utf8>>)),
1061 | 
1062 |     ok.
1063 | 
1064 | diff_bisect_test() ->
1065 |     ?assertEqual([{equal,<<"fruit flies ">>},
1066 |                   {delete,<<"lik">>},
1067 |                   {equal,<<"e">>},
1068 |                   {insert,<<"at">>},
1069 |                   {equal,<<" a banana">>}], diff_bisect(<<"fruit flies like a banana">>, 
1070 |                                                         <<"fruit flies eat a banana">>)),
1071 | 
1072 | 
1073 |     %?assertEqual([{delete,<<"cat">>},
1074 |     %              {insert,<<"map">>}], diff_bisect(<<"cat">>, <<"map">>)), 
1075 | 
1076 |     ?assertEqual([{delete,<<"c">>},
1077 |                   {insert,<<"m">>},
1078 |                   {equal,<<"a">>},
1079 |                   {delete,<<"t">>},
1080 |                   {insert,<<"p">>}],
1081 |                   diff_bisect(<<"cat">>, <<"map">>)), 
1082 | 
1083 |     ?assertEqual([{equal,<<"cat ">>},
1084 |                   {insert,<<"mouse dog sheep ">>},
1085 |                   {insert,<<"monkey chicken ">>},
1086 |                   {equal,<<"zebra">>}
1087 |                  ], diff_bisect(<<"cat zebra">>, <<"cat mouse dog sheep monkey chicken zebra">>)), 
1088 | 
1089 |     ?assertEqual([{equal, <<"text">>}],
1090 |                  diff_bisect(<<"text">>, <<"text">>)),
1091 |                  
1092 | 
1093 |     ok.
1094 | 
1095 | half_match_test() ->
1096 |     ?assertEqual(undefined, half_match(<<"1234567890">>, <<"abcdef">>)),
1097 |     ?assertEqual(undefined, half_match(<<"12345">>, <<"23">>)),
1098 | 
1099 |     %% Single Match
1100 |     ?assertEqual({half_match, <<"12">>, <<"90">>, <<"a">>, <<"z">>, <<"345678">>}, 
1101 |         half_match(<<"1234567890">>, <<"a345678z">>)),
1102 |     ?assertEqual({half_match, <<"a">>, <<"z">>, <<"12">>, <<"90">>, <<"345678">>}, 
1103 |         half_match(<<"a345678z">>, <<"1234567890">>)),
1104 |     ?assertEqual({half_match, <<"abc">>, <<"z">>, <<"1234">>, <<"0">>, <<"56789">>}, 
1105 |         half_match(<<"abc56789z">>, <<"1234567890">>)),
1106 |     ?assertEqual({half_match, <<"a">>, <<"xyz">>, <<"1">>, <<"7890">>, <<"23456">>}, 
1107 |         half_match(<<"a23456xyz">>, <<"1234567890">>)),
1108 | 
1109 |     %% Multiple Matches
1110 |     ?assertEqual({half_match, <<"12123">>, <<"123121">>, <<"a">>, <<"z">>, <<"1234123451234">>}, 
1111 |         half_match(<<"121231234123451234123121">>, <<"a1234123451234z">>)),
1112 | 
1113 |     ?assertEqual({half_match, <<"">>, <<"-=-=-=-=-=">>, <<"x">>, <<"">>, <<"x-=-=-=-=-=-=-=">>}, 
1114 |         half_match(<<"x-=-=-=-=-=-=-=-=-=-=-=-=">>, <<"xx-=-=-=-=-=-=-=">>)),
1115 | 
1116 |     ?assertEqual({half_match, <<"-=-=-=-=-=">>, <<"">>, <<"">>, <<"y">>, <<"-=-=-=-=-=-=-=y">>}, 
1117 |         half_match(<<"-=-=-=-=-=-=-=-=-=-=-=-=y">>, <<"-=-=-=-=-=-=-=yy">>)),
1118 | 
1119 |     % Non-optimal halfmatch.
1120 |     % Optimal diff would be -q+x=H-i+e=lloHe+Hu=llo-Hew+y not -qHillo+x=HelloHe-w+Hulloy
1121 |     ?assertEqual({half_match, <<"qHillo">>, <<"w">>, <<"x">>, <<"Hulloy">>, <<"HelloHe">>}, 
1122 |         half_match(<<"qHilloHelloHew">>, <<"xHelloHeHulloy">>)),
1123 | 
1124 |     ok.
1125 | 
1126 | 
1127 | common_prefix_test() ->
1128 |     ?assertEqual(<<>>, common_prefix(<<"Text">>, <<"Next">>)),
1129 |     ?assertEqual(<<"T">>, common_prefix(<<"Text">>, <<"Tax">>)),
1130 |     ?assertEqual(<<"text">>, common_prefix(<<"text">>, <<"text">>)),
1131 |     ok.
1132 | 
1133 | common_suffix_test() ->
1134 |     ?assertEqual(<<"ext">>, common_suffix(<<"Text">>, <<"Next">>)),
1135 |     ?assertEqual(<<>>, common_suffix(<<"Text">>, <<"Tax">>)),
1136 |     ?assertEqual(<<"text">>, common_suffix(<<"text">>, <<"text">>)),
1137 |     ok.
1138 | 
1139 | split_pre_and_suffix_test() ->
1140 |     ?assertEqual({<<>>, <<>>, <<>>, <<>>}, split_pre_and_suffix(<<>>, <<>>)),
1141 | 
1142 |     ?assertEqual({<<>>, <<"a">>, <<"b">>, <<>>}, split_pre_and_suffix(<<"a">>, <<"b">>)),
1143 |     
1144 |     ?assertEqual({<<"a">>, <<"b">>, <<"c">>, <<"d">>}, 
1145 |        split_pre_and_suffix(<<"abd">>, <<"acd">>)),
1146 |     ?assertEqual({<<"aa">>, <<"bb">>, <<"cc">>, <<"dd">>}, 
1147 |        split_pre_and_suffix(<<"aabbdd">>, <<"aaccdd">>)),
1148 |     ?assertEqual({<<"aa">>, <<"bb">>, <<"c">>, <<"dd">>}, 
1149 |        split_pre_and_suffix(<<"aabbdd">>, <<"aacdd">>)),
1150 | 
1151 |     ?assertEqual({<<"cat ">>, <<>>, <<"mouse dog ">>, <<>>},
1152 |                  split_pre_and_suffix(<<"cat ">>, <<"cat mouse dog ">>)),
1153 | 
1154 |     ok. 
1155 | 
1156 | unique_match_test() ->
1157 |     ?assertEqual(true, unique_match(<<"a">>, <<"abc">>)),
1158 |     ?assertEqual(true, unique_match(<<"b">>, <<"abc">>)),
1159 |     ?assertEqual(true, unique_match(<<"c">>, <<"abc">>)),
1160 |     ?assertEqual(false, unique_match(<<"ab">>, <<"abab">>)),
1161 |     ok.
1162 | 
1163 | 
1164 | text_smaller_than_test() ->
1165 |     ?assertEqual(true, text_smaller_than(<<>>, 5)),
1166 |     ?assertEqual(true, text_smaller_than(<<>>, 1)),
1167 | 
1168 |     ?assertEqual(false, text_smaller_than(<<>>, 0)),
1169 | 
1170 |     ?assertEqual(false, text_smaller_than(<<"abc">>, 0)),
1171 |     ?assertEqual(false, text_smaller_than(<<"abc">>, 1)),
1172 |     ?assertEqual(true, text_smaller_than(<<"abc">>, 4)),
1173 | 
1174 |     %% Test if we count characters.
1175 |     Utf8Binary = <<1046/utf8, 1011/utf8, 1022/utf8, 127/utf8>>,
1176 |     ?assertEqual(true, size(Utf8Binary) > 5), % binary is larger due to utf8 encoding
1177 |     ?assertEqual(true, text_smaller_than(Utf8Binary, 5)),
1178 |     ?assertEqual(false, text_smaller_than(Utf8Binary, 4)),
1179 | 
1180 |     %% Test illegal utf8 sequence, the chars are counted as normal chars
1181 |     ?assertEqual(false, text_smaller_than(<<149,157,112,8>>, 4)),
1182 | 
1183 |     ok.
1184 | 
1185 | lines_to_chars_test() ->
1186 |     ?assertEqual({<<>>, <<>>, []}, lines_to_chars(<<>>, <<>>)),
1187 | 
1188 |     %% Simple text
1189 |     ?assertEqual({<<0, 1>>, <<0, 2>>, [<<"hello\n">>, <<"world\n">>, <<"maas\n">>]}, 
1190 |         lines_to_chars(<<"hello\n\world\n">>, <<"hello\nmaas\n">>)),
1191 | 
1192 |     %% No newline at the end.
1193 |     ?assertEqual({<<0, 1>>, <<0, 2>>, [<<"hello\n">>, <<"world\n">>, <<"maas">>]}, 
1194 |         lines_to_chars(<<"hello\n\world\n">>, <<"hello\nmaas">>)),
1195 |    
1196 |     %% No newline at the end.
1197 |     ?assertEqual({<<0, 1>>, <<0, 2>>, [<<"hello\n">>, <<"world\n">>, <<"maas">>]}, 
1198 |         lines_to_chars(<<"hello\n\world\n">>, <<"hello\nmaas">>)),
1199 |     
1200 |     %% With empty lines 
1201 |     ?assertEqual({<<0, 1, 2>>, <<0, 1, 3>>, [<<"hello\n">>, <<"\n">>, <<"world\n">>, <<"maas">>]}, 
1202 |         lines_to_chars(<<"hello\n\nworld\n">>, <<"hello\n\nmaas">>)),
1203 | 
1204 |     ok.
1205 | 
1206 | 
1207 | diff_linemode_test() ->
1208 |     ?assertEqual([{equal, <<"hello\n">>}, {delete, <<"world\n">>}, {insert, <<"maas\n">>}], 
1209 |         diff_linemode(<<"hello\nworld\n">>, <<"hello\nmaas\n">>)),
1210 | 
1211 |     ok.
1212 | 
1213 | -endif.
1214 | 


--------------------------------------------------------------------------------