Jslt Versions Save

Issue #160 was fixed in this release, solving a relatively serious bug, so upgrading is recommended.

The Jackson dependencies were also upgraded, to avoid versions with known vulnerabilities.

This version was released to fix a threading issue in the sha256-hex function (issue #261).

In addition, it also removes usage of some deprecated Jackson APIs.

There are no other changes.

This release adds the uuid() built-in function, and a couple of minor improvements. Parsing of decimal numbers in the number() function has been improved to handle larger decimals. Also, syntax errors in regular expressions are now detected at compile time when possible.

Thanks to @fuchsst for the design and implementation of the uuid() function!

This release fixes a serious bug in the number() function that returned wrong results when converting strings into negative decimal numbers (issue #160).

Other than that, what is new in this release compared to 0.1.10 is what was added in the 0.1.11-beta:

When creating objects for output the key can now be computed with a JSLT expression.

Three functions have been added:

zip-with-index
zip
index-of

And, finally, the JSLT implementation has been made fully thread-safe by making the regular expression cache thread-safe.

This beta release adds one language extension, three functions, and fixes one bug.

When creating objects for output the key can now be computed with a JSLT expression.

Three functions have been added:

• zip-with-index
• zip
• index-of

And, finally, the JSLT implementation has been made fully thread-safe by making the regular expression cache thread-safe.

The main change in this release is the new pipe operator |, which allows you to set the context node explicitly. The most obvious use case for it is to select a source JSON object to do object matching, but it can be used for many other things, too. Many thanks to @ecerulm for contributing the implementation!

Other changes:

• The parse-url function has been added, designed and implemented by @ecerulm
• A bug in the parsing of escape sequences inside strings was fixed by @biochimia

Language changes:

• New functions min() and max() added
• New function hash-int added (thanks to @ecerulm)
• null + object now produces the object (not null)
• null + array now produces the array (not null)

API changes:

• FileSystemResourceResolver added (thanks to @ngsoftwaredev)
• Made it possible to configure encoding on resolvers

Bug fixes:

• Support leading zeroes in strings passed to number() (issue #112)
• Support Cyrillic characters in string literals (issue #115)
• Upgraded to Jackson 2.10.3 (security fixes)
• Handle null being returned from Java extension functions
• Avoid NullPointerException when statically wrapped method does not exist

Not so many changes in this version, which is being released because of the bug fix:

• Bug fix for issue #70: variable optimization issue in for loops
• Allow trailing commas in objects and arrays (thanks to @ecerulm for this change (see #72))
• Upgraded to Jackson 2.9.9

The following extensions have been made:

• Which values are included in JSON objects is now configurable (by default keys = null are omitted),
• The replace function was added
• The trim function was added

The following bugs have been fixed:

• Made JSLT work on JDK 11 by removing javax.* dependency
• Fixed a bug with variable references and array slicers

Some language improvements:

• it used to be impossible to declare global variables in modules and then refer to them from functions. This now works.
• JSLT now forbids object literals that contain the same key twice.
• JSLT now depends on Jackson 2.9.8.

One function has been added:

• mod(a, b) to compute a modulo b. (Thank you to @ecerulm for work on this!)

This version has been optimized in several ways:

• variables that are used only once, or that have constant values, are now optimized away completely
• operations involving two literals are now performed at compile-time,
• the internal representation of variables is now much faster, and
• if b in contains(a, b) is a large array literal, the optimizer now replaces this with a hashset lookup, instead of doing a linear search.