[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');
+});

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');
+});

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');
+});

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');
+});

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');
+});

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');
+});

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');
+});

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');
+});