From b3993d8fa2e72bf8fe9dd68acf2e1e0c9465d3ed Mon Sep 17 00:00:00 2001
From: Merlin Beutlberger <m.beutlberger@sap.com>
Date: Fri, 3 Dec 2021 00:32:13 +0100
Subject: [PATCH] [INTERNAL] Rework ReaderFilter to accept a simple filter
 callback

---
 lib/AbstractReader.js    |  6 ++--
 lib/ReaderFilter.js      | 54 +++++---------------------------
 test/lib/ReaderFilter.js | 66 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 76 insertions(+), 50 deletions(-)
 create mode 100644 test/lib/ReaderFilter.js

diff --git a/lib/AbstractReader.js b/lib/AbstractReader.js
index 6475d5e0..5f8fb9fc 100644
--- a/lib/AbstractReader.js
+++ b/lib/AbstractReader.js
@@ -70,13 +70,11 @@ class AbstractReader {
 		});
 	}
 
-	filter({resourceTagCollection, matchMode, filters}) {
+	filter(callback) {
 		const ReaderFilter = require("./ReaderFilter");
 		return new ReaderFilter({
 			reader: this,
-			resourceTagCollection,
-			matchMode,
-			filters
+			filterCallback: callback
 		});
 	}
 
diff --git a/lib/ReaderFilter.js b/lib/ReaderFilter.js
index d406e1b2..da18707b 100644
--- a/lib/ReaderFilter.js
+++ b/lib/ReaderFilter.js
@@ -13,30 +13,19 @@ class ReaderFilter extends AbstractReader {
 	 *
 	 * @param {object} parameters Parameters
 	 * @param {module:@ui5/fs.AbstractReader} parameters.reader A resource reader
-	 * @param {module:@ui5/fs.ResourceTagCollection} parameters.resourceTagCollection
-	 * 			Resource tag collection to apply filters onto
-	 * @param {object[]} parameters.filters Filters
-	 * @param {string} parameters.matchMode Whether to match "any", "all" or "none"
+	 * @param {Function} parameters.filterCallback
+	 * 			Filter function. Should return true for items to keep and false otherwise
 	 */
-	constructor({reader, resourceTagCollection, filters, matchMode}) {
+	constructor({reader, filterCallback}) {
 		super();
 		if (!reader) {
 			throw new Error(`Missing parameter "reader"`);
 		}
-		if (!resourceTagCollection) {
-			throw new Error(`Missing parameter "resourceTagCollection"`);
-		}
-		if (!filters || !filters.length) {
-			throw new Error(`Missing parameter "filters"`);
-		}
-		if (!matchMode) {
-			throw new Error(`Missing parameter "matchMode"`);
+		if (!filterCallback) {
+			throw new Error(`Missing parameter "filterCallback"`);
 		}
 		this._reader = reader;
-		this._resourceTagCollection = resourceTagCollection;
-		this._filters = filters;
-
-		this._matchMode = matchMode;
+		this._filterCallback = filterCallback;
 	}
 
 	/**
@@ -51,7 +40,7 @@ class ReaderFilter extends AbstractReader {
 	 */
 	async _byGlob(pattern, options, trace) {
 		const result = await this._reader._byGlob(pattern, options, trace);
-		return result.filter(this._filterResource.bind(this));
+		return result.filter(this._filterCallback);
 	}
 
 	/**
@@ -66,39 +55,12 @@ class ReaderFilter extends AbstractReader {
 	async _byPath(virPath, options, trace) {
 		const result = await this._reader._byPath(virPath, options, trace);
 		if (result) {
-			if (!this._filterResource(result)) {
+			if (!this._filterCallback(result)) {
 				return null;
 			}
 		}
 		return result;
 	}
-
-	_filterResource(resource) {
-		let filterFunction;
-		let testEquality = true;
-		switch (this._matchMode) {
-		case "any":
-			filterFunction = "some";
-			break;
-		case "all":
-			filterFunction = "every";
-			break;
-		case "none":
-			filterFunction = "every";
-			testEquality = false;
-			break;
-		default:
-			throw Error(`Unknown match mode ${this._matchMode}`);
-		}
-		return this._filters[filterFunction](({tag, value: filterValue}) => {
-			const tagValue = this._resourceTagCollection.getTag(resource, tag);
-			if (testEquality) {
-				return tagValue === filterValue;
-			} else {
-				return tagValue !== filterValue;
-			}
-		});
-	}
 }
 
 module.exports = ReaderFilter;
diff --git a/test/lib/ReaderFilter.js b/test/lib/ReaderFilter.js
new file mode 100644
index 00000000..3bef2a68
--- /dev/null
+++ b/test/lib/ReaderFilter.js
@@ -0,0 +1,66 @@
+const test = require("ava");
+const sinon = require("sinon");
+const ReaderFilter = require("../../lib/ReaderFilter");
+
+test("_byGlob: Basic filter", async (t) => {
+	const abstractReader = {
+		_byGlob: sinon.stub().returns(Promise.resolve(["resource a", "resource b"]))
+	};
+	const trace = {
+		collection: sinon.spy()
+	};
+	const readerCollection = new ReaderFilter({
+		reader: abstractReader,
+		filterCallback: function(resource) {
+			if (resource === "resource a") {
+				return false;
+			}
+			return true;
+		}
+	});
+
+	const resources = await readerCollection._byGlob("anyPattern", {}, trace);
+	t.deepEqual(resources, ["resource b"], "Correct resource in result");
+});
+
+test("_byPath: Negative filter", async (t) => {
+	const abstractReader = {
+		_byPath: sinon.stub().returns(Promise.resolve("resource a"))
+	};
+	const trace = {
+		collection: sinon.spy()
+	};
+	const readerCollection = new ReaderFilter({
+		reader: abstractReader,
+		filterCallback: function(resource) {
+			if (resource === "resource a") {
+				return false;
+			}
+			return true;
+		}
+	});
+
+	const resources = await readerCollection._byPath("anyPattern", {}, trace);
+	t.deepEqual(resources, null, "Correct empty in result");
+});
+
+test("_byPath: Positive filter", async (t) => {
+	const abstractReader = {
+		_byPath: sinon.stub().returns(Promise.resolve("resource b"))
+	};
+	const trace = {
+		collection: sinon.spy()
+	};
+	const readerCollection = new ReaderFilter({
+		reader: abstractReader,
+		filterCallback: function(resource) {
+			if (resource === "resource a") {
+				return false;
+			}
+			return true;
+		}
+	});
+
+	const resources = await readerCollection._byPath("anyPattern", {}, trace);
+	t.deepEqual(resources, "resource b", "Correct resource in result");
+});