add more tests and update unsupportedProperties

Author: Kai Volland

data/olStyles/function_boolean.ts

@@ -0,0 +1,21 @@
+import OlStyle from 'ol/style/Style';
+import OlStyleCircle from 'ol/style/Circle';
+import OlStyleFill from 'ol/style/Fill';
+
+export const olBoolean1 = new OlStyle({
+  image: new OlStyleCircle({
+    radius: 10,
+    fill: new OlStyleFill({
+      color: '#FF0000'
+    })
+  })
+});
+
+export const olBoolean2 = new OlStyle({
+  image: new OlStyleCircle({
+    radius: 6,
+    fill: new OlStyleFill({
+      color: '#FF0000'
+    })
+  })
+});

data/olStyles/function_nested_fillSymbolizer.ts

@@ -0,0 +1,14 @@
+import OlStyle from 'ol/style/Style';
+import OlStyleFill from 'ol/style/Fill';
+import OlStyleStroke from 'ol/style/Stroke';
+
+const olPolygonSimple = new OlStyle({
+  fill: new OlStyleFill({
+    color: '#F1337F',
+  }),
+  stroke: new OlStyleStroke({
+    width: 5
+  })
+});
+
+export default olPolygonSimple;

data/styles/function_boolean.ts

@@ -0,0 +1,37 @@
+import { Style } from 'geostyler-style';
+
+const functionBoolean: Style = {
+  name: 'OL Style',
+  rules: [
+    {
+      name: 'OL Style Rule 0',
+      filter: [
+        '==',
+        {
+          name: 'between',
+          args: [{
+            name: 'property',
+            args: ['testprop']
+          }, 0, 1]
+        },
+        true
+      ],
+      symbolizers: [{
+        kind: 'Mark',
+        wellKnownName: 'circle',
+        color: '#FF0000',
+        radius: 10
+      }]
+    }, {
+      name: 'OL Style Rule 1',
+      symbolizers: [{
+        kind: 'Mark',
+        wellKnownName: 'circle',
+        color: '#FF0000',
+        radius: 6
+      }]
+    }
+  ]
+};
+
+export default functionBoolean;

data/styles/function_nested_fillSymbolizer.ts

@@ -0,0 +1,25 @@
+import { Style } from 'geostyler-style';
+
+const functionNestedFillSymbolizer: Style = {
+  name: 'OL Style',
+  rules: [
+    {
+      name: 'OL Style Rule 0',
+      symbolizers: [{
+        kind: 'Fill',
+        color: '#F1337F',
+        outlineWidth: {
+          name: 'max',
+          args: [{
+            name: 'pi'
+          }, {
+            name: 'strLength',
+            args: ['Peter']
+          }]
+        }
+      }]
+    }
+  ]
+};
+
+export default functionNestedFillSymbolizer;

src/OlStyleParser.spec.ts

@@ -35,6 +35,7 @@ import filter_simplefilter from '../data/styles/filter_simpleFilter';
 import filter_nestedfilter from '../data/styles/filter_nestedFilter';
 import filter_invalidfilter from '../data/styles/filter_invalidFilter';
 import function_marksymbolizer from '../data/styles/function_markSymbolizer';
+import function_nested_fillsymbolizer from '../data/styles/function_nested_fillSymbolizer';
 import point_styledLabel_static from '../data/styles/point_styledLabel_static';
 import multi_twoRulesSimplepoint from '../data/styles/multi_twoRulesSimplepoint';
 import multi_simplefillSimpleline from '../data/styles/multi_simplefillSimpleline';
@@ -48,6 +49,8 @@ import point_styledlabel from '../data/styles/point_styledlabel';
 import point_fontglyph from '../data/styles/point_fontglyph';
 import unsupported_properties from '../data/styles/unsupported_properties';
 
+import ol_function_marksymbolizer from '../data/olStyles/function_markSymbolizer';
+import ol_function_nested_fillsymbolizer from '../data/olStyles/function_nested_fillSymbolizer';
 import ol_point_simplepoint from '../data/olStyles/point_simplepoint';
 import ol_point_icon from '../data/olStyles/point_icon';
 import ol_point_simplesquare from '../data/olStyles/point_simplesquare';
@@ -82,8 +85,8 @@ import {
 } from 'geostyler-style';
 
 import OlStyleUtil from './Util/OlStyleUtil';
-import olSimpleCross from '../data/olStyles/point_simplecross';
-import olFunctionMark from '../data/olStyles/function_markSymbolizer';
+import function_boolean from '../data/styles/function_boolean';
+import { olBoolean1 as ol_function_boolean_fillsymbolizer1, olBoolean2 as ol_function_boolean_fillsymbolizer2 } from '../data/olStyles/function_boolean';
 
 // reverse calculation of resolution for scale (from ol-util MapUtil)
 function getResolutionForScale (scale, units) {
@@ -1121,12 +1124,39 @@ describe('OlStyleParser implements StyleParser', () => {
     expect(geoStylerStyle).toBeDefined();
     expect(typeof geoStylerStyle === 'function').toBe(true);
     geoStylerStyle = geoStylerStyle as OlParserStyleFct;
-    const dummyFeat = new OlFeature({
-      path: 'image.jpg'
-    });
+    const dummyFeat = new OlFeature();
     const targetStyle = geoStylerStyle(dummyFeat);
     expect(geoStylerStyle.__geoStylerStyle).toEqual(function_marksymbolizer);
-    expect(targetStyle[0]).toEqual(olFunctionMark);
+    expect(targetStyle[0]).toEqual(ol_function_marksymbolizer);
+  });
+
+  it('can write a FillSymbolizer with a nested GeoStylerFunction', async () => {
+    let { output: geoStylerStyle } = await styleParser.writeStyle(function_nested_fillsymbolizer);
+    expect(geoStylerStyle).toBeDefined();
+    expect(typeof geoStylerStyle === 'function').toBe(true);
+    geoStylerStyle = geoStylerStyle as OlParserStyleFct;
+    const dummyFeat = new OlFeature();
+    const targetStyle = geoStylerStyle(dummyFeat);
+    expect(geoStylerStyle.__geoStylerStyle).toEqual(function_nested_fillsymbolizer);
+    expect(targetStyle[0]).toEqual(ol_function_nested_fillsymbolizer);
+  });
+
+  it('can write a Filter with a GeoStylerBooleanFunction', async () => {
+    let { output: geoStylerStyle } = await styleParser.writeStyle(function_boolean);
+    expect(geoStylerStyle).toBeDefined();
+    expect(typeof geoStylerStyle === 'function').toBe(true);
+    geoStylerStyle = geoStylerStyle as OlParserStyleFct;
+    const dummyFeat1 = new OlFeature({
+      testprop: 0.8
+    });
+    const dummyFeat2 = new OlFeature({
+      testprop: 2
+    });
+    const targetStyle1 = geoStylerStyle(dummyFeat1);
+    const targetStyle2 = geoStylerStyle(dummyFeat2);
+    expect(geoStylerStyle.__geoStylerStyle).toEqual(function_boolean);
+    expect(targetStyle1[0]).toEqual(ol_function_boolean_fillsymbolizer1);
+    expect(targetStyle2[0]).toEqual(ol_function_boolean_fillsymbolizer2);
   });
 
   it('adds unsupportedProperties to the write output', async () => {

src/OlStyleParser.ts

@@ -109,6 +109,24 @@ export class OlStyleParser implements StyleParser<OlStyleLike> {
         perpendicularOffset: 'none'
       },
       RasterSymbolizer: 'none'
+    },
+    Function: {
+      atan2: {
+        support: 'none',
+        info: 'Currently returns the first argument'
+      },
+      rint: {
+        support: 'none',
+        info: 'Currently returns the first argument'
+      },
+      numberFormat: {
+        support: 'none',
+        info: 'Currently returns the first argument'
+      },
+      strAbbreviate: {
+        support: 'none',
+        info: 'Currently returns the first argument'
+      }
     }
   };
 
@@ -793,11 +811,11 @@ export class OlStyleParser implements StyleParser<OlStyleLike> {
             throw new Error('Cannot parse Filter. Unknown combination or negation operator.');
         }
       } else {
-        let prop: any;
-        if (isGeoStylerStringFunction(filter[1])) {
-          prop = feature.get(OlStyleUtil.evaluateStringFunction(filter[1], feature));
+        let arg1: any;
+        if (isGeoStylerFunction(filter[1])) {
+          arg1 = OlStyleUtil.evaluateFunction(filter[1], feature);
         } else {
-          prop = feature.get(filter[1]);
+          arg1 = feature.get(filter[1]);
         }
         let arg2: any;
         if (isGeoStylerFunction(filter[2])) {
@@ -807,33 +825,33 @@ export class OlStyleParser implements StyleParser<OlStyleLike> {
         }
         switch (filter[0]) {
           case '==':
-            matchesFilter = ('' + prop) === ('' + arg2);
+            matchesFilter = ('' + arg1) === ('' + arg2);
             break;
           case '*=':
             // inspired by
             // https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/String/includes#Polyfill
-            if (typeof arg2 === 'string' && typeof prop === 'string') {
-              if (arg2.length > prop.length) {
+            if (typeof arg2 === 'string' && typeof arg1 === 'string') {
+              if (arg2.length > arg1.length) {
                 matchesFilter = false;
               } else {
-                matchesFilter = prop.indexOf(arg2) !== -1;
+                matchesFilter = arg1.indexOf(arg2) !== -1;
               }
             }
             break;
           case '!=':
-            matchesFilter = ('' + prop) !== ('' + arg2);
+            matchesFilter = ('' + arg1) !== ('' + arg2);
             break;
           case '<':
-            matchesFilter = parseFloat(prop) < Number(arg2);
+            matchesFilter = Number(arg1) < Number(arg2);
             break;
           case '<=':
-            matchesFilter = parseFloat(prop) <= Number(arg2);
+            matchesFilter = Number(arg1) <= Number(arg2);
             break;
           case '>':
-            matchesFilter = parseFloat(prop) > Number(arg2);
+            matchesFilter = Number(arg1) > Number(arg2);
             break;
           case '>=':
-            matchesFilter = parseFloat(prop) >= Number(arg2);
+            matchesFilter = Number(arg1) >= Number(arg2);
             break;
           default:
             throw new Error('Cannot parse Filter. Unknown comparison operator.');
@@ -1193,9 +1211,10 @@ export class OlStyleParser implements StyleParser<OlStyleLike> {
         OlStyleUtil.getRgbaColor(symbolizer.color, symbolizer.opacity) : symbolizer.color
     }) : null;
 
-    const stroke = symbolizer.outlineColor ? new this.OlStyleStrokeConstructor({
-      color: (symbolizer.outlineOpacity !== null && symbolizer.outlineOpacity !== undefined) ?
-        OlStyleUtil.getRgbaColor(symbolizer.outlineColor, symbolizer.outlineOpacity) : symbolizer.outlineColor,
+    const stroke = symbolizer.outlineColor || symbolizer.outlineWidth ? new this.OlStyleStrokeConstructor({
+      color: (symbolizer.outlineColor && Number.isFinite(symbolizer.outlineOpacity))
+        ? OlStyleUtil.getRgbaColor(symbolizer.outlineColor, symbolizer.outlineOpacity as number)
+        : symbolizer.outlineColor,
       width: symbolizer.outlineWidth,
       lineDash: symbolizer.outlineDasharray,
     }) : null;