OpenLayers OpenLayers

Ticket #1492: filter.2.patch

File filter.2.patch, 81.1 kB (added by tschaub, 9 months ago)

move rule subclasses to filter subclasses and test sld write

  • tests/Filter/FeatureId.html

    old new  
     1<html>  
     2<head>  
     3    <script src="../../lib/OpenLayers.js"></script>  
     4    <script type="text/javascript"> 
     5 
     6    function test_FeatureId_constructor(t) {  
     7        t.plan(3);  
     8          
     9        var options = {'foo': 'bar'};  
     10        var filter = new OpenLayers.Filter.FeatureId(options);  
     11        t.ok(filter instanceof OpenLayers.Filter.FeatureId,  
     12             "new OpenLayers.Filter.FeatureId returns object" );  
     13        t.eq(filter.foo, "bar", "constructor sets options correctly");  
     14        t.eq(typeof filter.evaluate, "function", "filter has an evaluate function");  
     15    } 
     16 
     17    function test_FeatureId_destroy(t) { 
     18        t.plan(1); 
     19         
     20        var filter = new OpenLayers.Filter.FeatureId(); 
     21        filter.destroy(); 
     22        t.eq(filter.symbolizer, null, "symbolizer hash nulled properly"); 
     23    } 
     24     
     25    function test_FeatureId_evaluate(t) { 
     26        t.plan(3); 
     27         
     28        var filter = new OpenLayers.Filter.FeatureId( 
     29                {fids: ["fid_1", "fid_3"]}); 
     30 
     31        var filterResults = { 
     32                "fid_1" : true, 
     33                "fid_2" : false, 
     34                "fid_3" : true}; 
     35        for (var i in filterResults) { 
     36            var feature = new OpenLayers.Feature.Vector(); 
     37            feature.fid = i; 
     38            var result = filter.evaluate(feature); 
     39            t.eq(result, filterResults[i], "feature "+i+" evaluates to "+result.toString()+" correctly."); 
     40            feature.destroy(); 
     41        } 
     42    } 
     43    </script>  
     44</head>  
     45<body>  
     46</body>  
     47</html>  

  • tests/Filter/Comparison.html

    old new  
     1<html>  
     2<head>  
     3    <script src="../../lib/OpenLayers.js"></script>  
     4    <script type="text/javascript"> 
     5 
     6    function test_Comparison_constructor(t) {  
     7        t.plan(3);  
     8          
     9        var options = {'foo': 'bar'};  
     10        var filter = new OpenLayers.Filter.Comparison(options);  
     11        t.ok(filter instanceof OpenLayers.Filter.Comparison,  
     12             "new OpenLayers.Filter.Comparison returns object" );  
     13        t.eq(filter.foo, "bar", "constructor sets options correctly");  
     14        t.eq(typeof filter.evaluate, "function", "filter has an evaluate function");  
     15    } 
     16 
     17    function test_Comparison_destroy(t) { 
     18        t.plan(1); 
     19         
     20        var filter = new OpenLayers.Filter.Comparison(); 
     21        filter.destroy(); 
     22        t.eq(filter.symbolizer, null, "symbolizer hash nulled properly"); 
     23    } 
     24     
     25    function test_Comparison_value2regex(t) { 
     26        t.plan(2); 
     27         
     28        var filter = new OpenLayers.Filter.Comparison({ 
     29                property: "foo", 
     30                value: "*b?r\\*\\?*", 
     31                type: OpenLayers.Filter.Comparison.LIKE}); 
     32        filter.value2regex("*", "?", "\\"); 
     33        t.eq(filter.value, ".*b.r\\*\\?.*", "Regular expression generated correctly."); 
     34         
     35        filter.value = "%b.r!%!.%"; 
     36        filter.value2regex("%", ".", "!"); 
     37        t.eq(filter.value, ".*b.r\\%\\..*", "Regular expression with different wildcard and escape chars generated correctly."); 
     38    } 
     39     
     40    function test_regex2value(t) { 
     41        t.plan(8); 
     42         
     43        function r2v(regex) { 
     44            return OpenLayers.Filter.Comparison.prototype.regex2value.call( 
     45                {value: regex} 
     46            ); 
     47        } 
     48         
     49        t.eq(r2v("foo"), "foo", "doesn't change string without special chars"); 
     50        t.eq(r2v("foo.*foo"), "foo*foo", "wildCard replaced"); 
     51        t.eq(r2v("foo.foo"), "foo.foo", "singleChar replaced"); 
     52        t.eq(r2v("foo\\\\foo"), "foo\\foo", "escape removed"); 
     53        t.eq(r2v("foo!foo"), "foo!!foo", "escapes !"); 
     54        t.eq(r2v("foo\\*foo"), "foo!*foo", "replaces escape on *"); 
     55        t.eq(r2v("foo\\.foo"), "foo!.foo", "replaces escape on ."); 
     56        t.eq(r2v("foo\\\\.foo"), "foo\\.foo", "unescapes only \\ before ."); 
     57         
     58    } 
     59     
     60    function test_Comparison_evaluate(t) { 
     61        t.plan(5); 
     62         
     63        var filter = new OpenLayers.Filter.Comparison({ 
     64                property: "area", 
     65                lowerBoundary: 1000, 
     66                upperBoundary: 4999, 
     67                type: OpenLayers.Filter.Comparison.BETWEEN}); 
     68 
     69        var features = [ 
     70                new OpenLayers.Feature.Vector(null, { 
     71                        area: 999}), 
     72                new OpenLayers.Feature.Vector(null, { 
     73                        area: 1000}), 
     74                new OpenLayers.Feature.Vector(null, { 
     75                        area: 4999}), 
     76                new OpenLayers.Feature.Vector(null, { 
     77                        area: 5000})]; 
     78        // PropertyIsBetween filter: lower and upper boundary are inclusive 
     79        var filterResults = { 
     80                0: false, 
     81                1: true, 
     82                2: true, 
     83                3: false}; 
     84        for (var i in filterResults) { 
     85            var result = filter.evaluate(features[i].attributes); 
     86            t.eq(result, filterResults[i], "feature "+i+ 
     87                    " evaluates to "+result.toString()+" correctly."); 
     88        } 
     89        var context = { 
     90            area: 4998 
     91        }; 
     92        var result = filter.evaluate(context); 
     93        t.eq(result, true, "evaluation against custom filter context works."); 
     94    } 
     95    </script>  
     96</head>  
     97<body>  
     98</body>  
     99</html>  

  • tests/Filter/Logical.html

    old new  
     1<html>  
     2<head>  
     3    <script src="../../lib/OpenLayers.js"></script>  
     4    <script type="text/javascript"> 
     5 
     6    function test_Logical_constructor(t) {  
     7        t.plan(3);  
     8          
     9        var options = {'foo': 'bar'};  
     10        var filter = new OpenLayers.Filter.Logical(options);  
     11        t.ok(filter instanceof OpenLayers.Filter.Logical,  
     12             "new OpenLayers.Filter.Logical returns object" );  
     13        t.eq(filter.foo, "bar", "constructor sets options correctly");  
     14        t.eq(typeof filter.evaluate, "function", "filter has an evaluate function");  
     15    } 
     16 
     17    function test_Logical_destroy(t) { 
     18        t.plan(1); 
     19         
     20        var filter = new OpenLayers.Filter.Logical(); 
     21        filter.destroy(); 
     22        t.eq(filter.filters, null, "filters array nulled properly"); 
     23    } 
     24     
     25    function test_Logical_evaluate(t) { 
     26        t.plan(1); 
     27         
     28        var filter = new OpenLayers.Filter.Logical({ 
     29                type: OpenLayers.Filter.Logical.NOT}); 
     30        filter.filters.push(new OpenLayers.Filter()); 
     31         
     32        var feature = new OpenLayers.Feature.Vector(); 
     33 
     34        t.eq(filter.evaluate(feature.attributes), false, 
     35                "feature evaluates to false correctly."); 
     36    } 
     37    </script>  
     38</head>  
     39<body>  
     40</body>  
     41</html>  

  • tests/Format/SLD/v1_0_0.html

    old new  
     1<html>  
     2<head>  
     3    <script src="../../../lib/OpenLayers.js"></script> 
     4    <script type="text/javascript"> 
     5     
     6    var sld = 
     7        '<StyledLayerDescriptor version="1.0.0" ' + 
     8            'xmlns="http://www.opengis.net/sld" ' + 
     9            'xmlns:gml="http://www.opengis.net/gml" ' + 
     10            'xmlns:ogc="http://www.opengis.net/ogc" ' + 
     11            'xmlns:xlink="http://www.w3.org/1999/xlink" ' + 
     12            'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' + 
     13            'xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd">' + 
     14            '<NamedLayer>' +  
     15                '<Name>AAA161</Name>' +  
     16                '<UserStyle>' +  
     17                    '<FeatureTypeStyle>' +  
     18                        '<Rule>' +  
     19                            '<Name>stortsteen</Name>' +  
     20                            '<ogc:Filter>' + 
     21                                '<ogc:PropertyIsEqualTo>' + 
     22                                    '<ogc:PropertyName>CTE</ogc:PropertyName>' + 
     23                                    '<ogc:Literal>V0305</ogc:Literal>' + 
     24                                '</ogc:PropertyIsEqualTo>' + 
     25                            '</ogc:Filter>' +  
     26                            '<MaxScaleDenominator>50000</MaxScaleDenominator>' +  
     27                            '<PolygonSymbolizer>' +  
     28                                '<Fill>' +  
     29                                    '<CssParameter name="fill">#ffffff</CssParameter>' +  
     30                                '</Fill>' +  
     31                                '<Stroke>' +  
     32                                    '<CssParameter name="stroke">#000000</CssParameter>' +  
     33                                '</Stroke>' +  
     34                            '</PolygonSymbolizer>' +  
     35                        '</Rule>' +  
     36                        '<Rule>' +  
     37                            '<Name>betonbekleding</Name>' +  
     38                            '<ogc:Filter>' + 
     39                                '<ogc:PropertyIsLessThan>' + 
     40                                    '<ogc:PropertyName>CTE</ogc:PropertyName>' + 
     41                                    '<ogc:Literal>1000</ogc:Literal>' + 
     42                                '</ogc:PropertyIsLessThan>' + 
     43                            '</ogc:Filter>' +  
     44                            '<MaxScaleDenominator>50000</MaxScaleDenominator>' +  
     45                            '<PolygonSymbolizer>' +  
     46                                '<Fill>' +  
     47                                    '<CssParameter name="fill">#ffff00</CssParameter>' +  
     48                                '</Fill>' +  
     49                                '<Stroke>' +  
     50                                    '<CssParameter name="stroke">#0000ff</CssParameter>' +  
     51                                '</Stroke>' +  
     52                            '</PolygonSymbolizer>' +  
     53                        '</Rule>' +  
     54                    '</FeatureTypeStyle>' +  
     55                '</UserStyle>' +  
     56            '</NamedLayer>' +  
     57            '<NamedLayer>' +  
     58                '<Name>Second Layer</Name>' +  
     59                '<UserStyle>' +  
     60                    '<FeatureTypeStyle>' +  
     61                        '<Rule>' +  
     62                            '<Name>first rule second layer</Name>' +  
     63                            '<ogc:Filter>' + 
     64                                '<ogc:Or>' + 
     65                                    '<ogc:PropertyIsBetween>' + 
     66                                        '<ogc:PropertyName>number</ogc:PropertyName>' + 
     67                                        '<ogc:LowerBoundary>' + 
     68                                            '<ogc:Literal>1064866676</ogc:Literal>' + 
     69                                        '</ogc:LowerBoundary>' + 
     70                                        '<ogc:UpperBoundary>' + 
     71                                            '<ogc:Literal>1065512599</ogc:Literal>' + 
     72                                        '</ogc:UpperBoundary>' + 
     73                                    '</ogc:PropertyIsBetween>' + 
     74                                    '<ogc:PropertyIsLike wildCard="*" singleChar="." escape="!">' + 
     75                                        '<ogc:PropertyName>cat</ogc:PropertyName>' + 
     76                                        '<ogc:Literal>*dog.food!*good</ogc:Literal>' + 
     77                                    '</ogc:PropertyIsLike>' + 
     78                                    '<ogc:Not>' + 
     79                                        '<ogc:PropertyIsLessThanOrEqualTo>' + 
     80                                            '<ogc:PropertyName>FOO</ogc:PropertyName>' + 
     81                                            '<ogc:Literal>5000</ogc:Literal>' + 
     82                                        '</ogc:PropertyIsLessThanOrEqualTo>' + 
     83                                    '</ogc:Not>' + 
     84                                '</ogc:Or>' + 
     85                            '</ogc:Filter>' +  
     86                            '<MaxScaleDenominator>10000</MaxScaleDenominator>' +  
     87                            '<PointSymbolizer>' + 
     88                                '<Graphic>' + 
     89                                    '<Mark>' + 
     90                                        '<WellKnownName>star</WellKnownName>' + 
     91                                        '<Fill>' +  
     92                                            '<CssParameter name="fill">lime</CssParameter>' +  
     93                                        '</Fill>' +  
     94                                        '<Stroke>' +  
     95                                            '<CssParameter name="stroke">olive</CssParameter>' +  
     96                                            '<CssParameter name="stroke-width">2</CssParameter>' + 
     97                                        '</Stroke>' +  
     98                                    '</Mark>' +  
     99                                '</Graphic>' + 
     100                            '</PointSymbolizer>' + 
     101                        '</Rule>' +  
     102                    '</FeatureTypeStyle>' +  
     103                '</UserStyle>' +  
     104            '</NamedLayer>' + 
     105        '</StyledLayerDescriptor>'; 
     106 
     107    function test_read(t) { 
     108        t.plan(6); 
     109         
     110        var parser = new OpenLayers.Format.SLD.v1_0_0(); 
     111        var xml = new OpenLayers.Format.XML(); 
     112        var obj = parser.read(xml.read(sld)); 
     113         
     114        // test the named layer count 
     115        var count = 0; 
     116        for(var key in obj.namedLayers) { 
     117            ++count; 
     118        }         
     119        t.eq(count, 2, "correct number of named layers"); 
     120         
     121        var layer, style, rule; 
     122         
     123        // check the first named layer 
     124        layer = obj.namedLayers["AAA161"]; 
     125        t.ok(layer, "first named layer exists"); 
     126        t.ok(layer.userStyles instanceof Array, "(AAA161) layer has array of user styles"); 
     127        t.eq(layer.userStyles.length, 1, "(AAA161) first layer has a single user style"); 
     128         
     129        // check the first user style 
     130        style = layer.userStyles[0]; 
     131        t.ok(style instanceof OpenLayers.Style, "(AAA161,0) user style is instance of OpenLayers.Style"); 
     132        t.eq(style.rules.length, 2, "(AAA161,0) user style has 2 rules"); 
     133         
     134        // check the first rule 
     135        // etc.  I'm convinced read works, really wanted to test write (since examples don't test that) 
     136        // I'll add more tests here later.         
     137 
     138    } 
     139     
     140    function test_write(t) { 
     141        t.plan(1); 
     142 
     143        // read first - testing that write produces the SLD aboce 
     144        var parser = new OpenLayers.Format.SLD.v1_0_0(); 
     145        var xml = new OpenLayers.Format.XML(); 
     146        var obj = parser.read(xml.read(sld)); 
     147         
     148        var node = parser.write(obj); 
     149        t.xml_eq(node, sld, "SLD correctly written"); 
     150         
     151    } 
     152     
     153 
     154    </script>  
     155</head>  
     156<body> 
     157</body>  
     158</html>  

  • tests/Filter.html

    old new  
     1<html>  
     2<head>  
     3    <script src="../lib/OpenLayers.js"></script>  
     4    <script type="text/javascript"> 
     5 
     6    function test_initialize(t) {  
     7        t.plan(3);  
     8          
     9        var options = {'foo': 'bar'};  
     10        var filter = new OpenLayers.Filter(options);  
     11        t.ok(filter instanceof OpenLayers.Filter,  
     12             "new OpenLayers.Filter returns object" );  
     13        t.eq(filter.foo, "bar", "constructor sets options correctly");  
     14        t.eq(typeof filter.evaluate, "function", "filter has an evaluate function");  
     15    } 
     16 
     17    </script>  
     18</head>  
     19<body>  
     20</body>  
     21</html>  

  • tests/Rule/FeatureId.html

    old new  
    1 <html>  
    2 <head>  
    3     <script src="../../lib/OpenLayers.js"></script>  
    4     <script type="text/javascript"> 
    5  
    6     function test_FeatureId_constructor(t) {  
    7         t.plan(3);  
    8           
    9         var options = {'foo': 'bar'};  
    10         var rule = new OpenLayers.Rule.FeatureId(options);  
    11         t.ok(rule instanceof OpenLayers.Rule.FeatureId,  
    12              "new OpenLayers.Rule.FeatureId returns object" );  
    13         t.eq(rule.foo, "bar", "constructor sets options correctly");  
    14         t.eq(typeof rule.evaluate, "function", "rule has an evaluate function");  
    15     } 
    16  
    17     function test_FeatureId_destroy(t) { 
    18         t.plan(1); 
    19          
    20         var rule = new OpenLayers.Rule.FeatureId(); 
    21         rule.destroy(); 
    22         t.eq(rule.symbolizer, null, "symbolizer hash nulled properly"); 
    23     } 
    24      
    25     function test_FeatureId_evaluate(t) { 
    26         t.plan(3); 
    27          
    28         var rule = new OpenLayers.Rule.FeatureId( 
    29                 {fids: ["fid_1", "fid_3"]}); 
    30  
    31         var ruleResults = { 
    32                 "fid_1" : true, 
    33                 "fid_2" : false, 
    34                 "fid_3" : true}; 
    35         for (var i in ruleResults) { 
    36             var feature = new OpenLayers.Feature.Vector(); 
    37             feature.fid = i; 
    38             var result = rule.evaluate(feature); 
    39             t.eq(result, ruleResults[i], "feature "+i+" evaluates to "+result.toString()+" correctly."); 
    40             feature.destroy(); 
    41         } 
    42     } 
    43     </script>  
    44 </head>  
    45 <body>  
    46 </body>  
    47 </html>  

  • tests/Rule/Comparison.html

    old new  
    1 <html>  
    2 <head>  
    3     <script src="../../lib/OpenLayers.js"></script>  
    4     <script type="text/javascript"> 
    5  
    6     function test_Comparison_constructor(t) {  
    7         t.plan(3);  
    8           
    9         var options = {'foo': 'bar'};  
    10         var rule = new OpenLayers.Rule.Comparison(options);  
    11         t.ok(rule instanceof OpenLayers.Rule.Comparison,  
    12              "new OpenLayers.Rule.Comparison returns object" );  
    13         t.eq(rule.foo, "bar", "constructor sets options correctly");  
    14         t.eq(typeof rule.evaluate, "function", "rule has an evaluate function");  
    15     } 
    16  
    17     function test_Comparison_destroy(t) { 
    18         t.plan(1); 
    19          
    20         var rule = new OpenLayers.Rule.Comparison(); 
    21         rule.destroy(); 
    22         t.eq(rule.symbolizer, null, "symbolizer hash nulled properly"); 
    23     } 
    24      
    25     function test_Comparison_value2regex(t) { 
    26         t.plan(2); 
    27          
    28         var rule = new OpenLayers.Rule.Comparison({ 
    29                 property: "foo", 
    30                 value: "*b?r\\*\\?*", 
    31                 type: OpenLayers.Rule.Comparison.LIKE}); 
    32         rule.value2regex("*", "?", "\\"); 
    33         t.eq(rule.value, ".*b.r\\*\\?.*", "Regular expression generated correctly."); 
    34          
    35         rule.value = "%b.r!%!.%"; 
    36         rule.value2regex("%", ".", "!"); 
    37         t.eq(rule.value, ".*b.r\\%\\..*", "Regular expression with different wildcard and escape chars generated correctly."); 
    38     } 
    39      
    40     function test_regex2value(t) { 
    41         t.plan(8); 
    42          
    43         function r2v(regex) { 
    44             return OpenLayers.Rule.Comparison.prototype.regex2value.call( 
    45                 {value: regex} 
    46             ); 
    47         } 
    48          
    49         t.eq(r2v("foo"), "foo", "doesn't change string without special chars"); 
    50         t.eq(r2v("foo.*foo"), "foo*foo", "wildCard replaced"); 
    51         t.eq(r2v("foo.foo"), "foo.foo", "singleChar replaced"); 
    52         t.eq(r2v("foo\\\\foo"), "foo\\foo", "escape removed"); 
    53         t.eq(r2v("foo!foo"), "foo!!foo", "escapes !"); 
    54         t.eq(r2v("foo\\*foo"), "foo!*foo", "replaces escape on *"); 
    55         t.eq(r2v("foo\\.foo"), "foo!.foo", "replaces escape on ."); 
    56         t.eq(r2v("foo\\\\.foo"), "foo\\.foo", "unescapes only \\ before ."); 
    57          
    58     } 
    59      
    60     function test_Comparison_evaluate(t) { 
    61         t.plan(5); 
    62          
    63         var rule = new OpenLayers.Rule.Comparison({ 
    64                 property: "area", 
    65                 lowerBoundary: 1000, 
    66                 upperBoundary: 4999, 
    67                 type: OpenLayers.Rule.Comparison.BETWEEN}); 
    68  
    69         var features = [ 
    70                 new OpenLayers.Feature.Vector(null, { 
    71                         area: 999}), 
    72                 new OpenLayers.Feature.Vector(null, { 
    73                         area: 1000}), 
    74                 new OpenLayers.Feature.Vector(null, { 
    75                         area: 4999}), 
    76                 new OpenLayers.Feature.Vector(null, { 
    77                         area: 5000})]; 
    78         // PropertyIsBetween filter: lower and upper boundary are inclusive 
    79         var ruleResults = { 
    80                 0: false, 
    81                 1: true, 
    82                 2: true, 
    83                 3: false}; 
    84         for (var i in ruleResults) { 
    85             var result = rule.evaluate(features[i]); 
    86             t.eq(result, ruleResults[i], "feature "+i+ 
    87                     " evaluates to "+result.toString()+" correctly."); 
    88         } 
    89         rule.context = { 
    90             area: 4998 
    91         } 
    92         var result = rule.evaluate(); 
    93         t.eq(result, true, "evaluation against custom rule context works."); 
    94     } 
    95     </script>  
    96 </head>  
    97 <body>  
    98 </body>  
    99 </html>  

  • tests/Rule/Logical.html

    old new  
    1 <html>  
    2 <head>  
    3     <script src="../../lib/OpenLayers.js"></script>  
    4     <script type="text/javascript"> 
    5  
    6     function test_Logical_constructor(t) {  
    7         t.plan(3);  
    8           
    9         var options = {'foo': 'bar'};  
    10         var rule = new OpenLayers.Rule.Logical(options);  
    11         t.ok(rule instanceof OpenLayers.Rule.Logical,  
    12              "new OpenLayers.Rule.Logical returns object" );  
    13         t.eq(rule.foo, "bar", "constructor sets options correctly");  
    14         t.eq(typeof rule.evaluate, "function", "rule has an evaluate function");  
    15     } 
    16  
    17     function test_Logical_destroy(t) { 
    18         t.plan(1); 
    19          
    20         var rule = new OpenLayers.Rule.Logical(); 
    21         rule.destroy(); 
    22         t.eq(rule.rules, null, "rules array nulled properly"); 
    23     } 
    24      
    25     function test_Logical_evaluate(t) { 
    26         t.plan(1); 
    27          
    28         var rule = new OpenLayers.Rule.Logical({ 
    29                 type: OpenLayers.Rule.Logical.NOT}); 
    30         rule.rules.push(new OpenLayers.Rule()); 
    31          
    32         var feature = new OpenLayers.Feature.Vector(); 
    33  
    34         t.eq(rule.evaluate(feature), false, 
    35                 "feature evaluates to false correctly."); 
    36     } 
    37     </script>  
    38 </head>  
    39 <body>  
    40 </body>  
    41 </html>  

  • tests/Style.html

    old new  
    2727         
    2828        var style = new OpenLayers.Style(baseStyle); 
    2929         
    30         var rule1 = new OpenLayers.Rule.FeatureId({ 
    31                 fids: ["1"], 
    32                 symbolizer: {"Point": {fillColor: "green"}}, 
    33                 maxScaleDenominator: 500000}); 
    34         var rule2 = new OpenLayers.Rule.FeatureId({ 
    35                 fids: ["1"], 
    36                 symbolizer: {"Point": {fillColor: "yellow"}}, 
    37                 minScaleDenominator: 500000, 
    38                 maxScaleDenominator: 1000000}); 
    39         var rule3 = new OpenLayers.Rule.FeatureId({ 
    40                 fids: ["1"], 
    41                 symbolizer: {"Point": {fillColor: "red"}}, 
    42                 minScaleDenominator: 1000000, 
    43                 maxScaleDenominator: 2500000}); 
     30        var rule1 = new OpenLayers.Rule({ 
     31            symbolizer: {"Point": {fillColor: "green"}}, 
     32            maxScaleDenominator: 500000, 
     33            filter: new OpenLayers.Filter.FeatureId({ 
     34                fids: ["1"] 
     35            }) 
     36        }); 
     37        var rule2 = new OpenLayers.Rule({ 
     38            symbolizer: {"Point": {fillColor: "yellow"}}, 
     39            minScaleDenominator: 500000, 
     40            maxScaleDenominator: 1000000, 
     41            filter: new OpenLayers.Filter.FeatureId({ 
     42                fids: ["1"] 
     43            }) 
     44        }); 
     45        var rule3 = new OpenLayers.Rule({ 
     46            symbolizer: {"Point": {fillColor: "red"}}, 
     47            minScaleDenominator: 1000000, 
     48            maxScaleDenominator: 2500000, 
     49            filter: new OpenLayers.Filter.FeatureId({ 
     50                fids: ["1"] 
     51            }) 
     52        }); 
    4453         
    4554        var feature = new OpenLayers.Feature.Vector( 
    4655                new OpenLayers.Geometry.Point(3,5), 
    …… 
    119128     
    120129    function test_Style_context(t) { 
    121130        t.plan(1); 
    122         var rule = new OpenLayers.Rule.Comparison({ 
    123             type: OpenLayers.Rule.Comparison.LESS_THAN, 
    124             property: "size", 
    125             value: 11, 
    126             symbolizer: {"Point": {externalGraphic: "${img1}"}}}); 
     131        var rule = new OpenLayers.Rule({ 
     132            symbolizer: {"Point": {externalGraphic: "${img1}"}}, 
     133            filter: new OpenLayers.Filter.Comparison({ 
     134                type: OpenLayers.Filter.Comparison.LESS_THAN, 
     135                property: "size", 
     136                value: 11 
     137            }) 
     138        }); 
    127139        var style = new OpenLayers.Style(); 
    128140        style.context = { 
    129141            "img1": "myImage.png" 

  • tests/list-tests.html

    old new  
    2929    <li>Format/OSM.html</li> 
    3030    <li>Format/KML.html</li> 
    3131    <li>Format/SLD.html</li> 
     32    <li>Format/SLD/v1_0_0.html</li> 
    3233    <li>Format/WKT.html</li> 
    3334    <li>Format/WMC.html</li> 
    3435    <li>Format/WMC/v1_1_0.html</li> 
    …… 
    4647    <li>Style.html</li> 
    4748    <li>StyleMap.html</li> 
    4849    <li>Rule.html</li> 
    49     <li>Rule/Comparison.html</li> 
    50     <li>Rule/FeatureId.html</li> 
    51     <li>Rule/Logical.html</li> 
     50    <li>Filter.html</li> 
     51    <li>Filter/Comparison.html</li> 
     52    <li>Filter/FeatureId.html</li> 
     53    <li>Filter/Logical.html</li> 
    5254    <li>Events.html</li> 
    5355    <li>Util.html</li> 
    5456    <li>Lang.html</li> 

  • lib/OpenLayers/Filter/FeatureId.js

    old new  
     1/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD 
     2 * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the 
     3  * full text of the license. */ 
     4 
     5 
     6/** 
     7 * @requires OpenLayers/Filter.js 
     8 */ 
     9 
     10/** 
     11 * Class: OpenLayers.Filter.FeatureId 
     12 * This class represents a ogc:FeatureId Filter, as being used for rule-based SLD 
     13 * styling 
     14 *  
     15 * Inherits from 
     16 * - <OpenLayers.Filter> 
     17 */ 
     18OpenLayers.Filter.FeatureId = OpenLayers.Class(OpenLayers.Filter, { 
     19 
     20    /**  
     21     * APIProperty: fids 
     22     * {Array(<String>)} Feature Ids to evaluate this rule against. To be passed 
     23     * To be passed inside the params object. 
     24     */ 
     25    fids: null, 
     26     
     27    /**  
     28     * Constructor: OpenLayers.Filter.FeatureId 
     29     * Creates an ogc:FeatureId rule. 
     30     * 
     31     * Parameters: 
     32     * options - {Object} An optional object with properties to set on the 
     33     *           rule 
     34     *  
     35     * Returns: 
     36     * {<OpenLayers.Filter.FeatureId>} 
     37     */ 
     38    initialize: function(options) { 
     39        this.fids = []; 
     40        OpenLayers.Filter.prototype.initialize.apply(this, [options]); 
     41    }, 
     42 
     43    /** 
     44     * APIMethod: evaluate 
     45     * evaluates this rule for a specific feature 
     46     *  
     47     * Parameters: 
     48     * feature - {<OpenLayers.Feature>} feature to apply the rule to. 
     49     *           For vector features, the check is run against the fid, 
     50     *           for plain features against the id. 
     51     *  
     52     * Returns: 
     53     * {boolean} true if the rule applies, false if it does not 
     54     */ 
     55    evaluate: function(feature) { 
     56        for (var i=0; i<this.fids.length; i++) { 
     57            var fid = feature.fid || feature.id; 
     58            if (fid == this.fids[i]) { 
     59                return true; 
     60            } 
     61        } 
     62        return false; 
     63    }, 
     64     
     65    CLASS_NAME: "OpenLayers.Filter.FeatureId" 
     66}); 

  • lib/OpenLayers/Filter/Comparison.js

    old new  
     1/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD 
     2 * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the 
     3  * full text of the license. */ 
     4 
     5/** 
     6 * @requires OpenLayers/Filter.js 
     7 */ 
     8 
     9/** 
     10 * Class: OpenLayers.Filter.Comparison 
     11 * This class represents a comparison filter. 
     12 *  
     13 * Inherits from 
     14 * - <OpenLayers.Filter> 
     15 */ 
     16OpenLayers.Filter.Comparison = OpenLayers.Class(OpenLayers.Filter, { 
     17 
     18    /** 
     19     * APIProperty: type 
     20     * {String} type: type of the comparison. This is one of 
     21     * - OpenLayers.Filter.Comparison.EQUAL_TO                 = "=="; 
     22     * - OpenLayers.Filter.Comparison.NOT_EQUAL_TO             = "!="; 
     23     * - OpenLayers.Filter.Comparison.LESS_THAN                = "<"; 
     24     * - OpenLayers.Filter.Comparison.GREATER_THAN             = ">"; 
     25     * - OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO    = "<="; 
     26     * - OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">="; 
     27     * - OpenLayers.Filter.Comparison.BETWEEN                  = ".."; 
     28     * - OpenLayers.Filter.Comparison.LIKE                     = "~";  
     29     */ 
     30    type: null, 
     31     
     32    /** 
     33     * APIProperty: property 
     34     * {String} 
     35     * name of the context property to compare 
     36     */ 
     37    property: null, 
     38     
     39    /** 
     40     * APIProperty: value 
     41     * {Number} or {String} 
     42     * comparison value for binary comparisons. In the case of a String, this 
     43     * can be a combination of text and propertyNames in the form 
     44     * "literal ${propertyName}" 
     45     */ 
     46    value: null, 
     47     
     48    /** 
     49     * APIProperty: lowerBoundary 
     50     * {Number} or {String} 
     51     * lower boundary for between comparisons. In the case of a String, this 
     52     * can be a combination of text and propertyNames in the form 
     53     * "literal ${propertyName}" 
     54     */ 
     55    lowerBoundary: null, 
     56     
     57    /** 
     58     * APIProperty: upperBoundary 
     59     * {Number} or {String} 
     60     * upper boundary for between comparisons. In the case of a String, this 
     61     * can be a combination of text and propertyNames in the form 
     62     * "literal ${propertyName}" 
     63     */ 
     64    upperBoundary: null, 
     65 
     66    /**  
     67     * Constructor: OpenLayers.Filter.Comparison 
     68     * Creates a comparison rule. 
     69     * 
     70     * Parameters: 
     71     * params  - {Object} Hash of parameters for this rule: 
     72     *              -  
     73     *              - value:  
     74     * options - {Object} An optional object with properties to set on the 
     75     *           rule 
     76     *  
     77     * Returns: 
     78     * {<OpenLayers.Filter.Comparison>} 
     79     */ 
     80    initialize: function(options) { 
     81        OpenLayers.Filter.prototype.initialize.apply(this, [options]); 
     82    }, 
     83 
     84    /** 
     85     * APIMethod: evaluate 
     86     * Evaluates this filter in a specific context.  Should be implemented by 
     87     *     subclasses. 
     88     *  
     89     * Parameters: 
     90     * context - {Object} Context to use in evaluating the filter. 
     91     *  
     92     * Returns: 
     93     * {Boolean} The filter applies. 
     94     */ 
     95    evaluate: function(context) { 
     96        switch(this.type) { 
     97            case OpenLayers.Filter.Comparison.EQUAL_TO: 
     98            case OpenLayers.Filter.Comparison.LESS_THAN: 
     99            case OpenLayers.Filter.Comparison.GREATER_THAN: 
     100            case OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO: 
     101            case OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO: 
     102                return this.binaryCompare(context, this.property, this.value); 
     103             
     104            case OpenLayers.Filter.Comparison.BETWEEN: 
     105                var result = 
     106                        context[this.property] >= this.lowerBoundary; 
     107                result = result && 
     108                        context[this.property] <= this.upperBoundary; 
     109                return result; 
     110            case OpenLayers.Filter.Comparison.LIKE: 
     111                var regexp = new RegExp(this.value, 
     112                                "gi"); 
     113                return regexp.test(context[this.property]);  
     114        } 
     115    }, 
     116     
     117    /** 
     118     * APIMethod: value2regex 
     119     * Converts the value of this rule into a regular expression string, 
     120     * according to the wildcard characters specified. This method has to 
     121     * be called after instantiation of this class, if the value is not a 
     122     * regular expression already. 
     123     *  
     124     * Parameters: 
     125     * wildCard   - {<Char>} wildcard character in the above value, default 
     126     *              is "*" 
     127     * singleChar - {<Char>) single-character wildcard in the above value 
     128     *              default is "." 
     129     * escape     - {<Char>) escape character in the above value, default is 
     130     *              "!" 
     131     *  
     132     * Returns: 
     133     * {String} regular expression string 
     134     */ 
     135    value2regex: function(wildCard, singleChar, escapeChar) { 
     136        if (wildCard == ".") { 
     137            var msg = "'.' is an unsupported wildCard character for "+ 
     138                    "OpenLayers.Filter.Comparison"; 
     139            OpenLayers.Console.error(msg); 
     140            return null; 
     141        } 
     142         
     143        // set UMN MapServer defaults for unspecified parameters 
     144        wildCard = wildCard ? wildCard : "*"; 
     145        singleChar = singleChar ? singleChar : "."; 
     146        escapeChar = escapeChar ? escapeChar : "!"; 
     147         
     148        this.value = this.value.replace( 
     149                new RegExp("\\"+escapeChar, "g"), "\\"); 
     150        this.value = this.value.replace( 
     151                new RegExp("\\"+singleChar, "g"), "."); 
     152        this.value = this.value.replace( 
     153                new RegExp("\\"+wildCard, "g"), ".*"); 
     154        this.value = this.value.replace( 
     155                new RegExp("\\\\.\\*", "g"), "\\"+wildCard); 
     156        this.value = this.value.replace( 
     157                new RegExp("\\\\\\.", "g"), "\\"+singleChar); 
     158         
     159        return this.value; 
     160    }, 
     161     
     162    /** 
     163     * Method: regex2value 
     164     * Convert the value of this rule from a regular expression string into an 
     165     *     ogc literal string using a wildCard of *, a singleChar of ., and an 
     166     *     escape of !.  Leaves the <value> property unmodified. 
     167     *  
     168     * Returns: 
     169     * {String} A string value. 
     170     */ 
     171    regex2value: function() { 
     172         
     173        var value = this.value; 
     174         
     175        // replace ! with !! 
     176        value = value.replace(/!/g, "!!"); 
     177 
     178        // replace \. with !. (watching out for \\.) 
     179        value = value.replace(/(\\)?\\\./g, function($0, $1) { 
     180            return $1 ? $0 : "!."; 
     181        }); 
     182         
     183        // replace \* with #* (watching out for \\*) 
     184        value = value.replace(/(\\)?\\\*/g, function($0, $1) { 
     185            return $1 ? $0 : "!*"; 
     186        }); 
     187         
     188        // replace \\ with \ 
     189        value = value.replace(/\\\\/g, "\\"); 
     190 
     191        // convert .* to * (the sequence #.* is not allowed) 
     192        value = value.replace(/\.\*/g, "*"); 
     193         
     194        return value; 
     195    }, 
     196 
     197    /** 
     198     * Function: binaryCompare 
     199     * Compares a feature property to a rule value 
     200     *  
     201     * Parameters: 
     202     * context  - {Object} 
     203     * property - {String} or {Number} 
     204     * value    - {String} or {Number}, same as property 
     205     *  
     206     * Returns: 
     207     * {boolean} 
     208     */ 
     209    binaryCompare: function(context, property, value) { 
     210        switch (this.type) { 
     211            case OpenLayers.Filter.Comparison.EQUAL_TO: 
     212                return context[property] == value; 
     213            case OpenLayers.Filter.Comparison.NOT_EQUAL_TO: 
     214&n