capn_proto-rpc 0.1.1.alpha.rpc

data/ext/capn_proto/schema_node_reader.h

@@ -0,0 +1,23 @@
+#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, VALUE parent);
+    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 is_interface(VALUE self);
+
+    static VALUE Class;
+  };
+}
+
+#endif /* SCHEMA_NODE_READER_H */

data/ext/capn_proto/schema_parser.cc

@@ -0,0 +1,61 @@
+#include "ruby_capn_proto.h"
+#include "schema_parser.h"
+#include "parsed_schema.h"
+#include "exception.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) {
+    try {
+
+      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(schema, self);
+
+    }catch ( kj::Exception t ){
+      Exception::raise(t);
+      return Qnil;
+    }
+  }
+}

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 */

data/ext/capn_proto/stream_fd_message_reader.cc

@@ -0,0 +1,59 @@
+#include "ruby_capn_proto.h"
+#include "message_reader.h"
+#include "stream_fd_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::StreamFdMessageReader;
+  VALUE StreamFdMessageReader::Class;
+
+  void StreamFdMessageReader::Init() {
+    ClassBuilder("StreamFdMessageReader", MessageReader::Class).
+      defineAlloc(&alloc).
+      defineMethod("initialize", &initialize).
+      defineMethod("get_root", &get_root).
+      store(&Class);
+  }
+
+  VALUE StreamFdMessageReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  VALUE StreamFdMessageReader::initialize(VALUE self, VALUE rb_io) {
+    VALUE rb_fileno = rb_funcall(rb_io, rb_intern("fileno"), 0);
+    auto fileno = FIX2INT(rb_fileno);
+    WrappedType* p = unwrap(self);
+
+    try {
+      new (p) WrappedType(fileno);
+    } catch (kj::Exception ex) {
+      return Exception::raise(ex);
+    }
+
+    return Qnil;
+  }
+
+  void StreamFdMessageReader::free(WrappedType* p) {
+    p->~StreamFdMessageReader();
+    ruby_xfree(p);
+  }
+
+  WrappedType* StreamFdMessageReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE StreamFdMessageReader::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/stream_fd_message_reader.h

@@ -0,0 +1,21 @@
+#ifndef STREAM_FD_MESSAGE_READER_H
+#define STREAM_FD_MESSAGE_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class StreamFdMessageReader {
+  public:
+    using WrappedType = capnp::StreamFdMessageReader;
+    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 /* STREAM_FD_MESSAGE_READER_H */

data/ext/capn_proto/struct_schema.cc

@@ -0,0 +1,59 @@
+#include "ruby_capn_proto.h"
+#include "struct_schema.h"
+#include "field_list.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::StructSchema;
+  VALUE StructSchema::Class;
+
+  void StructSchema::Init() {
+    ClassBuilder("StructSchema", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("field_names", &field_names).
+      defineMethod("fields", &fields).
+      store(&Class);
+  }
+
+  void StructSchema::free(WrappedType* p) {
+    p->~StructSchema();
+    ruby_xfree(p);
+  }
+
+  VALUE StructSchema::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* StructSchema::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE StructSchema::create(WrappedType schema, VALUE parent) {
+    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 StructSchema::field_names(VALUE self) {
+    auto field_list = unwrap(self)->getFields();
+    auto size = field_list.size();
+    auto rb_array = rb_ary_new2(size);
+    for (int i=0; i<size; i++) {
+      auto name = field_list[i].getProto().getName();
+      rb_ary_push(rb_array, rb_str_new(name.begin(), name.size()));
+    }
+
+    return rb_array;
+  }
+
+  VALUE StructSchema::fields(VALUE self) {
+    return FieldList::create(unwrap(self)->getFields());
+  }
+}

data/ext/capn_proto/struct_schema.h

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

data/ext/capn_proto/util.cc

@@ -0,0 +1,30 @@
+#include "util.h"
+
+namespace ruby_capn_proto {
+  kj::Array<kj::String> Util::toStringArray(VALUE rb_array) {
+    auto len = RARRAY_LEN(rb_array);
+    auto array = kj::heapArray<kj::String>(len);
+    for (int i=0; i < len; i++) {
+      auto rb_str = rb_ary_entry(rb_array, i);
+      array[i] = toString(rb_str);
+    }
+
+    return array;
+  }
+
+  kj::String Util::toString(VALUE rb_string) {
+    auto rb_val = StringValue(rb_string);
+    auto str = RSTRING_PTR(rb_val);
+    auto len = RSTRING_LEN(rb_val);
+    return kj::heapString(str, len);
+  }
+
+  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

@@ -0,0 +1,17 @@
+#ifndef UTIL_H
+#define UTIL_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class Util {
+  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);
+  };
+}
+
+#endif /* UTIL_H */

data/lib/capn_proto.rb

@@ -0,0 +1,231 @@
+require 'capn_proto/capn_proto'
+require 'capn_proto/version'
+
+module CapnProto
+  ListNestedNodeReader.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
+
+  DynamicListReader.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
+
+  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
+    def method_missing(name, *args, &block)
+      name = name.to_s
+
+      if name.end_with?("?")
+        which == name[0..-2]
+      else
+        self[name]
+      end
+    end
+  end
+
+  DynamicStructBuilder.class_eval do
+    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
+
+  module SchemaLoader
+    def schema_parser
+      @schema_parser
+    end
+
+    def load_schema(file_name, imports=[])
+      display_name = self.name
+
+      @schema_parser ||= CapnProto::SchemaParser.new
+
+      load_schema_rec = Proc.new do |schema, mod|
+        node = schema.get_proto
+        nested_nodes = node.nested_nodes
+
+        if node.struct?
+          struct_schema = schema.as_struct
+          mod.instance_variable_set(:@schema, struct_schema)
+          mod.extend(Struct)
+        end
+
+        if node.interface?
+          interface_schema = schema.as_interface
+          mod.instance_variable_set(:@schema, interface_schema)
+          mod.extend(Interface)
+        end
+
+        nested_nodes.each do |nested_node|
+          const_name = nested_node.name
+          const_name[0] = const_name[0].upcase
+          nested_mod = mod.const_set(const_name, Module.new)
+          nested_schema = schema.get_nested(nested_node.name)
+          load_schema_rec.call(nested_schema, nested_mod)
+        end
+      end
+
+      schema = @schema_parser.parse_disk_file(
+      display_name,
+      file_name,
+      imports);
+
+      load_schema_rec.call(schema, self)
+    end
+
+    module Struct
+      def schema
+        @schema
+      end
+
+      def read_from(io)
+        reader = StreamFdMessageReader.new(io)
+        reader.get_root(self)
+      end
+
+      def make_from_bytes(bytes)
+        # TODO: support FFI pointers
+        reader = FlatArrayMessageReader.new(bytes)
+        reader.get_root(self)
+      end
+
+      def new_message
+        builder = MallocMessageBuilder.new
+        builder.init_root(self)
+      end
+
+      def read_packed_from(io)
+        raise 'not implemented'
+      end
+    end
+
+    module Interface
+      attr_reader :schema
+
+      def method?(name)
+        @schema.find_method_by_name name
+      end
+
+      def method!(name) #short and ruby friendlier alias for find_method_by_name
+        temp = @schema.find_method_by_name name
+        if temp
+          return temp
+        else
+          raise "Method #{name} not found in this interface"
+        end
+      end
+    end
+  end
+
+  class RequestBuilder
+    attr_reader :data
+
+    def initialize
+      @data = []
+      @currentArray = []
+    end
+
+    def method_missing(*args)
+      if args.length == 1
+        @currentArray << args.pop.to_s
+        return self # to chain methods like .expression.literal(3)
+      elsif args.length == 2
+        @currentArray << args.shift.to_s
+        @currentArray << args.shift
+        @data << @currentArray
+        @currentArray = []
+      else
+        super
+      end
+    end
+
+    def wait(waitscope)
+      @to_request.wait(waitscope)
+    end
+  end
+
+  class Request < RequestBuilder
+
+    def initialize( client, method )
+      @to_request = client
+      @method = method
+      super()
+    end
+
+    def send
+      PipelinedRequest.new(@to_request.request_and_send(@method,@data))
+    end
+
+  end
+
+  class PipelinedRequest < RequestBuilder
+    attr_accessor :method
+
+    def initialize( remotePromise )
+      @to_request = remotePromise
+      super()
+    end
+
+    def get(value)
+      @value = value
+      return self # to chain calls like get('value').readRequest
+    end
+
+    def send
+      if !@value || !@method
+        raise "call both get and set method before calling send"
+      end
+      @to_request.request_and_send(@value,@method,@data)
+    end
+  end
+
+  DynamicCapabilityClient.class_eval do
+
+    def request(method)
+      Request.new(self,method)
+    end
+
+  end
+
+  class CapabilityServer
+
+    def initialize(interface)
+      @schema = interface
+    end
+
+  end
+
+end