public static String definedIn(String fullPath, String defaultType) { Optional<String> narrativePath = narrativePathsFor(fullPath); // String narrativePath = asResourcePath(fileSystemPathOfNarrativeInPackage(fullPath)) + ".txt"; try { if (narrativePath.isPresent()) { // String narrativeFilePath = Resources.getResource(narrativePath).getFile(); // if (new File(narrativeFilePath).exists()) { Optional<Narrative> narrative = LoadedNarrative.load().fromFile(new File(narrativePath.get()), defaultType); if (narrative.isPresent()) { return (narrative.get().getTitle().orElse("") + System.lineSeparator() + narrative.get().getText()).trim(); } } } catch (IllegalArgumentException noNarrativeFileFound) { } return ""; }
private Requirement leafRequirementWithNarrative(String shortName, Narrative requirementNarrative) { String displayName = getTitleFromNarrativeOrDirectoryName(requirementNarrative, shortName); String cardNumber = requirementNarrative.getCardNumber().orNull(); String type = requirementNarrative.getType(); List<String> releaseVersions = requirementNarrative.getVersionNumbers(); return Requirement.named(shortName) .withOptionalDisplayName(displayName) .withOptionalCardNumber(cardNumber) .withType(type) .withNarrative(requirementNarrative.getText()) .withReleaseVersions(releaseVersions); }
private Requirement leafRequirementWithNarrative(String shortName, String path, Narrative requirementNarrative) { String displayName = getTitleFromNarrativeOrDirectoryName(requirementNarrative, shortName); String cardNumber = requirementNarrative.getCardNumber().orElse(null); String type = requirementNarrative.getType(); List<String> releaseVersions = requirementNarrative.getVersionNumbers(); return Requirement.named(shortName) .withId(requirementNarrative.getId().orElse(path)) .withOptionalDisplayName(displayName) .withOptionalCardNumber(cardNumber) .withType(type) .withNarrative(requirementNarrative.getText()) .withPath(relativeDirectoryOf(path)) .withReleaseVersions(releaseVersions) .withTags(requirementNarrative.getTags()); }
private Optional<Narrative> narrativeLoadedFrom(File narrativeFile, String type) { try { BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(narrativeFile), "UTF-8")); List<String> lines = readPreambleFrom(reader); String title = null; String cardNumber = findCardNumberIn(lines); List<String> versionNumbers = findVersionNumberIn(lines); Optional<String> titleLine = readOptionalTitleFrom(lines); if (titleLine.isPresent()) { title = titleLine.get(); } String text = readNarrativeFrom(lines); reader.close(); return Optional.of(new Narrative(Optional.fromNullable(title), Optional.fromNullable(cardNumber), versionNumbers, type, text)); } catch(IOException ex) { ex.printStackTrace(); } return Optional.absent(); }
private Requirement requirementWithNarrative(File requirementDirectory, String shortName, Narrative requirementNarrative) { String displayName = getTitleFromNarrativeOrDirectoryName(requirementNarrative, shortName); String cardNumber = requirementNarrative.getCardNumber().orNull(); String type = requirementNarrative.getType(); List<String> releaseVersions = requirementNarrative.getVersionNumbers(); List<Requirement> children = readChildrenFrom(requirementDirectory); return Requirement.named(shortName) .withOptionalDisplayName(displayName) .withOptionalCardNumber(cardNumber) .withType(type) .withNarrative(requirementNarrative.getText()) .withReleaseVersions(releaseVersions) .withChildren(children); }
private String getTitleFromNarrativeOrDirectoryName(Narrative requirementNarrative, String nameIfNoNarrativePresent) { if (requirementNarrative.getTitle().isPresent() && isNotBlank(requirementNarrative.getTitle().get())) { return requirementNarrative.getTitle().get(); } return nameIfNoNarrativePresent; }
private Optional<Narrative> narrativeLoadedFrom(File narrativeFile, String defaultType) { try { BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(narrativeFile), "UTF-8")); List<String> lines = readPreambleFrom(reader); String title = null; String type = defaultType; String cardNumber = findCardNumberIn(lines); List<String> versionNumbers = findVersionNumberIn(lines); Optional<String> titleLine = readOptionalTitleFrom(lines); if (titleLine.isPresent()) { title = titleFrom(titleLine.get()); type = typeFrom(titleLine.get()).or(defaultType); } String text = readNarrativeFrom(lines); reader.close(); return Optional.of(new Narrative(Optional.fromNullable(title), Optional.fromNullable(cardNumber), versionNumbers, type, text)); } catch (IOException ex) { ex.printStackTrace(); } return Optional.absent(); }
private Requirement requirementWithNarrative(File requirementDirectory, String shortName, Narrative requirementNarrative) { String displayName = getTitleFromNarrativeOrDirectoryName(requirementNarrative, shortName); String cardNumber = requirementNarrative.getCardNumber().orNull(); String type = requirementNarrative.getType(); List<String> releaseVersions = requirementNarrative.getVersionNumbers(); List<Requirement> children = readChildrenFrom(requirementDirectory); return Requirement.named(shortName) .withOptionalDisplayName(displayName) .withOptionalCardNumber(cardNumber) .withType(type) .withNarrative(requirementNarrative.getText()) .withReleaseVersions(releaseVersions) .withChildren(children); }
public java.util.Optional<Narrative> fromFile(File narrativeFile, String defaultType) { try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(narrativeFile), StandardCharsets.UTF_8))) { List<String> lines = readPreambleFrom(reader); String title = null; String type = defaultType; String cardNumber = findCardNumberIn(lines); List<String> versionNumbers = findVersionNumberIn(lines); Optional<String> titleLine = readOptionalTitleFrom(lines); if (titleLine.isPresent()) { title = titleFrom(titleLine.get()); type = typeFrom(titleLine.get()).orElse(defaultType); } String text = readNarrativeFrom(lines); reader.close(); List<TestTag> tags = (StringUtils.isEmpty(title)) ? new ArrayList<>() : Collections.singletonList(TestTag.withName(title).andType("story")); return java.util.Optional.of(new Narrative(Optional.ofNullable(title), Optional.of(narrativeFile.getPath()), Optional.ofNullable(cardNumber), versionNumbers, type, text, tags)); } catch (IOException ex) { ex.printStackTrace(); } return java.util.Optional.empty(); }
private Requirement requirementWithNarrative(File requirementDirectory, String shortName, Narrative requirementNarrative) { String displayName = getTitleFromNarrativeOrDirectoryName(requirementNarrative, shortName); String cardNumber = requirementNarrative.getCardNumber().orElse(null); String type = requirementNarrative.getType(); List<String> releaseVersions = requirementNarrative.getVersionNumbers(); List<Requirement> children = readChildrenFrom(requirementDirectory); return Requirement.named(shortName) .withOptionalDisplayName(displayName) .withOptionalCardNumber(cardNumber) .withType(type) .withNarrative(requirementNarrative.getText()) .withReleaseVersions(releaseVersions) .withPath(relativeDirectoryOf(requirementDirectory.getPath())) .withChildren(children); }
public static String definedIn(Optional<Narrative> narrative) { return narrative.get().getTitle().get(); }
public Optional<Narrative> loadFeatureNarrative(File narrativeFile) { Optional<Feature> loadedFeature = loadFeature(narrativeFile); if (!loadedFeature.isPresent()) { return Optional.empty(); } Feature feature = loadedFeature.get(); String cardNumber = findCardNumberInTags(tagsDefinedIn(feature)); List<String> versionNumbers = findVersionNumberInTags(tagsDefinedIn(feature)); String title = feature.getName(); String text = descriptionWithScenarioReferencesFrom(feature); String id = getIdFromName(title); List<TestTag> tags = feature.getTags().stream().map(tag -> TestTag.withValue(tag.getName())).collect(Collectors.toList()); tags.add(TestTag.withName(title).andType("feature")); return Optional.of(new Narrative(Optional.ofNullable(title), Optional.ofNullable(id), Optional.ofNullable(cardNumber), versionNumbers, "feature", text != null ? text : "", tags)); }
public Optional<Narrative> loadFeatureNarrative(File narrativeFile) { CucumberFeatureListener gherkinStructure =new CucumberFeatureListener(); Parser parser = new Parser(gherkinStructure, true, "root", false, locale); try { String gherkinScenarios = filterOutCommentsFrom(FileUtils.readFileToString(narrativeFile)); parser.parse(gherkinScenarios, narrativeFile.getName(),0); String cardNumber = findCardNumberInTags(gherkinStructure.getFeature().getTags()); List<String> versionNumbers = findVersionNumberInTags(gherkinStructure.getFeature().getTags()); String title = gherkinStructure.getFeature().getName(); String text = gherkinStructure.getFeature().getDescription(); return Optional.of(new Narrative(Optional.fromNullable(title), Optional.fromNullable(cardNumber), versionNumbers, "feature", text)); } catch (IOException ex) { ex.printStackTrace(); } return Optional.absent(); }
private String storyNameFrom(java.util.Optional<Narrative> narrative, FeatureType type, File storyFile) { if (narrative.isPresent() && isNotBlank(narrative.get().getTitle().orElse(""))) { return narrative.get().getTitle().get(); } else { if (isSnakeCase(storyFile.getName())) { return storyFile.getName().replace(type.getExtension(), "").replace("_"," "); } else { String storyNameWithoutExtension = storyFile.getName().replace(type.getExtension(), ""); String snakeCaseStoryName = inflection().underscore(storyNameWithoutExtension); return inflection().of(snakeCaseStoryName).asATitle().toString(); } } }
public Requirement readRequirementsFromStoryOrFeatureFile(File storyFile) { FeatureType type = featureTypeOf(storyFile); String defaultStoryName = storyFile.getName().replace(type.getExtension(), ""); Optional<Narrative> optionalNarrative = (type == FeatureType.STORY) ? loadFromStoryFile(storyFile) : loadFromFeatureFile(storyFile); String storyName = (optionalNarrative.isPresent()) ? optionalNarrative.get().getTitle().or(defaultStoryName) : defaultStoryName; Requirement requirement = (optionalNarrative.isPresent()) ? leafRequirementWithNarrative(humanReadableVersionOf(storyName), optionalNarrative.get()).withType(type.toString()) : storyNamed(storyName).withType(type.toString()); return requirement.definedInFile(storyFile); }