version_sorter 1.1.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b1041937013eee0cb93a83330c30e3f6c8b84c5
-  data.tar.gz: d3f4d2a6834e1e0d79f6ef71cd58da5941c372ae
+  metadata.gz: 07d8f2b3a777fa9268641f6e66ec0feaf53173df
+  data.tar.gz: 7e87c239f9aa35b697646588c67f6e789177804a
 SHA512:
-  metadata.gz: e2d9d09fc0cdc43726e65d197ab5f768e46d2581706fd738c460ab0d90ae9ad893e0241ebc8eeb452691c92f2072412133050026144c92738a19b5df3f62acd6
-  data.tar.gz: d60d1df2d3bec7574541036ee0cd486aa448a82e8cd74d176a85d288d78b0f53debcf3d82f0dfa5b00e3368042331df58f164cc8a03c14b34cebc977a1035fef
+  metadata.gz: 05df11ccb84327dc57dccabe71fbdfa847047d28d45a1af451319510746c50b5fe315e7022c50fa6c72cb7c0ac23a65531a71630cbb087d6aeb0e16b22a2fd23
+  data.tar.gz: 8d068f96142e02c18c97459b49efae4338d2cca2b640689a86b918a172c39edf47e7320d3819dfa1021880cf283f6e96ba0414600d2b9195d1536087160e9692

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) K. Adam Christensen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+Software), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/ext/version_sorter/extconf.rb

@@ -1,5 +1,3 @@
 require 'mkmf'
 
-$defs.push("-DBUILD_FOR_RUBY")
-have_library('pcre', 'pcre_compile')
 create_makefile("version_sorter")

data/ext/version_sorter/version_sorter.c

@@ -11,203 +11,225 @@
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
-#include "version_sorter.h"
-
-
-static VersionSortingItem * version_sorting_item_init(const char *, int);
-static void version_sorting_item_free(VersionSortingItem *);
-static void version_sorting_item_add_piece(VersionSortingItem *, char *);
-static void parse_version_word(VersionSortingItem *);
-static void create_normalized_version(VersionSortingItem *, const int);
-static int compare_by_version(const void *, const void *);
-static enum scan_state scan_state_get(const char);
-
+#include <assert.h>
+#include <ruby.h>
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+typedef int compare_callback_t(const void *, const void *);
+
+struct version_number {
+	const char *original;
+	VALUE rb_version;
+	uint64_t num_flags;
+	int32_t size;
+	union version_comp {
+		uint32_t number;
+		struct strchunk {
+			uint16_t offset;
+			uint16_t len;
+		} string;
+	} comp[1];
+};
+
+static int
+strchunk_cmp(const char *original_a, const struct strchunk *a,
+		const char *original_b, const struct strchunk *b)
+{
+	size_t len = min(a->len, b->len);
+	int cmp = memcmp(original_a + a->offset, original_b + b->offset, len);
+	return cmp ? cmp : (int)(a->len - b->len);
+}
 
-VersionSortingItem *
-version_sorting_item_init(const char *original, int idx)
+static int
+compare_version_number(const struct version_number *a,
+		const struct version_number *b)
 {
-    VersionSortingItem *vsi = malloc(sizeof(VersionSortingItem));
-    if (vsi == NULL) {
-        DIE("ERROR: Not enough memory to allocate VersionSortingItem")
-    }
-    vsi->head = NULL;
-    vsi->tail = NULL;
-    vsi->node_len = 0;
-    vsi->widest_len = 0;
-    vsi->original = original;
-    vsi->original_len = strlen(original);
-    vsi->original_idx = idx;
-    vsi->normalized = NULL;
-    parse_version_word(vsi);
-
-    return vsi;
+	int n, max_n = min(a->size, b->size);
+
+	for (n = 0; n < max_n; ++n) {
+		int num_a = (a->num_flags & (1ull << n)) != 0;
+		int num_b = (b->num_flags & (1ull << n)) != 0;
+
+		if (num_a == num_b) {
+			const union version_comp *ca = &a->comp[n];
+			const union version_comp *cb = &b->comp[n];
+			int cmp = 0;
+
+			if (num_a) {
+				cmp = (int)ca->number - (int)cb->number;
+			} else {
+				cmp = strchunk_cmp(
+						a->original, &ca->string,
+						b->original, &cb->string);
+			}
+
+			if (cmp) return cmp;
+		} else {
+			return num_a ? 1 : -1;
+		}
+	}
+
+	if (a->size < b->size)
+		return (b->num_flags & (1ull << n)) ? -1 : 1;
+
+	if (a->size > b->size)
+		return (a->num_flags & (1ull << n)) ? 1 : -1;
+
+	return 0;
 }
 
-void
-version_sorting_item_free(VersionSortingItem *vsi)
+static int
+version_compare_cb(const void *a, const void *b)
 {
-    VersionPiece *cur;
-    while (cur = vsi->head) {
-        vsi->head = cur->next;
-        free(cur->str);
-        free(cur);
-    }
-    if (vsi->normalized != NULL) {
-      free(vsi->normalized);
-    }
-    free(vsi);
+	return compare_version_number(
+		(*(const struct version_number **)a),
+		(*(const struct version_number **)b));
 }
 
-void
-version_sorting_item_add_piece(VersionSortingItem *vsi, char *str)
+static int
+version_compare_cb_r(const void *a, const void *b)
 {
-    VersionPiece *piece = malloc(sizeof(VersionPiece));
-    if (piece == NULL) {
-        DIE("ERROR: Not enough memory to allocate string linked list node")
-    }
-    piece->str = str;
-    piece->len = strlen(str);
-    piece->next = NULL;
-
-    if (vsi->head == NULL) {
-        vsi->head = piece;
-        vsi->tail = piece;
-    } else {
-        vsi->tail->next = piece;
-        vsi->tail = piece;
-    }
-    vsi->node_len++;
-    if (piece->len > vsi->widest_len) {
-        vsi->widest_len = piece->len;
-    }
+	return -compare_version_number(
+		(*(const struct version_number **)a),
+		(*(const struct version_number **)b));
 }
 
-enum scan_state
-scan_state_get(const char c)
+static struct version_number *
+grow_version_number(struct version_number *version, int new_size)
 {
-    if (isdigit(c)) {
-        return digit;
-    } else if (isalpha(c)) {
-        return alpha;
-    } else {
-        return other;
-    }
+	return xrealloc(version,
+			(sizeof(struct version_number) +
+			 sizeof(union version_comp) * new_size));
+}
 
+static struct version_number *
+parse_version_number(const char *string)
+{
+	struct version_number *version = NULL;
+	uint64_t num_flags = 0x0;
+	uint16_t offset;
+	int comp_n = 0, comp_alloc = 4;
+
+	version = grow_version_number(version, comp_alloc);
+
+	for (offset = 0; string[offset] && comp_n < 64;) {
+		if (comp_n >= comp_alloc) {
+			comp_alloc += 4;
+			version = grow_version_number(version, comp_alloc);
+		}
+
+		if (isdigit(string[offset])) {
+			uint32_t number = 0;
+			uint16_t start = offset;
+			int overflown = 0;
+
+			while (isdigit(string[offset])) {
+				if (!overflown) {
+					uint32_t old_number = number;
+					number = (10 * number) + (string[offset] - '0');
+					if (number < old_number) overflown = 1;
+				}
+
+				offset++;
+			}
+
+			if (overflown) {
+				version->comp[comp_n].string.offset = start;
+				version->comp[comp_n].string.len = offset - start;
+			} else {
+				version->comp[comp_n].number = number;
+				num_flags |= (1 << comp_n);
+			}
+			comp_n++;
+			continue;
+		}
+
+		if (string[offset] == '-' || isalpha(string[offset])) {
+			uint16_t start = offset;
+
+			if (string[offset] == '-')
+				offset++;
+
+			while (isalpha(string[offset]))
+				offset++;
+
+			version->comp[comp_n].string.offset = start;
+			version->comp[comp_n].string.len = offset - start;
+			comp_n++;
+			continue;
+		}
+
+		offset++;
+	}
+
+	version->original = string;
+	version->num_flags = num_flags;
+	version->size = comp_n;
+
+	return version;
 }
 
-void
-parse_version_word(VersionSortingItem *vsi)
+static VALUE
+rb_version_sort_1(VALUE rb_self, VALUE rb_version_array, compare_callback_t cmp)
 {
-    int start = 0, end = 0, size = 0;
-    char current_char, next_char;
-    char *part;
-    enum scan_state current_state, next_state;
+	struct version_number **versions;
+	long length, i;
+	VALUE *rb_version_ptr;
 
-    while ((current_char = vsi->original[start]) != '\0') {
-        current_state = scan_state_get(current_char);
+	Check_Type(rb_version_array, T_ARRAY);
 
-        if (current_state == other) {
-            start++;
-            end = start;
-            continue;
-        }
+	length = RARRAY_LEN(rb_version_array);
+	if (!length)
+		return rb_ary_new();
 
-        do {
-            end++;
-            next_char = vsi->original[end];
-            next_state = scan_state_get(next_char);
-        } while (next_char != '\0' && current_state == next_state);
+	versions = xcalloc(length, sizeof(struct version_number *));
 
-        size = end - start;
+	for (i = 0; i < length; ++i) {
+		VALUE rb_version = rb_ary_entry(rb_version_array, i);
+		versions[i] = parse_version_number(StringValuePtr(rb_version));
+		versions[i]->rb_version = rb_version;
+	}
 
-        part = malloc((size+1) * sizeof(char));
-        if (part == NULL) {
-            DIE("ERROR: Not enough memory to allocate word")
-        }
+	qsort(versions, length, sizeof(struct version_number *), cmp);
+	rb_version_ptr = RARRAY_PTR(rb_version_array);
 
-        memcpy(part, vsi->original+start, size);
-        part[size] = '\0';
+	for (i = 0; i < length; ++i) {
+		rb_version_ptr[i] = versions[i]->rb_version;
+		xfree(versions[i]);
+	}
+	xfree(versions);
+	return rb_version_array;
+}
 
-        version_sorting_item_add_piece(vsi, part);
+static VALUE
+rb_version_sort(VALUE rb_self, VALUE rb_versions)
+{
+	return rb_version_sort_1(rb_self, rb_ary_dup(rb_versions), version_compare_cb);
+}
 
-        start = end;
-    }
+static VALUE
+rb_version_sort_r(VALUE rb_self, VALUE rb_versions)
+{
+	return rb_version_sort_1(rb_self, rb_ary_dup(rb_versions), version_compare_cb_r);
 }
 
-void
-create_normalized_version(VersionSortingItem *vsi, const int widest_len)
+static VALUE
+rb_version_sort_bang(VALUE rb_self, VALUE rb_versions)
 {
-    VersionPiece *cur;
-    int pos, i;
-
-    char *result = malloc(((vsi->node_len * widest_len) + 1) * sizeof(char));
-    if (result == NULL) {
-        DIE("ERROR: Unable to allocate memory")
-    }
-    result[0] = '\0';
-    pos = 0;
-
-    for (cur = vsi->head; cur; cur = cur->next) {
-
-        /* Left-Pad digits with a space */
-        if (cur->len < widest_len && isdigit(cur->str[0])) {
-            for (i = 0; i < widest_len - cur->len; i++) {
-                result[pos] = ' ';
-                pos++;
-            }
-            result[pos] = '\0';
-        }
-        strcat(result, cur->str);
-        pos += cur->len;
-
-        /* Right-Pad words with a space */
-        if (cur->len < widest_len && isalpha(cur->str[0])) {
-            for (i = 0; i < widest_len - cur->len; i++) {
-                result[pos] = ' ';
-                pos++;
-            }
-            result[pos] = '\0';
-        }
-    }
-    vsi->normalized = result;
-    vsi->widest_len = widest_len;
+	return rb_version_sort_1(rb_self, rb_versions, version_compare_cb);
 }
 
-int
-compare_by_version(const void *a, const void *b)
+static VALUE
+rb_version_sort_r_bang(VALUE rb_self, VALUE rb_versions)
 {
-    return strcmp((*(const VersionSortingItem **)a)->normalized, (*(const VersionSortingItem **)b)->normalized);
+	return rb_version_sort_1(rb_self, rb_versions, version_compare_cb_r);
 }
 
-int*
-version_sorter_sort(char **list, size_t list_len)
+void Init_version_sorter(void)
 {
-    int i, widest_len = 0;
-    VersionSortingItem *vsi;
-    VersionSortingItem **sorting_list = calloc(list_len, sizeof(VersionSortingItem *));
-    int *ordering = calloc(list_len, sizeof(int));
-
-    for (i = 0; i < list_len; i++) {
-        vsi = version_sorting_item_init(list[i], i);
-        if (vsi->widest_len > widest_len) {
-            widest_len = vsi->widest_len;
-        }
-        sorting_list[i] = vsi;
-    }
-
-    for (i = 0; i < list_len; i++) {
-        create_normalized_version(sorting_list[i], widest_len);
-    }
-
-    qsort((void *) sorting_list, list_len, sizeof(VersionSortingItem *), &compare_by_version);
-
-    for (i = 0; i < list_len; i++) {
-        vsi = sorting_list[i];
-        list[i] = (char *) vsi->original;
-        ordering[i] = vsi->original_idx;
-        version_sorting_item_free(vsi);
-    }
-    free(sorting_list);
-
-    return ordering;
+	VALUE rb_mVersionSorter = rb_define_module("VersionSorter");
+	rb_define_module_function(rb_mVersionSorter, "sort", rb_version_sort, 1);
+	rb_define_module_function(rb_mVersionSorter, "rsort", rb_version_sort_r, 1);
+	rb_define_module_function(rb_mVersionSorter, "sort!", rb_version_sort_bang, 1);
+	rb_define_module_function(rb_mVersionSorter, "rsort!", rb_version_sort_r_bang, 1);
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: version_sorter
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Chris Wanstrath
@@ -9,42 +9,27 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-18 00:00:00.000000000 Z
+date: 2015-02-19 00:00:00.000000000 Z
 dependencies: []
-description: Fast sorting of version strings
+description: VersionSorter is a C extension that does fast sorting of large sets of
+  version strings.
 email: chris@ozmm.org
 executables: []
 extensions:
 - ext/version_sorter/extconf.rb
-extra_rdoc_files:
-- README.markdown
+extra_rdoc_files: []
 files:
-- ".gitattributes"
-- README.markdown
-- Rakefile
+- LICENSE
 - ext/version_sorter/extconf.rb
-- ext/version_sorter/frameworks/cmockery.framework/Versions/A/Headers/cmockery.h
-- ext/version_sorter/frameworks/cmockery.framework/Versions/A/Resources/English.lproj/InfoPlist.strings
-- ext/version_sorter/frameworks/cmockery.framework/Versions/A/Resources/Info.plist
-- ext/version_sorter/frameworks/cmockery.framework/Versions/A/cmockery
-- ext/version_sorter/frameworks/cmockery.framework/cmockery
-- ext/version_sorter/rb_version_sorter.c
-- ext/version_sorter/test/main.c
 - ext/version_sorter/version_sorter.c
-- ext/version_sorter/version_sorter.h
-- ext/version_sorter/version_sorter.xcodeproj/project.pbxproj
-- lib/version_sorter/version.rb
-- test/tags.rb
-- test/tags.txt
-- test/version_sorter_test.rb
-homepage: http://github.com/defunkt/version_sorter
-licenses: []
+homepage: https://github.com/defunkt/version_sorter
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
-- ext
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="