MetadataValidatorImpl.java

/*******************************************************************************
 * (c) Copyright 2016 Hewlett-Packard Development Company, L.P.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Apache License v2.0 which accompany this distribution.
 *
 * The Apache License is available at
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 *******************************************************************************/
package io.cloudslang.lang.compiler.parser.utils;

import io.cloudslang.lang.compiler.SlangSource;
import io.cloudslang.lang.compiler.parser.MetadataParser;
import io.cloudslang.lang.compiler.parser.model.ParsedDescriptionData;
import io.cloudslang.lang.compiler.parser.model.ParsedDescriptionSection;
import io.cloudslang.lang.compiler.utils.MetadataUtils;
import io.cloudslang.lang.compiler.utils.SlangSourceUtils;
import io.cloudslang.lang.compiler.validator.matcher.DescriptionPatternMatcher;
import io.cloudslang.lang.entities.constants.Regex;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.apache.commons.lang3.Validate;
import org.apache.commons.lang3.tuple.Pair;

public class MetadataValidatorImpl implements MetadataValidator {

    private MetadataParser metadataParser;
    private DescriptionPatternMatcher descriptionPatternMatcher;

    public MetadataValidatorImpl() {
        descriptionPatternMatcher = new DescriptionPatternMatcher();
    }

    @Override
    public List<RuntimeException> validateCheckstyle(SlangSource source) {
        Validate.notNull(source.getContent(), "Source " + source.getName() + " cannot be null");
        try {
            return extractCheckstyleData(source);
        } catch (Throwable e) {
            throw new RuntimeException(
                    "There was a problem extracting checkstyle data for source [" +
                            source.getName() + "]  - " + e.getMessage(), e
            );
        }
    }

    private List<RuntimeException> extractCheckstyleData(SlangSource source) {
        List<String> lines = SlangSourceUtils.readLines(source);
        ParsedDescriptionData parsedDescriptionData = metadataParser.parse(source);
        List<RuntimeException> errors = new ArrayList<>();

        // process flow descriptions
        List<ParsedDescriptionSection> topLevelDescriptions = parsedDescriptionData.getTopLevelDescriptions();
        for (ParsedDescriptionSection topLevelDescription : topLevelDescriptions) {
            errors.addAll(processCommonRules(lines, topLevelDescription, false));
        }

        // process step descriptions
        Collection<ParsedDescriptionSection> stepDescriptions = parsedDescriptionData.getStepDescriptions().values();
        for (ParsedDescriptionSection stepDescription : stepDescriptions) {
            errors.addAll(processCommonRules(lines, stepDescription, true));
        }

        return errors;
    }

    private List<RuntimeException> processCommonRules(
            List<String> lines,
            ParsedDescriptionSection parsedDescriptionSection,
            boolean isStep) {
        List<RuntimeException> errors = new ArrayList<>();
        int startLineNumberZeroBased = parsedDescriptionSection.getStartLineNumber() - 1;

        // validate begin wrapper line
        validateBeginWrapperLine(lines, isStep, errors, startLineNumberZeroBased);

        boolean finished = false;
        String previousTag = null;
        int previousItemEndLineNumber = -1;
        for (int lineNrZeroBased = startLineNumberZeroBased + 1;
             !finished && lineNrZeroBased < lines.size();
             lineNrZeroBased++) {
            String currentLine = lines.get(lineNrZeroBased);

            // #! @tag var: content
            // #! @tag: content
            boolean variableLine = isVariableLine(currentLine);
            boolean isGeneralLine = isGeneralLine(currentLine);
            if (variableLine || isGeneralLine || isVariableLineDeclarationOnly(currentLine)) {
                // extract tag
                String currentTag;
                if (variableLine) {
                    Pair<String, String> declaration =
                            descriptionPatternMatcher.getDescriptionVariableLineData(currentLine);
                    String[] declarationElements = descriptionPatternMatcher.splitDeclaration(declaration.getLeft());
                    currentTag = declarationElements[0];
                } else if (isGeneralLine) {
                    Pair<String, String> declaration =
                            descriptionPatternMatcher.getDescriptionGeneralLineData(currentLine);
                    String[] declarationElements = descriptionPatternMatcher.splitDeclaration(declaration.getLeft());
                    currentTag = declarationElements[0];
                } else {
                    Pair<String, String> declaration =
                            descriptionPatternMatcher.getDescriptionVariableLineDataDeclarationOnly(currentLine);
                    String[] declarationElements = descriptionPatternMatcher.splitDeclaration(declaration.getLeft());
                    currentTag = declarationElements[0];
                }

                // validate empty line
                validateEmptyLine(lines, errors, previousTag, previousItemEndLineNumber, currentTag);

                previousTag = currentTag;
                previousItemEndLineNumber = lineNrZeroBased;
            } else {
                // #! continued from previous line
                if (isNonEmptyComplementaryLine(currentLine)) {
                    previousItemEndLineNumber = lineNrZeroBased;
                } else {
                    // #!!#
                    if (descriptionPatternMatcher.matchesDescriptionEnd(currentLine)) {
                        // validate ending wrapper line
                        validateEndingWrapperLine(lines, isStep, errors, lineNrZeroBased);

                        finished = true;
                    }
                    // otherwise ignore
                }
            }
        }
        return errors;
    }

    private void validateEndingWrapperLine(
            List<String> lines,
            boolean isStep,
            List<RuntimeException> errors,
            int lineNrZeroBased) {
        int targetedLineNumberZeroBased = lineNrZeroBased + 1;
        String nextLine = tryExtractLine(lines, targetedLineNumberZeroBased);
        if (isStep) {
            if (nextLine == null || !descriptionPatternMatcher.matchesStepDelimiterLine(nextLine)) {
                errors.add(
                        new RuntimeException(
                                generateErrorMessage(lineNrZeroBased,
                                        "Next line should be delimiter line (90 characters of `#`)"
                                )
                        )
                );
            }
        } else {
            if (nextLine == null || !descriptionPatternMatcher.matchesExecutableDelimiterLine(nextLine)) {
                errors.add(
                        new RuntimeException(
                                generateErrorMessage(lineNrZeroBased,
                                        "Next line should be delimiter line (120 characters of `#`)"
                                )
                        )
                );
            }
        }
    }

    private void validateEmptyLine(
            List<String> lines,
            List<RuntimeException> errors,
            String previousTag,
            int previousItemEndLineNumber,
            String currentTag) {
        if (previousTag != null && !previousTag.equals(currentTag)) {
            int targetedLineNumberZeroBased = previousItemEndLineNumber + 1;
            String targetedLine = lines.get(targetedLineNumberZeroBased);
            if (!descriptionPatternMatcher.matchesEmptyLine(targetedLine)) {
                errors.add(
                        new RuntimeException(
                                generateErrorMessage(
                                        targetedLineNumberZeroBased,
                                        "There should be an empty line between two sections of different tags" +
                                                " (" + previousTag + " and " + currentTag + ")"
                                )
                        )
                );
            }
        }
    }

    private void validateBeginWrapperLine(
            List<String> lines,
            boolean isStep,
            List<RuntimeException> errors,
            int startLineNumberZeroBased) {
        int targetedLineNumberZeroBased = startLineNumberZeroBased - 1;
        String previousLine = tryExtractLine(lines, targetedLineNumberZeroBased);
        if (isStep) {
            if (previousLine == null || !descriptionPatternMatcher.matchesStepDelimiterLine(previousLine)) {
                errors.add(
                        new RuntimeException(
                                generateErrorMessage(startLineNumberZeroBased,
                                        "Previous line should be delimiter line (90 characters of `#`)"
                                )
                        )
                );
            }
        } else {
            if (previousLine == null || !descriptionPatternMatcher.matchesExecutableDelimiterLine(previousLine)) {
                errors.add(
                        new RuntimeException(
                                generateErrorMessage(startLineNumberZeroBased,
                                        "Previous line should be delimiter line (120 characters of `#`)"
                                )
                        )
                );
            }
        }
    }

    private String generateErrorMessage(int lineNumberZeroBased, String data) {
        return MetadataUtils.generateErrorMessage(lineNumberZeroBased, data);
    }

    private boolean isNonEmptyComplementaryLine(String currentLine) {
        return
                descriptionPatternMatcher.matchesDescriptionComplementaryLine(currentLine) &&
                        !currentLine.trim().equals(Regex.DESCRIPTION_TOKEN);
    }

    private boolean isGeneralLine(String currentLine) {
        return descriptionPatternMatcher.matchesDescriptionGeneralLine(currentLine);
    }

    private boolean isVariableLine(String currentLine) {
        return descriptionPatternMatcher.matchesDescriptionVariableLine(currentLine);
    }

    private boolean isVariableLineDeclarationOnly(String currentLine) {
        return descriptionPatternMatcher.matchesVariableLineDeclarationOnlyLine(currentLine);
    }

    private String tryExtractLine(List<String> lines, int lineNr) {
        if (lineNr >= 0 && lineNr < lines.size()) {
            return lines.get(lineNr);
        }
        return null;
    }

    public void setMetadataParser(MetadataParser metadataParser) {
        this.metadataParser = metadataParser;
    }

}