ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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)

Browse Source 
git-svn-id: http://svn.openlayers.org/trunk/openlayers@6818 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
This commit is contained in:
Tim Schaub
2008-04-08 00:13:45 +00:00
parent d7bbcab4df
commit 1091e34c0b
18 changed files with 710 additions and 492 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
examples/georss-flickr.html
View File

@@ -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({
type: OpenLayers.Rule.Comparison.LIKE,
var rule = new OpenLayers.Rule({
symbolizer: {pointRadius: 30},
filter: new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.LIKE,
property: "title",
value: "*powder*",
symbolizer: {"Point": {pointRadius: 30}}});
rule.value2regex("*");
value: "*powder*"
})
});
rule.filter.value2regex("*");
// If the above rule does not apply, use a smaller pointRadius.
var elseRule = new OpenLayers.Rule({
elseFilter: true,
symbolizer: {"Point": {pointRadius: 20}}});
elseFilter: true,
symbolizer: {pointRadius: 20}
});
style.addRules([rule, elseRule]);
markerLayer = new OpenLayers.Layer.Vector("", {styleMap: new OpenLayers.StyleMap({
"default": style,
"select": selectStyle})});
// Create a layer with a style map. Giving the style map keys
// for "default" and "select" rendering intent.
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

7
lib/OpenLayers.js
View File

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

55
lib/OpenLayers/Filter.js Normal file
View File

@@ -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"
});

92
lib/OpenLayers/Rule/Comparison.js → lib/OpenLayers/Filter/Comparison.js
View File

@@ -3,30 +3,29 @@
* full text of the license. */
/**
* @requires OpenLayers/Rule.js
* @requires OpenLayers/Filter.js
*/
/**
* Class: OpenLayers.Rule.Comparison
* This class represents the comparison rules, as being used for rule-based
* SLD styling
* Class: OpenLayers.Filter.Comparison
* This class represents a comparison filter.
*
* 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.Rule.Comparison.NOT_EQUAL_TO = "!=";
* - OpenLayers.Rule.Comparison.LESS_THAN = "<";
* - OpenLayers.Rule.Comparison.GREATER_THAN = ">";
* - OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO = "<=";
* - OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
* - OpenLayers.Rule.Comparison.BETWEEN = "..";
* - OpenLayers.Rule.Comparison.LIKE = "~";
* - OpenLayers.Filter.Comparison.EQUAL_TO = "==";
* - OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!=";
* - OpenLayers.Filter.Comparison.LESS_THAN = "<";
* - OpenLayers.Filter.Comparison.GREATER_THAN = ">";
* - OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<=";
* - OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
* - OpenLayers.Filter.Comparison.BETWEEN = "..";
* - 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) {
if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) {
return false;
}
var context = this.getContext(feature);
evaluate: function(context) {
switch(this.type) {
case OpenLayers.Rule.Comparison.EQUAL_TO:
case OpenLayers.Rule.Comparison.LESS_THAN:
case OpenLayers.Rule.Comparison.GREATER_THAN:
case OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO:
case OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO:
case OpenLayers.Filter.Comparison.EQUAL_TO:
case OpenLayers.Filter.Comparison.LESS_THAN:
case OpenLayers.Filter.Comparison.GREATER_THAN:
case OpenLayers.Filter.Comparison.LESS_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.Rule.Comparison.NOT_EQUAL_TO = "!=";
OpenLayers.Rule.Comparison.LESS_THAN = "<";
OpenLayers.Rule.Comparison.GREATER_THAN = ">";
OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO = "<=";
OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
OpenLayers.Rule.Comparison.BETWEEN = "..";
OpenLayers.Rule.Comparison.LIKE = "~";
OpenLayers.Filter.Comparison.EQUAL_TO = "==";
OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!=";
OpenLayers.Filter.Comparison.LESS_THAN = "<";
OpenLayers.Filter.Comparison.GREATER_THAN = ">";
OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<=";
OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
OpenLayers.Filter.Comparison.BETWEEN = "..";
OpenLayers.Filter.Comparison.LIKE = "~";

21
lib/OpenLayers/Rule/FeatureId.js → lib/OpenLayers/Filter/FeatureId.js
View File

@@ -4,18 +4,18 @@
/**
* @requires OpenLayers/Rule.js
* @requires OpenLayers/Filter.js
*/
/**
* Class: OpenLayers.Rule.FeatureId
* This class represents a ogc:FeatureId Rule, as being used for rule-based SLD
* Class: OpenLayers.Filter.FeatureId
* 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"
});

99
lib/OpenLayers/Filter/Logical.js Normal file
View File

@@ -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 = "!";

309
lib/OpenLayers/Format/SLD/v1.js
View File

@@ -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.
// Filter elements are represented as instances of
// 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);
}
var rule = new OpenLayers.Rule();
this.readChildNodes(node, rule);
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);
if(filter.fids.length > 0) {
rule.rules.push(new OpenLayers.Rule.FeatureId({
fids: filter.fids
}));
}
if(filter.rules.length > 0) {
rule.rules = rule.rules.concat(filter.rules);
this.readChildNodes(node, obj);
if(obj.fids.length > 0) {
rule.filter = new OpenLayers.Filter.FeatureId({
fids: obj.fids
});
} else if(obj.filters.length > 0) {
rule.filter = obj.filters[0];
}
},
"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) {
var rule = new OpenLayers.Rule.Logical({
type: OpenLayers.Rule.Logical.AND
"And": function(node, obj) {
var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Filter.Logical.AND
});
// since FeatureId rules may be nested here, make room for them
rule.fids = [];
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);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"Or": function(node, filter) {
var rule = new OpenLayers.Rule.Logical({
type: OpenLayers.Rule.Logical.OR
"Or": function(node, obj) {
var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Filter.Logical.OR
});
// since FeatureId rules may be nested here, make room for them
rule.fids = [];
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);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"Not": function(node, filter) {
var rule = new OpenLayers.Rule.Logical({
type: OpenLayers.Rule.Logical.NOT
"Not": function(node, obj) {
var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Filter.Logical.NOT
});
// since FeatureId rules may be nested here, make room for them
rule.fids = [];
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);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsEqualTo": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.EQUAL_TO
"PropertyIsEqualTo": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.EQUAL_TO
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsNotEqualTo": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.NOT_EQUAL_TO
"PropertyIsNotEqualTo": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.NOT_EQUAL_TO
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsLessThan": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.LESS_THAN
"PropertyIsLessThan": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.LESS_THAN
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsGreaterThan": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.GREATER_THAN
"PropertyIsGreaterThan": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.GREATER_THAN
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsLessThanOrEqualTo": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO
"PropertyIsLessThanOrEqualTo": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsGreaterThanOrEqualTo": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO
"PropertyIsGreaterThanOrEqualTo": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsBetween": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.BETWEEN
"PropertyIsBetween": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.BETWEEN
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsLike": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.LIKE
"PropertyIsLike": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
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.rules.push(rule);
filter.value2regex(wildCard, singleChar, esc);
obj.filters.push(filter);
},
"Literal": function(node, obj) {
obj.value = this.getChildValue(node);
},
"PropertyName": function(node, rule) {
rule.property = this.getChildValue(node);
"PropertyName": function(node, filter) {
filter.property = this.getChildValue(node);
},
"LowerBoundary": function(node, rule) {
rule.lowerBoundary = this.readOgcExpression(node);
"LowerBoundary": function(node, filter) {
filter.lowerBoundary = this.readOgcExpression(node);
},
"UpperBoundary": function(node, rule) {
rule.upperBoundary = this.readOgcExpression(node);
"UpperBoundary": function(node, filter) {
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") {
this.writeNode(node, "ogc:Filter", rule);
} else if(rule.filter) {
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) {
this.writeNode(node, "FeatureId", rule.fids[i]);
for(var i=0; i<filter.fids.length; ++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;
for(var i=0; i<rule.rules.length; ++i) {
childRule = rule.rules[i];
var childFilter;
for(var i=0; i<filter.filters.length; ++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;
for(var i=0; i<rule.rules.length; ++i) {
childRule = rule.rules[i];
var childFilter;
for(var i=0; i<filter.filters.length; ++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, "Literal", rule);
this.writeNode(node, "PropertyName", filter);
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, "Literal", rule);
this.writeNode(node, "PropertyName", filter);
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, "Literal", rule);
this.writeNode(node, "PropertyName", filter);
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, "Literal", rule);
this.writeNode(node, "PropertyName", filter);
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, "Literal", rule);
this.writeNode(node, "PropertyName", filter);
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, "Literal", rule);
this.writeNode(node, "PropertyName", filter);
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, "LowerBoundary", rule);
this.writeNode(node, "UpperBoundary", rule);
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "LowerBoundary", filter);
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) {
var filterType = this.filterMap[rule.type];
getFilterType: function(filter) {
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: {

18
lib/OpenLayers/Rule.js
View File

@@ -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({
@@ -45,6 +45,12 @@ OpenLayers.Rule = OpenLayers.Class({
* be used.
*/
context: null,
/**
* Property: filter
* {<OpenLayers.Filter>} Optional filter for the rule.
*/
filter: null,
/**
* Property: elseFilter
@@ -136,6 +142,16 @@ OpenLayers.Rule = OpenLayers.Class({
applies = scale < OpenLayers.Style.createLiteral(
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;
},

104
lib/OpenLayers/Rule/Logical.js
View File

@@ -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 = "!";

21
tests/Filter.html Normal file
View File

@@ -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>

52
tests/Rule/Comparison.html → tests/Filter/Comparison.html
View File

@@ -7,41 +7,41 @@
t.plan(3);
var options = {'foo': 'bar'};
var rule = new OpenLayers.Rule.Comparison(options);
t.ok(rule instanceof OpenLayers.Rule.Comparison,
"new OpenLayers.Rule.Comparison returns object" );
t.eq(rule.foo, "bar", "constructor sets options correctly");
t.eq(typeof rule.evaluate, "function", "rule has an evaluate function");
var filter = new OpenLayers.Filter.Comparison(options);
t.ok(filter instanceof OpenLayers.Filter.Comparison,
"new OpenLayers.Filter.Comparison returns object" );
t.eq(filter.foo, "bar", "constructor sets options correctly");
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();
rule.destroy();
t.eq(rule.symbolizer, null, "symbolizer hash nulled properly");
var filter = new OpenLayers.Filter.Comparison();
filter.destroy();
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});
rule.value2regex("*", "?", "\\");
t.eq(rule.value, ".*b.r\\*\\?.*", "Regular expression generated correctly.");
type: OpenLayers.Filter.Comparison.LIKE});
filter.value2regex("*", "?", "\\");
t.eq(filter.value, ".*b.r\\*\\?.*", "Regular expression generated correctly.");
rule.value = "%b.r!%!.%";
rule.value2regex("%", ".", "!");
t.eq(rule.value, ".*b.r\\%\\..*", "Regular expression with different wildcard and escape chars generated correctly.");
filter.value = "%b.r!%!.%";
filter.value2regex("%", ".", "!");
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) {
var result = rule.evaluate(features[i]);
t.eq(result, ruleResults[i], "feature "+i+
for (var i in filterResults) {
var result = filter.evaluate(features[i].attributes);
t.eq(result, filterResults[i], "feature "+i+
" evaluates to "+result.toString()+" correctly.");
}
rule.context = {
var context = {
area: 4998
}
var result = rule.evaluate();
t.eq(result, true, "evaluation against custom rule context works.");
};
var result = filter.evaluate(context);
t.eq(result, true, "evaluation against custom filter context works.");
}
</script>
</head>

47
tests/Filter/FeatureId.html Normal file
View File

@@ -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>

41
tests/Filter/Logical.html Normal file
View File

@@ -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>

158
tests/Format/SLD/v1_0_0.html Normal file
View File

@@ -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>

47
tests/Rule/FeatureId.html
View File

@@ -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>

41
tests/Rule/Logical.html
View File

@@ -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>

50
tests/Style.html
View File

@@ -27,20 +27,29 @@
var style = new OpenLayers.Style(baseStyle);
var rule1 = new OpenLayers.Rule.FeatureId({
fids: ["1"],
symbolizer: {"Point": {fillColor: "green"}},
maxScaleDenominator: 500000});
var rule2 = new OpenLayers.Rule.FeatureId({
fids: ["1"],
symbolizer: {"Point": {fillColor: "yellow"}},
minScaleDenominator: 500000,
maxScaleDenominator: 1000000});
var rule3 = new OpenLayers.Rule.FeatureId({
fids: ["1"],
symbolizer: {"Point": {fillColor: "red"}},
minScaleDenominator: 1000000,
maxScaleDenominator: 2500000});
var rule1 = new OpenLayers.Rule({
symbolizer: {"Point": {fillColor: "green"}},
maxScaleDenominator: 500000,
filter: new OpenLayers.Filter.FeatureId({
fids: ["1"]
})
});
var rule2 = new OpenLayers.Rule({
symbolizer: {"Point": {fillColor: "yellow"}},
minScaleDenominator: 500000,
maxScaleDenominator: 1000000,
filter: new OpenLayers.Filter.FeatureId({
fids: ["1"]
})
});
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({
type: OpenLayers.Rule.Comparison.LESS_THAN,
property: "size",
value: 11,
symbolizer: {"Point": {externalGraphic: "${img1}"}}});
var rule = new OpenLayers.Rule({
symbolizer: {"Point": {externalGraphic: "${img1}"}},
filter: new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.LESS_THAN,
property: "size",
value: 11
})
});
var style = new OpenLayers.Style();
style.context = {
"img1": "myImage.png"

8
tests/list-tests.html
View File

@@ -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>Rule/FeatureId.html</li>
<li>Rule/Logical.html</li>
<li>Filter.html</li>
<li>Filter/Comparison.html</li>
<li>Filter/FeatureId.html</li>
<li>Filter/Logical.html</li>
<li>Events.html</li>
<li>Util.html</li>
<li>Lang.html</li>