ninjudd-bdb 0.0.7 → 0.0.8

data/bdb.gemspec

@@ -2,7 +2,7 @@ BDB_SPEC = Gem::Specification.new do |s|
     s.platform  =   Gem::Platform::RUBY
     s.required_ruby_version = '>=1.8.4'
     s.name      =   "bdb"
-    s.version   =   "0.0.7"
+    s.version   =   "0.0.8"
     s.authors   =  ["Matt Bauer", "Dan Janowski"]
     s.email     =  "bauer@pedalbrain.com"
     s.summary   =   "A Ruby interface to BerkeleyDB"

data/ext/bdb.c

@@ -1102,17 +1102,23 @@ void assoc_key(DBT* result, VALUE obj) {
   result->flags=LMEMFLAG;
 }
 
-VALUE
-assoc_callback2(VALUE *args)
+VALUE assoc_call(VALUE *args)
 {
   return rb_funcall(args[0],fv_call,3,args[1],args[2],args[3]);
 }
 
+VALUE assoc_rescue(VALUE *error, VALUE e)
+{
+  VALUE message = StringValue(e);
+  rb_warn(RSTRING_PTR(message));
+  *error = e;
+}
+
 int assoc_callback(DB *secdb, const DBT* key, const DBT* data, DBT* result)
 {
   t_dbh *dbh;
   VALUE proc;
-  int status;
+  VALUE error = Qnil;
   VALUE retv;
   VALUE args[4];
   VALUE keys;
@@ -1130,15 +1136,15 @@ int assoc_callback(DB *secdb, const DBT* key, const DBT* data, DBT* result)
   fprintf(stderr,"assoc_data %*s", data->size, data->data);
 #endif
 
-  retv=rb_protect((VALUE(*)_((VALUE)))assoc_callback2,(VALUE)args,&status);
-
-  if (status) return 99999;
-  if ( NIL_P(retv) )
+  retv=rb_rescue((VALUE(*)_((VALUE)))assoc_call,(VALUE)args,(VALUE(*)_((VALUE)))assoc_rescue,(VALUE)&error);
+  
+  if (!NIL_P(error)) return 99999;
+  if (NIL_P(retv))
     return DB_DONOTINDEX;
 
   keys = rb_check_array_type(retv);
   if (!NIL_P(keys)) {
-      keys = rb_funcall(keys,fv_uniq,0); /* secondary keys must be uniq */
+    keys = rb_funcall(keys,fv_uniq,0); /* secondary keys must be uniq */
     switch(RARRAY(keys)->len) {
     case 0:
       return DB_DONOTINDEX;
@@ -1152,7 +1158,7 @@ int assoc_callback(DB *secdb, const DBT* key, const DBT* data, DBT* result)
       memset(result->data,0,result->size * sizeof(DBT));
     
       for (i=0; i<result->size; i++) {
-          assoc_key(result->data + i*sizeof(DBT), (VALUE)RARRAY(keys)->ptr[i]);
+        assoc_key(result->data + i*sizeof(DBT), (VALUE)RARRAY(keys)->ptr[i]);
       }
       return 0;
     }

data/ext/extconf.rb

@@ -35,7 +35,7 @@ Then try building again.
 	end
 end
 
-versions=%w(db-4.7 db-4.6 db-4.5 db-4.4 db-4.3 db-4.2)
+versions=%w(db-4.8 db-4.7 db-4.6 db-4.5 db-4.4 db-4.3 db-4.2)
 until versions.empty?
   (lib_ok = have_library(versions.shift,'db_version', 'db.h')) && break
 end

data/lib/bdb/simple.rb

@@ -68,37 +68,49 @@ class Bdb::Simple
     @db = nil
   end
 
+  CLASS_ORDER = {}
+  [FalseClass, TrueClass, Fixnum, Numeric, Float, Symbol, String, Array].each_with_index {|c, i| CLASS_ORDER[c] = i}
+
   def self.compare_absolute(left, right)
-    if left.class == right.class
-      if left.is_a?(Array) and right.is_a?(Array)
+    if left.is_a?(right.class)
+      case left
+      when Array
         # Arrays: compare one element at a time.
-        left.zip(right) do |l,r|
-          comp = compare_absolute(l, r)
-          return comp unless comp == 0
+        n = [left.size, right.size].min
+        n.times do |i|
+          comp = compare_absolute(left[i], right[i])
+          return comp if comp != 0
         end
-        left.size == right.size ? 0 : -1
-      elsif left.is_a?(Hash) and right.is_a?(Hash)
-        # Hashes: sort the keys and compare as an array of arrays.
+        left.size <=> right.size
+      when Hash
+        # Hashes: sort the keys and compare as an array of arrays. This may be slow.
         left  = left.to_a.sort  {|a,b| compare_absolute(a[0],b[0])}
         right = right.to_a.sort {|a,b| compare_absolute(a[0],b[0])}
         compare_absolute(left, right)
+      when NilClass, TrueClass, FalseClass
+        0
+      when Symbol
+        left.to_s <=> right.to_s
       else
-        begin
-          # Try to use the spaceship operator.
-          left <=> right
-        rescue NoMethodError => e
-          left.hash <=> right.hash
-        end
-      end
+        # Use the spaceship operator.
+        left <=> right
+      end    
+    elsif left.kind_of?(Numeric) and right.kind_of?(Numeric)
+      # Numerics are always comparable.
+      left <=> right
     else
-      # Nil is the smallest. Hash is the largest. All other objects are sorted by class name.
-      return -1 if left.is_a?(NilClass)
-      return  1 if right.is_a?(NilClass)
-      return  1 if left.is_a?(Hash)
-      return -1 if right.is_a?(Hash)
+      # Nil is the smallest. Hash is the largest.
+      return -1 if left.is_a?(NilClass) or right.is_a?(Hash)
+      return  1 if left.is_a?(Hash)     or right.is_a?(NilClass)
       
-      # Compare class names and hashes as a last resort if that fails.
-      right.class.name <=> left.class.name
+      # Try to use the class sort order so we don't have to do a string comparison.
+      left_order  = CLASS_ORDER[left.class]
+      right_order = CLASS_ORDER[right.class]
+      if left_order.nil? and right_order.nil?
+        left.class.name <=> right.class.name
+      else
+        (left_order || 9999) <=> (right_order || 9999)
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ninjudd-bdb
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors: 
 - Matt Bauer