do_sqlite3 0.9.12 → 0.10.0

data/{History.txt → HISTORY.markdown}

@@ -1,10 +1,18 @@
-== 0.9.11 2009-01-19
+## 0.10.0 2009-10-15
+* Improvements
+  * JRuby Support (using *do_jdbc*)
+
+## 0.9.12 2009-05-17
+* Improvements
+  * rake-compiler for Windows support
+
+## 0.9.11 2009-01-19
 * Improvements
   * Ruby 1.9 support
 * Fixes
   * Fix Windows gem
 
-== 0.9.9 2008-11-27
+## 0.9.9 2008-11-27
 * Improvements
   * Added cross compile rake tasks for Windows gems [Jonathan Stott, Luis Lavena]
   * Added initial support for Ruby 1.9 [John Harrison]

data/Manifest.txt

@@ -1,8 +1,8 @@
 .gitignore
-History.txt
+HISTORY.markdown
 LICENSE
 Manifest.txt
-README.txt
+README.markdown
 Rakefile
 buildfile
 ext-java/src/main/java/DoSqlite3ExtService.java

data/{README.txt → README.markdown}

@@ -1,3 +1,4 @@
-= do_sqlite3
+do_sqlite3
+==========
 
 A DataObjects driver for SQLite3

data/Rakefile

@@ -8,9 +8,9 @@ require 'lib/do_sqlite3/version'
 ROOT    = Pathname(__FILE__).dirname.expand_path
 JRUBY   = RUBY_PLATFORM =~ /java/
 WINDOWS = Gem.win_platform?
-SUDO    = (WINDOWS || JRUBY) ? '' : ('sudo' unless ENV['SUDOLESS'])
+SUDO    = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
 BINARY_VERSION = '3_6_13'
 
-Dir['tasks/*.rake'].each { |f| import f }
+Dir['tasks/*.rake'].sort.each { |f| import f }
 
 CLEAN.include(%w[ {tmp,pkg}/ **/*.{o,so,bundle,jar,log,a,gem,dSYM,obj,pdb,exp,DS_Store,rbc,db} ext/do_sqlite3_ext/Makefile ext-java/target ])

data/ext/do_sqlite3_ext/do_sqlite3_ext.c

@@ -4,6 +4,38 @@
 #include <time.h>
 #include <locale.h>
 #include <sqlite3.h>
+#include "error.h"
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+
+#define DO_STR_NEW2(str, encoding) \
+  ({ \
+    VALUE _string = rb_str_new2((const char *)str); \
+    if(encoding != -1) { \
+      rb_enc_associate_index(_string, encoding); \
+    } \
+    _string; \
+  })
+
+#define DO_STR_NEW(str, len, encoding) \
+  ({ \
+    VALUE _string = rb_str_new((const char *)str, (long)len); \
+    if(encoding != -1) { \
+      rb_enc_associate_index(_string, encoding); \
+    } \
+    _string; \
+  })
+
+#else
+
+#define DO_STR_NEW2(str, encoding) \
+  rb_str_new2((const char *)str)
+
+#define DO_STR_NEW(str, len, encoding) \
+  rb_str_new((const char *)str, (long)len)
+#endif
+
 
 #define ID_CONST_GET rb_intern("const_get")
 #define ID_PATH rb_intern("path")
@@ -12,8 +44,6 @@
 #define ID_QUERY rb_intern("query")
 
 #define RUBY_CLASS(name) rb_const_get(rb_cObject, rb_intern(name))
-#define RUBY_STRING(char_ptr) rb_str_new2(char_ptr)
-#define TAINTED_STRING(name, length) rb_tainted_str_new(name, length)
 #define CONST_GET(scope, constant) (rb_funcall(scope, ID_CONST_GET, 1, rb_str_new2(constant)))
 #define SQLITE3_CLASS(klass, parent) (rb_define_class_under(mSqlite3, klass, parent))
 
@@ -69,7 +99,8 @@ static VALUE cResult;
 static VALUE cReader;
 
 static VALUE eArgumentError;
-static VALUE eSqlite3Error;
+static VALUE eConnectionError;
+static VALUE eDataError;
 
 static VALUE OPEN_FLAG_READONLY;
 static VALUE OPEN_FLAG_READWRITE;
@@ -126,6 +157,32 @@ static void data_objects_debug(VALUE string, struct timeval* start) {
   }
 }
 
+static void raise_error(VALUE self, sqlite3 *result, VALUE query) {
+  VALUE exception;
+  const char *message = sqlite3_errmsg(result);
+  const char *exception_type = "SQLError";
+  int sqlite3_errno = sqlite3_errcode(result);
+
+  struct errcodes *errs;
+
+  for (errs = errors; errs->error_name; errs++) {
+    if(errs->error_no == sqlite3_errno) {
+      exception_type = errs->exception;
+      break;
+    }
+  }
+
+
+  VALUE uri = rb_funcall(rb_iv_get(self, "@connection"), rb_intern("to_s"), 0);
+
+  exception = rb_funcall(CONST_GET(mDO, exception_type), ID_NEW, 5,
+                         rb_str_new2(message),
+                         INT2NUM(sqlite3_errno),
+                         rb_str_new2(""),
+                         query,
+                         uri);
+  rb_exc_raise(exception);
+}
 
 static VALUE parse_date(char *date) {
   int year, month, day;
@@ -200,7 +257,7 @@ static VALUE parse_date_time(char *date) {
       hour_offset = 0;
       minute_offset = 0;
       sec = 0;
-    }  
+    }
     // We read the Date and Time, default to the current locale's offset
 
     // Get localtime
@@ -222,7 +279,7 @@ static VALUE parse_date_time(char *date) {
 
   } else {
     // Something went terribly wrong
-    rb_raise(eSqlite3Error, "Couldn't parse date: %s", date);
+    rb_raise(eDataError, "Couldn't parse date: %s", date);
   }
 
   jd = jd_from_date(year, month, day);
@@ -278,7 +335,7 @@ static VALUE parse_time(char *date) {
   return rb_funcall(rb_cTime, rb_intern("local"), 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
 }
 
-static VALUE typecast(sqlite3_stmt *stmt, int i, VALUE type) {
+static VALUE typecast(sqlite3_stmt *stmt, int i, VALUE type, int encoding) {
   VALUE ruby_value = Qnil;
   int original_type = sqlite3_column_type(stmt, i);
   int length        = sqlite3_column_bytes(stmt, i);
@@ -310,11 +367,11 @@ static VALUE typecast(sqlite3_stmt *stmt, int i, VALUE type) {
   if (type == rb_cInteger) {
     return LL2NUM(sqlite3_column_int64(stmt, i));
   } else if (type == rb_cString) {
-    return TAINTED_STRING((char*)sqlite3_column_text(stmt, i), length);
+    return DO_STR_NEW((char*)sqlite3_column_text(stmt, i), length, encoding);
   } else if (type == rb_cFloat) {
     return rb_float_new(sqlite3_column_double(stmt, i));
   } else if (type == rb_cBigDecimal) {
-    return rb_funcall(rb_cBigDecimal, ID_NEW, 1, TAINTED_STRING((char*)sqlite3_column_text(stmt, i), length));
+    return rb_funcall(rb_cBigDecimal, ID_NEW, 1, rb_str_new((char*)sqlite3_column_text(stmt, i), length));
   } else if (type == rb_cDate) {
     return parse_date((char*)sqlite3_column_text(stmt, i));
   } else if (type == rb_cDateTime) {
@@ -324,15 +381,15 @@ static VALUE typecast(sqlite3_stmt *stmt, int i, VALUE type) {
   } else if (type == rb_cTrueClass) {
     return strcmp((char*)sqlite3_column_text(stmt, i), "t") == 0 ? Qtrue : Qfalse;
   } else if (type == rb_cByteArray) {
-    return rb_funcall(rb_cByteArray, ID_NEW, 1, TAINTED_STRING((char*)sqlite3_column_blob(stmt, i), length));
+    return rb_funcall(rb_cByteArray, ID_NEW, 1, rb_str_new((char*)sqlite3_column_blob(stmt, i), length));
   } else if (type == rb_cClass) {
-    return rb_funcall(rb_cObject, rb_intern("full_const_get"), 1, TAINTED_STRING((char*)sqlite3_column_text(stmt, i), length));
+    return rb_funcall(rb_cObject, rb_intern("full_const_get"), 1, rb_str_new((char*)sqlite3_column_text(stmt, i), length));
   } else if (type == rb_cObject) {
     return rb_marshal_load(rb_str_new((char*)sqlite3_column_text(stmt, i), length));
   } else if (type == rb_cNilClass) {
     return Qnil;
   } else {
-    return TAINTED_STRING((char*)sqlite3_column_text(stmt, i), length);
+    return DO_STR_NEW((char*)sqlite3_column_text(stmt, i), length, encoding);
   }
 }
 
@@ -390,11 +447,16 @@ static VALUE cConnection_initialize(VALUE self, VALUE uri) {
 #endif
 
   if ( ret != SQLITE_OK ) {
-    rb_raise(eSqlite3Error, sqlite3_errmsg(db));
+    raise_error(self, db, Qnil);
   }
 
   rb_iv_set(self, "@uri", uri);
   rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));
+  // Sqlite3 only supports UTF-8, so this is the standard encoding
+  rb_iv_set(self, "@encoding", rb_str_new2("UTF-8"));
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index("UTF-8")));
+#endif
 
   return Qtrue;
 }
@@ -453,7 +515,7 @@ static VALUE cCommand_set_types(int argc, VALUE *argv, VALUE self) {
 }
 
 static VALUE cConnection_quote_boolean(VALUE self, VALUE value) {
-  return rb_tainted_str_new2(value == Qtrue ? "'t'" : "'f'");
+  return rb_str_new2(value == Qtrue ? "'t'" : "'f'");
 }
 
 static VALUE cConnection_quote_string(VALUE self, VALUE string) {
@@ -464,7 +526,10 @@ static VALUE cConnection_quote_string(VALUE self, VALUE string) {
   // Wrap the escaped string in single-quotes, this is DO's convention
   escaped_with_quotes = sqlite3_mprintf("%Q", source);
 
-  result = rb_tainted_str_new2(escaped_with_quotes);
+  result = rb_str_new2(escaped_with_quotes);
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_enc_associate_index(result, FIX2INT(rb_iv_get(self, "@encoding_id")));
+#endif
   sqlite3_free(escaped_with_quotes);
   return result;
 }
@@ -499,7 +564,7 @@ static VALUE cCommand_execute_non_query(int argc, VALUE *argv, VALUE self) {
   status = sqlite3_exec(db, StringValuePtr(query), 0, 0, &error_message);
 
   if ( status != SQLITE_OK ) {
-    rb_raise(eSqlite3Error, "%s\nQuery: %s", sqlite3_errmsg(db), StringValuePtr(query));
+    raise_error(self, db, query);
   }
   data_objects_debug(query, &start);
 
@@ -531,7 +596,7 @@ static VALUE cCommand_execute_reader(int argc, VALUE *argv, VALUE self) {
   data_objects_debug(query, &start);
 
   if ( status != SQLITE_OK ) {
-    rb_raise(eSqlite3Error, "%s\nQuery: %s", sqlite3_errmsg(db), StringValuePtr(query));
+    raise_error(self, db, query);
   }
 
   field_count = sqlite3_column_count(sqlite3_reader);
@@ -603,9 +668,18 @@ static VALUE cReader_next(VALUE self) {
     return Qfalse;
   }
 
+  int enc = -1;
+#ifdef HAVE_RUBY_ENCODING_H
+  VALUE encoding_id = rb_iv_get(rb_iv_get(self, "@connection"), "@encoding_id");
+  if (encoding_id != Qnil) {
+    enc = FIX2INT(encoding_id);
+  }
+#endif
+
+
   for ( i = 0; i < field_count; i++ ) {
     field_type = rb_ary_entry(field_types, i);
-    value = typecast(reader, i, field_type);
+    value = typecast(reader, i, field_type, enc);
     rb_ary_push(arr, value);
   }
 
@@ -617,7 +691,7 @@ static VALUE cReader_next(VALUE self) {
 static VALUE cReader_values(VALUE self) {
   VALUE state = rb_iv_get(self, "@state");
   if ( state == Qnil || NUM2INT(state) != SQLITE_ROW ) {
-    rb_raise(eSqlite3Error, "Reader is not initialized");
+    rb_raise(eDataError, "Reader is not initialized");
     return Qnil;
   }
   else {
@@ -670,7 +744,8 @@ void Init_do_sqlite3_ext() {
   mSqlite3 = rb_define_module_under(mDO, "Sqlite3");
 
   eArgumentError = CONST_GET(rb_mKernel, "ArgumentError");
-  eSqlite3Error = rb_define_class("Sqlite3Error", rb_eStandardError);
+  eConnectionError = CONST_GET(mDO, "ConnectionError");
+  eDataError = CONST_GET(mDO, "DataError");
 
   cConnection = SQLITE3_CLASS("Connection", cDO_Connection);
   rb_define_method(cConnection, "initialize", cConnection_initialize, 1);

data/ext/do_sqlite3_ext/error.h

@@ -0,0 +1,106 @@
+static struct errcodes {
+  int  error_no;
+  const char *error_name;
+  const char *exception;
+} errors [] = {
+#ifdef SQLITE_ERROR
+  {    SQLITE_ERROR,
+      "SQLITE_ERROR", "SyntaxError"},
+#endif
+#ifdef SQLITE_INTERNAL
+  {    SQLITE_INTERNAL,
+      "SQLITE_INTERNAL", "SQLError"},
+#endif
+#ifdef SQLITE_PERM
+  {    SQLITE_PERM,
+      "SQLITE_PERM", "ConnectionError"},
+#endif
+#ifdef SQLITE_ABORT
+  {    SQLITE_ABORT,
+      "SQLITE_ABORT", "ConnectionError"},
+#endif
+#ifdef SQLITE_BUSY
+  {    SQLITE_BUSY,
+      "SQLITE_BUSY", "ConnectionError"},
+#endif
+
+#ifdef SQLITE_LOCKED
+  {    SQLITE_LOCKED,
+      "SQLITE_LOCKED", "ConnectionError"},
+#endif
+#ifdef SQLITE_NOMEM
+  {    SQLITE_NOMEM,
+      "SQLITE_NOMEM", "ConnectionError"},
+#endif
+#ifdef SQLITE_READONLY
+  {    SQLITE_READONLY,
+      "SQLITE_READONLY", "ConnectionError"},
+#endif
+#ifdef SQLITE_INTERRUPT
+  {    SQLITE_INTERRUPT,
+      "SQLITE_INTERRUPT", "ConnectionError"},
+#endif
+#ifdef SQLITE_IOERR
+  {    SQLITE_IOERR,
+      "SQLITE_IOERR", "ConnectionError"},
+#endif
+#ifdef SQLITE_CORRUPT
+  {    SQLITE_CORRUPT,
+      "SQLITE_CORRUPT", "ConnectionError"},
+#endif
+#ifdef SQLITE_FULL
+  {    SQLITE_FULL,
+      "SQLITE_FULL", "ConnectionError"},
+#endif
+#ifdef SQLITE_CANTOPEN
+  {    SQLITE_CANTOPEN,
+      "SQLITE_CANTOPEN", "ConnectionError"},
+#endif
+#ifdef SQLITE_EMPTY
+  {    SQLITE_EMPTY,
+      "SQLITE_EMPTY", "ConnectionError"},
+#endif
+#ifdef SQLITE_SCHEMA
+  {    SQLITE_SCHEMA,
+      "SQLITE_SCHEMA", "DataError"},
+#endif
+#ifdef SQLITE_TOOBIG
+  {    SQLITE_TOOBIG,
+      "SQLITE_TOOBIG", "DataError"},
+#endif
+#ifdef SQLITE_MISMATCH
+  {    SQLITE_MISMATCH,
+      "SQLITE_MISMATCH", "DataError"},
+#endif
+#ifdef SQLITE_CONSTRAINT
+  {    SQLITE_CONSTRAINT,
+      "SQLITE_CONSTRAINT", "IntegrityError"},
+#endif
+#ifdef SQLITE_MISUSE
+  {    SQLITE_MISUSE,
+      "SQLITE_MISUSE", "SQLError"},
+#endif
+
+#ifdef SQLITE_NOLFS
+  {    SQLITE_NOLFS,
+      "SQLITE_NOLFS", "ConnectionError"},
+#endif
+#ifdef SQLITE_FORMAT
+  {    SQLITE_FORMAT,
+      "SQLITE_FORMAT", "SyntaxError"},
+#endif
+#ifdef SQLITE_RANGE
+  {    SQLITE_RANGE,
+      "SQLITE_RANGE", "DataError"},
+#endif
+#ifdef SQLITE_NOTADB
+  {    SQLITE_NOTADB,
+      "SQLITE_NOTADB", "ConnectionError"},
+#endif
+
+#ifdef SQLITE_ROW
+  {    SQLITE_ROW,
+      "SQLITE_ROW", "SyntaxError"},
+#endif
+  {0, NULL, NULL}
+};

data/ext/do_sqlite3_ext/extconf.rb

@@ -1,21 +1,4 @@
-# ENV["RC_ARCHS"] = `uname -m`.chomp if `uname -sr` =~ /^Darwin/
-#
-# require 'mkmf'
-#
-# SWIG_WRAP = "sqlite3_api_wrap.c"
-#
-# dir_config( "sqlite3", "/usr/local" )
-#
-# if have_header( "sqlite3.h" ) && have_library( "sqlite3", "sqlite3_open" )
-#   create_makefile( "sqlite3_c" )
-# end
-
-if RUBY_PLATFORM =~ /darwin/
-  ENV["RC_ARCHS"] = `uname -m`.chomp if `uname -sr` =~ /^Darwin/
-
-  # On PowerPC the defaults are fine
-  ENV["RC_ARCHS"] = '' if `uname -m` =~ /^Power Macintosh/
-end
+ENV["RC_ARCHS"] = "" if RUBY_PLATFORM =~ /darwin/
 
 # Loads mkmf which is used to make makefiles for Ruby extensions
 require 'mkmf'
@@ -23,7 +6,8 @@ require 'mkmf'
 # Give it a name
 extension_name = 'do_sqlite3_ext'
 
-dir_config("sqlite3")
+# Use some default search paths
+dir_config("sqlite3", ["/usr/local", "/opt/local", "/usr"])
 
 # NOTE: use GCC flags unless Visual C compiler is used
 $CFLAGS << ' -Wall ' unless RUBY_PLATFORM =~ /mswin/

data/lib/do_sqlite3.rb

@@ -1,35 +1,36 @@
-# HACK: If running on Windows, then add the current directory to the PATH
-# for the current process so it can find the bundled dlls before the require
-# of the actual extension file.
-if RUBY_PLATFORM.match(/mingw|mswin/i)
-  libdir = File.expand_path(File.dirname(__FILE__)).gsub(File::SEPARATOR, File::ALT_SEPARATOR)
-  ENV['PATH'] = "#{libdir};" + ENV['PATH']
-end
-
-require 'rubygems'
 require 'data_objects'
 if RUBY_PLATFORM =~ /java/
   require 'do_jdbc'
   require 'java'
-  gem 'jdbc-sqlite3'
-  require 'jdbc/sqlite3' # the JDBC driver, packaged as a gem
+
+  driver =  'org.sqlite.JDBC'
+  begin
+    java.lang.Thread.currentThread.getContextClassLoader().loadClass(driver, true)
+  rescue
+    require 'jdbc/sqlite3' # the JDBC driver, packaged as a gem
+  end
+
+  # Another way of loading the JDBC Class. This seems to be more reliable
+  # than Class.forName() or
+  # Thread.currentThread.getContextClassLoader().loadClass() within the
+  # data_objects.Connection Java class, which is currently not working as
+  # expected.
+  java_import driver
 end
 
 require 'do_sqlite3_ext'
-require File.expand_path(File.join(File.dirname(__FILE__), 'do_sqlite3', 'version'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'do_sqlite3', 'transaction'))
+require 'do_sqlite3/version'
+require 'do_sqlite3/transaction'
 
 if RUBY_PLATFORM =~ /java/
-  # Another way of loading the JDBC Class. This seems to be more reliable
-  # than Class.forName() within the data_objects.Connection Java class,
-  # which is currently not working as expected.
-  import 'org.sqlite.JDBC'
 
   module DataObjects
     module Sqlite3
       class Connection
         def self.pool_size
-          20
+          # sqlite3 can have only one write access at a time, with this
+          # concurrent write access will result in "Database locked" errors
+          1
         end
       end
     end

data/lib/do_sqlite3/transaction.rb

@@ -5,28 +5,20 @@ module DataObjects
 
     class Transaction < DataObjects::Transaction
 
-      def begin
-        cmd = "BEGIN"
-        connection.create_command(cmd).execute_non_query
+      def begin_prepared
+        raise NotImplementedError
       end
 
-      def commit
-        cmd = "COMMIT"
-        connection.create_command(cmd).execute_non_query
-      end
-
-      def rollback
-        cmd = "ROLLBACK"
-        connection.create_command(cmd).execute_non_query
+      def commit_prepared
+        raise NotImplementedError
       end
 
       def rollback_prepared
-        cmd = "ROLLBACK"
-        connection.create_command(cmd).execute_non_query
+        raise NotImplementedError
       end
 
       def prepare
-        # Eek, I don't know how to do this. Lets hope a commit arrives soon...
+        raise NotImplementedError
       end
 
     end

data/lib/do_sqlite3/version.rb

@@ -1,5 +1,5 @@
 module DataObjects
   module Sqlite3
-    VERSION = "0.9.12"
+    VERSION = "0.10.0"
   end
 end

data/spec/result_spec.rb

@@ -3,7 +3,17 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 require 'data_objects/spec/result_spec'
 
+# splitting the descibe into two separate declaration avoids
+# concurrent execution of the "it_should_behave_like ....." calls
+# which would lock the database
+
+# TODO
+# the locked database created a deadlock which is worth exploring since
+# such situation could appear in the wild too
 describe DataObjects::Sqlite3::Result do
   it_should_behave_like 'a Result'
+end
+
+describe DataObjects::Sqlite3::Result do
   it_should_behave_like 'a Result which returns inserted keys'
 end

data/spec/spec_helper.rb

@@ -11,21 +11,24 @@ require 'ostruct'
 require 'pathname'
 require 'fileutils'
 
+dir = File.dirname(__FILE__)
+lib_path = File.expand_path("#{dir}/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
 # put data_objects from repository in the load path
 # DO NOT USE installed gem of data_objects!
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data_objects', 'lib'))
-require 'data_objects'
-
-DATAOBJECTS_SPEC_ROOT = Pathname(__FILE__).dirname.parent.parent + 'data_objects' + 'spec'
-Pathname.glob((DATAOBJECTS_SPEC_ROOT + 'lib/**/*.rb').to_s).each { |f| require f }
+do_lib_path = File.expand_path("#{dir}/../../data_objects/lib")
+$LOAD_PATH.unshift do_lib_path unless $LOAD_PATH.include?(do_lib_path)
 
 if JRUBY
-  $:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'do_jdbc', 'lib'))
+  jdbc_lib_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'do_jdbc', 'lib'))
+  $LOAD_PATH.unshift jdbc_lib_path unless $LOAD_PATH.include?(jdbc_lib_path)
   require 'do_jdbc'
 end
 
-# put the pre-compiled extension in the path to be found
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'data_objects'
+
+DATAOBJECTS_SPEC_ROOT = Pathname(__FILE__).dirname.parent.parent + 'data_objects' + 'spec'
+Pathname.glob((DATAOBJECTS_SPEC_ROOT + 'lib/**/*.rb').to_s).each { |f| require f }
 require 'do_sqlite3'
 
 log_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'log', 'do.log'))
@@ -79,6 +82,8 @@ module DataObjectsSpecHelpers
       );
     EOF
 
+    local_offset = Rational(Time.local(2008, 2, 14).utc_offset, 86400)
+    t = DateTime.civil(2008, 2, 14, 00, 31, 12, local_offset)
     conn.create_command(<<-EOF).execute_non_query
       CREATE TABLE "widgets" (
         "id" INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -91,7 +96,7 @@ module DataObjectsSpecHelpers
         "ad_image" blob NULL,
         "whitepaper_text" text NULL,
         "cad_drawing" blob,
-        "flags" char default 'f',
+        "flags" boolean default 'f',
         "number_in_stock" smallint default 500,
         "number_sold" integer default 0,
         "super_number" bigint default 9223372036854775807,
@@ -99,7 +104,7 @@ module DataObjectsSpecHelpers
         "cost1" double precision default 10.23,
         "cost2" decimal(8,2) default 50.23,
         "release_date" date default '2008-02-14',
-        "release_datetime" timestamp default '2008-02-14T00:31:12+00:00',
+        "release_datetime" timestamp default '#{t.to_s}',
         "release_timestamp" timestamp with time zone default '2008-02-14 00:31:31'
       );
     EOF
@@ -118,6 +123,30 @@ module DataObjectsSpecHelpers
       update widgets set ad_description = NULL where id = 3
     EOF
 
+    conn.create_command(<<-EOF).execute_non_query
+      update widgets set flags = NULL where id = 4
+    EOF
+
+    conn.create_command(<<-EOF).execute_non_query
+      update widgets set cost1 = NULL where id = 5
+    EOF
+
+    conn.create_command(<<-EOF).execute_non_query
+      update widgets set cost2 = NULL where id = 6
+    EOF
+
+    conn.create_command(<<-EOF).execute_non_query
+      update widgets set release_date = NULL where id = 7
+    EOF
+
+    conn.create_command(<<-EOF).execute_non_query
+      update widgets set release_datetime = NULL where id = 8
+    EOF
+
+    conn.create_command(<<-EOF).execute_non_query
+      update widgets set release_timestamp = NULL where id = 9
+    EOF
+
     conn.close
   end
 

data/spec/typecast/bigdecimal_spec.rb

@@ -3,6 +3,9 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 require 'data_objects/spec/typecast/bigdecimal_spec'
 
+# Sqlite3 doesn't support decimals natively, so autocasting is not available:
+# http://www.sqlite.org/datatype3.html
+
 describe 'DataObjects::Sqlite3 with BigDecimal' do
   it_should_behave_like 'supporting BigDecimal'
 end

data/spec/typecast/boolean_spec.rb

@@ -3,6 +3,9 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 require 'data_objects/spec/typecast/boolean_spec'
 
+# Sqlite3 doesn't support booleans natively, so autocasting is not available:
+# http://www.sqlite.org/datatype3.html
+
 describe 'DataObjects::Sqlite3 with Boolean' do
   it_should_behave_like 'supporting Boolean'
 end

data/spec/typecast/date_spec.rb

@@ -3,6 +3,9 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 require 'data_objects/spec/typecast/date_spec'
 
+# Sqlite3 doesn't support dates natively, so autocasting is not available:
+# http://www.sqlite.org/datatype3.html
+
 describe 'DataObjects::Sqlite3 with Date' do
   it_should_behave_like 'supporting Date'
 end

data/spec/typecast/datetime_spec.rb

@@ -3,6 +3,9 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 require 'data_objects/spec/typecast/datetime_spec'
 
+# Sqlite3 doesn't support datetimes natively, so autocasting is not available:
+# http://www.sqlite.org/datatype3.html
+
 describe 'DataObjects::Sqlite3 with DateTime' do
   it_should_behave_like 'supporting DateTime'
 end

data/spec/typecast/float_spec.rb

@@ -6,3 +6,7 @@ require 'data_objects/spec/typecast/float_spec'
 describe 'DataObjects::Sqlite3 with Float' do
   it_should_behave_like 'supporting Float'
 end
+
+describe 'DataObjects::Sqlite3 with Float' do
+  it_should_behave_like 'supporting Float autocasting'
+end

data/spec/typecast/nil_spec.rb

@@ -3,8 +3,18 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 require 'data_objects/spec/typecast/nil_spec'
 
+# splitting the descibe into two separate declaration avoids
+# concurrent execution of the "it_should_behave_like ....." calls
+# which would lock the database
+
 describe 'DataObjects::Sqlite3 with Nil' do
   it_should_behave_like 'supporting Nil'
-# it_should_behave_like 'supporting writing an Nil'
+end
+
+describe 'DataObjects::Sqlite3 with Nil' do
+  it_should_behave_like 'supporting writing an Nil'
+end
+
+describe 'DataObjects::Sqlite3 with Nil' do
   it_should_behave_like 'supporting Nil autocasting'
 end

data/tasks/gem.rake

@@ -1,61 +1,8 @@
 require 'rubygems/package_task'
 
-GEM_SPEC = Gem::Specification.new do |s|
-  # basic information
-  s.name        = "do_sqlite3"
-  s.version     = DataObjects::Sqlite3::VERSION
-
-  # description and details
-  s.summary     = 'DataObjects Sqlite3 Driver'
-  s.description = "Implements the DataObjects API for Sqlite3"
-
-  # dependencies
-  s.add_dependency "addressable", "~>2.0.0"
-  s.add_dependency "extlib", "~>0.9.12"
-  s.add_dependency "data_objects", DataObjects::Sqlite3::VERSION
-
-  if JRUBY
-    s.add_dependency "jdbc-sqlite3", ">=3.5.8"
-    s.add_dependency "do_jdbc", DataObjects::Sqlite3::VERSION
-    s.platform = "java"
-    # components, files and paths
-    s.files = FileList["lib/**/*.rb", "spec/**/*.rb", "tasks/**/*.rake",
-                        "LICENSE", "Rakefile", "*.{rdoc,txt,yml}", "lib/*.jar"]
-  else
-    s.platform    = Gem::Platform::RUBY
-    s.extensions << 'ext/do_sqlite3_ext/extconf.rb'
-    # components, files and paths
-    s.files = FileList["lib/**/*.rb", "spec/**/*.rb", "tasks/**/*.rake", "ext/**/*.{rb,c}",
-                        "LICENSE", "Rakefile", "*.{rdoc,txt,yml}"]
-  end
-
-  # development dependencies
-  s.add_development_dependency 'rspec', '~>1.2.0'
-
-
-  s.require_path = 'lib'
-
-  # documentation
-  s.has_rdoc = false
-
-  # project information
-  s.homepage          = 'http://github.com/datamapper/do'
-  s.rubyforge_project = 'dorb'
-
-  # author and contributors
-  s.author      = 'Dirkjan Bussink'
-  s.email       = 'd.bussink@gmail.com'
-end
+GEM_SPEC = eval(File.read('do_sqlite3.gemspec'))
 
 gem_package = Gem::PackageTask.new(GEM_SPEC) do |pkg|
   pkg.need_tar = false
   pkg.need_zip = false
 end
-
-file "#{GEM_SPEC.name}.gemspec" => ['Rakefile', 'tasks/gem.rake'] do |t|
-  puts "Generating #{t.name}"
-  File.open(t.name, 'w') { |f| f.puts GEM_SPEC.to_yaml }
-end
-
-desc "Generate or update the standalone gemspec file for the project"
-task :gemspec => ["#{GEM_SPEC.name}.gemspec"]

data/tasks/release.rake

@@ -8,7 +8,7 @@ end
 if defined?(RubyForge) then
   if defined?(GEM_SPEC) then
     desc 'Package and upload to RubyForge'
-    task :release => [:package] do |t|
+    task :release do |t|
       ver = ENV['VERSION'] or fail "Must supply VERSION (rake release VERSION=x.y.z)."
 
       # compare versions to avoid mistakes
@@ -26,19 +26,19 @@ if defined?(RubyForge) then
 
       # read project info and overview
       notes = begin
-                r = File.read("README.rdoc")
-                r.split(/^(=+ .*)/)[1..4].join.strip
+                r = File.read("README.markdown")
+                r.split(/^(.*\n\-+)/)[1..4].join.strip
               rescue
-                warn "Missing README.rdoc"
+                warn "Missing README.markdown"
                 ''
               end
 
       # read changes
       changes = begin
-                  h = File.read("History.txt")
-                  h.split(/^(==+ .*)/)[1..2].join.strip
+                  h = File.read("HISTORY.markdown")
+                  h.split(/^(##+ .*)/)[1..2].join.strip
                 rescue
-                  warn "Missing History.txt"
+                  warn "Missing HISTORY.markdown"
                   ''
                 end
 

data/tasks/retrieve.rake

@@ -36,7 +36,7 @@ begin
     url = "http://www.sqlite.org/#{File.basename(t.name)}"
     when_writing "downloading #{t.name}" do
       cd File.dirname(t.name) do
-        system "wget -c #{url} || curl -C - -O #{url}"
+        system "wget -c #{url} || curl -L -C - -O #{url}"
       end
     end
   end
@@ -46,7 +46,7 @@ begin
     url = "http://www.sqlite.org/#{File.basename(t.name)}"
     when_writing "downloading #{t.name}" do
       cd File.dirname(t.name) do
-        system "wget -c #{url} || curl -C - -O #{url}"
+        system "wget -c #{url} || curl -L -C - -O #{url}"
       end
     end
   end

data/tasks/spec.rake

@@ -5,6 +5,7 @@ desc 'Run specifications'
 Spec::Rake::SpecTask.new(:spec => [ :clean, :compile ]) do |t|
   t.spec_opts << '--options' << ROOT + 'spec/spec.opts'
   t.spec_files = Pathname.glob(ENV['FILES'] || 'spec/**/*_spec.rb').map { |f| f.to_s }
+  t.libs << 'lib'
 
   begin
     # RCov is run by default, except on the JRuby platform

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: do_sqlite3
 version: !ruby/object:Gem::Version 
-  version: 0.9.12
+  version: 0.10.0
 platform: ruby
 authors: 
 - Dirkjan Bussink
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-17 00:00:00 +02:00
+date: 2009-09-15 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 2.0.0
+        version: "2.0"
     version: 
 - !ruby/object:Gem::Dependency 
   name: extlib
@@ -40,7 +40,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.9.12
+        version: 0.10.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -91,12 +91,13 @@ files:
 - tasks/spec.rake
 - ext/do_sqlite3_ext/extconf.rb
 - ext/do_sqlite3_ext/do_sqlite3_ext.c
+- ext/do_sqlite3_ext/error.h
 - LICENSE
 - Rakefile
-- History.txt
+- HISTORY.markdown
+- README.markdown
 - Manifest.txt
-- README.txt
-has_rdoc: true
+has_rdoc: false
 homepage: http://github.com/datamapper/do
 licenses: []
 
@@ -120,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: dorb
-rubygems_version: 1.3.3
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: DataObjects Sqlite3 Driver