couchbase 1.2.3-x86-mingw32 → 1.3.0-x86-mingw32

data/ext/couchbase_ext/arguments.c

@@ -17,8 +17,6 @@
 
 #include "couchbase_ext.h"
 
-/* TOUCH */
-
 #define _alloc_data_for_s(type, _type, size, items, ptr) do {\
     lcb_size_t ii; \
     \
@@ -45,6 +43,40 @@
 
 #define _release_data_for(type) _release_data_for_s(type, items, ptr)
 
+    static VALUE
+get_transcoder(struct cb_bucket_st *bucket, VALUE override, int compat, VALUE opts)
+{
+    VALUE ret = Qundef;
+
+    /* override with symbol */
+    if (TYPE(override) == T_SYMBOL) {
+        if (override == cb_sym_document) {
+            ret = cb_mDocument;
+        } else if (override == cb_sym_marshal) {
+            ret = cb_mMarshal;
+        } else if (override == cb_sym_plain) {
+            ret = cb_mPlain;
+        }
+    } else if (!compat) {
+        /* override with transcoder */
+        if (rb_respond_to(override, cb_id_dump)
+                && rb_respond_to(override, cb_id_load)) {
+            ret = override;
+        }
+        /* nil is also valid */
+        if (NIL_P(override)) {
+            ret = Qnil;
+        }
+    }
+    if (ret == Qundef) {
+        return bucket->transcoder;
+    } else {
+        rb_hash_aset(opts, cb_sym_forced, Qtrue);
+        return ret;
+    }
+}
+
+/* TOUCH */
 
     static void
 cb_params_touch_alloc(struct cb_params_st *params, lcb_size_t size)
@@ -227,11 +259,11 @@ cb_params_store_init_item(struct cb_params_st *params, lcb_size_t idx,
         lcb_time_t exptime)
 {
     key_obj = cb_unify_key(params->bucket, key_obj, 1);
-    value_obj = cb_encode_value(value_obj, params->cmd.store.flags);
+    value_obj = cb_encode_value(params->cmd.store.transcoder, value_obj, &flags, params->cmd.store.transcoder_opts);
     if (rb_obj_is_kind_of(value_obj, rb_eStandardError)) {
         VALUE exc_str = rb_funcall(value_obj, cb_id_to_s, 0);
         VALUE msg = rb_funcall(rb_mKernel, cb_id_sprintf, 3,
-                rb_str_new2("unable to convert value for key '%s': %s"), key_obj, exc_str);
+                rb_str_new2("unable to convert value for key \"%s\": %s"), key_obj, exc_str);
         VALUE exc = rb_exc_new3(cb_eValueFormatError, msg);
         rb_ivar_set(exc, cb_id_iv_inner_exception, value_obj);
         rb_exc_raise(exc);
@@ -239,7 +271,7 @@ cb_params_store_init_item(struct cb_params_st *params, lcb_size_t idx,
     /* the value must be string after conversion */
     if (TYPE(value_obj) != T_STRING) {
         VALUE val = rb_any_to_s(value_obj);
-        rb_raise(cb_eValueFormatError, "unable to convert value for key '%s' to string: %s", RSTRING_PTR(key_obj), RSTRING_PTR(val));
+        rb_raise(cb_eValueFormatError, "unable to convert value for key \"%s\" to string: %s", RSTRING_PTR(key_obj), RSTRING_PTR(val));
     }
     rb_ary_push(params->ensurance, key_obj);
     rb_ary_push(params->ensurance, value_obj);
@@ -276,10 +308,6 @@ cb_params_store_parse_options(struct cb_params_st *params, VALUE options)
     if (tmp != Qnil) {
         params->cmd.store.flags = (lcb_uint32_t)NUM2ULONG(tmp);
     }
-    tmp = rb_hash_aref(options, cb_sym_format);
-    if (tmp != Qnil) { /* rewrite format bits */
-        params->cmd.store.flags = cb_flags_set_format(params->cmd.store.flags, tmp);
-    }
     tmp = rb_hash_aref(options, cb_sym_ttl);
     if (tmp != Qnil) {
         params->cmd.store.ttl = NUM2ULONG(tmp);
@@ -294,9 +322,15 @@ cb_params_store_parse_options(struct cb_params_st *params, VALUE options)
         rb_funcall(params->bucket->self, cb_id_verify_observe_options, 1, tmp);
         params->cmd.store.observe = tmp;
     }
-    if (cb_flags_get_format(params->cmd.store.flags) == cb_sym_document) {
-        /* just amend datatype for now */
-        params->cmd.store.datatype = 0x01;
+    tmp = rb_hash_aref(options, cb_sym_format);
+    if (tmp != Qnil) {
+        params->cmd.store.transcoder = get_transcoder(params->bucket,
+                tmp, 1, params->cmd.store.transcoder_opts);
+    }
+    tmp = rb_hash_lookup2(options, cb_sym_transcoder, Qundef);
+    if (tmp != Qundef) {
+        params->cmd.store.transcoder = get_transcoder(params->bucket,
+                tmp, 0, params->cmd.store.transcoder_opts);
     }
 }
 
@@ -391,8 +425,13 @@ cb_params_get_parse_options(struct cb_params_st *params, VALUE options)
     }
     tmp = rb_hash_aref(options, cb_sym_format);
     if (tmp != Qnil) {
-        Check_Type(tmp, T_SYMBOL);
-        params->cmd.get.forced_format = tmp;
+        params->cmd.get.transcoder = get_transcoder(params->bucket,
+                tmp, 1, params->cmd.get.transcoder_opts);
+    }
+    tmp = rb_hash_lookup2(options, cb_sym_transcoder, Qundef);
+    if (tmp != Qundef) {
+        params->cmd.get.transcoder = get_transcoder(params->bucket,
+                tmp, 0, params->cmd.get.transcoder_opts);
     }
     tmp = rb_hash_aref(options, cb_sym_ttl);
     if (tmp != Qnil) {
@@ -511,12 +550,14 @@ cb_params_arith_parse_options(struct cb_params_st *params, VALUE options)
         params->cmd.arith.delta = NUM2ULL(tmp) & INT64_MAX;
     }
     tmp = rb_hash_aref(options, cb_sym_format);
-    if (tmp != Qnil) { /* rewrite format bits */
-        params->cmd.arith.format = tmp;
+    if (tmp != Qnil) {
+        params->cmd.arith.transcoder = get_transcoder(params->bucket,
+                tmp, 1, params->cmd.arith.transcoder_opts);
     }
-    if (params->cmd.arith.format == cb_sym_document) {
-        /* just amend datatype for now */
-        params->cmd.arith.datatype = 0x01;
+    tmp = rb_hash_lookup2(options, cb_sym_transcoder, Qundef);
+    if (tmp != Qundef) {
+        params->cmd.arith.transcoder = get_transcoder(params->bucket,
+                tmp, 0, params->cmd.arith.transcoder_opts);
     }
 }
 
@@ -824,22 +865,26 @@ do_params_build(VALUE ptr)
             }
             params->cmd.store.datatype = 0x00;
             params->cmd.store.ttl = params->bucket->default_ttl;
-            params->cmd.store.flags = cb_flags_set_format(params->bucket->default_flags,
-                    params->bucket->default_format);
+            params->cmd.store.flags = params->bucket->default_flags;
             params->cmd.store.observe = Qnil;
+            params->cmd.store.transcoder = params->bucket->transcoder;
+            params->cmd.store.transcoder_opts = rb_hash_new();
             cb_params_store_parse_options(params, opts);
             cb_params_store_parse_arguments(params, argc, argv);
             break;
         case cb_cmd_get:
             params->cmd.get.quiet = params->bucket->quiet;
+            params->cmd.get.transcoder = params->bucket->transcoder;
+            params->cmd.get.transcoder_opts = rb_hash_new();
             cb_params_get_parse_options(params, opts);
             cb_params_get_parse_arguments(params, argc, argv);
             break;
         case cb_cmd_arith:
+            params->cmd.arith.transcoder = params->bucket->transcoder;
+            params->cmd.arith.transcoder_opts = rb_hash_new();
             params->cmd.arith.create = params->bucket->default_arith_create;
             params->cmd.arith.initial = params->bucket->default_arith_init;
             params->cmd.arith.delta = 1;
-            params->cmd.arith.format = params->bucket->default_format;
             params->cmd.arith.ttl = params->bucket->default_ttl;
             if (argc == 2 && TYPE(RARRAY_PTR(argv)[1]) == T_FIXNUM) {
                 /* allow form incr("foo", 1) */

data/ext/couchbase_ext/bucket.c

@@ -215,6 +215,7 @@ do_scan_connection_options(struct cb_bucket_st *bucket, int argc, VALUE *argv)
             arg = rb_hash_aref(opts, cb_sym_default_format);
             if (arg != Qnil) {
                 if (TYPE(arg) == T_FIXNUM) {
+                    rb_warn("numeric argument to :default_format option is deprecated, use symbol");
                     switch (FIX2INT(arg)) {
                         case CB_FMT_DOCUMENT:
                             arg = cb_sym_document;
@@ -227,12 +228,18 @@ do_scan_connection_options(struct cb_bucket_st *bucket, int argc, VALUE *argv)
                             break;
                     }
                 }
-                if (arg == cb_sym_document || arg == cb_sym_marshal || arg == cb_sym_plain) {
-                    bucket->default_format = arg;
-                    bucket->default_flags = cb_flags_set_format(bucket->default_flags, arg);
+                if (arg == cb_sym_document) {
+                    cb_bucket_transcoder_set(bucket->self, cb_mDocument);
+                } else if (arg == cb_sym_marshal) {
+                    cb_bucket_transcoder_set(bucket->self, cb_mMarshal);
+                } else if (arg == cb_sym_plain) {
+                    cb_bucket_transcoder_set(bucket->self, cb_mPlain);
                 }
             }
-            arg = rb_hash_aref(opts, cb_sym_environment);
+            arg = rb_hash_lookup2(opts, cb_sym_transcoder, Qundef);
+            if (arg != Qundef) {
+                cb_bucket_transcoder_set(bucket->self, arg);
+            }
             if (arg != Qnil) {
                 if (arg == cb_sym_production || arg == cb_sym_development) {
                     bucket->environment = arg;
@@ -269,6 +276,13 @@ do_scan_connection_options(struct cb_bucket_st *bucket, int argc, VALUE *argv)
                 }
             }
             bucket->async = RTEST(rb_hash_aref(opts, cb_sym_async));
+            arg = rb_hash_aref(opts, cb_sym_transcoder);
+            if (arg != Qnil) {
+                bucket->default_arith_create = RTEST(arg);
+                if (TYPE(arg) == T_FIXNUM) {
+                    bucket->default_arith_init = NUM2ULL(arg);
+                }
+            }
         } else {
             opts = Qnil;
         }
@@ -448,7 +462,7 @@ cb_bucket_alloc(VALUE klass)
  *     instead.
  *   @option options [String] :password (nil) the password of the user.
  *   @option options [true, false] :quiet (false) the flag controlling if raising
- *     exception when the client executes operations on unexising keys. If it
+ *     exception when the client executes operations on non-existent keys. If it
  *     is +true+ it will raise {Couchbase::Error::NotFound} exceptions. The
  *     default behaviour is to return +nil+ value silently (might be useful in
  *     Rails cache).
@@ -494,8 +508,8 @@ cb_bucket_alloc(VALUE klass)
  * @example Use list of nodes, in case some nodes might be dead
  *   Couchbase.new(:node_list => ['example.com:8091', 'example.org:8091', 'example.net'])
  *
- * @raise [Couchbase::Error::BucketNotFound] if there no such bucket to
- *   connect
+ * @raise [Couchbase::Error::BucketNotFound] if there is no such bucket to
+ *   connect to
  *
  * @raise [Couchbase::Error::Connect] if the socket wasn't accessible
  *   (doesn't accept connections or doesn't respond in time)
@@ -506,7 +520,6 @@ cb_bucket_alloc(VALUE klass)
 cb_bucket_init(int argc, VALUE *argv, VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
-
     bucket->self = self;
     bucket->exception = Qnil;
     bucket->type = LCB_TYPE_BUCKET;
@@ -521,7 +534,7 @@ cb_bucket_init(int argc, VALUE *argv, VALUE self)
     bucket->quiet = 0;
     bucket->default_ttl = 0;
     bucket->default_flags = 0;
-    bucket->default_format = cb_sym_document;
+    cb_bucket_transcoder_set(self, cb_mDocument);
     bucket->default_observe_timeout = 2500000;
     bucket->on_error_proc = Qnil;
     bucket->on_connect_proc = Qnil;
@@ -578,7 +591,7 @@ cb_bucket_init_copy(VALUE copy, VALUE orig)
     copy_b->engine = orig_b->engine;
     copy_b->async = orig_b->async;
     copy_b->quiet = orig_b->quiet;
-    copy_b->default_format = orig_b->default_format;
+    copy_b->transcoder = orig_b->transcoder;
     copy_b->default_flags = orig_b->default_flags;
     copy_b->default_ttl = orig_b->default_ttl;
     copy_b->environment = orig_b->environment;
@@ -707,23 +720,49 @@ cb_bucket_default_flags_set(VALUE self, VALUE val)
     struct cb_bucket_st *bucket = DATA_PTR(self);
 
     bucket->default_flags = (uint32_t)NUM2ULONG(val);
-    bucket->default_format = cb_flags_get_format(bucket->default_flags);
     return val;
 }
 
     VALUE
-cb_bucket_default_format_get(VALUE self)
+cb_bucket_transcoder_get(VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
-    return bucket->default_format;
+    return bucket->transcoder;
 }
 
     VALUE
-cb_bucket_default_format_set(VALUE self, VALUE val)
+cb_bucket_transcoder_set(VALUE self, VALUE val)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
 
+    if (val != Qnil && !rb_respond_to(val, cb_id_dump) && !rb_respond_to(val, cb_id_load)) {
+        rb_raise(rb_eArgError, "transcoder must respond to dump and load methods");
+    }
+    bucket->transcoder = val;
+
+    return bucket->transcoder;
+}
+
+    VALUE
+cb_bucket_default_format_get(VALUE self)
+{
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+
+    if (bucket->transcoder == cb_mDocument) {
+        return cb_sym_document;
+    } else if (bucket->transcoder == cb_mMarshal) {
+        return cb_sym_marshal;
+    } else if (bucket->transcoder == cb_mPlain) {
+        return cb_sym_plain;
+    }
+    return Qnil;
+}
+
+    VALUE
+cb_bucket_default_format_set(VALUE self, VALUE val)
+{
     if (TYPE(val) == T_FIXNUM) {
+        rb_warn("numeric argument to #default_format option is deprecated, use symbol");
         switch (FIX2INT(val)) {
             case CB_FMT_DOCUMENT:
                 val = cb_sym_document;
@@ -736,9 +775,14 @@ cb_bucket_default_format_set(VALUE self, VALUE val)
                 break;
         }
     }
-    if (val == cb_sym_document || val == cb_sym_marshal || val == cb_sym_plain) {
-        bucket->default_format = val;
-        bucket->default_flags = cb_flags_set_format(bucket->default_flags, val);
+    if (val == cb_sym_document) {
+        cb_bucket_transcoder_set(self, cb_mDocument);
+    } else if (val == cb_sym_marshal) {
+        cb_bucket_transcoder_set(self, cb_mMarshal);
+    } else if (val == cb_sym_plain) {
+        cb_bucket_transcoder_set(self, cb_mPlain);
+    } else {
+        rb_raise(rb_eArgError, "unknown format");
     }
 
     return val;
@@ -1103,9 +1147,9 @@ cb_bucket_inspect(VALUE self)
     rb_str_append(str, bucket->pool);
     rb_str_buf_cat2(str, "/buckets/");
     rb_str_append(str, bucket->bucket);
-    rb_str_buf_cat2(str, "/");
-    snprintf(buf, 150, "\" default_format=:%s, default_flags=0x%x, quiet=%s, connected=%s, timeout=%u",
-            rb_id2name(SYM2ID(bucket->default_format)),
+    rb_str_buf_cat2(str, "/\" transcoder=");
+    rb_str_append(str, rb_inspect(bucket->transcoder));
+    snprintf(buf, 150, ", default_flags=0x%x, quiet=%s, connected=%s, timeout=%u",
             bucket->default_flags,
             bucket->quiet ? "true" : "false",
             (bucket->handle && bucket->connected) ? "true" : "false",

data/ext/couchbase_ext/context.c

@@ -25,7 +25,8 @@ cb_context_mark(void *p, struct cb_bucket_st* bucket)
     rb_gc_mark(ctx->rv);
     rb_gc_mark(ctx->exception);
     rb_gc_mark(ctx->observe_options);
-    rb_gc_mark(ctx->force_format);
+    rb_gc_mark(ctx->transcoder);
+    rb_gc_mark(ctx->transcoder_opts);
     rb_gc_mark(ctx->operation);
     rb_gc_mark(ctx->headers_val);
     (void)bucket;

data/ext/couchbase_ext/couchbase_ext.c

@@ -27,8 +27,10 @@ VALUE cb_cTimer;
 /* Modules */
 VALUE cb_mCouchbase;
 VALUE cb_mError;
+VALUE cb_mTranscoder;
+VALUE cb_mDocument;
+VALUE cb_mPlain;
 VALUE cb_mMarshal;
-VALUE cb_mMultiJson;
 VALUE cb_mURI;
 VALUE em_m;
 
@@ -62,6 +64,7 @@ ID cb_sym_eventmachine;
 ID cb_sym_extended;
 ID cb_sym_flags;
 ID cb_sym_format;
+ID cb_sym_forced;
 ID cb_sym_found;
 ID cb_sym_get;
 ID cb_sym_hostname;
@@ -97,6 +100,7 @@ ID cb_sym_set;
 ID cb_sym_stats;
 ID cb_sym_timeout;
 ID cb_sym_touch;
+ID cb_sym_transcoder;
 ID cb_sym_ttl;
 ID cb_sym_type;
 ID cb_sym_unlock;
@@ -201,10 +205,12 @@ Init_couchbase_ext(void)
     /* just a holder for EventMachine module */
     em_m = 0;
 
-    cb_mMultiJson = rb_const_get(rb_cObject, rb_intern("MultiJson"));
     cb_mURI = rb_const_get(rb_cObject, rb_intern("URI"));
-    cb_mMarshal = rb_const_get(rb_cObject, rb_intern("Marshal"));
     cb_mCouchbase = rb_define_module("Couchbase");
+    cb_mTranscoder = rb_const_get(cb_mCouchbase, rb_intern("Transcoder"));
+    cb_mDocument = rb_const_get(cb_mTranscoder, rb_intern("Document"));
+    cb_mMarshal = rb_const_get(cb_mTranscoder, rb_intern("Marshal"));
+    cb_mPlain = rb_const_get(cb_mTranscoder, rb_intern("Plain"));
 
     cb_mError = rb_define_module_under(cb_mCouchbase, "Error");
     /* Document-class: Couchbase::Error::Base
@@ -285,8 +291,6 @@ Init_couchbase_ext(void)
     /* Document-class: Couchbase::Error::NoMemory
      * Out of memory error (on Server)
      *
-     * The client ran out of memory
-     *
      * @since 1.0.0
      */
     cb_eNoMemoryError = rb_define_class_under(cb_mError, "NoMemory", cb_eBaseError);
@@ -761,6 +765,50 @@ Init_couchbase_ext(void)
     rb_define_method(cb_cBucket, "default_flags", cb_bucket_default_flags_get, 0);
     rb_define_method(cb_cBucket, "default_flags=", cb_bucket_default_flags_set, 1);
 
+    /* Document-method: transcoder
+     * Set data transcoder for the current connection
+     *
+     * @since 1.2.4
+     *
+     * It is possible to define custom transcoder to handle all value
+     * transformation, for example, if you need to adopt legacy
+     * application. The transcoder should respond to two methods:
+     * +dump+ and +load+. They are accepting the data itself, the
+     * flags field, and the options hash from the library.
+     *
+     *  @example Simple data transcoder, which use Zlib to compress documents
+     *    class ZlibTranscoder
+     *      FMT_ZLIB = 0x04
+     *
+     *      def initialize(base)
+     *        @base = base
+     *      end
+     *
+     *      def dump(obj, flags, options = {})
+     *        obj, flags = @base.dump(obj, flags, options)
+     *        z = Zlib::Deflate.new(Zlib::BEST_SPEED)
+     *        buffer = z.deflate(obj, Zlib::FINISH)
+     *        z.close
+     *        [buffer, flags|FMT_ZLIB]
+     *      end
+     *
+     *      def load(blob, flags, options = {})
+     *        # decompress value only if Zlib flag set
+     *        if (flags & FMT_ZLIB) == FMT_ZLIB
+     *          z = Zlib::Inflate.new
+     *          blob = z.inflate(blob)
+     *          z.finish
+     *          z.close
+     *        end
+     *        @base.load(blob, flags, options)
+     *      end
+     *    end
+     *
+     * @return [Object] the data transcoder */
+    /* rb_define_attr(cb_cBucket, "transcoder", 1, 1); */
+    rb_define_method(cb_cBucket, "transcoder", cb_bucket_transcoder_get, 0);
+    rb_define_method(cb_cBucket, "transcoder=", cb_bucket_transcoder_set, 1);
+
     /* Document-method: default_format
      * Default format for new values.
      *
@@ -789,11 +837,11 @@ Init_couchbase_ext(void)
      *   your ruby object with standard <tt>Marshal.dump</tt> and
      *   <tt>Marhal.load</tt> methods.
      *
-     * @example Selecting plain format using cb_symbol
-     *   connection.format = :document
+     * @example Selecting 'plain' format using symbol
+     *   connection.default_format = :plain
      *
-     * @example Selecting plain format using Fixnum constant
-     *   connection.format = Couchbase::Bucket::FMT_PLAIN
+     * @example Selecting plain format using Fixnum constant (deprecated)
+     *   connection.default_format = Couchbase::Bucket::FMT_PLAIN
      *
      * @note Amending default_format will also change #default_flags value
      *
@@ -1130,6 +1178,7 @@ Init_couchbase_ext(void)
     cb_sym_extended = ID2SYM(rb_intern("extended"));
     cb_sym_flags = ID2SYM(rb_intern("flags"));
     cb_sym_format = ID2SYM(rb_intern("format"));
+    cb_sym_forced = ID2SYM(rb_intern("forced"));
     cb_sym_found = ID2SYM(rb_intern("found"));
     cb_sym_get = ID2SYM(rb_intern("get"));
     cb_sym_hostname = ID2SYM(rb_intern("hostname"));
@@ -1165,6 +1214,7 @@ Init_couchbase_ext(void)
     cb_sym_stats = ID2SYM(rb_intern("stats"));
     cb_sym_timeout = ID2SYM(rb_intern("timeout"));
     cb_sym_touch = ID2SYM(rb_intern("touch"));
+    cb_sym_transcoder = ID2SYM(rb_intern("transcoder"));
     cb_sym_ttl = ID2SYM(rb_intern("ttl"));
     cb_sym_type = ID2SYM(rb_intern("type"));
     cb_sym_unlock = ID2SYM(rb_intern("unlock"));