Merge branch 'filter-multiple-values'

src/CategoryOverpassFilter.js

@@ -153,67 +153,74 @@ class CategoryOverpassFilter {
   }
 
   applyParam (param) {
-    this.additionalFilter = []
-    let kvFilter = []
+    this.additionalFilter = Object.keys(param).map(k => {
+      let values = param[k]
+      let d = this.data[k]
 
-    for (var k in param) {
-      if (param[k] === null) {
-        continue
+      if (values === null) {
+        return null
       }
 
-      var d = this.data[k]
-
-      if ('values' in d && param[k] in d.values && typeof d.values[param[k]] === 'object' && 'query' in d.values[param[k]]) {
-        let f = new Filter(d.values[param[k]].query)
-        this.additionalFilter.push(f.def)
-        continue
-      } else if (d.queryTemplate) {
-        let f = new Filter(decodeHTML(d.queryTemplate.render({ value: param[k] }).toString()))
-        this.additionalFilter.push(f.def)
-        continue
+      if (!Array.isArray(values)) {
+        values = [ values ]
       }
 
-      var v  = {
-        key: 'key' in d ? d.key : k,
-        value: param[k],
-        op: '='
-      }
+      let ret = values.map(value => {
+        if ('values' in d && value in d.values && typeof d.values[value] === 'object' && 'query' in d.values[value]) {
+          let f = new Filter(d.values[value].query)
+          return f.def
+        } else if (d.queryTemplate) {
+          let f = new Filter(decodeHTML(d.queryTemplate.render({ value: value }).toString()))
+          return f.def
+        }
 
-      if ('op' in d) {
-        if (d.op === 'has_key_value') {
-          v = {
-            key: param[k],
-            op: 'has_key'
+        var v  = {
+          key: 'key' in d ? d.key : k,
+          value: value,
+          op: '='
+        }
+
+        if ('op' in d) {
+          if (d.op === 'has_key_value') {
+            v = {
+              key: value,
+              op: 'has_key'
+            }
+          } else {
+            v.op = d.op
           }
-        } else {
-          v.op = d.op
         }
-      }
 
-      if (Array.isArray(v.key)) {
-        v = {
-          "or": v.key.map(
-            key => {
-              let v1 = { key, value: v.value, op: v.op }
+        if (Array.isArray(v.key)) {
+          v = {
+            "or": v.key.map(
+              key => {
+                let v1 = { key, value: v.value, op: v.op }
 
-              let m = key.match(/^(.*)\*(.*)/)
-              if (m) {
-                v1.key = '^' + m[1] + '.*' + m[2]
-                v1.keyRegexp = true
-              }
+                let m = key.match(/^(.*)\*(.*)/)
+                if (m) {
+                  v1.key = '^' + m[1] + '.*' + m[2]
+                  v1.keyRegexp = true
+                }
 
-              return [ v1 ]
-            }
-          )
+                return [ v1 ]
+              }
+            )
+          }
         }
-      }
 
-      kvFilter.push(v)
-    }
+        return [ v ]
+      }).filter(f => f) // remove null values
 
-    if (kvFilter.length) {
-      this.additionalFilter.push(kvFilter)
-    }
+      switch (ret.length) {
+        case 0:
+          return null
+        case 1:
+          return ret[0]
+        default:
+          return { or: ret }
+      }
+    }).filter(f => f) // remove null values
 
     if (this.additionalFilter.length === 0) {
       this.additionalFilter = []