Committing what I have before starting again

serenity-cli/src/main/java/net/serenitybdd/cli/Serenity.java

@@ -17,10 +17,15 @@ public class Serenity {
     @Option(name = "--help", usage = "print this message")
     private boolean help;
 
+    @Option(name = "--features",
+            usage = "Source directory containing the feature files",
+            metaVar = "<directory>")
+    Path testScenariosDirectory = Paths.get("src/test/resources/features");
+
     @Option(name = "--source",
             usage = "Source directory containing the Serenity JSON output files",
             metaVar = "<directory>")
-    Path source = Paths.get("target/site/serenity");
+    Path jsonOutcomesDirectory = Paths.get("target/site/serenity");
 
     @Option(name = "--destination",
             usage = "Directory directory to contain the generated Serenity report",
@@ -63,11 +68,6 @@ public class Serenity {
             metaVar = "<string>")
     String jiraWorkflowActive;
 
-    @Option(name = "--features",
-            usage = "Source directory containing the feature files",
-            metaVar = "<directory>")
-    Path requirementsDirectory = Paths.get("src/test/resources/features");
-
     @Option(name = "--tags",
             metaVar = "<string>")
     String tags;
@@ -93,10 +93,9 @@ public void executeWith(String[] args) {
         CmdLineParser parser = new CmdLineParser(this);
 
         try {
-
             parser.parseArgument(args);
-
-        } catch (CmdLineException e) {
+        }
+        catch (CmdLineException e) {
             printUsage(parser);
             return;
         }
@@ -106,15 +105,20 @@ public void executeWith(String[] args) {
             return;
         }
 
-        SerenityCLIReportCoordinator reporter = new SerenityCLIReportCoordinator(source,
+        String projectName = (project != null) ? project : workingDirectoryName();
+
+        SerenityCLIReportCoordinator reporter = new SerenityCLIReportCoordinator(
+                testScenariosDirectory.toAbsolutePath(),
+                jsonOutcomesDirectory.toAbsolutePath(),
                 destination,
-                (project != null) ? project : workingDirectoryName(),
+                projectName,
                 issueTrackerUrl,
+                // todo: introduce a type for JiraDetails
                 jiraUrl, jiraProject, jiraUsername, jiraPassword, jiraWorkflowActive, jiraWorkflow,
-                requirementsDirectory.toAbsolutePath().toFile().toString(), tags);
+                tags
+        );
 
         reporter.execute();
-
     }
 
     private String workingDirectoryName() {

serenity-cli/src/main/java/net/serenitybdd/cli/SerenityCLIReportCoordinator.java

@@ -17,41 +17,52 @@ public class SerenityCLIReportCoordinator {
 
     List<CLIReportGenerator> reportGenerators = new ArrayList<>();
 
-    public SerenityCLIReportCoordinator(Path sourceDirectory,
-                                        Path destinationDirectory,
-                                        String project,
-                                        String issueTrackerUrl,
-                                        String jiraUrl,
-                                        String jiraProject,
-                                        String jiraUsername,
-                                        String jiraPassword,
-                                        String jiraWorkflowActive,
-                                        String jiraWorkflow,
-                                        String requirementsDirectory,
-                                        String tags) {
-        this.sourceDirectory = sourceDirectory;
+    public SerenityCLIReportCoordinator(
+            Path testScenariosDirectory,
+            Path jsonOutcomesDirectory,
+            Path destinationDirectory,
+            String project,
+            String issueTrackerUrl,
+            String jiraUrl,
+            String jiraProject,
+            String jiraUsername,
+            String jiraPassword,
+            String jiraWorkflowActive,
+            String jiraWorkflow,
+            String tags
+    ) {
+        this.sourceDirectory = jsonOutcomesDirectory;
         this.destinationDirectory = destinationDirectory;
 
         reportGenerators.addAll(List.of(
-                new CLIAggregateReportGenerator(sourceDirectory, destinationDirectory, project, issueTrackerUrl,
-                        jiraUrl, jiraProject, jiraUsername, jiraPassword,
-                        requirementsDirectory, tags),
-                new CLIIssueTrackerUpdater(jiraWorkflow, jiraWorkflowActive)
+                new CLIAggregateReportGenerator(
+                        testScenariosDirectory,
+                        destinationDirectory,
+                        project,
+                        issueTrackerUrl,
+                        jiraUrl,
+                        jiraProject,
+                        jiraUsername,
+                        jiraPassword,
+                        tags
+                ),
+                new CLIIssueTrackerUpdater(
+                        jiraWorkflow,
+                        jiraWorkflowActive
+                )
         ));
     }
 
 
     public void execute() {
         try {
-
             printStartingBanner();
 
             prepareDirectories();
 
             for (CLIReportGenerator generator : reportGenerators) {
                 generator.generateReportsFrom(sourceDirectory);
             }
-
         } catch (IOException e) {
             throw new RuntimeException(e);
         }

serenity-cli/src/main/java/net/serenitybdd/cli/reporters/CLIAggregateReportGenerator.java

@@ -2,6 +2,7 @@
 
 import net.thucydides.core.reports.html.HtmlAggregateStoryReporter;
 import net.thucydides.model.requirements.Requirements;
+import net.thucydides.model.requirements.SerenityJsRequirements;
 
 import java.io.IOException;
 import java.nio.file.Path;
@@ -10,46 +11,45 @@
 
 public class CLIAggregateReportGenerator implements CLIReportGenerator {
 
-    private final Path sourceDirectory;
+    private final Path requirementsDirectory;
     private final Path destinationDirectory;
     private final String project;
     private final String issueTrackerUrl;
     private final String jiraUrl;
     private final String jiraProject;
     private final String jiraUsername;
     private final String jiraPassword;
-    private final String requirementsDirectory;
     private final String tags;
 
-    public CLIAggregateReportGenerator(Path sourceDirectory,
-                                        Path destinationDirectory,
-                                        String project,
-                                        String issueTrackerUrl,
-                                        String jiraUrl,
-                                        String jiraProject,
-                                        String jiraUsername,
-                                        String jiraPassword,
-                                        String requirementsDirectory,
-                                        String tags) {
-        this.sourceDirectory = sourceDirectory;
+    public CLIAggregateReportGenerator(
+            Path testScenariosDirectory,
+            Path destinationDirectory,
+            String project,
+            String issueTrackerUrl,
+            String jiraUrl,
+            String jiraProject,
+            String jiraUsername,
+            String jiraPassword,
+            String tags
+    ) {
+        this.requirementsDirectory = testScenariosDirectory;
         this.destinationDirectory = destinationDirectory;
         this.issueTrackerUrl = issueTrackerUrl;
         this.jiraUrl = jiraUrl;
         this.jiraProject = jiraProject;
         this.jiraUsername = jiraUsername;
         this.jiraPassword = jiraPassword;
         this.project = project;
-        this.requirementsDirectory = requirementsDirectory;
         this.tags = tags;
     }
 
     @Override
-    public void generateReportsFrom(Path sourceDirectory) throws IOException {
+    public void generateReportsFrom(Path jsonOutcomesDirectory) throws IOException {
+
+        Requirements requirements = new SerenityJsRequirements(requirementsDirectory, jsonOutcomesDirectory);
 
-        Requirements requirements = RequirementsStrategy.forJSONOutputsIn(sourceDirectory)
-                                                        .andFeatureFilesIn(requirementsDirectory);
         HtmlAggregateStoryReporter reporter = new HtmlAggregateStoryReporter(project, requirements);
-        reporter.setSourceDirectory(sourceDirectory.toFile());
+        reporter.setSourceDirectory(jsonOutcomesDirectory.toFile());
         reporter.setOutputDirectory(destinationDirectory.toFile());
         reporter.setIssueTrackerUrl(issueTrackerUrl);
         reporter.setJiraUrl(jiraUrl);
@@ -63,6 +63,6 @@ public void generateReportsFrom(Path sourceDirectory) throws IOException {
             reporter.setTags(tags);
         }
 
-        reporter.generateReportsForTestResultsFrom(sourceDirectory.toFile());
+        reporter.generateReportsForTestResultsFrom(jsonOutcomesDirectory.toFile());
     }
 }

serenity-model/src/main/java/net/thucydides/model/requirements/DefaultCapabilityTypes.java

@@ -17,7 +17,7 @@
 
 public class DefaultCapabilityTypes {
 
-    public final static List<String> DEFAULT_CAPABILITY_TYPES = NewList.of("capability", "feature", "story");
+    public final static List<String> DEFAULT_CAPABILITY_TYPES = NewList.of("theme", "capability", "feature", "story");
     private final static DefaultCapabilityTypes INSTANCE = new DefaultCapabilityTypes();
     private List<String> defaultCapabilityTypes;
 

serenity-model/src/main/java/net/thucydides/model/requirements/FileSystemRequirementsTagProvider.java

@@ -32,6 +32,7 @@
 import java.io.IOException;
 import java.net.URISyntaxException;
 import java.nio.charset.Charset;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.*;
@@ -708,7 +709,21 @@ private Requirement requirementFromDirectoryName(File requirementDirectory) {
     private String getRequirementTypeOf(File requirementDirectory) {
         LOGGER.debug("Get requirements type for: {} ({})", requirementDirectory, requirementDirectory.getAbsolutePath());
         int depth = requirementDepthOf(topLevelDirectory, requirementDirectory);
-        int maxDepth = TheDirectoryStructure.startingAt(directoryAt(topLevelDirectory)).maxDepth();
+        File directory = directoryAt(topLevelDirectory);
+        int maxDepth = TheDirectoryStructure.startingAt(directory).maxDepth();
+
+        // todo: this is a hack to get the correct depth for JavaScript specs; we should come up with a better solution
+        try {
+            long count = Files.find(directory.toPath(), Integer.MAX_VALUE, (filePath, fileAttr) -> filePath.getFileName().toString().matches(JAVASCRIPT_SPEC_FILE_NAME_PATTERN))
+                    .collect(Collectors.counting());
+
+            if (count > 0) {
+                maxDepth++;
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
         return getDefaultType(depth, maxDepth);
     }
 

serenity-model/src/main/java/net/thucydides/model/requirements/SerenityJsRequirements.java

@@ -0,0 +1,79 @@
+package net.thucydides.model.requirements;
+
+import net.serenitybdd.model.di.ModelInfrastructure;
+import net.serenitybdd.model.environment.ConfiguredEnvironment;
+import net.thucydides.model.domain.ReportType;
+import net.thucydides.model.domain.RequirementCache;
+import net.thucydides.model.issues.IssueTracking;
+import net.thucydides.model.reports.TestOutcomeLoader;
+import net.thucydides.model.reports.html.ReportNameProvider;
+import net.thucydides.model.requirements.reports.RequirementsOutcomeFactory;
+import net.thucydides.model.requirements.reports.SerenityJsRequirementsOutcomeFactory;
+import net.thucydides.model.util.EnvironmentVariables;
+
+import java.nio.file.Path;
+import java.util.List;
+
+import static net.thucydides.model.reports.html.ReportNameProvider.NO_CONTEXT;
+
+public class SerenityJsRequirements implements Requirements {
+
+    private final RequirementsService requirementsService;
+    private final RequirementsOutcomeFactory requirementsOutcomeFactory;
+
+    public static SerenityJsRequirements from(Path testScenariosDirectory, Path jsonOutcomesDirectory) {
+        EnvironmentVariables environmentVariables = ModelInfrastructure.getEnvironmentVariables();
+        IssueTracking issueTracking = ModelInfrastructure.getIssueTracking();
+        RequirementCache requirementCache = RequirementCache.getInstance();
+        TestOutcomeLoader testOutcomeLoader = new TestOutcomeLoader(environmentVariables);
+        Path outputDirectory = ConfiguredEnvironment.getConfiguration().getOutputDirectory().toPath();
+
+        SerenityJsTagProvider serenityJsTagProvider = new SerenityJsTagProvider(
+                requirementCache,
+                testOutcomeLoader,
+                environmentVariables,
+                testScenariosDirectory,
+                jsonOutcomesDirectory,
+                outputDirectory
+        );
+
+        RequirementsTagProvider testOutcomeTagProvider = new TestOutcomeRequirementsTagProvider(environmentVariables)
+                .fromSourceDirectory(jsonOutcomesDirectory);
+
+        return new SerenityJsRequirements(
+                environmentVariables,
+                issueTracking,
+//                serenityJsTagProvider
+                testOutcomeTagProvider
+        );
+    }
+
+    public SerenityJsRequirements(
+            EnvironmentVariables environmentVariables,
+            IssueTracking issueTracking,
+            RequirementsTagProvider tagProvider
+    ) {
+        this.requirementsService = new AggregateRequirementsService(environmentVariables, tagProvider);
+        this.requirementsOutcomeFactory = new SerenityJsRequirementsOutcomeFactory(
+                environmentVariables,
+                issueTracking,
+                new ReportNameProvider(NO_CONTEXT, ReportType.HTML, requirementsService),
+                tagProvider
+        );
+    }
+
+    @Override
+    public RequirementsService getRequirementsService() {
+        return requirementsService;
+    }
+
+    @Override
+    public RequirementsOutcomeFactory getRequirementsOutcomeFactory() {
+        return requirementsOutcomeFactory;
+    }
+
+    @Override
+    public List<String> getTypes() {
+        return requirementsService.getRequirementTypes();
+    }
+}