sparsam 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c47d8f62e5244736a0f3e8e0e02f1f0104d3fb41982da0ca598940d2bfb6bc52
-  data.tar.gz: fe43b9eb4b3167adec9d435269a14ab90b08f4518f9c242875555a144fe3a689
+  metadata.gz: 5df1feed622f050f564cd17dd088ae575a544b1b26511f19b2bb8cec3d46d34a
+  data.tar.gz: 85622057c2fd20ef6af4e325a62a61858f6c0d73d8575b3a42cbf3871c0df86b
 SHA512:
-  metadata.gz: a62b9bc043e205badb26495651e918b6ff14c6ab3574b2fbf5cbdc00ca61cd1f1bbd7f44ea18ebd40673bde1fffbff57e981cd3db532ffba43451b7e8d71e3b5
-  data.tar.gz: 6d6454f006da2089124019b176d5e916b2a1ff77ff67731601e18cf64275f224afc234b9bd27a5d10ff687992163743bcf804b153cc00526d51155786eb77171
+  metadata.gz: f872a492fd9870cac0a19bd58fb458f02a7d0bc619e0a892aa7a6415c2a2d91d161634f390167f33ee67ed870ba42bafea5678f616f40d413b6e2e23c7e181f7
+  data.tar.gz: bbb8fd020a8bced074581523ee6bab24669ad88f244797957deac3b774a57d3c00425e6975ae9ba40925c04b56e1e91f6ff49b5bedec7bfd0b690cc3bfc18a0d

data/ext/ruby_hooks.c

@@ -1,7 +1,7 @@
-#include "stdio.h"
 #include <ruby.h>
 #include <ruby/intern.h>
 #include "serializer.h"
+#include "stdio.h"
 
 VALUE Sparsam = Qnil;
 VALUE static_zero_array;
@@ -11,10 +11,10 @@ ID intern_for_DEFAULT_VALUES;
 ID intern_for_assign_defaults;
 ID intern_for_assign_from_arg;
 
-static void deallocate(void *data) { serializer_free(data); }
+static void deallocate(void* data) { serializer_free(data); }
 
 static VALUE allocate(VALUE klass) {
-  void *data = serializer_create();
+  void* data = serializer_create();
   return Data_Wrap_Struct(klass, NULL, deallocate, data);
 }
 
@@ -24,8 +24,8 @@ static VALUE sparsam_init_bang(VALUE self) {
 }
 
 static VALUE initialize(VALUE self, VALUE type_arg, VALUE str_arg) {
-  void *self_data = NULL;
-  void *input_string = NULL;
+  void* self_data = NULL;
+  void* input_string = NULL;
 
   Check_Type(type_arg, T_FIXNUM);
   int prot = NUM2INT(type_arg);
@@ -38,7 +38,7 @@ static VALUE initialize(VALUE self, VALUE type_arg, VALUE str_arg) {
     memcpy(input_string, StringValuePtr(str_arg), len);
   }
 
-  Data_Get_Struct(self, void *, self_data);
+  Data_Get_Struct(self, void*, self_data);
   serializer_init(self_data, prot, input_string, len);
 
   return self;
@@ -46,7 +46,8 @@ static VALUE initialize(VALUE self, VALUE type_arg, VALUE str_arg) {
 
 VALUE sparsam_struct_initialize(int argc, VALUE* argv, VALUE self) {
   if (argc > 1) {
-    rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 0..1)", argc);
+    rb_raise(rb_eArgError,
+             "wrong number of arguments (given %d, expected 0..1)", argc);
   }
 
   VALUE defaults = rb_const_get(rb_obj_class(self), intern_for_DEFAULT_VALUES);
@@ -70,14 +71,16 @@ void Init_sparsam_native() {
   Sparsam = rb_define_module("Sparsam");
   rb_define_singleton_method(Sparsam, "init!", sparsam_init_bang, 0);
   rb_define_singleton_method(Sparsam, "cache_fields", cache_fields, 1);
-  VALUE SparsamSerializer = rb_define_class_under(Sparsam, "Serializer", rb_cObject);
+  VALUE SparsamSerializer =
+      rb_define_class_under(Sparsam, "Serializer", rb_cObject);
   SparsamNativeError =
       rb_define_class_under(Sparsam, "Exception", rb_eStandardError);
   rb_define_alloc_func(SparsamSerializer, allocate);
   rb_define_method(SparsamSerializer, "initialize", initialize, 2);
   rb_define_method(SparsamSerializer, "serialize", serializer_writeStruct, 2);
   rb_define_method(SparsamSerializer, "deserialize", serializer_readStruct, 1);
-  rb_define_method(SparsamSerializer, "deserializeUnion", serializer_readUnion, 1);
+  rb_define_method(SparsamSerializer, "deserializeUnion", serializer_readUnion,
+                   1);
   rb_define_const(Sparsam, "CompactProtocol", INT2FIX(compact));
   rb_define_const(Sparsam, "BinaryProtocol", INT2FIX(binary));
   rb_define_const(Sparsam, "UNION", INT2FIX(t_union));
@@ -90,8 +93,9 @@ void Init_sparsam_native() {
   intern_for_assign_defaults = rb_intern("assign_defaults");
   intern_for_assign_from_arg = rb_intern("assign_from_arg");
 
-
-  VALUE SparsamStructInitialization = rb_define_module_under(Sparsam, "StructInitialization");
-  rb_define_method(SparsamStructInitialization, "initialize", sparsam_struct_initialize, -1);
+  VALUE SparsamStructInitialization =
+      rb_define_module_under(Sparsam, "StructInitialization");
+  rb_define_method(SparsamStructInitialization, "initialize",
+                   sparsam_struct_initialize, -1);
   initialize_constants();
 }

data/ext/serializer.cpp

@@ -2,15 +2,15 @@ extern "C" {
 #include <ruby.h>
 #include <ruby/intern.h>
 }
-#include "serializer.h"
-#include <functional>
-#include <map>
 #include <ruby/encoding.h>
 #include <stdio.h>
 #include <thrift/protocol/TBinaryProtocol.h>
 #include <thrift/protocol/TCompactProtocol.h>
 #include <boost/make_shared.hpp>
+#include <functional>
+#include <map>
 #include <vector>
+#include "serializer.h"
 
 using namespace std;
 using ::apache::thrift::protocol::TType;
@@ -48,7 +48,7 @@ VALUE SparsamUnknownTypeException;
 
 VALUE SetClass;
 
-KlassFieldsCache klassCache; // consider the memory leaked.
+KlassFieldsCache klassCache;  // consider the memory leaked.
 std::unordered_set<VALUE> unions;
 
 void *serializer_create() { return (void *)(new ThriftSerializer()); }
@@ -83,8 +83,10 @@ void initialize_constants() {
 
 void initialize_runtime_constants() {
   klass_for_union = rb_const_get_at(Sparsam, rb_intern("Union"));
-  SparsamMissingMandatory = rb_const_get_at(Sparsam, rb_intern("MissingMandatory"));
-  SparsamTypeMismatchError = rb_const_get_at(Sparsam, rb_intern("TypeMismatch"));
+  SparsamMissingMandatory =
+      rb_const_get_at(Sparsam, rb_intern("MissingMandatory"));
+  SparsamTypeMismatchError =
+      rb_const_get_at(Sparsam, rb_intern("TypeMismatch"));
   SparsamUnionException = rb_const_get_at(Sparsam, rb_intern("UnionException"));
   SparsamUnknownTypeException =
       rb_const_get_at(Sparsam, rb_intern("UnknownTypeException"));
@@ -93,19 +95,16 @@ void initialize_runtime_constants() {
 
 void serializer_init(void *serializer, int protocol, void *str_arg1,
                      uint32_t len) {
-  using ::boost::shared_ptr;
-  using ::apache::thrift::protocol::TProtocol;
   using ::apache::thrift::protocol::TBinaryProtocol;
   using ::apache::thrift::protocol::TCompactProtocol;
+  using ::apache::thrift::protocol::TProtocol;
+  using ::boost::shared_ptr;
 
   ThriftSerializer *ts = (ThriftSerializer *)(serializer);
   shared_ptr<TMemoryBuffer> strBuffer;
   if (str_arg1 != NULL) {
     strBuffer = boost::make_shared<TMemoryBuffer>(
-      (uint8_t *)str_arg1,
-      len,
-      TMemoryBuffer::TAKE_OWNERSHIP
-    );
+        (uint8_t *)str_arg1, len, TMemoryBuffer::TAKE_OWNERSHIP);
   } else {
     strBuffer = boost::make_shared<TMemoryBuffer>();
   }
@@ -120,21 +119,19 @@ void serializer_init(void *serializer, int protocol, void *str_arg1,
   ts->tmb = strBuffer;
 }
 
-#define get_ts()                                                               \
-  void *self_data = NULL;                                                      \
-  Data_Get_Struct(self, void, self_data);                                      \
+#define get_ts()                          \
+  void *self_data = NULL;                 \
+  Data_Get_Struct(self, void, self_data); \
   ThriftSerializer *ts = (ThriftSerializer *)(self_data);
 
 #define watch_for_texcept() try {
-
-#define catch_thrift_and_reraise()                                             \
-  }                                                                            \
-  catch (::apache::thrift::TException e) {                                     \
-    rb_raise(SparsamNativeError, "%s", e.what());                              \
-    return Qnil;                                                               \
+#define catch_thrift_and_reraise()                \
+  }                                               \
+  catch (::apache::thrift::TException e) {        \
+    rb_raise(SparsamNativeError, "%s", e.what()); \
+    return Qnil;                                  \
   }
 
-
 static inline VALUE make_ruby_string(const string &val) {
   return rb_enc_str_new(val.c_str(), val.size(), rb_utf8_encoding());
 }
@@ -143,43 +140,58 @@ static inline VALUE make_ruby_binary(const string &val) {
   return rb_str_new(val.c_str(), val.size());
 }
 
-static void raise_exc_with_struct_and_field_names(
-        VALUE exc_class,
-        VALUE msg_prefix,
-        VALUE outer_struct_class,
-        VALUE field_sym) {
+static void raise_exc_with_struct_and_field_names(VALUE exc_class,
+                                                  VALUE msg_prefix,
+                                                  VALUE outer_struct_class,
+                                                  VALUE field_sym) {
   VALUE struct_name = rb_class_name(outer_struct_class);
   VALUE field_name = rb_sym_to_s(field_sym);
 
-  VALUE msg = rb_sprintf("%s (in %s#%s)",
-      RSTRING_PTR(msg_prefix),
-      RSTRING_PTR(struct_name),
-      RSTRING_PTR(field_name));
+  VALUE msg = rb_sprintf("%s (in %s#%s)", RSTRING_PTR(msg_prefix),
+                         RSTRING_PTR(struct_name), RSTRING_PTR(field_name));
   VALUE args[3] = {msg, struct_name, field_name};
   VALUE e = rb_class_new_instance(3, args, exc_class);
   rb_exc_raise(e);
 }
 
-static void raise_type_mismatch(VALUE outer_struct, VALUE field_sym) {
-    raise_exc_with_struct_and_field_names(
-      SparsamTypeMismatchError,
-      rb_str_new2("Mismatched type"),
-      CLASS_OF(outer_struct),
-      field_sym);
+static void raise_type_mismatch(VALUE outer_struct, VALUE field_sym,
+                                const char *expected, VALUE actual) {
+  VALUE actual_name = rb_class_name(CLASS_OF(actual));
+  VALUE msg = rb_sprintf(
+      "Mismatched type (expected to be compatible with: %s, found: %s)",
+      expected, RSTRING_PTR(actual_name));
+
+  raise_exc_with_struct_and_field_names(SparsamTypeMismatchError, msg,
+                                        CLASS_OF(outer_struct), field_sym);
+}
+
+static void raise_type_mismatch(VALUE outer_struct, VALUE field_sym, int ttype,
+                                VALUE actual) {
+  raise_type_mismatch(outer_struct, field_sym, TTypeName((size_t)ttype).c_str(),
+                      actual);
 }
 
-static inline long raise_type_mismatch_as_value(VALUE outer_struct, VALUE field_sym) {
-  raise_type_mismatch(outer_struct, field_sym);
+static void raise_type_mismatch(VALUE outer_struct, VALUE field_sym,
+                                VALUE klass, VALUE actual) {
+  VALUE expected_name = rb_class_name(klass);
+  raise_type_mismatch(outer_struct, field_sym, RSTRING_PTR(expected_name),
+                      actual);
+}
+
+static inline long raise_type_mismatch_as_value(VALUE outer_struct,
+                                                VALUE field_sym, int ttype,
+                                                VALUE actual) {
+  raise_type_mismatch(outer_struct, field_sym, ttype, actual);
   return 0;
 }
 
-static inline void Sparsam_Check_Type(VALUE x, int t, VALUE outer_struct, VALUE field_sym) {
+static inline void Sparsam_Check_Type(VALUE x, int t, VALUE outer_struct,
+                                      VALUE field_sym) {
   if (!(RB_TYPE_P(x, t))) {
-    raise_type_mismatch(outer_struct, field_sym);
+    raise_type_mismatch(outer_struct, field_sym, t, x);
   }
 }
 
-
 static inline VALUE make_ruby_bool(bool val) { return val ? Qtrue : Qfalse; }
 
 void ThriftSerializer::skip_n_type(uint32_t n, TType ttype) {
@@ -198,18 +210,17 @@ void ThriftSerializer::skip_n_pair(uint32_t n, TType type_a, TType type_b) {
 // Blatantly copied protobuf's design
 // https://git.io/vHuUn
 // CONVERT is new here, because we're targeting ruby
-#define HANDLE_TYPE(TYPE, CPPTYPE, READ_METHOD, CONVERT)                       \
-  case protocol::T_##TYPE: {                                                   \
-    CPPTYPE value;                                                             \
-    this->tprot->read##READ_METHOD(value);                                     \
-    ret = CONVERT(value);                                                      \
-    break;                                                                     \
+#define HANDLE_TYPE(TYPE, CPPTYPE, READ_METHOD, CONVERT) \
+  case protocol::T_##TYPE: {                             \
+    CPPTYPE value;                                       \
+    this->tprot->read##READ_METHOD(value);               \
+    ret = CONVERT(value);                                \
+    break;                                               \
   }
 
 VALUE ThriftSerializer::readAny(TType ttype, FieldInfo *field_info) {
   VALUE ret = Qnil;
   switch (ttype) {
-
     // Handle all the non-container types by marco
     HANDLE_TYPE(I16, int16_t, I16, INT2FIX)
     HANDLE_TYPE(I32, int32_t, I32, INT2FIX)
@@ -218,99 +229,100 @@ VALUE ThriftSerializer::readAny(TType ttype, FieldInfo *field_info) {
     HANDLE_TYPE(DOUBLE, double, Double, DBL2NUM)
     HANDLE_TYPE(BYTE, int8_t, Byte, INT2FIX)
 
-  case protocol::T_STRING: {
-    string value;
-    if (field_info->isBinaryString) { // if (field_info[:binary])
-      this->tprot->readBinary(value);
-      ret = make_ruby_binary(value);
-    } else {
-      this->tprot->readString(value);
-      ret = make_ruby_string(value);
+    case protocol::T_STRING: {
+      string value;
+      if (field_info->isBinaryString) {  // if (field_info[:binary])
+        this->tprot->readBinary(value);
+        ret = make_ruby_binary(value);
+      } else {
+        this->tprot->readString(value);
+        ret = make_ruby_string(value);
+      }
+      break;
     }
-    break;
-  }
 
-  case protocol::T_LIST: {
-    TType element_type;
-    uint32_t size;
+    case protocol::T_LIST: {
+      TType element_type;
+      uint32_t size;
 
-    this->tprot->readListBegin(element_type, size);
-    if (field_info->elementType == NULL ||
-        element_type != field_info->elementType->ftype) {
-      this->skip_n_type(size, element_type);
-      break;
-    }
-    ret = rb_ary_new2(size);
+      this->tprot->readListBegin(element_type, size);
+      if (field_info->elementType == NULL ||
+          element_type != field_info->elementType->ftype) {
+        this->skip_n_type(size, element_type);
+        break;
+      }
+      ret = rb_ary_new2(size);
 
-    for (uint32_t i = 0; i < size; i++) {
-      rb_ary_store(ret, i,
-                   this->readAny(element_type, field_info->elementType));
+      for (uint32_t i = 0; i < size; i++) {
+        rb_ary_store(ret, i,
+                     this->readAny(element_type, field_info->elementType));
+      }
+      this->tprot->readListEnd();
+
+      break;
     }
-    this->tprot->readListEnd();
 
-    break;
-  }
+    case protocol::T_SET: {
+      TType element_type;
+      uint32_t size;
 
-  case protocol::T_SET: {
-    TType element_type;
-    uint32_t size;
+      this->tprot->readSetBegin(element_type, size);
+      if (field_info->elementType == NULL ||
+          element_type != field_info->elementType->ftype) {
+        this->skip_n_type(size, element_type);
+        break;
+      }
+      VALUE ary = rb_ary_new2(size);
 
-    this->tprot->readSetBegin(element_type, size);
-    if (field_info->elementType == NULL ||
-        element_type != field_info->elementType->ftype) {
-      this->skip_n_type(size, element_type);
+      for (uint32_t i = 0; i < size; i++) {
+        rb_ary_store(ary, i,
+                     this->readAny(element_type, field_info->elementType));
+      }
+      ret = rb_class_new_instance(1, &ary, klass_for_set);
+      this->tprot->readSetEnd();
       break;
     }
-    VALUE ary = rb_ary_new2(size);
 
-    for (uint32_t i = 0; i < size; i++) {
-      rb_ary_store(ary, i,
-                   this->readAny(element_type, field_info->elementType));
+    case protocol::T_STRUCT: {
+      string cname;
+      this->tprot->readStructBegin(cname);
+      if (unions.count(field_info->klass) == 1) {
+        ret = this->readUnion(field_info->klass);
+      } else {
+        ret = this->readStruct(field_info->klass);
+      }
+      this->tprot->readStructEnd();
+      break;
     }
-    ret = rb_class_new_instance(1, &ary, klass_for_set);
-    this->tprot->readSetEnd();
-    break;
-  }
 
-  case protocol::T_STRUCT: {
-    string cname;
-    this->tprot->readStructBegin(cname);
-    if (unions.count(field_info->klass) == 1) {
-      ret = this->readUnion(field_info->klass);
-    } else {
-      ret = this->readStruct(field_info->klass);
-    }
-    this->tprot->readStructEnd();
-    break;
-  }
+    case protocol::T_MAP: {
+      TType key_type, value_type;
+      uint32_t size;
+      VALUE k, v;
 
-  case protocol::T_MAP: {
-    TType key_type, value_type;
-    uint32_t size;
-    VALUE k, v;
+      this->tprot->readMapBegin(key_type, value_type, size);
 
-    this->tprot->readMapBegin(key_type, value_type, size);
+      if (field_info->keyType == NULL ||
+          field_info->elementType == NULL) {  // no type check to be consistent
+        skip_n_pair(size, key_type, value_type);
+        break;
+      }
 
-    if (field_info->keyType == NULL ||
-        field_info->elementType == NULL) { // no type check to be consistent
-      skip_n_pair(size, key_type, value_type);
+      ret = rb_hash_new();
+      for (uint32_t i = 0; i < size; i++) {
+        k = this->readAny(key_type, field_info->keyType);
+        v = this->readAny(value_type, field_info->elementType);
+        rb_hash_aset(ret, k, v);
+      }
+      this->tprot->readMapEnd();
       break;
     }
 
-    ret = rb_hash_new();
-    for (uint32_t i = 0; i < size; i++) {
-      k = this->readAny(key_type, field_info->keyType);
-      v = this->readAny(value_type, field_info->elementType);
-      rb_hash_aset(ret, k, v);
-    }
-    this->tprot->readMapEnd();
-    break;
-  }
-
-  default:
-    this->tprot->skip(ttype);
-    rb_raise(SparsamUnknownTypeException, "Received unknown type with id: %d", ttype);
-    break;
+    default:
+      this->tprot->skip(ttype);
+      rb_raise(SparsamUnknownTypeException, "Received unknown type with id: %d",
+               ttype);
+      break;
   }
 
   return ret;
@@ -319,12 +331,11 @@ VALUE ThriftSerializer::readAny(TType ttype, FieldInfo *field_info) {
 #undef HANDLE_TYPE
 
 VALUE ThriftSerializer::readStruct(VALUE klass) {
-
   string cname;
   FieldBegin fieldBegin;
   TType typeId;
   FieldInfo *fieldInfo;
-  VALUE ret = rb_class_new_instance(0, NULL, klass); // ret = &klass.new
+  VALUE ret = rb_class_new_instance(0, NULL, klass);  // ret = &klass.new
   auto fields = FindOrCreateFieldInfoMap(klass);
 
   while (true) {
@@ -346,10 +357,11 @@ VALUE ThriftSerializer::readStruct(VALUE klass) {
 
     if (typeId != fieldBegin.ftype) {
       raise_exc_with_struct_and_field_names(
-        SparsamTypeMismatchError,
-        rb_sprintf("Mismatched type (definition: %d, found: %d)", fieldBegin.ftype, typeId),
-        klass,
-        fieldInfo->symName);
+          SparsamTypeMismatchError,
+          rb_sprintf("Mismatched type (definition: %s, found: %s)",
+                     TTypeName(fieldBegin.ftype).c_str(),
+                     TTypeName(typeId).c_str()),
+          klass, fieldInfo->symName);
     }
 
     VALUE rb_value = this->readAny(fieldBegin.ftype, iter->second);
@@ -366,7 +378,7 @@ VALUE ThriftSerializer::readUnion(VALUE klass) {
   string cname;
   FieldBegin fieldBegin;
 
-  VALUE ret = rb_class_new_instance(0, NULL, klass); // ret = &klass.new
+  VALUE ret = rb_class_new_instance(0, NULL, klass);  // ret = &klass.new
   auto fields = FindOrCreateFieldInfoMap(klass);
 
   VALUE key, rb_value;
@@ -404,23 +416,22 @@ VALUE ThriftSerializer::readUnion(VALUE klass) {
 // for the unary `+` before lambda:
 // https://stackoverflow.com/a/18889029/4944625
 // explicit cast to work with signature: (int (*)(...))
-#define HASH_FOREACH_BEGIN(hash, ...)                                          \
-  void *_args[] = {__VA_ARGS__};                                               \
+#define HASH_FOREACH_BEGIN(hash, ...) \
+  void *_args[] = {__VA_ARGS__};      \
   rb_hash_foreach(hash, (int (*)(ANYARGS))(+[](VALUE k, VALUE v, VALUE args) { \
     void **argv = (void **) args;
-
 #define HASH_FOREACH_RET() return (int)ST_CONTINUE;
 
 #define HASH_FOREACH_ABORT() return (int)ST_STOP;
 
-#define HASH_FOREACH_END()                                                     \
-  HASH_FOREACH_RET()                                                           \
+#define HASH_FOREACH_END() \
+  HASH_FOREACH_RET()       \
   }), (VALUE) _args);
 
-#define HANDLE_TYPE(TYPE, WRITE_METHOD, CONVERT)                               \
-  case protocol::T_##TYPE: {                                                   \
-    this->tprot->write##WRITE_METHOD(CONVERT);                                 \
-    break;                                                                     \
+#define HANDLE_TYPE(TYPE, WRITE_METHOD, CONVERT) \
+  case protocol::T_##TYPE: {                     \
+    this->tprot->write##WRITE_METHOD(CONVERT);   \
+    break;                                       \
   }
 
 static inline long raise_bignum_range_error_as_value() {
@@ -428,19 +439,21 @@ static inline long raise_bignum_range_error_as_value() {
   return 0;
 }
 
-#define CONVERT_FIXNUM(CONVERT)                                                \
-  ((FIXNUM_P(actual)) ?                                                        \
-    CONVERT(actual) :                                                          \
-    ((RB_TYPE_P(actual, T_BIGNUM)) ?                                           \
-      raise_bignum_range_error_as_value() :                                    \
-      raise_type_mismatch_as_value(outer_struct, field_sym)))
-
-#define CONVERT_I64                                                            \
-  ((FIXNUM_P(actual)) ?                                                        \
-    (LONG_LONG)FIX2LONG(actual) :                                              \
-    ((RB_TYPE_P(actual, T_BIGNUM)) ?                                           \
-      rb_big2ll(actual) :                                                      \
-      raise_type_mismatch_as_value(outer_struct, field_sym)))
+#define CONVERT_FIXNUM(CONVERT, INTENDED)                             \
+  ((FIXNUM_P(actual))                                                 \
+       ? CONVERT(actual)                                              \
+       : ((RB_TYPE_P(actual, T_BIGNUM))                               \
+              ? raise_bignum_range_error_as_value()                   \
+              : raise_type_mismatch_as_value(outer_struct, field_sym, \
+                                             INTENDED, actual)))
+
+#define CONVERT_I64                                                   \
+  ((FIXNUM_P(actual))                                                 \
+       ? (LONG_LONG)FIX2LONG(actual)                                  \
+       : ((RB_TYPE_P(actual, T_BIGNUM))                               \
+              ? rb_big2ll(actual)                                     \
+              : raise_type_mismatch_as_value(outer_struct, field_sym, \
+                                             protocol::T_I64, actual)))
 
 #ifdef RB_FLOAT_TYPE_P
 #define FLOAT_TYPE_P(x) RB_FLOAT_TYPE_P(x)
@@ -448,19 +461,21 @@ static inline long raise_bignum_range_error_as_value() {
 #define FLOAT_TYPE_P(x) RB_TYPE_P(x, T_FLOAT)
 #endif
 
-#define CONVERT_FLOAT(CONVERT)                                                 \
-  ((FLOAT_TYPE_P(actual)) ?                                                    \
-   CONVERT(actual) :                                                           \
-   raise_type_mismatch_as_value(outer_struct, field_sym))                      \
+#define CONVERT_FLOAT(CONVERT)                                 \
+  ((FLOAT_TYPE_P(actual))                                      \
+       ? CONVERT(actual)                                       \
+       : raise_type_mismatch_as_value(outer_struct, field_sym, \
+                                      protocol::T_DOUBLE, actual))
 
-static inline bool convertBool(VALUE actual, VALUE outer_struct, VALUE field_sym) {
+static inline bool convertBool(VALUE actual, VALUE outer_struct,
+                               VALUE field_sym) {
   switch (actual) {
     case Qtrue:
       return true;
     case Qfalse:
       return false;
     default:
-      raise_type_mismatch(outer_struct, field_sym);
+      raise_type_mismatch(outer_struct, field_sym, protocol::T_BOOL, actual);
   }
 
   /* unreachable */
@@ -477,7 +492,7 @@ static inline char byte_convert(VALUE x) {
   short s = SHORT_CONVERT(x);
 
   if (s <= 127 && s >= -128) {
-    return (char) s;
+    return (char)s;
   } else {
     rb_raise(rb_eRangeError, "integer %d out of range for char", s);
   }
@@ -487,89 +502,94 @@ static inline char byte_convert(VALUE x) {
 }
 
 void ThriftSerializer::writeAny(TType ttype, FieldInfo *field_info,
-                                VALUE actual, VALUE outer_struct, VALUE field_sym) {
+                                VALUE actual, VALUE outer_struct,
+                                VALUE field_sym) {
   switch (ttype) {
-    HANDLE_TYPE(I16, I16, CONVERT_FIXNUM(SHORT_CONVERT))
-    HANDLE_TYPE(I32, I32, CONVERT_FIXNUM(FIX2INT))
+    HANDLE_TYPE(I16, I16, CONVERT_FIXNUM(SHORT_CONVERT, protocol::T_I16))
+    HANDLE_TYPE(I32, I32, CONVERT_FIXNUM(FIX2INT, protocol::T_I32))
     HANDLE_TYPE(I64, I64, CONVERT_I64)
     HANDLE_TYPE(BOOL, Bool, convertBool(actual, outer_struct, field_sym))
     HANDLE_TYPE(DOUBLE, Double, CONVERT_FLOAT(NUM2DBL))
-    HANDLE_TYPE(BYTE, Byte, CONVERT_FIXNUM(byte_convert))
+    HANDLE_TYPE(BYTE, Byte, CONVERT_FIXNUM(byte_convert, protocol::T_BYTE))
 
-  case protocol::T_STRING: {
-    Sparsam_Check_Type(actual, T_STRING, outer_struct, field_sym);
+    case protocol::T_STRING: {
+      Sparsam_Check_Type(actual, T_STRING, outer_struct, field_sym);
 
-    string data = string(StringValuePtr(actual), RSTRING_LEN(actual));
-    if (field_info->isBinaryString) {
-      this->tprot->writeBinary(data);
-    } else {
-      this->tprot->writeString(data);
+      string data = string(StringValuePtr(actual), RSTRING_LEN(actual));
+      if (field_info->isBinaryString) {
+        this->tprot->writeBinary(data);
+      } else {
+        this->tprot->writeString(data);
+      }
+      break;
     }
-    break;
-  }
 
-  case protocol::T_LIST: {
-    Sparsam_Check_Type(actual, T_ARRAY, outer_struct, field_sym);
+    case protocol::T_LIST: {
+      Sparsam_Check_Type(actual, T_ARRAY, outer_struct, field_sym);
 
-    long length = RARRAY_LEN(actual);
-    TType elem = field_info->elementType->ftype;
-    this->tprot->writeListBegin(elem, static_cast<size_t>(length));
-    for (long i = 0; i < length; i++) {
-      this->writeAny(elem, field_info->elementType, rb_ary_entry(actual, i), outer_struct, field_sym);
+      long length = RARRAY_LEN(actual);
+      TType elem = field_info->elementType->ftype;
+      this->tprot->writeListBegin(elem, static_cast<size_t>(length));
+      for (long i = 0; i < length; i++) {
+        this->writeAny(elem, field_info->elementType, rb_ary_entry(actual, i),
+                       outer_struct, field_sym);
+      }
+      this->tprot->writeListEnd();
+      break;
     }
-    this->tprot->writeListEnd();
-    break;
-  }
 
-  case protocol::T_SET: {
-    if (rb_class_real(CLASS_OF(actual)) != SetClass) {
-      raise_type_mismatch(outer_struct, field_sym);
+    case protocol::T_SET: {
+      if (rb_class_real(CLASS_OF(actual)) != SetClass) {
+        raise_type_mismatch(outer_struct, field_sym, protocol::T_SET, actual);
+      }
+
+      VALUE ary = rb_funcall(actual, intern_for_to_a, 0);
+      long length = RARRAY_LEN(ary);
+      TType elem = field_info->elementType->ftype;
+      this->tprot->writeListBegin(elem, static_cast<size_t>(length));
+      for (long i = 0; i < length; i++) {
+        this->writeAny(elem, field_info->elementType, rb_ary_entry(ary, i),
+                       outer_struct, field_sym);
+      }
+      this->tprot->writeListEnd();
+      break;
     }
 
-    VALUE ary = rb_funcall(actual, intern_for_to_a, 0);
-    long length = RARRAY_LEN(ary);
-    TType elem = field_info->elementType->ftype;
-    this->tprot->writeListBegin(elem, static_cast<size_t>(length));
-    for (long i = 0; i < length; i++) {
-      this->writeAny(elem, field_info->elementType, rb_ary_entry(ary, i), outer_struct, field_sym);
+    case protocol::T_MAP: {
+      Sparsam_Check_Type(actual, T_HASH, outer_struct, field_sym);
+
+      TType keyTType = field_info->keyType->ftype,
+            valueTType = field_info->elementType->ftype;
+      this->tprot->writeMapBegin(keyTType, valueTType,
+                                 static_cast<size_t>(RHASH_SIZE(actual)));
+      HASH_FOREACH_BEGIN(actual, this, field_info, &outer_struct, &field_sym)
+      ThriftSerializer *that = (ThriftSerializer *)argv[0];
+      FieldInfo *field_info = (FieldInfo *)argv[1];
+      VALUE *outer_struct = (VALUE *)argv[2];
+      VALUE *field_sym = (VALUE *)argv[3];
+      that->writeAny(field_info->keyType->ftype, field_info->keyType, k,
+                     *outer_struct, *field_sym);
+      that->writeAny(field_info->elementType->ftype, field_info->elementType, v,
+                     *outer_struct, *field_sym);
+      HASH_FOREACH_END()
+      this->tprot->writeMapEnd();
+      break;
     }
-    this->tprot->writeListEnd();
-    break;
-  }
 
-  case protocol::T_MAP: {
-    Sparsam_Check_Type(actual, T_HASH, outer_struct, field_sym);
-
-    TType keyTType = field_info->keyType->ftype,
-          valueTType = field_info->elementType->ftype;
-    this->tprot->writeMapBegin(keyTType, valueTType,
-                               static_cast<size_t>(RHASH_SIZE(actual)));
-    HASH_FOREACH_BEGIN(actual, this, field_info, &outer_struct, &field_sym)
-    ThriftSerializer *that = (ThriftSerializer *)argv[0];
-    FieldInfo *field_info = (FieldInfo *)argv[1];
-    VALUE *outer_struct = (VALUE *)argv[2];
-    VALUE *field_sym = (VALUE *)argv[3];
-    that->writeAny(field_info->keyType->ftype, field_info->keyType, k, *outer_struct, *field_sym);
-    that->writeAny(field_info->elementType->ftype, field_info->elementType, v, *outer_struct, *field_sym);
-    HASH_FOREACH_END()
-    this->tprot->writeMapEnd();
-    break;
-  }
+    case protocol::T_STRUCT: {
+      if (rb_class_real(CLASS_OF(actual)) != field_info->klass) {
+        raise_type_mismatch(outer_struct, field_sym, field_info->klass, actual);
+      }
 
-  case protocol::T_STRUCT: {
-    if (rb_class_real(CLASS_OF(actual)) != field_info->klass) {
-      raise_type_mismatch(outer_struct, field_sym);
+      static const string cname = "";
+      this->tprot->writeStructBegin(cname.c_str());
+      this->writeStruct(field_info->klass, actual);
+      this->tprot->writeFieldStop();
+      this->tprot->writeStructEnd();
+      break;
     }
 
-    static const string cname = "";
-    this->tprot->writeStructBegin(cname.c_str());
-    this->writeStruct(field_info->klass, actual);
-    this->tprot->writeFieldStop();
-    this->tprot->writeStructEnd();
-    break;
-  }
-
-  default: { break; }
+    default: { break; }
   }
 }
 
@@ -582,10 +602,8 @@ static bool checkRequiredFields(VALUE klass, VALUE data) {
       VALUE val = rb_ivar_get(data, entry.second->ivarName);
       if (NIL_P(val)) {
         raise_exc_with_struct_and_field_names(
-          SparsamMissingMandatory,
-          rb_str_new2("Required field missing"),
-          klass,
-          entry.second->symName);
+            SparsamMissingMandatory, rb_str_new2("Required field missing"),
+            klass, entry.second->symName);
         return false;
       }
     }
@@ -604,14 +622,16 @@ void ThriftSerializer::writeStruct(VALUE klass, VALUE data) {
     return;
   }
 
-  for (auto const & entry : *fields) {
+  for (auto const &entry : *fields) {
     fieldBegin.fid = entry.first;
     fieldInfo = entry.second;
     fieldBegin.ftype = fieldInfo->ftype;
     VALUE actual = rb_ivar_get(data, fieldInfo->ivarName);
     if (!NIL_P(actual)) {
-      this->tprot->writeFieldBegin(cname.c_str(), fieldBegin.ftype, fieldBegin.fid);
-      this->writeAny(fieldBegin.ftype, entry.second, actual, data, fieldInfo->symName);
+      this->tprot->writeFieldBegin(cname.c_str(), fieldBegin.ftype,
+                                   fieldBegin.fid);
+      this->writeAny(fieldBegin.ftype, entry.second, actual, data,
+                     fieldInfo->symName);
       this->tprot->writeFieldEnd();
     }
   }
@@ -625,13 +645,10 @@ VALUE serializer_writeStruct(VALUE self, VALUE klass, VALUE data) {
     VALUE actual_name = rb_class_name(CLASS_OF(data));
 
     raise_exc_with_struct_and_field_names(
-      SparsamTypeMismatchError,
-      rb_sprintf(
-        "Mismatched type passed to serialize (expected: %s got: %s)",
-        RSTRING_PTR(expected_name),
-        RSTRING_PTR(actual_name)),
-      CLASS_OF(data),
-      ID2SYM(rb_intern("(root)")));
+        SparsamTypeMismatchError,
+        rb_sprintf("Mismatched type passed to serialize (expected: %s got: %s)",
+                   RSTRING_PTR(expected_name), RSTRING_PTR(actual_name)),
+        CLASS_OF(data), ID2SYM(rb_intern("(root)")));
 
     RB_GC_GUARD(expected_name);
     RB_GC_GUARD(actual_name);
@@ -708,34 +725,36 @@ FieldInfo *CreateFieldInfo(VALUE field_map_entry) {
       R_FIX_TO_TTYPE(rb_hash_aref(field_map_entry, sym_for_type));
   fieldInfo->isOptional =
       RTEST(rb_hash_aref(field_map_entry, sym_for_optional));
-  fieldInfo->ivarName = field_name_to_ivar_id(rb_hash_aref(field_map_entry, sym_for_name));
-  fieldInfo->symName = field_name_to_sym(rb_hash_aref(field_map_entry, sym_for_name));
+  fieldInfo->ivarName =
+      field_name_to_ivar_id(rb_hash_aref(field_map_entry, sym_for_name));
+  fieldInfo->symName =
+      field_name_to_sym(rb_hash_aref(field_map_entry, sym_for_name));
   switch (fieldInfo->ftype) {
-  case protocol::T_STRING: {
-    if (RTEST(rb_hash_aref(field_map_entry, sym_for_binary))) {
-      fieldInfo->isBinaryString = true;
+    case protocol::T_STRING: {
+      if (RTEST(rb_hash_aref(field_map_entry, sym_for_binary))) {
+        fieldInfo->isBinaryString = true;
+      }
+      break;
     }
-    break;
-  }
-  case protocol::T_STRUCT: {
-    fieldInfo->klass = rb_hash_aref(field_map_entry, sym_for_class);
-    break;
-  }
-  case protocol::T_LIST:
-  case protocol::T_SET: {
-    fieldInfo->elementType =
-        CreateFieldInfo(rb_hash_aref(field_map_entry, sym_for_element));
-    break;
-  }
-  case protocol::T_MAP: {
-    fieldInfo->keyType =
-        CreateFieldInfo(rb_hash_aref(field_map_entry, sym_for_key));
-    fieldInfo->elementType =
-        CreateFieldInfo(rb_hash_aref(field_map_entry, sym_for_value));
-    break;
-  }
-  default:
-    break;
+    case protocol::T_STRUCT: {
+      fieldInfo->klass = rb_hash_aref(field_map_entry, sym_for_class);
+      break;
+    }
+    case protocol::T_LIST:
+    case protocol::T_SET: {
+      fieldInfo->elementType =
+          CreateFieldInfo(rb_hash_aref(field_map_entry, sym_for_element));
+      break;
+    }
+    case protocol::T_MAP: {
+      fieldInfo->keyType =
+          CreateFieldInfo(rb_hash_aref(field_map_entry, sym_for_key));
+      fieldInfo->elementType =
+          CreateFieldInfo(rb_hash_aref(field_map_entry, sym_for_value));
+      break;
+    }
+    default:
+      break;
   }
   return fieldInfo;
 }

data/ext/serializer.h

@@ -18,9 +18,9 @@ enum TOType {
 
 enum ValidateStrictness { normal = 0, strict = 1, recursive = 2 };
 
-void serializer_free(void *data);
-void *serializer_create();
-void serializer_init(void *serializer, int protocol, void *str_arg1,
+void serializer_free(void* data);
+void* serializer_create();
+void serializer_init(void* serializer, int protocol, void* str_arg1,
                      uint32_t len);
 
 VALUE serializer_readStruct(VALUE self, VALUE klass);
@@ -36,18 +36,36 @@ void initialize_constants();
 void initialize_runtime_constants();
 
 #ifdef __cplusplus
-} // end extern "C"
+}  // end extern "C"
 
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TBufferTransports.h>
 #include <boost/shared_ptr.hpp>
 #include <map>
 #include <string>
-#include <thrift/protocol/TProtocol.h>
-#include <thrift/transport/TBufferTransports.h>
 #include <unordered_set>
 #include "third-party/sparsepp/sparsepp/spp.h"
 
 using ::apache::thrift::protocol::TType;
 
+// transposed from:
+// https://github.com/apache/thrift/blob/0.10.0/lib/cpp/src/thrift/protocol/TProtocol.h#L176
+// with: https://gist.github.com/andyfangdz/d4d52daa9f8a75223e76e92657036bb0
+// fun fact: it's not sorted there
+const std::string TTypeNames[] = {
+    "T_STOP",   "T_VOID",    "T_BOOL", "T_BYTE or T_I08",
+    "T_DOUBLE", "T_UNKNOWN", "T_I16",  "T_UNKNOWN",
+    "T_I32",    "T_U64",     "T_I64",  "T_STRING or T_UTF7",
+    "T_STRUCT", "T_MAP",     "T_SET",  "T_LIST",
+    "T_UTF8",   "T_UTF16"};
+
+const size_t TTypeMaxID = sizeof(TTypeNames) / sizeof(TTypeNames[0]);
+
+const std::string TTypeUnknown = "T_UNKNOWN";
+
+#define TTypeName(typeId) \
+  (typeId < TTypeMaxID ? TTypeNames[typeId] : TTypeUnknown)
+
 typedef uint16_t FieldIdIndex;
 typedef uint16_t KlassIndex;
 
@@ -60,38 +78,41 @@ typedef struct FieldBegin {
 
 typedef struct FieldInfo {
   TType ftype;
-  VALUE klass; // set if TTYPE is struct or union
-  ID ivarName; // set if field is on struct
-  VALUE symName; // set if field is on struct/union
+  VALUE klass;    // set if TTYPE is struct or union
+  ID ivarName;    // set if field is on struct
+  VALUE symName;  // set if field is on struct/union
   bool isOptional;
   bool isBinaryString;
-  FieldInfo *elementType; // element of list or set, or map
-  FieldInfo *keyType;     // type of key in maps
+  FieldInfo* elementType;  // element of list or set, or map
+  FieldInfo* keyType;      // type of key in maps
 } FieldInfo;
 
-typedef std::map<FieldID, FieldInfo *> FieldInfoMap;
-typedef spp::sparse_hash_map<VALUE, FieldInfoMap *> KlassFieldsCache;
+typedef std::map<FieldID, FieldInfo*> FieldInfoMap;
+typedef spp::sparse_hash_map<VALUE, FieldInfoMap*> KlassFieldsCache;
 
 class ThriftSerializer {
-public:
+ public:
   ThriftSerializer(){};
+  // clang-format off
   boost::shared_ptr< ::apache::thrift::protocol::TProtocol > tprot;
   boost::shared_ptr< ::apache::thrift::transport::TMemoryBuffer > tmb;
+  // clang-format on
 
   VALUE readStruct(VALUE klass);
   VALUE readUnion(VALUE klass);
   void writeStruct(VALUE klass, VALUE data);
 
-private:
-  VALUE readAny(TType ttype, FieldInfo *field_info);
-  void writeAny(TType ttype, FieldInfo *field_info, VALUE data, VALUE outer_struct, VALUE field_sym);
+ private:
+  VALUE readAny(TType ttype, FieldInfo* field_info);
+  void writeAny(TType ttype, FieldInfo* field_info, VALUE data,
+                VALUE outer_struct, VALUE field_sym);
   void skip_n_type(uint32_t n, TType ttype);
   void skip_n_pair(uint32_t n, TType type_a, TType type_b);
 };
 
-FieldInfoMap *FindOrCreateFieldInfoMap(VALUE klass);
-FieldInfo *CreateFieldInfo(VALUE field_map_entry);
-FieldInfoMap *CreateFieldInfoMap(VALUE klass);
+FieldInfoMap* FindOrCreateFieldInfoMap(VALUE klass);
+FieldInfo* CreateFieldInfo(VALUE field_map_entry);
+FieldInfoMap* CreateFieldInfoMap(VALUE klass);
 
 #endif
 #endif

data/spec/sparsam_spec.rb

@@ -227,6 +227,44 @@ describe 'Sparsam' do
       e.field_name.should == "id_i32"
     end
 
+    it "includes additional information on serializing mismatched types" do
+      data = MiniRequired.new
+      data.id_i32 = "not an i32"
+
+      e = nil
+      begin
+        data.serialize
+      rescue Sparsam::TypeMismatch => exception
+        e = exception
+      end
+      e.message.should include("T_I32", "String")
+
+      data = EveryType.new
+      data.a_struct = EveryType.new
+
+      e = nil
+      begin
+        data.serialize
+      rescue Sparsam::TypeMismatch => exception
+        e = exception
+      end
+      e.message.should include("US", "EveryType")
+    end
+
+    it "includes additional information on deserializing mismatched types" do
+      data = NotSS.new
+      data.id_s = "not an i32"
+
+      serialized = data.serialize
+
+      begin
+        Sparsam::Deserializer.deserialize(SS, serialized)
+      rescue Sparsam::TypeMismatch => exception
+        e = exception
+      end
+      e.message.should include("T_I32", "T_STRING")
+    end
+
     it "will throw errors when given junk data" do
       expect {
         Sparsam::Deserializer.deserialize(SS, "wolololololol")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sparsam
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Airbnb Thrift Developers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-07 00:00:00.000000000 Z
+date: 2018-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec