Move /lib to /src

src/filter-component.js

@@ -0,0 +1,141 @@
+/*
+Copyright 2016 OpenMarket Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+"use strict";
+/**
+ * @module filter-component
+ */
+
+/**
+ * Checks if a value matches a given field value, which may be a * terminated
+ * wildcard pattern.
+ * @param {String} actual_value  The value to be compared
+ * @param {String} filter_value  The filter pattern to be compared
+ * @return {bool} true if the actual_value matches the filter_value
+ */
+function _matches_wildcard(actual_value, filter_value) {
+    if (filter_value.endsWith("*")) {
+        var type_prefix = filter_value.slice(0, -1);
+        return actual_value.substr(0, type_prefix.length) === type_prefix;
+    }
+    else {
+        return actual_value === filter_value;
+    }
+}
+
+/**
+ * FilterComponent is a section of a Filter definition which defines the
+ * types, rooms, senders filters etc to be applied to a particular type of resource.
+ * This is all ported over from synapse's Filter object.
+ *
+ * N.B. that synapse refers to these as 'Filters', and what js-sdk refers to as
+ * 'Filters' are referred to as 'FilterCollections'.
+ *
+ * @constructor
+ * @param {Object} the definition of this filter JSON, e.g. { 'contains_url': true }
+ */
+function FilterComponent(filter_json) {
+    this.filter_json = filter_json;
+
+    this.types = filter_json.types || null;
+    this.not_types = filter_json.not_types || [];
+
+    this.rooms = filter_json.rooms || null;
+    this.not_rooms = filter_json.not_rooms || [];
+
+    this.senders = filter_json.senders || null;
+    this.not_senders = filter_json.not_senders || [];
+
+    this.contains_url = filter_json.contains_url || null;
+}
+
+/**
+ * Checks with the filter component matches the given event
+ * @param {MatrixEvent} event event to be checked against the filter
+ * @return {bool} true if the event matches the filter
+ */
+FilterComponent.prototype.check = function(event) {
+    return this._checkFields(
+        event.getRoomId(),
+        event.getSender(),
+        event.getType(),
+        event.getContent() ? event.getContent().url !== undefined : false
+    );
+};
+
+/**
+ * Checks whether the filter component matches the given event fields.
+ * @param {String} room_id       the room_id for the event being checked
+ * @param {String} sender        the sender of the event being checked
+ * @param {String} event_type    the type of the event being checked
+ * @param {String} contains_url  whether the event contains a content.url field
+ * @return {bool} true if the event fields match the filter
+ */
+FilterComponent.prototype._checkFields =
+    function(room_id, sender, event_type, contains_url)
+{
+    var literal_keys = {
+        "rooms": function(v) { return room_id === v; },
+        "senders": function(v) { return sender === v; },
+        "types": function(v) { return _matches_wildcard(event_type, v); },
+    };
+
+    var self = this;
+    Object.keys(literal_keys).forEach(function(name) {
+        var match_func = literal_keys[name];
+        var not_name = "not_" + name;
+        var disallowed_values = self[not_name];
+        if (disallowed_values.map(match_func)) {
+            return false;
+        }
+
+        var allowed_values = self[name];
+        if (allowed_values) {
+            if (!allowed_values.map(match_func)) {
+                return false;
+            }
+        }
+    });
+
+    var contains_url_filter = this.filter_json.contains_url;
+    if (contains_url_filter !== undefined) {
+        if (contains_url_filter !== contains_url) {
+            return false;
+        }
+    }
+
+    return true;
+};
+
+/**
+ * Filters a list of events down to those which match this filter component
+ * @param {MatrixEvent[]} events  Events to be checked againt the filter component
+ * @return {MatrixEvent[]} events which matched the filter component
+ */
+FilterComponent.prototype.filter = function(events) {
+    return events.filter(this.check, this);
+};
+
+/**
+ * Returns the limit field for a given filter component, providing a default of
+ * 10 if none is otherwise specified.  Cargo-culted from Synapse.
+ * @return {Number} the limit for this filter component.
+ */
+FilterComponent.prototype.limit = function() {
+    return this.filter_json.limit !== undefined ? this.filter_json.limit : 10;
+};
+
+/** The FilterComponent class */
+module.exports = FilterComponent;