capn_proto 0.0.1.alpha.1

data/ext/capn_proto/dynamic_value_reader.h

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

data/ext/capn_proto/exception.cc

@@ -0,0 +1,24 @@
+#include "ruby_capn_proto.h"
+#include "exception.h"
+#include "class_builder.h"
+#include "util.h"
+
+// VALUE rb_eException;
+// VALUE rb_eStandardError;
+// VALUE rb_eRuntimeError;
+
+namespace ruby_capn_proto {
+  using WrappedType = kj::Exception;
+  VALUE Exception::Class;
+
+  void Exception::Init() {
+    ClassBuilder("Exception", rb_eException).
+      store(&Class);
+  }
+
+  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;
+  }
+}

data/ext/capn_proto/exception.h

@@ -0,0 +1,18 @@
+#ifndef EXCEPTION_H
+#define EXCEPTION_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class Exception {
+  public:
+    using WrappedType = kj::Exception;
+    static void Init();
+    static VALUE create(WrappedType schema);
+
+    static VALUE Class;
+  };
+}
+
+
+#endif /* EXCEPTION_H */

data/ext/capn_proto/extconf.rb

@@ -0,0 +1,29 @@
+require 'mkmf'
+
+if enable_config('debug')
+  CONFIG['CFLAGS'] += " -O0 -ggdb3"
+else
+  $CPPFLAGS += " -DNDEBUG"
+end
+
+CONFIG['CXX'] = ENV['CXX'] if ENV['CXX']
+CONFIG['CXXFLAGS'] += " #{ENV['CXXFLAGS']}" if ENV['CXXFLAGS']
+
+$LDFLAGS += " -lcapnpc"
+$LDFLAGS += " -lcapnp"
+$LDFLAGS += " -lkj"
+
+create_makefile('ruby_capn_proto/init')
+
+# HACK ATTACK
+# def inreplace(path, search, replace)
+  # contents = File.read(path)
+  # contents.gsub!(search, replace)
+  # File.open(path, "w") do |f|
+    # f.write(contents)
+  # end
+# end
+
+# inreplace("Makefile", "V = 0", "V = 1")
+# inreplace("Makefile", "-O3", "-O0")
+# inreplace("Makefile", "ECHO = $(ECHO1:0=@echo)", "ECHO = @echo")

data/ext/capn_proto/field_list.cc

@@ -0,0 +1,51 @@
+#include "ruby_capn_proto.h"
+#include "field_list.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::StructSchema::FieldList;
+  VALUE FieldList::Class;
+
+  void FieldList::Init() {
+    ClassBuilder("FieldList", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("size", &size).
+      defineMethod("[]", &get).
+      store(&Class);
+  }
+
+  void FieldList::free(WrappedType* p) {
+    p->~FieldList();
+    ruby_xfree(p);
+  }
+
+  VALUE FieldList::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* FieldList::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE FieldList::create(WrappedType schema) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped_schema = unwrap(rb_obj);
+    *wrapped_schema = kj::mv(schema);
+
+    return rb_obj;
+  }
+
+  VALUE FieldList::get(VALUE self, VALUE index) {
+    auto idx = FIX2INT(index);
+    auto list = *unwrap(self);
+    return Qnil;
+    // return Field::create(list[idx]);
+  }
+
+  VALUE FieldList::size(VALUE self) {
+    return INT2FIX(unwrap(self)->size());
+  }
+}

data/ext/capn_proto/field_list.h

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

data/ext/capn_proto/init.cc

@@ -0,0 +1,34 @@
+#include "ruby_capn_proto.h"
+#include "parsed_schema.h"
+#include "schema_parser.h"
+#include "schema_node_reader.h"
+#include "struct_schema.h"
+#include "nested_node_reader.h"
+#include "list_nested_node_reader.h"
+#include "dynamic_struct_reader.h"
+#include "dynamic_list_reader.h"
+#include "stream_fd_message_reader.h"
+#include "message_reader.h"
+#include "field_list.h"
+
+extern "C" {
+  void Init_init();
+}
+
+using namespace ruby_capn_proto;
+
+extern "C" {
+  void Init_init() {
+    SchemaParser::Init();
+    SchemaNodeReader::Init();
+    ParsedSchema::Init();
+    StructSchema::Init();
+    MessageReader::Init();
+    ListNestedNodeReader::Init();
+    NestedNodeReader::Init();
+    DynamicStructReader::Init();
+    DynamicListReader::Init();
+    StreamFdMessageReader::Init();
+    FieldList::Init();
+  }
+}

data/ext/capn_proto/list_nested_node_reader.cc

@@ -0,0 +1,50 @@
+#include "ruby_capn_proto.h"
+#include "list_nested_node_reader.h"
+#include "nested_node_reader.h"
+#include "class_builder.h"
+
+namespace ruby_capn_proto {
+  using NodeList = ::capnp::List< ::capnp::schema::Node::NestedNode>::Reader;
+
+  VALUE ListNestedNodeReader::Class;
+
+  void ListNestedNodeReader::Init() {
+    ClassBuilder("ListNestedNodeReader", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("size", &size).
+      defineMethod("[]", &get).
+      store(&Class);
+  }
+
+  void ListNestedNodeReader::free(NodeList* p) {
+    p->~NodeList();
+    ruby_xfree(p);
+  }
+
+  VALUE ListNestedNodeReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(NodeList)));
+  }
+
+  NodeList* ListNestedNodeReader::unwrap(VALUE self) {
+    NodeList* p;
+    Data_Get_Struct(self, NodeList, p);
+    return p;
+  }
+
+  VALUE ListNestedNodeReader::create(NodeList schema) {
+    VALUE rb_obj = alloc(Class);
+    NodeList* wrapped_schema = unwrap(rb_obj);
+    *wrapped_schema = kj::mv(schema);
+    return rb_obj;
+  }
+
+  VALUE ListNestedNodeReader::size(VALUE self) {
+    return INT2FIX(unwrap(self)->size());
+  }
+
+  VALUE ListNestedNodeReader::get(VALUE self, VALUE index) {
+    auto idx = FIX2INT(index);
+    auto list = *unwrap(self);
+    return NestedNodeReader::create(list[idx]);
+  }
+}

data/ext/capn_proto/list_nested_node_reader.h

@@ -0,0 +1,24 @@
+#ifndef LIST_NESTED_NODE_READER_H
+#define LIST_NESTED_NODE_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class ListNestedNodeReader {
+  public:
+    using NodeList = ::capnp::List< ::capnp::schema::Node::NestedNode>::Reader;
+
+    static void Init();
+    static VALUE initialize(VALUE klass);
+    static VALUE alloc(VALUE klass);
+    static void free(NodeList* p);
+    static NodeList* unwrap(VALUE self);
+    static VALUE create(NodeList reader);
+    static VALUE size(VALUE self);
+    static VALUE get(VALUE self, VALUE index);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* LIST_NESTED_NODE_READER_H */

data/ext/capn_proto/message_reader.cc

@@ -0,0 +1,30 @@
+#include "ruby_capn_proto.h"
+#include "message_reader.h"
+#include "class_builder.h"
+#include "struct_schema.h"
+#include "dynamic_struct_reader.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::MessageReader;
+  VALUE MessageReader::Class;
+
+  void MessageReader::Init() {
+    ClassBuilder("MessageReader", rb_cObject).
+      store(&Class);
+  }
+
+  // XXX
+  // I wanted to use inheritance here for #get_root,
+  // but this segfaults unless I reinterpret_cast to the right
+  // subclass of capnp::MessageReader. Whish I know more about
+  // the C++ object model :(...
+  // Worst case scenario, I could probably use tempalates...
+  // If only I had experience with them.
+
+  WrappedType* MessageReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+}

data/ext/capn_proto/message_reader.h

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

data/ext/capn_proto/nested_node_reader.cc

@@ -0,0 +1,42 @@
+#include "ruby_capn_proto.h"
+#include "nested_node_reader.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::schema::Node::NestedNode::Reader;
+  VALUE NestedNodeReader::Class;
+
+  void NestedNodeReader::Init() {
+    ClassBuilder("NestedNodeReader", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("name", &name).
+      store(&Class);
+  }
+
+  VALUE NestedNodeReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  VALUE NestedNodeReader::create(WrappedType reader) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped = unwrap(rb_obj);
+    *wrapped = kj::mv(reader);
+    return rb_obj;
+  }
+
+  void NestedNodeReader::free(WrappedType* p) {
+    p->~Reader();
+    ruby_xfree(p);
+  }
+
+  WrappedType* NestedNodeReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE NestedNodeReader::name(VALUE self) {
+    return Util::toRubyString(unwrap(self)->getName());
+  }
+}

data/ext/capn_proto/nested_node_reader.h

@@ -0,0 +1,21 @@
+#ifndef NESTED_NODE_READER_H
+#define NESTED_NODE_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class NestedNodeReader {
+  public:
+    using WrappedType = capnp::schema::Node::NestedNode::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 name(VALUE self);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* NESTED_NODE_READER_H */

data/ext/capn_proto/parsed_schema.cc

@@ -0,0 +1,58 @@
+#include "ruby_capn_proto.h"
+#include "parsed_schema.h"
+#include "schema_node_reader.h"
+#include "struct_schema.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::ParsedSchema;
+  VALUE ParsedSchema::Class;
+
+  void ParsedSchema::Init() {
+    ClassBuilder("ParsedSchema", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("get_proto", &get_proto).
+      defineMethod("get_nested", &get_nested).
+      defineMethod("as_struct", &as_struct).
+      store(&Class);
+  }
+
+  void ParsedSchema::free(WrappedType* p) {
+    p->~ParsedSchema();
+    ruby_xfree(p);
+  }
+
+  VALUE ParsedSchema::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* ParsedSchema::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE ParsedSchema::create(VALUE parent, WrappedType schema) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped_schema = unwrap(rb_obj);
+    *wrapped_schema = kj::mv(schema);
+
+    rb_iv_set(rb_obj, "parent", parent);
+
+    return rb_obj;
+  }
+
+  VALUE ParsedSchema::get_proto(VALUE self) {
+    return SchemaNodeReader::create(unwrap(self)->getProto());
+  }
+
+  VALUE ParsedSchema::get_nested(VALUE self, VALUE rb_name) {
+    auto name = Util::toString(rb_name);
+    return create(self, unwrap(self)->getNested(name));
+  }
+
+  VALUE ParsedSchema::as_struct(VALUE self) {
+    return StructSchema::create(unwrap(self)->asStruct());
+  }
+}

data/ext/capn_proto/parsed_schema.h

@@ -0,0 +1,23 @@
+#ifndef PARSED_SCHEMA_H
+#define PARSED_SCHEMA_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class ParsedSchema {
+  public:
+    using WrappedType = capnp::ParsedSchema;
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(VALUE parent, WrappedType schema);
+    static void free(WrappedType* p);
+    static WrappedType* unwrap(VALUE self);
+    static VALUE get_proto(VALUE self);
+    static VALUE get_nested(VALUE self, VALUE name);
+    static VALUE as_struct(VALUE name);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* PARSED_SCHEMA_H */

data/ext/capn_proto/ruby_capn_proto.cc

@@ -0,0 +1,4 @@
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+}

data/ext/capn_proto/ruby_capn_proto.h

@@ -0,0 +1,38 @@
+#ifndef RUBY_CAPN_PROTO_H
+#define RUBY_CAPN_PROTO_H
+
+#include <iostream>
+#include <vector>
+
+#include <kj/common.h>
+#include <kj/array.h>
+
+#include <capnp/serialize.h>
+#include <capnp/serialize-packed.h>
+#include <capnp/message.h>
+#include <capnp/schema-parser.h>
+#include <capnp/schema.h>
+#include <capnp/message.h>
+#include <capnp/dynamic.h>
+
+#include <ruby.h>
+#ifdef __
+#undef __
+#endif
+#ifdef HAVE_RUBY_ENCODING_H
+#include "ruby/encoding.h"
+#endif
+
+#if defined(RUBY_METHOD_FUNC)
+# undef RUBY_METHOD_FUNC
+# if RUBY_VERSION_CODE <= 166
+    extern "C" typedef VALUE (*RUBY_METHOD_FUNC)();
+# else
+    extern "C" typedef VALUE (*RUBY_METHOD_FUNC)(ANYARGS);
+# endif
+#endif
+
+namespace ruby_capn_proto {
+}
+
+#endif /* RUBY_CAPN_PROTO_H */

data/ext/capn_proto/schema_node_reader.cc

@@ -0,0 +1,51 @@
+#include "ruby_capn_proto.h"
+#include "schema_node_reader.h"
+#include "list_nested_node_reader.h"
+#include "class_builder.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::schema::Node::Reader;
+  VALUE SchemaNodeReader::Class;
+
+  void SchemaNodeReader::Init() {
+    ClassBuilder("SchemaNodeReader", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("nested_nodes", &get_nested_nodes).
+      defineMethod("struct?", &is_struct).
+      store(&Class);
+  }
+
+  VALUE SchemaNodeReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  VALUE SchemaNodeReader::create(WrappedType reader) {
+    VALUE rb_obj = alloc(Class);
+    WrappedType* wrapped = unwrap(rb_obj);
+    *wrapped = kj::mv(reader);
+    return rb_obj;
+  }
+
+  void SchemaNodeReader::free(WrappedType* p) {
+    p->~Reader();
+    ruby_xfree(p);
+  }
+
+  WrappedType* SchemaNodeReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE SchemaNodeReader::get_nested_nodes(VALUE self) {
+    return ListNestedNodeReader::create(unwrap(self)->getNestedNodes());
+  }
+
+  VALUE SchemaNodeReader::is_struct(VALUE self) {
+    return unwrap(self)->isStruct() ? Qtrue : Qfalse;
+  }
+
+  VALUE SchemaNodeReader::is_enum(VALUE self) {
+    return unwrap(self)->isEnum() ? Qtrue : Qfalse;
+  }
+}

data/ext/capn_proto/schema_node_reader.h

@@ -0,0 +1,22 @@
+#ifndef SCHEMA_NODE_READER_H
+#define SCHEMA_NODE_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class SchemaNodeReader {
+  public:
+    static void Init();
+    static VALUE alloc(VALUE klass);
+    static VALUE create(capnp::schema::Node::Reader reader);
+    static void free(capnp::schema::Node::Reader* p);
+    static capnp::schema::Node::Reader* unwrap(VALUE self);
+    static VALUE get_nested_nodes(VALUE self);
+    static VALUE is_struct(VALUE self);
+    static VALUE is_enum(VALUE self);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* SCHEMA_NODE_READER_H */

data/ext/capn_proto/schema_parser.cc

@@ -0,0 +1,53 @@
+#include "ruby_capn_proto.h"
+#include "schema_parser.h"
+#include "parsed_schema.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  VALUE SchemaParser::Class;
+  using WrappedType = capnp::SchemaParser;
+
+  void SchemaParser::Init() {
+    ClassBuilder("SchemaParser", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("initialize", &initialize).
+      defineMethod("parse_disk_file", &parse_disk_file).
+      store(&Class);
+  }
+
+  void SchemaParser::free(SchemaParser* p) {
+    p->~SchemaParser();
+    ruby_xfree(p);
+  }
+
+  VALUE SchemaParser::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* SchemaParser::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE SchemaParser::initialize(VALUE self) {
+    WrappedType* p = unwrap(self);
+    new (p) WrappedType();
+
+    return Qnil;
+  }
+
+  VALUE SchemaParser::parse_disk_file(VALUE self, VALUE rb_display_name, VALUE rb_disk_path, VALUE rb_import_path) {
+    auto imports = Util::toStringArray(rb_import_path);
+    auto importsPtrs = KJ_MAP(s, imports) -> kj::StringPtr { return s; };
+
+    auto display_name = Util::toString(rb_display_name);
+    auto schema = unwrap(self)->parseDiskFile(
+        display_name,
+        StringValueCStr(rb_disk_path),
+        importsPtrs
+        );
+    return ParsedSchema::create(self, schema);
+  }
+}

data/ext/capn_proto/schema_parser.h

@@ -0,0 +1,20 @@
+#ifndef SCHEMA_PARSER_H
+#define SCHEMA_PARSER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class SchemaParser {
+  public:
+    static void Init();
+    static VALUE parse_disk_file(VALUE self, VALUE display_name, VALUE disk_path, VALUE import_path);
+    static VALUE initialize(VALUE klass);
+    static VALUE alloc(VALUE klass);
+    static void free(SchemaParser* p);
+    static capnp::SchemaParser* unwrap(VALUE self);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* SCHEMA_PARSER_H */