sparsam 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ab4bfb28dc0761f1ef66ea93e239408e4bdb308
-  data.tar.gz: 78cd96b406e6260832478236d53e7c20a166d628
+  metadata.gz: 82b851a7cec00fa3805571f1cd89d43077b86ed5
+  data.tar.gz: c4617c449ccd26bb73896e49ceb430b15f6f973c
 SHA512:
-  metadata.gz: 9c5cfdaed8ebc55ded0e937139d21d3133459be09b3787c6fc0625fdf09be2452d615969dbcd9aa7f7eb9510ec2bd1dd65c2314b9d979cabb043349f113cbc94
-  data.tar.gz: 4a72dbf9b165aff8c419beaa7f870ed3cdb00e1d858201325707cdd5248d7e6ce6126896e9e4ae1e381c5e055003f4c8d348f95297e8143c270e86fe2bd198eb
+  metadata.gz: 73aff3bcae386d83adb457c63ef35ec0d0281e2bab33436b4f05c7fa8b79f80e5110d7600cfa3427cfbd5eeb222f01cf997ce8f312cd3be72dbb6f7d6fbebdc1
+  data.tar.gz: 6f060447c4d06c8abd9f014dcdbafe5e3e1e8ffc8ce0a23c999c7c445138ac019a0257eccf48bdfc5af4cf722ccd64e44155574190c65f67dadc026b1f223317

data/README.md

@@ -1,4 +1,4 @@
-# Sparsam [![Build Status](https://travis-ci.org/airbnb/sparsam.svg?branch=master)](https://travis-ci.org/airbnb/sparsam) [![Coverage Status](https://coveralls.io/repos/github/airbnb/sparsam/badge.svg?branch=master)](https://coveralls.io/github/airbnb/sparsam?branch=master)
+# Sparsam [![Build Status](https://travis-ci.org/airbnb/sparsam.svg?branch=master)](https://travis-ci.org/airbnb/sparsam) [![Coverage Status](https://coveralls.io/repos/github/airbnb/sparsam/badge.svg?branch=master)](https://coveralls.io/github/airbnb/sparsam?branch=master) [![Gem Version](https://badge.fury.io/rb/sparsam.svg)](https://badge.fury.io/rb/sparsam)
 New Thrift bindings and generator for Ruby!
 
 ## Super basic Example

data/ext/serializer.cpp

@@ -136,6 +136,18 @@ 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,
+        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 args[3] = {msg, struct_name, field_name};
+  VALUE e = rb_class_new_instance(3, args, exc_class);
+  rb_exc_raise(e);
+}
+
 static inline VALUE make_ruby_bool(bool val) { return val ? Qtrue : Qfalse; }
 
 void ThriftSerializer::skip_n_type(uint32_t n, TType ttype) {
@@ -301,8 +313,11 @@ VALUE ThriftSerializer::readStruct(VALUE klass) {
     typeId = fieldInfo->ftype;
 
     if (typeId != fieldBegin.ftype) {
-      rb_raise(SparsamTypeMismatchError, "Type Mismatch. Defenition: %d, Actual: %d",
-               fieldBegin.ftype, typeId);
+      raise_exc_with_struct_and_field_names(
+        SparsamTypeMismatchError,
+        rb_sprintf("Type Mismatch. Defenition: %d, Actual: %d", fieldBegin.ftype, typeId),
+        klass,
+        fieldInfo->symName);
     }
 
     VALUE rb_value = this->readAny(fieldBegin.ftype, iter->second);
@@ -387,6 +402,8 @@ void ThriftSerializer::writeAny(TType ttype, FieldInfo *field_info,
     HANDLE_TYPE(BYTE, Byte, NUM2SHORT)
 
   case protocol::T_STRING: {
+    Check_Type(actual, T_STRING);
+
     string data = string(StringValuePtr(actual), RSTRING_LEN(actual));
     if (field_info->isBinaryString) {
       this->tprot->writeBinary(data);
@@ -397,6 +414,8 @@ void ThriftSerializer::writeAny(TType ttype, FieldInfo *field_info,
   }
 
   case protocol::T_LIST: {
+    Check_Type(actual, T_ARRAY);
+
     long length = RARRAY_LEN(actual);
     TType elem = field_info->elementType->ftype;
     this->tprot->writeListBegin(elem, static_cast<size_t>(length));
@@ -420,6 +439,8 @@ void ThriftSerializer::writeAny(TType ttype, FieldInfo *field_info,
   }
 
   case protocol::T_MAP: {
+    Check_Type(actual, T_HASH);
+
     TType keyTType = field_info->keyType->ftype,
           valueTType = field_info->elementType->ftype;
     this->tprot->writeMapBegin(keyTType, valueTType,
@@ -454,6 +475,11 @@ void ThriftSerializer::writeStruct(VALUE klass, VALUE data) {
   FieldBegin fieldBegin;
   FieldInfo *fieldInfo;
   auto fields = FindOrCreateFieldInfoMap(klass);
+
+  if (!validateStruct(klass, data, false, false)) {
+    return;
+  }
+
   for (auto const & entry : *fields) {
     fieldBegin.fid = entry.first;
     fieldInfo = entry.second;
@@ -490,15 +516,23 @@ VALUE serializer_readStruct(VALUE self, VALUE klass) {
   catch_thrift_and_reraise();
 }
 
-static inline void raise_type_mismatch() {
-  rb_raise(SparsamTypeMismatchError, "Type mismatch in field data");
+static void raise_type_mismatch(VALUE outer_struct, VALUE field_sym) {
+    raise_exc_with_struct_and_field_names(
+      SparsamTypeMismatchError,
+      rb_str_new2("Type mismatch in field data"),
+      CLASS_OF(outer_struct),
+      field_sym);
 }
 
-bool validateArray(FieldInfo *type, VALUE arr, bool recursive) {
+bool validateArray(
+        FieldInfo *type,
+        VALUE arr,
+        bool recursive,
+        VALUE outer_struct,
+        VALUE field_sym) {
   long length = RARRAY_LEN(arr);
   for (long i = 0; i < length; i++) {
-    if (!validateAny(type, rb_ary_entry(arr, i), recursive)) {
-      rb_raise(SparsamTypeMismatchError, "Type mismatch in container element");
+    if (!validateAny(type, rb_ary_entry(arr, i), recursive, outer_struct, field_sym)) {
       return false;
     }
   }
@@ -507,7 +541,7 @@ bool validateArray(FieldInfo *type, VALUE arr, bool recursive) {
 
 #define TEST_RB_VAL_FOR_CLASS(VAL, KLASS)                                      \
   if (!RTEST(rb_obj_is_kind_of(VAL, KLASS))) {                                 \
-    raise_type_mismatch();                                                     \
+    raise_type_mismatch(outer_struct, field_sym);                              \
     ret = false;                                                               \
   }
 
@@ -517,7 +551,7 @@ bool validateArray(FieldInfo *type, VALUE arr, bool recursive) {
     break;                                                                     \
   }
 
-bool validateAny(FieldInfo *type, VALUE val, bool recursive) {
+bool validateAny(FieldInfo *type, VALUE val, bool recursive, VALUE outer_struct, VALUE field_sym) {
   bool ret = true;
   switch (type->ftype) {
 
@@ -528,6 +562,14 @@ bool validateAny(FieldInfo *type, VALUE val, bool recursive) {
     HANDLE_TYPE(DOUBLE, klass_for_float)
     HANDLE_TYPE(STRING, klass_for_string)
 
+  case protocol::T_BOOL: {
+    if ( !(val == Qtrue || val == Qfalse) ) {
+      raise_type_mismatch(outer_struct, field_sym);
+      ret = false;
+    }
+    break;
+  }
+
   case protocol::T_STRUCT: {
     TEST_RB_VAL_FOR_CLASS(val, type->klass)
     if (ret && recursive) {
@@ -540,14 +582,14 @@ bool validateAny(FieldInfo *type, VALUE val, bool recursive) {
     TEST_RB_VAL_FOR_CLASS(val, klass_for_set)
     if (ret) {
       VALUE ary = rb_funcall(val, intern_for_to_a, 0);
-      ret = validateArray(type->elementType, ary, recursive);
+      ret = validateArray(type->elementType, ary, recursive, outer_struct, field_sym);
     }
     break;
   }
   case protocol::T_LIST: {
     TEST_RB_VAL_FOR_CLASS(val, klass_for_array)
     if (ret) {
-      ret = validateArray(type->elementType, val, recursive);
+      ret = validateArray(type->elementType, val, recursive, outer_struct, field_sym);
     }
     break;
   }
@@ -557,12 +599,13 @@ bool validateAny(FieldInfo *type, VALUE val, bool recursive) {
     if (ret) {
       bool flag = true;
       HASH_FOREACH_BEGIN(val, &flag, type->keyType, type->elementType,
-                         &recursive)
+                         &recursive, &outer_struct, &field_sym)
       bool *flag = (bool *)argv[0], *recursive = (bool *)argv[3];
+      VALUE *outer_struct = (VALUE *)argv[4], *field_sym = (VALUE *)argv[5];
       FieldInfo *field_info_key = (FieldInfo *)argv[1];
       FieldInfo *field_info_value = (FieldInfo *)argv[2];
-      if (!validateAny(field_info_key, k, *recursive) ||
-          !validateAny(field_info_value, v, *recursive)) {
+      if (!validateAny(field_info_key, k, *recursive, *outer_struct, *field_sym) ||
+          !validateAny(field_info_value, v, *recursive, *outer_struct, *field_sym)) {
         *flag = false;
         HASH_FOREACH_ABORT()
       }
@@ -594,12 +637,17 @@ bool validateStruct(VALUE klass, VALUE data, bool validateContainerTypes,
     VALUE val = rb_ivar_get(data, entry.second->ivarName);
     if (NIL_P(val)) {
       if (!entry.second->isOptional) {
-        rb_raise(SparsamMissingMandatory, "Missing: fieldID %d", entry.first);
+        raise_exc_with_struct_and_field_names(
+          SparsamMissingMandatory,
+          rb_sprintf("Missing: fieldID %d", entry.first),
+          klass,
+          entry.second->symName);
         return false;
       }
       continue;
     }
-    if (validateContainerTypes && !validateAny(entry.second, val, recursive)) {
+    if (validateContainerTypes &&
+        !validateAny(entry.second, val, recursive, data, entry.second->symName)) {
       return false;
     }
   }

data/ext/serializer.h

@@ -92,7 +92,7 @@ private:
 
 bool validateStruct(VALUE klass, VALUE data, bool validateContainerTypes,
                     bool recursive);
-bool validateAny(FieldInfo *type, VALUE val, bool recursive);
+bool validateAny(FieldInfo *type, VALUE val, bool recursive, VALUE outer_struct, VALUE field_sym);
 FieldInfoMap *FindOrCreateFieldInfoMap(VALUE klass);
 FieldInfo *CreateFieldInfo(VALUE field_map_entry);
 FieldInfoMap *CreateFieldInfoMap(VALUE klass);

data/lib/sparsam/base_class.rb

@@ -73,7 +73,6 @@ module Sparsam
     end
 
     def serialize(prot = Sparsam::CompactProtocol)
-      validate
       s = Sparsam::Serializer.new(prot, "")
       s.serialize(self.class, self)
     end

data/lib/sparsam/exceptions.rb

@@ -8,14 +8,22 @@ module Sparsam
   end
 
   class MissingMandatory < Exception
-    def initialize(msg)
-      super
+    attr_reader :struct_name, :field_name
+
+    def initialize(msg, struct_name = nil, field_name = nil)
+      @struct_name = struct_name
+      @field_name = field_name
+      super(msg)
     end
   end
 
   class TypeMismatch < Exception
-    def initialize(msg)
-      super
+    attr_reader :struct_name, :field_name
+
+    def initialize(msg, struct_name = nil, field_name = nil)
+      @struct_name = struct_name
+      @field_name = field_name
+      super(msg)
     end
   end
 

data/spec/gen-ruby/user_types.rb

@@ -104,3 +104,25 @@ class Nothing < ::Sparsam::Struct
   init_thrift_struct(self)
 end
 
+class EveryType < ::Sparsam::Struct
+  FIELDS = {
+    1 => {:type => ::Sparsam::Types::BOOL, :name => 'a_bool', :optional => true},
+    2 => {:type => ::Sparsam::Types::BYTE, :name => 'a_byte', :optional => true},
+    3 => {:type => ::Sparsam::Types::I16, :name => 'an_i16', :optional => true},
+    4 => {:type => ::Sparsam::Types::I32, :name => 'an_i32', :optional => true},
+    5 => {:type => ::Sparsam::Types::I64, :name => 'an_i64', :optional => true},
+    6 => {:type => ::Sparsam::Types::DOUBLE, :name => 'a_double', :optional => true},
+    7 => {:type => ::Sparsam::Types::STRING, :name => 'a_binary', :binary => true, :optional => true},
+    8 => {:type => ::Sparsam::Types::STRING, :name => 'a_string', :optional => true},
+    9 => {:type => ::Sparsam::Types::LIST, :name => 'an_i64_list', :element => {:type => ::Sparsam::Types::I64}, :optional => true},
+    10 => {:type => ::Sparsam::Types::SET, :name => 'an_i64_set', :element => {:type => ::Sparsam::Types::I64}, :optional => true},
+    11 => {:type => ::Sparsam::Types::MAP, :name => 'an_i64_map', :key => {:type => ::Sparsam::Types::I64}, :value => {:type => ::Sparsam::Types::I64}, :optional => true},
+    12 => {:type => ::Sparsam::Types::LIST, :name => 'a_list_of_i64_maps', :element => {:type => ::Sparsam::Types::MAP, :key => {:type => ::Sparsam::Types::I64}, :value => {:type => ::Sparsam::Types::I64}}, :optional => true},
+    13 => {:type => ::Sparsam::Types::MAP, :name => 'a_map_of_i64_maps', :key => {:type => ::Sparsam::Types::MAP, :key => {:type => ::Sparsam::Types::I64}, :value => {:type => ::Sparsam::Types::I64}}, :value => {:type => ::Sparsam::Types::MAP, :key => {:type => ::Sparsam::Types::I64}, :value => {:type => ::Sparsam::Types::I64}}, :optional => true},
+    14 => {:type => ::Sparsam::Types::STRUCT, :name => 'a_struct', :class => ::US, :optional => true},
+    15 => {:type => ::Sparsam::Types::STRUCT, :name => 'a_union', :class => ::UN, :optional => true}
+  }
+
+  init_thrift_struct(self)
+end
+

data/spec/sparsam_spec.rb

@@ -92,6 +92,7 @@ describe 'Sparsam' do
       expect {
         Sparsam.validate(NotSS, data, Sparsam::STRICT)
       }.to raise_error(Sparsam::TypeMismatch)
+
       expect {
         Sparsam.validate(EasilyInvalid, data, Sparsam::STRICT)
       }.to raise_error(Sparsam::TypeMismatch)
@@ -151,6 +152,21 @@ describe 'Sparsam' do
       }.to raise_error(Sparsam::TypeMismatch)
     end
 
+    it "includes additional data in TypeMismatch errors" do
+      data = EasilyInvalid.new
+      data.id_i32 = "definitely a string"
+
+      e = nil
+      begin
+        Sparsam.validate(EasilyInvalid, data, Sparsam::STRICT)
+      rescue Sparsam::TypeMismatch => exception
+        e = exception
+      end
+
+      e.struct_name.should == EasilyInvalid.name
+      e.field_name.should == "id_i32"
+    end
+
     it "works with crazy thriftness" do
       data = EasilyInvalid.new
       data.sure = [{ Set.new([1]) => { 1 => Set.new([[{ EasilyInvalid.new => "sure" }]]) } }]
@@ -189,6 +205,20 @@ describe 'Sparsam' do
       expect { data.validate }.to raise_error(Sparsam::MissingMandatory)
     end
 
+    it "includes additional information on missing required fields in exception" do
+      data = MiniRequired.new
+
+      e = nil
+      begin
+        data.validate
+      rescue Sparsam::MissingMandatory => exception
+        e = exception
+      end
+
+      e.struct_name.should == MiniRequired.name
+      e.field_name.should == "id_i32"
+    end
+
     it "will throw errors when given junk data" do
       expect {
         Sparsam::Deserializer.deserialize(SS, "wolololololol")
@@ -300,5 +330,80 @@ describe 'Sparsam' do
         Sparsam::Deserializer.deserialize(SS, really_bad, Sparsam::BinaryProtocol)
       }.to raise_error(Sparsam::Exception)
     end
+
+    it "handles all sorts of type issues without crashing" do
+      field_map = {
+        a_bool: :boolean,
+        a_byte: :int,
+        an_i16: :int,
+        an_i32: :int,
+        an_i64: :int,
+        a_double: :float,
+        a_binary: :string,
+        a_string: :string,
+
+        an_i64_list: :int_list,
+        an_i64_set: :int_set,
+        an_i64_map: :int_map,
+
+        a_list_of_i64_maps: :int_map_list,
+        a_map_of_i64_maps: :int_map_map,
+
+        a_struct: :struct,
+        a_union: :union,
+      }
+
+      scalar_values = {
+        boolean: true,
+        int: 42,
+        float: 3.14,
+        string: "Hello",
+        struct: US.new(id_i32: 10),
+        union: UN.new(id_s: "woo"),
+        complex: Complex(1),
+        bigint: 2**128,
+        rational: Rational(2, 3),
+      }
+
+      simple_collection_values = scalar_values.each_with_object({}) do |(type, val), obj|
+        obj[:"#{type}_list"] = [val]
+        obj[:"#{type}_set"] = Set.new([val])
+        obj[:"#{type}_map"] = { val => val }
+      end
+
+      nested_collection_values =
+        simple_collection_values.each_with_object({}) do |(type, val), obj|
+          obj[:"#{type}_list"] = [val]
+          obj[:"#{type}_set"] = Set.new([val])
+          obj[:"#{type}_map"] = { val => val }
+        end
+
+      all_values = scalar_values.merge(simple_collection_values).merge(nested_collection_values)
+
+      field_map.each do |field, type|
+        all_values.each do |val_type, val|
+          next if val_type == type
+
+          s = EveryType.new
+          s.send(:"#{field}=", val)
+
+          # Validation doesn't do range checking, though serialization does
+          unless val_type.to_s =~ /bigint/
+            expect {
+              Sparsam.validate(s.class, s, Sparsam::STRICT)
+            }.to(
+              raise_error(Sparsam::TypeMismatch),
+              "assigning #{field} : #{type} a value of " \
+              "#{val.inspect} : #{val_type} did not raise TypeMismatch"
+            )
+          end
+
+          begin
+            s.serialize
+          rescue TypeError, RangeError, NoMethodError, Sparsam::TypeMismatch
+          end
+        end
+      end
+    end
   end
 end

data/spec/user.thrift

@@ -60,3 +60,24 @@ struct NotSS_plus {
 
 struct nothing {
 }
+
+struct EveryType {
+  1: optional bool a_bool
+  2: optional byte a_byte
+  3: optional i16 an_i16
+  4: optional i32 an_i32
+  5: optional i64 an_i64
+  6: optional double a_double
+  7: optional binary a_binary
+  8: optional string a_string
+
+  9: optional list<i64> an_i64_list
+  10: optional set<i64> an_i64_set
+  11: optional map<i64, i64> an_i64_map
+
+  12: optional list<map<i64, i64>> a_list_of_i64_maps
+  13: optional map<map<i64, i64>, map<i64, i64>> a_map_of_i64_maps
+
+  14: optional US a_struct
+  15: optional UN a_union
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sparsam
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Airbnb Thrift Developers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-01 00:00:00.000000000 Z
+date: 2017-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -161,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: thrift
-rubygems_version: 2.6.12
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Ruby bindings for Apache Thrift