RubyGems - gdiff - Versions diffs - 0.0.1 - Mend

gdiff 0.0.1

Files changed (58) hide show

data/CHANGELOG +7 -0
data/COPYING.suffix_array +278 -0
data/LICENSE.suffix_array +17 -0
data/README +40 -0
data/README.suffix_array +274 -0
data/bin/gdiff +25 -0
data/bin/gpatch +25 -0
data/doc/classes/Diff.html +117 -0
data/doc/classes/Diff/GDiff.html +120 -0
data/doc/classes/Diff/GDiff/EGdiffError.html +111 -0
data/doc/classes/Diff/GDiff/ENoGdiffStream.html +113 -0
data/doc/classes/Diff/GDiff/EPrematureEndOfStream.html +113 -0
data/doc/classes/Diff/GDiff/Operations.html +156 -0
data/doc/classes/Diff/GDiff/Operations/Copy.html +246 -0
data/doc/classes/Diff/GDiff/Operations/Copy.src/M000014.html +19 -0
data/doc/classes/Diff/GDiff/Operations/Copy.src/M000015.html +39 -0
data/doc/classes/Diff/GDiff/Operations/Copy.src/M000016.html +25 -0
data/doc/classes/Diff/GDiff/Operations/Copy.src/M000017.html +18 -0
data/doc/classes/Diff/GDiff/Operations/Data.html +246 -0
data/doc/classes/Diff/GDiff/Operations/Data.src/M000009.html +18 -0
data/doc/classes/Diff/GDiff/Operations/Data.src/M000010.html +18 -0
data/doc/classes/Diff/GDiff/Operations/Data.src/M000011.html +35 -0
data/doc/classes/Diff/GDiff/Operations/Data.src/M000012.html +29 -0
data/doc/classes/Diff/GDiff/Operations/Data.src/M000013.html +19 -0
data/doc/classes/SAError.html +111 -0
data/doc/classes/SuffixArray.html +342 -0
data/doc/classes/SuffixArray.src/M000001.html +97 -0
data/doc/classes/SuffixArray.src/M000002.html +73 -0
data/doc/classes/SuffixArray.src/M000003.html +102 -0
data/doc/classes/SuffixArray.src/M000004.html +47 -0
data/doc/classes/SuffixArray.src/M000005.html +44 -0
data/doc/classes/SuffixArray.src/M000006.html +33 -0
data/doc/classes/SuffixArray.src/M000007.html +24 -0
data/doc/classes/SuffixArray.src/M000008.html +46 -0
data/doc/created.rid +1 -0
data/doc/files/ext/gdiff/suffix_array/extconf_rb.html +108 -0
data/doc/files/ext/gdiff/suffix_array/lcp_c.html +101 -0
data/doc/files/ext/gdiff/suffix_array/sarray_c.html +101 -0
data/doc/files/ext/gdiff/suffix_array/suffix_array_c.html +101 -0
data/doc/files/lib/gdiff_rb.html +108 -0
data/doc/fr_class_index.html +36 -0
data/doc/fr_file_index.html +31 -0
data/doc/fr_method_index.html +43 -0
data/doc/index.html +24 -0
data/doc/rdoc-style.css +208 -0
data/ext/gdiff/COPYING +278 -0
data/ext/gdiff/LICENSE +17 -0
data/ext/gdiff/README +274 -0
data/ext/gdiff/extconf.rb +3 -0
data/ext/gdiff/lcp.c +97 -0
data/ext/gdiff/sarray.3 +145 -0
data/ext/gdiff/sarray.c +372 -0
data/ext/gdiff/sarray.h +13 -0
data/ext/gdiff/suffix_array.c +510 -0
data/lib/gdiff.rb +255 -0
data/setup.rb +1551 -0
data/test/tc_gdiff.rb +66 -0
metadata +119 -0

data/doc/classes/SuffixArray.src/M000001.html ADDED

@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+  <title>new (SuffixArray)</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <link rel="stylesheet" href="../.././rdoc-style.css" type="text/css" media="screen" />
+</head>
+<body class="standalone-code">
+  <pre>/*
+ * call-seq:
+ *   SuffixArray.new(source, [raw_array], [start]) -&gt; SuffixArray
+ *
+ * Given a string (anything like a string really) this will generate a
+ * suffix array for the string so that you can work with it.  The
+ * source cannot be an empty string since this is a useless operation.
+ *
+ * Two optional parameters allow you to restore a suffix array without
+ * running the construction process again.  You basically give it the
+ * String from SuffixArray.raw_array and the start from SuffixArray.suffix_start
+ * and it will skip most calculations.  &lt;b&gt;This feature is really experimental
+ * and is CPU dependent since the integers in the raw_array are native.&lt;/b&gt;
+ */
+static VALUE SuffixArray_initialize(int argc, VALUE *argv, VALUE self)
+{
+    SuffixArray *sa = NULL;
+    size_t i = 0;
+    Data_Get_Struct(self, SuffixArray, sa);
+    assert(sa != NULL);
+    VALUE source;
+    VALUE array;
+    VALUE start;
+    // sort out the arguments and such
+    rb_scan_args(argc, argv, &quot;12&quot;, &amp;source, &amp;array, &amp;start);
+    // get the string value of the source given to us, keep it around for later
+    VALUE sa_source_str = StringValue(source);
+    rb_iv_set(self, &quot;@source&quot;, sa_source_str);
+    // setup temporary variables for the source and length pointers
+    unsigned char *sa_source = RSTRING(sa_source_str)-&gt;ptr;
+    size_t sa_source_len = RSTRING(sa_source_str)-&gt;len;
+    // error check the whole thing
+    if(sa_source_len == 0) {
+        // we can't have this, so return a nil
+        rb_raise(cSAError, ERR_NO_ZERO_LENGTH_INPUT);
+    }
+    if(!NIL_P(array) &amp;&amp; NIL_P(start)) {
+        rb_raise(cSAError, ERR_START_IF_ARRAY);
+    } else if (!NIL_P(array) &amp;&amp; !NIL_P(start)) {
+        // looks like both parameters were given so check out the lengths
+        if(RSTRING(array)-&gt;len / sizeof(int) != sa_source_len) {
+            rb_raise(cSAError, ERR_MISMATCH_LENGTH);
+        }
+    }
+    // allocate memory for the index integers
+    sa-&gt;suffix_index = malloc(sizeof(int) * (sa_source_len + 1));
+    if(NIL_P(array)) {
+        // create the suffix array from the source
+        int st = bsarray(sa_source, sa-&gt;suffix_index, sa_source_len-1);
+        // set the suffix_start in our object
+        rb_iv_set(self, &quot;@suffix_start&quot;, INT2NUM(st));
+    } else {
+        // convert the given array and start to the internal structures needed
+        // the return value is ignored since I can't seem find any consistent definition for
+        // it's value that will tell me if this failed.
+        memcpy(sa-&gt;suffix_index, RSTRING(array)-&gt;ptr, sa_source_len * sizeof(int));
+        rb_iv_set(self, &quot;@suffix_start&quot;, start);
+    }
+    unsigned char c = sa_source[sa-&gt;suffix_index[0]];  // start off with the first char in the sarray list
+    sa-&gt;starts[c] = 0;
+    for(i = 0; i &lt; sa_source_len; i++) {
+        // skip characters until we see a new one
+        if(sa_source[sa-&gt;suffix_index[i]] != c) {
+            sa-&gt;ends[c] = i-1; // it's -1 since this is a new character, so the end was actually behind this point
+            c = sa_source[sa-&gt;suffix_index[i]];
+            sa-&gt;starts[c] = i;
+        }
+    }
+    // set the last valid character to get the tail of the sa, the loop will miss it
+    c = sa_source[sa-&gt;suffix_index[sa_source_len-1]];
+    sa-&gt;ends[c] = sa_source_len-1;
+    return INT2FIX(sa_source_len);
+}</pre>
+</body>
+</html>

data/doc/classes/SuffixArray.src/M000002.html ADDED

@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+  <title>longest_match (SuffixArray)</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <link rel="stylesheet" href="../.././rdoc-style.css" type="text/css" media="screen" />
+</head>
+<body class="standalone-code">
+  <pre>/*
+ * call-seq:
+ *   sarray.longest_match(target, from_index) -&gt; [start, length]
+ *
+ * Takes a target string and an index inside that string, and then tries
+ * to find the longest match from that point in the source string for this
+ * SuffixArray object.
+ *
+ * It returns an array of [start, length] of where in the source a length
+ * string from the target would match.
+ *
+ * Refer to the unit test for examples of usage.
+ */
+static VALUE SuffixArray_longest_match(VALUE self, VALUE target, VALUE from_index)
+{
+    SuffixArray *sa = NULL;
+    Data_Get_Struct(self, SuffixArray, sa);
+    VALUE sa_source = SuffixArray_source(self);
+    if(sa == NULL || sa-&gt;suffix_index == NULL || RSTRING(sa_source)-&gt;len == 0) {
+        rb_raise(cSAError, ERR_NOT_INITIALIZED);
+    }
+    // get the from and for_length arguments as unsigned ints
+    size_t from = NUM2UINT(from_index);
+    // get better pointers for the source (should already be in String form)
+    unsigned char *source_ptr = RSTRING(sa_source)-&gt;ptr;
+    size_t source_len = RSTRING(sa_source)-&gt;len;
+    // get the target as a string
+    VALUE target_str = StringValue(target);
+    // better pointers again, we also need target_len as an in/out parameter
+    unsigned char *target_ptr = RSTRING(target_str)-&gt;ptr;
+    size_t target_len = RSTRING(target_str)-&gt;len;
+    // check the input for validity, returning nil like in array operations
+    if(from &gt; target_len) {
+        return Qnil;
+    }
+    // adjust for the from and for_length settings to be within the target len
+    target_ptr += from;
+    target_len -= from;
+    size_t start = find_longest_match(source_ptr, source_len, target_ptr, &amp;target_len,
+                                      sa-&gt;starts, sa-&gt;ends, sa-&gt;suffix_index);
+    // create the 2 value return array
+    VALUE result = rb_ary_new();
+    rb_ary_push(result, INT2FIX(start));
+    rb_ary_push(result, INT2FIX(target_len));
+    return result;
+}</pre>
+</body>
+</html>

data/doc/classes/SuffixArray.src/M000003.html ADDED

@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+  <title>longest_nonmatch (SuffixArray)</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <link rel="stylesheet" href="../.././rdoc-style.css" type="text/css" media="screen" />
+</head>
+<body class="standalone-code">
+  <pre>/*
+ * call-seq:
+ *   sarray.longest_nonmatch(target, from_index, min_match) -&gt; [non_match_length, match_start, match_length]
+ *
+ * Mostly the inverse of longest_match, except that it first tries to find a
+ * non-matching region, then a matching region.  The target and from_index are
+ * the same as in longest_match.  The min_match argument is the smallest matching
+ * region that you'll accept as significant enough to end the non-matching search.
+ * Giving non_match=0 will stop at the first matching region.
+ *
+ * It works by first searching the suffix array for a non-matching region.  When it
+ * hits a character that is in the source (according to the suffix array) it tries
+ * to find a matching region.  If it can find a matching region that is longer than min_match
+ * then it stops and returns, otherwise it adds this match to the length of the non-matching
+ * region and continues.
+ *
+ * The return value is an Array of [non_match_length, match_start, match_length].
+ */
+static VALUE SuffixArray_longest_nonmatch(VALUE self, VALUE target, VALUE from_index, VALUE min_match)
+{
+    SuffixArray *sa = NULL;
+    Data_Get_Struct(self, SuffixArray, sa);
+    VALUE sa_source = SuffixArray_source(self);
+    if(sa == NULL || sa-&gt;suffix_index == NULL || RSTRING(sa_source)-&gt;len == 0) {
+        rb_raise(cSAError, ERR_NOT_INITIALIZED);
+    }
+    // get the from and for_length arguments as unsigned ints
+    size_t from = NUM2UINT(from_index);
+    size_t min = NUM2INT(min_match);
+    // get better pointers for the source (should already be in String form)
+    unsigned char *source_ptr = RSTRING(sa_source)-&gt;ptr;
+    size_t source_len = RSTRING(sa_source)-&gt;len;
+    // get the target as a string
+    VALUE target_str = StringValue(target);
+    // better pointers again, we also need target_len as an in/out parameter
+    unsigned char *target_ptr = RSTRING(target_str)-&gt;ptr;
+    size_t target_len = RSTRING(target_str)-&gt;len;
+    // check the input for validity, returning nil like in array operations
+    if(from &gt; target_len) {
+        return Qnil;
+    }
+    // adjust for the from and for_length settings to be within the target len
+    unsigned char *scan = target_ptr + from;
+    unsigned char *end = target_ptr + target_len;
+    size_t match_len = 0;
+    size_t match_start = 0;
+    while(scan &lt; end) {
+        if(*scan != source_ptr[sa-&gt;suffix_index[sa-&gt;starts[*scan]]]) {
+            scan ++;
+        } else {
+            // search remaining stuff for a possible match, which return as a result as well
+            match_len = end - scan;
+            match_start = find_longest_match(source_ptr, source_len, scan, &amp;match_len,
+                                              sa-&gt;starts, sa-&gt;ends, sa-&gt;suffix_index);
+            if(match_len == 0) {
+                // match not found, which really shouldn't happen
+                break;
+            } else if(match_len &gt; min) {
+                // the match is possibly long enough, drop out
+                break;
+            } else {
+                // the number of possibly matching characters is much too small, so we continue by skipping them
+                scan += match_len;
+                // reset the match_len and match_start to 0 to signal that a match hasn't been found yet
+                match_len = match_start = 0;
+            }
+        }
+    }
+    VALUE result = rb_ary_new();
+    size_t nonmatch_len = (scan - (target_ptr + from));
+    rb_ary_push(result, INT2FIX(nonmatch_len));
+    rb_ary_push(result, INT2FIX(match_start));
+    rb_ary_push(result, INT2FIX(match_len));
+    return result;
+}</pre>
+</body>
+</html>

data/doc/classes/SuffixArray.src/M000004.html ADDED

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+  <title>array (SuffixArray)</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <link rel="stylesheet" href="../.././rdoc-style.css" type="text/css" media="screen" />
+</head>
+<body class="standalone-code">
+  <pre>/*
+ * call-seq:
+ *   sarray.array -&gt; Array
+ *
+ * Returns a copy of the internal suffix array as an Array of Fixnum objects.  This
+ * array is a copy so you're free to mangle it however you wish.
+ *
+ * A suffix array is the sequence of indices into the source that mark each suffix
+ * as if they were sorted.
+ */
+static VALUE SuffixArray_array(VALUE self)
+{
+    SuffixArray *sa = NULL;
+    Data_Get_Struct(self, SuffixArray, sa);
+    VALUE sa_source = SuffixArray_source(self);
+    if(sa == NULL || sa-&gt;suffix_index == NULL || RSTRING(sa_source)-&gt;len == 0) {
+        rb_raise(cSAError, ERR_NOT_INITIALIZED);
+    }
+    // get the length of the suffix index
+    size_t source_len = RSTRING(sa_source)-&gt;len;
+    size_t i = 0;
+    VALUE result = rb_ary_new();
+    for(i = 0; i &lt; source_len; i++) {
+        rb_ary_push(result, INT2FIX(sa-&gt;suffix_index[i]));
+    }
+    return result;
+}</pre>
+</body>
+</html>

data/doc/classes/SuffixArray.src/M000005.html ADDED

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+  <title>raw_array (SuffixArray)</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <link rel="stylesheet" href="../.././rdoc-style.css" type="text/css" media="screen" />
+</head>
+<body class="standalone-code">
+  <pre>/*
+ * call-seq:
+ *     sarray.raw_array -&gt; String
+ *
+ * Returns the &quot;raw&quot; internal suffix array which is an array of C int types used
+ * internally as the suffix array.  The purpose of this function is to allow you
+ * to store the suffix_array and then very quickly restore it later without having
+ * to rebuild the suffix array.
+ *
+ * The returned String should be treated as an opaque structure.  It is just a
+ * copy of the int[] used internally.  This means that it is dependent on your
+ * CPU.  If you want something you can use that is cross platform then use the
+ * SuffixArray.array function instead.
+ */
+static VALUE SuffixArray_raw_array(VALUE self)
+{
+    SuffixArray *sa = NULL;
+    Data_Get_Struct(self, SuffixArray, sa);
+    VALUE sa_source = SuffixArray_source(self);
+    if(sa == NULL || sa-&gt;suffix_index == NULL || RSTRING(sa_source)-&gt;len == 0) {
+        rb_raise(cSAError, ERR_NOT_INITIALIZED);
+    }
+    // build a string that copies this stuff
+    VALUE result = rb_str_new((const char *)sa-&gt;suffix_index, RSTRING(sa_source)-&gt;len * sizeof(int));
+    return result;
+}</pre>
+</body>
+</html>

data/doc/classes/SuffixArray.src/M000006.html ADDED

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+  <title>suffix_start (SuffixArray)</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <link rel="stylesheet" href="../.././rdoc-style.css" type="text/css" media="screen" />
+</head>
+<body class="standalone-code">
+  <pre>/*
+ * call-seq:
+ *   sarray.start -&gt; Fixnum
+ *
+ * Tells you which index in the suffix array is the longest suffix (also known as the
+ * start of the source string).  If you want to get the beginning of the source string
+ * in a round about way you would do this:
+ *
+ * source = &quot;abracadabra&quot;
+ * sa = SuffixArray.new source
+ * first = source[sa.array[sa.start]]]
+ *
+ * Remember that the start is the index into the suffix array where the source starts,
+ * not an index into the source string (that would just be 0).
+ */
+static VALUE SuffixArray_suffix_start(VALUE self)
+{
+    return rb_iv_get(self, &quot;@suffix_start&quot;);
+}</pre>
+</body>
+</html>

data/doc/classes/SuffixArray.src/M000007.html ADDED

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+  <title>source (SuffixArray)</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <link rel="stylesheet" href="../.././rdoc-style.css" type="text/css" media="screen" />
+</head>
+<body class="standalone-code">
+  <pre>/*
+ * call-seq:
+ *    sarray.source -&gt; String
+ *
+ * Returns the source that this suffix array was constructed with.
+ */
+static VALUE SuffixArray_source(VALUE self)
+{
+    return rb_iv_get(self, &quot;@source&quot;);
+}</pre>
+</body>
+</html>

data/doc/classes/SuffixArray.src/M000008.html ADDED

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+  <title>all_starts (SuffixArray)</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <link rel="stylesheet" href="../.././rdoc-style.css" type="text/css" media="screen" />
+</head>
+<body class="standalone-code">
+  <pre>/*
+ * call-seq:
+ *   sarray.all_starts(character) -&gt; Array
+ *
+ * Returns an array containing all the indexes into the source that start
+ * with the given character.  This is a very fast operation since the
+ * SuffixArray already knows where each character starts and ends in the
+ * suffix array structure internally.  All it does is copy the range of
+ * the suffix array for that region.
+ */
+static VALUE SuffixArray_all_starts(VALUE self, VALUE character)
+{
+    SuffixArray *sa = NULL;
+    Data_Get_Struct(self, SuffixArray, sa);
+    VALUE result = rb_ary_new();
+    VALUE char_str = StringValue(character);
+    // must be at least one length
+    if(RSTRING(char_str)-&gt;len &gt; 0) {
+        size_t ch = (size_t)RSTRING(char_str)-&gt;ptr[0];
+        // go through all the suffix array indices as indicated by sa-&gt;starts and sa-&gt;ends
+        size_t start = 0;
+        for(start = sa-&gt;starts[ch]; start &lt;= sa-&gt;ends[ch]; start++) {
+            rb_ary_push(result, INT2FIX(sa-&gt;suffix_index[start]));
+        }
+    }
+    return result;
+}</pre>
+</body>
+</html>