mikser-io-render-liquid 4.2.2 → 4.2.3

package/index.js

@@ -319,10 +319,23 @@ export function parseReferences(source) {
                     const raw = [...found][0] ?? null
                     const from = raw ? record(raw, scope, guarded) : null
                     if (node.key) {
-                        assigns.push({ key: node.key, from })
+                        // `derived` travels with it: the closure walker applies
+                        // these assigns as bindings too, and it has no other way
+                        // to know the value went through a filter.
+                        const derived = !!(node.value?.filters ?? []).length
+                        assigns.push({ key: node.key, from, ...(derived ? { derived } : {}) })
                         // Bound for the REST of this template, which is what
                         // `assign` means — everything after it sees the alias.
-                        if (from) scope[node.key] = from
+                        //
+                        // NOT bound when the value passed through a filter: the
+                        // result is DERIVED, so a read on it says nothing about
+                        // the source. `{% assign rows = c.specs | split: '|' %}`
+                        // turns a string into a list, and binding it would let a
+                        // loop over `rows` report `specs[]` — a key the document
+                        // does not have and cannot be given, since specs is the
+                        // string being split. The source itself is still
+                        // recorded above, which is the true dependency.
+                        if (from && !derived) scope[node.key] = from
                     }
                     break
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mikser-io-render-liquid",
-  "version": "4.2.2",
+  "version": "4.2.3",
   "description": "",
   "main": "index.js",
   "type": "module",

package/test/references.test.js

@@ -213,3 +213,47 @@ describe('liquid parseReferences: default: as a guard', () => {
             `optional: ${r.optional.join(', ')}`)
     })
 })
+
+// A filtered value is DERIVED, not an alias.
+//
+// `{% assign rows = c.specs | split: '|' %}` turns a string into a list, so a
+// read of `rows[0]` says nothing about `specs` having members. Treating it as an
+// alias reports `specs[]` as a required key of a document whose `specs` IS the
+// string being split — a key no document can ever satisfy, on a page that
+// renders correctly.
+describe('liquid parseReferences: derived values are not aliases', () => {
+    it('records the source but does not extend paths under it', () => {
+        const r = parseReferences(
+            "{% assign rows = data.meta.specs | split: '|' %}"
+            + '{% for row in rows %}{{ row.name }}{% endfor %}')
+        assert.ok(r.variables.includes('data.meta.specs'), 'the real dependency is still recorded')
+        assert.ok(!r.variables.some(v => v.startsWith('data.meta.specs[')),
+            `fabricated a member of a string: ${r.variables.join(', ')}`)
+    })
+
+    it('marks the assign derived so a closure walker knows too', () => {
+        // The walker applies these as bindings as well, and has no other way to
+        // know the value went through a filter.
+        const r = parseReferences("{% assign rows = data.meta.specs | split: '|' %}")
+        assert.equal(r.assigns.find(a => a.key === 'rows')?.derived, true)
+    })
+
+    it('leaves an UNFILTERED alias working', () => {
+        const r = parseReferences('{% assign hero = data.meta.hero %}{{ hero.title }}')
+        assert.ok(r.variables.includes('data.meta.hero.title'))
+        assert.ok(!r.assigns.find(a => a.key === 'hero')?.derived)
+    })
+
+    it('handles the real shape: split, loop, split again', () => {
+        // Verbatim from the project that surfaced this.
+        const r = parseReferences(
+            "{% assign rows = data.meta.results.cases | split: '|' %}"
+            + '{% for row in rows %}'
+            + "{% assign kv = row | split: ':' %}"
+            + '<dt>{{ kv[0] }}</dt>'
+            + '{% endfor %}')
+        assert.ok(r.variables.includes('data.meta.results.cases'))
+        assert.ok(!r.variables.some(v => /results\.cases\[/.test(v)),
+            `fabricated: ${r.variables.filter(v => v.includes('cases')).join(', ')}`)
+    })
+})