ninjudd-tuple 0.0.7 → 0.0.10

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Justin Balthrop
+
+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/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 0
-:patch: 7
 :major: 0
+:minor: 0
+:patch: 10

data/ext/tuple.c

@@ -1,8 +1,11 @@
 #include "ruby.h"
 
 VALUE mTuple;
+VALUE rb_cDate;
 
 #define TRUE_SORT  255 // TrueClass
+#define TUPLE_SORT 192 // Array
+#define TUPLE_END  191 // For nested tuples 
 #define TIME_SORT  128 // Time
 #define SYM_SORT    64 // Symbol
 #define STR_SORT    32 // String
@@ -11,8 +14,6 @@ VALUE mTuple;
 #define FALSE_SORT   1 // FalseClass
 #define NIL_SORT     0 // NilClass
 
-#define MAX_INT 0xffffffff
-
 #define BDIGITS(x) ((BDIGIT*)RBIGNUM(x)->digits)
 
 static void null_pad(VALUE data, int len) {
@@ -38,6 +39,7 @@ static VALUE tuple_dump(VALUE self, VALUE tuple) {
   int i, j, len, sign;
   u_int8_t header[4];
   u_int32_t digit;
+  int64_t fixnum;
   BDIGIT *digits;
 
   if (TYPE(tuple) != T_ARRAY) tuple = rb_ary_new4(1, &tuple);
@@ -46,22 +48,32 @@ static VALUE tuple_dump(VALUE self, VALUE tuple) {
     item = RARRAY(tuple)->ptr[i];
     header[0] = header[1] = header[2] = header[3] = 0;
     if (FIXNUM_P(item)) {
-      sign = (digit >= 0);
-      header[2] = (sign ? INTP_SORT : INTN_SORT);
-      header[3] = 0;
+      fixnum = FIX2LONG(item);
+      sign = (fixnum >= 0);
+      if (!sign) fixnum = -fixnum;
+      len = fixnum > UINT_MAX ? 2 : 1;
+      header[2] = sign ? INTP_SORT : INTN_SORT;
+      header[3] = sign ? len : UCHAR_MAX - len;
       rb_str_cat(data, (char*)&header, sizeof(header));
 
-      digit = htonl(FIX2INT(item) + (sign ? 0 : MAX_INT));
-      rb_str_cat(data, (char*)&digit,  sizeof(digit));
+      if (len == 2) {
+        digit = ((u_int32_t *)(&fixnum))[_QUAD_HIGHWORD];
+        digit = htonl(sign ? digit : UINT_MAX - digit);
+        rb_str_cat(data, (char*)&digit, sizeof(digit));
+      }
+      digit = ((u_int32_t *)(&fixnum))[_QUAD_LOWWORD];
+      digit = htonl(sign ? digit : UINT_MAX - digit);
+      rb_str_cat(data, (char*)&digit, sizeof(digit));
     } else if (TYPE(item) == T_BIGNUM) {
       sign = RBIGNUM(item)->sign;
+      len  = RBIGNUM(item)->len;
       header[2] = sign ? INTP_SORT : INTN_SORT;
-      header[3] = RBIGNUM(item)->len;
+      header[3] = sign ? len : UCHAR_MAX - len;
       rb_str_cat(data, (char*)&header, sizeof(header));
 
       digits = BDIGITS(item);
-      for (j = header[3]-1; j >= 0; j--) {
-        digit = htonl(sign ? digits[j] : (MAX_INT - digits[j]));
+      for (j = len-1; j >= 0; j--) {
+        digit = htonl(sign ? digits[j] : (UINT_MAX - digits[j]));
         rb_str_cat(data, (char*)&digit, sizeof(digit));
       }
     } else if (SYMBOL_P(item) || TYPE(item) == T_STRING) {
@@ -76,16 +88,28 @@ static VALUE tuple_dump(VALUE self, VALUE tuple) {
       rb_str_cat(data, RSTRING_PTR(item), len);
       
       null_pad(data, len);
-    } else if (rb_obj_class(item) == rb_cTime) {
+    } else if (rb_obj_class(item) == rb_cTime || rb_obj_class(item) == rb_cDate) {
       header[2] = TIME_SORT;
       rb_str_cat(data, (char*)&header, sizeof(header));
 
-      item = rb_funcall(item, rb_intern("getgm"), 0);
-      item = rb_funcall(item, rb_intern("strftime"), 1, rb_str_new2("%Y/%m/%d %H:%M:%S +0000"));
-      len  = RSTRING_LEN(item);
+      if (rb_obj_class(item) == rb_cTime) {
+        item = rb_funcall(item, rb_intern("getgm"), 0);
+        item = rb_funcall(item, rb_intern("strftime"), 1, rb_str_new2("%Y/%m/%d %H:%M:%S +0000"));
+      } else {
+        item = rb_funcall(item, rb_intern("strftime"), 1, rb_str_new2("%Y/%m/%d"));
+      }
+      len = RSTRING_LEN(item);
       rb_str_cat(data, RSTRING_PTR(item), len);
 
       null_pad(data, len);
+    } else if (TYPE(item) == T_ARRAY) {
+      header[2] = TUPLE_SORT;
+      rb_str_cat(data, (char*)&header, sizeof(header));
+
+      rb_str_concat(data, tuple_dump(mTuple, item));
+
+      header[2] = TUPLE_END;
+      rb_str_cat(data, (char*)&header, sizeof(header));      
     } else {        
       if      (item == Qnil)   header[2] = NIL_SORT;
       else if (item == Qtrue)  header[2] = TRUE_SORT;
@@ -98,19 +122,22 @@ static VALUE tuple_dump(VALUE self, VALUE tuple) {
   return data;
 }
 
-/*
- * call-seq:
- * Tuple.load(string) -> tuple
- *
- * Reads in a previously dumped tuple from a string of binary data.
- *
- */
-static VALUE tuple_load(VALUE self, VALUE data) {
+static VALUE empty_bignum(int sign, int len) {
+  /* Create an empty bignum with the right number of digits. */
+  NEWOBJ(num, struct RBignum);
+  OBJSETUP(num, rb_cBignum, T_BIGNUM);
+  num->sign = sign ? 1 : 0;
+  num->len = len;
+  num->digits = ALLOC_N(BDIGIT, len);
+
+  return (VALUE)num;
+}
+
+static VALUE tuple_parse(void **data, int data_len) {
   VALUE tuple = rb_ary_new();
   VALUE item;
-  data = StringValue(data);
-  void* ptr = RSTRING_PTR(data); 
-  void* end = ptr + RSTRING_LEN(data);
+  void* ptr = *data; *data = &ptr;
+  void* end = ptr + data_len;
   int i, len, sign;
   u_int8_t header[4];
   u_int32_t digit;
@@ -126,58 +153,73 @@ static VALUE tuple_load(VALUE self, VALUE data) {
     case NIL_SORT:   rb_ary_push(tuple, Qnil);   break;
     case INTP_SORT:
     case INTN_SORT:
-      sign = (header[2] == INTP_SORT);
-      if (header[3] == 0) {
-        digit = ntohl(*(u_int32_t*)ptr) - (sign ? 0 : MAX_INT);
+      sign  = (header[2] == INTP_SORT);
+      len   = sign ? header[3] : (UCHAR_MAX - header[3]);
+
+      item = empty_bignum(sign, len);
+      digits = BDIGITS(item);
+      for (i = len-1; i >= 0; i--) {
+        digit = ntohl(*(u_int32_t*)ptr);
+        digits[i] = sign ? digit : UINT_MAX - digit;
         ptr += 4;
-        rb_ary_push(tuple, INT2NUM(digit));
-      } else {
-        // Create an empty bignum with the right number of digits.
-        NEWOBJ(item, struct RBignum);
-        OBJSETUP(item, rb_cBignum, T_BIGNUM);        
-        item->sign = sign ? 1 : 0;
-        item->len = header[3];
-        item->digits = ALLOC_N(BDIGIT, header[3]);
-
-        digits = BDIGITS(item);
-        for (i = header[3]-1; i >= 0; i--) {
-          digit = ntohl(*(u_int32_t*)ptr);
-          digits[i] = sign ? digit : MAX_INT - digit;
-          ptr += 4;
-        }
-        rb_ary_push(tuple, (VALUE)item);
       }
+      rb_ary_push(tuple, item);
       break;
     case STR_SORT:
     case SYM_SORT:
       item = rb_str_new2(ptr);
       len  = RSTRING_LEN(item);
-      while (len % 4 != 0) len++;
-      ptr += len;
       if (header[2] == SYM_SORT) item = rb_funcall(item, rb_intern("to_sym"), 0);
       rb_ary_push(tuple, item);
+      while (len % 4 != 0) len++; ptr += len;
       break;
     case TIME_SORT:
       item = rb_str_new2(ptr);
       len  = RSTRING_LEN(item);
-      while (len % 4 != 0) len++;
-      ptr += len;
-      item = rb_funcall(rb_cTime, rb_intern("parse"), 1, item);
+      if (len == 10) item = rb_funcall(rb_cDate, rb_intern("parse"), 1, item);
+      else           item = rb_funcall(rb_cTime, rb_intern("parse"), 1, item);
       rb_ary_push(tuple, item);
+      while (len % 4 != 0) len++; ptr += len;
       break;
+    case TUPLE_SORT:
+      item = tuple_parse(&ptr, end - ptr);
+      rb_ary_push(tuple, item);
+      break;
+    case TUPLE_END:
+      return tuple;
     default:
       rb_raise(rb_eTypeError, "invalid type code %d in tuple", header[2]);
       break;
     }
-  }  
+  }
   return tuple;
 }
 
+/*
+ * call-seq:
+ * Tuple.load(string) -> tuple
+ *
+ * Reads in a previously dumped tuple from a string of binary data.
+ *
+ */
+static VALUE tuple_load(VALUE self, VALUE data) {
+  data = StringValue(data);
+  void* ptr = RSTRING_PTR(data);
+  return tuple_parse(&ptr, RSTRING_LEN(data));
+}
+
+static VALUE array_compare(VALUE self, VALUE other) {
+  rb_funcall(tuple_dump(mTuple, self), rb_intern("<=>"), 1, tuple_dump(mTuple, other));
+}
+
 VALUE mTuple;
 void Init_tuple() {
   rb_require("time");
+  rb_require("date");
+  rb_cDate = rb_const_get(rb_cObject, rb_intern("Date"));
 
   mTuple = rb_define_module("Tuple");
   rb_define_module_function(mTuple, "dump", tuple_dump, 1);
   rb_define_module_function(mTuple, "load", tuple_load, 1);
+  rb_define_method(rb_cArray, "<=>", array_compare, 1);
 }

data/test/tuple_test.rb

@@ -9,14 +9,15 @@ end
 
 class TupleTest < Test::Unit::TestCase
   should "dump and load arrays of simple types" do
-    t = [1, true, :foo, "foo", -1001, false, nil, Time.now]
+    t = [1, true, :foo, "foo", -1001, false, nil, Time.now, Date.today - 7, [:foo, 1, 4, nil]]
     assert_equal t, Tuple.load(Tuple.dump(t))
   end
   
-  should "dump and load fixnums and bignums" do
-    t = [2**64, 2**32, 2**32 - 1, 2**31, 2**31 - 1, 1, 0]
-    t = t + t.collect {|n| -n}
+  should "dump, load, and sort fixnums and bignums" do
+    t = [2**64, 2**38, 2**32, 2**32 - 1, 2**31, 2**31 - 1, 1, 0]
+    t = t + t.reverse.collect {|n| -n}
     assert_equal t, Tuple.load(Tuple.dump(t))
+    assert_equal t.reverse, t.sort_by {|i| Tuple.dump(i)}
   end
 
   should "convert single value into array" do
@@ -24,7 +25,8 @@ class TupleTest < Test::Unit::TestCase
   end
 
   should "sort tuples using binary" do
-    now = Time.now
+    now   = Time.now.getgm
+    today = Date.parse(now.to_s)
 
     tuples = [
       [1, "foo"],
@@ -47,6 +49,9 @@ class TupleTest < Test::Unit::TestCase
       [now, "foo"],
       [now, "bar"],
       [now - 24 * 60 * 60],
+      [today + 1],
+      [today - 1],
+      [today],
     ]
 
     expected = [
@@ -66,11 +71,14 @@ class TupleTest < Test::Unit::TestCase
       [:foo, -18446744073709551616],
       [:foo, -1],
       [:foo, 18446744073709551616],
+      [today - 1],
       [now - 24 * 60 * 60],
+      [today],
       [now, "bar"],
       [now, "foo"],
+      [today + 1],
       [true]
-    ]  
+    ]
     assert_equal expected, tuples.sort_by {|t| Tuple.dump(t)}
 
     100.times do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ninjudd-tuple
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.10
 platform: ruby
 authors: 
 - Justin Balthrop
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-22 00:00:00 -07:00
+date: 2009-09-21 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -19,21 +19,22 @@ executables: []
 
 extensions: 
 - ext/extconf.rb
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
 files: 
 - README.rdoc
 - VERSION.yml
-- ext/tuple.c
 - ext/extconf.rb
+- ext/tuple.c
 - test/test_helper.rb
 - test/tuple_test.rb
-has_rdoc: true
+- LICENSE
+has_rdoc: false
 homepage: http://github.com/ninjudd/tuple
 licenses: 
 post_install_message: 
 rdoc_options: 
-- --inline-source
 - --charset=UTF-8
 require_paths: 
 - ext
@@ -54,7 +55,8 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Tuple serialization functions.
-test_files: []
-
+test_files: 
+- test/test_helper.rb
+- test/tuple_test.rb