Cast values containing numbers into Number objects in Filter and SLD

format to ensure correct comparison of scale denominators against map 
scale  and filters against features. Introduces a new 
OpenLayers.String.numericIf function. r=fredj,tschaub (closes #1874)


git-svn-id: http://svn.openlayers.org/trunk/openlayers@8927 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf

lib/OpenLayers/BaseTypes.js

@@ -186,6 +186,18 @@ OpenLayers.String = {
      */
     isNumeric: function(value) {
         return OpenLayers.String.numberRegEx.test(value);
+    },
+    
+    /**
+     * APIFunction: numericIf
+     * Converts a string that appears to be a numeric value into a number.
+     * 
+     * Returns
+     * {Number|String} a Number if the passed value is a number, a String
+     *     otherwise. 
+     */
+    numericIf: function(value) {
+        return OpenLayers.String.isNumeric(value) ? parseFloat(value) : value;
     }
 
 };

lib/OpenLayers/Format/Filter/v1.js

@@ -168,16 +168,19 @@ OpenLayers.Format.Filter.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
                 obj.filters.push(filter);
             },
             "Literal": function(node, obj) {
-                obj.value = this.getChildValue(node);
+                obj.value = OpenLayers.String.numericIf(
+                    this.getChildValue(node));
             },
             "PropertyName": function(node, filter) {
                 filter.property = this.getChildValue(node);
             },
             "LowerBoundary": function(node, filter) {
-                filter.lowerBoundary = this.readOgcExpression(node);
+                filter.lowerBoundary = OpenLayers.String.numericIf(
+                    this.readOgcExpression(node));
             },
             "UpperBoundary": function(node, filter) {
-                filter.upperBoundary = this.readOgcExpression(node);
+                filter.upperBoundary = OpenLayers.String.numericIf(
+                    this.readOgcExpression(node));
             },
             "Intersects": function(node, obj) {
                 this.readSpatial(node, obj, OpenLayers.Filter.Spatial.INTERSECTS);

lib/OpenLayers/Format/SLD/v1.js

@@ -154,13 +154,13 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.Filter.v1_0_0, {
                 rule.elseFilter = true;
             },
             "MinScaleDenominator": function(node, rule) {
-                rule.minScaleDenominator = this.getChildValue(node);
+                rule.minScaleDenominator = parseFloat(this.getChildValue(node));
             },
             "MaxScaleDenominator": function(node, rule) {
-                rule.maxScaleDenominator = this.getChildValue(node);
+                rule.maxScaleDenominator = parseFloat(this.getChildValue(node));
             },
             "LineSymbolizer": function(node, rule) {
-                // OpenLayers doens't do painter's order, instead we extend
+                // OpenLayers doesn't do painter's order, instead we extend
                 var symbolizer = rule.symbolizer["Line"] || {};
                 this.readChildNodes(node, symbolizer);
                 // in case it didn't exist before

tests/BaseTypes.html

@@ -195,6 +195,42 @@
         }
         
     }
+    
+    function test_Number_numericIf(t) {
+        var cases = [
+            {value: "3", expect: 3},
+            {value: "+3", expect: 3},
+            {value: "-3", expect: -3},
+            {value: "3.0", expect: 3},
+            {value: "+3.0", expect: 3},
+            {value: "-3.0", expect: -3},
+            {value: "6.02e23", expect: 6.02e23},
+            {value: "+1.0e-100", expect: 1e-100},
+            {value: "-1.0e+100", expect: -1e100},
+            {value: "1E100", expect: 1e100},
+            {value: null, expect: null},
+            {value: true, expect: true},
+            {value: false, expect: false},
+            {value: undefined, expect: undefined},
+            {value: "", expect: ""},
+            {value: "3 ", expect: "3 "},
+            {value: " 3", expect: " 3"},
+            {value: "1e", expect: "1e"},
+            {value: "1+e", expect: "1+e"},
+            {value: "1-e", expect: "1-e"}
+        ];
+        t.plan(cases.length);
+        
+        var func = OpenLayers.String.numericIf;
+        var obj, val, got, exp;
+        for(var i=0; i<cases.length; ++i) {
+            obj = cases[i];
+            val = obj.value;
+            exp = obj.expect;
+            got = func(val);
+            t.eq(got, exp, "'" + val + "' returns " + exp);
+        }
+    }
    
    
     function test_Number_limitSigDigs(t) {

tests/Format/SLD/v1_0_0.html

@@ -105,7 +105,7 @@
         '</StyledLayerDescriptor>';
 
     function test_read(t) {
-        t.plan(6);
+        t.plan(8);
         
         var parser = new OpenLayers.Format.SLD.v1_0_0();
         var xml = new OpenLayers.Format.XML();
@@ -131,7 +131,23 @@
         t.ok(style instanceof OpenLayers.Style, "(AAA161,0) user style is instance of OpenLayers.Style");
         t.eq(style.rules.length, 2, "(AAA161,0) user style has 2 rules");
         
-        // check the first rule
+        // check the second rule
+        rule = style.rules[1];
+        var feature = {
+            layer: {
+                map: {
+                    getScale: function(){
+                        return 40000; 
+                    }
+                }
+            },
+            attributes: {
+                CTE: "900"
+            }
+        };
+        t.ok(typeof rule.maxScaleDenominator == "number", "MaxScaleDenominator is a number");
+        t.eq(rule.evaluate(feature), true, "numeric filter comparison evaluates correctly");
+        
         // etc.  I'm convinced read works, really wanted to test write (since examples don't test that)
         // I'll add more tests here later.