Ticket #495: patch-MapFish-495-r2707-A2.diff

server/python/mapfish/tests/test_filter.py

@@ -224 +224 @@
     filter = filter.to_sql_expr()
     params = filter.compile().params
     assert str(filter) == '"table".text LIKE :text_1'
-    assert params["text_1"] == "%foo%"
+    assert params["text_1"] == "foo"
 
 def test_comparison_ilike():
     filter = comparison.Comparison(
@@ -235 +235 @@
     filter = filter.to_sql_expr()
     params = filter.compile().params
     assert str(filter) == 'lower("table".text) LIKE lower(:text_1)'
-    assert params["text_1"] == "%foo%"
+    assert params["text_1"] == "foo"
 
 #
 # Test FeatureId
@@ -284 +284 @@
     filter = filter.to_sql_expr()
     params = filter.compile().params
     assert str(filter) == '"table".text NOT LIKE :text_1'
-    assert params["text_1"] == "%foo%"
+    assert params["text_1"] == "foo"
 
 def test_logical_and():
     filter = logical.Logical(
@@ -306 +306 @@
     params = filter.compile().params
     assert str(filter) == '"table".id = :id_1 AND "table".text LIKE :text_1'
     assert params["id_1"] == 1
-    assert params["text_1"] == "%foo%"
+    assert params["text_1"] == "foo"
 
 def test_logical_or():
     filter = logical.Logical(
@@ -328 +328 @@
     params = filter.compile().params
     assert str(filter) == '"table".id = :id_1 OR "table".text LIKE :text_1'
     assert params["id_1"] == 1
-    assert params["text_1"] == "%foo%"
+    assert params["text_1"] == "foo"

server/python/mapfish/lib/filters/comparison.py

@@ -92 +92 @@
             )
 
         if self.type == Comparison.LIKE:
-            return self.column.like('%' + self.values['value'] + '%')
+            return self.column.like(self.values['value'])
 
         if self.type == Comparison.ILIKE:
-            return self.column.ilike('%' + self.values['value'] + '%')
+            return self.column.ilike(self.values['value'])

client/mfbase/mapfish/tests/widgets/recenter/DataField.html

@@ -117 +117 @@
                      "protocol.read is passed a LIKE filter");
                 t.eq(options.filter.property, "bar",
                      "protocol.read is passed a filter with expected property");
-                t.eq(options.filter.value, q,
+                t.eq(options.filter.value, ".*" + q + ".*",
                      "protocol.read is passed a filter with expected value");
             };
 

client/mfbase/mapfish/tests/core/Protocol/MapFish.html

@@ -64 +64 @@
     }
 
     function test_MapFish_filterAdapter(t) {
-        t.plan(43);
+        t.plan(46);
 
         // setup
 
@@ -367 +367 @@
         t.eq(options.filter, undefined,
              "filterAdapter deletes filter");
 
+        // 3 tests
+        protocol = new mapfish.Protocol.MapFish({wildcarded: true});
+        options = {
+            filter: new OpenLayers.Filter.Comparison({
+                type: OpenLayers.Filter.Comparison.LIKE,
+                property: "foo",
+                value: "bar"
+            })
+        };
+
+        protocol.filterAdapter(options);
+        t.eq(options.params["queryable"][0], "foo",
+             "filterAdapter sets correct queryable param if passed a LIKE filter (wildcarded true)");
+        t.eq(options.params["foo__ilike"], "%bar%",
+             "filterAdapter sets correct param key and value if passed an LIKE filter (wildcarded true)");
+        t.eq(options.filter, undefined,
+             "filterAdapter deletes filter (wildcarded true)");
     }
 
+    function test_MapFish_regex2value(t) {
+        t.plan(16);
+
+        // setup
+
+        var protocol = new mapfish.Protocol.MapFish();
+        var value;
+
+        // test
+
+        value = protocol.regex2value("foo");
+        t.eq(value, "foo", 'regex2value converts "foo" to "foo"');
+
+        value = protocol.regex2value("foo%");
+        t.eq(value, "foo\\%", 'regex2value converts "foo%" to "foo\\%"');
+
+        value = protocol.regex2value("foo.*");
+        t.eq(value, "foo%", 'regex2value converts "foo.*" to "foo%"');
+
+        value = protocol.regex2value("f.*oo.*");
+        t.eq(value, "f%oo%", 'regex2value converts "f.*oo.*" to "f%oo%"');
+
+        value = protocol.regex2value("foo.");
+        t.eq(value, "foo_", 'regex2value converts "foo." to "foo_"');
+
+        value = protocol.regex2value("f.oo.");
+        t.eq(value, "f_oo_", 'regex2value converts "f.oo." to "f_oo_"');
+
+        value = protocol.regex2value("f.oo.*");
+        t.eq(value, "f_oo%", 'regex2value converts "f.oo.*" to "f_oo%"');
+
+        value = protocol.regex2value("foo\\\\");
+        t.eq(value, "foo\\\\", 'regex2value converts "foo\\\\" to "foo\\\\"');
+
+        value = protocol.regex2value("foo\\.");
+        t.eq(value, "foo.", 'regex2value converts "foo\\." to "foo."');
+
+        value = protocol.regex2value("foo\\\\.");
+        t.eq(value, "foo\\\\_", 'regex2value converts "foo\\\\." to "foo\\\\_"');
+
+        value = protocol.regex2value("foo\\*");
+        t.eq(value, "foo*", 'regex2value converts "foo\\*" to "foo*"');
+
+        value = protocol.regex2value("foo\\\\*");
+        t.eq(value, "foo\\\\*", 'regex2value converts "foo\\\\*" to "foo\\\\*"');
+
+        value = protocol.regex2value("foo\\\\.*");
+        t.eq(value, "foo\\\\%", 'regex2value converts "foo\\\\.*" to "foo\\\\%"');
+
+        value = protocol.regex2value("fo\\.o.*");
+        t.eq(value, "fo.o%", 'regex2value converts from "fo\\.o.*" to "fo.o%"');
+
+        value = protocol.regex2value("fo.*o\\.");
+        t.eq(value, "fo%o.", 'regex2value converts from "fo.*o\\." to "to%o."');
+
+        value = protocol.regex2value("\\*\\..*.\\\\.*\\\\.%");
+        t.eq(value, "*.%_\\\\%\\\\_\\%",
+             'regex2value converts from "\\*\\..*.\\\\.*\\\\.%" ' +
+             'to "*.%_\\\\%\\\\_\\%"');
+   }
+
     function test_MapFish_update(t) {
         t.plan(9);
 

client/mfbase/mapfish/widgets/recenter/DataField.js

@@ -151 +151 @@
         // itself passes these options to protocol.read
         store.on({
             beforeload: function(store, options) {
+                var value = ".*" + store.baseParams[combo.queryParam] + ".*";
                 options.filter = new OpenLayers.Filter.Comparison({
                     type: OpenLayers.Filter.Comparison.LIKE,
                     property: combo.queryParam,
-                    value: store.baseParams[combo.queryParam]
+                    value: value
                 });
                 // remove the queryParam from the store's base
                 // params not to pollute the query string

client/mfbase/mapfish/core/Protocol/MapFish.js

@@ -37 +37 @@
 
 mapfish.Protocol.MapFish = OpenLayers.Class(OpenLayers.Protocol.HTTP, {
     /**
+     * APIProperty: wildcarded.
+     * {Boolean} If true percent signs are added around values 
+     *     read from LIKE filters, for example if the protocol
+     *     read method is passed a LIKE filter whose property
+     *     is "foo" and whose value is "bar" the string
+     *     "foo__ilike=%bar%" will be sent in the query string;
+     *     defaults to false.
+     */
+    wildcarded: false,
+
+    /**
      * Constructor: mapfish.Protocol.MapFish
      *
      * Parameters:
@@ -203 +214 @@
                         'Unknown comparison filter type ' + filter.type);
                     return false;
                 }
-                params[filter.property + "__" + op] = filter.value;
+                var value = filter.value;
+                if (filter.type == OpenLayers.Filter.Comparison.LIKE) {
+                    value = this.regex2value(value);
+                    if (this.wildcarded) {
+                        value = "%" + value + "%";
+                    }
+                }
+                params[filter.property + "__" + op] = value;
                 params["queryable"] = params["queryable"] || [];
                 params["queryable"].push(filter.property);
                 break;
@@ -231 +249 @@
     },
 
     /**
+     * Method: regex2value
+     * Convert the value from a regular expression string to a LIKE/ILIKE
+     *     string known to the MapFish web service.
+     *
+     * Parameters:
+     * value - {String} The regex string.
+     *
+     * Returns:
+     * {String} The converted string.
+     */
+    regex2value: function(value) {
+
+        // highly sensitive!! Do not change this without running the
+        // Protocol/MapFish.html unit tests
+
+        // convert % to \%
+        value = value.replace(/%/g, "\\%");
+
+        // convert \\. to \\_ (\\.* occurences converted later)
+        value = value.replace(/\\\\\.(\*)?/g, function($0, $1) {
+            return $1 ? $0 : "\\\\_";
+        });
+
+        // convert \\.* to \\%
+        value = value.replace(/\\\\\.\*/g, "\\\\%");
+
+        // convert . to _ (\. and .* occurences converted later)
+        value = value.replace(/(\\)?\.(\*)?/g, function($0, $1, $2) {
+            return $1 || $2 ? $0 : "_";
+        });
+
+        // convert .* to % (\.* occurnces converted later)
+        value = value.replace(/(\\)?\.\*/g, function($0, $1) {
+            return $1 ? $0 : "%";
+        });
+
+        // convert \. to .
+        value = value.replace(/\\\./g, ".");
+
+        // replace \* with * (watching out for \\*)
+        value = value.replace(/(\\)?\\\*/g, function($0, $1) {
+            return $1 ? $0 : "*";
+        });
+        
+        return value;
+    },
+
+    /**
      * Method: filterAdapter
      *      If params has a filter property and if that filter property
      *      is an OpenLayers.Filter that the MapFish protocol can deal