From 6a2d61bb0771ffe96ccdd315c19063da62251cd0 Mon Sep 17 00:00:00 2001 From: Adrian Crum Date: Wed, 25 Apr 2012 17:09:15 +0000 Subject: [PATCH] First pass at overhauled Mini-language element. 1. The schema has been updated to reflect the new syntax. 2. The updated element will log warnings for incorrect syntax. Validation logging can be turned off by changing the minilang.properties validation.level property to none. 3. The element will auto-correct the XML source file if the minilang.properties autocorrect property is set to true. 4. Code has been cleaned up and simplified. git-svn-id: https://svn.apache.org/repos/asf/ofbiz/trunk@1330422 13f79535-47bb-0310-9956-ffa450edef68 --- framework/minilang/dtd/simple-methods-v2.xsd | 16 +- .../minilang/method/envops/SetOperation.java | 174 +++++++++++++----- 2 files changed, 142 insertions(+), 48 deletions(-) diff --git a/framework/minilang/dtd/simple-methods-v2.xsd b/framework/minilang/dtd/simple-methods-v2.xsd index 4664b543f0..7215568b3a 100644 --- a/framework/minilang/dtd/simple-methods-v2.xsd +++ b/framework/minilang/dtd/simple-methods-v2.xsd @@ -1351,6 +1351,13 @@ under the License. + + + Deprecated - use "from". + + + + An expression or script that returns an object or null. The source of the assignment. @@ -1372,6 +1379,13 @@ under the License. + + + Deprecated - use "default". + + + + A default value that is used if the from-field attribute evaluates to null or empty. @@ -1383,7 +1397,7 @@ under the License. - The Java data type to convert to. "NewList" will create a new List, "NewMap" will create a new java.util.Map. + The Java data type to convert to. "NewList" will create a new java.util.List, "NewMap" will create a new java.util.Map. <br/><br/> Optional. Attribute type: constant. Attribute must contain a valid Java class name. diff --git a/framework/minilang/src/org/ofbiz/minilang/method/envops/SetOperation.java b/framework/minilang/src/org/ofbiz/minilang/method/envops/SetOperation.java index 83bb935b06..590733da55 100644 --- a/framework/minilang/src/org/ofbiz/minilang/method/envops/SetOperation.java +++ b/framework/minilang/src/org/ofbiz/minilang/method/envops/SetOperation.java @@ -24,83 +24,140 @@ import javolution.util.FastMap; import org.ofbiz.base.util.Debug; import org.ofbiz.base.util.GeneralException; import org.ofbiz.base.util.ObjectType; -import org.ofbiz.base.util.ScriptUtil; -import org.ofbiz.base.util.UtilValidate; +import org.ofbiz.base.util.Scriptlet; +import org.ofbiz.base.util.collections.FlexibleMapAccessor; import org.ofbiz.base.util.string.FlexibleStringExpander; import org.ofbiz.minilang.MiniLangException; +import org.ofbiz.minilang.MiniLangUtil; +import org.ofbiz.minilang.MiniLangValidate; import org.ofbiz.minilang.SimpleMethod; -import org.ofbiz.minilang.method.ContextAccessor; import org.ofbiz.minilang.method.MethodContext; import org.ofbiz.minilang.method.MethodOperation; import org.w3c.dom.Element; /** - * A general set operation to set a field from another field or from a value. Also supports a default-value, and type conversion. + * Assigns a field from an expression or script, or from a constant value. Also supports a default value and type conversion. */ -public class SetOperation extends MethodOperation { +public final class SetOperation extends MethodOperation { public static final String module = SetOperation.class.getName(); - protected FlexibleStringExpander defaultExdr; - protected ContextAccessor field; - protected ContextAccessor fromField; - protected Class parsedScript = null; - protected boolean setIfEmpty; // default to true - protected boolean setIfNull; // default to false - protected String type; - protected FlexibleStringExpander valueExdr; + // This method is needed only during the v1 to v2 transition + private static boolean autoCorrect(Element element) { + boolean elementModified = false; + // Correct deprecated default-value attribute + String defaultAttr = element.getAttribute("default-value"); + if (defaultAttr.length() > 0) { + element.setAttribute("default", defaultAttr); + element.removeAttribute("default-value"); + elementModified = true; + } + // Correct deprecated from-field attribute + String fromAttr = element.getAttribute("from-field"); + if (fromAttr.length() > 0) { + element.setAttribute("from", fromAttr); + element.removeAttribute("from-field"); + elementModified = true; + } + fromAttr = element.getAttribute("from").trim(); + // Correct from attribute wrapped in ${} + if (fromAttr.startsWith("${") && fromAttr.endsWith("}")) { + fromAttr = fromAttr.substring(2, fromAttr.length() - 1); + if (!fromAttr.contains("${")) { + element.setAttribute("from", fromAttr); + elementModified = true; + } + } + // Correct value attribute expression that belongs in from attribute + String valueAttr = element.getAttribute("value").trim(); + if (valueAttr.startsWith("${") && valueAttr.endsWith("}")) { + valueAttr = valueAttr.substring(2, valueAttr.length() - 1); + if (!valueAttr.contains("${")) { + element.setAttribute("from", valueAttr); + element.removeAttribute("value"); + elementModified = true; + } + } + return elementModified; + } + + private final FlexibleStringExpander defaultFse; + private final FlexibleMapAccessor fieldFma; + private final FlexibleMapAccessor fromFma; + private final Scriptlet scriptlet; + private final boolean setIfEmpty; + private final boolean setIfNull; + private final String type; + private final FlexibleStringExpander valueFse; public SetOperation(Element element, SimpleMethod simpleMethod) throws MiniLangException { super(element, simpleMethod); - this.field = new ContextAccessor(element.getAttribute("field")); - String fromFieldStr = element.getAttribute("from-field"); - if (fromFieldStr != null && fromFieldStr.startsWith("groovy:")) { - this.parsedScript = ScriptUtil.parseScript("groovy", fromFieldStr.replace("groovy:", "")); + if (MiniLangValidate.validationOn()) { + /* + MiniLangValidate.deprecatedAttribute(simpleMethod, element, "from-field", "replace with \"from\""); + MiniLangValidate.deprecatedAttribute(simpleMethod, element, "default-value", "replace with \"default\""); + */ + MiniLangValidate.attributeNames(simpleMethod, element, "field", "from-field", "from", "value", "default-value", "default", "type", "set-if-null", "set-if-empty"); + MiniLangValidate.requiredAttributes(simpleMethod, element, "field"); + MiniLangValidate.requireAnyAttribute(simpleMethod, element, "from-field", "from", "value"); + MiniLangValidate.constantPlusExpressionAttributes(simpleMethod, element, "value"); + MiniLangValidate.constantAttributes(simpleMethod, element, "type", "set-if-null", "set-if-empty"); + MiniLangValidate.noChildElements(simpleMethod, element); } - this.fromField = new ContextAccessor(fromFieldStr); - this.valueExdr = FlexibleStringExpander.getInstance(element.getAttribute("value")); - this.defaultExdr = FlexibleStringExpander.getInstance(element.getAttribute("default-value")); + boolean elementModified = autoCorrect(element); + if (elementModified && MiniLangUtil.autoCorrectOn()) { + MiniLangUtil.flagDocumentAsCorrected(element); + } + this.fieldFma = FlexibleMapAccessor.getInstance(element.getAttribute("field")); + String fromAttribute = element.getAttribute("from"); + if (MiniLangUtil.containsScript(fromAttribute)) { + this.scriptlet = new Scriptlet(fromAttribute); + this.fromFma = FlexibleMapAccessor.getInstance(null); + } else { + this.scriptlet = null; + this.fromFma = FlexibleMapAccessor.getInstance(fromAttribute); + } + this.valueFse = FlexibleStringExpander.getInstance(element.getAttribute("value")); + this.defaultFse = FlexibleStringExpander.getInstance(element.getAttribute("default")); this.type = element.getAttribute("type"); - // default to false, anything but true is false - this.setIfNull = "true".equals(element.getAttribute("set-if-null")); - // default to true, anything but false is true - this.setIfEmpty = !"false".equals(element.getAttribute("set-if-empty")); - if (!this.fromField.isEmpty() && !this.valueExdr.isEmpty()) { - throw new IllegalArgumentException("Cannot specify a from-field [" + element.getAttribute("from-field") + "] and a value [" + element.getAttribute("value") + "] on the set action in a screen widget"); + this.setIfNull = "true".equals(element.getAttribute("set-if-null")); // default to false, anything but true is false + this.setIfEmpty = !"false".equals(element.getAttribute("set-if-empty")); // default to true, anything but false is true + if (!this.fromFma.isEmpty() && !this.valueFse.isEmpty()) { + throw new IllegalArgumentException("Cannot include both a from attribute and a value attribute in a element."); } } @Override public boolean exec(MethodContext methodContext) throws MiniLangException { Object newValue = null; - if (this.parsedScript != null) { + if (this.scriptlet != null) { try { - newValue = ScriptUtil.evaluate("groovy", null, this.parsedScript, methodContext.getEnvMap()); + newValue = this.scriptlet.executeScript(methodContext.getEnvMap()); } catch (Exception exc) { - Debug.logWarning(exc, "Error evaluating scriptlet [" + this + "]; error was: " + exc, module); + Debug.logWarning(exc, "Error evaluating scriptlet [" + this.scriptlet + "]: " + exc, module); } - } else if (!this.fromField.isEmpty()) { - newValue = this.fromField.get(methodContext); + } else if (!this.fromFma.isEmpty()) { + newValue = this.fromFma.get(methodContext.getEnvMap()); if (Debug.verboseOn()) - Debug.logVerbose("In screen getting value for field from [" + this.fromField.toString() + "]: " + newValue, module); - } else if (!this.valueExdr.isEmpty()) { - newValue = methodContext.expandString(this.valueExdr); + Debug.logVerbose("In screen getting value for field from [" + this.fromFma.toString() + "]: " + newValue, module); + } else if (!this.valueFse.isEmpty()) { + newValue = this.valueFse.expand(methodContext.getEnvMap()); } // If newValue is still empty, use the default value - if (ObjectType.isEmpty(newValue) && !this.defaultExdr.isEmpty()) { - newValue = methodContext.expandString(this.defaultExdr); + if (ObjectType.isEmpty(newValue) && !this.defaultFse.isEmpty()) { + newValue = this.defaultFse.expand(methodContext.getEnvMap()); } if (!setIfNull && newValue == null) { if (Debug.verboseOn()) - Debug.logVerbose("Field value not found (null) with name [" + fromField + "] and value [" + valueExdr + "], and there was not default value, not setting field", module); + Debug.logVerbose("Field value not found (null) with name [" + fromFma + "] and value [" + valueFse + "], and there was not default value, not setting field", module); return true; } if (!setIfEmpty && ObjectType.isEmpty(newValue)) { if (Debug.verboseOn()) - Debug.logVerbose("Field value not found (empty) with name [" + fromField + "] and value [" + valueExdr + "], and there was not default value, not setting field", module); + Debug.logVerbose("Field value not found (empty) with name [" + fromFma + "] and value [" + valueFse + "], and there was not default value, not setting field", module); return true; } - if (UtilValidate.isNotEmpty(this.type)) { + if (this.type.length() > 0) { if ("NewMap".equals(this.type)) { newValue = FastMap.newInstance(); } else if ("NewList".equals(this.type)) { @@ -109,29 +166,52 @@ public class SetOperation extends MethodOperation { try { newValue = ObjectType.simpleTypeConvert(newValue, this.type, null, methodContext.getTimeZone(), methodContext.getLocale(), true); } catch (GeneralException e) { - String errMsg = "Could not convert field value for the field: [" + this.field.toString() + "] to the [" + this.type + "] type for the value [" + newValue + "]: " + e.toString(); - Debug.logError(e, errMsg, module); + String errMsg = "Could not convert field value for the field: [" + this.fieldFma.toString() + "] to the [" + this.type + "] type for the value [" + newValue + "]: " + e.toString(); + Debug.logWarning(e, errMsg, module); methodContext.setErrorReturn(errMsg, simpleMethod); return false; } } } if (Debug.verboseOn()) - Debug.logVerbose("In screen setting field [" + this.field.toString() + "] to value: " + newValue, module); - this.field.put(methodContext, newValue); + Debug.logVerbose("In screen setting field [" + this.fieldFma.toString() + "] to value: " + newValue, module); + this.fieldFma.put(methodContext.getEnvMap(), newValue); return true; } @Override public String expandedString(MethodContext methodContext) { - // TODO: something more than a stub/dummy - return this.rawString(); + return FlexibleStringExpander.expandString(toString(), methodContext.getEnvMap()); } @Override public String rawString() { - return ""; + return toString(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(" 0) { + sb.append("type=\"").append(this.type).append("\" "); + } + sb.append("/>"); + return sb.toString(); } public static final class SetOperationFactory implements Factory {