@rhinostone/swig-twig 2.0.0-alpha.4 → 2.0.0-alpha.5

package/lib/index.js

@@ -16,7 +16,8 @@ var utils = require('@rhinostone/swig-core/lib/utils'),
   dateformatter = require('@rhinostone/swig-core/lib/dateformatter'),
   parser = require('./parser'),
   _tags = require('./tags'),
-  _filters = require('./filters');
+  _filters = require('./filters'),
+  _tests = require('./tests');
 
 exports.name = 'twig';
 
@@ -140,6 +141,7 @@ exports.setDefaultTZOffset = function (offset) {
  * @return {object}           New Twig environment.
  */
 exports.Twig = function (opts) {
+  var self = this;
   validateOptions(opts);
   this.options = utils.extend({}, defaultOptions, opts || {});
   this.cache = {};
@@ -154,6 +156,16 @@ exports.Twig = function (opts) {
       utils.throwError(err, null, options.filename);
     }
   });
+
+  // Register Twig `is <name>` runtime helpers as `_ext._test_<name>`. The
+  // parser lowers `foo is odd` to a two-segment VarRef + FnCall pointing
+  // at this slot, so the helpers must be installed on every Twig
+  // instance (including the default one). `setExtension` attaches to the
+  // per-instance `extensions` map — consumers can still override a test
+  // with their own `setExtension('_test_<name>', fn)` after construction.
+  utils.each(_tests, function (fn, name) {
+    self.setExtension('_test_' + name, fn);
+  });
 };
 
 /*!

package/lib/parser.js

@@ -302,11 +302,11 @@ exports.parseExpr = function (tokens, filters, _posOut) {
     var m;
     switch (tok.type) {
     case _t.STRING:
-      return ir.literal('string', unquoteString(tok.match));
+      return parsePostfix(ir.literal('string', unquoteString(tok.match)));
     case _t.NUMBER:
-      return ir.literal('number', parseFloat(tok.match));
+      return parsePostfix(ir.literal('number', parseFloat(tok.match)));
     case _t.BOOL:
-      return ir.literal('bool', tok.match === 'true');
+      return parsePostfix(ir.literal('bool', tok.match === 'true'));
     case _t.NOT:
       return ir.unaryOp('!', parseUnary());
     case _t.OPERATOR:
@@ -371,13 +371,29 @@ exports.parseExpr = function (tokens, filters, _posOut) {
       // parses as `(foo is defined) and bar`.
       if (info.op === 'is' || info.op === 'is not') {
         var test = parseTest();
-        var testCall = ir.fnCall(ir.varRef(['_test_' + test.name]), [left].concat(test.args));
+        var testCall;
+        // VarRef subjects coerce null/undefined to "" through checkMatchExpr
+        // in emitVarRef, which loses the defined/undefined signal that
+        // `is defined` / `is null` need. Route both through IRVarRefExists
+        // (same shape as the `??` fallback from C3) so a path that is
+        // actually undefined or null yields the right boolean instead of
+        // being compared against the coerced "" placeholder. Non-VarRef
+        // subjects (Literal, BinaryOp, FnCall, FilterCall) evaluate to a
+        // concrete value with no coercion, so they fall through to the
+        // generic `_ext._test_<name>` helper path registered by the engine.
+        if (test.args.length === 0 && left.type === 'VarRef' && test.name === 'defined') {
+          testCall = ir.varRefExists(left.path, left.loc);
+        } else if (test.args.length === 0 && left.type === 'VarRef' && test.name === 'null') {
+          testCall = ir.unaryOp('!', ir.varRefExists(left.path, left.loc));
+        } else {
+          testCall = ir.fnCall(ir.varRef(['_ext', '_test_' + test.name]), [left].concat(test.args));
+        }
         left = info.op === 'is not' ? ir.unaryOp('!', testCall) : testCall;
         continue;
       }
       var right = parseExpression(info.prec + 1);
       if (info.op === '..') {
-        left = ir.fnCall(ir.varRef(['_range']), [left, right]);
+        left = ir.fnCall(ir.varRef(['_utils', 'range']), [left, right]);
       } else {
         left = ir.binaryOp(info.op, left, right);
       }

package/lib/tests/index.js

@@ -0,0 +1,109 @@
+/**
+ * @rhinostone/swig-twig — built-in test runtime helpers.
+ *
+ * Twig `is <name>` / `is not <name>` expressions lower to
+ * `_ext._test_<name>(subject, ...args)` at the IR layer. The Twig
+ * constructor registers each export here via `self.setExtension('_test_'
+ * + name, fn)`, which installs the helper onto the per-instance
+ * `_swig.extensions` map — so Path A (`new Twig().render(...)`) honors
+ * per-instance overrides without leaking cross-instance.
+ *
+ * Two tests (`defined`, `null`) are additionally special-cased in the
+ * Twig parser when the subject is a VarRef with no args: both route
+ * through IRVarRefExists to preserve the defined/undefined signal that
+ * `emitVarRef` coerces to "". The helpers below still run for non-VarRef
+ * subjects (literals, BinaryOp, FnCall) where the coercion isn't in
+ * play. See packages/swig-twig/lib/parser.js `parseExpression` IS/ISNOT
+ * branch for the special-case logic.
+ */
+
+function isNumber(v) {
+  return typeof v === 'number' && !isNaN(v);
+}
+
+/**
+ * `foo is defined` — true when the subject is not `undefined`. The
+ * VarRef-subject path bypasses this helper and uses IRVarRefExists.
+ *
+ * @param  {*} v
+ * @return {boolean}
+ */
+exports['defined'] = function (v) {
+  return typeof v !== 'undefined';
+};
+
+/**
+ * `foo is null` — true when the subject is `null` or `undefined`. The
+ * VarRef-subject path bypasses this helper and uses `!IRVarRefExists`.
+ *
+ * @param  {*} v
+ * @return {boolean}
+ */
+exports['null'] = function (v) {
+  return v === null || typeof v === 'undefined';
+};
+
+/**
+ * `foo is empty` — true for `null`, `undefined`, `""`, empty arrays,
+ * and objects with no own-enumerable keys.
+ *
+ * @param  {*} v
+ * @return {boolean}
+ */
+exports['empty'] = function (v) {
+  if (v === null || typeof v === 'undefined') { return true; }
+  if (typeof v === 'string') { return v.length === 0; }
+  if (Object.prototype.toString.call(v) === '[object Array]') { return v.length === 0; }
+  if (typeof v === 'object') {
+    for (var k in v) {
+      if (Object.prototype.hasOwnProperty.call(v, k)) { return false; }
+    }
+    return true;
+  }
+  return false;
+};
+
+/**
+ * `foo is iterable` — true for arrays and non-null objects (mirrors
+ * Twig's rule that dicts iterate by key).
+ *
+ * @param  {*} v
+ * @return {boolean}
+ */
+exports['iterable'] = function (v) {
+  if (v === null || typeof v === 'undefined') { return false; }
+  if (Object.prototype.toString.call(v) === '[object Array]') { return true; }
+  return typeof v === 'object';
+};
+
+/**
+ * `n is odd` — true for numbers whose remainder mod 2 is non-zero.
+ *
+ * @param  {number} v
+ * @return {boolean}
+ */
+exports['odd'] = function (v) {
+  return isNumber(v) && v % 2 !== 0;
+};
+
+/**
+ * `n is even` — true for numbers whose remainder mod 2 is zero.
+ *
+ * @param  {number} v
+ * @return {boolean}
+ */
+exports['even'] = function (v) {
+  return isNumber(v) && v % 2 === 0;
+};
+
+/**
+ * `n is divisibleby(m)` — true when `m` is a non-zero number and `n % m
+ * === 0`. Twig's canonical name for the test.
+ *
+ * @param  {number} v
+ * @param  {number} n
+ * @return {boolean}
+ */
+exports['divisibleby'] = function (v, n) {
+  return isNumber(v) && isNumber(n) && n !== 0 && v % n === 0;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhinostone/swig-twig",
-  "version": "2.0.0-alpha.4",
+  "version": "2.0.0-alpha.5",
   "description": "Twig frontend for the @rhinostone/swig-core template engine. Phase 3 of the multi-flavor architecture (see @rhinostone/swig #T16).",
   "keywords": [
     "template",
@@ -22,7 +22,7 @@
     "node": ">=12"
   },
   "peerDependencies": {
-    "@rhinostone/swig-core": "2.0.0-alpha.4"
+    "@rhinostone/swig-core": "2.0.0-alpha.5"
   },
   "publishConfig": {
     "access": "public"