ExamplesTable.java

  1. package org.jbehave.core.model;

  3. import static java.lang.Boolean.parseBoolean;
  4. import static java.util.regex.Pattern.DOTALL;
  5. import static java.util.stream.Collectors.toList;
  6. import static org.apache.commons.lang3.Validate.isTrue;
  7. import static org.apache.commons.lang3.Validate.notBlank;

  9. import java.io.PrintStream;
  10. import java.lang.reflect.Type;
  11. import java.util.ArrayList;
  12. import java.util.Collections;
  13. import java.util.Deque;
  14. import java.util.LinkedHashMap;
  15. import java.util.LinkedList;
  16. import java.util.List;
  17. import java.util.Locale;
  18. import java.util.Map;
  19. import java.util.Optional;
  20. import java.util.Properties;
  21. import java.util.regex.Matcher;
  22. import java.util.regex.Pattern;
  23. import java.util.stream.Collectors;
  24. import java.util.stream.IntStream;
  25. import java.util.stream.Stream;

  27. import org.apache.commons.lang3.StringUtils;
  28. import org.apache.commons.lang3.builder.ToStringBuilder;
  29. import org.apache.commons.lang3.builder.ToStringStyle;
  30. import org.jbehave.core.configuration.Keywords;
  31. import org.jbehave.core.i18n.LocalizedKeywords;
  32. import org.jbehave.core.io.LoadFromClasspath;
  33. import org.jbehave.core.model.TableTransformers.TableTransformer;
  34. import org.jbehave.core.steps.ChainedRow;
  35. import org.jbehave.core.steps.ConvertedParameters;
  36. import org.jbehave.core.steps.ParameterControls;
  37. import org.jbehave.core.steps.ParameterConverters;
  38. import org.jbehave.core.steps.Parameters;
  39. import org.jbehave.core.steps.Row;

  41. /**
  42.  * Represents a tabular structure that holds rows of example data for parameters named via the column headers:
  43.  * <pre>
  44.  * |header 1|header 2| .... |header n|
  45.  * |value 11|value 12| .... |value 1n|
  46.  * ...
  47.  * |value m1|value m2| .... |value mn|
  48.  * </pre>
  49.  *
  50.  * <p>Different header and value column separators can be specified to replace the default separator "|":
  51.  * <pre>
  52.  * !!header 1!!header 2!! .... !!header n!!
  53.  * !value 11!value 12! .... !value 1n!
  54.  * ...
  55.  * !value m1!value m2| .... !value mn!
  56.  * </pre>
  57.  * </p>
  58.  *
  59.  * <p>Rows starting with an ignorable separator are allowed and ignored:
  60.  * <pre>
  61.  * |header 1|header 2| .... |header n|
  62.  * |-- A commented row --|
  63.  * |value 11|value 12| .... |value 1n|
  64.  * ...
  65.  * |-- Another commented row --|
  66.  * |value m1|value m2| .... |value mn|
  67.  * </pre>
  68.  * </p>
  69.  *
  70.  * <p>Ignorable separator is configurable and defaults to "|--".</p>
  71.  * <p>The separators are also configurable via inlined properties:
  72.  * <pre>
  73.  * {ignorableSeparator=!--,headerSeparator=!,valueSeparator=!}
  74.  * !header 1!header 2! .... !header n!
  75.  * !-- A commented row --!
  76.  * !value 11!value 12! .... !value 1n!
  77.  * ...
  78.  * !-- Another commented row --!
  79.  * !value m1!value m2! .... !value mn!
  80.  * </pre>
  81.  * </p>
  82.  *
  83.  * <p>By default all column values are trimmed. To avoid trimming the values, use the "trim" inlined property:
  84.  * <pre>
  85.  * {trim=false}
  86.  * | header 1 | header 2 | .... | header n |
  87.  * | value 11 | value 12 | .... | value 1n |
  88.  * </pre>
  89.  * </p>
  90.  * 
  91.  * <p>Comments is column values are supported via the "commentSeparator" inlined property:
  92.  * <pre>
  93.  * {commentSeparator=#}
  94.  * | header 1#comment | header 2 | .... | header n |
  95.  * | value 11#comment | value 12 | .... | value 1n |
  96.  * </pre>
  97.  * Comments including the separator are stripped.</p>
  98.  *
  99.  * <p>Line break is a default separator for rows in ExamplesTable, that's why they can't be added as is
  100.  * to the data. In order to put the value with line breaks to ExamplesTable escape sequences (a character preceded by a
  101.  * backslash (\) is an escape sequence) must be used.
  102.  * <table>
  103.  *  <thead><tr><th>Escape Sequence</th><th>Description</th></tr></thead>
  104.  *  <tbody>
  105.  *   <tr><td>\n</td><td>Insert a newline in the value at this point.</td></tr>
  106.  *   <tr><td>\r</td><td>Insert a carriage return in the text at this point.</td></tr>
  107.  *   <tr><td>\\</td><td>Insert a backslash character in the text at this point.</td></tr>
  108.  *  </tbody>
  109.  * </table>
  110.  * Inlined property <code>processEscapeSequences</code> defines whether escape sequences should be replaced in the data.
  111.  * It’s <code>false</code> by default (no property is declared explicitly). The allowed values are <code>true</code> and
  112.  * <code>false</code>, any other values are considered invalid and will lead to exception thrown at parsing.
  113.  * <pre>
  114.  * {processEscapeSequences=true, commentSeparator=#}
  115.  * |header          |
  116.  * |line 1\nline 2  |# The value with a newline
  117.  * |line 1\r\nline 2|# The value with a carriage return and a newline
  118.  * |line 1\\nline 2 |# The value with an escaped escape sequence, the result will be "line 1\nline 2"
  119.  * </pre>
  120.  * </p>
  121.  * 
  122.  * <p>The table allows the retrieval of row values as converted parameters. Use {@link #getRowAsParameters(int)} and
  123.  * invoke {@link Parameters#valueAs(String, Type)} specifying the header and the class type of the parameter.</p>
  124.  * 
  125.  * <p>The table allows the transformation of its string representation via the "transformer" inlined property
  126.  * (multiple transformers will be applied in chain-mode):
  127.  * <pre>
  128.  * {transformer=myTransformerName}
  129.  * {transformer=myOtherTransformerName}
  130.  * |header 1|header 2| .... |header n|
  131.  * |value 11|value 12| .... |value 1n|
  132.  * ...
  133.  * |value m1|value m2| .... |value mn|
  134.  * </pre>
  135.  * The transformers need to be registered by name via the
  136.  * {@link TableTransformers#useTransformer(String, TableTransformer)}. A few transformers are already registered by
  137.  * default in {@link TableTransformers}.</p>
  138.  * 
  139.  * <p>The table allow filtering on meta by row via the "metaByRow" inlined property:
  140.  * <pre>
  141.  * {metaByRow=true}
  142.  * | Meta:       | header 1 | .... | header n |
  143.  * | @name=value | value 11 | .... | value 1n |
  144.  * </pre>
  145.  * </p>
  146.  *
  147.  * <p>Once created, the table row can be modified, via the {@link #withRowValues(int, Map)} method, by specifying the
  148.  * map of row values to be changed.</p>
  149.  * 
  150.  * <p>A table can also be created by providing the entire data content, via the {@link #withRows(List)} method.</p>
  151.  *
  152.  * <p>The parsing code assumes that the number of columns for data rows is the same as in the header, if a row has
  153.  * less fields, the remaining are filled with empty values, if it has more, the fields are ignored.</p>
  154.  */
  155. public class ExamplesTable {
  156.     private static final Map<String, String> EMPTY_MAP = Collections.emptyMap();
  157.     private static final String EMPTY_VALUE = "";

  159.     public static final Pattern INLINED_PROPERTIES_PATTERN = Pattern.compile("\\{(.*?[^\\\\])\\}\\s*(.*)", DOTALL);
  160.     public static final ExamplesTable EMPTY = new ImmutableExamplesTable(EMPTY_VALUE);

  162.     private final ParameterConverters parameterConverters;
  163.     private final Row defaults;
  164.     private final TableRows tableRows;
  165.     private final Deque<TableProperties> tablePropertiesQueue = new LinkedList<>();

  167.     private Map<String, String> namedParameters = Collections.emptyMap();
  168.     private ParameterControls parameterControls;
  169.     private TableTransformerMonitor tableTransformerMonitor;

  171.     public ExamplesTable(String tableAsString) {
  172.         this(tableAsString, new TableTransformers());
  173.     }

  175.     private ExamplesTable(String tableAsString, TableTransformers tableTransformers) {
  176.         this(tableAsString, new ParameterConverters(new LoadFromClasspath(), tableTransformers), tableTransformers);
  177.     }

  179.     private ExamplesTable(String tableAsString, ParameterConverters parameterConverters,
  180.             TableTransformers tableTransformers) {
  181.         this(tableAsString, parameterConverters, new TableParsers(new LocalizedKeywords(), parameterConverters),
  182.                 tableTransformers);
  183.     }

  185.     private ExamplesTable(String tableAsString, ParameterConverters parameterConverters, TableParsers tableParsers,
  186.             TableTransformers tableTransformers) {
  187.         this(tableParsers.parseProperties(tableAsString), parameterConverters, new ParameterControls(), tableParsers,
  188.                 tableTransformers, new NullTableTransformerMonitor());
  189.     }

  191.     ExamplesTable(TablePropertiesQueue tablePropertiesQueue, ParameterConverters parameterConverters,
  192.                   ParameterControls parameterControls, TableParsers tableParsers, TableTransformers tableTransformers,
  193.                   TableTransformerMonitor tableTransformerMonitor) {
  194.         this.parameterConverters = parameterConverters;
  195.         this.parameterControls = parameterControls;
  196.         this.defaults = new ConvertedParameters(EMPTY_MAP, parameterConverters);
  197.         this.tablePropertiesQueue.addAll(tablePropertiesQueue.getProperties());
  198.         this.tableTransformerMonitor = tableTransformerMonitor;
  199.         String transformedTable = applyTransformers(tableTransformers, tablePropertiesQueue.getTable(), tableParsers);
  200.         this.tableRows = tableParsers.parseRows(transformedTable, lastTableProperties());
  201.     }

  203.     private TableProperties lastTableProperties() {
  204.         return tablePropertiesQueue.getLast();
  205.     }

  207.     private ExamplesTable(ExamplesTable other, Row defaults) {
  208.         this.tableRows = new TableRows(other.tableRows.getHeaders(),
  209.                 other.tableRows.getRows());
  210.         this.parameterConverters = other.parameterConverters;
  211.         this.tablePropertiesQueue.addAll(other.tablePropertiesQueue);
  212.         this.defaults = defaults;
  213.     }

  215.     private String applyTransformers(TableTransformers tableTransformers, String tableAsString,
  216.             TableParsers tableParsers) {
  217.         String transformedTable = tableAsString;
  218.         TableProperties previousProperties = null;
  219.         for (TableProperties properties : tablePropertiesQueue) {
  220.             String transformer = properties.getTransformer();
  221.             if (transformer != null) {
  222.                 if (previousProperties != null) {
  223.                     properties.overrideSeparatorsFrom(previousProperties);
  224.                 }
  225.                 tableTransformerMonitor.beforeTransformerApplying(transformer, properties, tableAsString);
  226.                 transformedTable = tableTransformers.transform(transformer, transformedTable, tableParsers, properties);
  227.                 tableTransformerMonitor.afterTransformerApplying(transformer, properties, transformedTable);
  228.             }
  229.             previousProperties = properties;
  230.         }
  231.         return transformedTable;
  232.     }

  234.     public ExamplesTable withDefaults(Parameters defaults) {
  235.         return new ExamplesTable(this, new ChainedRow(defaults, this.defaults));
  236.     }

  238.     public ExamplesTable withNamedParameters(Map<String, String> namedParameters) {
  239.         this.namedParameters = namedParameters;
  240.         return this;
  241.     }

  243.     public ExamplesTable withRowValues(int rowIndex, Map<String, String> values) {
  244.         for (String header : values.keySet()) {
  245.             if (!getHeaders().contains(header)) {
  246.                 getHeaders().add(header);
  247.             }
  248.         }
  249.         List<String> row = getRowValues(rowIndex);
  250.         List<String> headers = getHeaders();
  251.         for (int i = 0, headersSize = headers.size(); i < headersSize; i++) {
  252.             String value = values.get(headers.get(i));

  254.             if (i >= row.size()) {
  255.                 row.add(Optional.ofNullable(value).orElse(EMPTY_VALUE));
  256.             } else if (value != null) {
  257.                 row.set(i, value);
  258.             }
  259.         }
  260.         return this;
  261.     }

  263.     public ExamplesTable withRows(List<Map<String, String>> rows) {
  264.         tableRows.clear();
  265.         if (!rows.isEmpty()) {
  266.             getHeaders().addAll(rows.get(0).keySet());
  267.             rows.stream().map(Map::values).map(ArrayList::new).forEach(tableRows.rows::add);
  268.         }
  269.         return this;
  270.     }

  272.     public Properties getProperties() {
  273.         return lastTableProperties().getProperties();
  274.     }

  276.     public String getPropertiesAsString() {
  277.         return lastTableProperties().getPropertiesAsString();
  278.     }

  280.     private String replaceNamedParameters(String text) {
  281.         return parameterControls.replaceAllDelimitedNames(text, namedParameters);
  282.     }

  284.     private List<String> replaceNamedParameters(List<String> values, boolean replaceNamedParameters) {
  285.         return replaceNamedParameters ? values.stream().map(this::replaceNamedParameters).collect(toList()) : values;
  286.     }

  288.     public List<String> getHeaders() {
  289.         return tableRows.getHeaders();
  290.     }

  292.     public Map<String, String> getRow(int rowIndex) {
  293.         return getRow(rowIndex, false);
  294.     }

  296.     public Map<String, String> getRow(int rowIndex, boolean replaceNamedParameters) {
  297.         List<String> values = getRowValues(rowIndex, replaceNamedParameters);

  299.         if (!tableRows.areAllColumnsDistinct()) {
  300.             String exceptionMessage = "ExamplesTable contains non-distinct columns, all columns are: "
  301.                     + String.join(", ", getHeaders());
  302.             throw new NonDistinctColumnFound(exceptionMessage);
  303.         }

  305.         Map<String, String> result = new LinkedHashMap<>();
  306.         List<String> headers = getHeaders();
  307.         for (int i = 0, headersSize = headers.size(); i < headersSize; i++) {
  308.             result.put(headers.get(i), i < values.size() ? values.get(i) : EMPTY_VALUE);
  309.         }
  310.         return result;
  311.     }

  313.     public List<String> getRowValues(int rowIndex) {
  314.         return getRowValues(rowIndex, false);
  315.     }

  317.     public List<String> getRowValues(int rowIndex, boolean replaceNamedParameters) {
  318.         return replaceNamedParameters(tableRows.getRow(rowIndex), replaceNamedParameters);
  319.     }

  321.     public Parameters getRowAsParameters(int rowIndex) {
  322.         return getRowAsParameters(rowIndex, false);
  323.     }

  325.     public Parameters getRowAsParameters(int rowIndex, boolean replaceNamedParameters) {
  326.         Map<String, String> row = getRow(rowIndex, replaceNamedParameters);
  327.         return new ConvertedParameters(new ChainedRow(new ConvertedParameters(row, parameterConverters), defaults),
  328.                 parameterConverters);
  329.     }

  331.     public int getRowCount() {
  332.         return tableRows.getRows().size();
  333.     }

  335.     public boolean metaByRow() {
  336.         return lastTableProperties().isMetaByRow();
  337.     }

  339.     public List<Map<String, String>> getRows() {
  340.         List<Map<String, String>> rows = new ArrayList<>();
  341.         for (int row = 0; row < getRowCount(); row++) {
  342.             rows.add(getRow(row));
  343.         }
  344.         return rows;
  345.     }

  347.     public List<Parameters> getRowsAsParameters() {
  348.         return getRowsAsParameters(false);
  349.     }

  351.     public List<Parameters> getRowsAsParameters(boolean replaceNamedParameters) {
  352.         List<Parameters> rows = new ArrayList<>();

  354.         for (int row = 0; row < getRowCount(); row++) {
  355.             rows.add(getRowAsParameters(row, replaceNamedParameters));
  356.         }

  358.         return rows;
  359.     }

  361.     public <T> List<T> getRowsAs(Class<T> type) {
  362.         return getRowsAs(type, Collections.emptyMap());
  363.     }

  365.     public <T> List<T> getRowsAs(Class<T> type, Map<String, String> fieldNameMapping) {
  366.         return getRowsAsParameters().stream()
  367.                                     .map(p -> p.mapTo(type, fieldNameMapping))
  368.                                     .collect(toList());
  369.     }

  371.     public List<String> getColumn(String columnName) {
  372.         return getColumn(columnName, false);
  373.     }

  375.     public List<String> getColumn(String columnName, boolean replaceNamedParameters) {
  376.         return replaceNamedParameters(tableRows.getColumn(columnName), replaceNamedParameters);
  377.     }

  379.     public String getHeaderSeparator() {
  380.         return lastTableProperties().getHeaderSeparator();
  381.     }

  383.     public String getValueSeparator() {
  384.         return lastTableProperties().getValueSeparator();
  385.     }

  387.     public String asString() {
  388.         if (tableRows.getRows().isEmpty()) {
  389.             return EMPTY_VALUE;
  390.         }
  391.         StringBuilder sb = new StringBuilder();
  392.         for (TableProperties properties : tablePropertiesQueue) {
  393.             String propertiesAsString = properties.getPropertiesAsString();
  394.             if (!propertiesAsString.isEmpty()) {
  395.                 sb.append("{").append(propertiesAsString).append("}").append(lastTableProperties().getRowSeparator());
  396.             }
  397.         }
  398.         sb.append(ExamplesTableStringBuilder.buildExamplesTableString(lastTableProperties(), getHeaders(),
  399.                 tableRows.getRows()));

  401.         return sb.toString();
  402.     }

  404.     public boolean isEmpty() {
  405.         return getHeaders().isEmpty();
  406.     }

  408.     public void outputTo(PrintStream output) {
  409.         output.print(asString());
  410.     }

  412.     public static ExamplesTable empty() {
  413.         return new ExamplesTable("");
  414.     }

  416.     @Override
  417.     public String toString() {
  418.         return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
  419.     }

  421.     public static final class TableProperties {

  423.         public enum Decorator {
  424.             LOWERCASE, UPPERCASE, VERBATIM, TRIM
  425.         }

  427.         private static final String COMMA = ",";
  428.         private static final String COMMA_REGEX = "\\,";
  429.         private static final String EQUAL = "=";
  430.         private static final String PIPE_REGEX = "\\|";

  432.         private static final String DECORATORS_REGEX = Stream.of(Decorator.values())
  433.                 .map(Decorator::name)
  434.                 .collect(Collectors.joining("|", "(", ")"));

  436.         private static final Pattern DECORATED_PROPERTY_PATTERN = Pattern.compile(
  437.                 "\\s*\\{([^=,\\s]+(\\|" + DECORATORS_REGEX + ")*)}\\s*", Pattern.CASE_INSENSITIVE);

  439.         private static final String HEADER_SEPARATOR_KEY = "headerSeparator";
  440.         private static final String VALUE_SEPARATOR_KEY = "valueSeparator";
  441.         private static final String IGNORABLE_SEPARATOR_KEY = "ignorableSeparator";
  442.         private static final String COMMENT_SEPARATOR_KEY = "commentSeparator";
  443.         private static final String NULL_PLACEHOLDER_KEY = "nullPlaceholder";
  444.         private static final String PROCESS_ESCAPE_SEQUENCES_KEY = "processEscapeSequences";

  446.         private static final String ROW_SEPARATOR = "\n";

  448.         private final Properties properties = new Properties();
  449.         private final ParameterConverters parameterConverters;
  450.         private final String propertiesAsString;

  452.         public TableProperties(String propertiesAsString, Keywords keywords, ParameterConverters parameterConverters) {
  453.             this.propertiesAsString = propertiesAsString;
  454.             this.parameterConverters = parameterConverters;
  455.             properties.setProperty(HEADER_SEPARATOR_KEY, keywords.examplesTableHeaderSeparator());
  456.             properties.setProperty(VALUE_SEPARATOR_KEY, keywords.examplesTableValueSeparator());
  457.             properties.setProperty(IGNORABLE_SEPARATOR_KEY, keywords.examplesTableIgnorableSeparator());
  458.             properties.putAll(parseProperties(propertiesAsString));
  459.         }

  461.         private Map<String, String> parseProperties(String propertiesAsString) {
  462.             Map<String, String> result = new LinkedHashMap<>();
  463.             if (!StringUtils.isEmpty(propertiesAsString)) {
  464.                 for (String propertyAsString : propertiesAsString.split("(?<!\\\\),")) {
  465.                     String[] property = StringUtils.split(propertyAsString, EQUAL, 2);
  466.                     String propertyName = property[0];
  467.                     String propertyValue = property[1];
  468.                     Matcher decoratedPropertyMatcher = DECORATED_PROPERTY_PATTERN.matcher(propertyName);
  469.                     if (decoratedPropertyMatcher.matches()) {
  470.                         String[] propertyWithDecorators = decoratedPropertyMatcher.group(1).split(PIPE_REGEX);
  471.                         propertyName = propertyWithDecorators[0];
  472.                         for (int i = 1; i < propertyWithDecorators.length; i++) {
  473.                             String decorator = propertyWithDecorators[i].toUpperCase();
  474.                             propertyValue = decoratePropertyValue(propertyValue, Decorator.valueOf(decorator));
  475.                         }
  476.                     } else {
  477.                         propertyValue = propertyValue.trim();
  478.                     }
  479.                     result.put(propertyName.trim(), StringUtils.replace(propertyValue, COMMA_REGEX, COMMA));
  480.                 }
  481.             }
  482.             return result;
  483.         }

  485.         private String decoratePropertyValue(String value, Decorator decorator) {
  486.             switch (decorator) {
  487.                 case VERBATIM:
  488.                     return value;
  489.                 case LOWERCASE:
  490.                     return value.toLowerCase();
  491.                 case UPPERCASE:
  492.                     return value.toUpperCase();
  493.                 case TRIM:
  494.                 default:
  495.                     return value.trim();
  496.             }
  497.         }

  499.         @SuppressWarnings("unchecked")
  500.         public <T> T getMandatoryNonBlankProperty(String propertyName, Type type) {
  501.             String propertyValue = properties.getProperty(propertyName);
  502.             isTrue(propertyValue != null, "'%s' is not set in ExamplesTable properties", propertyName);
  503.             notBlank(propertyValue, "ExamplesTable property '%s' is blank", propertyName);
  504.             return (T) parameterConverters.convert(propertyValue, type);
  505.         }

  507.         public String getRowSeparator() {
  508.             return ROW_SEPARATOR;
  509.         }

  511.         public String getHeaderSeparator() {
  512.             return properties.getProperty(HEADER_SEPARATOR_KEY);
  513.         }

  515.         public String getValueSeparator() {
  516.             return properties.getProperty(VALUE_SEPARATOR_KEY);
  517.         }

  519.         public String getIgnorableSeparator() {
  520.             return properties.getProperty(IGNORABLE_SEPARATOR_KEY);
  521.         }

  523.         public String getCommentSeparator() {
  524.             return properties.getProperty(COMMENT_SEPARATOR_KEY);
  525.         }

  527.         public Optional<String> getNullPlaceholder() {
  528.             return Optional.ofNullable(properties.getProperty(NULL_PLACEHOLDER_KEY));
  529.         }

  531.         public boolean isProcessEscapeSequences() {
  532.             String processEscapeSequences = properties.getProperty(PROCESS_ESCAPE_SEQUENCES_KEY);
  533.             if (processEscapeSequences != null) {
  534.                 String processEscapeSequencesTrimmed = processEscapeSequences.trim().toLowerCase(Locale.ENGLISH);
  535.                 if ("true".equals(processEscapeSequencesTrimmed)) {
  536.                     return true;
  537.                 }
  538.                 if ("false".equals(processEscapeSequencesTrimmed)) {
  539.                     return false;
  540.                 }
  541.                 throw new IllegalArgumentException(
  542.                         "ExamplesTable property 'processEscapeSequences' contains invalid value: '"
  543.                                 + processEscapeSequences + "', but allowed values are 'true' and 'false'");
  544.             }
  545.             return false;
  546.         }

  548.         void overrideSeparatorsFrom(TableProperties properties) {
  549.             Stream.of(HEADER_SEPARATOR_KEY, VALUE_SEPARATOR_KEY, IGNORABLE_SEPARATOR_KEY, COMMENT_SEPARATOR_KEY)
  550.                   .forEach(key -> {
  551.                       String value = properties.properties.getProperty(key);
  552.                       if (value != null) {
  553.                           this.properties.setProperty(key, value);
  554.                       }
  555.                   });
  556.         }

  558.         public boolean isTrim() {
  559.             return parseBoolean(properties.getProperty("trim", "true"));
  560.         }

  562.         public boolean isMetaByRow() {
  563.             return parseBoolean(properties.getProperty("metaByRow", "false"));
  564.         }

  566.         public String getTransformer() {
  567.             return properties.getProperty("transformer");
  568.         }

  570.         public Properties getProperties() {
  571.             return properties;
  572.         }

  574.         public String getPropertiesAsString() {
  575.             return propertiesAsString;
  576.         }
  577.     }

  579.     static final class TablePropertiesQueue {
  580.         private final String table;
  581.         private final Deque<TableProperties> properties;

  583.         TablePropertiesQueue(String table, Deque<TableProperties> properties) {
  584.             this.table = table;
  585.             this.properties = properties;
  586.         }

  588.         String getTable() {
  589.             return table;
  590.         }

  592.         Deque<TableProperties> getProperties() {
  593.             return properties;
  594.         }
  595.     }

  597.     public static final class TableRows {
  598.         private final List<String> headers;
  599.         private final List<List<String>> rows;
  600.         private final boolean allColumnsDistinct;

  602.         public TableRows(List<String> headers, List<List<String>> rows) {
  603.             this.headers = headers;
  604.             this.rows = rows;
  605.             this.allColumnsDistinct = headers.stream().distinct().count() == headers.size();
  606.         }

  608.         public List<String> getHeaders() {
  609.             return headers;
  610.         }

  612.         public List<List<String>> getRows() {
  613.             return rows;
  614.         }

  616.         private boolean areAllColumnsDistinct() {
  617.             return allColumnsDistinct;
  618.         }

  620.         private void clear() {
  621.             headers.clear();
  622.             rows.clear();
  623.         }

  625.         private List<String> getRow(int rowIndex) {
  626.             if (rowIndex > rows.size() - 1) {
  627.                 throw new RowNotFound(rowIndex);
  628.             }
  629.             return rows.get(rowIndex);
  630.         }

  632.         private List<String> getColumn(int columnIndex) {
  633.             return rows.stream().map(row -> row.get(columnIndex)).collect(toList());
  634.         }

  636.         private List<String> getColumn(String columnName) {
  637.             int[] headerIndexes = IntStream.range(0, headers.size()).filter(i -> headers.get(i).equals(columnName))
  638.                     .toArray();
  639.             long headerCount = headerIndexes.length;
  640.             if (headerCount == 0) {
  641.                 throw new ColumnNotFound(columnName);
  642.             } else if (headerCount > 1) {
  643.                 throw new NonDistinctColumnFound(columnName, headerCount);
  644.             }
  645.             return getColumn(headerIndexes[0]);
  646.         }
  647.     }

  649.     public static class RowNotFound extends RuntimeException {
  650.         static final long serialVersionUID = 6577709350720827070L;

  652.         public RowNotFound(int rowIndex) {
  653.             super(Integer.toString(rowIndex));
  654.         }
  655.     }

  657.     public static class ColumnNotFound extends RuntimeException {
  658.         static final long serialVersionUID = -6008855238823273059L;

  660.         public ColumnNotFound(String columnName) {
  661.             super(String.format("The '%s' column does not exist", columnName));
  662.         }
  663.     }

  665.     public static class NonDistinctColumnFound extends RuntimeException {
  666.         static final long serialVersionUID = -6898791308443992005L;

  668.         public NonDistinctColumnFound(String columnName, long totalColumnCount) {
  669.             super(String.format("There are %d columns with the name '%s'", totalColumnCount, columnName));
  670.         }

  672.         public NonDistinctColumnFound(String message) {
  673.             super(message);
  674.         }
  675.     }
  676. }
Created with JaCoCo 0.8.10.202304240956