@port-labs/jq-node-bindings 0.0.13 → 0.0.15-dev1

package/src/binding.h

@@ -1,13 +1,12 @@
 #ifndef SRC_BINDING_H_
 #define SRC_BINDING_H_
 
-#include <nan.h>
+#include <napi.h> 
 
-extern "C"
-{
+extern "C" {
     #include "jq.h"
 }
 
 #include <string>
 
-#endif  // SRC_BINDING_H_
+#endif 

package/test/santiy-async.test.js

@@ -0,0 +1,171 @@
+const jq = require('../lib');
+
+describe('jq - async', () => {
+    it('should break', async () => {
+        const json = { foo2: 'bar' };
+        const input = 'foo';
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe(null);
+    }),
+    it('should break for invalid input', async () => {
+        const json = { foo2: 'bar' };
+        const input = 123;
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe(null);
+    }),
+    it('should break for invalid input', async () => {
+        const json = { foo2: 'bar' };
+        const input = undefined;
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe(null);
+    }),
+    it('should break for invalid input', async () => {
+        const json = { foo2: 'bar' };
+        const input = null;
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe(null);
+    }),
+    it('string should work', async () => {
+        const json = { foo: 'bar' };
+        const input = '.foo';
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe('bar');
+    });
+
+    it('number should work', async ()=> {
+      const json = { foo: 1 };
+      const input = '.foo';
+      const result = await jq.execAsync(json, input);
+
+      expect(result).toBe(1);
+    });
+
+    it ('should return null', async () => {
+        const json = { foo: 'bar' };
+        const input = '.bar';
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe(null);
+    });
+
+    it ('should return array with object', async () => {
+        const json = { foo: ['bar'] };
+        const input = '.foo';
+        const result = await jq.execAsync(json, input);
+
+        expect(result[0]).toBe('bar');
+    });
+
+    it ('should return an item of an array', async () => {
+        const json = { foo: ['bar'] };
+        const input = '.foo[0]';
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe('bar');
+    })
+
+    it ('should return array with objects', async () => {
+        const json = { foo: [{ bar: 'bar' }] };
+        const input = '.foo';
+        const result = await jq.execAsync(json, input);
+
+        expect(result[0].bar).toBe('bar');
+    });
+
+    it ('should return boolean', async () => {
+        const json = { foo: true };
+        const input = '.foo';
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe(true);
+    });
+    it ('should return object', async () => {
+        const json = { foo: {prop1: "1"} };
+        const input = '.foo';
+        const result = await jq.execAsync(json, input);
+
+        expect(result.prop1).toBe("1");
+    })
+
+    it ('should return recursed obj', async () => {
+        const json = { foo: {obj: { obj2: { num: 1, string: "str"} }} };
+        const input = '.foo';
+        const result = await jq.execAsync(json, input);
+
+        expect(result.obj.obj2.num).toBe(1);
+        expect(result.obj.obj2.string).toBe("str");
+    }),
+
+    it ('should return recursed obj', async () => {
+        const json = { foo: { obj: { obj2: { num: 1, string: "str", bool: true} }} };
+        const input = '.foo';
+        const result = await jq.execAsync(json, input);
+
+        expect(result.obj.obj2.num).toBe(1);
+        expect(result.obj.obj2.string).toBe("str");
+        expect(result.obj.obj2.bool).toBe(true);
+    })
+
+    it ('should return null on invalid json', async () => {
+        const json = "foo";
+        const input = '.foo';
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe(null);
+    })
+
+    it('should excape \'\' to ""', async () => {
+        const json = { foo: 'com' };
+        const input = "'https://url.' + .foo";
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe('https://url.com');
+    })
+
+    it('should not escape \' in the middle of the string', async () => {
+        const json = { foo: 'com' };
+        const input = "\"https://'url.\" + 'test.' + .foo";
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe("https://'url.test.com");
+    });
+
+    it ('should run a jq function succesfully', async () => {
+        const json = { foo: 'bar' };
+        const input = '.foo | gsub("bar";"foo")';
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe('foo');
+    })
+
+    it ('Testing multiple the \'\' in the same expression', async () => {
+        const json = { foo: 'bar' };
+        const input = "'https://some.random.url' + .foo + '-1' + '.' + .foo + '.' + 'longgggg' + .foo + ')test(' + .foo + 'testadsftets'";
+        const result = await jq.execAsync(json, input);
+
+        expect(result).toBe('https://some.random.urlbar-1.bar.longggggbar)test(bartestadsftets');
+    })
+
+    it('test disable env', async () => {
+        expect(await jq.execAsync({}, 'env', {enableEnv: false})).toEqual({});
+        expect(await jq.execAsync({}, 'env', {enableEnv: true})).not.toEqual({});
+        expect(await jq.execAsync({}, 'env', {})).toEqual({});
+        expect(await jq.execAsync({}, 'env')).toEqual({});
+    })
+
+    it('test throw on error', async () => {
+        await expect(jq.execAsync({}, 'foo', {throwOnError: true})).rejects.toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
+        await expect(jq.execAsync({}, '1/0', {throwOnError: true})).rejects.toThrow("number (1) and number (0) cannot be divided because the divisor is zero");
+        await expect(jq.execAsync({}, '{', {throwOnError: true})).rejects.toThrow("jq: compile error: syntax error, unexpected end of file (Unix shell quoting issues?) at <top-level>, line 1:");
+        await expect(jq.execAsync({}, '{(0):1}', {throwOnError: true})).rejects.toThrow("jq: compile error: Cannot use number (0) as object key at <top-level>, line 1:");
+        await expect(jq.execAsync({}, 'if true then 1 else 0', {throwOnError: true})).rejects.toThrow("jq: compile error: Possibly unterminated 'if' statement at <top-level>, line 1:");
+        await expect(jq.execAsync({}, 'null | map(.+1)', {throwOnError: true})).rejects.toThrow("jq: error: Cannot iterate over null (null)");
+        await expect(jq.execAsync({foo: "bar"}, '.foo + 1', {throwOnError: true})).rejects.toThrow("jq: error: string (\"bar\") and number (1) cannot be added");
+    })
+})
+

package/test/santiy.test.js

@@ -160,8 +160,8 @@ describe('jq', () => {
 
     it('test throw on error', () => {
         expect(() => { jq.exec({}, 'foo', {throwOnError: true}) }).toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
-        expect(() => { jq.exec({}, '1/0', {throwOnError: true}) }).toThrow("jq: compile error: Division by zero? at <top-level>, line 1:");
-        expect(() => { jq.exec({}, '{', {throwOnError: true}) }).toThrow("jq: compile error: syntax error, unexpected $end (Unix shell quoting issues?) at <top-level>, line 1:");
+        expect(() => { jq.exec({}, '1/0', {throwOnError: true}) }).toThrow("number (1) and number (0) cannot be divided because the divisor is zero");
+        expect(() => { jq.exec({}, '{', {throwOnError: true}) }).toThrow("jq: compile error: syntax error, unexpected end of file (Unix shell quoting issues?) at <top-level>, line 1:");
         expect(() => { jq.exec({}, '{(0):1}', {throwOnError: true}) }).toThrow("jq: compile error: Cannot use number (0) as object key at <top-level>, line 1:");
         expect(() => { jq.exec({}, 'if true then 1 else 0', {throwOnError: true}) }).toThrow("jq: compile error: Possibly unterminated 'if' statement at <top-level>, line 1:");
         expect(() => { jq.exec({}, 'null | map(.+1)', {throwOnError: true}) }).toThrow("jq: error: Cannot iterate over null (null)");

package/test/template-async.test.js

@@ -0,0 +1,182 @@
+const jq = require('../lib');
+
+describe('template', () => {
+    it('should break', async () => {
+        const json = { foo2: 'bar' };
+        const input = '{{.foo}}';
+        const result = await jq.renderRecursivelyAsync(json, input);
+
+        expect(result).toBe(null);
+    });
+    it('non template should work', async () => {
+        const json = { foo2: 'bar' };
+        const render = async (input) => await jq.renderRecursivelyAsync(json, input);
+
+        expect(await render(123)).toBe(123);
+        expect(await render(undefined)).toBe(undefined);
+        expect(await render(null)).toBe(null);
+        expect(await render(true)).toBe(true);
+        expect(await render(false)).toBe(false);
+    });
+    it('different types should work', async () => {
+        const input = '{{.foo}}';
+        const render = async (json) => await jq.renderRecursivelyAsync(json, input);
+
+        expect(await render({ foo: 'bar' })).toBe('bar');
+        expect(await render({ foo: 1 })).toBe(1);
+        expect(await render({ foo: true })).toBe(true);
+        expect(await render({ foo: null })).toBe(null);
+        expect(await render({ foo: undefined })).toBe(null);
+        expect(await render({ foo: ['bar'] })).toEqual(['bar']);
+        expect(await render({ foo: [{ bar: 'bar' }] })).toEqual([{ bar: 'bar' }]);
+        expect(await render({ foo: {prop1: "1"} })).toEqual({prop1: "1"});
+        expect(await render({ foo: {obj: { obj2: { num: 1, string: "str"} }} })).toEqual({obj: { obj2: { num: 1, string: "str"} }});
+        expect(await render({ foo: { obj: { obj2: { num: 1, string: "str", bool: true} }} })).toEqual({ obj: { obj2: { num: 1, string: "str", bool: true} }});
+    });
+    it ('should return undefined', async () => {
+        const json = { foo: 'bar' };
+        const input = '{{empty}}';
+        const result = await jq.renderRecursivelyAsync(json, input);
+
+        expect(result).toBe(undefined);
+    });
+    it ('should return null on invalid json', async () => {
+        const json = "foo";
+        const input = '{{.foo}}';
+        const result = await jq.renderRecursivelyAsync(json, input);
+        console.log('!!!!!',result);
+        expect(result).toBe(null);
+    });
+    it('should excape \'\' to ""', async () => {
+        const json = { foo: 'com' };
+        const input = "{{'https://url.' + .foo}}";
+        const result = await jq.renderRecursivelyAsync(json, input);
+
+        expect(result).toBe('https://url.com');
+    });
+    it('should not escape \' in the middle of the string', async () => {
+        const json = { foo: 'com' };
+        const input = "{{\"https://'url.\" + 'test.' + .foo}}";
+        const result = await jq.renderRecursivelyAsync(json, input);
+
+        expect(result).toBe("https://'url.test.com");
+    });
+    it ('should run a jq function succesfully', async () => {
+        const json = { foo: 'bar' };
+        const input = '{{.foo | gsub("bar";"foo")}}';
+        const result = await jq.renderRecursivelyAsync(json, input);
+
+        expect(result).toBe('foo');
+    });
+    it ('Testing multiple the \'\' in the same expression', async () => {
+        const json = { foo: 'bar' };
+        const input = "{{'https://some.random.url' + .foo + '-1' + '.' + .foo + '.' + 'longgggg' + .foo + ')test(' + .foo + 'testadsftets'}}";
+        const result = await jq.renderRecursivelyAsync(json, input);
+
+        expect(result).toBe('https://some.random.urlbar-1.bar.longggggbar)test(bartestadsftets');
+    });
+    it ('Testing multiple the \'\' in the same expression', async () => {
+        const json = { foo: 'bar' };
+        const input = "{{'https://some.random.url' + .foo + '-1' + '.' + .foo + '.' + 'longgggg' + .foo + ')test(' + .foo + 'testadsftets'}}";
+        const result = await jq.renderRecursivelyAsync(json, input);
+
+        expect(result).toBe('https://some.random.urlbar-1.bar.longggggbar)test(bartestadsftets');
+    });
+    it('should break for invalid template', async () => {
+        const json = { foo: 'bar' };
+        const render = async (input) => async () => await jq.renderRecursivelyAsync(json, input);
+
+        expect(await render('prefix{{.foo}postfix')).rejects.toThrow('Found opening double braces in index 6 without closing double braces');
+        expect(await render('prefix{.foo}}postfix')).rejects.toThrow('Found closing double braces in index 11 without opening double braces');
+        expect(await render('prefix{{ .foo {{ }}postfix')).rejects.toThrow('Found double braces in index 14 inside other one in index 6');
+        expect(await render('prefix{{ .foo }} }}postfix')).rejects.toThrow('Found closing double braces in index 17 without opening double braces');
+        expect(await render('prefix{{ .foo }} }}postfix')).rejects.toThrow('Found closing double braces in index 17 without opening double braces');
+        expect(await render('prefix{{ "{{" + .foo }} }}postfix')).rejects.toThrow('Found closing double braces in index 24 without opening double braces');
+        expect(await render('prefix{{ \'{{\' + .foo }} }}postfix')).rejects.toThrow('Found closing double braces in index 24 without opening double braces');
+        expect(await render({'{{1}}': 'bar'})).rejects.toThrow('Evaluated object key should be undefined, null or string. Original key: {{1}}, evaluated to: 1');
+        expect(await render({'{{true}}': 'bar'})).rejects.toThrow('Evaluated object key should be undefined, null or string. Original key: {{true}}, evaluated to: true');
+        expect(await render({'{{ {} }}': 'bar'})).rejects.toThrow('Evaluated object key should be undefined, null or string. Original key: {{ {} }}, evaluated to: {}');
+    });
+    it('should concat string and other types', async () => {
+        const input = 'https://some.random.url?q={{.foo}}';
+        const render = async (json) => await jq.renderRecursivelyAsync(json, input);
+
+        expect(await render({ foo: 'bar' })).toBe('https://some.random.url?q=bar');
+        expect(await render({ foo: 1 })).toBe('https://some.random.url?q=1');
+        expect(await render({ foo: false })).toBe('https://some.random.url?q=false');
+        expect(await render({ foo: null })).toBe('https://some.random.url?q=null');
+        expect(await render({ foo: undefined })).toBe('https://some.random.url?q=null');
+        expect(await render({ foo: [1] })).toBe('https://some.random.url?q=[1]');
+        expect(await render({ foo: {bar: 'bar'} })).toBe('https://some.random.url?q={\"bar\":\"bar\"}');
+    });
+    it('testing multiple template blocks', async () => {
+        const json = {str: 'bar', num: 1, bool: true, 'null': null, arr: ['foo'], obj: {bar: 'bar'}};
+        const input = 'https://some.random.url?str={{.str}}&num={{.num}}&bool={{.bool}}&null={{.null}}&arr={{.arr}}&obj={{.obj}}';
+        const result = await jq.renderRecursivelyAsync(json, input);
+
+        expect(result).toBe("https://some.random.url?str=bar&num=1&bool=true&null=null&arr=[\"foo\"]&obj={\"bar\":\"bar\"}");
+    });
+    it('testing conditional key', async () => {
+        const json = {};
+        const render = async (input) => await jq.renderRecursivelyAsync(json, input);
+
+        expect(await render({'{{empty}}': 'bar'})).toEqual({});
+        expect(await render({'{{null}}': 'bar'})).toEqual({});
+        expect(await render({'{{""}}': 'bar'})).toEqual({});
+        expect(await render({'{{\'\'}}': 'bar'})).toEqual({});
+    });
+    it('testing spread key', async () => {
+        const json = { foo: "bar" };
+        const render = async (input) => await jq.renderRecursivelyAsync(json, input);
+
+        expect(await render({ "{{spreadValue()}}": { foo: "bar" } })).toEqual({foo: "bar"});
+        expect(await render({ " {{ spreadValue( ) }} ": { foo: "bar" } })).toEqual({foo: "bar"});
+        expect(await render({ "{{spreadValue()}}": "{{ . }}" })).toEqual({ foo: "bar" });
+    });
+    it('recursive templates should work', async () => {
+        const json = { foo: 'bar', bar: 'foo' };
+        const render = async (input) => await jq.renderRecursivelyAsync(json, input);
+
+        expect(await render({'{{.foo}}': '{{.bar}}{{.foo}}'})).toEqual({bar: 'foobar'});
+        expect(await render({'{{.foo}}': {foo: '{{.foo}}'}})).toEqual({bar: {foo: 'bar'}});
+        expect(await render([1, true, null, undefined, '{{.foo}}', 'https://{{.bar}}.com'])).toEqual([1, true, null, undefined, 'bar', 'https://foo.com']);
+        expect(await render([['{{.bar}}{{.foo}}'], 1, '{{.bar | ascii_upcase}}'])).toEqual([['foobar'], 1, 'FOO']);
+        expect(await render([{'{{.bar}}': [false, '/foo/{{.foo + .bar}}']}])).toEqual([{foo: [false, '/foo/barfoo']}]);
+        expect(await render({foo: [{bar: '{{1}}'}, '{{empty}}']})).toEqual({foo: [{bar: 1}, undefined]});
+    });
+    it('should accept quotes outside of template', async () => {
+        const json = { foo: 'bar', bar: 'foo' };
+        const render = async (input) => await jq.renderRecursivelyAsync(json, input);
+
+        expect(await render('"{{.foo}}"')).toEqual('"bar"');
+        expect(await render('\'{{.foo}}\'')).toEqual('\'bar\'');
+    });
+    it('should accept escaped quotes inside jq template', async () => {
+        const json = { foo: 'bar', bar: 'foo' };
+        const render = async (input) => await jq.renderRecursivelyAsync(json, input);
+
+        expect(await render('{{"\\"foo\\""}}')).toEqual('"foo"');
+    });
+    it('test disable env', async () => {
+        expect(await jq.renderRecursivelyAsync({}, '{{env}}', {enableEnv: false})).toEqual({});
+        expect(await jq.renderRecursivelyAsync({}, '{{env}}', {enableEnv: true})).not.toEqual({});
+        expect(await jq.renderRecursivelyAsync({}, '{{env}}', {})).toEqual({});
+        expect(await jq.renderRecursivelyAsync({}, '{{env}}')).toEqual({});
+    })
+    it('test throw on error', async () => {
+        expect(async () => { await jq.renderRecursivelyAsync({}, '{{foo}}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '{{1/0}}', {throwOnError: true}) }).rejects.toThrow("number (1) and number (0) cannot be divided because the divisor is zero");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '{{{}}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: syntax error, unexpected end of file (Unix shell quoting issues?) at <top-level>, line 1:");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '{{ {(0):1} }}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: Cannot use number (0) as object key at <top-level>, line 1:");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '{{if true then 1 else 0}}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: Possibly unterminated 'if' statement at <top-level>, line 1:");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '{{null | map(.+1)}}', {throwOnError: true}) }).rejects.toThrow("jq: error: Cannot iterate over null (null)");
+        expect(async () => { await jq.renderRecursivelyAsync({foo: "bar"}, '{{.foo + 1}}', {throwOnError: true}) }).rejects.toThrow("jq: error: string (\"bar\") and number (1) cannot be added");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '{{foo}}/{{bar}}', {throwOnError: true}) }).rejects.toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
+        expect(async () => { await jq.renderRecursivelyAsync({}, '/{{foo}}/', {throwOnError: true}) }).rejects.toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
+        expect(async () => { await jq.renderRecursivelyAsync({}, { "{{ spreadValue() }}": "str" }, { throwOnError: true }) })
+            .rejects.toThrow('Evaluated value should be an object if the key is {{ spreadValue() }}. Original value: str, evaluated to: "str"');
+        expect(async () => { await jq.renderRecursivelyAsync({}, { "{{ spreadValue() }}": "{{ \"str\" }}" }, { throwOnError: true }) })
+            .rejects.toThrow('Evaluated value should be an object if the key is {{ spreadValue() }}. Original value: {{ \"str\" }}, evaluated to: "str"');
+    })
+})
+

package/test/template.test.js

@@ -44,7 +44,7 @@ describe('template', () => {
         const json = "foo";
         const input = '{{.foo}}';
         const result = jq.renderRecursively(json, input);
-
+        console.log('!!!!!',result);
         expect(result).toBe(null);
     });
     it('should excape \'\' to ""', () => {
@@ -165,8 +165,8 @@ describe('template', () => {
     })
     it('test throw on error', () => {
         expect(() => { jq.renderRecursively({}, '{{foo}}', {throwOnError: true}) }).toThrow("jq: compile error: foo/0 is not defined at <top-level>, line 1:");
-        expect(() => { jq.renderRecursively({}, '{{1/0}}', {throwOnError: true}) }).toThrow("jq: compile error: Division by zero? at <top-level>, line 1:");
-        expect(() => { jq.renderRecursively({}, '{{{}}', {throwOnError: true}) }).toThrow("jq: compile error: syntax error, unexpected $end (Unix shell quoting issues?) at <top-level>, line 1:");
+        expect(() => { jq.renderRecursively({}, '{{1/0}}', {throwOnError: true}) }).toThrow("number (1) and number (0) cannot be divided because the divisor is zero");
+        expect(() => { jq.renderRecursively({}, '{{{}}', {throwOnError: true}) }).toThrow("jq: compile error: syntax error, unexpected end of file (Unix shell quoting issues?) at <top-level>, line 1:");
         expect(() => { jq.renderRecursively({}, '{{ {(0):1} }}', {throwOnError: true}) }).toThrow("jq: compile error: Cannot use number (0) as object key at <top-level>, line 1:");
         expect(() => { jq.renderRecursively({}, '{{if true then 1 else 0}}', {throwOnError: true}) }).toThrow("jq: compile error: Possibly unterminated 'if' statement at <top-level>, line 1:");
         expect(() => { jq.renderRecursively({}, '{{null | map(.+1)}}', {throwOnError: true}) }).toThrow("jq: error: Cannot iterate over null (null)");

package/deps/jq/.travis.yml

@@ -1,202 +0,0 @@
-sudo: false
-
-language: c
-
-stages:
-    -   name: test
-
-    -   name: build
-        # Don't run build stage for pull requests to save time and resources.
-        if: type != pull_request
-
-
-jobs:
-    include:
-        # Build with gcc and run tests on Ubuntu.
-        -   &test-ubuntu
-            stage: test
-            os: linux
-            compiler: gcc
-
-            addons:
-                apt:
-                    packages:
-                        - valgrind
-                        - bison
-                        - automake
-
-            before_install:
-                - uname -s
-                - rvm install ruby-1.9.3-p551
-                - rvm use 1.9.3
-                - rm src/{lexer,parser}.{c,h}
-                - sed -i.bak '/^AM_INIT_AUTOMAKE(\[-Wno-portability 1\.14\])$/s/14/11/' modules/oniguruma/configure.ac
-
-            install:
-                - bundle install --gemfile=docs/Gemfile
-                - wget http://ftp.debian.org/debian/pool/main/b/bison/bison_3.0.2.dfsg-2_amd64.deb
-                - ar p bison_3.0.2.dfsg-2_amd64.deb data.tar.xz | tar xJ
-                - if [ -n "$COVERAGE" ]; then pip install --user cpp-coveralls; fi
-
-            before_script:
-                # If this is OS X we'll get bison from brew, else we'll get bison
-                # from the .deb unpacked above in the install section.
-                - PATH=/usr/local/opt/bison/bin:$PWD/usr/bin:$PATH
-                - echo SHELL=$SHELL
-                - echo PATH=$PATH
-                - which bison
-                - bison --version
-                - autoreconf -if
-                - ./configure --with-oniguruma=builtin YACC="$(which bison) -y" $COVERAGE
-
-            script:
-                # When using the bison from Debian we need to tell that bison where
-                # to find its data.  Yay non-relocatable code.  Not.
-                - echo PATH=$PATH
-                - which bison
-                - make BISON_PKGDATADIR=$PWD/usr/share/bison src/parser.c || make src/parser.c
-                # Make dist!
-                #
-                # Make it first to fail the build early, before we test with
-                # valgrind.
-                - make dist
-                # Build and test the dist (without valgrind)
-                - |
-                    (
-                    tar xvf jq-`scripts/version`.tar.gz &&
-                    cd jq-`scripts/version` &&
-                    pwd &&
-                    ./configure --disable-valgrind --with-oniguruma=builtin YACC="$(which bison) -y" $COVERAGE &&
-                    make BISON_PKGDATADIR=$PWD/usr/share/bison src/parser.c || make src/parser.c &&
-                    make -j4 &&
-                    make check -j4 || true
-                    )
-                # Build and test the HEAD
-                - make -j4
-                - make check -j4
-
-            after_failure:
-                - cat test-suite.log
-                - cat tests/*.log
-
-
-        # Build with clang and run tests on Ubuntu.
-        -   <<: *test-ubuntu
-            compiler: clang
-
-
-        # Build with gcc and run tests with gcov on Ubuntu.
-        -   <<: *test-ubuntu
-            env: COVERAGE="--disable-valgrind --enable-gcov"
-
-            after_script:
-                - rm -rf src/.libs # don't care about coverage for libjq
-                - coveralls --gcov-options '\-lp'
-                    -e src/lexer.c -e src/parser.c -e src/jv_dtoa.c
-
-
-        # Build with gcc and run tests on macOS.
-        -   &test-osx
-            <<: *test-ubuntu
-            os: osx
-
-            before_install:
-                - uname -s
-                - brew update
-                - brew install flex bison
-                - rvm install ruby-1.9.3-p551
-                - rvm use 1.9.3
-                - gem install bundler
-                - rm src/{lexer,parser}.{c,h}
-                - sed -i.bak '/^AM_INIT_AUTOMAKE(\[-Wno-portability 1\.14\])$/s/14/11/' modules/oniguruma/configure.ac
-
-            install:
-                - bundle install --gemfile=docs/Gemfile
-                - if [ -n "$COVERAGE" ]; then pip install --user cpp-coveralls; fi
-
-
-        # Build with clang and run tests on macOS.
-        -   <<: *test-osx
-            compiler: clang
-
-
-        # Build with gcc and run tests on Alpine Linux v3.7 (inside chroot).
-        # Note: Alpine uses musl libc.
-        -   &test-alpine
-            stage: test
-            os: linux
-            language: minimal
-            compiler: gcc
-            sudo: true
-
-            before_install:
-                - "wget 'https://raw.githubusercontent.com/alpinelinux/alpine-chroot-install/v0.7.0/alpine-chroot-install' \
-                    && echo '090d323d887ef3a2fd4e752428553f22a52b87bb  alpine-chroot-install' | sha1sum -c || travis_terminate 1"
-                - alpine() { /alpine/enter-chroot -u "$USER" "$@"; }
-
-            install:
-                - sudo sh alpine-chroot-install -b v3.7 -a "$ARCH"
-                    -p 'build-base automake autoconf bison libtool oniguruma-dev'
-
-            before_script:
-                - autoreconf -if
-
-            script:
-                - alpine ./configure --disable-docs
-                - alpine make
-                - alpine make check
-
-
-        # Build release binary statically linked with musl libc on Alpine Linux
-        # (inside chroot). If building a tagged commit, then deploy release
-        # tarball to GitHub Releases.
-        -   &build-alpine
-            <<: *test-alpine
-            stage: build
-            env: ARCH=x86_64
-
-            script:
-                - alpine ./configure --disable-docs --enable-all-static
-                    CFLAGS='-Os -static -no-pie' CXXFLAGS='-Os -static -no-pie'
-                - alpine make
-                - alpine strip jq
-
-                - jq -V
-                - ls -lah jq
-                - file jq
-                # Ensure that the built executable is really statically linked.
-                - file jq | grep -Fw 'statically linked'
-
-            before_deploy:
-                - PKGNAME="jq-$TRAVIS_TAG-$ARCH-linux"
-                - mkdir $PKGNAME && mv jq $PKGNAME/
-                - tar -czf $PKGNAME.tar.gz $PKGNAME/
-                - sha256sum $PKGNAME.tar.gz > $PKGNAME.tar.gz.sha256
-
-            deploy:
-                provider: releases
-                api_key:
-                    secure:  # TODO: put encrypted GitHub token here!
-                file: jq-$TRAVIS_TAG-*.tar.gz*
-                file_glob: true
-                skip_cleanup: true
-                on:
-                    tags: true
-
-        # Build binaries for other architectures using QEMU user-mode emulation.
-        -   <<: *build-alpine
-            env: ARCH=x86
-
-        -   <<: *build-alpine
-            env: ARCH=aarch64
-
-        -   <<: *build-alpine
-            env: ARCH=armhf
-
-        -   <<: *build-alpine
-            env: ARCH=ppc64le
-
-
-notifications:
-    email: false
-