jsonnet 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 594f8f8d8e1b7fe224e63b82ac7f66c29e56baee
-  data.tar.gz: c46ca9961aaa22fd42f54623b7a375487f4b541f
+  metadata.gz: 683ffa45384b3ea064634f162faea0450cdbb2ac
+  data.tar.gz: 74539b2a0e88253d86fad6ed532bc48240a74df2
 SHA512:
-  metadata.gz: fd7fbcc1dcdcdff7cc6f7367d8b878ae712326d5bc9f69a010b7bb5a42d98fad132c6ee1145fc21708d73422261e0d0b56e198c4a47e9756594144a84229eba1
-  data.tar.gz: 0f34b0b7b14ac0a290fa9f4f6563d8359f53343bd82f0b958f3f2c423e77eb58c92d3f82bb06bf16b9a46d546bcb288dba9e775cf1d2a91ed7ef2d617c929aad
+  metadata.gz: d1a6f533c001414eacd2b776f2a7cbdb53e9dae4a0c53e2b83e43e90a53fe4d4eb888a96eb76623ad1007ed2d0fd45cc49737795cc6b5adeb5524922bf5d0d00
+  data.tar.gz: 175c210648ad1a5fe49d2a5c5846039d5ffb9c62146880925ead54dfd69ded603b0cbf5b8f14db04fa87133f3867052af1a374f185bbb9dedf81853cc3424c37

data/.clang-format

@@ -0,0 +1,11 @@
+---
+BasedOnStyle: Google
+IndentWidth: 4
+ColumnLimit: 100
+---
+Language: Cpp
+PointerAlignment: Right
+AlwaysBreakAfterReturnType: AllDefinitions
+BreakBeforeBraces: Linux
+UseTab: Always
+TabWidth: 8

data/ext/jsonnet/callbacks.c

@@ -0,0 +1,241 @@
+#include <string.h>
+
+#include <libjsonnet.h>
+#include <ruby/ruby.h>
+
+#include "ruby_jsonnet.h"
+
+/* Magic prefix which distinguishes Ruby-level non-exception global escapes
+ * from other errors in Jsonnet.
+ * Any other errors in Jsonnet evaluation cannot contain this fragment of message.
+ */
+#define RUBYJSONNET_GLOBAL_ESCAPE_MAGIC "\x07\x03\x0c:rubytag:\x07\x03\x0c:"
+
+/*
+ * callback support in VM
+ */
+
+static ID id_call;
+
+/*
+ * Just invokes a callback with arguments, but also adapts the invocation to rb_protect.
+ * @param[in] args  list of arguments whose first value is the callable object itself.
+ * @return result of the callback
+ */
+static VALUE
+invoke_callback(VALUE args)
+{
+    long len = RARRAY_LEN(args);
+    VALUE callback = rb_ary_entry(args, 0);
+    return rb_funcall2(callback, id_call, len - 1, RARRAY_PTR(args) + 1);
+}
+
+/*
+ * Handles long jump caught by rb_protect() in a callback function.
+ *
+ * Returns an error message which represents rb_errinfo().
+ * It is the caller's responsibility to return the message to the Jsonnet VM
+ * in the right way.
+ * Also the caller of the VM must handle evaluation failure caused by the
+ * error message.
+ * \sa rubyjsonnet_jump_tag
+ * \sa raise_eval_error
+ */
+static VALUE
+rescue_callback(int state, const char *fmt, ...)
+{
+    VALUE err = rb_errinfo();
+    if (rb_obj_is_kind_of(err, rb_eException)) {
+	VALUE msg = rb_protect(rubyjsonnet_format_exception, rb_errinfo(), NULL);
+	if (msg == Qnil) {
+	    va_list ap;
+	    va_start(ap, fmt);
+	    msg = rb_vsprintf(fmt, ap);
+	    va_end(ap);
+	}
+	rb_set_errinfo(Qnil);
+	return msg;
+    }
+
+    /*
+     * Other types of global escape.
+     * Here, we'll report the state as an evaluation error to let
+     * the Jsonnet VM clean up its internal resources.
+     * But we'll translate the error into an non-exception global escape
+     * in Ruby again in raise_eval_error().
+     */
+    return rb_sprintf("%s%d%s", RUBYJSONNET_GLOBAL_ESCAPE_MAGIC, state,
+		      RUBYJSONNET_GLOBAL_ESCAPE_MAGIC);
+}
+
+/*
+ * Tries to extract a jump tag from a string representation encoded by
+ * rescue_callback.
+ * @retval zero if \a exc_mesg is not such a string representation.
+ * @retval non-zero the extracted tag
+ */
+int
+rubyjsonnet_jump_tag(const char *exc_mesg)
+{
+    const char *tag;
+#define JSONNET_RUNTIME_ERROR_PREFIX "RUNTIME ERROR: "
+    if (strncmp(exc_mesg, JSONNET_RUNTIME_ERROR_PREFIX, strlen(JSONNET_RUNTIME_ERROR_PREFIX))) {
+	return 0;
+    }
+    tag = strstr(exc_mesg + strlen(JSONNET_RUNTIME_ERROR_PREFIX), RUBYJSONNET_GLOBAL_ESCAPE_MAGIC);
+    if (tag) {
+	const char *const body = tag + strlen(RUBYJSONNET_GLOBAL_ESCAPE_MAGIC);
+	char *last;
+	long state = strtol(body, &last, 10);
+	if (!strncmp(last, RUBYJSONNET_GLOBAL_ESCAPE_MAGIC,
+		     strlen(RUBYJSONNET_GLOBAL_ESCAPE_MAGIC)) &&
+	    INT_MIN <= state && state <= INT_MAX) {
+	    return (int)state;
+	}
+    }
+    return 0;
+}
+
+static char *
+import_callback_entrypoint(void *ctx, const char *base, const char *rel, char **found_here,
+			   int *success)
+{
+    struct jsonnet_vm_wrap *const vm = (struct jsonnet_vm_wrap *)ctx;
+    int state;
+    VALUE result, args;
+
+    args = rb_ary_tmp_new(3);
+
+    rb_ary_push(args, vm->import_callback);
+    rb_ary_push(args, rb_enc_str_new_cstr(base, rb_filesystem_encoding()));
+    rb_ary_push(args, rb_enc_str_new_cstr(rel, rb_filesystem_encoding()));
+    result = rb_protect(invoke_callback, args, &state);
+
+    rb_ary_free(args);
+
+    if (state) {
+	VALUE msg = rescue_callback(state, "cannot import %s from %s", rel, base);
+	*success = 0;
+	return rubyjsonnet_str_to_cstr(vm->vm, msg);
+    }
+
+    result = rb_Array(result);
+    *success = 1;
+    *found_here = rubyjsonnet_str_to_cstr(vm->vm, rb_ary_entry(result, 1));
+    return rubyjsonnet_str_to_cstr(vm->vm, rb_ary_entry(result, 0));
+}
+
+/*
+ * Sets a custom way to resolve "import" expression.
+ * @param [#call] callback receives two parameters and returns two values.
+ *                The first parameter "base" is a base directory to resolve
+ *                "rel" from.
+ *                The second parameter "rel" is an absolute or a relative
+ *                path to the file to import.
+ *                The first return value is the content of the imported file.
+ *                The second return value is the resolved path of the imported file.
+ */
+static VALUE
+vm_set_import_callback(VALUE self, VALUE callback)
+{
+    struct jsonnet_vm_wrap *const vm = rubyjsonnet_obj_to_vm(self);
+
+    vm->import_callback = callback;
+    jsonnet_import_callback(vm->vm, import_callback_entrypoint, vm);
+
+    return callback;
+}
+
+/**
+ * Generic entrypoint of native callbacks which adapts callable objects in Ruby to \c
+ * JsonnetNativeCallback.
+ *
+ * @param[in] data pointer to a {\c struct native_callback_ctx}
+ * @param[in] argv NULL-terminated array of arguments
+ * @param[out] success set to 1 on success, or 0 if otherwise.
+ * @returns the result of the callback on success, an error message on failure.
+ */
+static struct JsonnetJsonValue *
+native_callback_entrypoint(void *data, const struct JsonnetJsonValue *const *argv, int *success)
+{
+    long i;
+    int state = 0;
+
+    struct native_callback_ctx *const ctx = (struct native_callback_ctx *)data;
+    struct JsonnetVm *const vm = rubyjsonnet_obj_to_vm(ctx->vm)->vm;
+    VALUE result, args = rb_ary_tmp_new(ctx->arity + 1);
+
+    rb_ary_push(args, ctx->callback);
+    for (i = 0; i < ctx->arity; ++i) {
+	rb_ary_push(args, rubyjsonnet_json_to_obj(vm, argv[i]));
+    }
+
+    result = rb_protect(invoke_callback, args, &state);
+
+    rb_ary_free(args);
+
+    if (state) {
+	VALUE msg = rescue_callback(state, "something wrong in %" PRIsVALUE, ctx->callback);
+	*success = 0;
+	return rubyjsonnet_obj_to_json(vm, msg, &state);
+    }
+
+    return rubyjsonnet_obj_to_json(vm, result, success);
+}
+
+/*
+ * Registers a native extension written in Ruby.
+ * @param callback [#call] a PURE callable object
+ * @param params [Array]   names of the parameters of the function
+ */
+static VALUE
+vm_register_native_callback(VALUE self, VALUE name, VALUE callback, VALUE params)
+{
+    struct {
+	volatile VALUE store;
+	long len;
+	const char **buf;
+    } cstr_params;
+    struct native_callback_ctx *ctx;
+    struct jsonnet_vm_wrap *vm = rubyjsonnet_obj_to_vm(self);
+    long i;
+
+    name = rb_to_symbol(name);
+    rubyjsonnet_assert_asciicompat(name);
+
+    params = rb_Array(params);
+    cstr_params.len = RARRAY_LEN(params);
+    cstr_params.buf = (const char **)rb_alloc_tmp_buffer(
+	&cstr_params.store, sizeof(const char *const) * (cstr_params.len + 1));
+    for (i = 0; i < cstr_params.len; ++i) {
+	const VALUE pname = rb_to_symbol(RARRAY_AREF(params, i));
+	rubyjsonnet_assert_asciicompat(pname);
+	cstr_params.buf[i] = rb_id2name(RB_SYM2ID(pname));
+    }
+    cstr_params.buf[cstr_params.len] = NULL;
+
+    ctx = RB_ALLOC_N(struct native_callback_ctx, 1);
+    ctx->callback = callback;
+    ctx->arity = cstr_params.len;
+    ctx->vm = self;
+    jsonnet_native_callback(vm->vm, rb_id2name(RB_SYM2ID(name)), native_callback_entrypoint, ctx,
+			    cstr_params.buf);
+
+    rb_free_tmp_buffer(&cstr_params.store);
+
+    RB_REALLOC_N(vm->native_callbacks.contexts, struct native_callback_ctx *,
+		 vm->native_callbacks.len + 1);
+    vm->native_callbacks.contexts[vm->native_callbacks.len] = ctx;
+    vm->native_callbacks.len++;
+
+    return name;
+}
+
+void
+rubyjsonnet_init_callbacks(VALUE cVM)
+{
+    id_call = rb_intern("call");
+
+    rb_define_method(cVM, "import_callback=", vm_set_import_callback, 1);
+    rb_define_private_method(cVM, "register_native_callback", vm_register_native_callback, 3);
+}

data/ext/jsonnet/helpers.c

@@ -0,0 +1,74 @@
+#include <string.h>
+
+#include <libjsonnet.h>
+#include <ruby/ruby.h>
+#include <ruby/encoding.h>
+
+#include "ruby_jsonnet.h"
+
+static ID id_message;
+
+/*
+ * Indicates that the encoding of the given string is not allowed by
+ * the C++ implementation of Jsonnet.
+ */
+static VALUE eUnsupportedEncodingError;
+
+/**
+ * Asserts that the given string-like object is in an
+ * ASCII-compatible encoding.
+ *
+ * @param[in] str a String-like object
+ * @throw UnsupportedEncodingError on assertion failure.
+ */
+rb_encoding *
+rubyjsonnet_assert_asciicompat(VALUE str)
+{
+    rb_encoding *enc = rb_enc_get(str);
+    if (!rb_enc_asciicompat(enc)) {
+	rb_raise(eUnsupportedEncodingError, "jsonnet encoding must be ASCII-compatible but got %s",
+		 rb_enc_name(enc));
+    }
+    return enc;
+}
+
+/**
+ * Allocates a C string whose content is equal to \c str with jsonnet_realloc.
+ */
+char *
+rubyjsonnet_str_to_cstr(struct JsonnetVm *vm, VALUE str)
+{
+    const char *const cstr = StringValueCStr(str);
+    char *const buf = jsonnet_realloc(vm, NULL, strlen(cstr));
+    strcpy(buf, cstr);
+    return buf;
+}
+
+/**
+ * @return a human readable string which contains the class name of the
+ *   exception and its message. It might be nil on failure
+ */
+VALUE
+rubyjsonnet_format_exception(VALUE exc)
+{
+    VALUE name = rb_class_name(rb_obj_class(exc));
+    VALUE msg = rb_funcall(exc, id_message, 0);
+    if (RB_TYPE_P(name, RUBY_T_STRING) && rb_str_strlen(name)) {
+	if (RB_TYPE_P(msg, RUBY_T_STRING) && rb_str_strlen(msg)) {
+	    return rb_str_concat(rb_str_cat_cstr(name, " : "), msg);
+	} else {
+	    return name;
+	}
+    } else if (RB_TYPE_P(msg, RUBY_T_STRING) && rb_str_strlen(msg)) {
+	return msg;
+    }
+    return Qnil;
+}
+
+void
+rubyjsonnet_init_helpers(VALUE mJsonnet)
+{
+    id_message = rb_intern("message");
+    eUnsupportedEncodingError =
+	rb_define_class_under(mJsonnet, "UnsupportedEncodingError", rb_eEncodingError);
+}

data/ext/jsonnet/jsonnet.c

@@ -1,127 +1,8 @@
-#include <string.h>
+#include <libjsonnet.h>
 #include <ruby/ruby.h>
-#include <ruby/intern.h>
 #include <ruby/encoding.h>
-#include <libjsonnet.h>
 
-static ID id_call;
-static ID id_message;
-
-/*
- * Jsonnet evaluator
- */
-static VALUE cVM;
-static VALUE eEvaluationError;
-/**
- * Indicates that the encoding of the given string is not allowed by
- * the C++ implementation of Jsonnet.
- */
-static VALUE eUnsupportedEncodingError;
-
-struct jsonnet_vm_wrap {
-    struct JsonnetVm *vm;
-    VALUE callback;
-};
-
-static void vm_free(void *ptr);
-static void vm_mark(void *ptr);
-
-static const rb_data_type_t jsonnet_vm_type = {
-    "JsonnetVm",
-    {
-      /* dmark = */ vm_mark,
-      /* dfree = */ vm_free,
-      /* dsize = */ 0,
-    },
-    /* parent = */ 0,
-    /* data = */ 0,
-    /* flags = */ RUBY_TYPED_FREE_IMMEDIATELY
-};
-
-/**
- * raises an EvaluationError whose message is \c msg.
- * @param[in] vm  a JsonnetVM
- * @param[in] msg must be a NUL-terminated string returned by \c vm.
- * @return never returns
- * @throw EvaluationError
- */
-static void
-raise_eval_error(struct JsonnetVm *vm, char *msg, rb_encoding *enc)
-{
-    VALUE ex = rb_exc_new3(eEvaluationError, rb_enc_str_new_cstr(msg, enc));
-    jsonnet_realloc(vm, msg, 0);
-    rb_exc_raise(ex);
-}
-
-/**
- * Returns a String whose contents is equal to \c json.
- * It automatically frees \c json just after constructing the return value.
- *
- * @param[in] vm   a JsonnetVM
- * @param[in] json must be a NUL-terminated string returned by \c vm.
- * @return Ruby string equal to \c json.
- */
-static VALUE
-str_new_json(struct JsonnetVm *vm, char *json, rb_encoding *enc)
-{
-    VALUE str = rb_enc_str_new_cstr(json, enc);
-    jsonnet_realloc(vm, json, 0);
-    return str;
-}
-
-/**
- * Returns a Hash, whose keys are file names in the multi-mode of Jsonnet,
- * and whose values are corresponding JSON values.
- * It automatically frees \c json just after constructing the return value.
- *
- * @param[in] vm   a JsonnetVM
- * @param[in] buf  NUL-separated and double-NUL-terminated sequence of strings returned by \c vm.
- * @return Hash
- */
-static VALUE
-fileset_new(struct JsonnetVm *vm, char *buf, rb_encoding *enc)
-{
-    VALUE fileset = rb_hash_new();
-    char *ptr, *json;
-    for (ptr = buf; *ptr; ptr = json + strlen(json)+1) {
-        json = ptr + strlen(ptr) + 1;
-        if (!*json) {
-            VALUE ex = rb_exc_new3(
-                    eEvaluationError,
-                    rb_enc_sprintf(enc, "output file %s without body", ptr));
-            jsonnet_realloc(vm, buf, 0);
-            rb_exc_raise(ex);
-        }
-
-        rb_hash_aset(fileset, rb_enc_str_new_cstr(ptr, enc), rb_enc_str_new_cstr(json, enc));
-    }
-    jsonnet_realloc(vm, buf, 0);
-    return fileset;
-}
-
-/**
- * Allocates a C string whose content is equal to \c str with jsonnet_realloc.
- */
-static char *
-str_jsonnet_cstr(struct JsonnetVm *vm, VALUE str)
-{
-    const char *const cstr = StringValueCStr(str);
-    char *const buf = jsonnet_realloc(vm, NULL, strlen(cstr));
-    strcpy(buf, cstr);
-    return buf;
-}
-
-static rb_encoding *
-enc_assert_asciicompat(VALUE str) {
-    rb_encoding *enc = rb_enc_get(str);
-    if (!rb_enc_asciicompat(enc)) {
-        rb_raise(
-            eUnsupportedEncodingError,
-            "jsonnet encoding must be ASCII-compatible but got %s",
-            rb_enc_name(enc));
-    }
-    return enc;
-}
+#include "ruby_jsonnet.h"
 
 /*
  * call-seq:
@@ -135,237 +16,12 @@ jw_s_version(VALUE mod)
     return rb_usascii_str_new_cstr(jsonnet_version());
 }
 
-static VALUE
-vm_s_new(int argc, const VALUE *argv, VALUE klass)
-{
-    struct jsonnet_vm_wrap *vm;
-    VALUE self = TypedData_Make_Struct(cVM, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
-    vm->vm = jsonnet_make();
-    vm->callback = Qnil;
-    rb_obj_call_init(self, argc, argv);
-    return self;
-}
-
-static void
-vm_free(void *ptr)
-{
-    struct jsonnet_vm_wrap *vm = (struct jsonnet_vm_wrap*)ptr;
-    jsonnet_destroy(vm->vm);
-    REALLOC_N(vm, struct jsonnet_vm_wrap, 0);
-}
-
-static void
-vm_mark(void *ptr)
-{
-    struct jsonnet_vm_wrap *vm = (struct jsonnet_vm_wrap*)ptr;
-    rb_gc_mark(vm->callback);
-}
-
-static VALUE
-vm_evaluate_file(VALUE self, VALUE fname, VALUE encoding, VALUE multi_p)
-{
-    struct jsonnet_vm_wrap *vm;
-    int error;
-    char *result;
-    rb_encoding *const enc = rb_to_encoding(encoding);
-
-    TypedData_Get_Struct(self, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
-    FilePathValue(fname);
-    if (RTEST(multi_p)) {
-        result = jsonnet_evaluate_file_multi(vm->vm, StringValueCStr(fname), &error);
-    }
-    else {
-        result = jsonnet_evaluate_file(vm->vm, StringValueCStr(fname), &error);
-    }
-
-    if (error) {
-        raise_eval_error(vm->vm, result, rb_enc_get(fname));
-    }
-    return RTEST(multi_p) ? fileset_new(vm->vm, result, enc) : str_new_json(vm->vm, result, enc);
-}
-
-static VALUE
-vm_evaluate(VALUE self, VALUE snippet, VALUE fname, VALUE multi_p)
-{
-    struct jsonnet_vm_wrap *vm;
-    int error;
-    char *result;
-
-    rb_encoding *enc = enc_assert_asciicompat(StringValue(snippet));
-    TypedData_Get_Struct(self, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
-    FilePathValue(fname);
-    if (RTEST(multi_p)) {
-        result = jsonnet_evaluate_snippet_multi(
-                vm->vm,
-                StringValueCStr(fname), StringValueCStr(snippet), &error);
-    }
-    else {
-        result = jsonnet_evaluate_snippet(
-                vm->vm,
-                StringValueCStr(fname), StringValueCStr(snippet), &error);
-    }
-
-    if (error) {
-        raise_eval_error(vm->vm, result, rb_enc_get(fname));
-    }
-    return RTEST(multi_p) ? fileset_new(vm->vm, result, enc) : str_new_json(vm->vm, result, enc);
-}
-
-static VALUE
-import_callback_thunk0(VALUE args)
-{
-    VALUE callback = rb_ary_entry(args, 0);
-    return rb_funcall(callback, id_call, 2, rb_ary_entry(args, 1), rb_ary_entry(args, 2));
-}
-
-static char *
-import_callback_thunk(void *ctx, const char *base, const char *rel, char **found_here, int *success)
-{
-    struct jsonnet_vm_wrap *const vm = (struct jsonnet_vm_wrap*)ctx;
-    int state;
-    VALUE result, args;
-
-    args = rb_ary_tmp_new(3);
-    rb_ary_push(args, vm->callback);
-    rb_ary_push(args, rb_enc_str_new_cstr(base, rb_filesystem_encoding()));
-    rb_ary_push(args, rb_enc_str_new_cstr(rel, rb_filesystem_encoding()));
-    result = rb_protect(import_callback_thunk0, args, &state);
-
-    if (state) {
-        VALUE err = rb_errinfo();
-        VALUE msg, name;
-
-        rb_set_errinfo(Qnil);
-        name = rb_class_name(rb_obj_class(err));
-        msg = rb_funcall(err, id_message, 0);
-        if (rb_str_strlen(name)) {
-            if (rb_str_strlen(msg)) {
-                msg = rb_str_concat(rb_str_cat_cstr(name, " : "), msg);
-            } else {
-                msg = name;
-            }
-        } else if (!rb_str_strlen(msg)) {
-            msg = rb_sprintf("cannot import %s from %s", rel, base);
-        }
-        *success = 0;
-        return str_jsonnet_cstr(vm->vm, msg);
-    }
-
-    result = rb_Array(result);
-    *success = 1;
-    *found_here = str_jsonnet_cstr(vm->vm, rb_ary_entry(result, 1));
-    return str_jsonnet_cstr(vm->vm, rb_ary_entry(result, 0));
-}
-
-/**
- * Sets a custom way to resolve "import" expression.
- * @param [#call] callback receives two parameters and returns two values.
- *                The first parameter "base" is a base directory to resolve
- *                "rel" from.
- *                The second parameter "rel" is an absolute or a relative
- *                path to the file to import.
- *                The first return value is the content of the imported file.
- *                The second return value is the resolved path of the imported file.
- */
-static VALUE
-vm_set_import_callback(VALUE self, VALUE callback)
-{
-    struct jsonnet_vm_wrap *vm;
-    TypedData_Get_Struct(self, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
-
-    vm->callback = callback;
-    jsonnet_import_callback(vm->vm, import_callback_thunk, vm);
-    return callback;
-}
-
-/*
- * Binds an external variable to a value.
- * @param [String] key name of the variable
- * @param [String] val the value
- */
-static VALUE
-vm_ext_var(VALUE self, VALUE key, VALUE val)
-{
-    struct jsonnet_vm_wrap *vm;
-
-    enc_assert_asciicompat(StringValue(key));
-    enc_assert_asciicompat(StringValue(val));
-    TypedData_Get_Struct(self, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
-    jsonnet_ext_var(vm->vm, StringValueCStr(key), StringValueCStr(val));
-    return Qnil;
-}
-
-static VALUE
-vm_set_max_stack(VALUE self, VALUE val)
-{
-    struct jsonnet_vm_wrap *vm;
-    TypedData_Get_Struct(self, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
-    jsonnet_max_stack(vm->vm, NUM2UINT(val));
-    return Qnil;
-}
-
-static VALUE
-vm_set_gc_min_objects(VALUE self, VALUE val)
-{
-    struct jsonnet_vm_wrap *vm;
-    TypedData_Get_Struct(self, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
-    jsonnet_gc_min_objects(vm->vm, NUM2UINT(val));
-    return Qnil;
-}
-
-static VALUE
-vm_set_gc_growth_trigger(VALUE self, VALUE val)
-{
-    struct jsonnet_vm_wrap *vm;
-    TypedData_Get_Struct(self, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
-    jsonnet_gc_growth_trigger(vm->vm, NUM2DBL(val));
-    return Qnil;
-}
-
-/*
- * Let #evaluate and #evaluate_file return a raw String instead of JSON-encoded string if val is true
- * @param [Boolean] val
- */
-static VALUE
-vm_set_string_output(VALUE self, VALUE val)
-{
-    struct jsonnet_vm_wrap *vm;
-    TypedData_Get_Struct(self, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
-    jsonnet_string_output(vm->vm, RTEST(val));
-    return Qnil;
-}
-
-static VALUE
-vm_set_max_trace(VALUE self, VALUE val)
-{
-    struct jsonnet_vm_wrap *vm;
-    TypedData_Get_Struct(self, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
-    jsonnet_max_trace(vm->vm, NUM2UINT(val));
-    return Qnil;
-}
-
 void
 Init_jsonnet_wrap(void)
 {
-    id_call = rb_intern("call");
-    id_message = rb_intern("message");
-
     VALUE mJsonnet = rb_define_module("Jsonnet");
     rb_define_singleton_method(mJsonnet, "libversion", jw_s_version, 0);
 
-    cVM = rb_define_class_under(mJsonnet, "VM", rb_cData);
-    rb_define_singleton_method(cVM, "new", vm_s_new, -1);
-    rb_define_private_method(cVM, "eval_file", vm_evaluate_file, 3);
-    rb_define_private_method(cVM, "eval_snippet", vm_evaluate, 3);
-    rb_define_method(cVM, "ext_var", vm_ext_var, 2);
-    rb_define_method(cVM, "max_stack=", vm_set_max_stack, 1);
-    rb_define_method(cVM, "gc_min_objects=", vm_set_gc_min_objects, 1);
-    rb_define_method(cVM, "gc_growth_trigger=", vm_set_gc_growth_trigger, 1);
-    rb_define_method(cVM, "string_output=", vm_set_string_output, 1);
-    rb_define_method(cVM, "max_trace=", vm_set_max_trace, 1);
-    rb_define_method(cVM, "import_callback=", vm_set_import_callback, 1);
-
-    eEvaluationError = rb_define_class_under(mJsonnet, "EvaluationError", rb_eRuntimeError);
-    eUnsupportedEncodingError =
-        rb_define_class_under(mJsonnet, "UnsupportedEncodingError", rb_eEncodingError);
+    rubyjsonnet_init_helpers(mJsonnet);
+    rubyjsonnet_init_vm(mJsonnet);
 }