congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
GroovyTreeParser
Code IndexAdd Tabnine to your IDE (free)

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

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

origin: palantir/language-servers

@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();
}
origin: palantir/language-servers

    GroovyWorkspaceCompiler.of(targetDirectory, workspaceRoot, changedFilesDirectory);
TreeParser parser =
    GroovyTreeParser.of(compiler, workspaceRoot,
        new WorkspaceUriSupplier(workspaceRoot, changedFilesDirectory));
DefaultCompilerWrapper groovycWrapper = new DefaultCompilerWrapper(compiler, parser);
origin: palantir/language-servers

/**
 * 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);
}
origin: palantir/language-servers

@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)));
}
origin: palantir/language-servers

        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())) {
origin: palantir/language-servers

@Override
public CompletionList getCompletion(URI uri, Position position) {
  return CompletionUtils.createCompletionListFromSymbols(getFileSymbols().get(uri));
}
origin: palantir/language-servers

@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)));
}
origin: palantir/language-servers

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));
    }
  }
}
origin: palantir/language-servers

        + "   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);
origin: palantir/language-servers

@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());
}
origin: palantir/language-servers

@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.
}
origin: palantir/language-servers

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

        + "   }\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());
origin: palantir/language-servers

@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)));
}
origin: palantir/language-servers

@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();
}
origin: palantir/language-servers

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

        + "   }\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)));
origin: palantir/language-servers

@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();
}
origin: palantir/language-servers

@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);
}
origin: palantir/language-servers

@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)));
}
com.palantir.ls.groovyGroovyTreeParser

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
  • parseAllSymbols,
  • parseMethod

Popular in Java

  • Finding current android device location
  • orElseThrow (Optional)
    Return the contained value, if present, otherwise throw an exception to be created by the provided s
  • requestLocationUpdates (LocationManager)
  • onCreateOptionsMenu (Activity)
  • Color (java.awt)
    The Color class is used to encapsulate colors in the default sRGB color space or colors in arbitrary
  • Container (java.awt)
    A generic Abstract Window Toolkit(AWT) container object is a component that can contain other AWT co
  • Graphics2D (java.awt)
    This Graphics2D class extends the Graphics class to provide more sophisticated control overgraphics
  • AtomicInteger (java.util.concurrent.atomic)
    An int value that may be updated atomically. See the java.util.concurrent.atomic package specificati
  • LogFactory (org.apache.commons.logging)
    Factory for creating Log instances, with discovery and configuration features similar to that employ
  • Loader (org.hibernate.loader)
    Abstract superclass of object loading (and querying) strategies. This class implements useful common
  • Top plugins for Android Studio
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now