com.palantir.ls.groovy.GroovyTreeParser java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 OutputStreamWriter o =OutputStream out;new OutputStreamWriter(out)
OutputStream out;String charsetName;new OutputStreamWriter(out, charsetName)
HttpURLConnection connection;new OutputStreamWriter(connection.getOutputStream())
Smart code suggestions by Tabnine
}

@Test
public void testComputeAllSymbols_interface() throws InterruptedException, ExecutionException, IOException {
  addFileToFolder(workspaceRoot, "my/folder", "ICoordinates.groovy",
      "interface ICoordinates {\n"
          + "   abstract double getAt(int idx);\n"
          + "}\n");
  parser.parseAllSymbols();
  Map<URI, Set<SymbolInformation>> symbols = parser.getFileSymbols();
  // The symbols will contain a lot of inherited and default fields and methods, so we just check to make sure it
  // contains our custom fields and methods.
  assertThat(mapHasSymbol(symbols, Optional.absent(), "ICoordinates", SymbolKind.Interface)).isTrue();
  assertThat(mapHasSymbol(symbols, Optional.of("ICoordinates"), "getAt", SymbolKind.Method)).isTrue();
  assertThat(mapHasSymbol(symbols, Optional.of("getAt"), "idx", SymbolKind.Variable)).isTrue();
}

    GroovyWorkspaceCompiler.of(targetDirectory, workspaceRoot, changedFilesDirectory);
TreeParser parser =
    GroovyTreeParser.of(compiler, workspaceRoot,
        new WorkspaceUriSupplier(workspaceRoot, changedFilesDirectory));
DefaultCompilerWrapper groovycWrapper = new DefaultCompilerWrapper(compiler, parser);

/**
 * Creates a new instance of GroovyTreeParser.
 *
 * @param unitSupplier
 *        the supplier of compilation unit to be parsed
 * @param workspaceRoot
 *        the directory to compile
 * @param workspaceUriSupplier
 *        the provider use to resolve uris
 * @return the newly created GroovyTreeParser
 */
@SuppressFBWarnings("PT_FINAL_TYPE_RETURN")
public static GroovyTreeParser of(Supplier<CompilationUnit> unitSupplier, Path workspaceRoot,
    UriSupplier workspaceUriSupplier) {
  checkNotNull(unitSupplier, "unitSupplier must not be null");
  checkNotNull(workspaceRoot, "workspaceRoot must not be null");
  checkNotNull(workspaceUriSupplier, "workspaceUriSupplier must not be null");
  checkArgument(workspaceRoot.toFile().isDirectory(), "workspaceRoot must be a directory");
  return new GroovyTreeParser(unitSupplier, workspaceRoot, workspaceUriSupplier);
}

@Test
public void testReferences_typeEnumOneLine() throws IOException {
  // edge case on one line
  File enumFile = addFileToFolder(workspaceRoot, "MyEnum.groovy",
      "enum MyEnum {ONE,TWO}\n");
  File scriptFile = addFileToFolder(workspaceRoot, "MyScript.groovy",
      "MyEnum a\n\n");
  parser.parseAllSymbols();
  // Find one line enum correctly
  Set<Location> myEnumExpectedResult = Sets.newHashSet(
          createLocation(scriptFile.toPath(), Ranges.createRange(0, 0, 0, 6)));
  assertEquals(myEnumExpectedResult,
      parser.findReferences(createReferenceParams(enumFile.toURI(), 0, 6, false)));
}

        createSymbolInformation(clazz.getName(), getKind(clazz),
            GroovyLocations.createClassDefinitionLocation(sourceUri, clazz),
            Optional.fromNullable(clazz.getOuterClass()).transform(ClassNode::getName));
    SymbolInformation symbol = getVariableSymbolInformation(clazz.getName(), sourceUri, field);
    newIndexer.addSymbol(sourceUri, symbol);
    if (classes.containsKey(field.getType().getName())) {
      .forEach(method -> parseMethod(newIndexer, sourceUri, clazz, classes, classFields, method));
});
      variable -> {
        SymbolInformation symbol =
            getVariableSymbolInformation(scriptClass.getName(), sourceUri, variable);
        newIndexer.addSymbol(sourceUnit.getSource().getURI(), symbol);
        if (classes.containsKey(variable.getType().getName())) {

@Override
public CompletionList getCompletion(URI uri, Position position) {
  return CompletionUtils.createCompletionListFromSymbols(getFileSymbols().get(uri));
}

@Test
public void testGotoDefinition_multipleFiles() throws IOException {
  File dog = addFileToFolder(workspaceRoot, "mydogfolder", "Dog.groovy",
      "public class Dog {}\n");
  File cat = addFileToFolder(workspaceRoot, "mycatfolder", "Cat.groovy",
      "public class Cat {\n"
          + "   public static Dog dog = new Dog()\n"
          + "   public static Dog foo() {\n"
          + "       Dog newDog = new Dog()\n"
          + "       foo()\n"
          + "       return newDog\n"
          + "   }\n"
          + "}\n");
  parser.parseAllSymbols();
  // Dog class
  Location expectedLocation = new Location(dog.toPath().toUri().toString(), Ranges.createRange(0, 0, 0, 19));
  assertEquals(Optional.of(expectedLocation), parser.gotoDefinition(cat.toURI(), new Position(1, 18)));
  assertEquals(Optional.of(expectedLocation), parser.gotoDefinition(cat.toURI(), new Position(2, 18)));
  assertEquals(Optional.of(expectedLocation), parser.gotoDefinition(cat.toURI(), new Position(3, 8)));
  assertEquals(Optional.of(expectedLocation), parser.gotoDefinition(cat.toURI(), new Position(3, 25)));
  // newDog local variable
  expectedLocation = new Location(cat.toPath().toUri().toString(), Ranges.createRange(3, 11, 3, 17));
  assertEquals(Optional.of(expectedLocation), parser.gotoDefinition(cat.toURI(), new Position(5, 18)));
  // foo method
  // TODO(#124): make this more accurate
  expectedLocation = new Location(cat.toPath().toUri().toString(), Ranges.createRange(2, 3, 6, 4));
  assertEquals(Optional.of(expectedLocation), parser.gotoDefinition(cat.toURI(), new Position(4, 10)));
}

private void parseMethod(Indexer newIndexer, URI sourceUri, ClassNode parent, Map<String, Location> classes,
    Map<String, FieldNode> classFields, MethodNode method) {
  SymbolInformation methodSymbol =
      createSymbolInformation(method.getName(), SymbolKind.Method,
          GroovyLocations.createLocation(sourceUri, method), Optional.of(parent.getName()));
  newIndexer.addSymbol(sourceUri, methodSymbol);
  // Method parameters
  method.getVariableScope().getDeclaredVariables().values().forEach(variable -> {
    SymbolInformation variableSymbol = getVariableSymbolInformation(method.getName(), sourceUri, variable);
    newIndexer.addSymbol(sourceUri, variableSymbol);
    if (classes.containsKey(variable.getType().getName())) {
      newIndexer.addReference(classes.get(variable.getType().getName()),
          GroovyLocations.createLocation(sourceUri, variable.getType()));
    }
  });
  // Return type
  if (classes.containsKey(method.getReturnType().getName())) {
    newIndexer.addReference(classes.get(method.getReturnType().getName()),
        GroovyLocations.createLocation(sourceUri, method.getReturnType()));
  }
  // We only want to visit the method if its not generated
  if (Ranges.isValid(methodSymbol.getLocation().getRange())) {
    // Visit the method
    if (method.getCode() instanceof BlockStatement) {
      BlockStatement blockStatement = (BlockStatement) method.getCode();
      blockStatement.visit(new MethodVisitor(newIndexer, sourceUri, parent, classes, classFields,
          Optional.of(method), workspaceUriSupplier));
    }
  }
}

        + "   abstract double getAt(int idx);\n"
        + "}\n");
parser.parseAllSymbols();
Set<SymbolInformation> filteredSymbols = parser.getFilteredSymbols("Coordinates");
assertEquals(Sets.newHashSet(new SymbolInformation(
        "Coordinates",
filteredSymbols = parser.getFilteredSymbols("Coordinates*");
assertEquals(Sets.newHashSet(
    new SymbolInformation(
filteredSymbols = parser.getFilteredSymbols("Coordinates?");
assertEquals(NO_SYMBOLS, filteredSymbols);
filteredSymbols = parser.getFilteredSymbols("*Coordinates*");
assertThat(filteredSymbols).containsExactlyInAnyOrder(
    new SymbolInformation(
filteredSymbols = parser.getFilteredSymbols("Coordinates???");
assertEquals(Sets.newHashSet(
    new SymbolInformation(
        "Coordinates")),
    filteredSymbols);
filteredSymbols = parser.getFilteredSymbols("Coordinates...");
assertEquals(NO_SYMBOLS, filteredSymbols);
filteredSymbols = parser.getFilteredSymbols("*Coordinates...*");
assertEquals(NO_SYMBOLS, filteredSymbols);

@Override
public Set<SymbolInformation> getFilteredSymbols(String query) {
  checkNotNull(query, "query must not be null");
  Pattern pattern = getQueryPattern(query);
  return indexer.getFileSymbols().values().stream().flatMap(Collection::stream)
      .filter(symbol -> pattern.matcher(symbol.getName()).matches())
      .collect(Collectors.toSet());
}

@Test
public void testReferences_catchStatement() throws IOException {
  File file = addFileToFolder(workspaceRoot, "Coordinates.groovy",
      "class Foo extends Throwable{}\n"
          + "try {\n"
          + "   println \"Hello\""
          + "}\n catch (Foo e1) {\n"
          + "   println e1\n"
          + "}\n");
  parser.parseAllSymbols();
  // Class Foo
  Set<Location> expectedReferences =
      Sets.newHashSet(createLocation(file.toPath(), Ranges.createRange(3, 8, 3, 11)));
  // Get references when providing definition position
  assertEquals(expectedReferences, parser.findReferences(createReferenceParams(file.toURI(), 0, 6, false)));
  // Get references when providing position of usage
  assertEquals(expectedReferences,  parser.findReferences(createReferenceParams(file.toURI(), 3, 9, false)));
  // TODO(#125): add a symbol for the exception variables and test here.
}

@Test
public void testNotParsedYet() throws IOException {
  assertEquals(NO_SYMBOLS,
      parser.getFileSymbols().values().stream().flatMap(Collection::stream).collect(Collectors.toSet()));
}

        + "   }\n"
        + "}\n");
parser.parseAllSymbols();
assertEquals(expectedLocation, parser.gotoDefinition(file.toURI(), new Position(1, 15)).get());
assertEquals(expectedLocation, parser.gotoDefinition(file.toURI(), new Position(10, 10)).get());
assertEquals(expectedLocation, parser.gotoDefinition(file.toURI(), new Position(10, 31)).get());
assertEquals(expectedLocation, parser.gotoDefinition(file.toURI(), new Position(12, 12)).get());
assertEquals(expectedLocation, parser.gotoDefinition(file.toURI(), new Position(14, 11)).get());
assertEquals(expectedLocation, parser.gotoDefinition(file.toURI(), new Position(11, 15)).get());
assertEquals(expectedLocation, parser.gotoDefinition(file.toURI(), new Position(13, 10)).get());
assertEquals(expectedLocation, parser.gotoDefinition(file.toURI(), new Position(11, 23)).get());
assertEquals(expectedLocation, parser.gotoDefinition(file.toURI(), new Position(12, 23)).get());
assertEquals(expectedLocation, parser.gotoDefinition(file.toURI(), new Position(13, 23)).get());
assertEquals(expectedLocation, parser.gotoDefinition(file.toURI(), new Position(14, 20)).get());
assertEquals(expectedLocation, parser.gotoDefinition(file.toURI(), new Position(15, 20)).get());

@Test
public void testReferences_typeInnerClassOneLine() throws IOException {
  // edge case on one line
  File innerClass = addFileToFolder(workspaceRoot, "AandB.groovy",
      "public class A {public static class B {}\n"
          + "A a\n"
          + "B b\n"
          + "}\n");
  parser.parseAllSymbols();
  // Identify type A correctly
  Set<Location> typeAExpectedResult = Sets.newHashSet(
          createLocation(innerClass.toPath(), Ranges.createRange(1, 0, 1, 1)));
  assertEquals(typeAExpectedResult,
      parser.findReferences(createReferenceParams(innerClass.toURI(), 0, 6, false)));
  // Identify type B correctly
  Set<Location> typeBExpectedResult = Sets.newHashSet(
          createLocation(innerClass.toPath(), Ranges.createRange(2, 0, 2, 1)));
  assertEquals(typeBExpectedResult,
      parser.findReferences(createReferenceParams(innerClass.toURI(), 0, 17, false)));
}

@Test
public void testComputeAllSymbols_enum() throws InterruptedException, ExecutionException, IOException {
  addFileToFolder(workspaceRoot, "Type.groovy",
      "enum Type {\n"
          + "   ONE, TWO, THREE\n"
          + "}\n");
  parser.parseAllSymbols();
  Map<URI, Set<SymbolInformation>> symbols = parser.getFileSymbols();
  // The symbols will contain a lot of inherited and default fields and methods, so we just check to make sure it
  // contains our custom fields and methods.
  assertThat(mapHasSymbol(symbols, Optional.absent(), "Type", SymbolKind.Enum)).isTrue();
  assertThat(mapHasSymbol(symbols, Optional.of("Type"), "ONE", SymbolKind.Field)).isTrue();
  assertThat(mapHasSymbol(symbols, Optional.of("Type"), "TWO", SymbolKind.Field)).isTrue();
  assertThat(mapHasSymbol(symbols, Optional.of("Type"), "THREE", SymbolKind.Field)).isTrue();
}

@Test
public void testWorkspaceRootNotFolder() throws IOException {
  expectedException.expect(IllegalArgumentException.class);
  expectedException.expectMessage("workspaceRoot must be a directory");
  GroovyTreeParser.of(() -> null, tempFolder.newFile().toPath(), uriSupplier);
}

        + "   }\n"
        + "}\n");
parser.parseAllSymbols();
assertEquals(NO_REFERENCES, parser.findReferences(createReferenceParams(file.toURI(), 7, 0, false)));
assertEquals(NO_REFERENCES, parser.findReferences(createReferenceParams(file.toURI(), 10, 2, false)));
assertEquals(expectedResult, parser.findReferences(createReferenceParams(file.toURI(), 13, 9, false)));

@Test
public void testComputeAllSymbols_script()
    throws InterruptedException, ExecutionException, IOException {
  addFileToFolder(workspaceRoot, "test.groovy",
      "def name = \"Natacha\"\n"
          + "def myMethod() {\n"
          + "   def someString = \"Also in symbols\"\n"
          + "   println \"Hello World\"\n"
          + "}\n"
          + "println name\n"
          + "myMethod()\n");
  parser.parseAllSymbols();
  Map<URI, Set<SymbolInformation>> symbols = parser.getFileSymbols();
  assertThat(mapHasSymbol(symbols, Optional.of("test"), "myMethod", SymbolKind.Method)).isTrue();
  assertThat(mapHasSymbol(symbols, Optional.of("test"), "name", SymbolKind.Variable)).isTrue();
  assertThat(mapHasSymbol(symbols, Optional.of("myMethod"), "someString", SymbolKind.Variable)).isTrue();
}

@Before
public void setup() throws IOException {
  workspaceRoot = tempFolder.newFolder();
  Path changedOutput = tempFolder.newFolder().toPath();
  Path target = tempFolder.newFolder().toPath();
  uriSupplier = new WorkspaceUriSupplier(workspaceRoot.toPath(), changedOutput);
  parser = GroovyTreeParser.of(() -> {
    GroovyWorkspaceCompiler compiler =
        GroovyWorkspaceCompiler.of(target, workspaceRoot.toPath(), changedOutput);
    assertEquals(Sets.newHashSet(), compiler.compile(ImmutableSet.of()));
    return compiler.get();
  }, workspaceRoot.toPath(), uriSupplier);
}

@Test
public void testReferences_typeFields() throws IOException {
  File dogFile = addFileToFolder(workspaceRoot, "Dog.groovy",
      "class Dog {\n"
          + "   Cat friend1;\n"
          + "   Cat friend2;\n"
          + "   Cat bark(Cat enemy) {\n"
          + "      Cat myCat\n"
          + "      println \"Bark! \" + enemy.name\n"
          + "      return friend1\n"
          + "   }\n"
          + "}\n");
  File catFile = addFileToFolder(workspaceRoot, "Cat.groovy",
      "class Cat {\n"
          + "   public String name = \"Bobby\"\n"
          + "}\n");
  parser.parseAllSymbols();
  // Dog should have no references
  assertEquals(NO_REFERENCES, parser.findReferences(createReferenceParams(dogFile.toURI(), 0, 7, false)));
  Set<Location> expectedResult = Sets.newHashSet(
      createLocation(dogFile.toPath(), Ranges.createRange(1, 3, 1, 6)),
      createLocation(dogFile.toPath(), Ranges.createRange(2, 3, 2, 6)),
      createLocation(dogFile.toPath(), Ranges.createRange(3, 3, 3, 6)),
      createLocation(dogFile.toPath(), Ranges.createRange(3, 12, 3, 15)),
      createLocation(dogFile.toPath(), Ranges.createRange(4, 6, 4, 9)));
  assertEquals(expectedResult,
      parser.findReferences(createReferenceParams(catFile.toURI(), 0, 7, false)));
}

Javadoc

Groovy implementation of the TreeParser. Depends on a supplier of a Groovy CompilationUnit.

Most used methods

getFileSymbols
of
Creates a new instance of GroovyTreeParser.
<init>
createSymbolInformation
findReferences
getFilteredSymbols
getKind
getQueryPattern
getVariableSymbolInformation
gotoDefinition
parseAllSymbols
parseMethod

Popular in Java

Making http post requests using okhttp
startActivity (Activity)
getSupportFragmentManager (FragmentActivity)
setContentView (Activity)
EOFException (java.io)
Thrown when a program encounters the end of a file or stream during an input operation.
Collections (java.util)
This class consists exclusively of static methods that operate on or return collections. It contains
Servlet (javax.servlet)
Defines methods that all servlets must implement. A servlet is a small Java program that runs within
IsNull (org.hamcrest.core)
Is the value null?
Runner (org.openjdk.jmh.runner)
Scheduler (org.quartz)
This is the main interface of a Quartz Scheduler. A Scheduler maintains a registry of org.quartz.Job
Top 15 Vim Plugins

How to useGroovyTreeParser in com.palantir.ls.groovy

Best Java code snippets using com.palantir.ls.groovy.GroovyTreeParser (Showing top 20 results out of 315)

How to use
GroovyTreeParser
in
com.palantir.ls.groovy