org.sonar.sslr.grammar.GrammarRuleKey Java Examples

public static ParserAssert assertThat(LexerlessGrammarBuilder b, GrammarRuleKey rule) {
  return new ParserAssert(new ActionParser<Tree>(
    Charsets.UTF_8,
    b,
    EsqlGrammar.class,
    new TreeFactory(),
    new EsqlNodeBuilder(),
    rule));
}
 

private static ActionParser<Tree> createParser(Charset charset, GrammarRuleKey rootRule) {
  return new CssParser(
    charset,
    LexicalGrammar.createCssGrammar(),
    CssGrammar.class,
    new TreeFactory(),
    new CssNodeBuilder(),
    rootRule);
}
 

private void test_binary_expression(String str, GrammarRuleKey rule, Kind kind, String operator) throws Exception {
	BinaryExpressionTree tree = parse(str, rule, kind);

	assertThat(tree.is(kind)).isTrue();
	assertThat(tree.leftOperand()).isNotNull();
	assertThat(tree.operator().text()).isEqualTo(operator);
	assertThat(tree.rightOperand()).isNotNull();

	tree = (BinaryExpressionTree) tree.leftOperand();

	assertThat(tree.is(kind)).isTrue();
	assertThat(tree.leftOperand()).isNotNull();
	assertThat(tree.operator().text()).isEqualTo(operator);
	assertThat(tree.rightOperand()).isNotNull();
}
 

private static ActionParser<Tree> createParser(Charset charset, GrammarRuleKey rootRule) {
  return new EmbeddedCssParser(
    charset,
    LexicalGrammar.createEmbeddedCssGrammar(),
    EmbeddedCssGrammar.class,
    new TreeFactory(),
    new EmbeddedCssNodeBuilder(),
    rootRule);
}
 

@Override
public Object createNonTerminal(GrammarRuleKey ruleKey, Rule rule, List<Object> children, int startIndex, int endIndex) {
  for (Object child : children) {
    if (child instanceof InternalSyntaxToken) {
      return child;
    }
  }
  return new InternalSyntaxSpacing();
}
 

private static ActionParser<Tree> createParser(Charset charset, GrammarRuleKey rootRule) {
  return new LessParser(
    charset,
    LexicalGrammar.createLessGrammar(),
    LessGrammar.class,
    new TreeFactory(),
    new LessNodeBuilder(),
    rootRule);
}
 

@Override
public Object createNonTerminal(GrammarRuleKey ruleKey, Rule rule, List<Object> children, int startIndex, int endIndex) {
  for (Object child : children) {
    if (child instanceof InternalSyntaxToken) {
      return child;
    }
  }
  return new InternalSyntaxSpacing(startIndex, endIndex);
}
 

public EsqlParser(GrammarRuleKey rootRule) {
  super(
    Charset.defaultCharset(),
    EsqlLegacyGrammar.createGrammarBuilder(),
    EsqlGrammar.class,
    new TreeFactory(),
    new EsqlNodeBuilder(),
    rootRule);
}
 

@Override
public Object createNonTerminal(GrammarRuleKey ruleKey, Rule rule, List<Object> children, int startIndex, int endIndex) {
  for (Object child : children) {
    if (child instanceof InternalSyntaxToken) {
      return child;
    }
  }
  return new InternalSyntaxSpacing(startIndex, endIndex);
}
 

private static ActionParser<Tree> createParser(Charset charset, GrammarRuleKey rootRule) {
  return new ScssParser(
    charset,
    LexicalGrammar.createScssGrammar(),
    ScssGrammar.class,
    new TreeFactory(),
    new ScssNodeBuilder(),
    rootRule);
}
 

private static GherkinParser createParser(Charset charset, GrammarRuleKey rootRule, String language) {
  return new GherkinParser(
    charset,
    GherkinLexicalGrammar.createGrammar(language),
    GherkinGrammar.class,
    new TreeFactory(),
    new GherkinNodeBuilder(),
    rootRule);
}
 

protected void setRootRule(GrammarRuleKey ruleKey) {
    parser.setRootRule(parser.getGrammar().rule(ruleKey));
}
 

public static ParserAssert assertThat(GrammarRuleKey rule) {
  return assertThat(EsqlLegacyGrammar.createGrammarBuilder(), rule);
}
 

private ActionParser<Tree> getParser(GrammarRuleKey rule){
	return  new ActionParser<>(Charsets.UTF_8, EsqlLegacyGrammar.createGrammarBuilder(), EsqlGrammar.class,
			new TreeFactory(), new EsqlNodeBuilder(), rule);

}
 

public static ActionParser<Tree> createParser(GrammarRuleKey rootRule){
 return new EsqlParser(rootRule);
}
 

public static GherkinParser createTestParser(Charset charset, GrammarRuleKey rootRule) {
  return createParser(charset, rootRule, GherkinDialectProvider.DEFAULT_LANGUAGE);
}
 

public static GherkinParser createTestParser(Charset charset, GrammarRuleKey rootRule, String language) {
  return createParser(charset, rootRule, language);
}
 

public GherkinParser(Charset charset, LexerlessGrammarBuilder grammarBuilder, Class<GherkinGrammar> grammarClass,
                     TreeFactory treeFactory, GherkinNodeBuilder nodeBuilder, GrammarRuleKey rootRule) {
  super(charset, grammarBuilder, grammarClass, treeFactory, nodeBuilder, rootRule);
}
 

public AbstractParser(Charset charset, LexerlessGrammarBuilder grammarBuilder, Class<? extends CssGrammar> grammarClass,
                      TreeFactory treeFactory, AbstractNodeBuilder nodeBuilder, GrammarRuleKey rootRule) {
  super(charset, grammarBuilder, grammarClass, treeFactory, nodeBuilder, rootRule);
}
 

@VisibleForTesting
public static ActionParser<Tree> createTestParser(Charset charset, GrammarRuleKey rootRule) {
  return createParser(charset, rootRule);
}
 

private ScssParser(Charset charset, LexerlessGrammarBuilder grammarBuilder, Class<ScssGrammar> scssGrammarClass,
                   TreeFactory treeFactory, ScssNodeBuilder scssNodeBuilder, GrammarRuleKey rootRule) {
  super(charset, grammarBuilder, scssGrammarClass, treeFactory, scssNodeBuilder, rootRule);
}
 

@VisibleForTesting
public static ActionParser<Tree> createTestParser(Charset charset, GrammarRuleKey rootRule) {
  return createParser(charset, rootRule);
}
 

private LessParser(Charset charset, LexerlessGrammarBuilder grammarBuilder, Class<LessGrammar> lessGrammarClass,
  TreeFactory treeFactory, LessNodeBuilder lessNodeBuilder, GrammarRuleKey rootRule) {
  super(charset, grammarBuilder, lessGrammarClass, treeFactory, lessNodeBuilder, rootRule);
}
 

@VisibleForTesting
public static ActionParser<Tree> createTestParser(Charset charset, GrammarRuleKey rootRule) {
  return createParser(charset, rootRule);
}
 

private EmbeddedCssParser(Charset charset, LexerlessGrammarBuilder grammarBuilder, Class<EmbeddedCssGrammar> embeddedCssGrammarClass,
  TreeFactory treeFactory, EmbeddedCssNodeBuilder embeddedCssNodeBuilder, GrammarRuleKey rootRule) {
  super(charset, grammarBuilder, embeddedCssGrammarClass, treeFactory, embeddedCssNodeBuilder, rootRule);
}
 

@VisibleForTesting
public static ActionParser<Tree> createTestParser(Charset charset, GrammarRuleKey rootRule) {
  return createParser(charset, rootRule);
}
 

private CssParser(Charset charset, LexerlessGrammarBuilder grammarBuilder, Class<CssGrammar> cssGrammarClass,
  TreeFactory treeFactory, CssNodeBuilder cssNodeBuilder, GrammarRuleKey rootRule) {
  super(charset, grammarBuilder, cssGrammarClass, treeFactory, cssNodeBuilder, rootRule);
}
 

/**
 * Parse the given string and return the first descendant of the given kind.
 *
 * @param s
 *            the string to parse
 * @param rule
 *            the rule used to parse the string
 * @param descendantToReturn
 *            the node kind to seek in the generated tree
 * @return the node found for the given kind, null if not found.
 */
@SuppressWarnings("unchecked")
protected T parse(String s, GrammarRuleKey rule, Kind descendantToReturn) throws Exception {
	Tree node = getParser(rule).parse(s);
	checkFullFidelity(node, s);
	return (T) getFirstDescendant((EsqlTree) node, descendantToReturn);
}