capn_proto 0.0.1.alpha.4 → 0.0.1.alpha.5

data/.gitignore

@@ -1,5 +1,6 @@
 Gemfile.lock
 *.bundle
+*.pyc
 tmp
 .env
 pkg

data/README.md

@@ -31,6 +31,33 @@ module AddressBook extend CapnProto::SchemaLoader
   load_schema("addressbook.capnp")
 end
 
+def write_address_book(file)
+  addresses = AddressBook::AddressBook.new_message
+  people = addresses.initPeople(2)
+
+  alice = people[0]
+  alice.id = 123
+  alice.name = 'Alice'
+  alice.email = 'alice@example.com'
+  alice_phones = alice.initPhones(1)
+  alice_phones[0].number = "555-1212"
+  alice_phones[0].type = 'mobile'
+  alice.employment.school = "MIT"
+
+  bob = people[1]
+  bob.id = 456
+  bob.name = 'Bob'
+  bob.email = 'bob@example.com'
+  bob_phones = bob.initPhones(2)
+  bob_phones[0].number = "555-4567"
+  bob_phones[0].type = 'home'
+  bob_phones[1].number = "555-7654"
+  bob_phones[1].type = 'work'
+  bob.employment.unemployed = nil
+
+  addresses.write(file)
+end
+
 def print_address_book(file)
   addresses = AddressBook::AddressBook.read_from(file)
 
@@ -41,22 +68,25 @@ def print_address_book(file)
       puts "#{phone.type} : #{phone.number}"
     end
 
-    which = person.employment.which
-
-    if which == "unemployed"
+    if person.employment.unemployed?
       puts "unemployed"
-    elsif which == 'employer'
+    if person.employment.employer?
       puts "employer: #{person.employment.employer}"
-    elsif which == "school"
+    if person.employment.school?
       puts "student at: #{person.employment.school}"
-    elsif which == "selfEmployed"
+    if person.employment.selfEmployed?
       puts "self employed"
     end
   end
 end
 
-file = File.open("addressbook.bin", "rb")
-print_address_book(file)
+if __FILE__ == $0
+  file = File.open("addressbook.bin", "wb")
+  write_address_book(file)
+
+  file = File.open("addressbook.bin", "rb")
+  print_address_book(file)
+end
 ```
 
 # Status
@@ -64,11 +94,18 @@ print_address_book(file)
 What's implemented:
 - Schema parsing/loading
 - Message reading
-
-What's to come:
+  - From byte string
+  - From file descriptor
 - Message writing
+  - To byte string
+  - To file descriptor
 
-Proper support for [JRuby][jruby] will come after I implement support for Java.
+What's to come:
+- More reading/writing mechanisms:
+  - Packing/unpacking
+- Extensive test coverage
+- Proper support for [JRuby][jruby]
+- Support for RPC
 
 [logo]: https://raw.github.com/cstrahan/capnp-ruby/master/media/captain_proto_small.png "Cap'n Proto"
 [ruby]: http://www.ruby-lang.org/ "Ruby"

data/Rakefile

@@ -21,6 +21,7 @@ task :default => [:compile, :spec]
 Rake::Task["clean"].clear
 task :clean do
   rm_r "tmp" rescue nil
+  rm_r "pkg" rescue nil
   rm "lib/capn_proto/capn_proto.bundle" rescue nil
 end
 

data/ext/capn_proto/dynamic_list_builder.cc

@@ -0,0 +1,123 @@
+#include "ruby_capn_proto.h"
+#include "dynamic_list_builder.h"
+#include "dynamic_value_builder.h"
+#include "dynamic_struct_reader.h"
+#include "dynamic_struct_builder.h"
+#include "exception.h"
+#include "util.h"
+#include "class_builder.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::DynamicList::Builder;
+  VALUE DynamicListBuilder::Class;
+
+  void DynamicListBuilder::Init() {
+    ClassBuilder("DynamicListBuilder", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("[]", &get).
+      defineMethod("[]=", &set).
+      defineMethod("size", &size).
+      store(&Class);
+  }
+
+  VALUE DynamicListBuilder::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  void DynamicListBuilder::free(WrappedType* p) {
+    p->~Builder();
+    ruby_xfree(p);
+  }
+
+  WrappedType* DynamicListBuilder::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE DynamicListBuilder::create(WrappedType builder, VALUE parent) {
+    auto rb_obj = alloc(Class);
+    WrappedType* wrapped = unwrap(rb_obj);
+    *wrapped = kj::mv(builder);
+
+    rb_iv_set(rb_obj, "parent", parent);
+
+    return rb_obj;
+  }
+
+  VALUE DynamicListBuilder::size(VALUE self) {
+    return INT2FIX(unwrap(self)->size());
+  }
+
+  VALUE DynamicListBuilder::get(VALUE self, VALUE rb_index) {
+    try {
+      return _get(self, rb_index);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+  }
+
+  VALUE DynamicListBuilder::_get(VALUE self, VALUE rb_index) {
+    auto builder = *unwrap(self);
+    auto size = builder.size();
+
+    unsigned long index;
+    if (Util::isNegative(rb_index)) {
+      index = NUM2LONG(rb_index) % builder.size();
+    } else {
+      index = NUM2ULONG(rb_index);
+    }
+
+    // return DynamicValueBuilder::to_ruby(builder.get(field), self);
+    return DynamicValueBuilder::to_ruby(builder[index], self);
+  }
+
+  VALUE DynamicListBuilder::set(VALUE self, VALUE rb_index, VALUE rb_obj) {
+    try {
+      return _set(self, rb_index, rb_obj);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+  }
+
+  VALUE DynamicListBuilder::_set(VALUE self, VALUE rb_index, VALUE rb_obj) {
+    VALUE klass = rb_funcall(rb_obj, rb_intern("class"), 0);
+
+    unsigned long field;
+    if (Util::isNegative(rb_index)) {
+      field = NUM2LONG(rb_index) % unwrap(self)->size();
+    } else {
+      field = NUM2ULONG(rb_index);
+    }
+
+    // TODO: handle assigning lists (see _setDynamicField)
+    if FIXNUM_P(rb_obj) {
+      if (Util::isNegative(rb_obj)) {
+        unwrap(self)->set(field, NUM2LONG(rb_obj));
+      } else {
+        unwrap(self)->set(field, NUM2ULONG(rb_obj));
+      }
+    } else if (RB_TYPE_P(rb_obj, T_FLOAT)) {
+      unwrap(self)->set(field, RFLOAT_VALUE(rb_obj));
+    } else if (rb_obj == Qtrue || rb_obj == Qfalse) {
+      unwrap(self)->set(field, (rb_obj == Qtrue) ? true : false);
+    } else if (RB_TYPE_P(rb_obj, T_STRING)) {
+      // TODO: need to ensure that the UTF8 char buffer is null terminated.
+      // consider something similar to rb_string_value_cstr,
+      // which grows the the buffer if necessary.
+      capnp::DynamicValue::Reader tmp =
+        capnp::Text::Reader(RSTRING_PTR(rb_obj), RSTRING_LEN(rb_obj));
+      unwrap(self)->set(field, tmp);
+    } else if (NIL_P(rb_obj)) {
+      unwrap(self)->set(field, capnp::VOID);
+    } else if (rb_equal(klass, DynamicStructReader::Class)) {
+      unwrap(self)->set(field, *DynamicStructReader::unwrap(rb_obj));
+    } else if (rb_equal(klass, DynamicStructBuilder::Class)) {
+      unwrap(self)->set(field, (*DynamicStructBuilder::unwrap(rb_obj)).asReader());
+    } else {
+      // TODO: raise "Non primitive type"
+    }
+
+    return rb_obj;
+  }
+}

data/ext/capn_proto/dynamic_list_builder.h

@@ -0,0 +1,27 @@
+#ifndef DYNAMIC_LIST_BUILDER_H
+#define DYNAMIC_LIST_BUILDER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class DynamicListBuilder {
+  public:
+    using WrappedType = capnp::DynamicList::Builder;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType reader, VALUE parent);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE which(VALUE self);
+    static VALUE get(VALUE self, VALUE index);
+    static VALUE set(VALUE self, VALUE index, VALUE rb_obj);
+    static VALUE size(VALUE self);
+
+    static VALUE Class;
+  private:
+    static VALUE _get(VALUE self, VALUE index);
+    static VALUE _set(VALUE self, VALUE index, VALUE rb_obj);
+  };
+}
+
+#endif /* DYNAMIC_LIST_BUILDER_H */

data/ext/capn_proto/dynamic_list_reader.cc

@@ -1,6 +1,7 @@
 #include "ruby_capn_proto.h"
 #include "dynamic_list_reader.h"
 #include "dynamic_value_reader.h"
+#include "exception.h"
 #include "class_builder.h"
 
 namespace ruby_capn_proto {
@@ -45,6 +46,14 @@ namespace ruby_capn_proto {
   }
 
   VALUE DynamicListReader::get(VALUE self, VALUE rb_index) {
+    try {
+      return _get(self, rb_index);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+  }
+
+  VALUE DynamicListReader::_get(VALUE self, VALUE rb_index) {
     auto reader = *unwrap(self);
     auto index = FIX2INT(rb_index);
     auto size = reader.size();

data/ext/capn_proto/dynamic_list_reader.h

@@ -17,6 +17,8 @@ namespace ruby_capn_proto {
     static VALUE size(VALUE self);
 
     static VALUE Class;
+  private:
+    static VALUE _get(VALUE self, VALUE index);
   };
 }
 

data/ext/capn_proto/dynamic_object_builder.cc

@@ -0,0 +1,57 @@
+#include "ruby_capn_proto.h"
+#include "dynamic_object_builder.h"
+#include "dynamic_struct_builder.h"
+#include "struct_schema.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::ObjectPointer::Builder;
+  VALUE DynamicObjectBuilder::Class;
+
+  void DynamicObjectBuilder::Init() {
+    ClassBuilder("DynamicObjectBuilder", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("as_struct", &as_struct).
+      store(&Class);
+  }
+
+  void DynamicObjectBuilder::free(WrappedType* p) {
+    p->~Builder();
+    ruby_xfree(p);
+  }
+
+  VALUE DynamicObjectBuilder::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* DynamicObjectBuilder::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE DynamicObjectBuilder::create(WrappedType reader, VALUE parent) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped = unwrap(rb_obj);
+    *wrapped = kj::mv(reader);
+
+    rb_iv_set(rb_obj, "parent", parent);
+
+    return rb_obj;
+  }
+
+  VALUE DynamicObjectBuilder::as_struct(VALUE self, VALUE rb_schema) {
+    if (rb_respond_to(rb_schema, rb_intern("schema"))) {
+      rb_schema = rb_funcall(rb_schema, rb_intern("schema"), 0);
+    }
+
+    auto reader = *unwrap(self);
+    auto schema = *StructSchema::unwrap(rb_schema);
+
+    return DynamicStructBuilder::create(
+      reader.getAs<capnp::DynamicStruct>(schema),
+      self,
+      false);
+  }
+}

data/ext/capn_proto/dynamic_object_builder.h

@@ -0,0 +1,22 @@
+#ifndef DYNAMIC_OBJECT_BUILDER_H
+#define DYNAMIC_OBJECT_BUILDER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class DynamicObjectBuilder {
+  public:
+    using WrappedType = capnp::ObjectPointer::Builder;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType reader, VALUE parent);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE as_struct(VALUE self, VALUE name);
+
+    static VALUE Class;
+  };
+}
+
+
+#endif

data/ext/capn_proto/dynamic_object_reader.h

@@ -19,4 +19,4 @@ namespace ruby_capn_proto {
 }
 
 
-#endif /* DYNAMIC_STRUCT_READER_H */
+#endif

data/ext/capn_proto/dynamic_struct_builder.cc

@@ -0,0 +1,171 @@
+#include "ruby_capn_proto.h"
+#include "dynamic_struct_builder.h"
+#include "dynamic_struct_reader.h"
+#include "dynamic_value_reader.h"
+#include "dynamic_value_builder.h"
+#include "message_builder.h"
+#include "malloc_message_builder.h"
+#include "class_builder.h"
+#include "exception.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::DynamicStruct::Builder;
+  VALUE DynamicStructBuilder::Class;
+
+  void DynamicStructBuilder::Init() {
+    ClassBuilder("DynamicStructBuilder", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("which", &which).
+      defineMethod("write", &write).
+      defineMethod("to_bytes", &to_bytes).
+      defineMethod("[]", &get).
+      defineMethod("[]=", &set).
+      defineMethod("init", (VALUE (*)(int, VALUE*, VALUE))&init).
+      store(&Class);
+  }
+
+  void DynamicStructBuilder::free(WrappedType* p) {
+    p->~Builder();
+    ruby_xfree(p);
+  }
+
+  VALUE DynamicStructBuilder::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* DynamicStructBuilder::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE DynamicStructBuilder::create(WrappedType reader, VALUE parent, bool is_root) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped = unwrap(rb_obj);
+    *wrapped = kj::mv(reader);
+
+    rb_iv_set(rb_obj, "parent", parent);
+    rb_iv_set(rb_obj, "is_root", is_root ? Qtrue : Qfalse);
+
+    return rb_obj;
+  }
+
+  VALUE DynamicStructBuilder::init(int argc, VALUE* argv, VALUE self) {
+    VALUE name;
+    VALUE count;
+
+    rb_scan_args(argc, argv, "11", &name, &count);
+
+    try {
+      return _init(self, name, count, argc);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+  }
+
+  VALUE DynamicStructBuilder::_init(VALUE self, VALUE rb_name, VALUE rb_count, int argc) {
+    auto name = Util::toString(rb_name);
+
+    if (argc == 1) {
+      return DynamicValueBuilder::to_ruby(unwrap(self)->init(name), self);
+    } else {
+      auto count = NUM2ULONG(rb_count);
+      return DynamicValueBuilder::to_ruby(unwrap(self)->init(name, count), self);
+    }
+  }
+
+  VALUE DynamicStructBuilder::get(VALUE self, VALUE rb_name) {
+    try {
+      return _get(self, rb_name);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+  }
+
+  VALUE DynamicStructBuilder::_get(VALUE self, VALUE rb_name) {
+    auto builder = *unwrap(self);
+    auto name = Util::toString(rb_name);
+    return DynamicValueBuilder::to_ruby(builder.get(name), self);
+  }
+
+  VALUE DynamicStructBuilder::set(VALUE self, VALUE rb_name, VALUE rb_obj) {
+    try {
+      return _set(self, rb_name, rb_obj);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+  }
+
+  VALUE DynamicStructBuilder::_set(VALUE self, VALUE rb_field, VALUE rb_obj) {
+    VALUE klass = rb_funcall(rb_obj, rb_intern("class"), 0);
+    auto field = Util::toString(rb_field);
+
+    // TODO: handle assigning lists (see _setDynamicField)
+    if FIXNUM_P(rb_obj) {
+      if (Util::isNegative(rb_obj)) {
+        unwrap(self)->set(field, NUM2LONG(rb_obj));
+      } else {
+        unwrap(self)->set(field, NUM2ULONG(rb_obj));
+      }
+    } else if (RB_TYPE_P(rb_obj, T_FLOAT)) {
+      unwrap(self)->set(field, RFLOAT_VALUE(rb_obj));
+    } else if (rb_obj == Qtrue || rb_obj == Qfalse) {
+      unwrap(self)->set(field, (rb_obj == Qtrue) ? true : false);
+    } else if (RB_TYPE_P(rb_obj, T_STRING)) {
+      // TODO: need to ensure that the UTF8 char buffer is null terminated.
+      // consider something similar to rb_string_value_cstr,
+      // which grows the the buffer if necessary.
+      capnp::DynamicValue::Reader tmp =
+        capnp::Text::Reader(RSTRING_PTR(rb_obj), RSTRING_LEN(rb_obj));
+      unwrap(self)->set(field, tmp);
+    } else if (NIL_P(rb_obj)) {
+      unwrap(self)->set(field, capnp::VOID);
+    } else if (rb_equal(klass, DynamicStructReader::Class)) {
+      unwrap(self)->set(field, *DynamicStructReader::unwrap(rb_obj));
+    } else if (rb_equal(klass, DynamicStructBuilder::Class)) {
+      unwrap(self)->set(field, (*DynamicStructBuilder::unwrap(rb_obj)).asReader());
+    } else {
+      // TODO: raise "Non primitive type"
+    }
+
+    return rb_obj;
+  }
+
+  VALUE DynamicStructBuilder::write(VALUE self, VALUE file) {
+    VALUE rb_fileno = rb_funcall(file, rb_intern("fileno"), 0);
+    int fileno = FIX2INT(rb_fileno);
+    if (!RTEST(rb_iv_get(self, "is_root"))) {
+      rb_raise(Exception::Class, "You can only call write() on the message's root struct.");
+    }
+
+    capnp::MessageBuilder* message_builder = MallocMessageBuilder::unwrap(rb_iv_get(self, "parent"));
+    try {
+      capnp::writeMessageToFd(fileno, message_builder->getSegmentsForOutput());
+      return Qnil;
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+  }
+
+  VALUE DynamicStructBuilder::to_bytes(VALUE self) {
+    if (!RTEST(rb_iv_get(self, "is_root"))) {
+      rb_raise(Exception::Class, "You can only call to_bytes() on the message's root struct.");
+    }
+
+    capnp::MessageBuilder* message_builder = MallocMessageBuilder::unwrap(rb_iv_get(self, "parent"));
+    auto array = capnp::messageToFlatArray(*message_builder);
+    return rb_str_new((char*)array.begin(), sizeof(capnp::word) * array.size());
+  }
+
+  VALUE DynamicStructBuilder::which(VALUE self) {
+    auto schema_maybe = unwrap(self)->which();
+    KJ_IF_MAYBE(schema, schema_maybe) {
+      auto name = schema->getProto().getName();
+      return rb_str_new(name.begin(), name.size());
+    } else {
+      // throw std::invalid_argument("member was null");
+      return Qnil;
+    }
+  }
+}

data/ext/capn_proto/dynamic_struct_builder.h

@@ -0,0 +1,34 @@
+#ifndef DYNAMIC_STRUCT_BUILDER_H
+#define DYNAMIC_STRUCT_BUILDER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class DynamicStructBuilder {
+  public:
+    using WrappedType = capnp::DynamicStruct::Builder;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType reader, VALUE parent, bool is_root);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE which(VALUE self);
+    static VALUE get(VALUE self, VALUE rb_name);
+    static VALUE set(VALUE self, VALUE rb_name, VALUE rb_obj);
+
+    static VALUE init(VALUE self, VALUE rb_name, VALUE rb_obj);
+    static VALUE init(int argc, VALUE* argv, VALUE self);
+
+    static VALUE write(VALUE self, VALUE file);
+    static VALUE to_bytes(VALUE self);
+
+    static VALUE Class;
+  private:
+    static VALUE _get(VALUE self, VALUE name);
+    static VALUE _set(VALUE self, VALUE rb_name, VALUE rb_obj);
+
+    static VALUE _init(VALUE self, VALUE rb_name, VALUE rb_count, int argc);
+  };
+}
+
+#endif

data/ext/capn_proto/dynamic_struct_reader.cc

@@ -2,6 +2,7 @@
 #include "dynamic_struct_reader.h"
 #include "dynamic_value_reader.h"
 #include "class_builder.h"
+#include "exception.h"
 #include "util.h"
 
 namespace ruby_capn_proto {
@@ -42,9 +43,16 @@ namespace ruby_capn_proto {
   }
 
   VALUE DynamicStructReader::get(VALUE self, VALUE rb_name) {
+    try {
+      return _get(self, rb_name);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+  }
+
+  VALUE DynamicStructReader::_get(VALUE self, VALUE rb_name) {
     auto reader = *unwrap(self);
     auto name = Util::toString(rb_name);
-
     return DynamicValueReader::to_ruby(reader.get(name), self);
   }
 

data/ext/capn_proto/dynamic_struct_reader.h

@@ -16,6 +16,8 @@ namespace ruby_capn_proto {
     static VALUE get(VALUE self, VALUE name);
 
     static VALUE Class;
+  private:
+    static VALUE _get(VALUE self, VALUE name);
   };
 }
 

data/ext/capn_proto/dynamic_value_builder.cc

@@ -0,0 +1,53 @@
+#include "ruby_capn_proto.h"
+#include "dynamic_value_builder.h"
+#include "dynamic_list_builder.h"
+#include "dynamic_struct_builder.h"
+#include "dynamic_object_builder.h"
+
+namespace ruby_capn_proto {
+
+  VALUE DynamicValueBuilder::to_ruby(capnp::DynamicValue::Builder value, VALUE parent) {
+    switch (value.getType())
+    {
+      case capnp::DynamicValue::BOOL:
+        return value.as<bool>() ? Qtrue : Qfalse;
+      case capnp::DynamicValue::INT:
+        return INT2NUM(value.as<int64_t>());
+      case capnp::DynamicValue::UINT:
+        return UINT2NUM(value.as<uint64_t>());
+      case capnp::DynamicValue::FLOAT:
+        return rb_float_new(value.as<double>());
+      case capnp::DynamicValue::TEXT:
+        {
+          auto text = value.as<capnp::Text>();
+          return rb_str_new(text.begin(), text.size());
+        }
+      case capnp::DynamicValue::DATA:
+        {
+          auto data = value.as<capnp::Data>();
+          return rb_str_new((const char*)data.begin(), data.size());
+        }
+      case capnp::DynamicValue::LIST:
+        return DynamicListBuilder::create(value.as<capnp::DynamicList>(), parent);
+      case capnp::DynamicValue::STRUCT:
+        return DynamicStructBuilder::create(value.as<capnp::DynamicStruct>(), parent, false);
+      case capnp::DynamicValue::ENUM:
+        {
+          auto enumerant_maybe = value.as<capnp::DynamicEnum>().getEnumerant();
+          KJ_IF_MAYBE(enumerant, enumerant_maybe) {
+            auto name = enumerant->getProto().getName();
+            return rb_str_new(name.begin(), name.size());
+          } else {
+            return Qnil;
+          }
+        }
+      case capnp::DynamicValue::OBJECT:
+        return DynamicObjectBuilder::create(value.as<capnp::ObjectPointer>(), parent);
+      case capnp::DynamicValue::VOID:
+        return Qnil;
+      case capnp::DynamicValue::UNKNOWN:
+      default:
+        return Qnil;
+    }
+  }
+}

data/ext/capn_proto/dynamic_value_builder.h

@@ -0,0 +1,13 @@
+#ifndef DYNAMIC_VALUE_BUILDER_H
+#define DYNAMIC_VALUE_BUILDER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class DynamicValueBuilder {
+  public:
+    static VALUE to_ruby(capnp::DynamicValue::Builder value, VALUE parent);
+  };
+}
+
+#endif /* DYNAMIC_VALUE_BUILDER_H */

data/ext/capn_proto/exception.cc

@@ -19,6 +19,12 @@ namespace ruby_capn_proto {
   VALUE Exception::create(WrappedType exception) {
     VALUE msg = Util::toRubyString(exception.getDescription());
     VALUE rb_exception = rb_funcall(Class, rb_intern("new"), 1, msg);
+
     return rb_exception;
   }
+
+  VALUE Exception::raise(WrappedType exception) {
+    rb_exc_raise(create(exception));
+    return Qnil;
+  }
 }

data/ext/capn_proto/exception.h

@@ -8,7 +8,8 @@ namespace ruby_capn_proto {
   public:
     using WrappedType = kj::Exception;
     static void Init();
-    static VALUE create(WrappedType schema);
+    static VALUE create(WrappedType exception);
+    static VALUE raise(WrappedType exception);
 
     static VALUE Class;
   };

data/ext/capn_proto/flat_array_message_reader.cc

@@ -0,0 +1,61 @@
+#include "ruby_capn_proto.h"
+#include "message_reader.h"
+#include "flat_array_message_reader.h"
+#include "struct_schema.h"
+#include "dynamic_struct_reader.h"
+#include "class_builder.h"
+#include "exception.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::FlatArrayMessageReader;
+  VALUE FlatArrayMessageReader::Class;
+
+  void FlatArrayMessageReader::Init() {
+    ClassBuilder("FlatArrayMessageReader", MessageReader::Class).
+      defineAlloc(&alloc).
+      defineMethod("initialize", &initialize).
+      defineMethod("get_root", &get_root).
+      store(&Class);
+  }
+
+  VALUE FlatArrayMessageReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  VALUE FlatArrayMessageReader::initialize(VALUE self, VALUE rb_buff) {
+    rb_iv_set(self, "buff", rb_buff);
+    auto str = RSTRING_PTR(rb_buff);
+    auto len = RSTRING_LEN(rb_buff);
+    kj::ArrayPtr<const capnp::word> buff((const capnp::word*)str, len/sizeof(capnp::word));
+
+    try {
+      WrappedType* p = unwrap(self);
+      new (p) WrappedType(buff);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+
+    return Qnil;
+  }
+
+  void FlatArrayMessageReader::free(WrappedType* p) {
+    p->~FlatArrayMessageReader();
+    ruby_xfree(p);
+  }
+
+  WrappedType* FlatArrayMessageReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE FlatArrayMessageReader::get_root(VALUE self, VALUE rb_schema) {
+    if (rb_respond_to(rb_schema, rb_intern("schema"))) {
+      rb_schema = rb_funcall(rb_schema, rb_intern("schema"), 0);
+    }
+
+    auto schema = *StructSchema::unwrap(rb_schema);
+    auto reader = unwrap(self)->getRoot<capnp::DynamicStruct>(schema);
+    return DynamicStructReader::create(reader, self);
+  }
+}

data/ext/capn_proto/flat_array_message_reader.h

@@ -0,0 +1,21 @@
+#ifndef FLAT_ARRAY_MESSAGE_READER_H
+#define FLAT_ARRAY_MESSAGE_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class FlatArrayMessageReader {
+  public:
+    using WrappedType = capnp::FlatArrayMessageReader;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE initialize(VALUE klass, VALUE io);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE get_root(VALUE self, VALUE schema);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* FLAT_ARRAY_MESSAGE_READER_H */

data/ext/capn_proto/init.cc

@@ -1,36 +1,53 @@
 #include "ruby_capn_proto.h"
-#include "parsed_schema.h"
+
+#include "exception.h"
+
 #include "schema_parser.h"
-#include "schema_node_reader.h"
+#include "parsed_schema.h"
 #include "struct_schema.h"
+#include "schema_node_reader.h"
 #include "nested_node_reader.h"
 #include "list_nested_node_reader.h"
+#include "field_list.h"
+
+#include "message_reader.h"
+#include "message_builder.h"
+#include "stream_fd_message_reader.h"
+#include "malloc_message_builder.h"
+#include "flat_array_message_reader.h"
+
 #include "dynamic_struct_reader.h"
+#include "dynamic_struct_builder.h"
 #include "dynamic_list_reader.h"
-#include "stream_fd_message_reader.h"
+#include "dynamic_list_builder.h"
 #include "dynamic_object_reader.h"
-#include "message_reader.h"
-#include "field_list.h"
-
-extern "C" {
-  void Init_init();
-}
+#include "dynamic_object_builder.h"
 
 using namespace ruby_capn_proto;
 
 extern "C" {
   void Init_capn_proto() {
+    Exception::Init();
+
     SchemaParser::Init();
-    SchemaNodeReader::Init();
     ParsedSchema::Init();
     StructSchema::Init();
-    MessageReader::Init();
-    ListNestedNodeReader::Init();
+    SchemaNodeReader::Init();
     NestedNodeReader::Init();
+    ListNestedNodeReader::Init();
+    FieldList::Init();
+
+    MessageReader::Init();
+    MessageBuilder::Init();
+    StreamFdMessageReader::Init();
+    MallocMessageBuilder::Init();
+    FlatArrayMessageReader::Init();
+
     DynamicStructReader::Init();
+    DynamicStructBuilder::Init();
     DynamicListReader::Init();
-    StreamFdMessageReader::Init();
-    FieldList::Init();
+    DynamicListBuilder::Init();
     DynamicObjectReader::Init();
+    DynamicObjectBuilder::Init();
   }
 }

data/ext/capn_proto/malloc_message_builder.cc

@@ -0,0 +1,51 @@
+#include "ruby_capn_proto.h"
+#include "malloc_message_builder.h"
+#include "message_builder.h"
+#include "struct_schema.h"
+#include "dynamic_struct_builder.h"
+#include "class_builder.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::MallocMessageBuilder;
+  VALUE MallocMessageBuilder::Class;
+
+  void MallocMessageBuilder::Init() {
+    ClassBuilder("MallocMessageBuilder", MessageBuilder::Class).
+      defineAlloc(&alloc).
+      defineMethod("initialize", &initialize).
+      defineMethod("init_root", &init_root).
+      // defineMethod("get_root", &get_root).
+      store(&Class);
+  }
+
+  VALUE MallocMessageBuilder::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  VALUE MallocMessageBuilder::initialize(VALUE self) {
+    WrappedType* p = unwrap(self);
+    new (p) WrappedType();
+    return Qnil;
+  }
+
+  void MallocMessageBuilder::free(WrappedType* p) {
+    p->~MallocMessageBuilder();
+    ruby_xfree(p);
+  }
+
+  WrappedType* MallocMessageBuilder::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE MallocMessageBuilder::init_root(VALUE self, VALUE rb_schema) {
+    if (rb_respond_to(rb_schema, rb_intern("schema"))) {
+      rb_schema = rb_funcall(rb_schema, rb_intern("schema"), 0);
+    }
+
+    auto schema = *StructSchema::unwrap(rb_schema);
+    auto builder = unwrap(self)->initRoot<capnp::DynamicStruct>(schema);
+    return DynamicStructBuilder::create(builder, self, true);
+  }
+}

data/ext/capn_proto/malloc_message_builder.h

@@ -0,0 +1,21 @@
+#ifndef MALLOC_MESSAGE_BUILDER_H
+#define MALLOC_MESSAGE_BUILDER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class MallocMessageBuilder {
+  public:
+    using WrappedType = capnp::MallocMessageBuilder;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE initialize(VALUE klass);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE init_root(VALUE name, VALUE schema);
+
+    static VALUE Class;
+  };
+}
+
+#endif

data/ext/capn_proto/message_builder.cc

@@ -0,0 +1,22 @@
+#include "ruby_capn_proto.h"
+#include "message_builder.h"
+#include "class_builder.h"
+#include "struct_schema.h"
+#include "dynamic_struct_reader.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::MessageBuilder;
+  VALUE MessageBuilder::Class;
+
+  void MessageBuilder::Init() {
+    ClassBuilder("MessageBuilder", rb_cObject).
+      store(&Class);
+  }
+
+  WrappedType* MessageBuilder::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+}

data/ext/capn_proto/message_builder.h

@@ -0,0 +1,17 @@
+#ifndef MESSAGE_BUILDER_H
+#define MESSAGE_BUILDER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class MessageBuilder {
+  public:
+    using WrappedType = capnp::MessageBuilder;
+    static void Init();
+    static WrappedType* unwrap(VALUE self);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* MESSAGE_BUILDER_H */

data/ext/capn_proto/stream_fd_message_reader.cc

@@ -4,6 +4,7 @@
 #include "struct_schema.h"
 #include "dynamic_struct_reader.h"
 #include "class_builder.h"
+#include "exception.h"
 
 namespace ruby_capn_proto {
   using WrappedType = capnp::StreamFdMessageReader;
@@ -25,7 +26,12 @@ namespace ruby_capn_proto {
     VALUE rb_fileno = rb_funcall(rb_io, rb_intern("fileno"), 0);
     auto fileno = FIX2INT(rb_fileno);
     WrappedType* p = unwrap(self);
-    new (p) WrappedType(fileno);
+
+    try {
+      new (p) WrappedType(fileno);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
 
     return Qnil;
   }

data/ext/capn_proto/stream_fd_message_reader.h

@@ -12,7 +12,7 @@ namespace ruby_capn_proto {
     static VALUE initialize(VALUE klass, VALUE io);
     static void free(WrappedType* p);
     static WrappedType* unwrap(VALUE self);
-    static VALUE get_root(VALUE name, VALUE schema);
+    static VALUE get_root(VALUE self, VALUE schema);
 
     static VALUE Class;
   };

data/ext/capn_proto/util.cc

@@ -22,4 +22,9 @@ namespace ruby_capn_proto {
   VALUE Util::toRubyString(kj::StringPtr string) {
     return rb_str_new(string.begin(), string.size());
   }
+
+  bool Util::isNegative(VALUE rb_obj) {
+    if (FIXNUM_P(rb_obj)) return FIX2LONG(rb_obj) < 0;
+    return RTEST(rb_funcall(rb_obj, '<', 1, INT2FIX(0)));
+  }
 }

data/ext/capn_proto/util.h

@@ -8,6 +8,7 @@ namespace ruby_capn_proto {
   public:
     static kj::Array<kj::String> toStringArray(VALUE array_of_strings);
     static kj::String toString(VALUE string);
+    static bool isNegative(VALUE rb_obj);
 
     static VALUE toRubyString(kj::StringPtr string);
   };

data/lib/capn_proto/version.rb

@@ -1,3 +1,3 @@
 module CapnProto
-  VERSION = "0.0.1.alpha.4"
+  VERSION = "0.0.1.alpha.5"
 end

data/lib/capn_proto.rb

@@ -22,9 +22,55 @@ module CapnProto
     end
   end
 
+  DynamicListBuilder.class_eval do
+    include Enumerable
+    def each
+      return to_enum(:each) unless block_given?
+      (0...size).each do |n|
+        yield self[n]
+      end
+    end
+  end
+
   DynamicStructReader.class_eval do
+    # examples:
+    #
+    #    x.employed?
+    #    x.age
     def method_missing(name, *args, &block)
-      self[name.to_s, *args, &block]
+      name = name.to_s
+
+      if name.end_with?("?")
+        which == name[0..-2]
+      else
+        self[name]
+      end
+    end
+  end
+
+  DynamicStructBuilder.class_eval do
+    # examples:
+    #
+    #    x.initSandwich
+    #    x.initPeople(10)
+    #    x.employed?
+    #    x.age = 10
+    #    x.age
+    def method_missing(name, *args, &block)
+      name = name.to_s
+
+      if name.start_with?("init") && name.size > 4
+        name = name[4..-1]
+        name[0] = name[0].downcase
+        init(name, *args)
+      elsif name.end_with?("=")
+        name = name[0..-2]
+        self[name] = args[0]
+      elsif name.end_with?("?")
+        which == name[0..-2]
+      else
+        self[name]
+      end
     end
   end
 
@@ -73,11 +119,18 @@ module CapnProto
         reader.get_root(self)
       end
 
-      def read_packed_from(io)
-        raise 'not implemented'
+      def make_from_bytes(bytes)
+        # TODO: support FFI pointers
+        reader = FlatArrayMessageReader.new(bytes)
+        reader.get_root(self)
       end
 
-      def new_message(file)
+      def new_message
+        builder = MallocMessageBuilder.new
+        builder.init_root(self)
+      end
+
+      def read_packed_from(io)
         raise 'not implemented'
       end
     end

data/spec/capn_proto_spec.rb

@@ -1,3 +1,5 @@
+require 'tempfile'
+require 'spec_helper'
 require 'capn_proto'
 
 ADDRESSBOOK_SCHEMA = File.expand_path("../addressbook.capnp", __FILE__)
@@ -5,3 +7,74 @@ ADDRESSBOOK_SCHEMA = File.expand_path("../addressbook.capnp", __FILE__)
 module AddressBook extend CapnProto::SchemaLoader
   load_schema(ADDRESSBOOK_SCHEMA)
 end
+
+describe "reading" do
+  describe "Dynamic Structs" do
+    let(:file) { open_file("addressbook.bin") }
+    let(:addresses) { AddressBook::AddressBook.read_from(file) }
+
+    it "unkown fields raise exception" do
+      expect { addresses.foo }.to raise_error(CapnProto::Exception)
+    end
+  end
+
+  describe "Dynamic Lists" do
+    let(:file) { open_file("addressbook.bin") }
+    let(:addresses) { AddressBook::AddressBook.read_from(file) }
+    let(:people) { addresses.people }
+
+    it "#[] given out-of-bounds index raises" do
+      expect { addresses.people[999999] }.to raise_error(CapnProto::Exception)
+    end
+  end
+end
+
+describe "writing" do
+  describe "#write" do
+    it "full circle" do
+      tmp = Tempfile.new('test.bin')
+      addresses = AddressBook::AddressBook.new_message
+      people = addresses.initPeople(1)
+      bob = people[0]
+      bob.name = "Bob"
+      bob.id = 123
+      addresses.write(tmp)
+
+      tmp.rewind
+      addresses = AddressBook::AddressBook.read_from(tmp)
+      expect(addresses.people.size).to eq 1
+      expect(addresses.people.first.name).to eq "Bob"
+      expect(addresses.people.first.id).to eq 123
+    end
+  end
+
+  describe "#to_bytes" do
+    it "full circle" do
+      addresses = AddressBook::AddressBook.new_message
+      people = addresses.initPeople(1)
+      bob = people[0]
+      bob.name = "Bob"
+      bob.id = 123
+      bytes = addresses.to_bytes
+
+      addresses = AddressBook::AddressBook.make_from_bytes(bytes)
+      expect(addresses.people.size).to eq 1
+      expect(addresses.people.first.name).to eq "Bob"
+      expect(addresses.people.first.id).to eq 123
+    end
+  end
+
+  describe "Dynamic Structs" do
+    let(:addresses) { AddressBook::AddressBook.new_message }
+
+    it "works" do
+      people = addresses.initPeople(3)
+      bob = people.first
+      bob.name = "Bob"
+      bob.id = 10
+
+      people[1] = bob
+      x = people[1]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+RSpec.configure do |c|
+  c.include(Module.new do
+    def open_file(path)
+      path = File.join(File.expand_path("../", __FILE__), path)
+      File.open(path, "rb")
+    end
+  end)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capn_proto
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha.4
+  version: 0.0.1.alpha.5
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-25 00:00:00.000000000 Z
+date: 2013-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -114,16 +114,23 @@ files:
 - examples/create_test_data.py
 - examples/example.rb
 - ext/capn_proto/.ycm_extra_conf.py
-- ext/capn_proto/.ycm_extra_conf.pyc
 - ext/capn_proto/class_builder.cc
 - ext/capn_proto/class_builder.h
 - ext/capn_proto/cxx_compiler.rb
+- ext/capn_proto/dynamic_list_builder.cc
+- ext/capn_proto/dynamic_list_builder.h
 - ext/capn_proto/dynamic_list_reader.cc
 - ext/capn_proto/dynamic_list_reader.h
+- ext/capn_proto/dynamic_object_builder.cc
+- ext/capn_proto/dynamic_object_builder.h
 - ext/capn_proto/dynamic_object_reader.cc
 - ext/capn_proto/dynamic_object_reader.h
+- ext/capn_proto/dynamic_struct_builder.cc
+- ext/capn_proto/dynamic_struct_builder.h
 - ext/capn_proto/dynamic_struct_reader.cc
 - ext/capn_proto/dynamic_struct_reader.h
+- ext/capn_proto/dynamic_value_builder.cc
+- ext/capn_proto/dynamic_value_builder.h
 - ext/capn_proto/dynamic_value_reader.cc
 - ext/capn_proto/dynamic_value_reader.h
 - ext/capn_proto/exception.cc
@@ -131,9 +138,15 @@ files:
 - ext/capn_proto/extconf.rb
 - ext/capn_proto/field_list.cc
 - ext/capn_proto/field_list.h
+- ext/capn_proto/flat_array_message_reader.cc
+- ext/capn_proto/flat_array_message_reader.h
 - ext/capn_proto/init.cc
 - ext/capn_proto/list_nested_node_reader.cc
 - ext/capn_proto/list_nested_node_reader.h
+- ext/capn_proto/malloc_message_builder.cc
+- ext/capn_proto/malloc_message_builder.h
+- ext/capn_proto/message_builder.cc
+- ext/capn_proto/message_builder.h
 - ext/capn_proto/message_reader.cc
 - ext/capn_proto/message_reader.h
 - ext/capn_proto/nested_node_reader.cc
@@ -162,6 +175,7 @@ files:
 - spec/addressbook.capnp
 - spec/capn_proto_spec.rb
 - spec/create_test_data.py
+- spec/spec_helper.rb
 homepage: https://github.com/cstrahan/capnp-ruby
 licenses:
 - MIT
@@ -177,7 +191,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -525111796228691179
+      hash: 3271871129015226386
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: