[5.x] Add parent keyword to field conditions

resources/js/components/field-conditions/Converter.js

@@ -32,11 +32,17 @@ export default class {
     }
 
     getScopedFieldHandle(field, prefix) {
-        if (field.startsWith('root.') || ! prefix) {
+        if (field.startsWith('$root.') || field.startsWith('root.')) {
             return field;
         }
 
-        return prefix + field;
+        if (field.startsWith('$parent.')) {
+            return field;
+        }
+
+        return prefix
+            ? prefix + field
+            : field;
     }
 
     getOperatorFromRhs(condition) {

resources/js/components/field-conditions/ParentResolver.js

@@ -0,0 +1,42 @@
+export default class {
+    constructor(currentFieldPath) {
+        this.currentFieldPath = currentFieldPath;
+    }
+
+    resolve(pathWithParent) {
+        let parentPath = this.getParentFieldPath(this.currentFieldPath, true);
+        let fieldPath = this.removeOneParentKeyword(pathWithParent);
+
+        while (fieldPath.startsWith('$parent.')) {
+            parentPath = this.getParentFieldPath(parentPath);
+            fieldPath = this.removeOneParentKeyword(fieldPath);
+        }
+
+        let resolved = parentPath
+            ? `${parentPath}.${fieldPath}`
+            : fieldPath;
+
+        return `$root.${resolved}`;
+    }
+
+    getParentFieldPath(dottedFieldPath, removeCurrentField) {
+        const regex = new RegExp('(.*?[^\\.]+)(\\.[0-9]+)*\\.[^\\.]*$');
+
+        if (removeCurrentField || this.isAtSetLevel(dottedFieldPath)) {
+            dottedFieldPath = dottedFieldPath.replace(regex, '$1');
+        }
+
+        return dottedFieldPath.includes('.')
+            ? dottedFieldPath.replace(regex, '$1$2')
+            : '';
+    }
+
+    isAtSetLevel(dottedFieldPath) {
+        return dottedFieldPath.match(new RegExp('(\\.[0-9]+)$'));
+    }
+
+    removeOneParentKeyword(dottedFieldPath) {
+        return dottedFieldPath.replace(new RegExp('^\\$parent.'), '');
+    }
+
+}

resources/js/components/field-conditions/Validator.js

@@ -1,4 +1,5 @@
 import Converter from './Converter.js';
+import ParentResolver from './ParentResolver.js';
 import { KEYS } from './Constants.js';
 import { data_get } from  '../../bootstrap/globals.js'
 import isString from 'underscore/modules/isString.js'
@@ -20,12 +21,13 @@ const NUMBER_SPECIFIC_COMPARISONS = [
 ];
 
 export default class {
-    constructor(field, values, store, storeName) {
+    constructor(field, values, dottedFieldPath, store, storeName) {
         this.field = field;
         this.values = values;
-        this.rootValues = store ? store.state.publish[storeName].values : false;
+        this.dottedFieldPath = dottedFieldPath;
         this.store = store;
         this.storeName = storeName;
+        this.rootValues = store ? store.state.publish[storeName].values : false;
         this.passOnAny = false;
         this.showOnPass = true;
         this.converter = new Converter;
@@ -204,9 +206,15 @@ export default class {
     }
 
     getFieldValue(field) {
-        return field.startsWith('root.')
-            ?  data_get(this.rootValues, field.replace(new RegExp('^root.'), ''))
-            :  data_get(this.values, field);
+        if (field.startsWith('$parent.')) {
+            field = new ParentResolver(this.dottedFieldPath).resolve(field);
+        }
+
+        if (field.startsWith('$root.') || field.startsWith('root.')) {
+            return data_get(this.rootValues, field.replace(new RegExp('^\\$?root\\.'), ''));
+        }
+
+        return data_get(this.values, field);
     }
 
     passesCondition(condition) {
@@ -264,6 +272,7 @@ export default class {
             root: this.rootValues,
             store: this.store,
             storeName: this.storeName,
+            fieldPath: this.dottedFieldPath,
         });
 
         return this.showOnPass ? passes : ! passes;
@@ -286,12 +295,16 @@ export default class {
     }
 
     relativeLhsToAbsoluteFieldPath(lhs, dottedPrefix) {
-        if (! dottedPrefix) {
-            return lhs;
+        if (lhs.startsWith('$parent.')) {
+            lhs = new ParentResolver(this.dottedFieldPath).resolve(lhs);
+        }
+
+        if (lhs.startsWith('$root.') || lhs.startsWith('root.')) {
+            return lhs.replace(new RegExp('^\\$?root\\.'), '');
         }
 
-        return lhs.startsWith('root.')
-            ? lhs.replace(/^root\./, '')
-            : dottedPrefix + '.' + lhs;
+        return dottedPrefix
+            ? dottedPrefix + '.' + lhs
+            : lhs;
     }
 }

resources/js/components/field-conditions/ValidatorMixin.js

@@ -25,7 +25,7 @@ export default {
             }
 
             // Use validation to determine whether field should be shown.
-            let validator = new Validator(field, this.values, this.$store, this.storeName);
+            let validator = new Validator(field, this.values, dottedFieldPath, this.$store, this.storeName);
             let passes = validator.passesConditions();
 
             // If the field is configured to always save, never omit value.

resources/js/tests/FieldConditionsConverter.test.js

@@ -35,7 +35,21 @@ test('it converts from blueprint format and applies prefixes', () => {
     expect(converted).toEqual(expected);
 });
 
-test('it converts from blueprint format and does not apply prefix to root field conditions', () => {
+test('it converts from blueprint format and does not apply prefix to field conditions with root syntax', () => {
+    let converted = FieldConditionsConverter.fromBlueprint({
+        'name': 'isnt joe',
+        '$root.title': 'not empty',
+    }, 'nested_');
+
+    let expected = [
+        {field: 'nested_name', operator: 'not', value: 'joe'},
+        {field: '$root.title', operator: 'not', value: 'empty'}
+    ];
+
+    expect(converted).toEqual(expected);
+});
+
+test('it converts from blueprint format and does not apply prefix to field conditions with legacy root syntax for backwards compatibility', () => {
     let converted = FieldConditionsConverter.fromBlueprint({
         'name': 'isnt joe',
         'root.title': 'not empty',
@@ -49,6 +63,20 @@ test('it converts from blueprint format and does not apply prefix to root field
     expect(converted).toEqual(expected);
 });
 
+test('it converts from blueprint format and does not apply prefix to field conditions with parent syntax', () => {
+    let converted = FieldConditionsConverter.fromBlueprint({
+        'name': 'isnt joe',
+        '$parent.title': 'not empty',
+    }, 'nested_');
+
+    let expected = [
+        {field: 'nested_name', operator: 'not', value: 'joe'},
+        {field: '$parent.title', operator: 'not', value: 'empty'}
+    ];
+
+    expect(converted).toEqual(expected);
+});
+
 test('it converts to blueprint format', () => {
     let converted = FieldConditionsConverter.toBlueprint([
         {field: 'name', operator: 'isnt', value: 'joe'},

resources/js/tests/FieldConditionsParentResolver.test.js

@@ -0,0 +1,68 @@
+import ParentResolver from '../components/field-conditions/ParentResolver.js';
+
+let resolve = function (currentFieldPath, pathWithParent) {
+    return new ParentResolver(currentFieldPath).resolve(pathWithParent);
+}
+
+test('it resolves from group to top level', () => {
+    expect(resolve('group.field', '$parent.name')).toEqual('$root.name');
+});
+
+test('it resolves from set/row to top level', () => {
+    expect(resolve('replicator.0.field', '$parent.name')).toEqual('$root.name');
+    expect(resolve('grid.0.field', '$parent.name')).toEqual('$root.name');
+    expect(resolve('bard.0.field', '$parent.name')).toEqual('$root.name');
+});
+
+test('it resolves from nested group to parent group', () => {
+    expect(resolve('group.nested_group.field', '$parent.name')).toEqual('$root.group.name');
+});
+
+test('it resolves from nested set to parent set', () => {
+    expect(resolve('replicator.2.nested_replicator.1.field', '$parent.name')).toEqual('$root.replicator.2.name');
+    expect(resolve('grid.2.nested_grid.1.field', '$parent.name')).toEqual('$root.grid.2.name');
+    expect(resolve('bard.2.nested_bard.1.field', '$parent.name')).toEqual('$root.bard.2.name');
+});
+
+test('it resolves from nested group to parent set', () => {
+    expect(resolve('replicator.1.group.field', '$parent.name')).toEqual('$root.replicator.1.name');
+    expect(resolve('grid.1.group.field', '$parent.name')).toEqual('$root.grid.1.name');
+    expect(resolve('bard.1.group.field', '$parent.name')).toEqual('$root.bard.1.name');
+});
+
+test('it resolves from nested set to parent group', () => {
+    expect(resolve('group.replicator.1.field', '$parent.name')).toEqual('$root.group.name');
+    expect(resolve('group.grid.1.field', '$parent.name')).toEqual('$root.group.name');
+    expect(resolve('group.bard.1.field', '$parent.name')).toEqual('$root.group.name');
+});
+
+test('it resolves from deeply nested groups all the way up to top level', () => {
+    let fromField = 'group.nested_group.deeper_group.deeeeeeeper_group.field';
+
+    expect(resolve(fromField, '$parent.name')).toEqual('$root.group.nested_group.deeper_group.name');
+    expect(resolve(fromField, '$parent.$parent.name')).toEqual('$root.group.nested_group.name');
+    expect(resolve(fromField, '$parent.$parent.$parent.name')).toEqual('$root.group.name');
+    expect(resolve(fromField, '$parent.$parent.$parent.$parent.name')).toEqual('$root.name');
+});
+
+test('it resolves from deeply nested sets all the way up to top level', () => {
+    let fromField = 'replicator.1.bard.4.grid.0.replicator.6.field';
+
+    expect(resolve(fromField, '$parent.name')).toEqual('$root.replicator.1.bard.4.grid.0.name');
+    expect(resolve(fromField, '$parent.$parent.name')).toEqual('$root.replicator.1.bard.4.name');
+    expect(resolve(fromField, '$parent.$parent.$parent.name')).toEqual('$root.replicator.1.name');
+    expect(resolve(fromField, '$parent.$parent.$parent.$parent.name')).toEqual('$root.name');
+});
+
+test('it resolves from deeply nested mix of everything all the way up to top level', () => {
+    let fromField = 'group.replicator.1.group.bard.4.grid.0.group.group.replicator.6.field';
+
+    expect(resolve(fromField, '$parent.name')).toEqual('$root.group.replicator.1.group.bard.4.grid.0.group.group.name');
+    expect(resolve(fromField, '$parent.$parent.name')).toEqual('$root.group.replicator.1.group.bard.4.grid.0.group.name');
+    expect(resolve(fromField, '$parent.$parent.$parent.name')).toEqual('$root.group.replicator.1.group.bard.4.grid.0.name');
+    expect(resolve(fromField, '$parent.$parent.$parent.$parent.name')).toEqual('$root.group.replicator.1.group.bard.4.name');
+    expect(resolve(fromField, '$parent.$parent.$parent.$parent.$parent.name')).toEqual('$root.group.replicator.1.group.name');
+    expect(resolve(fromField, '$parent.$parent.$parent.$parent.$parent.$parent.name')).toEqual('$root.group.replicator.1.name');
+    expect(resolve(fromField, '$parent.$parent.$parent.$parent.$parent.$parent.$parent.name')).toEqual('$root.group.name');
+    expect(resolve(fromField, '$parent.$parent.$parent.$parent.$parent.$parent.$parent.$parent.name')).toEqual('$root.name');
+});