extralite 1.27 → 2.1

data/ext/extralite/database.c

@@ -6,13 +6,17 @@ VALUE cError;
 VALUE cSQLError;
 VALUE cBusyError;
 VALUE cInterruptError;
+VALUE eArgumentError;
 
+ID ID_bind;
 ID ID_call;
 ID ID_keys;
 ID ID_new;
 ID ID_strip;
 ID ID_to_s;
 
+VALUE SYM_read_only;
+
 static size_t Database_size(const void *ptr) {
   return sizeof(Database_t);
 }
@@ -35,27 +39,21 @@ static VALUE Database_allocate(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &Database_type, db);
 }
 
-#define GetDatabase(obj, database) \
-  TypedData_Get_Struct((obj), Database_t, &Database_type, (database))
-
-// make sure the database is open
-#define GetOpenDatabase(obj, database) { \
-  TypedData_Get_Struct((obj), Database_t, &Database_type, (database)); \
-  if (!(database)->sqlite3_db) { \
-    rb_raise(cError, "Database is closed"); \
-  } \
+inline Database_t *self_to_database(VALUE self) {
+  Database_t *db;
+  TypedData_Get_Struct(self, Database_t, &Database_type, db);
+  return db;
 }
 
-Database_t *Database_struct(VALUE self) {
-  Database_t *db;
-  GetDatabase(self, db);
+inline Database_t *self_to_open_database(VALUE self) {
+  Database_t *db = self_to_database(self);
+  if (!(db)->sqlite3_db) rb_raise(cError, "Database is closed");
+  
   return db;
 }
 
-sqlite3 *Database_sqlite3_db(VALUE self) {
-  Database_t *db;
-  GetDatabase(self, db);
-  return db->sqlite3_db;
+inline sqlite3 *Database_sqlite3_db(VALUE self) {
+  return self_to_database(self)->sqlite3_db;
 }
 
 /* call-seq:
@@ -68,18 +66,37 @@ VALUE Extralite_sqlite3_version(VALUE self) {
   return rb_str_new_cstr(sqlite3_version);
 }
 
-/* call-seq:
- *   db.initialize(path)
+static inline int db_open_flags_from_opts(VALUE opts) {
+  if (opts == Qnil) goto default_flags;
+
+  if (TYPE(opts) != T_HASH)
+    rb_raise(eArgumentError, "Expected hash as database initialization options");
+
+  VALUE read_only = rb_hash_aref(opts, SYM_read_only);
+  if (RTEST(read_only)) return SQLITE_OPEN_READONLY;
+default_flags:
+  return SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
+}
+
+/* Initializes a new SQLite database with the given path and options.
  *
- * Initializes a new SQLite database with the given path.
+ * @overload initialize(path)
+ *   @param path [String] file path (or ':memory:' for memory database)
+ *   @return [void]
+ * @overload initialize(path, read_only: false)
+ *   @param path [String] file path (or ':memory:' for memory database)
+ *   @param read_only [boolean] true for opening the database for reading only
+ *   @return [void]
  */
+VALUE Database_initialize(int argc, VALUE *argv, VALUE self) {
+  Database_t *db = self_to_database(self);
+  VALUE path;
+  VALUE opts = Qnil;
 
-VALUE Database_initialize(VALUE self, VALUE path) {
-  int rc;
-  Database_t *db;
-  GetDatabase(self, db);
+  rb_scan_args(argc, argv, "11", &path, &opts);
+  int flags = db_open_flags_from_opts(opts);
 
-  rc = sqlite3_open(StringValueCStr(path), &db->sqlite3_db);
+  int rc = sqlite3_open_v2(StringValueCStr(path), &db->sqlite3_db, flags, NULL);
   if (rc) {
     sqlite3_close_v2(db->sqlite3_db);
     rb_raise(cError, "%s", sqlite3_errstr(rc));
@@ -105,6 +122,16 @@ VALUE Database_initialize(VALUE self, VALUE path) {
   return Qnil;
 }
 
+/* Returns true if the database was open for read only access.
+ *
+ * @return [boolean] true if database is open for read only access
+ */
+VALUE Database_read_only_p(VALUE self) {
+  Database_t *db = self_to_database(self);
+  int open = sqlite3_db_readonly(db->sqlite3_db, "main");
+  return (open == 1) ? Qtrue : Qfalse;
+}
+
 /* call-seq:
  *   db.close -> db
  *
@@ -112,8 +139,7 @@ VALUE Database_initialize(VALUE self, VALUE path) {
  */
 VALUE Database_close(VALUE self) {
   int rc;
-  Database_t *db;
-  GetDatabase(self, db);
+  Database_t *db = self_to_database(self);
 
   rc = sqlite3_close_v2(db->sqlite3_db);
   if (rc) {
@@ -132,14 +158,12 @@ VALUE Database_close(VALUE self) {
  * @return [bool] is database closed
  */
 VALUE Database_closed_p(VALUE self) {
-  Database_t *db;
-  GetDatabase(self, db);
-
+  Database_t *db = self_to_database(self);
   return db->sqlite3_db ? Qfalse : Qtrue;
 }
 
 static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VALUE (*call)(query_ctx *)) {
-  Database_t *db;
+  Database_t *db = self_to_open_database(self);
   sqlite3_stmt *stmt;
   VALUE sql;
 
@@ -149,13 +173,12 @@ static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VA
   if (RSTRING_LEN(sql) == 0) return Qnil;
 
   // prepare query ctx
-  GetOpenDatabase(self, db);
   if (db->trace_block != Qnil) rb_funcall(db->trace_block, ID_call, 1, sql);
   prepare_multi_stmt(db->sqlite3_db, &stmt, sql);
   RB_GC_GUARD(sql);
 
   bind_all_parameters(stmt, argc - 1, argv + 1);
-  query_ctx ctx = { self, db->sqlite3_db, stmt };
+  query_ctx ctx = { self, db->sqlite3_db, stmt, Qnil, QUERY_MODE(QUERY_MULTI_ROW), ALL_ROWS };
 
   return rb_ensure(SAFE(call), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
 }
@@ -170,7 +193,7 @@ static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VA
  * 
  * Query parameters to be bound to placeholders in the query can be specified as
  * a list of values or as a hash mapping parameter names to values. When
- * parameters are given as a least, the query should specify parameters using
+ * parameters are given as an array, the query should specify parameters using
  * `?`:
  * 
  *     db.query('select * from foo where x = ?', 42)
@@ -195,7 +218,7 @@ VALUE Database_query_hash(int argc, VALUE *argv, VALUE self) {
  *
  * Query parameters to be bound to placeholders in the query can be specified as
  * a list of values or as a hash mapping parameter names to values. When
- * parameters are given as a least, the query should specify parameters using
+ * parameters are given as an array, the query should specify parameters using
  * `?`:
  *
  *     db.query_ary('select * from foo where x = ?', 42)
@@ -219,7 +242,7 @@ VALUE Database_query_ary(int argc, VALUE *argv, VALUE self) {
  *
  * Query parameters to be bound to placeholders in the query can be specified as
  * a list of values or as a hash mapping parameter names to values. When
- * parameters are given as a least, the query should specify parameters using
+ * parameters are given as an array, the query should specify parameters using
  * `?`:
  *
  *     db.query_single_row('select * from foo where x = ?', 42)
@@ -244,7 +267,7 @@ VALUE Database_query_single_row(int argc, VALUE *argv, VALUE self) {
  *
  * Query parameters to be bound to placeholders in the query can be specified as
  * a list of values or as a hash mapping parameter names to values. When
- * parameters are given as a least, the query should specify parameters using
+ * parameters are given as an array, the query should specify parameters using
  * `?`:
  *
  *     db.query_single_column('select x from foo where x = ?', 42)
@@ -268,7 +291,7 @@ VALUE Database_query_single_column(int argc, VALUE *argv, VALUE self) {
  *
  * Query parameters to be bound to placeholders in the query can be specified as
  * a list of values or as a hash mapping parameter names to values. When
- * parameters are given as a least, the query should specify parameters using
+ * parameters are given as an array, the query should specify parameters using
  * `?`:
  *
  *     db.query_single_value('select x from foo where x = ?', 42)
@@ -285,6 +308,31 @@ VALUE Database_query_single_value(int argc, VALUE *argv, VALUE self) {
   return Database_perform_query(argc, argv, self, safe_query_single_value);
 }
 
+/* call-seq:
+ *   db.execute(sql, *parameters) -> changes
+ *
+ * Runs a query returning the total changes effected. This method should be used
+ * for data- or schema-manipulation queries.
+ *
+ * Query parameters to be bound to placeholders in the query can be specified as
+ * a list of values or as a hash mapping parameter names to values. When
+ * parameters are given as an array, the query should specify parameters using
+ * `?`:
+ *
+ *     db.execute('update foo set x = ? where y = ?', 42, 43)
+ *
+ * Named placeholders are specified using `:`. The placeholder values are
+ * specified using a hash, where keys are either strings are symbols. String
+ * keys can include or omit the `:` prefix. The following are equivalent:
+ *
+ *     db.execute('update foo set x = :bar', bar: 42)
+ *     db.execute('update foo set x = :bar', 'bar' => 42)
+ *     db.execute('update foo set x = :bar', ':bar' => 42)
+ */
+VALUE Database_execute(int argc, VALUE *argv, VALUE self) {
+  return Database_perform_query(argc, argv, self, safe_query_changes);
+}
+
 /* call-seq:
  *   db.execute_multi(sql, params_array) -> changes
  *
@@ -296,19 +344,18 @@ VALUE Database_query_single_value(int argc, VALUE *argv, VALUE self) {
  *       [1, 2, 3],
  *       [4, 5, 6]
  *     ]
- *     db.execute_multi_query('insert into foo values (?, ?, ?)', records)
+ *     db.execute_multi('insert into foo values (?, ?, ?)', records)
  *
  */
 VALUE Database_execute_multi(VALUE self, VALUE sql, VALUE params_array) {
-  Database_t *db;
+  Database_t *db = self_to_open_database(self);
   sqlite3_stmt *stmt;
 
   if (RSTRING_LEN(sql) == 0) return Qnil;
 
   // prepare query ctx
-  GetOpenDatabase(self, db);
   prepare_single_stmt(db->sqlite3_db, &stmt, sql);
-  query_ctx ctx = { self, db->sqlite3_db, stmt, params_array };
+  query_ctx ctx = { self, db->sqlite3_db, stmt, params_array, QUERY_MODE(QUERY_MULTI_ROW), ALL_ROWS };
 
   return rb_ensure(SAFE(safe_execute_multi), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
 }
@@ -328,8 +375,7 @@ VALUE Database_columns(VALUE self, VALUE sql) {
  * Returns the rowid of the last inserted row.
  */
 VALUE Database_last_insert_rowid(VALUE self) {
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   return INT2FIX(sqlite3_last_insert_rowid(db->sqlite3_db));
 }
@@ -340,8 +386,7 @@ VALUE Database_last_insert_rowid(VALUE self) {
  * Returns the number of changes made to the database by the last operation.
  */
 VALUE Database_changes(VALUE self) {
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   return INT2FIX(sqlite3_changes(db->sqlite3_db));
 }
@@ -354,8 +399,7 @@ VALUE Database_changes(VALUE self) {
 VALUE Database_filename(int argc, VALUE *argv, VALUE self) {
   const char *db_name;
   const char *filename;
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   rb_check_arity(argc, 0, 1);
   db_name = (argc == 1) ? StringValueCStr(argv[0]) : "main";
@@ -369,8 +413,7 @@ VALUE Database_filename(int argc, VALUE *argv, VALUE self) {
  * Returns true if a transaction is currently in progress.
  */
 VALUE Database_transaction_active_p(VALUE self) {
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   return sqlite3_get_autocommit(db->sqlite3_db) ? Qfalse : Qtrue;
 }
@@ -382,8 +425,7 @@ VALUE Database_transaction_active_p(VALUE self) {
  * Loads an extension with the given path.
  */
 VALUE Database_load_extension(VALUE self, VALUE path) {
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
   char *err_msg;
 
   int rc = sqlite3_load_extension(db->sqlite3_db, RSTRING_PTR(path), 0, &err_msg);
@@ -398,12 +440,16 @@ VALUE Database_load_extension(VALUE self, VALUE path) {
 #endif
 
 /* call-seq:
- *   db.prepare(sql) -> Extralite::PreparedStatement
+ *   db.prepare(sql) -> Extralite::Query
  *
  * Creates a prepared statement with the given SQL query.
  */
-VALUE Database_prepare(VALUE self, VALUE sql) {
-  return rb_funcall(cPreparedStatement, ID_new, 2, self, sql);
+VALUE Database_prepare(int argc, VALUE *argv, VALUE self) {
+  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+  VALUE query = rb_funcall(cQuery, ID_new, 2, self, argv[0]);
+  if (argc > 1) rb_funcallv(query, ID_bind, argc - 1, argv + 1);
+  RB_GC_GUARD(query);
+  return query;
 }
 
 /* call-seq:
@@ -417,8 +463,7 @@ VALUE Database_prepare(VALUE self, VALUE sql) {
  * For more information, consult the [sqlite3 API docs](https://sqlite.org/c3ref/interrupt.html).
  */
 VALUE Database_interrupt(VALUE self) {
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   sqlite3_interrupt(db->sqlite3_db);
   return self;
@@ -510,8 +555,7 @@ VALUE Database_backup(int argc, VALUE *argv, VALUE self) {
 
   int dst_is_fn = TYPE(dst) == T_STRING;
 
-  Database_t *src;
-  GetOpenDatabase(self, src);
+  Database_t *src = self_to_open_database(self);
   sqlite3 *dst_db;
 
   if (dst_is_fn) {
@@ -522,8 +566,7 @@ VALUE Database_backup(int argc, VALUE *argv, VALUE self) {
     }
   }
   else {
-    Database_t *dst_struct;
-    GetOpenDatabase(dst, dst_struct);
+    Database_t *dst_struct = self_to_open_database(dst);
     dst_db = dst_struct->sqlite3_db;
   }
 
@@ -540,6 +583,9 @@ VALUE Database_backup(int argc, VALUE *argv, VALUE self) {
   backup_ctx ctx = { dst_db, dst_is_fn, backup, rb_block_given_p(), 0 };
   rb_ensure(SAFE(backup_safe_iterate), (VALUE)&ctx, SAFE(backup_cleanup), (VALUE)&ctx);
 
+  RB_GC_GUARD(src_name);
+  RB_GC_GUARD(dst_name);
+
   return self;
 }
 
@@ -575,8 +621,7 @@ VALUE Database_status(int argc, VALUE *argv, VALUE self) {
 
   rb_scan_args(argc, argv, "11", &op, &reset);
 
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   int rc = sqlite3_db_status(db->sqlite3_db, NUM2INT(op), &cur, &hwm, RTEST(reset) ? 1 : 0);
   if (rc != SQLITE_OK) rb_raise(cError, "%s", sqlite3_errstr(rc));
@@ -596,8 +641,7 @@ VALUE Database_limit(int argc, VALUE *argv, VALUE self) {
 
   rb_scan_args(argc, argv, "11", &category, &new_value);
 
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   int value = sqlite3_limit(db->sqlite3_db, NUM2INT(category), RTEST(new_value) ? NUM2INT(new_value) : -1);
 
@@ -614,8 +658,7 @@ VALUE Database_limit(int argc, VALUE *argv, VALUE self) {
  * disable the busy timeout, set it to 0 or nil.
  */
 VALUE Database_busy_timeout_set(VALUE self, VALUE sec) {
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   int ms = (sec == Qnil) ? 0 : (int)(NUM2DBL(sec) * 1000);
   int rc = sqlite3_busy_timeout(db->sqlite3_db, ms);
@@ -630,8 +673,7 @@ VALUE Database_busy_timeout_set(VALUE self, VALUE sec) {
  * Returns the total number of changes made to the database since opening it.
  */
 VALUE Database_total_changes(VALUE self) {
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   int value = sqlite3_total_changes(db->sqlite3_db);
   return INT2NUM(value);
@@ -645,8 +687,7 @@ VALUE Database_total_changes(VALUE self) {
  * executed.
  */
 VALUE Database_trace(VALUE self) {
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   db->trace_block = rb_block_given_p() ? rb_block_proc() : Qnil;
   return self;
@@ -658,8 +699,7 @@ VALUE Database_trace(VALUE self) {
  * Returns the last error code for the database.
  */
 VALUE Database_errcode(VALUE self) {
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   return INT2NUM(sqlite3_errcode(db->sqlite3_db));
 }
@@ -670,8 +710,7 @@ VALUE Database_errcode(VALUE self) {
  * Returns the last error message for the database.
  */
 VALUE Database_errmsg(VALUE self) {
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   return rb_str_new2(sqlite3_errmsg(db->sqlite3_db));
 }
@@ -683,13 +722,25 @@ VALUE Database_errmsg(VALUE self) {
  * Returns the offset for the last error
  */
 VALUE Database_error_offset(VALUE self) {
-  Database_t *db;
-  GetOpenDatabase(self, db);
+  Database_t *db = self_to_open_database(self);
 
   return INT2NUM(sqlite3_error_offset(db->sqlite3_db));
 }
 #endif
 
+/* Returns a short string representation of the database instance, including the
+ * database filename.
+ *
+ * @return [String] string representation
+ */
+VALUE Database_inspect(VALUE self) {
+  VALUE cname = rb_class_name(CLASS_OF(self));
+  VALUE filename = Database_filename(0, NULL, self);
+  if (RSTRING_LEN(filename) == 0) filename = rb_str_new_literal(":memory:");
+
+  return rb_sprintf("#<%"PRIsVALUE":%p %"PRIsVALUE">", cname, (void*)self, filename);
+}
+
 void Init_ExtraliteDatabase(void) {
   VALUE mExtralite = rb_define_module("Extralite");
   rb_define_singleton_method(mExtralite, "runtime_status", Extralite_runtime_status, -1);
@@ -711,19 +762,22 @@ void Init_ExtraliteDatabase(void) {
   rb_define_method(cDatabase, "error_offset", Database_error_offset, 0);
   #endif
 
+  rb_define_method(cDatabase, "execute", Database_execute, -1);
   rb_define_method(cDatabase, "execute_multi", Database_execute_multi, 2);
   rb_define_method(cDatabase, "filename", Database_filename, -1);
-  rb_define_method(cDatabase, "initialize", Database_initialize, 1);
+  rb_define_method(cDatabase, "initialize", Database_initialize, -1);
+  rb_define_method(cDatabase, "inspect", Database_inspect, 0);
   rb_define_method(cDatabase, "interrupt", Database_interrupt, 0);
   rb_define_method(cDatabase, "last_insert_rowid", Database_last_insert_rowid, 0);
   rb_define_method(cDatabase, "limit", Database_limit, -1);
-  rb_define_method(cDatabase, "prepare", Database_prepare, 1);
+  rb_define_method(cDatabase, "prepare", Database_prepare, -1);
   rb_define_method(cDatabase, "query", Database_query_hash, -1);
   rb_define_method(cDatabase, "query_ary", Database_query_ary, -1);
   rb_define_method(cDatabase, "query_hash", Database_query_hash, -1);
   rb_define_method(cDatabase, "query_single_column", Database_query_single_column, -1);
   rb_define_method(cDatabase, "query_single_row", Database_query_single_row, -1);
   rb_define_method(cDatabase, "query_single_value", Database_query_single_value, -1);
+  rb_define_method(cDatabase, "read_only?", Database_read_only_p, 0);
   rb_define_method(cDatabase, "status", Database_status, -1);
   rb_define_method(cDatabase, "total_changes", Database_total_changes, 0);
   rb_define_method(cDatabase, "trace", Database_trace, 0);
@@ -742,9 +796,15 @@ void Init_ExtraliteDatabase(void) {
   rb_gc_register_mark_object(cBusyError);
   rb_gc_register_mark_object(cInterruptError);
 
+  eArgumentError = rb_const_get(rb_cObject, rb_intern("ArgumentError"));
+
+  ID_bind   = rb_intern("bind");
   ID_call   = rb_intern("call");
   ID_keys   = rb_intern("keys");
   ID_new    = rb_intern("new");
   ID_strip  = rb_intern("strip");
   ID_to_s   = rb_intern("to_s");
+
+  SYM_read_only = ID2SYM(rb_intern("read_only"));
+  rb_gc_register_mark_object(SYM_read_only);
 }

data/ext/extralite/extconf.rb

@@ -4,13 +4,13 @@ if ENV['EXTRALITE_BUNDLE']
   require_relative('extconf-bundle')
 else
   ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
-  
+
   require 'mkmf'
-  
+
   # :stopdoc:
-  
+
   RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
-  
+
   ldflags = cppflags = nil
   if RbConfig::CONFIG["host_os"] =~ /darwin/
     begin
@@ -25,7 +25,7 @@ else
         cppflags  = "#{brew_prefix}/include"
         pkg_conf  = "#{brew_prefix}/lib/pkgconfig"
       end
-      
+
       # pkg_config should be less error prone than parsing compiler
       # commandline options, but we need to set default ldflags and cpp flags
       # in case the user doesn't have pkg-config installed
@@ -33,13 +33,13 @@ else
     rescue
     end
   end
-  
+
   if with_config('sqlcipher')
     pkg_config("sqlcipher")
   else
     pkg_config("sqlite3")
   end
-  
+
   # --with-sqlite3-{dir,include,lib}
   if with_config('sqlcipher')
     $CFLAGS << ' -DUSING_SQLCIPHER'
@@ -47,15 +47,15 @@ else
   else
     dir_config("sqlite3", cppflags, ldflags)
   end
-  
+
   if RbConfig::CONFIG["host_os"] =~ /mswin/
     $CFLAGS << ' -W3'
   end
-  
+
   if RUBY_VERSION < '2.7'
     $CFLAGS << ' -DTAINTING_SUPPORT'
   end
-  
+
   # @!visibility private
   def asplode missing
     if RUBY_PLATFORM =~ /mingw|mswin/
@@ -70,25 +70,25 @@ else
         error
       end
     end
-    
+
     asplode('sqlite3.h')  unless find_header  'sqlite3.h'
     find_library 'pthread', 'pthread_create' # 1.8 support. *shrug*
-    
+
     have_library 'dl' # for static builds
-    
+
     if with_config('sqlcipher')
       asplode('sqlcipher') unless find_library 'sqlcipher', 'sqlite3_libversion_number'
     else
       asplode('sqlite3') unless find_library 'sqlite3', 'sqlite3_libversion_number'
     end
-    
+
     have_func('sqlite3_enable_load_extension')
     have_func('sqlite3_load_extension')
     have_func('sqlite3_prepare_v2')
     have_func('sqlite3_error_offset')
-    
+
     $defs << "-DEXTRALITE_NO_BUNDLE"
-    
+
     dir_config('extralite_ext')
     create_makefile('extralite_ext')
   end