TableTransformers.java

  1. package org.jbehave.core.model;

  3. import static java.util.stream.Collectors.joining;

  5. import java.util.ArrayList;
  6. import java.util.HashMap;
  7. import java.util.LinkedHashMap;
  8. import java.util.List;
  9. import java.util.Map;
  10. import java.util.regex.Matcher;
  11. import java.util.regex.Pattern;
  12. import java.util.stream.Collectors;
  13. import java.util.stream.IntStream;

  15. import org.apache.commons.lang3.StringUtils;
  16. import org.apache.commons.lang3.Validate;
  17. import org.jbehave.core.model.ExamplesTable.TableProperties;
  18. import org.jbehave.core.model.ExamplesTable.TableRows;
  19. import org.jbehave.core.steps.ParameterControls;

  21. /**
  22.  * <p>
  23.  * Facade responsible for transforming table string representations. It allows
  24.  * the registration of several {@link TableTransformer} instances by name.
  25.  * </p>
  26.  * <p>
  27.  * Some Transformers are provided out-of-the-box:
  28.  * <ul>
  29.  * <li>{@link TableTransformers.FromLandscape FromLandscape}: registered under
  30.  * name {@link TableTransformers#FROM_LANDSCAPE}</li>
  31.  * <li>{@link TableTransformers.Formatting Formatting}: registered under name
  32.  * {@link TableTransformers#FORMATTING}</li>
  33.  * <li>{@link TableTransformers.Replacing Replacing}: registered under name
  34.  * {@link TableTransformers#REPLACING}</li>
  35.  * </ul>
  36.  * Out-of-the-box transformers that must be registered:
  37.  * <ul>
  38.  * <li>{@link ResolvingSelfReferences ResolvingSelfReferences}
  39.  * </ul>
  40.  * </p>
  41.  */
  42. public class TableTransformers {

  44.     public static final String FROM_LANDSCAPE = "FROM_LANDSCAPE";
  45.     public static final String FORMATTING = "FORMATTING";
  46.     public static final String REPLACING = "REPLACING";

  48.     private final Map<String, TableTransformer> transformers = new HashMap<>();

  50.     public TableTransformers() {
  51.         useTransformer(FROM_LANDSCAPE, new FromLandscape());
  52.         useTransformer(FORMATTING, new Formatting());
  53.         useTransformer(REPLACING, new Replacing());
  54.     }

  56.     public String transform(String transformerName, String tableAsString, TableParsers tableParsers,
  57.             TableProperties properties) {
  58.         TableTransformer tableTransformer = transformers.get(transformerName);
  59.         if (tableTransformer == null) {
  60.             throw new TransformerNotFoundException(transformerName);
  61.         }
  62.         String result = tableTransformer.transform(tableAsString, tableParsers, properties);
  63.         if (result == null) {
  64.             throw new InvalidTransformationResultException(
  65.                     String.format("Table transformation using transformer '%s' resulted in 'null'", transformerName));
  66.         }
  67.         return result;
  68.     }

  70.     public void useTransformer(String name, TableTransformer transformer) {
  71.         transformers.put(name, transformer);
  72.     }

  74.     public interface TableTransformer {
  75.         String transform(String tableAsString, TableParsers tableParsers, TableProperties properties);
  76.     }

  78.     public static class FromLandscape implements TableTransformer {

  80.         @Override
  81.         public String transform(String tableAsString, TableParsers tableParsers, TableProperties properties) {
  82.             Map<String, List<String>> data = new LinkedHashMap<>();
  83.             for (String rowAsString : tableAsString.split(properties.getRowSeparator())) {
  84.                 if (ignoreRow(rowAsString, properties.getIgnorableSeparator())) {
  85.                     continue;
  86.                 }
  87.                 List<String> values = tableParsers.parseRow(rowAsString, false, properties);
  88.                 String header = values.get(0);
  89.                 List<String> rowValues = new ArrayList<>(values);
  90.                 rowValues.remove(0);
  91.                 data.put(header, rowValues);
  92.             }

  94.             if (data.values().stream().mapToInt(List::size).distinct().count() != 1) {
  95.                 String errorMessage = data.entrySet()
  96.                         .stream()
  97.                         .map(e -> {
  98.                             int numberOfCells = e.getValue().size();
  99.                             StringBuilder rowDescription = new StringBuilder(e.getKey())
  100.                                     .append(" -> ")
  101.                                     .append(numberOfCells)
  102.                                     .append(" cell");
  103.                             if (numberOfCells > 1) {
  104.                                 rowDescription.append('s');
  105.                             }
  106.                             return rowDescription.toString();
  107.                         })
  108.                         .collect(joining(", ", "The table rows have unequal numbers of cells: ", ""));
  109.                 throw new IllegalArgumentException(errorMessage);
  110.             }

  112.             StringBuilder builder = new StringBuilder();
  113.             builder.append(properties.getHeaderSeparator());
  114.             for (String header : data.keySet()) {
  115.                 builder.append(header).append(properties.getHeaderSeparator());
  116.             }
  117.             builder.append(properties.getRowSeparator());
  118.             int numberOfCells = data.values().iterator().next().size();
  119.             for (int c = 0; c < numberOfCells; c++) {
  120.                 builder.append(properties.getValueSeparator());
  121.                 for (List<String> row : data.values()) {
  122.                     builder.append(row.get(c)).append(properties.getValueSeparator());
  123.                 }
  124.                 builder.append(properties.getRowSeparator());
  125.             }
  126.             return builder.toString();
  127.         }

  129.         private boolean ignoreRow(String rowAsString, String ignorableSeparator) {
  130.             return rowAsString.startsWith(ignorableSeparator)
  131.                     || rowAsString.length() == 0;
  132.         }

  134.     }

  136.     public static class Formatting implements TableTransformer {

  138.         @Override
  139.         public String transform(String tableAsString, TableParsers tableParsers, TableProperties properties) {
  140.             List<List<String>> data = new ArrayList<>();
  141.             for (String rowAsString : tableAsString.split(properties.getRowSeparator())) {
  142.                 if (ignoreRow(rowAsString, properties.getIgnorableSeparator())) {
  143.                     continue;
  144.                 }
  145.                 data.add(tableParsers.parseRow(rowAsString, rowAsString.contains(properties.getHeaderSeparator()),
  146.                         properties));
  147.             }

  149.             StringBuilder builder = new StringBuilder();
  150.             Map<Integer, Integer> maxWidths = maxWidth(data);
  151.             for (int r = 0; r < data.size(); r++) {
  152.                 String formattedRow = formatRow(data.get(r), maxWidths,
  153.                         r == 0 ? properties.getHeaderSeparator() : properties.getValueSeparator());
  154.                 builder.append(formattedRow).append(properties.getRowSeparator());
  155.             }
  156.             return builder.toString();
  157.         }

  159.         private boolean ignoreRow(String rowAsString, String ignorableSeparator) {
  160.             return rowAsString.startsWith(ignorableSeparator)
  161.                     || rowAsString.length() == 0;
  162.         }

  164.         private Map<Integer, Integer> maxWidth(List<List<String>> data) {
  165.             Map<Integer, Integer> maxWidths = new HashMap<>();
  166.             for (List<String> row : data) {
  167.                 for (int c = 0; c < row.size(); c++) {
  168.                     String cell = row.get(c).trim();
  169.                     Integer width = maxWidths.get(c);
  170.                     int length = cell.length();
  171.                     if (width == null || length > width) {
  172.                         width = length;
  173.                         maxWidths.put(c, width);
  174.                     }
  175.                 }
  176.             }

  178.             return maxWidths;
  179.         }

  181.         private String formatRow(List<String> row,
  182.                 Map<Integer, Integer> maxWidths, String separator) {
  183.             StringBuilder builder = new StringBuilder();
  184.             builder.append(separator);
  185.             for (int c = 0; c < row.size(); c++) {
  186.                 builder.append(formatValue(row.get(c).trim(), maxWidths.get(c)))
  187.                         .append(separator);
  188.             }
  189.             return builder.toString();
  190.         }

  192.         private String formatValue(String value, int width) {
  193.             if (value.length() < width) {
  194.                 return value + padding(width - value.length());
  195.             }
  196.             return value;
  197.         }

  199.         private String padding(int size) {
  200.             StringBuilder builder = new StringBuilder();
  201.             for (int i = 0; i < size; i++) {
  202.                 builder.append(' ');
  203.             }
  204.             return builder.toString();
  205.         }

  207.     }

  209.     public static class Replacing implements TableTransformer {

  211.         @Override
  212.         public String transform(String tableAsString, TableParsers tableParsers, TableProperties properties) {
  213.             String replacing = properties.getProperties().getProperty("replacing");
  214.             String replacement = properties.getProperties().getProperty("replacement");
  215.             if (replacing == null || replacement == null) {
  216.                 return tableAsString;
  217.             }
  218.             return tableAsString.replace(replacing, replacement);
  219.         }
  220.     }

  222.     public static class ResolvingSelfReferences implements TableTransformer {
  223.         private final ParameterControls parameterControls;
  224.         private final Pattern placeholderPattern;

  226.         public ResolvingSelfReferences(ParameterControls parameterControls) {
  227.             this.parameterControls = parameterControls;
  228.             placeholderPattern = Pattern.compile(
  229.                     parameterControls.nameDelimiterLeft() + "(.*?)" + parameterControls.nameDelimiterRight());
  230.         }

  232.         @Override
  233.         public String transform(String tableAsString, TableParsers tableParsers, TableProperties properties) {
  234.             TableRows rows = tableParsers.parseRows(tableAsString, properties);
  235.             List<String> headers = rows.getHeaders();

  237.             List<List<String>> resolvedRows = getNamedRows(rows.getRows(), headers).stream()
  238.                     .map(this::resolveRow)
  239.                     .collect(Collectors.toList());

  241.             return ExamplesTableStringBuilder.buildExamplesTableString(properties, headers, resolvedRows);
  242.         }

  244.         private List<String> resolveRow(Map<String, String> unresolvedRow) {
  245.             Map<String, String> resolvedRow = new HashMap<>(unresolvedRow.size(), 1);
  246.             return unresolvedRow.keySet().stream()
  247.                     .map(name -> resolveCell(name, resolvedRow, unresolvedRow))
  248.                     .collect(Collectors.toList());
  249.         }

  251.         private String resolveCell(String name, Map<String, String> resolvedRow, Map<String, String> unresolvedRow) {
  252.             return resolveCell(name, new ArrayList<>(), resolvedRow, unresolvedRow);
  253.         }

  255.         private String resolveCell(String name, List<String> resolutionChain, Map<String, String> resolvedRow,
  256.                                    Map<String, String> unresolvedRow) {
  257.             if (resolvedRow.containsKey(name)) {
  258.                 return resolvedRow.get(name);
  259.             }
  260.             resolutionChain.add(name);
  261.             String result = unresolvedRow.get(name);
  262.             Matcher matcher = placeholderPattern.matcher(result);
  263.             while (matcher.find()) {
  264.                 String nestedName = matcher.group(1);
  265.                 Validate.validState(!name.equals(nestedName), "Circular self reference is found in column '%s'", name);
  266.                 checkForCircularChainOfReferences(resolutionChain, nestedName);
  267.                 if (unresolvedRow.containsKey(nestedName)) {
  268.                     resolveCell(nestedName, resolutionChain, resolvedRow, unresolvedRow);
  269.                 }
  270.                 result = StringUtils.replace(result,
  271.                         parameterControls.nameDelimiterLeft() + nestedName + parameterControls.nameDelimiterRight(),
  272.                         resolvedRow.get(nestedName));
  273.             }
  274.             resolvedRow.put(name, result);
  275.             return result;
  276.         }

  278.         private void checkForCircularChainOfReferences(List<String> resolutionChain, String name) {
  279.             int index = resolutionChain.indexOf(name);
  280.             if (index >= 0) {
  281.                 String delimiter = " -> ";
  282.                 String truncatedChain = resolutionChain.stream().skip(index).collect(Collectors.joining(delimiter));
  283.                 throw new IllegalStateException(
  284.                         "Circular chain of references is found: " + truncatedChain + delimiter + name);
  285.             }
  286.         }

  288.         private List<Map<String, String>> getNamedRows(List<List<String>> tableRows, List<String> tableHeaders) {
  289.             List<Map<String, String>> namedRows = new ArrayList<>();
  290.             for (List<String> row : tableRows) {
  291.                 Map<String, String> namedRow = new LinkedHashMap<>();
  292.                 IntStream.range(0, row.size()).forEach(i -> namedRow.put(tableHeaders.get(i), row.get(i)));
  293.                 namedRows.add(namedRow);
  294.             }
  295.             return namedRows;
  296.         }
  297.     }

  299.     public static class TransformerNotFoundException extends RuntimeException {
  300.         private static final long serialVersionUID = 3742264745351414296L;

  302.         public TransformerNotFoundException(String transformerName) {
  303.             super(String.format("Table transformer '%s' does not exist", transformerName));
  304.         }
  305.     }

  307.     public static class InvalidTransformationResultException extends RuntimeException {
  308.         private static final long serialVersionUID = -1242448321325167977L;

  310.         public InvalidTransformationResultException(String message) {
  311.             super(message);
  312.         }
  313.     }
  314. }
Created with JaCoCo 0.8.10.202304240956