capn_proto 0.0.1.alpha.3 → 0.0.1.alpha.4

data/.travis.yml

@@ -16,5 +16,4 @@ before_install:
                                      --slave   /usr/bin/g++  g++  /usr/bin/g++-4.8
                                      --slave   /usr/bin/gcov gcov /usr/bin/gcov-4.8
   - sudo update-alternatives --quiet --set gcc /usr/bin/gcc-4.8
-  - wget https://github.com/kentonv/capnproto/archive/master.zip && unzip master.zip && cd capnproto-master/c++ && ./setup-autotools.sh && autoreconf -i && ./configure && make -j6 check && sudo make install && sudo ldconfig && cd ../..
-  - export CXXFLAGS="-std=c++11"
+  - git clone --depth=1 https://github.com/kentonv/capnproto.git && cd capnproto/c++ && ./setup-autotools.sh && autoreconf -i && ./configure && make -j6 check && sudo make install && sudo ldconfig && cd ../..

data/README.md

@@ -6,7 +6,7 @@
 
 This here is a [Ruby][ruby] wrapper for the official C++ implementation of [Cap'n Proto][capnp].
 
-[![Build Status](https://travis-ci.org/cstrahan/capnp-ruby.png?branch=master)](https://travis-ci.org/cstrahan/capnp-ruby)
+[![Build Status][travis-badge]][travis-link]
 
 # Installing
 
@@ -16,12 +16,10 @@ First [install libcapnp][libcapnp-install], then install the gem:
 gem install capn_proto --pre
 ```
 
-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:
+The native extension for this gem requires a C++ compiler with C++11 features, so use the same C++ compiler and flags that you used to compile libcapnp (e.g. `CXX` and `CXXFLAGS`). 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 --pre
+CXX=$HOME/clang-3.2/bin/clang++ gem install capn_proto --pre
 ```
 
 # Example
@@ -78,3 +76,6 @@ Proper support for [JRuby][jruby] will come after I implement support for Java.
 [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"
+
+[travis-link]: https://travis-ci.org/cstrahan/capnp-ruby
+[travis-badge]: https://travis-ci.org/cstrahan/capnp-ruby.png?branch=master

data/Rakefile

@@ -1,3 +1,4 @@
+require 'capn_proto/version'
 GEMSPEC = eval(File.read('capn_proto.gemspec'))
 
 require 'rubygems/package_task'
@@ -17,9 +18,23 @@ end
 
 task :default => [:compile, :spec]
 
+Rake::Task["clean"].clear
+task :clean do
+  rm_r "tmp" rescue nil
+  rm "lib/capn_proto/capn_proto.bundle" rescue nil
+end
+
+task :release => [:clean, :compile, :spec, :gem]  do
+  tag = "v#{CapnProto::VERSION}"
+  sh "git tag #{tag}"
+  sh "git push origin #{tag}"
+  sh "gem push pkg/capn_proto-#{CapnProto::VERSION}.gem"
+end
+
 task :console do
   $: << File.expand_path("../lib", __FILE__)
   require 'irb'
+  require 'capn_proto'
   ARGV.clear
   IRB.start
 end

data/ext/capn_proto/cxx_compiler.rb

@@ -0,0 +1,126 @@
+require 'shellwords'
+require 'tmpdir'
+
+# Discovers support for C++11 features,
+# and any required CXXFLAGS for such features.
+class CXXCompiler
+  CXX_COMPILER_FEATURES = <<-CODE
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+    typedef check<check<bool>> right_angle_brackets;
+
+    int a;
+    decltype(a) b;
+
+    typedef check<int> check_type;
+    check_type c;
+    check_type&& cr = static_cast<check_type&&>(c);
+
+    #ifdef __has_include
+    #if __has_include(<type_traits>)
+    #include <type_traits>
+    #endif
+    #endif
+  CODE
+
+  CXX_LIBRARY_FEATURES = <<-CODE
+    #include <initializer_list>
+    #include <unordered_map>
+    #include <atomic>
+    #include <thread>
+  CODE
+
+  # env: The environment variables (e.g. CXX, CXXFLAGS).
+  def initialize(env)
+    @env = env.dup
+    @exist = system("command -v #{@env['CXX'].shellescape} >/dev/null 2>&1")
+  end
+
+  # True if the compiler is accessible on the $PATH.
+  def exist?
+    @exist
+  end
+
+  # True if support for C++11 was detected, false otherwise.
+  def has_cxx11_compiler_support?
+    !!std_flag
+  end
+
+  # True if support for C++11 libraries was detected, false otherwise.
+  def has_cxx11_library_support?
+    !!stdlib_flag
+  end
+
+  # The required std flag (e.g. '-std=c++11'),
+  # empty string if unecessary given the current environment and/or compiler,
+  # or nil in the case where the compiler has no support.
+  def std_flag
+    test_compiler_flags(@env)
+    @std_flag
+  end
+
+  # The required stdlib flag (e.g. '-stdlib=libc++'),
+  # empty string if unecessary given the current environment and/or compiler,
+  # or nil in the case where the compiler has no support.
+  def stdlib_flag
+    test_compiler_flags(@env)
+    @stdlib_flag
+  end
+
+  private
+
+  # Detect any required flags.
+  def test_compiler_flags(env)
+    return if @tested || !exist?
+    @tested = true
+
+    cxxflags = (env['CXXFLAGS'] || '')
+    env = env.dup
+
+    flags = ['', '-std=gnu++11', '-std=gnu++0x', '-std=c++11', '-std=c++0x']
+    @std_flag = flags.detect do |flag|
+      env['CXXFLAGS'] = [cxxflags, flag].join(' ')
+      compile(CXX_COMPILER_FEATURES, env)
+    end
+
+    return unless @std_flag
+
+    env = env.dup
+    flags = ['', '-stdlib=libc++']
+    @stdlib_flag = flags.detect do |flag|
+      env['CXXFLAGS'] = [cxxflags, std_flag, flag].join(' ')
+      compile(CXX_LIBRARY_FEATURES, env)
+    end
+  end
+
+  # Compile a snippet of C++, returning true or false to indicate
+  # success.
+  def compile(code, env)
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        File.open("test.cc", "w") {|f| f.write(code)}
+        system("#{env['CXX'].shellescape} #{env['CXXFLAGS']} -c test.cc >/dev/null 2>&1")
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  compiler         = CXXCompiler.new(ENV.to_hash)
+  cxx              = ENV['CXX']
+  cxxflags         = ENV['CXXFLAGS']
+  extra_cxxflags   = [compiler.std_flag, compiler.stdlib_flag].join(' ')
+  compiler_support = compiler.has_cxx11_compiler_support? ? 'YES' : 'NO'
+  lib_support      = compiler.has_cxx11_library_support? ? 'YES' : 'NO'
+
+  puts "     given CXX      = #{cxx}"
+  puts "     given CXXFLAGS = #{cxxflags}"
+  puts "additional CXXFLAGS = #{extra_cxxflags}"
+  puts ""
+  puts "Has C++11 compiler support?  #{compiler_support}"
+  puts "Has C++11 library support?   #{lib_support}"
+end

data/ext/capn_proto/dynamic_list_reader.cc

@@ -35,6 +35,8 @@ namespace ruby_capn_proto {
     WrappedType* wrapped = unwrap(rb_obj);
     *wrapped = kj::mv(reader);
 
+    rb_iv_set(rb_obj, "parent", parent);
+
     return rb_obj;
   }
 

data/ext/capn_proto/dynamic_object_reader.cc

@@ -0,0 +1,56 @@
+#include "ruby_capn_proto.h"
+#include "dynamic_object_reader.h"
+#include "dynamic_struct_reader.h"
+#include "struct_schema.h"
+#include "class_builder.h"
+#include "util.h"
+
+namespace ruby_capn_proto {
+  using WrappedType = capnp::ObjectPointer::Reader;
+  VALUE DynamicObjectReader::Class;
+
+  void DynamicObjectReader::Init() {
+    ClassBuilder("DynamicObjectReader", rb_cObject).
+      defineAlloc(&alloc).
+      defineMethod("as_struct", &as_struct).
+      store(&Class);
+  }
+
+  void DynamicObjectReader::free(WrappedType* p) {
+    p->~Reader();
+    ruby_xfree(p);
+  }
+
+  VALUE DynamicObjectReader::alloc(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
+  }
+
+  WrappedType* DynamicObjectReader::unwrap(VALUE self) {
+    WrappedType* p;
+    Data_Get_Struct(self, WrappedType, p);
+    return p;
+  }
+
+  VALUE DynamicObjectReader::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 DynamicObjectReader::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 DynamicStructReader::create(
+      reader.getAs<capnp::DynamicStruct>(schema),
+      self);
+  }
+}

data/ext/capn_proto/dynamic_object_reader.h

@@ -0,0 +1,22 @@
+#ifndef DYNAMIC_OBJECT_READER_H
+#define DYNAMIC_OBJECT_READER_H
+
+#include "ruby_capn_proto.h"
+
+namespace ruby_capn_proto {
+  class DynamicObjectReader {
+  public:
+    using WrappedType = capnp::ObjectPointer::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 as_struct(VALUE self, VALUE name);
+
+    static VALUE Class;
+  };
+}
+
+
+#endif /* DYNAMIC_STRUCT_READER_H */

data/ext/capn_proto/dynamic_struct_reader.cc

@@ -31,11 +31,13 @@ namespace ruby_capn_proto {
     return p;
   }
 
-  VALUE DynamicStructReader::create(WrappedType reader) {
+  VALUE DynamicStructReader::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;
   }
 

data/ext/capn_proto/dynamic_struct_reader.h

@@ -9,7 +9,7 @@ namespace ruby_capn_proto {
     using WrappedType = capnp::DynamicStruct::Reader;
     static void Init();
     static VALUE alloc(VALUE klass);
-    static VALUE create(WrappedType reader);
+    static VALUE create(WrappedType reader, VALUE parent);
     static void free(WrappedType* p);
     static WrappedType* unwrap(VALUE self);
     static VALUE which(VALUE self);

data/ext/capn_proto/dynamic_value_reader.cc

@@ -2,6 +2,7 @@
 #include "dynamic_value_reader.h"
 #include "dynamic_list_reader.h"
 #include "dynamic_struct_reader.h"
+#include "dynamic_object_reader.h"
 
 namespace ruby_capn_proto {
   VALUE DynamicValueReader::to_ruby(capnp::DynamicValue::Reader value, VALUE parent) {
@@ -10,9 +11,9 @@ namespace ruby_capn_proto {
       case capnp::DynamicValue::BOOL:
         return value.as<bool>() ? Qtrue : Qfalse;
       case capnp::DynamicValue::INT:
-        return INT2FIX(value.as<int64_t>());
+        return INT2NUM(value.as<int64_t>());
       case capnp::DynamicValue::UINT:
-        return INT2FIX(value.as<uint64_t>());
+        return UINT2NUM(value.as<uint64_t>());
       case capnp::DynamicValue::FLOAT:
         return rb_float_new(value.as<double>());
       case capnp::DynamicValue::TEXT:
@@ -28,7 +29,7 @@ namespace ruby_capn_proto {
       case capnp::DynamicValue::LIST:
         return DynamicListReader::create(value.as<capnp::DynamicList>(), parent);
       case capnp::DynamicValue::STRUCT:
-        return DynamicStructReader::create(value.as<capnp::DynamicStruct>());
+        return DynamicStructReader::create(value.as<capnp::DynamicStruct>(), parent);
       case capnp::DynamicValue::ENUM:
         {
           auto enumerant_maybe = value.as<capnp::DynamicEnum>().getEnumerant();
@@ -39,6 +40,8 @@ namespace ruby_capn_proto {
             return Qnil;
           }
         }
+      case capnp::DynamicValue::OBJECT:
+        return DynamicObjectReader::create(value.as<capnp::ObjectPointer>(), parent);
       case capnp::DynamicValue::VOID:
         return Qnil;
       case capnp::DynamicValue::UNKNOWN:

data/ext/capn_proto/extconf.rb

@@ -1,4 +1,18 @@
 require 'mkmf'
+require File.expand_path("../cxx_compiler", __FILE__)
+
+compiler = CXXCompiler.new({'CXX' => CONFIG['CXX']}.merge(ENV.to_hash))
+unless compiler.has_cxx11_compiler_support?
+  abort "*** A compiler with support for C++11 language features is required."
+end
+unless compiler.has_cxx11_library_support?
+  abort "*** A C++ library with support for C++11 features is required."
+end
+
+CONFIG['CXX']      = ENV['CXX'] || CONFIG['CXX']
+CONFIG['CXXFLAGS'] = [(ENV['CXXFLAGS'] || CONFIG['CXXFLAGS']),
+                      compiler.std_flag,
+                      compiler.stdlib_flag].join(' ')
 
 if enable_config('debug')
   CONFIG['CFLAGS'] += " -O0 -ggdb3"
@@ -6,24 +20,8 @@ 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('capn_proto/capn_proto')
-
-# 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/init.cc

@@ -8,6 +8,7 @@
 #include "dynamic_struct_reader.h"
 #include "dynamic_list_reader.h"
 #include "stream_fd_message_reader.h"
+#include "dynamic_object_reader.h"
 #include "message_reader.h"
 #include "field_list.h"
 
@@ -30,5 +31,6 @@ extern "C" {
     DynamicListReader::Init();
     StreamFdMessageReader::Init();
     FieldList::Init();
+    DynamicObjectReader::Init();
   }
 }

data/ext/capn_proto/list_nested_node_reader.cc

@@ -31,10 +31,13 @@ namespace ruby_capn_proto {
     return p;
   }
 
-  VALUE ListNestedNodeReader::create(NodeList schema) {
+  VALUE ListNestedNodeReader::create(NodeList schema, VALUE parent) {
     VALUE rb_obj = alloc(Class);
     NodeList* wrapped_schema = unwrap(rb_obj);
     *wrapped_schema = kj::mv(schema);
+
+    rb_iv_set(rb_obj, "parent", parent);
+
     return rb_obj;
   }
 

data/ext/capn_proto/list_nested_node_reader.h

@@ -13,7 +13,7 @@ namespace ruby_capn_proto {
     static VALUE alloc(VALUE klass);
     static void free(NodeList* p);
     static NodeList* unwrap(VALUE self);
-    static VALUE create(NodeList reader);
+    static VALUE create(NodeList reader, VALUE parent);
     static VALUE size(VALUE self);
     static VALUE get(VALUE self, VALUE index);
 

data/ext/capn_proto/parsed_schema.cc

@@ -33,7 +33,7 @@ namespace ruby_capn_proto {
     return p;
   }
 
-  VALUE ParsedSchema::create(VALUE parent, WrappedType schema) {
+  VALUE ParsedSchema::create(WrappedType schema, VALUE parent) {
     VALUE rb_obj = alloc(Class);
     WrappedType* wrapped_schema = unwrap(rb_obj);
     *wrapped_schema = kj::mv(schema);
@@ -44,15 +44,15 @@ namespace ruby_capn_proto {
   }
 
   VALUE ParsedSchema::get_proto(VALUE self) {
-    return SchemaNodeReader::create(unwrap(self)->getProto());
+    return SchemaNodeReader::create(unwrap(self)->getProto(), self);
   }
 
   VALUE ParsedSchema::get_nested(VALUE self, VALUE rb_name) {
     auto name = Util::toString(rb_name);
-    return create(self, unwrap(self)->getNested(name));
+    return create(unwrap(self)->getNested(name), self);
   }
 
   VALUE ParsedSchema::as_struct(VALUE self) {
-    return StructSchema::create(unwrap(self)->asStruct());
+    return StructSchema::create(unwrap(self)->asStruct(), self);
   }
 }

data/ext/capn_proto/parsed_schema.h

@@ -9,7 +9,7 @@ namespace ruby_capn_proto {
     using WrappedType = capnp::ParsedSchema;
     static void Init();
     static VALUE alloc(VALUE klass);
-    static VALUE create(VALUE parent, WrappedType schema);
+    static VALUE create(WrappedType schema, VALUE parent);
     static void free(WrappedType* p);
     static WrappedType* unwrap(VALUE self);
     static VALUE get_proto(VALUE self);

data/ext/capn_proto/ruby_capn_proto.h

@@ -14,6 +14,7 @@
 #include <capnp/schema.h>
 #include <capnp/message.h>
 #include <capnp/dynamic.h>
+#include <capnp/object.h>
 
 #include <ruby.h>
 #ifdef __

data/ext/capn_proto/schema_node_reader.cc

@@ -19,10 +19,13 @@ namespace ruby_capn_proto {
     return Data_Wrap_Struct(klass, NULL, free, ruby_xmalloc(sizeof(WrappedType)));
   }
 
-  VALUE SchemaNodeReader::create(WrappedType reader) {
+  VALUE SchemaNodeReader::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;
   }
 
@@ -38,7 +41,7 @@ namespace ruby_capn_proto {
   }
 
   VALUE SchemaNodeReader::get_nested_nodes(VALUE self) {
-    return ListNestedNodeReader::create(unwrap(self)->getNestedNodes());
+    return ListNestedNodeReader::create(unwrap(self)->getNestedNodes(), self);
   }
 
   VALUE SchemaNodeReader::is_struct(VALUE self) {

data/ext/capn_proto/schema_node_reader.h

@@ -8,7 +8,7 @@ namespace ruby_capn_proto {
   public:
     static void Init();
     static VALUE alloc(VALUE klass);
-    static VALUE create(capnp::schema::Node::Reader reader);
+    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);

data/ext/capn_proto/schema_parser.cc

@@ -48,6 +48,6 @@ namespace ruby_capn_proto {
         StringValueCStr(rb_disk_path),
         importsPtrs
         );
-    return ParsedSchema::create(self, schema);
+    return ParsedSchema::create(schema, self);
   }
 }

data/ext/capn_proto/stream_fd_message_reader.cc

@@ -48,6 +48,6 @@ namespace ruby_capn_proto {
 
     auto schema = *StructSchema::unwrap(rb_schema);
     auto reader = unwrap(self)->getRoot<capnp::DynamicStruct>(schema);
-    return DynamicStructReader::create(reader);
+    return DynamicStructReader::create(reader, self);
   }
 }

data/ext/capn_proto/struct_schema.cc

@@ -31,11 +31,13 @@ namespace ruby_capn_proto {
     return p;
   }
 
-  VALUE StructSchema::create(WrappedType schema) {
+  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;
   }
 

data/ext/capn_proto/struct_schema.h

@@ -9,7 +9,7 @@ namespace ruby_capn_proto {
     using WrappedType = capnp::StructSchema;
     static void Init();
     static VALUE alloc(VALUE klass);
-    static VALUE create(WrappedType schema);
+    static VALUE create(WrappedType schema, VALUE parent);
     static void free(WrappedType* p);
     static WrappedType* unwrap(VALUE self);
     static VALUE field_names(VALUE self);

data/lib/capn_proto/version.rb

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

data/lib/capn_proto.rb

@@ -1,9 +1,11 @@
 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
@@ -13,6 +15,7 @@ module CapnProto
   DynamicListReader.class_eval do
     include Enumerable
     def each
+      return to_enum(:each) unless block_given?
       (0...size).each do |n|
         yield self[n]
       end
@@ -23,12 +26,6 @@ module CapnProto
     def method_missing(name, *args, &block)
       self[name.to_s, *args, &block]
     end
-
-    def each
-      (0...size).each do |n|
-        yield self[n]
-      end
-    end
   end
 
   module SchemaLoader
@@ -41,29 +38,29 @@ module CapnProto
 
       @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
+
+        nested_nodes.each do |nested_node|
+          nested_mod = mod.const_set(nested_node.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(schema, self)
-    end
-
-    def _load_schema_rec(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
-
-      nested_nodes.each do |nested_node|
-        nested_mod = mod.const_set(nested_node.name, Module.new)
-        nested_schema = schema.get_nested(nested_node.name)
-        _load_schema_rec(nested_schema, nested_mod)
-      end
+      load_schema_rec.call(schema, self)
     end
 
     module Struct

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capn_proto
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha.3
+  version: 0.0.1.alpha.4
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-04 00:00:00.000000000 Z
+date: 2013-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -117,8 +117,11 @@ files:
 - 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_reader.cc
 - ext/capn_proto/dynamic_list_reader.h
+- ext/capn_proto/dynamic_object_reader.cc
+- ext/capn_proto/dynamic_object_reader.h
 - ext/capn_proto/dynamic_struct_reader.cc
 - ext/capn_proto/dynamic_struct_reader.h
 - ext/capn_proto/dynamic_value_reader.cc
@@ -174,7 +177,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2636867598034040588
+      hash: -525111796228691179
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: