do_postgres 0.10.10-x86-mingw32 → 0.10.11-x86-mingw32

data/ChangeLog.markdown

@@ -1,3 +1,7 @@
+## 0.10.11 2012-12-29
+
+* Rename C symbols to prevent name collitions
+
 ## 0.10.10 2012-10-11
 
 No changes

data/ext/do_postgres/do_common.c

@@ -11,13 +11,13 @@
  */
 
 // To store rb_intern values
-ID ID_NEW;
-ID ID_NEW_DATE;
-ID ID_CONST_GET;
-ID ID_RATIONAL;
-ID ID_ESCAPE;
-ID ID_STRFTIME;
-ID ID_LOG;
+ID DO_ID_NEW;
+ID DO_ID_NEW_DATE;
+ID DO_ID_CONST_GET;
+ID DO_ID_RATIONAL;
+ID DO_ID_ESCAPE;
+ID DO_ID_STRFTIME;
+ID DO_ID_LOG;
 
 // Reference to Extlib module
 VALUE mExtlib;
@@ -33,8 +33,8 @@ VALUE cDO_Reader;
 VALUE cDO_Logger;
 VALUE cDO_Logger_Message;
 VALUE cDO_Extension;
-VALUE eConnectionError;
-VALUE eDataError;
+VALUE eDO_ConnectionError;
+VALUE eDO_DataError;
 
 // References to Ruby classes that we'll need
 VALUE rb_cDate;
@@ -47,7 +47,7 @@ VALUE rb_cBigDecimal;
 
 
 VALUE data_objects_const_get(VALUE scope, const char *constant) {
-  return rb_funcall(scope, ID_CONST_GET, 1, rb_str_new2(constant));
+  return rb_funcall(scope, DO_ID_CONST_GET, 1, rb_str_new2(constant));
 }
 
 void data_objects_debug(VALUE connection, VALUE string, struct timeval *start) {
@@ -58,9 +58,9 @@ void data_objects_debug(VALUE connection, VALUE string, struct timeval *start) {
   gettimeofday(&stop, NULL);
   duration = (stop.tv_sec - start->tv_sec) * 1000000 + stop.tv_usec - start->tv_usec;
 
-  message = rb_funcall(cDO_Logger_Message, ID_NEW, 3, string, rb_time_new(start->tv_sec, start->tv_usec), INT2NUM(duration));
+  message = rb_funcall(cDO_Logger_Message, DO_ID_NEW, 3, string, rb_time_new(start->tv_sec, start->tv_usec), INT2NUM(duration));
 
-  rb_funcall(connection, ID_LOG, 1, message);
+  rb_funcall(connection, DO_ID_LOG, 1, message);
 }
 
 void data_objects_raise_error(VALUE self, const struct errcodes *errors, int errnum, const char *message, VALUE query, VALUE state) {
@@ -80,7 +80,7 @@ void data_objects_raise_error(VALUE self, const struct errcodes *errors, int err
 
   exception = rb_funcall(
     data_objects_const_get(mDO, exception_type),
-    ID_NEW,
+    DO_ID_NEW,
     5,
     rb_str_new2(message),
     INT2NUM(errnum),
@@ -125,7 +125,7 @@ VALUE data_objects_build_query_from_args(VALUE klass, int count, VALUE *args) {
     rb_ary_push(array, args[i]);
   }
 
-  return rb_funcall(klass, ID_ESCAPE, 1, array);
+  return rb_funcall(klass, DO_ID_ESCAPE, 1, array);
 }
 
 // Find the greatest common denominator and reduce the provided numerator and denominator.
@@ -163,7 +163,7 @@ VALUE data_objects_seconds_to_offset(long seconds_offset) {
   do_int64 den = 86400;
 
   data_objects_reduce(&num, &den);
-  return rb_funcall(rb_mKernel, ID_RATIONAL, 2, rb_ll2inum(num), rb_ll2inum(den));
+  return rb_funcall(rb_mKernel, DO_ID_RATIONAL, 2, rb_ll2inum(num), rb_ll2inum(den));
 }
 
 VALUE data_objects_timezone_to_offset(int hour_offset, int minute_offset) {
@@ -189,7 +189,7 @@ VALUE data_objects_parse_date(const char *date) {
     return Qnil;
   }
 
-  return rb_funcall(rb_cDate, ID_NEW, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
+  return rb_funcall(rb_cDate, DO_ID_NEW, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
 }
 
 VALUE data_objects_parse_time(const char *date) {
@@ -299,11 +299,11 @@ VALUE data_objects_parse_date_time(const char *date) {
       break;
 
     default: /* Any other combo of missing tokens and we can't do anything */
-      rb_raise(eDataError, "Couldn't parse date: %s", date);
+      rb_raise(eDO_DataError, "Couldn't parse date: %s", date);
   }
 
   offset = data_objects_timezone_to_offset(hour_offset, minute_offset);
-  return rb_funcall(rb_cDateTime, ID_NEW, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day),
+  return rb_funcall(rb_cDateTime, DO_ID_NEW, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day),
                                              INT2NUM(hour), INT2NUM(min), INT2NUM(sec), offset);
 }
 
@@ -320,17 +320,17 @@ VALUE data_objects_cConnection_ssl_cipher(VALUE self) {
 }
 
 VALUE data_objects_cConnection_quote_time(VALUE self, VALUE value) {
-  return rb_funcall(value, ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d %H:%M:%S'"));
+  return rb_funcall(value, DO_ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d %H:%M:%S'"));
 }
 
 VALUE data_objects_cConnection_quote_date_time(VALUE self, VALUE value) {
   // TODO: Support non-local dates. we need to call #new_offset on the date to be
   // quoted and pass in the current locale's date offset (self.new_offset((hours * 3600).to_r / 86400)
-  return rb_funcall(value, ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d %H:%M:%S'"));
+  return rb_funcall(value, DO_ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d %H:%M:%S'"));
 }
 
 VALUE data_objects_cConnection_quote_date(VALUE self, VALUE value) {
-  return rb_funcall(value, ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d'"));
+  return rb_funcall(value, DO_ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d'"));
 }
 
 /*
@@ -379,7 +379,7 @@ VALUE data_objects_cReader_values(VALUE self) {
   VALUE values = rb_iv_get(self, "@values");
 
   if (state == Qnil || state == Qfalse || values == Qnil) {
-    rb_raise(eDataError, "Reader is not initialized");
+    rb_raise(eDO_DataError, "Reader is not initialized");
   }
 
   return rb_iv_get(self, "@values");
@@ -400,24 +400,24 @@ void data_objects_common_init(void) {
   rb_require("data_objects");
 
   // Needed by data_objects_const_get
-  ID_CONST_GET = rb_intern("const_get");
+  DO_ID_CONST_GET = rb_intern("const_get");
 
   // Get references classes needed for Date/Time parsing
   rb_cDate = data_objects_const_get(rb_mKernel, "Date");
   rb_cDateTime = data_objects_const_get(rb_mKernel, "DateTime");
   rb_cBigDecimal = data_objects_const_get(rb_mKernel, "BigDecimal");
 
-  ID_NEW = rb_intern("new");
+  DO_ID_NEW = rb_intern("new");
 #ifdef RUBY_LESS_THAN_186
-  ID_NEW_DATE = rb_intern("new0");
+  DO_ID_NEW_DATE = rb_intern("new0");
 #else
-  ID_NEW_DATE = rb_intern("new!");
+  DO_ID_NEW_DATE = rb_intern("new!");
 #endif
-  ID_CONST_GET = rb_intern("const_get");
-  ID_RATIONAL = rb_intern("Rational");
-  ID_ESCAPE = rb_intern("escape_sql");
-  ID_STRFTIME = rb_intern("strftime");
-  ID_LOG = rb_intern("log");
+  DO_ID_CONST_GET = rb_intern("const_get");
+  DO_ID_RATIONAL = rb_intern("Rational");
+  DO_ID_ESCAPE = rb_intern("escape_sql");
+  DO_ID_STRFTIME = rb_intern("strftime");
+  DO_ID_LOG = rb_intern("log");
 
   // Get references to the Extlib module
   mExtlib = data_objects_const_get(rb_mKernel, "Extlib");
@@ -434,15 +434,15 @@ void data_objects_common_init(void) {
   cDO_Logger_Message = data_objects_const_get(cDO_Logger, "Message");
   cDO_Extension = data_objects_const_get(mDO, "Extension");
 
-  eConnectionError = data_objects_const_get(mDO, "ConnectionError");
-  eDataError = data_objects_const_get(mDO, "DataError");
+  eDO_ConnectionError = data_objects_const_get(mDO, "ConnectionError");
+  eDO_DataError = data_objects_const_get(mDO, "DataError");
 
-  rb_global_variable(&ID_NEW_DATE);
-  rb_global_variable(&ID_RATIONAL);
-  rb_global_variable(&ID_CONST_GET);
-  rb_global_variable(&ID_ESCAPE);
-  rb_global_variable(&ID_LOG);
-  rb_global_variable(&ID_NEW);
+  rb_global_variable(&DO_ID_NEW_DATE);
+  rb_global_variable(&DO_ID_RATIONAL);
+  rb_global_variable(&DO_ID_CONST_GET);
+  rb_global_variable(&DO_ID_ESCAPE);
+  rb_global_variable(&DO_ID_LOG);
+  rb_global_variable(&DO_ID_NEW);
 
   rb_global_variable(&rb_cDate);
   rb_global_variable(&rb_cDateTime);
@@ -452,8 +452,8 @@ void data_objects_common_init(void) {
   rb_global_variable(&mDO);
   rb_global_variable(&cDO_Logger_Message);
 
-  rb_global_variable(&eConnectionError);
-  rb_global_variable(&eDataError);
+  rb_global_variable(&eDO_ConnectionError);
+  rb_global_variable(&eDO_DataError);
 
   tzset();
 }
@@ -478,7 +478,7 @@ extern VALUE data_objects_typecast(const char *value, long length, const VALUE t
     return rb_float_new(rb_cstr_to_dbl(value, Qfalse));
   }
   else if (type == rb_cBigDecimal) {
-    return rb_funcall(rb_cBigDecimal, ID_NEW, 1, rb_str_new(value, length));
+    return rb_funcall(rb_cBigDecimal, DO_ID_NEW, 1, rb_str_new(value, length));
   }
   else if (type == rb_cDate) {
     return data_objects_parse_date(value);
@@ -493,7 +493,7 @@ extern VALUE data_objects_typecast(const char *value, long length, const VALUE t
     return (!value || strcmp("0", value) == 0) ? Qfalse : Qtrue;
   }
   else if (type == rb_cByteArray) {
-    return rb_funcall(rb_cByteArray, ID_NEW, 1, rb_str_new(value, length));
+    return rb_funcall(rb_cByteArray, DO_ID_NEW, 1, rb_str_new(value, length));
   }
   else if (type == rb_cClass) {
     return rb_funcall(mDO, rb_intern("full_const_get"), 1, rb_str_new(value, length));

data/ext/do_postgres/do_common.h

@@ -54,13 +54,13 @@ typedef signed long long int do_int64;
 #endif
 
 // To store rb_intern values
-extern ID ID_NEW;
-extern ID ID_NEW_DATE;
-extern ID ID_CONST_GET;
-extern ID ID_RATIONAL;
-extern ID ID_ESCAPE;
-extern ID ID_STRFTIME;
-extern ID ID_LOG;
+extern ID DO_ID_NEW;
+extern ID DO_ID_NEW_DATE;
+extern ID DO_ID_CONST_GET;
+extern ID DO_ID_RATIONAL;
+extern ID DO_ID_ESCAPE;
+extern ID DO_ID_STRFTIME;
+extern ID DO_ID_LOG;
 
 // Reference to Extlib module
 extern VALUE mExtlib;
@@ -68,7 +68,6 @@ extern VALUE rb_cByteArray;
 
 // References to DataObjects base classes
 extern VALUE mDO;
-extern VALUE mEncoding;
 extern VALUE cDO_Quoting;
 extern VALUE cDO_Connection;
 extern VALUE cDO_Command;
@@ -77,8 +76,8 @@ extern VALUE cDO_Reader;
 extern VALUE cDO_Logger;
 extern VALUE cDO_Logger_Message;
 extern VALUE cDO_Extension;
-extern VALUE eConnectionError;
-extern VALUE eDataError;
+extern VALUE eDO_ConnectionError;
+extern VALUE eDO_DataError;
 
 // References to Ruby classes that we'll need
 extern VALUE rb_cDate;

data/ext/do_postgres/do_postgres.c

@@ -42,12 +42,12 @@
 
 #include "do_common.h"
 
-VALUE mPostgres;
-VALUE mEncoding;
-VALUE cPostgresConnection;
-VALUE cPostgresCommand;
-VALUE cPostgresResult;
-VALUE cPostgresReader;
+VALUE mDO_Postgres;
+VALUE mDO_PostgresEncoding;
+VALUE cDO_PostgresConnection;
+VALUE cDO_PostgresCommand;
+VALUE cDO_PostgresResult;
+VALUE cDO_PostgresReader;
 
 void do_postgres_full_connect(VALUE self, PGconn *db);
 
@@ -88,7 +88,7 @@ VALUE do_postgres_typecast(const char *value, long length, const VALUE type, int
   else if (type == rb_cByteArray) {
     size_t new_length = 0;
     char *unescaped = (char *)PQunescapeBytea((unsigned char*)value, &new_length);
-    VALUE byte_array = rb_funcall(rb_cByteArray, ID_NEW, 1, rb_str_new(unescaped, new_length));
+    VALUE byte_array = rb_funcall(rb_cByteArray, DO_ID_NEW, 1, rb_str_new(unescaped, new_length));
 
     PQfreemem(unescaped);
     return byte_array;
@@ -155,7 +155,7 @@ VALUE do_postgres_cConnection_quote_string(VALUE self, VALUE string) {
   quoted_length = PQescapeStringConn(db, escaped + 1, source, source_len, &error);
 
   if(error) {
-    rb_raise(eDataError, "%s", PQerrorMessage(db));
+    rb_raise(eDO_DataError, "%s", PQerrorMessage(db));
   }
 
   // Wrap the escaped string in single-quotes, this is DO's convention
@@ -228,7 +228,7 @@ PGresult * do_postgres_cCommand_execute_sync(VALUE self, VALUE connection, PGcon
     }
 
     if(!response) {
-      rb_raise(eConnectionError, PQerrorMessage(db));
+      rb_raise(eDO_ConnectionError, PQerrorMessage(db));
     }
   }
 
@@ -264,7 +264,7 @@ PGresult * do_postgres_cCommand_execute_async(VALUE self, VALUE connection, PGco
     }
 
     if (!retval) {
-      rb_raise(eConnectionError, "%s", PQerrorMessage(db));
+      rb_raise(eDO_ConnectionError, "%s", PQerrorMessage(db));
     }
   }
 
@@ -285,7 +285,7 @@ PGresult * do_postgres_cCommand_execute_async(VALUE self, VALUE connection, PGco
     }
 
     if (PQconsumeInput(db) == 0) {
-      rb_raise(eConnectionError, "%s", PQerrorMessage(db));
+      rb_raise(eDO_ConnectionError, "%s", PQerrorMessage(db));
     }
 
     if (PQisBusy(db) == 0) {
@@ -412,7 +412,7 @@ void do_postgres_full_connect(VALUE self, PGconn *db) {
   );
 
   if (PQstatus(db) == CONNECTION_BAD) {
-    rb_raise(eConnectionError, "%s", PQerrorMessage(db));
+    rb_raise(eDO_ConnectionError, "%s", PQerrorMessage(db));
   }
 
   PGresult *result;
@@ -465,11 +465,11 @@ void do_postgres_full_connect(VALUE self, PGconn *db) {
 
   VALUE encoding = rb_iv_get(self, "@encoding");
 #ifdef HAVE_PQSETCLIENTENCODING
-  VALUE pg_encoding = rb_hash_aref(data_objects_const_get(mEncoding, "MAP"), encoding);
+  VALUE pg_encoding = rb_hash_aref(data_objects_const_get(mDO_PostgresEncoding, "MAP"), encoding);
 
   if (pg_encoding != Qnil) {
     if (PQsetClientEncoding(db, rb_str_ptr_readonly(pg_encoding))) {
-      rb_raise(eConnectionError, "Couldn't set encoding: %s", rb_str_ptr_readonly(encoding));
+      rb_raise(eDO_ConnectionError, "Couldn't set encoding: %s", rb_str_ptr_readonly(encoding));
     }
     else {
 #ifdef HAVE_RUBY_ENCODING_H
@@ -497,7 +497,7 @@ VALUE do_postgres_cCommand_execute_non_query(int argc, VALUE *argv, VALUE self)
   VALUE postgres_connection = rb_iv_get(connection, "@connection");
 
   if (postgres_connection == Qnil) {
-    rb_raise(eConnectionError, "This connection has already been closed.");
+    rb_raise(eDO_ConnectionError, "This connection has already been closed.");
   }
 
   VALUE query = data_objects_build_query_from_args(self, argc, argv);
@@ -530,7 +530,7 @@ VALUE do_postgres_cCommand_execute_non_query(int argc, VALUE *argv, VALUE self)
   }
 
   PQclear(response);
-  return rb_funcall(cPostgresResult, ID_NEW, 3, self, affected_rows, insert_id);
+  return rb_funcall(cDO_PostgresResult, DO_ID_NEW, 3, self, affected_rows, insert_id);
 }
 
 VALUE do_postgres_cCommand_execute_reader(int argc, VALUE *argv, VALUE self) {
@@ -538,7 +538,7 @@ VALUE do_postgres_cCommand_execute_reader(int argc, VALUE *argv, VALUE self) {
   VALUE postgres_connection = rb_iv_get(connection, "@connection");
 
   if (postgres_connection == Qnil) {
-    rb_raise(eConnectionError, "This connection has already been closed.");
+    rb_raise(eDO_ConnectionError, "This connection has already been closed.");
   }
 
   VALUE query = data_objects_build_query_from_args(self, argc, argv);
@@ -550,7 +550,7 @@ VALUE do_postgres_cCommand_execute_reader(int argc, VALUE *argv, VALUE self) {
   }
 
   int field_count = PQnfields(response);
-  VALUE reader = rb_funcall(cPostgresReader, ID_NEW, 0);
+  VALUE reader = rb_funcall(cDO_PostgresReader, DO_ID_NEW, 0);
 
   rb_iv_set(reader, "@connection", connection);
   rb_iv_set(reader, "@reader", Data_Wrap_Struct(rb_cObject, 0, 0, response));
@@ -614,7 +614,7 @@ VALUE do_postgres_cReader_next(VALUE self) {
   VALUE reader = rb_iv_get(self, "@reader");
 
   if(reader == Qnil) {
-    rb_raise(eConnectionError, "This result set has already been closed.");
+    rb_raise(eDO_ConnectionError, "This result set has already been closed.");
     return Qfalse;
   }
 
@@ -668,32 +668,32 @@ VALUE do_postgres_cReader_next(VALUE self) {
 void Init_do_postgres() {
   data_objects_common_init();
 
-  mPostgres = rb_define_module_under(mDO, "Postgres");
-  mEncoding = rb_define_module_under(mPostgres, "Encoding");
+  mDO_Postgres = rb_define_module_under(mDO, "Postgres");
+  mDO_PostgresEncoding = rb_define_module_under(mDO_Postgres, "Encoding");
 
-  cPostgresConnection = rb_define_class_under(mPostgres, "Connection", cDO_Connection);
-  rb_define_method(cPostgresConnection, "initialize", do_postgres_cConnection_initialize, 1);
-  rb_define_method(cPostgresConnection, "dispose", do_postgres_cConnection_dispose, 0);
-  rb_define_method(cPostgresConnection, "character_set", data_objects_cConnection_character_set , 0);
-  rb_define_method(cPostgresConnection, "quote_string", do_postgres_cConnection_quote_string, 1);
-  rb_define_method(cPostgresConnection, "quote_byte_array", do_postgres_cConnection_quote_byte_array, 1);
+  cDO_PostgresConnection = rb_define_class_under(mDO_Postgres, "Connection", cDO_Connection);
+  rb_define_method(cDO_PostgresConnection, "initialize", do_postgres_cConnection_initialize, 1);
+  rb_define_method(cDO_PostgresConnection, "dispose", do_postgres_cConnection_dispose, 0);
+  rb_define_method(cDO_PostgresConnection, "character_set", data_objects_cConnection_character_set , 0);
+  rb_define_method(cDO_PostgresConnection, "quote_string", do_postgres_cConnection_quote_string, 1);
+  rb_define_method(cDO_PostgresConnection, "quote_byte_array", do_postgres_cConnection_quote_byte_array, 1);
 
-  cPostgresCommand = rb_define_class_under(mPostgres, "Command", cDO_Command);
-  rb_define_method(cPostgresCommand, "set_types", data_objects_cCommand_set_types, -1);
-  rb_define_method(cPostgresCommand, "execute_non_query", do_postgres_cCommand_execute_non_query, -1);
-  rb_define_method(cPostgresCommand, "execute_reader", do_postgres_cCommand_execute_reader, -1);
+  cDO_PostgresCommand = rb_define_class_under(mDO_Postgres, "Command", cDO_Command);
+  rb_define_method(cDO_PostgresCommand, "set_types", data_objects_cCommand_set_types, -1);
+  rb_define_method(cDO_PostgresCommand, "execute_non_query", do_postgres_cCommand_execute_non_query, -1);
+  rb_define_method(cDO_PostgresCommand, "execute_reader", do_postgres_cCommand_execute_reader, -1);
 
-  cPostgresResult = rb_define_class_under(mPostgres, "Result", cDO_Result);
+  cDO_PostgresResult = rb_define_class_under(mDO_Postgres, "Result", cDO_Result);
 
-  cPostgresReader = rb_define_class_under(mPostgres, "Reader", cDO_Reader);
-  rb_define_method(cPostgresReader, "close", do_postgres_cReader_close, 0);
-  rb_define_method(cPostgresReader, "next!", do_postgres_cReader_next, 0);
-  rb_define_method(cPostgresReader, "values", data_objects_cReader_values, 0);
-  rb_define_method(cPostgresReader, "fields", data_objects_cReader_fields, 0);
-  rb_define_method(cPostgresReader, "field_count", data_objects_cReader_field_count, 0);
+  cDO_PostgresReader = rb_define_class_under(mDO_Postgres, "Reader", cDO_Reader);
+  rb_define_method(cDO_PostgresReader, "close", do_postgres_cReader_close, 0);
+  rb_define_method(cDO_PostgresReader, "next!", do_postgres_cReader_next, 0);
+  rb_define_method(cDO_PostgresReader, "values", data_objects_cReader_values, 0);
+  rb_define_method(cDO_PostgresReader, "fields", data_objects_cReader_fields, 0);
+  rb_define_method(cDO_PostgresReader, "field_count", data_objects_cReader_field_count, 0);
 
-  rb_global_variable(&cPostgresResult);
-  rb_global_variable(&cPostgresReader);
+  rb_global_variable(&cDO_PostgresResult);
+  rb_global_variable(&cDO_PostgresReader);
 
-  data_objects_define_errors(mPostgres, do_postgres_errors);
+  data_objects_define_errors(mDO_Postgres, do_postgres_errors);
 }

data/lib/do_postgres/version.rb

@@ -1,5 +1,5 @@
 module DataObjects
   module Postgres
-    VERSION = '0.10.10'
+    VERSION = '0.10.11'
   end
 end

data/tasks/compile.rake

@@ -70,7 +70,7 @@ begin
     ext.classpath = '../do_jdbc/lib/do_jdbc_internal.jar'
     ext.java_compiling do |gem|
       gem.add_dependency 'jdbc-postgres', '>=8.2'
-      gem.add_dependency 'do_jdbc',       '0.10.10'
+      gem.add_dependency 'do_jdbc',       '0.10.11'
     end
   end
 rescue LoadError

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 10
-  - 10
-  version: 0.10.10
+  - 11
+  version: 0.10.11
 platform: x86-mingw32
 authors: 
 - Dirkjan Bussink
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-29 00:00:00 +02:00
+date: 2012-12-29 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -28,8 +28,8 @@ dependencies:
         segments: 
         - 0
         - 10
-        - 10
-        version: 0.10.10
+        - 11
+        version: 0.10.11
   requirement: *id001
 - !ruby/object:Gem::Dependency 
   prerelease: false