How to use tableRowIsNotExcludedBy method of io.cucumber.core.plugin.LineFilters class

1package io.cucumber.core.plugin;
2
3import io.cucumber.core.internal.gherkin.ast.Examples;
4import io.cucumber.core.internal.gherkin.ast.TableRow;
5import net.serenitybdd.cucumber.CucumberWithSerenity;
6
7import java.net.URI;
8import java.util.HashMap;
9import java.util.Map;
10import java.util.Optional;
11import java.util.Set;
12
13public class LineFilters {
14
15    private Map<URI, Set<Integer>> lineFilters;
16
17    public LineFilters() {
18        lineFilters = newLineFilters();
19    }
20
21    public static LineFilters forCurrentContext() {
22        return new LineFilters();
23    }
24
25    public Optional<URI> getURIForFeaturePath(URI featurePath) {
26        return lineFilters.keySet().stream()
27                .filter(uri -> featurePath.equals(uri))
28                .findFirst();
29    }
30
31    private Map<URI, Set<Integer>> newLineFilters() {
32        Map<URI, Set<Integer>> lineFiltersFromRuntime = CucumberWithSerenity.currentRuntimeOptions().getLineFilters();
33        if (lineFiltersFromRuntime == null) {
34            return new HashMap<>();
35        } else {
36            return lineFiltersFromRuntime;
37        }
38    }
39
40    public Set<Integer> getLineNumbersFor(URI featurePath) {
41        return lineFilters.get(featurePath);
42    }
43
44
45    public boolean examplesAreNotExcluded(Examples examples, URI featurePath) {
46        if (lineFilters.isEmpty()) {
47            return true;
48        }
49        if (lineFiltersContainFeaturePath(featurePath)) {
50            Optional<URI> uriForFeaturePath = getURIForFeaturePath(featurePath);
51            return uriForFeaturePath.filter(
52                    uri -> examples.getTableBody().stream()
53                            .anyMatch(
54                                    row -> lineFilters.get(uri).contains(row.getLocation().getLine()))
55            ).isPresent();
56        }
57        return false;
58    }
59
60    public boolean tableRowIsNotExcludedBy(TableRow tableRow, URI featurePath) {
61        if (lineFilters.isEmpty()) {
62            return true;
63        }
64        if (lineFiltersContainFeaturePath(featurePath)) {
65            Optional<URI> uriForFeaturePath = getURIForFeaturePath(featurePath);
66            return uriForFeaturePath.filter(uri -> lineFilters.get(uri).contains(tableRow.getLocation().getLine())).isPresent();
67        }
68        return false;
69    }
70
71    private boolean lineFiltersContainFeaturePath(URI featurePath) {
72        return getURIForFeaturePath(featurePath) != null;
73    }
74}
75

Source: LineFilters.java

package io.cucumber.core.plugin;

import io.cucumber.core.internal.gherkin.ast.Examples;
import io.cucumber.core.internal.gherkin.ast.TableRow;
import net.serenitybdd.cucumber.CucumberWithSerenity;

import java.net.URI;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

public class LineFilters {

    private Map<URI, Set<Integer>> lineFilters;

    public LineFilters() {
        lineFilters = newLineFilters();
    }

    public static LineFilters forCurrentContext() {
        return new LineFilters();
    }

    public Optional<URI> getURIForFeaturePath(URI featurePath) {
        return lineFilters.keySet().stream()
                .filter(uri -> featurePath.equals(uri))
                .findFirst();
    }

    private Map<URI, Set<Integer>> newLineFilters() {
        Map<URI, Set<Integer>> lineFiltersFromRuntime = CucumberWithSerenity.currentRuntimeOptions().getLineFilters();
        if (lineFiltersFromRuntime == null) {
            return new HashMap<>();
        } else {
            return lineFiltersFromRuntime;
        }
    }

    public Set<Integer> getLineNumbersFor(URI featurePath) {
        return lineFilters.get(featurePath);
    }


    public boolean examplesAreNotExcluded(Examples examples, URI featurePath) {
        if (lineFilters.isEmpty()) {
            return true;
        }
        if (lineFiltersContainFeaturePath(featurePath)) {
            Optional<URI> uriForFeaturePath = getURIForFeaturePath(featurePath);
            return uriForFeaturePath.filter(
                    uri -> examples.getTableBody().stream()
                            .anyMatch(
                                    row -> lineFilters.get(uri).contains(row.getLocation().getLine()))
            ).isPresent();
        }
        return false;
    }

    public boolean tableRowIsNotExcludedBy(TableRow tableRow, URI featurePath) {
        if (lineFilters.isEmpty()) {
            return true;
        }
        if (lineFiltersContainFeaturePath(featurePath)) {
            Optional<URI> uriForFeaturePath = getURIForFeaturePath(featurePath);
            return uriForFeaturePath.filter(uri -> lineFilters.get(uri).contains(tableRow.getLocation().getLine())).isPresent();
        }
        return false;
    }

    private boolean lineFiltersContainFeaturePath(URI featurePath) {
        return getURIForFeaturePath(featurePath) != null;
    }
}