com.sonar.sslr.api.typed.ActionParser Java Examples

public static Collection<CheckMessage> getIssues(String relativePath, CssCheck check, ActionParser<Tree> parser) {
  File file = new File(relativePath);

  TreeImpl tree = (TreeImpl) parser.parse(file);
  CssTreeVisitorContext context = new CssTreeVisitorContext(tree, file, "css");
  List<Issue> issues = check.scanFile(context);

  return getCheckMessages(issues);
}
 

private static EsqlVisitorContext createContext(InputFile file, ActionParser<Tree> parser) {
    try {
        ProgramTree programTree = (ProgramTree) parser.parse(file.contents());
        return new EsqlVisitorContext(programTree, file, new MapSettings().asConfig());
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

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));
}
 

@Before
public void setUp() throws Exception {
  LexerlessGrammarBuilder b = EsqlLegacyGrammar.createGrammarBuilder();
  // Only called to completed the grammar
  new ActionParser<AstNode>(Charsets.UTF_8, b, EsqlGrammar.class, new TreeFactory(), new AstNodeBuilder(), EsqlLegacyGrammar.SPACING);
  g = b.build();
}
 

private void parse(File esql) {
	ActionParser parser = new ActionParser<>(Charsets.UTF_8, EsqlLegacyGrammar.createGrammarBuilder(), EsqlGrammar.class,
			new TreeFactory(), new EsqlNodeBuilder(), EsqlLegacyGrammar.PROGRAM);
    try{
    	parser.parse(esql);
   	} catch(RecognitionException e ){
   		System.err.println("Cannot parse "+esql.toPath());
   		throw e;
   	}

	
}
 

private static void verify(CssCheck check, File file, Charset charset, ActionParser<Tree> parser, String language) {

    TreeImpl tree = (TreeImpl) parser.parse(file);
    CssTreeVisitorContext context = new CssTreeVisitorContext(tree, file, language);

    CssCheckVerifier checkVerifier = new CssCheckVerifier();
    checkVerifier.scanFile(context);

    List<TestIssue> expectedIssues = checkVerifier.expectedIssues
      .stream()
      .sorted((i1, i2) -> Integer.compare(i1.line(), i2.line()))
      .collect(Collectors.toList());

    if (check instanceof CharsetAwareVisitor) {
      ((CharsetAwareVisitor) check).setCharset(charset);
    }
    Iterator<Issue> actualIssues = getActualIssues(check, context);

    for (TestIssue expected : expectedIssues) {
      if (actualIssues.hasNext()) {
        verifyIssue(expected, actualIssues.next(), file);
      } else {
        throw new AssertionError("Missing issue at line " + expected.line() + " in file " + file.getAbsolutePath());
      }
    }

    if (actualIssues.hasNext()) {
      Issue issue = actualIssues.next();
      throw new AssertionError("Unexpected issue at line " + line(issue) + ": \"" + message(issue) + "\"" + " in file " + file.getAbsolutePath());
    }
  }
 

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

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

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

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

@Override
public ActionParser<Tree> parser(FileSystem fileSystem) {
  return LessParser.createParser(fileSystem.encoding());
}
 

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

private static ActionParser<Tree> newParser() {
    return EsqlParserBuilder.createParser();
}
 

public ParserAssert(ActionParser<Tree> actual) {
  super(ParserAssert.class, actual);
}
 

public static ActionParser<Tree> createParser(Charset charset) {
  return createParser(charset, LexicalGrammar.FILE_WITH_EMBEDDED_CSS);
}
 

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

}
 

private TestVisitor getTestVisitor(String code) {
	ActionParser<Tree> p = EsqlParserBuilder.createParser();
	TestVisitor testVisitor = new TestVisitor();
	testVisitor.visitProgram((ProgramTree) p.parse(code));
	return testVisitor;
}
 

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

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

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

public ActionParser<Tree> parser() {
  return parser;
}
 

@Override
public ActionParser<Tree> parser(FileSystem fileSystem) {
  return ScssParser.createParser(fileSystem.encoding());
}
 

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

@Override
public ActionParser<Tree> parser(FileSystem fileSystem) {
  return EmbeddedCssParser.createParser(fileSystem.encoding());
}
 

@Override
public ActionParser<Tree> parser(FileSystem fileSystem) {
  return CssParser.createParser(fileSystem.encoding());
}
 

public static ActionParser<Tree> createParser(Charset charset) {
  return createParser(charset, LexicalGrammar.STYLESHEET);
}
 

public ActionParser<Tree> parser() {
  return parser;
}
 

public ActionParser<Tree> parser() {
  return parser;
}
 

public ActionParser<Tree> parser() {
  return parser;
}
 

public ActionParser<Tree> parser() {
  return parser;
}