With dramatic flourish, I'm modifying 21 files with 1033 insertions and 815 deletions between release candidates. This moves all rule subclasses to a more natural home as filter subclasses. Also adds tests for SLD write and corrects a handful of issues there. Apologies to all who lose sleep over this sort of thing. r=ahocevar,crschmidt (closes #1492)

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

examples/georss-flickr.html

@@ -31,28 +31,34 @@
             // the thumbail attribute of the rss item
             style = new OpenLayers.Style({externalGraphic: "${thumbnail}"});
             
-            // make the thumbnails larger when we select them
-            selectStyle = new OpenLayers.Style({pointRadius: 35});
-            
             // create a rule with a point symbolizer that will make the thumbnail
             // larger if the title of the rss item conatins "powder"
-            var rule = new OpenLayers.Rule.Comparison({
+            var rule = new OpenLayers.Rule({
-                    type: OpenLayers.Rule.Comparison.LIKE,
+                symbolizer: {pointRadius: 30},
+                filter: new OpenLayers.Filter.Comparison({
+                    type: OpenLayers.Filter.Comparison.LIKE,
                     property: "title",
-                    value: "*powder*",
+                    value: "*powder*"
-                    symbolizer: {"Point": {pointRadius: 30}}});
+                })
-            rule.value2regex("*");
+            });
+            rule.filter.value2regex("*");
             
             // If the above rule does not apply, use a smaller pointRadius.
             var elseRule = new OpenLayers.Rule({
-                    elseFilter: true,
+                elseFilter: true,
-                    symbolizer: {"Point": {pointRadius: 20}}});
+                symbolizer: {pointRadius: 20}
+            });
             
             style.addRules([rule, elseRule]);
             
-            markerLayer = new OpenLayers.Layer.Vector("", {styleMap: new OpenLayers.StyleMap({
+            // Create a layer with a style map.  Giving the style map keys
-                "default": style,
+            // for "default" and "select" rendering intent.
-                "select": selectStyle})});
+            markerLayer = new OpenLayers.Layer.Vector("", {
+                styleMap: new OpenLayers.StyleMap({
+                    "default": style,
+                    "select": new OpenLayers.Style({pointRadius: 35})
+                })
+            });
             map.addLayer(markerLayer);
             
             // control that will show a popup when clicking on a thumbnail

lib/OpenLayers.js

@@ -183,9 +183,10 @@
             "OpenLayers/Style.js",
             "OpenLayers/StyleMap.js",
             "OpenLayers/Rule.js",
-            "OpenLayers/Rule/FeatureId.js",
+            "OpenLayers/Filter.js",
-            "OpenLayers/Rule/Logical.js",
+            "OpenLayers/Filter/FeatureId.js",
-            "OpenLayers/Rule/Comparison.js",
+            "OpenLayers/Filter/Logical.js",
+            "OpenLayers/Filter/Comparison.js",
             "OpenLayers/Format.js",
             "OpenLayers/Format/XML.js",
             "OpenLayers/Format/GML.js",

lib/OpenLayers/Filter.js

@@ -0,0 +1,55 @@
+/* Copyright (c) 2006 MetaCarta, Inc., published under a modified BSD license.
+ * See http://svn.openlayers.org/trunk/openlayers/repository-license.txt 
+ * for the full text of the license. */
+
+
+/**
+ * @requires OpenLayers/Util.js
+ * @requires OpenLayers/Style.js
+ */
+
+/**
+ * Class: OpenLayers.Filter
+ * This class represents an OGC Filter.
+ */
+OpenLayers.Filter = OpenLayers.Class({
+    
+    /** 
+     * Constructor: OpenLayers.Filter
+     * This is an abstract class.  Create an instance of a filter subclass.
+     *
+     * Parameters:
+     * options - {Object} Optional object whose properties will be set on the
+     *     instance.
+     * 
+     * Returns:
+     * {<OpenLayers.Filter>}
+     */
+    initialize: function(options) {
+        OpenLayers.Util.extend(this, options);
+    },
+
+    /** 
+     * APIMethod: destroy
+     * Remove reference to anything added.
+     */
+    destroy: function() {
+    },
+
+    /**
+     * APIMethod: evaluate
+     * Evaluates this filter in a specific context.  Should be implemented by
+     *     subclasses.
+     * 
+     * Parameters:
+     * context - {Object} Context to use in evaluating the filter.
+     * 
+     * Returns:
+     * {Boolean} The filter applies.
+     */
+    evaluate: function(context) {
+        return true;
+    },
+    
+    CLASS_NAME: "OpenLayers.Filter"
+});

lib/OpenLayers/Filter/Comparison.js

@@ -3,30 +3,29 @@
   * full text of the license. */
 
 /**
- * @requires OpenLayers/Rule.js
+ * @requires OpenLayers/Filter.js
  */
 
 /**
- * Class: OpenLayers.Rule.Comparison
+ * Class: OpenLayers.Filter.Comparison
- * This class represents the comparison rules, as being used for rule-based 
+ * This class represents a comparison filter.
- * SLD styling
  * 
  * Inherits from
- * - <OpenLayers.Rule>
+ * - <OpenLayers.Filter>
  */
-OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
+OpenLayers.Filter.Comparison = OpenLayers.Class(OpenLayers.Filter, {
 
     /**
      * APIProperty: type
      * {String} type: type of the comparison. This is one of
-     * - OpenLayers.Rule.Comparison.EQUAL_TO                 = "==";
+     * - OpenLayers.Filter.Comparison.EQUAL_TO                 = "==";
-     * - OpenLayers.Rule.Comparison.NOT_EQUAL_TO             = "!=";
+     * - OpenLayers.Filter.Comparison.NOT_EQUAL_TO             = "!=";
-     * - OpenLayers.Rule.Comparison.LESS_THAN                = "<";
+     * - OpenLayers.Filter.Comparison.LESS_THAN                = "<";
-     * - OpenLayers.Rule.Comparison.GREATER_THAN             = ">";
+     * - OpenLayers.Filter.Comparison.GREATER_THAN             = ">";
-     * - OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO    = "<=";
+     * - OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO    = "<=";
-     * - OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
+     * - OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
-     * - OpenLayers.Rule.Comparison.BETWEEN                  = "..";
+     * - OpenLayers.Filter.Comparison.BETWEEN                  = "..";
-     * - OpenLayers.Rule.Comparison.LIKE                     = "~"; 
+     * - OpenLayers.Filter.Comparison.LIKE                     = "~"; 
      */
     type: null,
     
@@ -65,7 +64,7 @@ OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
     upperBoundary: null,
 
     /** 
-     * Constructor: OpenLayers.Rule.Comparison
+     * Constructor: OpenLayers.Filter.Comparison
      * Creates a comparison rule.
      *
      * Parameters:
@@ -76,42 +75,39 @@ OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
      *           rule
      * 
      * Returns:
-     * {<OpenLayers.Rule.Comparison>}
+     * {<OpenLayers.Filter.Comparison>}
      */
     initialize: function(options) {
-        OpenLayers.Rule.prototype.initialize.apply(this, [options]);
+        OpenLayers.Filter.prototype.initialize.apply(this, [options]);
     },
 
     /**
      * APIMethod: evaluate
-     * evaluates this rule for a specific context
+     * Evaluates this filter in a specific context.  Should be implemented by
+     *     subclasses.
      * 
      * Parameters:
-     * context - {Object} context to apply the rule to.
+     * context - {Object} Context to use in evaluating the filter.
      * 
      * Returns:
-     * {boolean} true if the rule applies, false if it does not
+     * {Boolean} The filter applies.
      */
-    evaluate: function(feature) {
+    evaluate: function(context) {
-        if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) {
-            return false;
-        }
-        var context = this.getContext(feature);
         switch(this.type) {
-            case OpenLayers.Rule.Comparison.EQUAL_TO:
+            case OpenLayers.Filter.Comparison.EQUAL_TO:
-            case OpenLayers.Rule.Comparison.LESS_THAN:
+            case OpenLayers.Filter.Comparison.LESS_THAN:
-            case OpenLayers.Rule.Comparison.GREATER_THAN:
+            case OpenLayers.Filter.Comparison.GREATER_THAN:
-            case OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO:
+            case OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO:
-            case OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO:
+            case OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO:
                 return this.binaryCompare(context, this.property, this.value);
             
-            case OpenLayers.Rule.Comparison.BETWEEN:
+            case OpenLayers.Filter.Comparison.BETWEEN:
                 var result =
                         context[this.property] >= this.lowerBoundary;
                 result = result &&
                         context[this.property] <= this.upperBoundary;
                 return result;
-            case OpenLayers.Rule.Comparison.LIKE:
+            case OpenLayers.Filter.Comparison.LIKE:
                 var regexp = new RegExp(this.value,
                                 "gi");
                 return regexp.test(context[this.property]); 
@@ -139,7 +135,7 @@ OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
     value2regex: function(wildCard, singleChar, escapeChar) {
         if (wildCard == ".") {
             var msg = "'.' is an unsupported wildCard character for "+
-                    "OpenLayers.Rule.Comparison";
+                    "OpenLayers.Filter.Comparison";
             OpenLayers.Console.error(msg);
             return null;
         }
@@ -212,30 +208,30 @@ OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
      */
     binaryCompare: function(context, property, value) {
         switch (this.type) {
-            case OpenLayers.Rule.Comparison.EQUAL_TO:
+            case OpenLayers.Filter.Comparison.EQUAL_TO:
                 return context[property] == value;
-            case OpenLayers.Rule.Comparison.NOT_EQUAL_TO:
+            case OpenLayers.Filter.Comparison.NOT_EQUAL_TO:
                 return context[property] != value;
-            case OpenLayers.Rule.Comparison.LESS_THAN:
+            case OpenLayers.Filter.Comparison.LESS_THAN:
                 return context[property] < value;
-            case OpenLayers.Rule.Comparison.GREATER_THAN:
+            case OpenLayers.Filter.Comparison.GREATER_THAN:
                 return context[property] > value;
-            case OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO:
+            case OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO:
                 return context[property] <= value;
-            case OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO:
+            case OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO:
                 return context[property] >= value;
         }      
     },
     
-    CLASS_NAME: "OpenLayers.Rule.Comparison"
+    CLASS_NAME: "OpenLayers.Filter.Comparison"
 });
 
 
-OpenLayers.Rule.Comparison.EQUAL_TO                 = "==";
+OpenLayers.Filter.Comparison.EQUAL_TO                 = "==";
-OpenLayers.Rule.Comparison.NOT_EQUAL_TO             = "!=";
+OpenLayers.Filter.Comparison.NOT_EQUAL_TO             = "!=";
-OpenLayers.Rule.Comparison.LESS_THAN                = "<";
+OpenLayers.Filter.Comparison.LESS_THAN                = "<";
-OpenLayers.Rule.Comparison.GREATER_THAN             = ">";
+OpenLayers.Filter.Comparison.GREATER_THAN             = ">";
-OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO    = "<=";
+OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO    = "<=";
-OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
+OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
-OpenLayers.Rule.Comparison.BETWEEN                  = "..";
+OpenLayers.Filter.Comparison.BETWEEN                  = "..";
-OpenLayers.Rule.Comparison.LIKE                     = "~";
+OpenLayers.Filter.Comparison.LIKE                     = "~";

lib/OpenLayers/Filter/FeatureId.js

@@ -4,18 +4,18 @@
 
 
 /**
- * @requires OpenLayers/Rule.js
+ * @requires OpenLayers/Filter.js
  */
 
 /**
- * Class: OpenLayers.Rule.FeatureId
+ * Class: OpenLayers.Filter.FeatureId
- * This class represents a ogc:FeatureId Rule, as being used for rule-based SLD
+ * This class represents a ogc:FeatureId Filter, as being used for rule-based SLD
  * styling
  * 
  * Inherits from
- * - <OpenLayers.Rule>
+ * - <OpenLayers.Filter>
  */
-OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
+OpenLayers.Filter.FeatureId = OpenLayers.Class(OpenLayers.Filter, {
 
     /** 
      * APIProperty: fids
@@ -25,7 +25,7 @@ OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
     fids: null,
     
     /** 
-     * Constructor: OpenLayers.Rule.FeatureId
+     * Constructor: OpenLayers.Filter.FeatureId
      * Creates an ogc:FeatureId rule.
      *
      * Parameters:
@@ -33,11 +33,11 @@ OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
      *           rule
      * 
      * Returns:
-     * {<OpenLayers.Rule.FeatureId>}
+     * {<OpenLayers.Filter.FeatureId>}
      */
     initialize: function(options) {
         this.fids = [];
-        OpenLayers.Rule.prototype.initialize.apply(this, [options]);
+        OpenLayers.Filter.prototype.initialize.apply(this, [options]);
     },
 
     /**
@@ -53,9 +53,6 @@ OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
      * {boolean} true if the rule applies, false if it does not
      */
     evaluate: function(feature) {
-        if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) {
-            return false;
-        }
         for (var i=0; i<this.fids.length; i++) {
             var fid = feature.fid || feature.id;
             if (fid == this.fids[i]) {
@@ -65,5 +62,5 @@ OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
         return false;
     },
     
-    CLASS_NAME: "OpenLayers.Rule.FeatureId"
+    CLASS_NAME: "OpenLayers.Filter.FeatureId"
 });

lib/OpenLayers/Filter/Logical.js

@@ -0,0 +1,99 @@
+/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
+ * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+  * full text of the license. */
+
+
+/**
+ * @requires OpenLayers/Filter.js
+ */
+
+/**
+ * Class: OpenLayers.Filter.Logical
+ * This class represents ogc:And, ogc:Or and ogc:Not rules.
+ * 
+ * Inherits from
+ * - <OpenLayers.Filter>
+ */
+OpenLayers.Filter.Logical = OpenLayers.Class(OpenLayers.Filter, {
+
+    /**
+     * APIProperty: filters
+     * {Array(<OpenLayers.Filter>)} Child filters for this filter.
+     */
+    filters: null, 
+     
+    /**
+     * APIProperty: type
+     * {String} type of logical operator. Available types are:
+     * - OpenLayers.Filter.Locical.AND = "&&";
+     * - OpenLayers.Filter.Logical.OR  = "||";
+     * - OpenLayers.Filter.Logical.NOT = "!";
+     */
+    type: null,
+
+    /** 
+     * Constructor: OpenLayers.Filter.Logical
+     * Creates a logical filter (And, Or, Not).
+     *
+     * Parameters:
+     * options - {Object} An optional object with properties to set on the
+     *     filter.
+     * 
+     * Returns:
+     * {<OpenLayers.Filter.Logical>}
+     */
+    initialize: function(options) {
+        this.filters = [];
+        OpenLayers.Filter.prototype.initialize.apply(this, [options]);
+    },
+    
+    /** 
+     * APIMethod: destroy
+     * Remove reference to child filters.
+     */
+    destroy: function() {
+        this.filters = null;
+        OpenLayers.Filter.prototype.destroy.apply(this);
+    },
+
+    /**
+     * APIMethod: evaluate
+     * Evaluates this filter in a specific context.  Should be implemented by
+     *     subclasses.
+     * 
+     * Parameters:
+     * context - {Object} Context to use in evaluating the filter.
+     * 
+     * Returns:
+     * {Boolean} The filter applies.
+     */
+    evaluate: function(context) {
+        switch(this.type) {
+            case OpenLayers.Filter.Logical.AND:
+                for (var i=0; i<this.filters.length; i++) {
+                    if (this.filters[i].evaluate(context) == false) {
+                        return false;
+                    }
+                }
+                return true;
+                
+            case OpenLayers.Filter.Logical.OR:
+                for (var i=0; i<this.filters.length; i++) {
+                    if (this.filters[i].evaluate(context) == true) {
+                        return true;
+                    }
+                }
+                return false;
+            
+            case OpenLayers.Filter.Logical.NOT:
+                return (!this.filters[0].evaluate(context));
+        }
+    },
+    
+    CLASS_NAME: "OpenLayers.Filter.Logical"
+});
+
+
+OpenLayers.Filter.Logical.AND = "&&";
+OpenLayers.Filter.Logical.OR  = "||";
+OpenLayers.Filter.Logical.NOT = "!";

lib/OpenLayers/Format/SLD/v1.js

@@ -142,24 +142,8 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
                 style.rules = obj.rules;
             },
             "Rule": function(node, obj) {
-                // Rule elements are represented as OpenLayers.Rule instances.
+                var rule = new OpenLayers.Rule();
-                // Filter elements are represented as instances of
+                this.readChildNodes(node, rule);
-                // OpenLayers.Rule subclasses.
-                var config = {
-                    rules: [],
-                    symbolizer: {}
-                };
-                this.readChildNodes(node, config);
-                // Now we've either got zero or one rules (from filters)
-                var rule;
-                if(config.rules.length == 0) {
-                    delete config.rules;
-                    rule = new OpenLayers.Rule(config);
-                } else {
-                    rule = config.rules[0];
-                    delete config.rules;
-                    OpenLayers.Util.extend(rule, config);
-                }
                 obj.rules.push(rule);
             },
             "ElseFilter": function(node, rule) {
@@ -283,146 +267,121 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
         },
         "ogc": {
             "Filter": function(node, rule) {
-                // Filters correspond to subclasses of OpenLayers.Rule.
+                // Filters correspond to subclasses of OpenLayers.Filter.
                 // Since they contain information we don't persist, we
-                // create a temporary object and then pass on the rules
+                // create a temporary object and then pass on the filter
                 // (ogc:Filter) to the parent rule (sld:Rule).
-                var filter = {
+                var obj = {
                     fids: [],
-                    rules: []
+                    filters: []
                 };
-                this.readChildNodes(node, filter);
+                this.readChildNodes(node, obj);
-                if(filter.fids.length > 0) {
+                if(obj.fids.length > 0) {
-                    rule.rules.push(new OpenLayers.Rule.FeatureId({
+                    rule.filter = new OpenLayers.Filter.FeatureId({
-                        fids: filter.fids
+                        fids: obj.fids
-                    }));
+                    });
-                }
+                } else if(obj.filters.length > 0) {
-                if(filter.rules.length > 0) {
+                    rule.filter = obj.filters[0];
-                    rule.rules = rule.rules.concat(filter.rules);
                 }
             },
-            "FeatureId": function(node, filter) {
+            "FeatureId": function(node, obj) {
                 var fid = node.getAttribute("fid");
                 if(fid) {
-                    filter.fids.push(fid);
+                    obj.fids.push(fid);
                 }
             },
-            "And": function(node, filter) {
+            "And": function(node, obj) {
-                var rule = new OpenLayers.Rule.Logical({
+                var filter = new OpenLayers.Filter.Logical({
-                    type: OpenLayers.Rule.Logical.AND
+                    type: OpenLayers.Filter.Logical.AND
                 });
-                // since FeatureId rules may be nested here, make room for them
+                this.readChildNodes(node, filter);
-                rule.fids = [];
+                obj.filters.push(filter);
-                this.readChildNodes(node, rule);
-                if(rule.fids.length > 0) {
-                    rule.rules.push(new OpenLayers.Rule.FeatureId({
-                        fids: rule.fids
-                    }));
-                }
-                delete rule.fids;
-                filter.rules.push(rule);
             },
-            "Or": function(node, filter) {
+            "Or": function(node, obj) {
-                var rule = new OpenLayers.Rule.Logical({
+                var filter = new OpenLayers.Filter.Logical({
-                    type: OpenLayers.Rule.Logical.OR
+                    type: OpenLayers.Filter.Logical.OR
                 });
-                // since FeatureId rules may be nested here, make room for them
+                this.readChildNodes(node, filter);
-                rule.fids = [];
+                obj.filters.push(filter);
-                this.readChildNodes(node, rule);
-                if(rule.fids.length > 0) {
-                    rule.rules.push(new OpenLayers.Rule.FeatureId({
-                        fids: rule.fids
-                    }));
-                }
-                delete rule.fids;
-                filter.rules.push(rule);
             },
-            "Not": function(node, filter) {
+            "Not": function(node, obj) {
-                var rule = new OpenLayers.Rule.Logical({
+                var filter = new OpenLayers.Filter.Logical({
-                    type: OpenLayers.Rule.Logical.NOT
+                    type: OpenLayers.Filter.Logical.NOT
                 });
-                // since FeatureId rules may be nested here, make room for them
+                this.readChildNodes(node, filter);
-                rule.fids = [];
+                obj.filters.push(filter);
-                this.readChildNodes(node, rule);
-                if(rule.fids.length > 0) {
-                    rule.rules.push(new OpenLayers.Rule.FeatureId({
-                        fids: rule.fids
-                    }));
-                }
-                delete rule.fids;
-                filter.rules.push(rule);
             },
-            "PropertyIsEqualTo": function(node, filter) {
+            "PropertyIsEqualTo": function(node, obj) {
-                var rule = new OpenLayers.Rule.Comparison({
+                var filter = new OpenLayers.Filter.Comparison({
-                    type: OpenLayers.Rule.Comparison.EQUAL_TO
+                    type: OpenLayers.Filter.Comparison.EQUAL_TO
                 });
-                this.readChildNodes(node, rule);
+                this.readChildNodes(node, filter);
-                filter.rules.push(rule);
+                obj.filters.push(filter);
             },
-            "PropertyIsNotEqualTo": function(node, filter) {
+            "PropertyIsNotEqualTo": function(node, obj) {
-                var rule = new OpenLayers.Rule.Comparison({
+                var filter = new OpenLayers.Filter.Comparison({
-                    type: OpenLayers.Rule.Comparison.NOT_EQUAL_TO
+                    type: OpenLayers.Filter.Comparison.NOT_EQUAL_TO
                 });
-                this.readChildNodes(node, rule);
+                this.readChildNodes(node, filter);
-                filter.rules.push(rule);
+                obj.filters.push(filter);
             },
-            "PropertyIsLessThan": function(node, filter) {
+            "PropertyIsLessThan": function(node, obj) {
-                var rule = new OpenLayers.Rule.Comparison({
+                var filter = new OpenLayers.Filter.Comparison({
-                    type: OpenLayers.Rule.Comparison.LESS_THAN
+                    type: OpenLayers.Filter.Comparison.LESS_THAN
                 });
-                this.readChildNodes(node, rule);
+                this.readChildNodes(node, filter);
-                filter.rules.push(rule);
+                obj.filters.push(filter);
             },
-            "PropertyIsGreaterThan": function(node, filter) {
+            "PropertyIsGreaterThan": function(node, obj) {
-                var rule = new OpenLayers.Rule.Comparison({
+                var filter = new OpenLayers.Filter.Comparison({
-                    type: OpenLayers.Rule.Comparison.GREATER_THAN
+                    type: OpenLayers.Filter.Comparison.GREATER_THAN
                 });
-                this.readChildNodes(node, rule);
+                this.readChildNodes(node, filter);
-                filter.rules.push(rule);
+                obj.filters.push(filter);
             },
-            "PropertyIsLessThanOrEqualTo": function(node, filter) {
+            "PropertyIsLessThanOrEqualTo": function(node, obj) {
-                var rule = new OpenLayers.Rule.Comparison({
+                var filter = new OpenLayers.Filter.Comparison({
-                    type: OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO
+                    type: OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO
                 });
-                this.readChildNodes(node, rule);
+                this.readChildNodes(node, filter);
-                filter.rules.push(rule);
+                obj.filters.push(filter);
             },
-            "PropertyIsGreaterThanOrEqualTo": function(node, filter) {
+            "PropertyIsGreaterThanOrEqualTo": function(node, obj) {
-                var rule = new OpenLayers.Rule.Comparison({
+                var filter = new OpenLayers.Filter.Comparison({
-                    type: OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO
+                    type: OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO
                 });
-                this.readChildNodes(node, rule);
+                this.readChildNodes(node, filter);
-                filter.rules.push(rule);
+                obj.filters.push(filter);
             },
-            "PropertyIsBetween": function(node, filter) {
+            "PropertyIsBetween": function(node, obj) {
-                var rule = new OpenLayers.Rule.Comparison({
+                var filter = new OpenLayers.Filter.Comparison({
-                    type: OpenLayers.Rule.Comparison.BETWEEN
+                    type: OpenLayers.Filter.Comparison.BETWEEN
                 });
-                this.readChildNodes(node, rule);
+                this.readChildNodes(node, filter);
-                filter.rules.push(rule);
+                obj.filters.push(filter);
             },
-            "PropertyIsLike": function(node, filter) {
+            "PropertyIsLike": function(node, obj) {
-                var rule = new OpenLayers.Rule.Comparison({
+                var filter = new OpenLayers.Filter.Comparison({
-                    type: OpenLayers.Rule.Comparison.LIKE
+                    type: OpenLayers.Filter.Comparison.LIKE
                 });
-                this.readChildNodes(node, rule);
+                this.readChildNodes(node, filter);
                 var wildCard = node.getAttribute("wildCard");
                 var singleChar = node.getAttribute("singleChar");
                 var esc = node.getAttribute("escape");
-                rule.value2regex(wildCard, singleChar, esc);
+                filter.value2regex(wildCard, singleChar, esc);
-                filter.rules.push(rule);
+                obj.filters.push(filter);
             },
             "Literal": function(node, obj) {
                 obj.value = this.getChildValue(node);
             },
-            "PropertyName": function(node, rule) {
+            "PropertyName": function(node, filter) {
-                rule.property = this.getChildValue(node);
+                filter.property = this.getChildValue(node);
             },
-            "LowerBoundary": function(node, rule) {
+            "LowerBoundary": function(node, filter) {
-                rule.lowerBoundary = this.readOgcExpression(node);
+                filter.lowerBoundary = this.readOgcExpression(node);
             },
-            "UpperBoundary": function(node, rule) {
+            "UpperBoundary": function(node, filter) {
-                rule.upperBoundary = this.readOgcExpression(node);
+                filter.upperBoundary = this.readOgcExpression(node);
             }
         }
     },
@@ -682,8 +641,8 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
                 // add in optional filters
                 if(rule.elseFilter) {
                     this.writeNode(node, "ElseFilter");
-                } else if(rule.CLASS_NAME != "OpenLayers.Rule") {
+                } else if(rule.filter) {
-                    this.writeNode(node, "ogc:Filter", rule);
+                    this.writeNode(node, "ogc:Filter", rule.filter);
                 }
                 
                 // add in scale limits
@@ -867,15 +826,15 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
             }
         },
         "ogc": {
-            "Filter": function(rule) {
+            "Filter": function(filter) {
                 var node = this.createElementNSPlus("ogc:Filter");
-                var sub = rule.CLASS_NAME.split(".").pop();
+                var sub = filter.CLASS_NAME.split(".").pop();
                 if(sub == "FeatureId") {
-                    for(var i=0; i<rule.fids.length; ++i) {
+                    for(var i=0; i<filter.fids.length; ++i) {
-                        this.writeNode(node, "FeatureId", rule.fids[i]);
+                        this.writeNode(node, "FeatureId", filter.fids[i]);
                     }
                 } else {
-                    this.writeNode(node, this.getFilterType(rule), rule);
+                    this.writeNode(node, this.getFilterType(filter), filter);
                 }
                 return node;
             },
@@ -884,120 +843,120 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
                     attributes: {fid: fid}
                 });
             },
-            "And": function(rule) {
+            "And": function(filter) {
                 var node = this.createElementNSPlus("ogc:And");
-                var childRule;
+                var childFilter;
-                for(var i=0; i<rule.rules.length; ++i) {
+                for(var i=0; i<filter.filters.length; ++i) {
-                    childRule = rule.rules[i];
+                    childFilter = filter.filters[i];
                     this.writeNode(
-                        node, this.getFilterType(childRule), childRule
+                        node, this.getFilterType(childFilter), childFilter
                     );
                 }
                 return node;
             },
-            "Or": function(rule) {
+            "Or": function(filter) {
                 var node = this.createElementNSPlus("ogc:Or");
-                var childRule;
+                var childFilter;
-                for(var i=0; i<rule.rules.length; ++i) {
+                for(var i=0; i<filter.filters.length; ++i) {
-                    childRule = rule.rules[i];
+                    childFilter = filter.filters[i];
                     this.writeNode(
-                        node, this.getFilterType(childRule), childRule
+                        node, this.getFilterType(childFilter), childFilter
                     );
                 }
                 return node;
             },
-            "Not": function(rule) {
+            "Not": function(filter) {
                 var node = this.createElementNSPlus("ogc:Not");
-                var childRule = rule.rules[0];
+                var childFilter = filter.filters[0];
                 this.writeNode(
-                    node, this.getFilterType(childRule), childRule
+                    node, this.getFilterType(childFilter), childFilter
                 );
                 return node;
             },
-            "PropertyIsEqualTo": function(rule) {
+            "PropertyIsEqualTo": function(filter) {
                 var node = this.createElementNSPlus("ogc:PropertyIsEqualTo");
                 // no ogc:expression handling for now
-                this.writeNode(node, "PropertyName", rule);
+                this.writeNode(node, "PropertyName", filter);
-                this.writeNode(node, "Literal", rule);
+                this.writeNode(node, "Literal", filter.value);
                 return node;
             },
-            "PropertyIsNotEqualTo": function(rule) {
+            "PropertyIsNotEqualTo": function(filter) {
                 var node = this.createElementNSPlus("ogc:PropertyIsNotEqualTo");
                 // no ogc:expression handling for now
-                this.writeNode(node, "PropertyName", rule);
+                this.writeNode(node, "PropertyName", filter);
-                this.writeNode(node, "Literal", rule);
+                this.writeNode(node, "Literal", filter.value);
                 return node;
             },
-            "PropertyIsLessThan": function(rule) {
+            "PropertyIsLessThan": function(filter) {
                 var node = this.createElementNSPlus("ogc:PropertyIsLessThan");
                 // no ogc:expression handling for now
-                this.writeNode(node, "PropertyName", rule);
+                this.writeNode(node, "PropertyName", filter);
-                this.writeNode(node, "Literal", rule);                
+                this.writeNode(node, "Literal", filter.value);                
                 return node;
             },
-            "PropertyIsGreaterThan": function(rule) {
+            "PropertyIsGreaterThan": function(filter) {
                 var node = this.createElementNSPlus("ogc:PropertyIsGreaterThan");
                 // no ogc:expression handling for now
-                this.writeNode(node, "PropertyName", rule);
+                this.writeNode(node, "PropertyName", filter);
-                this.writeNode(node, "Literal", rule);
+                this.writeNode(node, "Literal", filter.value);
                 return node;
             },
-            "PropertyIsLessThanOrEqualTo": function(rule) {
+            "PropertyIsLessThanOrEqualTo": function(filter) {
                 var node = this.createElementNSPlus("ogc:PropertyIsLessThanOrEqualTo");
                 // no ogc:expression handling for now
-                this.writeNode(node, "PropertyName", rule);
+                this.writeNode(node, "PropertyName", filter);
-                this.writeNode(node, "Literal", rule);
+                this.writeNode(node, "Literal", filter.value);
                 return node;
             },
-            "PropertyIsGreaterThanOrEqualTo": function(rule) {
+            "PropertyIsGreaterThanOrEqualTo": function(filter) {
                 var node = this.createElementNSPlus("ogc:PropertyIsGreaterThanOrEqualTo");
                 // no ogc:expression handling for now
-                this.writeNode(node, "PropertyName", rule);
+                this.writeNode(node, "PropertyName", filter);
-                this.writeNode(node, "Literal", rule);
+                this.writeNode(node, "Literal", filter.value);
                 return node;
             },
-            "PropertyIsBetween": function(rule) {
+            "PropertyIsBetween": function(filter) {
                 var node = this.createElementNSPlus("ogc:PropertyIsBetween");
                 // no ogc:expression handling for now
-                this.writeNode(node, "PropertyName", rule);
+                this.writeNode(node, "PropertyName", filter);
-                this.writeNode(node, "LowerBoundary", rule);
+                this.writeNode(node, "LowerBoundary", filter);
-                this.writeNode(node, "UpperBoundary", rule);
+                this.writeNode(node, "UpperBoundary", filter);
                 return node;
             },
-            "PropertyIsLike": function(rule) {
+            "PropertyIsLike": function(filter) {
                 var node = this.createElementNSPlus("ogc:PropertyIsLike", {
                     attributes: {
                         wildCard: "*", singleChar: ".", escape: "!"
                     }
                 });
                 // no ogc:expression handling for now
-                this.writeNode(node, "PropertyName", rule);
+                this.writeNode(node, "PropertyName", filter);
                 // convert regex string to ogc string
-                this.writeNode(node, "Literal", {value: rule.regex2value()});
+                this.writeNode(node, "Literal", filter.regex2value());
                 return node;
             },
-            "PropertyName": function(rule) {
+            "PropertyName": function(filter) {
                 // no ogc:expression handling for now
                 return this.createElementNSPlus("ogc:PropertyName", {
-                    value: rule.property
+                    value: filter.property
                 });
             },
-            "Literal": function(rule) {
+            "Literal": function(value) {
                 // no ogc:expression handling for now
                 return this.createElementNSPlus("ogc:Literal", {
-                    value: rule.value
+                    value: value
                 });
             },
-            "LowerBoundary": function(rule) {
+            "LowerBoundary": function(filter) {
                 // no ogc:expression handling for now
                 var node = this.createElementNSPlus("ogc:LowerBoundary");
-                this.writeNode(node, "Literal", rule.lowerBoundary);
+                this.writeNode(node, "Literal", filter.lowerBoundary);
                 return node;
             },
-            "UpperBoundary": function(rule) {
+            "UpperBoundary": function(filter) {
                 // no ogc:expression handling for now
                 var node = this.createElementNSPlus("ogc:UpperBoundary");
-                this.writeNode(node, "Literal", rule.upperBoundary);
+                this.writeNode(node, "Literal", filter.upperBoundary);
                 return node;
             }
         }
@@ -1006,17 +965,17 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
     /**
      * Method: getFilterType
      */
-    getFilterType: function(rule) {
+    getFilterType: function(filter) {
-        var filterType = this.filterMap[rule.type];
+        var filterType = this.filterMap[filter.type];
         if(!filterType) {
-            throw "SLD writing not supported for rule type: " + rule.type;
+            throw "SLD writing not supported for rule type: " + filter.type;
         }
         return filterType;
     },
     
     /**
      * Property: filterMap
-     * {Object} Contains a member for each rule type.  Values are node names
+     * {Object} Contains a member for each filter type.  Values are node names
      *     for corresponding OGC Filter child elements.
      */
     filterMap: {

lib/OpenLayers/Rule.js

@@ -10,7 +10,7 @@
 
 /**
  * Class: OpenLayers.Rule
- * This class represents a OGC Rule, as being used for rule-based SLD styling.
+ * This class represents an SLD Rule, as being used for rule-based SLD styling.
  */
 OpenLayers.Rule = OpenLayers.Class({
     
@@ -46,6 +46,12 @@ OpenLayers.Rule = OpenLayers.Class({
      */
     context: null,
     
+    /**
+     * Property: filter
+     * {<OpenLayers.Filter>} Optional filter for the rule.
+     */
+    filter: null,
+
     /**
      * Property: elseFilter
      * {Boolean} Determines whether this rule is only to be applied only if
@@ -137,6 +143,16 @@ OpenLayers.Rule = OpenLayers.Class({
                     this.maxScaleDenominator, context);
         }
         
+        // check if optional filter applies
+        if(applies && this.filter) {
+            // feature id filters get the feature, others get the context
+            if(this.filter.CLASS_NAME == "OpenLayers.Filter.FeatureId") {
+                applies = this.filter.evaluate(feature);
+            } else {
+                applies = this.filter.evaluate(context);
+            }
+        }
+
         return applies;
     },
     

lib/OpenLayers/Rule/Logical.js

@@ -1,104 +0,0 @@
-/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
- * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
-  * full text of the license. */
-
-
-/**
- * @requires OpenLayers/Rule.js
- */
-
-/**
- * Class: OpenLayers.Rule.Logical
- * This class represents ogc:And, ogc:Or and ogc:Not rules.
- * 
- * Inherits from
- * - <OpenLayers.Rule>
- */
-OpenLayers.Rule.Logical = OpenLayers.Class(OpenLayers.Rule, {
-
-    /**
-     * APIProperty: children
-     * {Array(<OpenLayers.Rule>)} child rules for this rule
-     */
-    rules: null, 
-     
-    /**
-     * APIProperty: type
-     * {String} type of logical operator. Available types are:
-     * - OpenLayers.Rule.Locical.AND = "&&";
-     * - OpenLayers.Rule.Logical.OR  = "||";
-     * - OpenLayers.Rule.Logical.NOT = "!";
-     */
-    type: null,
-
-    /** 
-     * Constructor: OpenLayers.Rule.Logical
-     * Creates a logical rule (And, Or, Not).
-     *
-     * Parameters:
-     * options - {Object} An optional object with properties to set on the
-     *           rule
-     * 
-     * Returns:
-     * {<OpenLayers.Rule.Logical>}
-     */
-    initialize: function(options) {
-        this.rules = [];
-        OpenLayers.Rule.prototype.initialize.apply(this, [options]);
-    },
-    
-    /** 
-     * APIMethod: destroy
-     * nullify references to prevent circular references and memory leaks
-     */
-    destroy: function() {
-        for (var i=0; i<this.rules.length; i++) {
-            this.rules[i].destroy();
-        }
-        this.rules = null;
-        OpenLayers.Rule.prototype.destroy.apply(this, arguments);
-    },
-
-    /**
-     * APIMethod: evaluate
-     * evaluates this rule for a specific feature
-     * 
-     * Parameters:
-     * feature - {<OpenLayers.Feature>} feature to apply the rule to.
-     * 
-     * Returns:
-     * {boolean} true if the rule applies, false if it does not
-     */
-    evaluate: function(feature) {
-        if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) {
-            return false;
-        }
-        switch(this.type) {
-            case OpenLayers.Rule.Logical.AND:
-                for (var i=0; i<this.rules.length; i++) {
-                    if (this.rules[i].evaluate(feature) == false) {
-                        return false;
-                    }
-                }
-                return true;
-                
-            case OpenLayers.Rule.Logical.OR:
-                for (var i=0; i<this.rules.length; i++) {
-                    if (this.rules[i].evaluate(feature) == true) {
-                        return true;
-                    }
-                }
-                return false;
-            
-            case OpenLayers.Rule.Logical.NOT:
-                return (!this.rules[0].evaluate(feature));
-        }
-    },
-    
-    CLASS_NAME: "OpenLayers.Rule.Logical"
-});
-
-
-OpenLayers.Rule.Logical.AND = "&&";
-OpenLayers.Rule.Logical.OR  = "||";
-OpenLayers.Rule.Logical.NOT = "!";

tests/Filter.html

@@ -0,0 +1,21 @@
+<html> 
+<head> 
+    <script src="../lib/OpenLayers.js"></script> 
+    <script type="text/javascript">
+
+    function test_initialize(t) { 
+        t.plan(3); 
+         
+        var options = {'foo': 'bar'}; 
+        var filter = new OpenLayers.Filter(options); 
+        t.ok(filter instanceof OpenLayers.Filter, 
+             "new OpenLayers.Filter returns object" ); 
+        t.eq(filter.foo, "bar", "constructor sets options correctly"); 
+        t.eq(typeof filter.evaluate, "function", "filter has an evaluate function"); 
+    }
+
+    </script> 
+</head> 
+<body> 
+</body> 
+</html> 

tests/Filter/Comparison.html

@@ -7,41 +7,41 @@
         t.plan(3); 
          
         var options = {'foo': 'bar'}; 
-        var rule = new OpenLayers.Rule.Comparison(options); 
+        var filter = new OpenLayers.Filter.Comparison(options); 
-        t.ok(rule instanceof OpenLayers.Rule.Comparison, 
+        t.ok(filter instanceof OpenLayers.Filter.Comparison, 
-             "new OpenLayers.Rule.Comparison returns object" ); 
+             "new OpenLayers.Filter.Comparison returns object" ); 
-        t.eq(rule.foo, "bar", "constructor sets options correctly"); 
+        t.eq(filter.foo, "bar", "constructor sets options correctly"); 
-        t.eq(typeof rule.evaluate, "function", "rule has an evaluate function"); 
+        t.eq(typeof filter.evaluate, "function", "filter has an evaluate function"); 
     }
 
     function test_Comparison_destroy(t) {
         t.plan(1);
         
-        var rule = new OpenLayers.Rule.Comparison();
+        var filter = new OpenLayers.Filter.Comparison();
-        rule.destroy();
+        filter.destroy();
-        t.eq(rule.symbolizer, null, "symbolizer hash nulled properly");
+        t.eq(filter.symbolizer, null, "symbolizer hash nulled properly");
     }
     
     function test_Comparison_value2regex(t) {
         t.plan(2);
         
-        var rule = new OpenLayers.Rule.Comparison({
+        var filter = new OpenLayers.Filter.Comparison({
                 property: "foo",
                 value: "*b?r\\*\\?*",
-                type: OpenLayers.Rule.Comparison.LIKE});
+                type: OpenLayers.Filter.Comparison.LIKE});
-        rule.value2regex("*", "?", "\\");
+        filter.value2regex("*", "?", "\\");
-        t.eq(rule.value, ".*b.r\\*\\?.*", "Regular expression generated correctly.");
+        t.eq(filter.value, ".*b.r\\*\\?.*", "Regular expression generated correctly.");
         
-        rule.value = "%b.r!%!.%";
+        filter.value = "%b.r!%!.%";
-        rule.value2regex("%", ".", "!");
+        filter.value2regex("%", ".", "!");
-        t.eq(rule.value, ".*b.r\\%\\..*", "Regular expression with different wildcard and escape chars generated correctly.");
+        t.eq(filter.value, ".*b.r\\%\\..*", "Regular expression with different wildcard and escape chars generated correctly.");
     }
     
     function test_regex2value(t) {
         t.plan(8);
         
         function r2v(regex) {
-            return OpenLayers.Rule.Comparison.prototype.regex2value.call(
+            return OpenLayers.Filter.Comparison.prototype.regex2value.call(
                 {value: regex}
             );
         }
@@ -60,11 +60,11 @@
     function test_Comparison_evaluate(t) {
         t.plan(5);
         
-        var rule = new OpenLayers.Rule.Comparison({
+        var filter = new OpenLayers.Filter.Comparison({
                 property: "area",
                 lowerBoundary: 1000,
                 upperBoundary: 4999,
-                type: OpenLayers.Rule.Comparison.BETWEEN});
+                type: OpenLayers.Filter.Comparison.BETWEEN});
 
         var features = [
                 new OpenLayers.Feature.Vector(null, {
@@ -76,21 +76,21 @@
                 new OpenLayers.Feature.Vector(null, {
                         area: 5000})];
         // PropertyIsBetween filter: lower and upper boundary are inclusive
-        var ruleResults = {
+        var filterResults = {
                 0: false,
                 1: true,
                 2: true,
                 3: false};
-        for (var i in ruleResults) {
+        for (var i in filterResults) {
-            var result = rule.evaluate(features[i]);
+            var result = filter.evaluate(features[i].attributes);
-            t.eq(result, ruleResults[i], "feature "+i+
+            t.eq(result, filterResults[i], "feature "+i+
                     " evaluates to "+result.toString()+" correctly.");
         }
-        rule.context = {
+        var context = {
             area: 4998
-        }
+        };
-        var result = rule.evaluate();
+        var result = filter.evaluate(context);
-        t.eq(result, true, "evaluation against custom rule context works.");
+        t.eq(result, true, "evaluation against custom filter context works.");
     }
     </script> 
 </head> 

tests/Filter/FeatureId.html

@@ -0,0 +1,47 @@
+<html> 
+<head> 
+    <script src="../../lib/OpenLayers.js"></script> 
+    <script type="text/javascript">
+
+    function test_FeatureId_constructor(t) { 
+        t.plan(3); 
+         
+        var options = {'foo': 'bar'}; 
+        var filter = new OpenLayers.Filter.FeatureId(options); 
+        t.ok(filter instanceof OpenLayers.Filter.FeatureId, 
+             "new OpenLayers.Filter.FeatureId returns object" ); 
+        t.eq(filter.foo, "bar", "constructor sets options correctly"); 
+        t.eq(typeof filter.evaluate, "function", "filter has an evaluate function"); 
+    }
+
+    function test_FeatureId_destroy(t) {
+        t.plan(1);
+        
+        var filter = new OpenLayers.Filter.FeatureId();
+        filter.destroy();
+        t.eq(filter.symbolizer, null, "symbolizer hash nulled properly");
+    }
+    
+    function test_FeatureId_evaluate(t) {
+        t.plan(3);
+        
+        var filter = new OpenLayers.Filter.FeatureId(
+                {fids: ["fid_1", "fid_3"]});
+
+        var filterResults = {
+                "fid_1" : true,
+                "fid_2" : false,
+                "fid_3" : true};
+        for (var i in filterResults) {
+            var feature = new OpenLayers.Feature.Vector();
+            feature.fid = i;
+            var result = filter.evaluate(feature);
+            t.eq(result, filterResults[i], "feature "+i+" evaluates to "+result.toString()+" correctly.");
+            feature.destroy();
+        }
+    }
+    </script> 
+</head> 
+<body> 
+</body> 
+</html> 

tests/Filter/Logical.html

@@ -0,0 +1,41 @@
+<html> 
+<head> 
+    <script src="../../lib/OpenLayers.js"></script> 
+    <script type="text/javascript">
+
+    function test_Logical_constructor(t) { 
+        t.plan(3); 
+         
+        var options = {'foo': 'bar'}; 
+        var filter = new OpenLayers.Filter.Logical(options); 
+        t.ok(filter instanceof OpenLayers.Filter.Logical, 
+             "new OpenLayers.Filter.Logical returns object" ); 
+        t.eq(filter.foo, "bar", "constructor sets options correctly"); 
+        t.eq(typeof filter.evaluate, "function", "filter has an evaluate function"); 
+    }
+
+    function test_Logical_destroy(t) {
+        t.plan(1);
+        
+        var filter = new OpenLayers.Filter.Logical();
+        filter.destroy();
+        t.eq(filter.filters, null, "filters array nulled properly");
+    }
+    
+    function test_Logical_evaluate(t) {
+        t.plan(1);
+        
+        var filter = new OpenLayers.Filter.Logical({
+                type: OpenLayers.Filter.Logical.NOT});
+        filter.filters.push(new OpenLayers.Filter());
+        
+        var feature = new OpenLayers.Feature.Vector();
+
+        t.eq(filter.evaluate(feature.attributes), false,
+                "feature evaluates to false correctly.");
+    }
+    </script> 
+</head> 
+<body> 
+</body> 
+</html> 

tests/Format/SLD/v1_0_0.html

@@ -0,0 +1,158 @@
+<html> 
+<head> 
+    <script src="../../../lib/OpenLayers.js"></script>
+    <script type="text/javascript">
+    
+    var sld =
+        '<StyledLayerDescriptor version="1.0.0" ' +
+            'xmlns="http://www.opengis.net/sld" ' +
+            'xmlns:gml="http://www.opengis.net/gml" ' +
+            'xmlns:ogc="http://www.opengis.net/ogc" ' +
+            'xmlns:xlink="http://www.w3.org/1999/xlink" ' +
+            'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' +
+            'xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd">' +
+            '<NamedLayer>' + 
+                '<Name>AAA161</Name>' + 
+                '<UserStyle>' + 
+                    '<FeatureTypeStyle>' + 
+                        '<Rule>' + 
+                            '<Name>stortsteen</Name>' + 
+                            '<ogc:Filter>' +
+                                '<ogc:PropertyIsEqualTo>' +
+                                    '<ogc:PropertyName>CTE</ogc:PropertyName>' +
+                                    '<ogc:Literal>V0305</ogc:Literal>' +
+                                '</ogc:PropertyIsEqualTo>' +
+                            '</ogc:Filter>' + 
+                            '<MaxScaleDenominator>50000</MaxScaleDenominator>' + 
+                            '<PolygonSymbolizer>' + 
+                                '<Fill>' + 
+                                    '<CssParameter name="fill">#ffffff</CssParameter>' + 
+                                '</Fill>' + 
+                                '<Stroke>' + 
+                                    '<CssParameter name="stroke">#000000</CssParameter>' + 
+                                '</Stroke>' + 
+                            '</PolygonSymbolizer>' + 
+                        '</Rule>' + 
+                        '<Rule>' + 
+                            '<Name>betonbekleding</Name>' + 
+                            '<ogc:Filter>' +
+                                '<ogc:PropertyIsLessThan>' +
+                                    '<ogc:PropertyName>CTE</ogc:PropertyName>' +
+                                    '<ogc:Literal>1000</ogc:Literal>' +
+                                '</ogc:PropertyIsLessThan>' +
+                            '</ogc:Filter>' + 
+                            '<MaxScaleDenominator>50000</MaxScaleDenominator>' + 
+                            '<PolygonSymbolizer>' + 
+                                '<Fill>' + 
+                                    '<CssParameter name="fill">#ffff00</CssParameter>' + 
+                                '</Fill>' + 
+                                '<Stroke>' + 
+                                    '<CssParameter name="stroke">#0000ff</CssParameter>' + 
+                                '</Stroke>' + 
+                            '</PolygonSymbolizer>' + 
+                        '</Rule>' + 
+                    '</FeatureTypeStyle>' + 
+                '</UserStyle>' + 
+            '</NamedLayer>' + 
+            '<NamedLayer>' + 
+                '<Name>Second Layer</Name>' + 
+                '<UserStyle>' + 
+                    '<FeatureTypeStyle>' + 
+                        '<Rule>' + 
+                            '<Name>first rule second layer</Name>' + 
+                            '<ogc:Filter>' +
+                                '<ogc:Or>' +
+                                    '<ogc:PropertyIsBetween>' +
+                                        '<ogc:PropertyName>number</ogc:PropertyName>' +
+                                        '<ogc:LowerBoundary>' +
+                                            '<ogc:Literal>1064866676</ogc:Literal>' +
+                                        '</ogc:LowerBoundary>' +
+                                        '<ogc:UpperBoundary>' +
+                                            '<ogc:Literal>1065512599</ogc:Literal>' +
+                                        '</ogc:UpperBoundary>' +
+                                    '</ogc:PropertyIsBetween>' +
+                                    '<ogc:PropertyIsLike wildCard="*" singleChar="." escape="!">' +
+                                        '<ogc:PropertyName>cat</ogc:PropertyName>' +
+                                        '<ogc:Literal>*dog.food!*good</ogc:Literal>' +
+                                    '</ogc:PropertyIsLike>' +
+                                    '<ogc:Not>' +
+                                        '<ogc:PropertyIsLessThanOrEqualTo>' +
+                                            '<ogc:PropertyName>FOO</ogc:PropertyName>' +
+                                            '<ogc:Literal>5000</ogc:Literal>' +
+                                        '</ogc:PropertyIsLessThanOrEqualTo>' +
+                                    '</ogc:Not>' +
+                                '</ogc:Or>' +
+                            '</ogc:Filter>' + 
+                            '<MaxScaleDenominator>10000</MaxScaleDenominator>' + 
+                            '<PointSymbolizer>' +
+                                '<Graphic>' +
+                                    '<Mark>' +
+                                        '<WellKnownName>star</WellKnownName>' +
+                                        '<Fill>' + 
+                                            '<CssParameter name="fill">lime</CssParameter>' + 
+                                        '</Fill>' + 
+                                        '<Stroke>' + 
+                                            '<CssParameter name="stroke">olive</CssParameter>' + 
+                                            '<CssParameter name="stroke-width">2</CssParameter>' +
+                                        '</Stroke>' + 
+                                    '</Mark>' + 
+                                '</Graphic>' +
+                            '</PointSymbolizer>' +
+                        '</Rule>' + 
+                    '</FeatureTypeStyle>' + 
+                '</UserStyle>' + 
+            '</NamedLayer>' +
+        '</StyledLayerDescriptor>';
+
+    function test_read(t) {
+        t.plan(6);
+        
+        var parser = new OpenLayers.Format.SLD.v1_0_0();
+        var xml = new OpenLayers.Format.XML();
+        var obj = parser.read(xml.read(sld));
+        
+        // test the named layer count
+        var count = 0;
+        for(var key in obj.namedLayers) {
+            ++count;
+        }        
+        t.eq(count, 2, "correct number of named layers");
+        
+        var layer, style, rule;
+        
+        // check the first named layer
+        layer = obj.namedLayers["AAA161"];
+        t.ok(layer, "first named layer exists");
+        t.ok(layer.userStyles instanceof Array, "(AAA161) layer has array of user styles");
+        t.eq(layer.userStyles.length, 1, "(AAA161) first layer has a single user style");
+        
+        // check the first user style
+        style = layer.userStyles[0];
+        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
+        // etc.  I'm convinced read works, really wanted to test write (since examples don't test that)
+        // I'll add more tests here later.        
+
+    }
+    
+    function test_write(t) {
+        t.plan(1);
+
+        // read first - testing that write produces the SLD aboce
+        var parser = new OpenLayers.Format.SLD.v1_0_0();
+        var xml = new OpenLayers.Format.XML();
+        var obj = parser.read(xml.read(sld));
+        
+        var node = parser.write(obj);
+        t.xml_eq(node, sld, "SLD correctly written");
+        
+    }
+    
+
+    </script> 
+</head> 
+<body>
+</body> 
+</html> 

tests/Rule/FeatureId.html

@@ -1,47 +0,0 @@
-<html> 
-<head> 
-    <script src="../../lib/OpenLayers.js"></script> 
-    <script type="text/javascript">
-
-    function test_FeatureId_constructor(t) { 
-        t.plan(3); 
-         
-        var options = {'foo': 'bar'}; 
-        var rule = new OpenLayers.Rule.FeatureId(options); 
-        t.ok(rule instanceof OpenLayers.Rule.FeatureId, 
-             "new OpenLayers.Rule.FeatureId returns object" ); 
-        t.eq(rule.foo, "bar", "constructor sets options correctly"); 
-        t.eq(typeof rule.evaluate, "function", "rule has an evaluate function"); 
-    }
-
-    function test_FeatureId_destroy(t) {
-        t.plan(1);
-        
-        var rule = new OpenLayers.Rule.FeatureId();
-        rule.destroy();
-        t.eq(rule.symbolizer, null, "symbolizer hash nulled properly");
-    }
-    
-    function test_FeatureId_evaluate(t) {
-        t.plan(3);
-        
-        var rule = new OpenLayers.Rule.FeatureId(
-                {fids: ["fid_1", "fid_3"]});
-
-        var ruleResults = {
-                "fid_1" : true,
-                "fid_2" : false,
-                "fid_3" : true};
-        for (var i in ruleResults) {
-            var feature = new OpenLayers.Feature.Vector();
-            feature.fid = i;
-            var result = rule.evaluate(feature);
-            t.eq(result, ruleResults[i], "feature "+i+" evaluates to "+result.toString()+" correctly.");
-            feature.destroy();
-        }
-    }
-    </script> 
-</head> 
-<body> 
-</body> 
-</html> 

tests/Rule/Logical.html

@@ -1,41 +0,0 @@
-<html> 
-<head> 
-    <script src="../../lib/OpenLayers.js"></script> 
-    <script type="text/javascript">
-
-    function test_Logical_constructor(t) { 
-        t.plan(3); 
-         
-        var options = {'foo': 'bar'}; 
-        var rule = new OpenLayers.Rule.Logical(options); 
-        t.ok(rule instanceof OpenLayers.Rule.Logical, 
-             "new OpenLayers.Rule.Logical returns object" ); 
-        t.eq(rule.foo, "bar", "constructor sets options correctly"); 
-        t.eq(typeof rule.evaluate, "function", "rule has an evaluate function"); 
-    }
-
-    function test_Logical_destroy(t) {
-        t.plan(1);
-        
-        var rule = new OpenLayers.Rule.Logical();
-        rule.destroy();
-        t.eq(rule.rules, null, "rules array nulled properly");
-    }
-    
-    function test_Logical_evaluate(t) {
-        t.plan(1);
-        
-        var rule = new OpenLayers.Rule.Logical({
-                type: OpenLayers.Rule.Logical.NOT});
-        rule.rules.push(new OpenLayers.Rule());
-        
-        var feature = new OpenLayers.Feature.Vector();
-
-        t.eq(rule.evaluate(feature), false,
-                "feature evaluates to false correctly.");
-    }
-    </script> 
-</head> 
-<body> 
-</body> 
-</html> 

tests/Style.html

@@ -27,20 +27,29 @@
         
         var style = new OpenLayers.Style(baseStyle);
         
-        var rule1 = new OpenLayers.Rule.FeatureId({
+        var rule1 = new OpenLayers.Rule({
-                fids: ["1"],
+            symbolizer: {"Point": {fillColor: "green"}},
-                symbolizer: {"Point": {fillColor: "green"}},
+            maxScaleDenominator: 500000,
-                maxScaleDenominator: 500000});
+            filter: new OpenLayers.Filter.FeatureId({
-        var rule2 = new OpenLayers.Rule.FeatureId({
+                fids: ["1"]
-                fids: ["1"],
+            })
-                symbolizer: {"Point": {fillColor: "yellow"}},
+        });
-                minScaleDenominator: 500000,
+        var rule2 = new OpenLayers.Rule({
-                maxScaleDenominator: 1000000});
+            symbolizer: {"Point": {fillColor: "yellow"}},
-        var rule3 = new OpenLayers.Rule.FeatureId({
+            minScaleDenominator: 500000,
-                fids: ["1"],
+            maxScaleDenominator: 1000000,
-                symbolizer: {"Point": {fillColor: "red"}},
+            filter: new OpenLayers.Filter.FeatureId({
-                minScaleDenominator: 1000000,
+                fids: ["1"]
-                maxScaleDenominator: 2500000});
+            })
+        });
+        var rule3 = new OpenLayers.Rule({
+            symbolizer: {"Point": {fillColor: "red"}},
+            minScaleDenominator: 1000000,
+            maxScaleDenominator: 2500000,
+            filter: new OpenLayers.Filter.FeatureId({
+                fids: ["1"]
+            })
+        });
         
         var feature = new OpenLayers.Feature.Vector(
                 new OpenLayers.Geometry.Point(3,5),
@@ -119,11 +128,14 @@
     
     function test_Style_context(t) {
         t.plan(1);
-        var rule = new OpenLayers.Rule.Comparison({
+        var rule = new OpenLayers.Rule({
-            type: OpenLayers.Rule.Comparison.LESS_THAN,
+            symbolizer: {"Point": {externalGraphic: "${img1}"}},
-            property: "size",
+            filter: new OpenLayers.Filter.Comparison({
-            value: 11,
+                type: OpenLayers.Filter.Comparison.LESS_THAN,
-            symbolizer: {"Point": {externalGraphic: "${img1}"}}});
+                property: "size",
+                value: 11
+            })
+        });
         var style = new OpenLayers.Style();
         style.context = {
             "img1": "myImage.png"

tests/list-tests.html

@@ -29,6 +29,7 @@
     <li>Format/OSM.html</li>
     <li>Format/KML.html</li>
     <li>Format/SLD.html</li>
+    <li>Format/SLD/v1_0_0.html</li>
     <li>Format/WKT.html</li>
     <li>Format/WMC.html</li>
     <li>Format/WMC/v1_1_0.html</li>
@@ -46,9 +47,10 @@
     <li>Style.html</li>
     <li>StyleMap.html</li>
     <li>Rule.html</li>
-    <li>Rule/Comparison.html</li>
+    <li>Filter.html</li>
-    <li>Rule/FeatureId.html</li>
+    <li>Filter/Comparison.html</li>
-    <li>Rule/Logical.html</li>
+    <li>Filter/FeatureId.html</li>
+    <li>Filter/Logical.html</li>
     <li>Events.html</li>
     <li>Util.html</li>
     <li>Lang.html</li>