Added support for dot-delimited paths to access and match nested item values.

jrencz · jrencz · commit b6df99a52b6f · 2014-06-06T11:23:06.000+02:00
Renamed provider properties.
Applied JSCS to test spec.
Tagged 0.1.0
diff --git a/Gruntfile.js b/Gruntfile.js
@@ -112,7 +112,11 @@ module.exports = function (grunt) {
         },
         jscs: {
             all: {
-                src: '<%= jshint.all.src %>',
+                src: [
+                    'Gruntfile.js',
+                    'src/<%= pkg.name %>.js',
+                    'test/unit/spec/<%= pkg.name %>.spec.js',
+                ],
                 options: {
                     config: '.jscs.json',
                 },
diff --git a/README.md b/README.md
@@ -22,7 +22,7 @@ A module providing an [AngularJS](http://angularjs.org/) filter which can be use
 ```
 angular.module('myApp')
   .config(function (uiTreeFilterSettingsProvider) {
-    uiTreeFilterSettingsProvider.supportedFields = ['title', 'description', 'username'];
+    uiTreeFilterSettingsProvider.addresses = ['title', 'description', 'username'];
   });
 ```
 
@@ -68,9 +68,10 @@ Filter can be used in the template to as an argument of the `ng-show` or `ng-if`
 
 ## Configuration reference
 
-- `supportedFields` (default: `['title']`): properties of notes against which pattern will be matched
+- `addresses` (default: `['title']`): properties of notes against which pattern will be matched.
+   Deep filed access is supported: one can provide `foo.bar.baz` to match against item.foo.bar.baz value. 
 - `regexFlags` (default: `'gi'`): [Regular expression flags](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/RegExp#Parameters) applied during he matching
-- `descendantCollectionField` (default: `'items'`): property of the node that holds nodes descendants
+- `descendantCollection` (default: `'items'`): name of item property that holds item descendants
 
 ## Performance
 
diff --git a/bower.json b/bower.json
@@ -1,6 +1,6 @@
 {
     "name": "angular-ui-tree-filter",
-    "version": "0.0.2",
+    "version": "0.1.0",
     "homepage": "https://github.com/ee/angular-ui-tree-filter",
     "authors": [
         "Jarek Rencz", "Jarek Rencz <jarek.rencz@laboratorium.ee>"
diff --git a/demo/dist/angular-ui-tree-filter.min.js b/demo/dist/angular-ui-tree-filter.min.js
diff --git a/dist/angular-ui-tree-filter.js b/dist/angular-ui-tree-filter.js
@@ -10,15 +10,15 @@
 
             var uiTreeFilterSettings = this;
 
-            this.supportedFields = ['title'];
+            this.addresses = ['title'];
             this.regexFlags = 'gi';
-            this.descendantCollectionField = 'items';
+            this.descendantCollection = 'items';
 
             this.$get = function () {
                 return {
-                    supportedFields: uiTreeFilterSettings.supportedFields,
+                    addresses: uiTreeFilterSettings.addresses,
                     regexFlags: uiTreeFilterSettings.regexFlags,
-                    descendantCollectionField: uiTreeFilterSettings.descendantCollectionField,
+                    descendantCollection: uiTreeFilterSettings.descendantCollection,
                 };
             };
         })
@@ -31,50 +31,68 @@
              * Iterates through given collection if flag is not true and sets a flag to true on first match.
              *
              * @param {Array}   collection
-             * @param {string}  fieldName
              * @param {string}  pattern
-             * @param {boolean} flag
+             * @param {string}  address
+             *
              * @returns {boolean}
              */
-            function visit(collection, pattern, fieldName, flag) {
-                flag = flag || false;
-                if (!flag && collection) {
-                    collection.forEach(function (collectionItem) {
-                        flag = flag ? true : testForField(collectionItem, fieldName, pattern);
-                    });
-                }
-                return flag;
+            function visit(collection, pattern, address) {
+                collection = collection || [];
+                var foundSoFar = false;
+
+                collection.forEach(function (collectionItem) {
+                    foundSoFar = foundSoFar || testForField(collectionItem, pattern, address);
+                });
+
+                return foundSoFar;
+            }
+
+            /**
+             * Resolves object value from dot-delimited address.
+             *
+             * @param object
+             * @param path
+             * @returns {*}
+             */
+            function resolveAddress(object, path) {
+                var parts = path.split('.');
+                return parts.length < 2 ? object[parts[0]] : resolveAddress(object[parts[0]], parts.slice(1).join('.'));
             }
 
             /**
              * Checks if object or its children matches a pattern on a given field
              *
-             * @param {object} item
+             * First it resolves the property address and gets the value.
+             * If the value is a string it matches it against provided pattern.
+             * If item matches because its property matches it's children are not checked.
+             * Otherwise all item descendants are checked as well
+             *
+             * @param {Object} item
              * @param {string} pattern
-             * @param {string} fieldName
+             * @param {string} address property name or dot-delimited path to property.
              *
              * @returns {boolean}
              */
-            function testForField(item, pattern, fieldName) {
-                var foundInField = item[fieldName] ?
-                    !!item[fieldName].match(new RegExp(pattern, uiTreeFilterSettings.regexFlags)) :
+            function testForField(item, pattern, address) {
+                var value = resolveAddress(item, address);
+                var found = typeof value === 'string' ?
+                    !!value.match(new RegExp(pattern, uiTreeFilterSettings.regexFlags)) :
                     false;
-
-                return visit(item[uiTreeFilterSettings.descendantCollectionField], fieldName, pattern, foundInField);
+                return found || visit(item[uiTreeFilterSettings.descendantCollection], pattern, address);
             }
 
             /**
-             * Checks if pattern matches any of supported fields
+             * Checks if pattern matches any of addresses
              *
              * @param {object} item
              * @param {string} pattern
              *
              * @returns {boolean}
              */
-            return function (item, pattern, supportedFields) {
-                supportedFields = supportedFields || uiTreeFilterSettings.supportedFields;
-                return supportedFields.reduce(function (foundInAnyField, fieldName) {
-                    return foundInAnyField ? true : testForField(item, pattern, fieldName);
+            return function (item, pattern, addresses) {
+                addresses = addresses || uiTreeFilterSettings.addresses;
+                return pattern === undefined || addresses.reduce(function (foundSoFar, fieldName) {
+                    return foundSoFar || testForField(item, pattern, fieldName);
                 }, false);
             };
         }]);
diff --git a/dist/angular-ui-tree-filter.min.js b/dist/angular-ui-tree-filter.min.js
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "angular-ui-tree-filter",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "A module providing an AngularJS filter which can be used with angular-ui-tree to match tree nodes",
   "scripts": {
     "test": "grunt test"
diff --git a/src/angular-ui-tree-filter.js b/src/angular-ui-tree-filter.js
@@ -10,15 +10,15 @@
 
             const uiTreeFilterSettings = this;
 
-            this.supportedFields = ['title'];
+            this.addresses = ['title'];
             this.regexFlags = 'gi';
-            this.descendantCollectionField = 'items';
+            this.descendantCollection = 'items';
 
             this.$get = function () {
                 return {
-                    supportedFields: uiTreeFilterSettings.supportedFields,
+                    addresses: uiTreeFilterSettings.addresses,
                     regexFlags: uiTreeFilterSettings.regexFlags,
-                    descendantCollectionField: uiTreeFilterSettings.descendantCollectionField,
+                    descendantCollection: uiTreeFilterSettings.descendantCollection,
                 };
             };
         })
@@ -31,50 +31,68 @@
              * Iterates through given collection if flag is not true and sets a flag to true on first match.
              *
              * @param {Array}   collection
-             * @param {string}  fieldName
              * @param {string}  pattern
-             * @param {boolean} flag
+             * @param {string}  address
+             *
              * @returns {boolean}
              */
-            function visit(collection, pattern, fieldName, flag) {
-                flag = flag || false;
-                if (!flag && collection) {
-                    collection.forEach(function (collectionItem) {
-                        flag = flag ? true : testForField(collectionItem, fieldName, pattern);
-                    });
-                }
-                return flag;
+            function visit(collection, pattern, address) {
+                collection = collection || [];
+                let foundSoFar = false;
+
+                collection.forEach(function (collectionItem) {
+                    foundSoFar = foundSoFar || testForField(collectionItem, pattern, address);
+                });
+
+                return foundSoFar;
+            }
+
+            /**
+             * Resolves object value from dot-delimited address.
+             *
+             * @param object
+             * @param path
+             * @returns {*}
+             */
+            function resolveAddress(object, path) {
+                const parts = path.split('.');
+                return parts.length < 2 ? object[parts[0]] : resolveAddress(object[parts[0]], parts.slice(1).join('.'));
             }
 
             /**
              * Checks if object or its children matches a pattern on a given field
              *
-             * @param {object} item
+             * First it resolves the property address and gets the value.
+             * If the value is a string it matches it against provided pattern.
+             * If item matches because its property matches it's children are not checked.
+             * Otherwise all item descendants are checked as well
+             *
+             * @param {Object} item
              * @param {string} pattern
-             * @param {string} fieldName
+             * @param {string} address property name or dot-delimited path to property.
              *
              * @returns {boolean}
              */
-            function testForField(item, pattern, fieldName) {
-                const foundInField = item[fieldName] ?
-                    !!item[fieldName].match(new RegExp(pattern, uiTreeFilterSettings.regexFlags)) :
+            function testForField(item, pattern, address) {
+                const value = resolveAddress(item, address);
+                const found = typeof value === 'string' ?
+                    !!value.match(new RegExp(pattern, uiTreeFilterSettings.regexFlags)) :
                     false;
-
-                return visit(item[uiTreeFilterSettings.descendantCollectionField], fieldName, pattern, foundInField);
+                return found || visit(item[uiTreeFilterSettings.descendantCollection], pattern, address);
             }
 
             /**
-             * Checks if pattern matches any of supported fields
+             * Checks if pattern matches any of addresses
              *
              * @param {object} item
              * @param {string} pattern
              *
              * @returns {boolean}
              */
-            return function (item, pattern, supportedFields) {
-                supportedFields = supportedFields || uiTreeFilterSettings.supportedFields;
-                return supportedFields.reduce(function (foundInAnyField, fieldName) {
-                    return foundInAnyField ? true : testForField(item, pattern, fieldName);
+            return function (item, pattern, addresses) {
+                addresses = addresses || uiTreeFilterSettings.addresses;
+                return pattern === undefined || addresses.reduce(function (foundSoFar, fieldName) {
+                    return foundSoFar || testForField(item, pattern, fieldName);
                 }, false);
             };
         });
diff --git a/test/unit/spec/angular-ui-tree-filter.spec.js b/test/unit/spec/angular-ui-tree-filter.spec.js
@@ -5,8 +5,8 @@ describe('Module: ui.tree-filter', function () {
 
     beforeEach(module('ui.tree-filter'));
 
-    beforeEach(module(function(uiTreeFilterSettingsProvider) {
-        uiTreeFilterSettingsProvider.supportedFields = ['title'];
+    beforeEach(module(function (uiTreeFilterSettingsProvider) {
+        uiTreeFilterSettingsProvider.addresses = ['title'];
     }));
 
     beforeEach(function () {
@@ -32,17 +32,17 @@ describe('Module: ui.tree-filter', function () {
                                         id: 212,
                                         title: '2.1.1.1. bubble-burst',
                                         items: [],
-                                    }
-                                ]
-                            }
-                        ]
+                                    },
+                                ],
+                            },
+                        ],
                     },
                     {
                         id: 22,
                         title: '2.2. barehand-atomsplitting',
                         items: [],
-                    }
-                ]
+                    },
+                ],
             },
             {
                 id: 3,
@@ -63,7 +63,7 @@ describe('Module: ui.tree-filter', function () {
 
     it('should match item on level 1', function () {
         const matchedString = 'romantic';
-        
+
         expect(uiTreeFilter(sampleTree[0], matchedString)).toBe(false);
         expect(uiTreeFilter(sampleTree[1], matchedString)).toBe(false);
         expect(uiTreeFilter(sampleTree[1].items[0], matchedString)).toBe(false);
@@ -115,7 +115,7 @@ describe('Module: ui.tree-filter', function () {
 
     it('should match regular expression (entire path)', function () {
         // 2.1, 2.1.1, 2.1.1.1 and 2 since it's part of the path, as well as 2.2
-        const matchedString = "[0-9]\.[0-9]\..[a-z]";
+        const matchedString = '[0-9]\.[0-9]\..[a-z]';
 
         expect(uiTreeFilter(sampleTree[0], matchedString)).toBe(false);
         expect(uiTreeFilter(sampleTree[1], matchedString)).toBe(true);
@@ -135,4 +135,16 @@ describe('Module: ui.tree-filter', function () {
         expect(uiTreeFilter(sampleTree[0], matchedString, ['title', 'description'])).toBe(true);
     });
 
+    it('should match dot-delimited paths to value', function () {
+        sampleTree[0].nested = {
+            property: 'nested property value',
+        };
+        const matchedString = 'nested';
+
+        expect(uiTreeFilter(sampleTree[0], matchedString)).toBe(false);
+        expect(uiTreeFilter(sampleTree[0], matchedString, ['title', 'description'])).toBe(false);
+        expect(uiTreeFilter(sampleTree[0], matchedString, ['title', 'description', 'nested'])).toBe(false);
+        expect(uiTreeFilter(sampleTree[0], matchedString, ['title', 'description', 'nested.property'])).toBe(true);
+    });
+
 });

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "angular-ui-tree-filter",`
`3`		`- "version": "0.0.2",`
	`3`	`+ "version": "0.1.0",`
`4`	`4`	`"homepage": "https://github.com/ee/angular-ui-tree-filter",`
`5`	`5`	`"authors": [`
`6`	`6`	`"Jarek Rencz", "Jarek Rencz <[email protected]>"`