import gherkin.ast.Node; //导入依赖的package包/类
private void processScenarioOutlineExamples(
        final Map<Integer, AstNode> nodeMap, final ScenarioOutline scenarioOutline, final AstNode childNode
) {
    scenarioOutline.getExamples().forEach(examples -> {
        final AstNode examplesNode = new AstNode(examples, childNode);
        final TableRow headerRow = examples.getTableHeader();
        final AstNode headerNode = new AstNode(headerRow, examplesNode);
        nodeMap.put(headerRow.getLocation().getLine(), headerNode);
        IntStream.range(0, examples.getTableBody().size()).forEach(i -> {
            final TableRow examplesRow = examples.getTableBody().get(i);
            final Node rowNode = new CucumberSourceUtils.ExamplesRowWrapperNode(examplesRow, i);
            final AstNode expandedScenarioNode = new AstNode(rowNode, examplesNode);
            nodeMap.put(examplesRow.getLocation().getLine(), expandedScenarioNode);
        });
    });
}
 

import gherkin.ast.Node; //导入依赖的package包/类
/**
 * Converts a list of Gherkin steps to Cucable steps including data tables.
 *
 * @param gherkinSteps a {@link Step} list.
 * @return a {@link com.trivago.rta.vo.Step} list.
 */
List<com.trivago.rta.vo.Step> convertGherkinStepsToCucableSteps(final List<Step> gherkinSteps) {
    List<com.trivago.rta.vo.Step> steps = new ArrayList<>();

    for (Step gherkinStep : gherkinSteps) {
        com.trivago.rta.vo.Step step;
        com.trivago.rta.vo.DataTable dataTable = null;

        Node argument = gherkinStep.getArgument();
        if (argument instanceof DataTable) {
            dataTable = convertGherkinDataTableToCucumberDataTable((DataTable) argument);
        }

        String keywordAndName = gherkinStep.getKeyword().concat(gherkinStep.getText());
        step = new com.trivago.rta.vo.Step(keywordAndName, dataTable);
        steps.add(step);
    }
    return steps;
}
 

import gherkin.ast.Node; //导入依赖的package包/类
private void processStep(Step step, List<StepDefinition> stepDefinitions)
{
    String keyword = step.getKeyword().trim();
    String text = step.getText().trim();
    Node argument = step.getArgument();

    testLog.logStep(keyword, text);

    for (StepDefinition stepDefinition : stepDefinitions)
    {
        if (stepDefinition.matches(text))
        {
            stepDefinition.invoke(text, argument);
            return;
        }
    }

    throw new StepDefinitionNotFoundException(keyword, text);
}
 

import gherkin.ast.Node; //导入依赖的package包/类
private List<Argument> createPickleArguments(Node argument, List<TableCell> variableCells, List<TableCell> valueCells, String path) {
    List<Argument> result = new ArrayList<>();
    if (argument == null) return result;
    if (argument instanceof DataTable) {
        DataTable t = (DataTable) argument;
        List<TableRow> rows = t.getRows();
        List<PickleRow> newRows = new ArrayList<>(rows.size());
        for (TableRow row : rows) {
            List<TableCell> cells = row.getCells();
            List<PickleCell> newCells = new ArrayList<>();
            for (TableCell cell : cells) {
                newCells.add(
                        new PickleCell(
                                pickleLocation(cell.getLocation(), path),
                                interpolate(cell.getValue(), variableCells, valueCells)
                        )
                );
            }
            newRows.add(new PickleRow(newCells));
        }
        result.add(new PickleTable(newRows));
    } else if (argument instanceof DocString) {
        DocString ds = (DocString) argument;
        result.add(
                new PickleString(
                        pickleLocation(ds.getLocation(), path),
                        interpolate(ds.getContent(), variableCells, valueCells)
                )
        );
    } else {
        throw new RuntimeException("Unexpected argument type: " + argument);
    }
    return result;
}
 

import gherkin.ast.Node; //导入依赖的package包/类
private void checkNodeSpelling(SensorContext sensorContext,
                               InputFile inputFile,
                               JLanguageTool langTool,
                               Node node,
                               String nodeText) throws IOException {
  List<RuleMatch> matches = langTool.check(nodeText);

  for (RuleMatch match : matches) {
    createSpellCheckIssueObject(sensorContext, inputFile, node, match);
  }
}
 

import gherkin.ast.Node; //导入依赖的package包/类
private List<Argument> createPickleArguments(Node argument, List<TableCell> variableCells, List<TableCell> valueCells) {
    List<Argument> result = new ArrayList<>();
    if (argument == null) return result;
    if (argument instanceof DataTable) {
        DataTable t = (DataTable) argument;
        List<TableRow> rows = t.getRows();
        List<PickleRow> newRows = new ArrayList<>(rows.size());
        for (TableRow row : rows) {
            List<TableCell> cells = row.getCells();
            List<PickleCell> newCells = new ArrayList<>();
            for (TableCell cell : cells) {
                newCells.add(
                        new PickleCell(
                                pickleLocation(cell.getLocation()),
                                interpolate(cell.getValue(), variableCells, valueCells)
                        )
                );
            }
            newRows.add(new PickleRow(newCells));
        }
        result.add(new PickleTable(newRows));
    } else if (argument instanceof DocString) {
        DocString ds = (DocString) argument;
        result.add(
                new PickleString(
                        pickleLocation(ds.getLocation()),
                        interpolate(ds.getContent(), variableCells, valueCells)
                )
        );
    } else {
        throw new RuntimeException("Unexpected argument type: " + argument);
    }
    return result;
}
 

import gherkin.ast.Node; //导入依赖的package包/类
ExamplesRowWrapperNode(final Node examplesRow, final int bodyRowIndex) {
    super(examplesRow.getLocation());
    this.bodyRowIndex = bodyRowIndex;
}
 

import gherkin.ast.Node; //导入依赖的package包/类
AstNode(final Node node, final AstNode parent) {
    this.node = node;
    this.parent = parent;
}
 

import gherkin.ast.Node; //导入依赖的package包/类
public Node getNode() {
    return node;
}
 

import gherkin.ast.Node; //导入依赖的package包/类
private void createSpellCheckIssueObject(SensorContext sensorContext,
                                         InputFile inputFile,
                                         Node node,
                                         RuleMatch match) {

  // TODO: Don't hardcode the ruleKey
  RuleKey ruleKey = RuleKey.of(GherkinRulesDefinition.REPOSITORY_NAME, "SpellCheck");

  try {

    TextRange textRange = inputFile.newRange(
            node.getLocation().getLine(),
            match.getColumn(),
            node.getLocation().getLine(),
            match.getEndColumn()
    );

    NewIssue newIssue = sensorContext.newIssue();

    String suggestedReplace = "";

    if (!match.getSuggestedReplacements().isEmpty()) {
      suggestedReplace = " - replace it with:";
      for (String suggest: match.getSuggestedReplacements()
              ) {
        suggestedReplace = suggestedReplace + " " + suggest + ";";
      }
    }

    NewIssueLocation primaryLocation = newIssue.newLocation()
            .message(match.getMessage() + suggestedReplace)
            .on(inputFile)
            .at(textRange);

    newIssue.forRule(ruleKey).at(primaryLocation);
    newIssue.save();

  } catch (IllegalArgumentException iarg) {
    LOG.error("SpellCheck rule is an error when create issue: \n" +
            "file is: " + inputFile.relativePath() + "\n" +
            "match is:" + match.getMessage() + "\n" +
            "line is:" + node.getLocation().getLine() + "\n" +
            "offsets is: start - " + match.getColumn() + " to " + match.getEndColumn(),
            iarg);
  }

}