capn_proto 0.0.1.alpha.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Charles Strahan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/cstrahan/capnp-ruby/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+
+![Cap'n Proto][logo]
+
+# Ruby Edition
+
+This here is a [Ruby][ruby] wrapper for the official C++ implementation of [Cap'n Proto][capnp].
+
+# Installing
+
+First [install libcapnp][libcapnp-install], then install the gem:
+
+```bash
+gem install capn_proto
+```
+
+Remember to set the `CXX` and `CXXFLAGS` environment variables as necessary. As an OSX user, having followed the [instructions for installing libcapnp on OSX][libcapnp-install], the correct incantation is as follows:
+
+```bash
+export CXX=$HOME/clang-3.2/bin/clang++
+export CXXFLAGS="-std=c++11 -stdlib=libc++"
+gem install capn_proto
+```
+
+# License
+
+The MIT License
+
+# Status
+
+- [x] Schema parsing (and recursive Module definition)
+- [x] Message reading
+- [ ] Message writing
+
+Proper support for [JRuby][jruby] will come after I implement support for Java.
+
+[logo]: https://raw.github.com/cstrahan/capnp-ruby/master/media/captain_proto_small.png "Cap'n Proto"
+[ruby]: http://www.ruby-lang.org/ "Ruby"
+[capnp]: http://kentonv.github.io/capnproto/ "Cap'n Proto"
+[jruby]: http://jruby.org/ "JRuby"
+[libcapnp-install]: http://kentonv.github.io/capnproto/install.html "Installing Cap'n Proto"
+[mit-license]: http://opensource.org/licenses/MIT "MIT License"

data/Rakefile

@@ -0,0 +1,25 @@
+GEMSPEC = eval(File.read('capn_proto.gemspec'))
+
+require 'rubygems/package_task'
+Gem::PackageTask.new(GEMSPEC) do |pkg|
+end
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('init', GEMSPEC) do |ext|
+  ext.ext_dir = 'ext/capn_proto'
+  ext.lib_dir = 'lib/capn_proto'
+  ext.source_pattern = "*.{cc,h}"
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |config|
+end
+
+task :default => [:compile, :spec]
+
+task :console do
+  $: << File.expand_path("../lib", __FILE__)
+  require 'irb'
+  ARGV.clear
+  IRB.start
+end

data/capn_proto.gemspec

@@ -0,0 +1,33 @@
+require File.expand_path('../lib/capn_proto/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = 'capn_proto'
+  s.version = CapnProto::VERSION
+
+  s.summary = "Cap'n Proto (libcapnp) bindings for Ruby."
+
+  s.description =
+    "This gem wraps the official C++ implementation of Cap'n Proto " \
+    "(libcapnp). " \
+    "From the Cap'n Proto documentation: " \
+    "\"Cap'n Proto is an insanely fast data interchange format and " \
+    "capability-based RPC system. Think JSON, except binary. " \
+    "Or think Protocol Buffers, except faster.\""
+
+  s.homepage = 'https://github.com/cstrahan/capnp-ruby'
+
+  s.authors = ['Charles Strahan']
+  s.email = ['charles.c.strahan@gmail.com']
+
+  s.add_development_dependency 'rspec', '2.14.1'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rake-compiler', '0.7.6'
+
+  s.add_development_dependency 'awesome_print'
+  s.add_development_dependency 'interactive_editor'
+
+  s.extensions = ['ext/capn_proto/extconf.rb']
+  s.require_paths = ['lib']
+
+  s.files = `git ls-files`.split("\n")
+end

data/examples/addressbook.capnp

@@ -0,0 +1,31 @@
+@0x9eb32e19f86ee174;
+
+struct Person {
+  id @0 :UInt32;
+  name @1 :Text;
+  email @2 :Text;
+  phones @3 :List(PhoneNumber);
+
+  struct PhoneNumber {
+    number @0 :Text;
+    type @1 :Type;
+
+    enum Type {
+      mobile @0;
+      home @1;
+      work @2;
+    }
+  }
+
+  employment :union {
+    unemployed @4 :Void;
+    employer @5 :Text;
+    school @6 :Text;
+    selfEmployed @7 :Void;
+    # We assume that a person is only one of these.
+  }
+}
+
+struct AddressBook {
+  people @0 :List(Person);
+}

data/examples/create_test_data.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import os
+import capnp
+
+this_dir = os.path.dirname(__file__)
+out_path = os.path.join(this_dir, 'addressbook.bin')
+addressbook = capnp.load(os.path.join(this_dir, 'addressbook.capnp'))
+
+def writeAddressBook(file):
+    addresses = addressbook.AddressBook.newMessage()
+    people = addresses.init('people', 2)
+
+    alice = people[0]
+    alice.id = 123
+    alice.name = 'Alice'
+    alice.email = 'alice@example.com'
+    alicePhones = alice.init('phones', 1)
+    alicePhones[0].number = "555-1212"
+    alicePhones[0].type = 'mobile'
+    alice.employment.school = "MIT"
+
+    bob = people[1]
+    bob.id = 456
+    bob.name = 'Bob'
+    bob.email = 'bob@example.com'
+    bobPhones = bob.init('phones', 2)
+    bobPhones[0].number = "555-4567"
+    bobPhones[0].type = 'home'
+    bobPhones[1].number = "555-7654"
+    bobPhones[1].type = 'work'
+    bob.employment.unemployed = None
+
+    addresses.writeTo(file)
+
+
+if __name__ == '__main__':
+    f = open(out_path, 'w')
+    writeAddressBook(f)

data/examples/example.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+$: << File.expand_path("../../lib", __FILE__)
+$: << File.expand_path("../../ext", __FILE__)
+require 'capn_proto'
+
+ADDRESSBOOK_SCHEMA = File.expand_path("../addressbook.capnp", __FILE__);
+MESSAGE = File.expand_path("../addressbook.bin", __FILE__);
+
+module AddressBook extend CapnProto::SchemaLoader
+  load_schema(ADDRESSBOOK_SCHEMA)
+end
+
+def print_address_book(file)
+  addresses = AddressBook::AddressBook.read_from(file)
+
+  addresses.people.each do |person|
+    puts "#{person.name} : #{person.email}"
+    person.phones.each do |phone|
+      puts "#{phone.type} : #{phone.number}"
+    end
+
+    which = person.employment.which
+    puts which
+
+    if which == "unemployed"
+      puts "unemployed"
+    elsif which == 'employer'
+      puts "employer: #{person.employment.employer}"
+    elsif which == "school"
+      puts "student at: #{person.employment.school}"
+    elsif which == "selfEmployed"
+      puts "self employed"
+    end
+  end
+end
+
+file = File.open(MESSAGE, "rb")
+print_address_book(file)

data/ext/capn_proto/.ycm_extra_conf.py

@@ -0,0 +1,65 @@
+# vim: ts=2 et sw=2 sts=2
+
+import os
+import ycm_core
+import glob
+import subprocess
+
+def RubyInclude():
+  cmd = ["ruby", "-e", "print RbConfig::CONFIG['rubyhdrdir']"]
+  process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+  rubyhdrdir = process.stdout.read()
+  return rubyhdrdir
+
+flags = [
+'-Wall',
+'-Wextra',
+'-Werror',
+'-fexceptions',
+'-Wc++98-compat',
+'-std=c++11',
+'-x', 'c++',
+'-I', '.',
+'-I', '/usr/local/include',
+'-I', RubyInclude(),
+]
+
+def DirectoryOfThisScript():
+  return os.path.dirname( os.path.abspath( __file__ ) )
+
+def MakeRelativePathsInFlagsAbsolute( flags, working_directory ):
+  if not working_directory:
+    return list( flags )
+  new_flags = []
+  make_next_absolute = False
+  path_flags = [ '-isystem', '-I', '-iquote', '--sysroot=' ]
+  for flag in flags:
+    new_flag = flag
+
+    if make_next_absolute:
+      make_next_absolute = False
+      if not flag.startswith( '/' ):
+        new_flag = os.path.join( working_directory, flag )
+
+    for path_flag in path_flags:
+      if flag == path_flag:
+        make_next_absolute = True
+        break
+
+      if flag.startswith( path_flag ):
+        path = flag[ len( path_flag ): ]
+        new_flag = path_flag + os.path.join( working_directory, path )
+        break
+
+    if new_flag:
+      new_flags.append( new_flag )
+  return new_flags
+
+def FlagsForFile( filename ):
+  relative_to = DirectoryOfThisScript()
+  final_flags = MakeRelativePathsInFlagsAbsolute( flags, relative_to )
+
+  return {
+    'flags': final_flags,
+    'do_cache': True
+  }

data/ext/capn_proto/class_builder.cc

@@ -0,0 +1,80 @@
+#include "ruby_capn_proto.h"
+#include "class_builder.h"
+
+namespace ruby_capn_proto {
+
+  VALUE defineClass(const char *name, VALUE superclass = rb_cObject) {
+    VALUE CapnProto = rb_define_module("CapnProto");
+    VALUE klass = rb_define_class_under(CapnProto, name, superclass);
+    // rb_funcall(klass, rb_intern("private_class_method"), 1, rb_str_new2("new"));
+    return klass;
+  }
+
+  ClassBuilder::ClassBuilder(const char* name, VALUE superclass) {
+    this->value = defineClass(name, superclass);
+  }
+  ClassBuilder::ClassBuilder(const char* name, const char* supername) {
+    VALUE superclass = defineClass(supername);
+    this->value = defineClass(name, superclass);
+  }
+
+  ClassBuilder& ClassBuilder::defineAlloc(VALUE (*impl)(VALUE)) {
+    rb_define_alloc_func(this->value, (VALUE (*)(VALUE))impl);
+    return *this;
+  }
+
+  ClassBuilder& ClassBuilder::defineConst(const char* name, VALUE value) {
+    rb_define_const(this->value, name, value);
+    return *this;
+  }
+
+  ClassBuilder& ClassBuilder::defineMethod(const char* name, VALUE (*impl)(int, VALUE*, VALUE)) {
+    rb_define_method(this->value, name, (VALUE (*)(...))impl, -1);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineMethod(const char* name, VALUE (*impl)(VALUE)) {
+    rb_define_method(this->value, name, (VALUE (*)(...))impl, 0);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineMethod(const char* name, VALUE (*impl)(VALUE, VALUE)) {
+    rb_define_method(this->value, name, (VALUE (*)(...))impl, 1);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE)) {
+    rb_define_method(this->value, name, (VALUE (*)(...))impl, 2);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE, VALUE)) {
+    rb_define_method(this->value, name, (VALUE (*)(...))impl, 3);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineSingletonMethod(const char* name, VALUE (*impl)(int, VALUE*, VALUE)) {
+    rb_define_singleton_method(this->value, name, (VALUE (*)(...))impl, -1);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineSingletonMethod(const char* name, VALUE (*impl)(VALUE)) {
+    rb_define_singleton_method(this->value, name, (VALUE (*)(...))impl, 0);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineSingletonMethod(const char* name, VALUE (*impl)(VALUE, VALUE)) {
+    rb_define_singleton_method(this->value, name, (VALUE (*)(...))impl, 1);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineSingletonMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE)) {
+    rb_define_singleton_method(this->value, name, (VALUE (*)(...))impl, 2);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineSingletonMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE, VALUE)) {
+    rb_define_singleton_method(this->value, name, (VALUE (*)(...))impl, 3);
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::defineEnumConst(const char* name, int value) {
+    rb_define_const(this->value, name, INT2FIX(value));
+    return *this;
+  }
+  ClassBuilder& ClassBuilder::store(VALUE* storage) {
+    rb_gc_register_address(storage);
+    *storage = this->value;
+    return *this;
+  }
+}

data/ext/capn_proto/class_builder.h

@@ -0,0 +1,72 @@
+#ifndef CLASS_BUILDER_H
+#define CLASS_BUILDER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class ClassBuilder {
+  public:
+    ClassBuilder() {};
+    ClassBuilder(const char* name, VALUE superclass = rb_cObject);
+    ClassBuilder(const char* name, const char* supername);
+    ClassBuilder& defineAlloc(VALUE (*impl)(VALUE));
+    ClassBuilder& defineConst(const char* name, VALUE value);
+    ClassBuilder& defineMethod(const char* name, VALUE (*impl)(int, VALUE*, VALUE));
+    ClassBuilder& defineMethod(const char* name, VALUE (*impl)(VALUE));
+    ClassBuilder& defineMethod(const char* name, VALUE (*impl)(VALUE, VALUE));
+    ClassBuilder& defineMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE));
+    ClassBuilder& defineMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE, VALUE));
+    ClassBuilder& defineSingletonMethod(const char* name, VALUE (*impl)(int, VALUE*, VALUE));
+    ClassBuilder& defineSingletonMethod(const char* name, VALUE (*impl)(VALUE));
+    ClassBuilder& defineSingletonMethod(const char* name, VALUE (*impl)(VALUE, VALUE));
+    ClassBuilder& defineSingletonMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE));
+    ClassBuilder& defineSingletonMethod(const char* name, VALUE (*impl)(VALUE, VALUE, VALUE, VALUE));
+    ClassBuilder& defineEnumConst(const char* name, int value);
+    ClassBuilder& store(VALUE* storage);
+    inline operator VALUE() {return this->value;}
+  protected:
+    VALUE value;
+  };
+
+  template <VALUE(* f)(int, VALUE*, VALUE)>
+  VALUE handleExceptions(int argc, VALUE* argv, VALUE self)
+  {
+    try {
+      return f(argc, argv, self);
+    } catch (...) {
+      rb_raise(rb_eRuntimeError, "caught unkown error");
+    }
+  }
+
+  template <VALUE(* f)(VALUE)>
+  VALUE handleExceptions(VALUE self)
+  {
+    return f(self);
+  }
+
+  template <VALUE(* f)(VALUE, VALUE)>
+  VALUE handleExceptions(VALUE self, VALUE arg1)
+  {
+    return f(self, arg1);
+  }
+
+  template <VALUE(* f)(VALUE, VALUE, VALUE)>
+  VALUE handleExceptions(VALUE self, VALUE arg1, VALUE arg2)
+  {
+    return f(self, arg1, arg2);
+  }
+
+  template <VALUE(* f)(VALUE, VALUE, VALUE, VALUE)>
+  VALUE handleExceptions(VALUE self, VALUE arg2, VALUE arg1, VALUE arg3)
+  {
+    return f(self, arg1, arg2, arg3);
+  }
+
+  template <VALUE(* f)(VALUE, VALUE, VALUE, VALUE, VALUE)>
+  VALUE handleExceptions(VALUE self, VALUE arg2, VALUE arg1, VALUE arg3, VALUE arg4)
+  {
+    return f(self, arg1, arg2, arg3, arg4);
+  }
+}
+
+#endif /* CLASS_BUILDER_H */

data/ext/capn_proto/dynamic_list_reader.cc

@@ -0,0 +1,52 @@
+#include "ruby_capn_proto.h"
+#include "dynamic_list_reader.h"
+#include "dynamic_value_reader.h"
+#include "class_builder.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::DynamicList::Reader;
+  VALUE DynamicListReader::Class;
+
+  void DynamicListReader::Init() {
+    ClassBuilder("DynamicListReader", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("[]", &get).
+      defineMethod("size", &size).
+      store(&Class);
+  }
+
+  VALUE DynamicListReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  void DynamicListReader::free(WrappedType* p) {
+    p->~Reader();
+    ruby_xfree(p);
+  }
+
+  WrappedType* DynamicListReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE DynamicListReader::create(WrappedType reader, VALUE parent) {
+    auto rb_obj = alloc(Class);
+    WrappedType* wrapped = unwrap(rb_obj);
+    *wrapped = kj::mv(reader);
+
+    return rb_obj;
+  }
+
+  VALUE DynamicListReader::size(VALUE self) {
+    return INT2FIX(unwrap(self)->size());
+  }
+
+  VALUE DynamicListReader::get(VALUE self, VALUE rb_index) {
+    auto reader = *unwrap(self);
+    auto index = FIX2INT(rb_index);
+    auto size = reader.size();
+
+    return DynamicValueReader::to_ruby(reader[index], self);
+  }
+}

data/ext/capn_proto/dynamic_list_reader.h

@@ -0,0 +1,23 @@
+#ifndef DYNAMIC_LIST_READER_H
+#define DYNAMIC_LIST_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class DynamicListReader {
+  public:
+    using WrappedType = capnp::DynamicList::Reader;
+    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 size(VALUE self);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* DYNAMIC_LIST_READER_H */

data/ext/capn_proto/dynamic_struct_reader.cc

@@ -0,0 +1,59 @@
+#include "ruby_capn_proto.h"
+#include "dynamic_struct_reader.h"
+#include "dynamic_value_reader.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::DynamicStruct::Reader;
+  VALUE DynamicStructReader::Class;
+
+  void DynamicStructReader::Init() {
+    ClassBuilder("DynamicStructReader", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("which", &which).
+      defineMethod("[]", &get).
+      store(&Class);
+  }
+
+  void DynamicStructReader::free(WrappedType* p) {
+    p->~Reader();
+    ruby_xfree(p);
+  }
+
+  VALUE DynamicStructReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* DynamicStructReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE DynamicStructReader::create(WrappedType reader) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped = unwrap(rb_obj);
+    *wrapped = kj::mv(reader);
+
+    return rb_obj;
+  }
+
+  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);
+  }
+
+  VALUE DynamicStructReader::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_reader.h

@@ -0,0 +1,23 @@
+#ifndef DYNAMIC_STRUCT_READER_H
+#define DYNAMIC_STRUCT_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class DynamicStructReader {
+  public:
+    using WrappedType = capnp::DynamicStruct::Reader;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(WrappedType reader);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE which(VALUE self);
+    static VALUE get(VALUE self, VALUE name);
+
+    static VALUE Class;
+  };
+}
+
+
+#endif /* DYNAMIC_STRUCT_READER_H */

data/ext/capn_proto/dynamic_value_reader.cc

@@ -0,0 +1,50 @@
+#include "ruby_capn_proto.h"
+#include "dynamic_value_reader.h"
+#include "dynamic_list_reader.h"
+#include "dynamic_struct_reader.h"
+
+namespace ruby_capn_proto {
+  VALUE DynamicValueReader::to_ruby(capnp::DynamicValue::Reader value, VALUE parent) {
+    switch (value.getType())
+    {
+      case capnp::DynamicValue::BOOL:
+        return value.as<bool>() ? Qtrue : Qfalse;
+      case capnp::DynamicValue::INT:
+        return INT2FIX(value.as<int64_t>());
+      case capnp::DynamicValue::UINT:
+        return INT2FIX(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 DynamicListReader::create(value.as<capnp::DynamicList>(), parent);
+        // return Qnil;
+      case capnp::DynamicValue::STRUCT:
+        return DynamicStructReader::create(value.as<capnp::DynamicStruct>());
+      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::VOID:
+        return Qnil;
+      case capnp::DynamicValue::UNKNOWN:
+      default:
+        return Qnil;
+    }
+  }
+}