|No such thing as a small change|
Algorithm::Diff icult to useby tye (Sage)
|on Aug 21, 2002 at 07:52 UTC||Need Help??|
I've been using Algorithm::Diff a bit lately. I'm really glad we have this module and I like it in a lot of ways. But I've decided that it is okay for me to hate the interfaces provided.
Just some quick background. Algorithm::Diff takes two lists and returns what /usr/bin/diff would return if those were two lists of lines (often called "two text files"). You can get this 'difference' information in three different formats.
Format (1) isn't what I want (most of the time) because it contains copies of the contents of the lines and not the line numbers.
Format (2) is a problem mainly because it is not defined in what order the calls will be made when you have several lines in each file between two blocks of "same" lines. If you have qw( a b c 1 2 3 4 x y z ) vs qw( a b c 7 8 9 x y z ), you know you get 'a' first, then 'b', then 'c'. But then you don't know if you'll get 1 2 3 4 7 8 9 or 1 7 2 8 3 9 4 or 7 8 1 2 9 3 4 or ...
Another problem is that you don't get qw( a b c ) together. Depending on what you are doing, you'll likely have to save up 'a', then 'b', then 'c' (luckily this isn't too bad since these are all calls to the same subroutine). Then, you have to have the other two subroutines note, "Oh, we hit the end of that sequence, we can deal with those lines you saved up in that other subroutine now". I've written some "slick" code that does this (more than once), but I wouldn't call it easy to understand and simple changes in how you want to process things can require major code rework so it certainly isn't easy to maintain.
Format (3) is better in several ways. But it has the potential to make huge numbers of tiny lists of tiny lists (that consume a lot of memory). And these lists contain copies of the line contents (which consume more memory). And the data is split up too much and so is hard to deal with in some ways.
So what I want is a list of line number ranges that coorespond to the runs of 'different' or 'same' lines between the files. So I extended it to provide exactly that and I'm posting it for public review before I finish the patch and forward it to the module owner.
First, here is some rough documentation on what you get back. Since we already have an interface called diff() that I find difficult to use, I've (temporarily) called my interface easy() (yes, I have to think of a better name). If you take this example invocation (mostly taken straight from the module documentation):
@diff will contain 5 elements for each range of either 'different' or 'same' lines between the two lists. The 5 elements are $same, $aMin, $aMax, $bMin, and $bMax. $same is 1 if the ranges represent lines that the files have in common and 0 if the ranges represent differences. The other 4 values are line numbers (well, they are array indices and so are zero-based while line numbers would usually be one-based). @a[$aMin..$aMax] will give the lines from @a that fall into that range while @b[$bMin..$bMax] gives the lines from @b.
Note that $aMin..$aMax is the empty set when $aMax < $aMin (specifically, we'll always use $aMax == $aMin-1) and so @a[$aMin..$aMax] will also be the empty set.
So, for our example, @diff contains (I've used "=>" in place of "," where I want you to think ".."; so the code below is valid Perl that produces the same list as @diff):
Now the hope is that this will be easy to use. So let's try to use it. First, an HTML difference. (I've switched from @diff to $diff for efficiency and to show that it doesn't complicate the code much.)
Second, "unified" output from 'diff':
Thirdly, the most complex, "traditional" output from 'diff':
Well, I think those blocks of code are pretty simple, so I hope that means I've hit on a useful format for the information.
Here is the subroutine that returns the new format:
Thanks for reviewing this and thanks in advance for any suggestions.- tye (but my friends call me "Tye")