vividus-framework · valfirst · Sep 25, 2021 · Sep 24, 2021
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2019-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.vividus.bdd.converter;
+
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.Map;
+
+import org.jbehave.core.model.ExamplesTable;
+import org.jbehave.core.model.ExamplesTableFactory;
+import org.jbehave.core.steps.ParameterConverters;
+import org.vividus.bdd.steps.PlaceholderResolver;
+
+public class ResolvingPlaceholdersExamplesTableConverter extends ParameterConverters.ExamplesTableConverter
+{
+    private final PlaceholderResolver placeholderResolver;
+
+    public ResolvingPlaceholdersExamplesTableConverter(ExamplesTableFactory factory,
+            PlaceholderResolver placeholderResolver)
+    {
+        super(factory);
+        this.placeholderResolver = placeholderResolver;
+    }
+
+    @Override
+    public ExamplesTable convertValue(String value, Type type)
+    {
+        ExamplesTable examplesTable = super.convertValue(value, type);
+        List<Map<String, String>> rows = examplesTable.getRows();
+        rows.forEach(row -> row.entrySet().forEach(cell -> {
+            String cellValue = cell.getValue();
+            if (cellValue != null)
+            {
+                cell.setValue((String) placeholderResolver.resolvePlaceholders(cellValue, String.class));
+            }
+        }));
+        return examplesTable.withRows(rows);
+    }
+}
@@ -42,15 +42,14 @@
 import org.jbehave.core.steps.StepMonitor;
 import org.vividus.bdd.IPathFinder;
 import org.vividus.bdd.batch.BatchResourceConfiguration;
-import org.vividus.bdd.steps.ExpressionAdaptor;
+import org.vividus.bdd.converter.ResolvingPlaceholdersExamplesTableConverter;
 import org.vividus.bdd.steps.ParameterConvertersDecorator;
-import org.vividus.bdd.steps.VariableResolver;
+import org.vividus.bdd.steps.PlaceholderResolver;
 
 public class ExtendedConfiguration extends Configuration
 {
     private IPathFinder pathFinder;
-    private VariableResolver variableResolver;
-    private ExpressionAdaptor expressionAdaptor;
+    private PlaceholderResolver placeholderResolver;
     private List<ParameterConverter<?, ?>> customConverters;
     private List<StepMonitor> stepMonitors;
     private Map<String, TableTransformer> customTableTransformers;
@@ -65,8 +64,10 @@ public void init() throws IOException
         initKeywords();
         initCompositePaths();
         useParameterControls(parameterControls);
-        useParameterConverters(new ParameterConvertersDecorator(this, variableResolver, expressionAdaptor)
+        useParameterConverters(new ParameterConvertersDecorator(this, placeholderResolver)
                 .addConverters(customConverters));
+        parameterConverters().addConverters(
+                new ResolvingPlaceholdersExamplesTableConverter(examplesTableFactory(), placeholderResolver));
         useStoryParser(new RegexStoryParser(examplesTableFactory()));
         TableTransformers transformers = tableTransformers();
         customTableTransformers.forEach(transformers::useTransformer);
@@ -129,9 +130,9 @@ public void setCompositePaths(String compositePaths)
         this.compositePaths = compositePaths;
     }
 
-    public void setVariableResolver(VariableResolver variableResolver)
+    public void setPlaceholderResolver(PlaceholderResolver placeholderResolver)
     {
-        this.variableResolver = variableResolver;
+        this.placeholderResolver = placeholderResolver;
     }
 
     @Inject
@@ -146,11 +147,6 @@ public void setCustomTableTransformers(Map<String, TableTransformer> customTable
         this.customTableTransformers = customTableTransformers;
     }
 
-    public void setExpressionAdaptor(ExpressionAdaptor expressionAdaptor)
-    {
-        this.expressionAdaptor = expressionAdaptor;
-    }
-
     public void setStoryControls(StoryControls storyControls)
     {
         this.storyControls = storyControls;

@@ -18,30 +18,21 @@
 
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
-import java.util.List;
-import java.util.Map;
 import java.util.Optional;
 
 import org.apache.commons.lang3.StringUtils;
 import org.jbehave.core.configuration.Configuration;
-import org.jbehave.core.model.ExamplesTable;
 import org.jbehave.core.steps.ParameterConverters;
 
 public class ParameterConvertersDecorator extends ParameterConverters
 {
-    private static final int MAX_DEPTH = 16;
+    private final PlaceholderResolver placeholderResolver;
 
-    private final VariableResolver variableResolver;
-
-    private final ExpressionAdaptor expressionAdaptor;
-
-    public ParameterConvertersDecorator(Configuration configuration, VariableResolver variableResolver,
-            ExpressionAdaptor expressionAdaptor)
+    public ParameterConvertersDecorator(Configuration configuration, PlaceholderResolver placeholderResolver)
     {
         super(configuration.stepMonitor(), configuration.keywords(), configuration.storyLoader(),
                 configuration.parameterControls(), configuration.tableTransformers());
-        this.variableResolver = variableResolver;
-        this.expressionAdaptor = expressionAdaptor;
+        this.placeholderResolver = placeholderResolver;
     }
 
     @Override
@@ -51,10 +42,10 @@ public Object convert(String value, Type type)
         {
             return super.convert(value, type);
         }
-        Object adaptedValue = resolvePlaceholders(value, type);
+        Object adaptedValue = placeholderResolver.resolvePlaceholders(value, type);
         if (type == String.class || adaptedValue instanceof String)
         {
-            adaptedValue = processExpressions(String.valueOf(adaptedValue));
+            adaptedValue = placeholderResolver.processExpressions(String.valueOf(adaptedValue));
         }
         return convertAdaptedValue(adaptedValue, type);
     }
@@ -83,59 +74,12 @@ private Object convertAdaptedValue(Object adaptedValue, Type type)
                         : Optional.of(super.convert(convertedValue, argType));
             }
         }
-        Object result = super.convert(convertedValue, type);
-        resolvePlaceholdersAfterConversion(type, result);
-        return result;
-    }
-
-    private void resolvePlaceholdersAfterConversion(Type type, Object result)
-    {
-        if (type == ExamplesTable.class)
-        {
-            ExamplesTable examplesTable = (ExamplesTable) result;
-            List<Map<String, String>> rows = examplesTable.getRows();
-            rows.forEach(
-                row -> row.entrySet().forEach(
-                    cell -> cell.setValue((String) resolvePlaceholders(cell.getValue(), String.class))
-                )
-            );
-            examplesTable.withRows(rows);
-        }
-    }
-
-    private Object resolvePlaceholders(String value, Type type)
-    {
-        return resolvePlaceholders(value, value, type, 1);
-    }
-
-    private Object resolvePlaceholders(String originalValue, String value, Type type, int iteration)
-    {
-        Object adaptedValue = variableResolver.resolve(value);
-        if (type == String.class || String.class.isInstance(adaptedValue))
-        {
-            adaptedValue = processExpressions(String.valueOf(adaptedValue));
-            if (!value.equals(adaptedValue) && adaptedValue instanceof String)
-            {
-                if (iteration == MAX_DEPTH)
-                {
-                    // If we reached max depth, then we see circular reference or variables have more than MAX_DEPTH
-                    // nested levels, we need to fallback to one cycle of variable resolution and exit early
-                    return variableResolver.resolve(originalValue);
-                }
-                return resolvePlaceholders(originalValue, (String) adaptedValue, type, iteration + 1);
-            }
-        }
-        return adaptedValue;
+        return super.convert(convertedValue, type);
     }
 
     private boolean isAssignableFrom(ParameterizedType parameterizedType, Class<?> clazz)
     {
         Type rawType = parameterizedType.getRawType();
         return rawType instanceof Class<?> && ((Class<?>) rawType).isAssignableFrom(clazz);
     }
-
-    private Object processExpressions(String valueToConvert)
-    {
-        return expressionAdaptor.processRawExpression(valueToConvert);
-    }
 }
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2019-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.vividus.bdd.steps;
+
+import java.lang.reflect.Type;
+
+public class PlaceholderResolver
+{
+    private static final int MAX_DEPTH = 16;
+
+    private final VariableResolver variableResolver;
+    private final ExpressionAdaptor expressionAdaptor;
+
+    public PlaceholderResolver(VariableResolver variableResolver, ExpressionAdaptor expressionAdaptor)
+    {
+        this.variableResolver = variableResolver;
+        this.expressionAdaptor = expressionAdaptor;
+    }
+
+    public Object resolvePlaceholders(String value, Type type)
+    {
+        return resolvePlaceholders(value, value, type, 1);
+    }
+
+    private Object resolvePlaceholders(String originalValue, String value, Type type, int iteration)
+    {
+        Object adaptedValue = variableResolver.resolve(value);
+        if (type == String.class || adaptedValue instanceof String)
+        {
+            adaptedValue = processExpressions(String.valueOf(adaptedValue));
+            if (!value.equals(adaptedValue) && adaptedValue instanceof String)
+            {
+                if (iteration == MAX_DEPTH)
+                {
+                    // If we reached max depth, then we see circular reference or variables have more than MAX_DEPTH
+                    // nested levels, we need to fallback to one cycle of variable resolution and exit early
+                    return variableResolver.resolve(originalValue);
+                }
+                return resolvePlaceholders(originalValue, (String) adaptedValue, type, iteration + 1);
+            }
+        }
+        return adaptedValue;
+    }
+
+    public Object processExpressions(String valueToConvert)
+    {
+        return expressionAdaptor.processRawExpression(valueToConvert);
+    }
+}
@@ -19,6 +19,7 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
+import java.util.regex.Pattern;
 
 import com.google.common.base.CaseFormat;
 
@@ -29,6 +30,7 @@
 public class VariableResolver
 {
     private static final String VARIABLE_START_MARKER = "${";
+    private static final String LINE_BREAKS = "[\r\n]*";
 
     private final IBddVariableContext bddVariableContext;
     private final Map<String, DynamicVariable> dynamicVariables;
@@ -137,7 +139,7 @@ private Object replaceVariableKeyWithValue(String target, String variableKey)
             return target;
         }
         String variablePlaceholder = VARIABLE_START_MARKER + variableKey + "}";
-        if (variablePlaceholder.equals(target))
+        if (target.matches(LINE_BREAKS + Pattern.quote(variablePlaceholder) + LINE_BREAKS))
         {
             return variableValue;
         }

@@ -64,16 +64,13 @@
         </property>
     </bean>
 
-    <bean id="expressionAdaptor" class="org.vividus.bdd.steps.ExpressionAdaptor" />
-
     <bean id="configuration" class="org.vividus.bdd.spring.ExtendedConfiguration"
         init-method="init">
         <property name="pathFinder" ref="pathFinder" />
         <property name="storyLoader" ref="storyLoader" />
         <property name="storyReporterBuilder" ref="storyReporterBuilder" />
-        <property name="variableResolver" ref="variableResolver" />
+        <property name="placeholderResolver" ref="placeholderResolver" />
         <property name="compositePaths" value="${bdd.configuration.all-composite-paths}"/>
-        <property name="expressionAdaptor" ref="expressionAdaptor" />
         <property name="storyControls" ref="springStoryControls" />
         <property name="parallelStoryExamplesEnabled" value="${bdd.configuration.parallel-story-examples-enabled}"/>
         <property name="examplesTableHeaderSeparator" value="${bdd.configuration.examples-table-header-separator}"/>
@@ -105,7 +102,9 @@
         <property name="generateViewAfterBatches" value="${bdd.generate-view-after-batches}" />
     </bean>
 
-    <bean id="variableResolver" class="org.vividus.bdd.steps.VariableResolver" />
+    <bean class="org.vividus.bdd.steps.VariableResolver" />
+    <bean class="org.vividus.bdd.steps.ExpressionAdaptor" />
+    <bean id="placeholderResolver" class="org.vividus.bdd.steps.PlaceholderResolver" />
     <bean id="parameterControls" class="org.jbehave.core.steps.ParameterControls" />
 
 </beans>