RegexStoryParser.java

  1. package org.jbehave.core.parsers;

  3. import static java.util.Arrays.asList;
  4. import static java.util.regex.Pattern.DOTALL;
  5. import static java.util.regex.Pattern.compile;
  6. import static org.apache.commons.lang3.StringUtils.removeStart;

  8. import java.util.ArrayList;
  9. import java.util.Arrays;
  10. import java.util.List;
  11. import java.util.regex.Matcher;
  12. import java.util.regex.Pattern;

  14. import org.apache.commons.lang3.StringUtils;
  15. import org.jbehave.core.annotations.AfterScenario.Outcome;
  16. import org.jbehave.core.annotations.Scope;
  17. import org.jbehave.core.io.LoadFromClasspath;
  18. import org.jbehave.core.io.ResourceLoader;
  19. import org.jbehave.core.model.Description;
  20. import org.jbehave.core.model.ExamplesTable;
  21. import org.jbehave.core.model.ExamplesTableFactory;
  22. import org.jbehave.core.model.GivenStories;
  23. import org.jbehave.core.model.Lifecycle;
  24. import org.jbehave.core.model.Lifecycle.Steps;
  25. import org.jbehave.core.model.Meta;
  26. import org.jbehave.core.model.Narrative;
  27. import org.jbehave.core.model.Scenario;
  28. import org.jbehave.core.model.Story;
  29. import org.jbehave.core.model.TableTransformers;

  31. /**
  32.  * Pattern-based story parser, which uses the keywords provided to parse the
  33.  * textual story into a {@link Story}.
  34.  */
  35. public class RegexStoryParser extends AbstractRegexParser implements StoryParser {

  37.     public static final ResourceLoader DEFAULT_RESOURCE_LOADER = new LoadFromClasspath();
  38.     public static final TableTransformers DEFAULT_TABLE_TRANSFORMERS = new TableTransformers();
  39.     private final ExamplesTableFactory tableFactory;

  41.     public RegexStoryParser() {
  42.         this(new ExamplesTableFactory(DEFAULT_RESOURCE_LOADER, DEFAULT_TABLE_TRANSFORMERS));
  43.     }

  45.     public RegexStoryParser(ExamplesTableFactory tableFactory) {
  46.         super(tableFactory.keywords());
  47.         this.tableFactory = tableFactory;
  48.     }

  50.     @Override
  51.     public Story parseStory(String storyAsText) {
  52.         return parseStory(storyAsText, null);
  53.     }

  55.     @Override
  56.     public Story parseStory(String storyAsText, String storyPath) {
  57.         Description description = parseDescriptionFrom(storyAsText);
  58.         Meta meta = parseStoryMetaFrom(storyAsText);
  59.         Narrative narrative = parseNarrativeFrom(storyAsText);
  60.         GivenStories givenStories = parseGivenStories(storyAsText);
  61.         Lifecycle lifecycle = parseLifecycle(storyAsText);
  62.         if (lifecycle != null) {
  63.             ExamplesTable storyExamplesTable = lifecycle.getExamplesTable();
  64.             if (!storyExamplesTable.isEmpty()) {
  65.                 useExamplesTableForGivenStories(givenStories, storyExamplesTable);
  66.             }
  67.         }
  68.         List<Scenario> scenarios = parseScenariosFrom(storyAsText);
  69.         return new Story(storyPath, description, meta, narrative, givenStories, lifecycle, scenarios);
  70.     }

  72.     private Description parseDescriptionFrom(String storyAsText) {
  73.         Matcher findingDescription = findingDescription().matcher(storyAsText);
  74.         if (findingDescription.matches()) {
  75.             return new Description(findingDescription.group(1).trim());
  76.         }
  77.         return Description.EMPTY;
  78.     }

  80.     private Meta parseStoryMetaFrom(String storyAsText) {
  81.         Matcher findingMeta = findingStoryMeta().matcher(preScenarioText(storyAsText));
  82.         if (findingMeta.matches()) {
  83.             String meta = findingMeta.group(1).trim();
  84.             return Meta.createMeta(meta, keywords());
  85.         }
  86.         return Meta.EMPTY;
  87.     }

  89.     private String preScenarioText(String storyAsText) {
  90.         String[] split = storyAsText.split(keywords().scenario());
  91.         return split.length > 0 ? split[0] : storyAsText;
  92.     }

  94.     private Narrative parseNarrativeFrom(String storyAsText) {
  95.         Matcher findingNarrative = findingNarrative().matcher(storyAsText);
  96.         if (findingNarrative.matches()) {
  97.             String narrative = findingNarrative.group(1).trim();
  98.             return createNarrative(narrative);
  99.         }
  100.         return Narrative.EMPTY;
  101.     }

  103.     @SuppressWarnings("checkstyle:LocalVariableName")
  104.     private Narrative createNarrative(String narrative) {
  105.         Matcher findingElements = findingNarrativeElements().matcher(narrative);
  106.         if (findingElements.matches()) {
  107.             String inOrderTo = findingElements.group(1).trim();
  108.             String asA = findingElements.group(2).trim();
  109.             String iWantTo = findingElements.group(3).trim();
  110.             return new Narrative(inOrderTo, asA, iWantTo);
  111.         }
  112.         Matcher findingAlternativeElements = findingAlternativeNarrativeElements().matcher(narrative);
  113.         if (findingAlternativeElements.matches()) {            
  114.             String asA = findingAlternativeElements.group(1).trim();
  115.             String iWantTo = findingAlternativeElements.group(2).trim();
  116.             String soThat = findingAlternativeElements.group(3).trim();
  117.             return new Narrative("", asA, iWantTo, soThat);
  118.         }
  119.         return Narrative.EMPTY;
  120.     }
  121.     
  122.     private GivenStories parseGivenStories(String storyAsText) {
  123.         String scenarioKeyword = keywords().scenario();
  124.         // use text before scenario keyword, if found
  125.         String beforeScenario = "";
  126.         if (StringUtils.contains(storyAsText, scenarioKeyword)) {
  127.             beforeScenario = StringUtils.substringBefore(storyAsText, scenarioKeyword);
  128.         }
  129.         Matcher findingGivenStories = findingStoryGivenStories().matcher(beforeScenario);
  130.         String givenStories = findingGivenStories.find() ? findingGivenStories.group(1).trim() : NONE;
  131.         return new GivenStories(givenStories);
  132.     }

  134.     private Lifecycle parseLifecycle(String storyAsText) {
  135.         String scenarioKeyword = keywords().scenario();
  136.         // use text before scenario keyword, if found
  137.         String beforeScenario = "";
  138.         if (StringUtils.contains(storyAsText, scenarioKeyword)) {
  139.             beforeScenario = StringUtils.substringBefore(storyAsText, scenarioKeyword);
  140.         }
  141.         Matcher findingLifecycle = findingLifecycle().matcher(beforeScenario);
  142.         String lifecycle;
  143.         ExamplesTable examplesTable;
  144.         if (findingLifecycle.find()) {
  145.             lifecycle = findingLifecycle.group(1).trim();
  146.             String examplesTableAsString = findExamplesTable(findingLifecycle.group(0));
  147.             examplesTable = parseExamplesTable(examplesTableAsString);
  148.         } else {
  149.             lifecycle = NONE;
  150.             examplesTable = ExamplesTable.EMPTY;
  151.         }
  152.         Matcher findingBeforeAndAfter = compile(
  153.                 ".*" + keywords().before() + "(.*)\\s*" + keywords().after() + "(.*)\\s*", DOTALL).matcher(lifecycle);
  154.         if (findingBeforeAndAfter.matches()) {
  155.             String beforeLifecycle = findingBeforeAndAfter.group(1).trim();
  156.             List<Steps> beforeSteps = parseBeforeLifecycle(beforeLifecycle);
  157.             String afterLifecycle = findingBeforeAndAfter.group(2).trim();
  158.             List<Steps> afterSteps = parseAfterLifecycle(afterLifecycle);
  159.             return new Lifecycle(examplesTable, beforeSteps, afterSteps);
  160.         }
  161.         Matcher findingBefore = compile(".*" + keywords().before() + "(.*)\\s*", DOTALL).matcher(lifecycle);
  162.         if (findingBefore.matches()) {
  163.             String beforeLifecycle = findingBefore.group(1).trim();
  164.             List<Steps> beforeSteps = parseBeforeLifecycle(beforeLifecycle);
  165.             return new Lifecycle(examplesTable, beforeSteps, Arrays.<Steps>asList());
  166.         }
  167.         Matcher findingAfter = compile(".*" + keywords().after() + "(.*)\\s*", DOTALL).matcher(lifecycle);
  168.         if (findingAfter.matches()) {
  169.             List<Steps> beforeSteps = asList();
  170.             String afterLifecycle = findingAfter.group(1).trim();
  171.             List<Steps> afterSteps = parseAfterLifecycle(afterLifecycle);
  172.             return new Lifecycle(examplesTable, beforeSteps, afterSteps);
  173.         }
  174.         return new Lifecycle(examplesTable);
  175.     }

  177.     private List<Steps> parseBeforeLifecycle(String lifecycleAsText) {
  178.         List<Steps> list = new ArrayList<>();
  179.         for (String byScope : lifecycleAsText.split(keywords().scope())) {
  180.             byScope = byScope.trim();
  181.             if (byScope.isEmpty()) {
  182.                 continue;
  183.             }
  184.             Scope scope = parseScope(findScope(keywords().scope() + byScope));
  185.             Steps steps = new Steps(scope, findSteps(startingWithNL(byScope)));
  186.             list.add(steps);
  187.         }
  188.         return list;
  189.     }

  191.     private List<Steps> parseAfterLifecycle(String lifecycleAsText) {
  192.         List<Steps> list = new ArrayList<>();
  193.         for (String byScope : lifecycleAsText.split(keywords().scope())) {
  194.             byScope = byScope.trim();
  195.             if (byScope.isEmpty()) {
  196.                 continue;
  197.             }
  198.             Scope scope = parseScope(findScope(keywords().scope() + byScope));
  199.             for (String byOutcome : byScope.split(keywords().outcome())) {
  200.                 byOutcome = byOutcome.trim();
  201.                 if (byOutcome.isEmpty()) {
  202.                     continue;
  203.                 }
  204.                 String outcomeAsText = findOutcome(byOutcome);
  205.                 String filtersAsText = findFilters(removeStart(byOutcome, outcomeAsText));
  206.                 List<String> steps = findSteps(startingWithNL(removeStart(byOutcome, filtersAsText)));
  207.                 list.add(new Steps(scope, parseOutcome(outcomeAsText), parseFilters(filtersAsText), steps));
  208.             }
  209.         }
  210.         return list;
  211.     }

  213.     private String findScope(String lifecycleAsText) {
  214.         Matcher findingScope = findingLifecycleScope().matcher(lifecycleAsText.trim());
  215.         if (findingScope.matches()) {
  216.             return findingScope.group(1).trim();
  217.         }
  218.         return NONE;
  219.     }

  221.     private Scope parseScope(String scopeAsText) {
  222.         if (scopeAsText.trim().equals(keywords().scopeStep())) {
  223.             return Scope.STEP;
  224.         } else if (scopeAsText.trim().equals(keywords().scopeScenario())) {
  225.             return Scope.SCENARIO;
  226.         } else if (scopeAsText.trim().equals(keywords().scopeStory())) {
  227.             return Scope.STORY;
  228.         }
  229.         return Scope.SCENARIO;
  230.     }

  232.     private String findOutcome(String stepsByOutcome) {
  233.         Matcher findingOutcome = findingLifecycleOutcome().matcher(stepsByOutcome);
  234.         if (findingOutcome.matches()) {
  235.             return findingOutcome.group(1).trim();
  236.         }
  237.         return keywords().outcomeAny();
  238.     }

  240.     private Outcome parseOutcome(String outcomeAsText) {
  241.         if (outcomeAsText.equals(keywords().outcomeSuccess())) {
  242.             return Outcome.SUCCESS;
  243.         } else if (outcomeAsText.equals(keywords().outcomeFailure())) {
  244.             return Outcome.FAILURE;
  245.         }
  246.         return Outcome.ANY;
  247.     }

  249.     private String findFilters(String stepsByFilters) {
  250.         Matcher findingFilters = findingLifecycleFilters().matcher(stepsByFilters.trim());
  251.         if (findingFilters.matches()) {
  252.             return findingFilters.group(1).trim();
  253.         }
  254.         return NONE;
  255.     }

  257.     private String parseFilters(String filtersAsText) {
  258.         return removeStart(filtersAsText, keywords().metaFilter()).trim();
  259.     }

  261.     private List<Scenario> parseScenariosFrom(String storyAsText) {
  262.         List<Scenario> parsed = new ArrayList<>();
  263.         for (String scenarioAsText : splitScenarios(storyAsText)) {
  264.             parsed.add(parseScenario(scenarioAsText));
  265.         }
  266.         return parsed;
  267.     }

  269.     private List<String> splitScenarios(String storyAsText) {
  270.         String scenarioKeyword = keywords().scenario();

  272.         // use text after scenario keyword, if found
  273.         if (StringUtils.contains(storyAsText, scenarioKeyword)) {
  274.             storyAsText = StringUtils.substringAfter(storyAsText, scenarioKeyword);
  275.         }

  277.         return splitElements(storyAsText, scenarioKeyword);
  278.     }

  280.     private Scenario parseScenario(String scenarioAsText) {
  281.         String title = findScenarioTitle(scenarioAsText);
  282.         String scenarioWithoutKeyword = removeStart(scenarioAsText, keywords().scenario()).trim();
  283.         String scenarioWithoutTitle = removeStart(scenarioWithoutKeyword, title);
  284.         scenarioWithoutTitle = startingWithNL(scenarioWithoutTitle);
  285.         Meta meta = findScenarioMeta(scenarioWithoutTitle);
  286.         String examplesTableAsString = findExamplesTable(scenarioWithoutTitle);
  287.         ExamplesTable examplesTable = parseExamplesTable(examplesTableAsString);
  288.         GivenStories givenStories = findScenarioGivenStories(scenarioWithoutTitle);
  289.         useExamplesTableForGivenStories(givenStories, examplesTable);
  290.         List<String> rawSteps = new ArrayList<>();
  291.         if (examplesTableAsString.trim().isEmpty()) {
  292.             rawSteps.addAll(findSteps(scenarioWithoutTitle));
  293.         } else {
  294.             int afterExampleIndex = scenarioWithoutTitle.indexOf(examplesTableAsString)
  295.                     + examplesTableAsString.length();
  296.             rawSteps.addAll(findSteps(scenarioWithoutTitle.substring(0, afterExampleIndex)));
  297.         }
  298.         return new Scenario(title, meta, givenStories, examplesTable, rawSteps);
  299.     }

  301.     private void useExamplesTableForGivenStories(GivenStories givenStories, ExamplesTable examplesTable) {
  302.         if (givenStories.requireParameters()) {
  303.             givenStories.useExamplesTable(examplesTable);
  304.         }
  305.     }

  307.     private String findScenarioTitle(String scenarioAsText) {
  308.         Matcher findingTitle = findingScenarioTitle().matcher(scenarioAsText);
  309.         return findingTitle.find() ? findingTitle.group(1).trim() : NONE;
  310.     }

  312.     private Meta findScenarioMeta(String scenarioAsText) {
  313.         Matcher findingMeta = findingScenarioMeta().matcher(scenarioAsText);
  314.         if (findingMeta.matches()) {
  315.             String meta = findingMeta.group(1).trim();
  316.             return Meta.createMeta(meta, keywords());
  317.         }
  318.         return Meta.EMPTY;
  319.     }

  321.     private String findExamplesTable(String scenarioAsText) {
  322.         Matcher findingTable = findingExamplesTable().matcher(scenarioAsText);
  323.         return findingTable.find() ? findingTable.group(1).trim() : NONE;
  324.     }

  326.     private ExamplesTable parseExamplesTable(String tableInput) {
  327.         return tableFactory.createExamplesTable(tableInput);
  328.     }

  330.     private GivenStories findScenarioGivenStories(String scenarioAsText) {
  331.         Matcher findingGivenStories = findingScenarioGivenStories().matcher(scenarioAsText);
  332.         String givenStories = findingGivenStories.find() ? findingGivenStories.group(1).trim() : NONE;
  333.         return new GivenStories(givenStories);
  334.     }

  336.     // Regex Patterns

  338.     private Pattern findingDescription() {
  339.         String metaOrNarrativeOrLifecycleOrScenario = concatenateWithOr(keywords().meta(), keywords().narrative(),
  340.                 keywords().lifecycle(), keywords().scenario());
  341.         return compile("(.*?)(" + metaOrNarrativeOrLifecycleOrScenario + ").*", DOTALL);
  342.     }

  344.     private Pattern findingStoryMeta() {
  345.         String narrativeOrLifecycleOrGivenStories = concatenateWithOr(keywords().narrative(), keywords().lifecycle(),
  346.                 keywords().givenStories());
  347.         return compile(".*" + keywords().meta() + "(.*?)\\s*(\\Z|" + narrativeOrLifecycleOrGivenStories + ").*",
  348.                 DOTALL);
  349.     }

  351.     private Pattern findingNarrative() {
  352.         String givenStoriesOrLifecycleOrScenario = concatenateWithOr(keywords().givenStories(), keywords().lifecycle(),
  353.                 keywords().scenario());
  354.         return compile(".*" + keywords().narrative() + "(.*?)\\s*(" + givenStoriesOrLifecycleOrScenario + ").*",
  355.                 DOTALL);
  356.     }

  358.     private Pattern findingNarrativeElements() {
  359.         return compile(".*" + keywords().inOrderTo() + "(.*)\\s*" + keywords().asA() + "(.*)\\s*" + keywords().iWantTo()
  360.                 + "(.*)", DOTALL);
  361.     }

  363.     private Pattern findingAlternativeNarrativeElements() {
  364.         return compile(
  365.                 ".*" + keywords().asA() + "(.*)\\s*" + keywords().iWantTo() + "(.*)\\s*" + keywords().soThat() + "(.*)",
  366.                 DOTALL);
  367.     }
  368.     
  369.     private Pattern findingStoryGivenStories() {
  370.         String lifecycleOrScenario = concatenateWithOr(keywords().lifecycle(), keywords().scenario());
  371.         return compile(".*" + keywords().givenStories() + "(.*?)\\s*(\\Z|" + lifecycleOrScenario + ").*", DOTALL);
  372.     }
  373.     
  374.     private Pattern findingLifecycle() {
  375.         return compile(".*" + keywords().lifecycle() + "\\s*(.*)", DOTALL);
  376.     }

  378.     private Pattern findingLifecycleScope() {
  379.         String startingWords = concatenateStartingWords();
  380.         return compile(keywords().scope() + "((.)*?)\\s*(" + keywords().outcome() + "|" + keywords().metaFilter() + "|"
  381.                 + startingWords + ").*", DOTALL);
  382.     }

  384.     private Pattern findingLifecycleOutcome() {
  385.         String startingWords = concatenateStartingWords();
  386.         String outcomes = concatenateWithOr(keywords().outcomeAny(), keywords().outcomeSuccess(),
  387.                 keywords().outcomeFailure());
  388.         return compile("\\s*(" + outcomes + ")\\s*(" + keywords().metaFilter() + "|" + startingWords + ").*", DOTALL);
  389.     }

  391.     private Pattern findingLifecycleFilters() {
  392.         String startingWords = concatenateStartingWords();
  393.         String filters = concatenateWithOr(keywords().metaFilter());
  394.         return compile("\\s*(" + filters + "[\\w\\+\\-\\_\\s]*)(" + startingWords + ").*", DOTALL);
  395.     }

  397.     private Pattern findingScenarioTitle() {
  398.         String startingWords = concatenateStartingWords();
  399.         return compile(keywords().scenario() + "(.*?)\\s*(" + keywords().meta() + "|" + keywords().givenStories() + "|"
  400.                 + startingWords + "|$).*", DOTALL);
  401.     }

  403.     private Pattern findingScenarioMeta() {
  404.         String startingWords = concatenateStartingWords();
  405.         return compile(
  406.                 ".*" + keywords().meta() + "(.*?)\\s*(" + keywords().givenStories() + "|" + startingWords + "|$).*",
  407.                 DOTALL);
  408.     }

  410.     private Pattern findingScenarioGivenStories() {
  411.         String startingWords = concatenateStartingWords();
  412.         return compile("\\n" + keywords().givenStories() + "((.|\\n)*?)\\s*(" + startingWords + ").*", DOTALL);
  413.     }

  415.     private Pattern findingExamplesTable() {
  416.         return compile("\\n" + keywords().examplesTable() + "\\s*(.*?)(?:\\n" + keywords().ignorable() + ".*)?$",
  417.                 DOTALL);
  418.     }

  420.     private String concatenateWithOr(String... keywords) {
  421.         return concatenateWithOr(NONE, asList(keywords));
  422.     }
  423. }
Created with JaCoCo 0.8.10.202304240956