jsonnet 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a215d91a36c8af2f5ad4d145f571fbbc070cedb7
-  data.tar.gz: 4e5b93b2fc44a5c33bb1fb27830a33ee810b4e8f
+SHA256:
+  metadata.gz: 2872d26e221e6ec8bbd30265edd0109eb9f1c68fa19fcfaa888c9921f096f771
+  data.tar.gz: b91f326aa5a64a97f9f088a17b6462e8cf77d8e82679c11231cc68eff2b495e5
 SHA512:
-  metadata.gz: 84a38e5e7e776ac8d11505693adedd2fd05dfe0d01146e5e242241f2a82f9d2b849983d15bb1909cd24fcfe6404aee0eb87647074a34893204ae522fee0c14bc
-  data.tar.gz: 1d44661d345335978fe2f67fec727c06aa3888b08b8418f570b7b27226b57e6c9501d4cc93fb51b312a861cbe2c6ba515793031c34cfec92468f67b319cfa8bb
+  metadata.gz: dab85234e40a4b05ae60a4fe7423af108df27b9e3d2db119e6d18edb40f9abbb92c20a5cf7c25fb5d20e3a090031fae42ec93fab135ea3c6682adaf3ec006693
+  data.tar.gz: 8aea3bbab4b7661a4ee6d055bd6fdd9b5c0834feae98f266b5d162563b860b932689f4fcd4096a3f2dcdf12fb5e960b2fbb7f7e65ce23d1d177d5f85128dbb56

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/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+dist: xenial
+script: bundle exec rake test
+
+matrix:
+  include:
+  - os: linux
+    rvm: 2.5.8
+  - os: osx
+    rvm: 2.5.8
+  - os: linux
+    rvm: 2.6.6
+  - os: osx
+    rvm: 2.6.6
+  - os: linux
+    rvm: 2.7.2
+  - os: osx
+    rvm: 2.7.2
+  fast_finish: true

data/README.md

@@ -1,17 +1,11 @@
+[![Build Status](https://travis-ci.org/yugui/ruby-jsonnet.svg?branch=master)](https://travis-ci.org/yugui/ruby-jsonnet)
+
 # Jsonnet
 
-Jsonnet processor library.  Wraps the official C++ implementation with a Ruby extention library.
+[Jsonnet][] processor library.  Wraps the official C++ implementation with a Ruby extension library.
 
 ## Installation
 
-Install libjsonnet:
-
-    $ git clone https://github.com/google/jsonnet.git
-    $ cd jsonnet
-    $ make
-    $ sudo cp libjsonnet.so /usr/local/lib/libjsonnet.so
-    $ sudo cp libjsonnet.h /usr/local/include/libjsonnet.h
-
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -20,20 +14,85 @@ gem 'jsonnet'
 
 And then execute:
 
-    $ bundle
+```shell
+$ bundle install
+```
 
 Or install it yourself as:
 
-    $ gem install jsonnet
+```shell
+$ gem install jsonnet
+```
+
+By default this gem will compile and install Jsonnet (v0.16.0) as part of
+installation. However you can use the system version of Jsonnet if you prefer.
+This would be the recommended route if you want to use a different version
+of Jsonnet or are having problems installing this.
+
+To install libjsonnet:
+
+```shell
+$ git clone https://github.com/google/jsonnet.git
+$ cd jsonnet
+$ make libjsonnet.so
+$ sudo cp libjsonnet.so /usr/local/lib/libjsonnet.so
+$ sudo cp include/libjsonnet.h /usr/local/include/libjsonnet.h
+```
+
+Note: /usr/local/lib and /usr/local/include are used as they are library lookup
+locations. You may need to adjust these for your system if you have errors
+running this gem saying it can't open libjsonnet.so - on Ubuntu for instance
+I found /lib worked when /usr/local/lib did not.
+
+To install this gem without jsonnet:
+
+Use `JSONNET_USE_SYSTEM_LIBRARIES` ENV var:
+
+```shell
+$ JSONNET_USE_SYSTEM_LIBRARIES=1 bundle install
+```
+
+or, the `--use-system-libraries` option:
+
+
+```shell
+gem install jsonnet -- --use-system-libraries
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+Load the library with `require "jsonnet"`
+
+You can evaluate a string of Jsonnet using `Jsonnet.parse`
+
+```
+irb(main):002:0> Jsonnet.evaluate('{ foo: "bar" }')
+=> {"foo"=>"bar"}
+```
+Or load a file using `Jsonnet.load`
+
+```
+irb(main):002:0> Jsonnet.load('example.jsonnet')
+=> {"baz"=>1}
+```
+
+To get closer to the C++ interface you can create an instance of `Jsonnet::VM`
+
+```
+irb(main):002:0> vm = Jsonnet::VM.new
+=> #<Jsonnet::VM:0x007fd29aa1e568>
+irb(main):003:0> vm.evaluate('{ foo: "bar" }')
+=> "{\n   \"foo\": \"bar\"\n}\n"
+irb(main):004:0> vm.evaluate_file('example.jsonnet')
+=> "{\n   \"baz\": 1\n}\n"
+```
 
 ## Contributing
 
-1. Fork it ( https://github.com/yugui/jsonnet/fork )
+1. Fork it ( https://github.com/yugui/ruby-jsonnet/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
+
+[Jsonnet]: https://github.com/google/jsonnet

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/extconf.rb

@@ -1,6 +1,62 @@
 require 'mkmf'
+require 'fileutils'
+
+def using_system_libraries?
+  arg_config('--use-system-libraries', !!ENV['JSONNET_USE_SYSTEM_LIBRARIES'])
+end
 
 dir_config('jsonnet')
+
+unless using_system_libraries?
+  message "Building jsonnet using packaged libraries.\n"
+  require 'rubygems'
+  require 'mini_portile2'
+  message "Using mini_portile version #{MiniPortile::VERSION}\n"
+
+  recipe = MiniPortile.new('jsonnet', 'v0.17.0')
+  recipe.files = ['https://github.com/google/jsonnet/archive/v0.17.0.tar.gz']
+  class << recipe
+
+    def compile
+      # We want to create a file a library we can link to. Jsonnet provides us
+      # with the command `make libjsonnet.so` which creates a shared object
+      # however that won't be bundled into the compiled output so instead
+      # we compile the c into .o files and then create an archive that can
+      # be linked to
+      execute('compile', make_cmd)
+      execute('archive', 'ar rcs libjsonnet.a core/desugarer.o core/formatter.o core/lexer.o core/libjsonnet.o core/parser.o core/pass.o core/static_analysis.o core/string_utils.o core/vm.o third_party/md5/md5.o')
+    end
+
+    def configured?
+      true
+    end
+
+    def install
+      lib_path = File.join(port_path, 'lib')
+      include_path = File.join(port_path, 'include')
+
+      FileUtils.mkdir_p([lib_path, include_path])
+
+      FileUtils.cp(File.join(work_path, 'libjsonnet.a'), lib_path)
+      FileUtils.cp(File.join(work_path, 'include', 'libjsonnet.h'), include_path)
+      FileUtils.cp(File.join(work_path, 'include', 'libjsonnet_fmt.h'), include_path)
+    end
+  end
+
+  recipe.cook
+  # I tried using recipe.activate here but that caused this file to build ok
+  # but the makefile to fail. These commands add the necessary paths to do both
+  $LIBPATH = ["#{recipe.path}/lib"] | $LIBPATH
+  $CPPFLAGS << " -I#{recipe.path}/include"
+
+  # This resolves an issue where you can get improper linkage when compiling
+  # and get an error like "undefined symbol: _ZTVN10__cxxabiv121__vmi_class_type_infoE"
+  # experienced on ubuntu.
+  # See: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=193950
+  $LIBS << " -lstdc++"
+end
+
 abort 'libjsonnet.h not found' unless have_header('libjsonnet.h')
 abort 'libjsonnet not found' unless have_library('jsonnet')
+have_header('libjsonnet_fmt.h')
 create_makefile('jsonnet/jsonnet_wrap')