jsonnet 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0608c5c013b33c3336b6032b17e8a42266d3b273
-  data.tar.gz: ce3d29f5b2be96106b458cd93765a1b2b2063287
+  metadata.gz: b3ba7719f8a07cc8385aef8ffc4b2e1b21924f33
+  data.tar.gz: ca340bf28f5f521aef9b5a7f2e71613e277f7fd4
 SHA512:
-  metadata.gz: 830a1cb02c29949849ffa25d116a65096715054fcf077133a854025c1485f57b6ce796ced668d15c0cdd8e243c019708b09a8ff3b87f1b13033834fd11fab18f
-  data.tar.gz: 3634f878aaa031ff2699963ab4c12c23dba41f52495e1b9915c71073b5ef8cbee8c3f7a4e7053e5f7c7f0fc4c84865a948a7cfb7633c7b7f1e9b71afe90c6809
+  metadata.gz: ba5847ad581b28bde58ee1b14f96e6b5624d72d96125ccf82aabc9543aff3280f6c39f0ba69ba2d4ae7484517e7fd3971d563e2868c8a01bef78adce74d89aab
+  data.tar.gz: 9519135c4c6f81cb94dca96ac22a4fb401839af5e8b6d573e7cd6d7d33a1b000bc92f3a907048a93ee251b15cef9a0727470c4655129d69360b8acf9149fac22

data/ext/jsonnet/jsonnet.c

@@ -1,13 +1,30 @@
+#include <string.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 const rb_data_type_t jsonnet_vm_type = {
     "JsonnetVm",
     {
@@ -20,6 +37,91 @@ static const rb_data_type_t jsonnet_vm_type = {
     /* 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;
+}
+
 /*
  * call-seq:
  *  Jsonnet.version -> String
@@ -27,66 +129,242 @@ static const rb_data_type_t jsonnet_vm_type = {
  * Returns the version of the underlying C++ implementation of Jsonnet.
  */
 static VALUE
-jw_s_version(VALUE mod) {
+jw_s_version(VALUE mod)
+{
     return rb_usascii_str_new_cstr(jsonnet_version());
 }
 
 static VALUE
 vm_s_new(VALUE mod) {
-    struct JsonnetVm *const vm = jsonnet_make();
-    return TypedData_Wrap_Struct(cVM, &jsonnet_vm_type, vm);
+    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;
+    return self;
 }
 
 static void
 vm_free(void *ptr) {
-    jsonnet_destroy((struct JsonnetVm*)ptr);
+    struct jsonnet_vm_wrap *vm = (struct jsonnet_vm_wrap*)ptr;
+    jsonnet_destroy(vm->vm);
+    REALLOC_N(vm, struct jsonnet_vm_wrap, 0);
 }
 
 static VALUE
-vm_evaluate_file(VALUE self, VALUE fname) {
-    struct JsonnetVm *vm;
+vm_evaluate_file(VALUE self, VALUE fname, VALUE encoding, VALUE multi_p)
+{
+    struct jsonnet_vm_wrap *vm;
     int error;
-    char* result;
+    char *result;
+    rb_encoding *const enc = rb_to_encoding(encoding);
 
-    TypedData_Get_Struct(self, struct JsonnetVm, &jsonnet_vm_type, vm);
+    TypedData_Get_Struct(self, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
     FilePathValue(fname);
-    result = jsonnet_evaluate_file(vm, StringValueCStr(fname), &error);
+    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) {
-        rb_raise(eEvaluationError, "%s", result);
+        raise_eval_error(vm->vm, result, rb_enc_get(fname));
     }
-    return rb_utf8_str_new_cstr(result);
+    return RTEST(multi_p) ? fileset_new(vm->vm, result, enc) : str_new_json(vm->vm, result, enc);
 }
 
 static VALUE
-vm_evaluate(int argc, VALUE *argv, VALUE self) {
-    struct JsonnetVm *vm;
+vm_evaluate(VALUE self, VALUE snippet, VALUE fname, VALUE multi_p)
+{
+    struct jsonnet_vm_wrap *vm;
     int error;
-    char* result;
-    VALUE snippet, fname = Qnil;
+    char *result;
 
-    rb_scan_args(argc, argv, "11", &snippet, &fname);
+    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);
+    }
 
-    TypedData_Get_Struct(self, struct JsonnetVm, &jsonnet_vm_type, vm);
-    result = jsonnet_evaluate_snippet(
-            vm,
-            fname == Qnil ? "(jsonnet)" : (FilePathValue(fname), StringValueCStr(fname)),
-            StringValueCStr(snippet),
-            &error);
     if (error) {
-        rb_raise(eEvaluationError, "%s", result);
+        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);
     }
-    return rb_utf8_str_new_cstr(result);
+
+    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 #evalutae 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;
+}
+
+static VALUE
+vm_set_debug_ast(VALUE self, VALUE val)
+{
+    struct jsonnet_vm_wrap *vm;
+    TypedData_Get_Struct(self, struct jsonnet_vm_wrap, &jsonnet_vm_type, vm);
+    jsonnet_debug_ast(vm->vm, RTEST(val));
+    return Qnil;
 }
 
 void
-Init_jsonnet_wrap(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, 0);
-    rb_define_method(cVM, "evaluate_file", vm_evaluate_file, 1);
-    rb_define_method(cVM, "evaluate", vm_evaluate, -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, "debug_ast=", vm_set_debug_ast, 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);
 }

data/lib/jsonnet.rb

@@ -1,5 +1,6 @@
 require "jsonnet/version"
 require "jsonnet/jsonnet_wrap"
+require "jsonnet/vm"
 
 module Jsonnet
   # Your code goes here...

data/lib/jsonnet/version.rb

@@ -1,3 +1,3 @@
 module Jsonnet
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/jsonnet/vm.rb

@@ -0,0 +1,37 @@
+module Jsonnet
+  class VM
+    ##
+    # Evaluates Jsonnet source.
+    #
+    # @param [String]  jsonnet  Jsonnet source string.
+    #                  Must be encoded in an ASCII-compatible encoding.
+    # @param [String]  filename filename of the source. Used in stacktrace.
+    # @param [Boolean] multi    enables multi-mode
+    # @return [String] a JSON representation of the evaluation result
+    # @raise [EvaluationError] raised when the evaluation results an error.
+    # @raise [UnsupportedEncodingError] raised when the encoding of jsonnet
+    #        is not ASCII-compatible.
+    # @note It is recommended to encode the source string in UTF-8 because 
+    #       Jsonnet expects it is ASCII-compatible, the result JSON string 
+    #       shall be UTF-{8,16,32} according to RFC 7159 thus the only 
+    #       intersection between the requirements is UTF-8.
+    def evaluate(jsonnet, filename: "(jsonnet)", multi: false)
+      eval_snippet(jsonnet, filename, multi)
+    end
+
+    ##
+    # Evaluates Jsonnet file.
+    #
+    # @param [String]  filename filename of a Jsonnet source file.
+    # @param [Boolean] multi    enables multi-mode
+    # @return [String] a JSON representation of the evaluation result
+    # @raise [EvaluationError] raised when the evaluation results an error.
+    # @note It is recommended to encode the source file in UTF-8 because 
+    #       Jsonnet expects it is ASCII-compatible, the result JSON string 
+    #       shall be UTF-{8,16,32} according to RFC 7159 thus the only 
+    #       intersection between the requirements is UTF-8.
+    def evaluate_file(filename, encoding: Encoding.default_external, multi: false)
+      eval_file(filename, encoding, multi)
+    end
+  end
+end

data/test/test_vm.rb

@@ -1,28 +1,63 @@
+# -*- coding: UTF-8 -*-
 require 'jsonnet'
 
 require 'json'
+require 'tempfile'
 require 'test/unit'
 
 class TestVM < Test::Unit::TestCase
   test 'Jsonnet::VM#evaluate_file evaluates file' do
     vm = Jsonnet::VM.new
-    result = vm.evaluate_file example_file('example.jsonnet')
-
-    assert_equal JSON.parse(<<-EOS), JSON.parse(result)
+    with_example_file(%<
+      local myvar = 1;
+      {
+        ["foo" + myvar]: myvar,
+      }
+    >) {|fname|
+      result = vm.evaluate_file(fname)
+      assert_equal JSON.parse(<<-EOS), JSON.parse(result)
       {"foo1": 1}
-    EOS
+      EOS
+    }
   end
 
   test 'Jsonnet::VM#evaluate_file raises an EvaluationError on error' do
     vm = Jsonnet::VM.new
-    assert_raise(Jsonnet::EvaluationError) do
-      vm.evaluate_file example_file('error.jsonnet')
+    with_example_file(%<
+      {
+        // unbound variable
+        ["foo" + myvar]: myvar,
+      }
+    >) {|fname|
+      assert_raise(Jsonnet::EvaluationError) do
+        vm.evaluate_file(fname)
+      end
+    }
+  end
+
+  test "Jsonnet::VM#evaluate_file returns the same encoding as source" do
+    vm = Jsonnet::VM.new
+    with_example_file(%Q{ ["テスト"] }.encode(Encoding::EUC_JP)) {|fname|
+      result = vm.evaluate_file(fname, encoding: Encoding::EUC_JP)
+      assert_equal Encoding::EUC_JP, result.encoding
+    }
+  end
+
+  test "Jsonnet::VM#evaluate_file raises an error in the encoding of filename" do
+    vm = Jsonnet::VM.new
+    begin
+      with_example_file(%q{ ["unterminated string }) {|fname|
+        vm.evaluate_file(fname.encode(Encoding::SJIS)) 
+      }
+    rescue Jsonnet::EvaluationError => e
+      assert_equal Encoding::SJIS, e.message.encoding
     end
   end
 
+
   test 'Jsonnet::VM#evaluate evaluates snippet' do
     vm = Jsonnet::VM.new
-    result = vm.evaluate(<<-EOS, 'example.snippet')
+    result = vm.evaluate(<<-EOS, filename: 'example.snippet')
       local myvar = 1;
       {
           ["foo" + myvar]: myvar,
@@ -51,7 +86,7 @@ class TestVM < Test::Unit::TestCase
   test 'Jsonnet::VM#evaluate raises an EvaluationError on error' do
     vm = Jsonnet::VM.new
     assert_raise(Jsonnet::EvaluationError) do
-      vm.evaluate(<<-EOS, 'example.snippet')
+      vm.evaluate(<<-EOS, filename: 'example.snippet')
         {
             // unbound variable
             ["foo" + myvar]: myvar,
@@ -60,9 +95,180 @@ class TestVM < Test::Unit::TestCase
     end
   end
 
+  test "Jsonnet::VM#evaluate returns the same encoding as source" do
+    vm = Jsonnet::VM.new
+    result = vm.evaluate(%Q{ ["テスト"] }.encode(Encoding::EUC_JP))
+    assert_equal Encoding::EUC_JP, result.encoding
+  end
+
+  test "Jsonnet::VM#evaluate raises an error in the encoding of filename" do
+    vm = Jsonnet::VM.new
+    begin
+      vm.evaluate(%Q{ ["unterminated string }, filename: "テスト.json".encode(Encoding::SJIS)) 
+    rescue Jsonnet::EvaluationError => e
+      assert_equal Encoding::SJIS, e.message.encoding
+    end
+  end
+
+  test "Jsonnet::VM#ext_var binds a variable" do
+    vm = Jsonnet::VM.new
+    vm.ext_var("var1", "foo")
+    result = vm.evaluate('[std.extVar("var1")]')
+    assert_equal JSON.parse('["foo"]'), JSON.parse(result)
+  end
+
+  test 'Jsonnet::VM#evaluate returns a JSON per filename on multi mode' do
+    vm = Jsonnet::VM.new
+    [
+      [ "{}", {} ],
+      [
+        %<
+          local myvar = 1;
+          { ["foo" + myvar]: [myvar] }
+        >,
+        {
+          'foo1' => [1],
+        }
+      ],
+      [
+        %<
+          local myvar = 1;
+          {
+            ["foo" + myvar]: [myvar],
+            ["bar" + myvar]: {
+              ["baz" + (myvar+1)]: myvar+1,
+            },
+          }
+        >,
+        {
+          'foo1' => [1],
+          'bar1' => {'baz2' => 2},
+        }
+      ],
+    ].each do |jsonnet, expected|
+      result = vm.evaluate(jsonnet, multi: true)
+      assert_equal expected.keys.sort, result.keys.sort
+      expected.each do |fname, value|
+        assert_not_nil result[fname]
+        assert_equal value, JSON.parse(result[fname])
+      end
+    end
+  end
+
+  test 'Jsonnet::VM#evaluate_file returns a JSON per filename on multi mode' do
+    vm = Jsonnet::VM.new
+    [
+      [ "{}", {} ],
+      [
+        %<
+          local myvar = 1;
+          { ["foo" + myvar]: [myvar] }
+        >,
+        {
+          'foo1' => [1],
+        }
+      ],
+      [
+        %<
+          local myvar = 1;
+          {
+            ["foo" + myvar]: [myvar],
+            ["bar" + myvar]: {
+              ["baz" + (myvar+1)]: myvar+1,
+            },
+          }
+        >,
+        {
+          'foo1' => [1],
+          'bar1' => {'baz2' => 2},
+        }
+      ],
+    ].each do |jsonnet, expected|
+      with_example_file(jsonnet) {|fname|
+        result = vm.evaluate_file(fname, multi: true)
+        assert_equal expected.keys.sort, result.keys.sort
+        expected.each do |fname, value|
+          assert_not_nil result[fname]
+          assert_equal value, JSON.parse(result[fname])
+        end
+      }
+    end
+  end
+
+  test "Jsonnet::VM responds to max_stack=" do
+    Jsonnet::VM.new.max_stack = 1
+  end
+
+  test "Jsonnet::VM responds to gc_min_objects=" do
+    Jsonnet::VM.new.gc_min_objects = 1
+  end
+
+  test "Jsonnet::VM responds to gc_growth_trigger=" do
+    Jsonnet::VM.new.gc_growth_trigger = 1.5
+  end
+
+  test "Jsonnet::VM responds to max_trace=" do
+    Jsonnet::VM.new.max_trace = 1
+  end
+
+  test "Jsonnet::VM responds to debug_ast=" do
+    Jsonnet::VM.new.debug_ast = true
+  end
+
+  test "Jsonnet::VM#string_output lets the VM output a raw string" do
+    vm = Jsonnet::VM.new
+    vm.string_output = true
+    assert_equal "foo\n", vm.evaluate(%q[ "foo" ])
+    vm.string_output = false
+    assert_equal ["foo"], JSON.parse(vm.evaluate(%q[ ["foo"] ]))
+  end
+
+  test "Jsonnet::VM#import_callback customizes import file resolution" do
+    vm = Jsonnet::VM.new
+    vm.import_callback = ->(base, rel) {
+      case [base, rel]
+      when ['/path/to/base/', 'imported1.jsonnet']
+        return <<-EOS, '/path/to/imported1/imported1.jsonnet'
+          import "imported2.jsonnet" {
+            b: 2,
+          }
+        EOS
+      when ['/path/to/imported1/', "imported2.jsonnet"]
+        return <<-EOS, '/path/to/imported2/imported2.jsonnet'
+          { a: 1 }
+        EOS
+      else
+        raise Errno::ENOENT, "#{rel} at #{base}"
+      end
+    }
+    result = vm.evaluate(<<-EOS, filename: "/path/to/base/example.jsonnet")
+      import "imported1.jsonnet" { c: 3 }
+    EOS
+
+    expected = {"a" => 1, "b" => 2, "c" => 3}
+    assert_equal expected, JSON.parse(result)
+  end
+
+  test "Jsonnet::VM#evaluate returns an error if customized import callback raises an exception" do
+    vm = Jsonnet::VM.new
+    called = false
+    vm.import_callback = ->(base, rel) { called = true; raise }
+    assert_raise(Jsonnet::EvaluationError) {
+      vm.evaluate(<<-EOS)
+        import "a.jsonnet" {}
+      EOS
+    }
+    assert_true called
+  end
+
   private
-  def example_file(name)
-    File.join(File.dirname(__FILE__), name)
+  def with_example_file(content)
+    Tempfile.open("example.jsonnet") {|f|
+      f.print content
+      f.flush
+      f.rewind
+      yield f.path
+    }
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsonnet
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Yuki Yugui Sonoda
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-03 00:00:00.000000000 Z
+date: 2015-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -85,8 +85,7 @@ files:
 - jsonnet.gemspec
 - lib/jsonnet.rb
 - lib/jsonnet/version.rb
-- test/error.jsonnet
-- test/example.jsonnet
+- lib/jsonnet/vm.rb
 - test/test_jsonnet.rb
 - test/test_vm.rb
 homepage: ''
@@ -114,7 +113,6 @@ signing_key:
 specification_version: 4
 summary: Jsonnet library
 test_files:
-- test/error.jsonnet
-- test/example.jsonnet
 - test/test_jsonnet.rb
 - test/test_vm.rb
+has_rdoc: 

data/test/error.jsonnet

@@ -1,5 +0,0 @@
-{
-	// unbound variable
-	["foo" + myvar]: myvar,
-}
-

data/test/example.jsonnet

@@ -1,4 +0,0 @@
-local myvar = 1;
-{
-	["foo" + myvar]: myvar,
-}