Method Details

• fromExpression

  public static Object fromExpression(com.github.javaparser.ast.expr.Expression arg, com.github.javaparser.resolution.types.ResolvedType expectedType)

  Parses the given expression and returns the object it represents.

  If the argument is a null literal, it is returned as is. Method call expressions are also returned as is.

  Parameters:

  arg - the expression to parse

  expectedType - the expected type of the object or null if unknown

  Returns:

  the object represented by the expression

• findNameReferences

  public static Stream<com.github.javaparser.ast.expr.Expression> findNameReferences(String variableName, com.github.javaparser.ast.stmt.BlockStmt scope)

  Finds all name references to the given variable name in the given scope.

  Parameters:

  variableName - the variable name

  scope - the scope

  Returns:

  a stream of name references

• findMethodCallStatements

  public static List<com.github.javaparser.ast.expr.MethodCallExpr> findMethodCallStatements(ComponentInfo componentDefinition)

  Find all method calls that are statements, i.e. calls like foo.bar() or baz.qux("zug")). Does not find usage of the variable in other expressions, like otherFunction("something" + foo.bar())

  Parameters:

  componentDefinition - the component to look for

  Returns:

  a list of method calls

• findMethodCallNonStatements

  public static List<com.github.javaparser.ast.expr.MethodCallExpr> findMethodCallNonStatements(ComponentInfo componentDefinition)

  Finds usage of the variable outside of method call statements, i.e. all usage not reported by findMethodCallStatements(ComponentInfo).

  Parameters:

  componentDefinition - the component to look for

  Returns:

  a list of method calls

• findMethodCalls

  public static List<com.github.javaparser.ast.expr.MethodCallExpr> findMethodCalls(ComponentInfo componentInfo)

  Finds all method calls that are related to the given component.

  Parameters:

  componentInfo - the component to look for

  Returns:

  a list of method calls

• findMethodCalls

  public static List<com.github.javaparser.ast.expr.MethodCallExpr> findMethodCalls(ComponentInfo componentInfo, com.github.javaparser.ast.Node.TreeTraversal traversalOrder)

  Finds all method calls that are related to the given component.

  Parameters:

  componentInfo - the component to look for

  traversalOrder - the order in which the nodes are traversed

  Returns:

  a list of method calls

• findParameterUsage

  public static List<com.github.javaparser.ast.expr.Expression> findParameterUsage(ComponentInfo componentDefinition)

  Find all expressions where the given component is used as a call parameter.

  Parameters:

  componentDefinition - the component to look for

  Returns:

  a list of expressions

• extractInlineVariableToLocalVariable

  public static JavaRewriter.ExtractInlineVariableResult extractInlineVariableToLocalVariable(ComponentInfo componentInfo)

  Extracts an inline variable to local variable with a new variable name.

  Parameters:

  componentInfo - Component info

  Returns:

  Block, new variable name and index, null if attach call is not found.

• isRouteClass

  public static boolean isRouteClass(ComponentTypeAndSourceLocation typeAndSourceLocation, com.github.javaparser.ast.CompilationUnit compilationUnit)

  Checks if the given location refers to a @Route annotated class.

  Parameters:

  typeAndSourceLocation - the type and source location to check

  compilationUnit - the compilation unit that contains the code

  Returns:

  true if the location refers to a @Route annotated class, false otherwise

• hasSingleParameterMethod

  public static boolean hasSingleParameterMethod(Class<? extends Component> type, String func)

  Checks if the given component type has a method with the given name, taking one parameter.

  Parameters:

  type - The component type

  func - The method name

  Returns:

  true if the method exists, false otherwise

• findBlockStatementIndex

  public static int findBlockStatementIndex(com.github.javaparser.ast.Node node)

  Finds the index of the statement that wraps the given node in the closest block statement.

  Parameters:

  node - The node to find the wrapping statement for

  Returns:

  The index of the statement in the block statement

• findDeclarationIndex

  public static int findDeclarationIndex(com.github.javaparser.ast.Node node)

  Finds the index of the given node in the block statement.

  Parameters:

  node - The node to find the index for

  Returns:

  The index of the node in the block statement or -1 if not found

• findFreeVariableName

  public static String findFreeVariableName(ComponentInfo componentInfo, com.github.javaparser.ast.stmt.BlockStmt block)

  Finds a free variable name based on the component type.

  Parameters:

  componentInfo - The component info

  block - The block the variable will be used in

  Returns:

  A free variable name

• findFreeVariableName

  public static String findFreeVariableName(String base, com.github.javaparser.ast.stmt.BlockStmt block)

  Finds a free variable name based on the given base name.

  Parameters:

  base - The base name

  block - The block the variable will be used in

  Returns:

  A free variable name

• findFreeVariableName

  public static String findFreeVariableName(String base, com.github.javaparser.ast.body.ClassOrInterfaceDeclaration block)

  Finds a free field name based on the given base name.

  Parameters:

  base - The base name

  block - The ClassOrInterfaceDeclaration the variable will be used in

  Returns:

  A free variable name

• findFreeRecordName

  public static String findFreeRecordName(String base, com.github.javaparser.ast.body.ClassOrInterfaceDeclaration block)

• removeStatement

  public static void removeStatement(com.github.javaparser.ast.Node node)

  Removes the statement that wraps the given node.

  Parameters:

  node - the node to remove

• removeFromStringConcatenation

  public static boolean removeFromStringConcatenation(com.github.javaparser.ast.Node node)

  Removes the given node from a string concatenation expression.

  Parameters:

  node - the node to remove

  Returns:

  true if the node was removed, false otherwise

• findReference

  public static Optional<com.github.javaparser.ast.expr.Expression> findReference(com.github.javaparser.ast.NodeList<com.github.javaparser.ast.expr.Expression> nodes, ComponentInfo componentDefinition)

  Finds a node among the nodes which refer to the given component.

  Parameters:

  nodes - the nodes to search

  componentDefinition - the component definition

  Returns:

  the first node that refers to the component, if any

• findFieldDeclaration

  public static com.github.javaparser.ast.body.FieldDeclaration findFieldDeclaration(com.github.javaparser.ast.Node nodeInClass, String fieldName)

  Finds the field declaration for the given field name in the class of the given node.

  Parameters:

  nodeInClass - the node in the class

  fieldName - the field name

  Returns:

  the field declaration

  Throws:

  IllegalArgumentException - if the field is not found

• getSetterAndValue

  public static JavaRewriter.SetterAndValue getSetterAndValue(Class<?> componentType, String property, Object value)

  Gets the setter name and value for the given component type, property and value.

  Parameters:

  componentType - the component type

  property - the property

  value - the value

  Returns:

  the setter name and value

• getSetterName

  public static String getSetterName(String property, Class<?> type, boolean includeReactConversions)

  Gets the setter name for the given property.

  Parameters:

  property - the property

  type - the component type

  includeReactConversions - whether to include React property name conversions in the setter name

  Returns:

  the setter name

• getPropertyName

  public static String getPropertyName(String setter)

  Gets the camel case property name for the given setter.

  Parameters:

  setter - the setter name

  Returns:

  the property name

• getFieldOrVariableName

  public static String getFieldOrVariableName(ComponentInfo componentInfo)

  Gets the field or local variable name for the given component.

  Parameters:

  componentInfo - the component info

  Returns:

  the field or local variable name

• addImport

  public static void addImport(com.github.javaparser.ast.CompilationUnit compilationUnit, String qualifiedName)

  Adds an import to the given compilation unit if it is not already imported.

  Parameters:

  compilationUnit - the compilation unit

  qualifiedName - the qualified name of the import

• getJavaIdentifier

  public static String getJavaIdentifier(String str, int maxLength)

  Converts the given string into a valid Java identifier.

  Parameters:

  str - the string

  maxLength - the maximum length of the identifier, or 0 for unlimited

  Returns:

  the Java identifier

• hasMethod

  public static boolean hasMethod(Class<?> type, String methodName)

  Checks if the given component type has the given method.

  Parameters:

  type - the component type

  methodName - the method to check for

  Returns:

  true if the component has the method, false otherwise

• getClass

  public static Class<?> getClass(String name) throws IllegalArgumentException

  Finds the class for the given source type.

  Parameters:

  name - the class name

  Returns:

  the class for the given name

  Throws:

  IllegalArgumentException - if the class is not found

• hasSetterForType

  public static boolean hasSetterForType(Class<?> componentType, String setterName, Class<?> valueType)

• getEnumValue

  public static Enum<?> getEnumValue(Class<?> componentType, String setterName, String value)

• removeArgumentCalls

  public static void removeArgumentCalls(List<com.github.javaparser.ast.expr.MethodCallExpr> methods, List<? extends com.github.javaparser.ast.expr.Expression> argumentsToRemove, boolean removeMethodIfNoArgs)

  Removes the given arguments from the given method calls.

  Parameters:

  methods - the method calls to process

  argumentsToRemove - the arguments to remove

  removeMethodIfNoArgs - whether to remove the method call if no arguments are left

• removeArgumentCalls

  public static boolean removeArgumentCalls(com.github.javaparser.ast.expr.MethodCallExpr methodCallExpr, List<? extends com.github.javaparser.ast.expr.Expression> argumentsToRemove, boolean removeMethodIfNoArgs)

  Removes the given arguments from the given method call.

  Parameters:

  methodCallExpr - the method call

  argumentsToRemove - the arguments to remove

  removeMethodIfNoArgs - whether to remove the method call if no arguments are left

  Returns:

  true

• findLocationBefore

  public static InsertionPoint findLocationBefore(com.github.javaparser.ast.expr.Expression expr)

  Finds the insert location before of given expression.

  Parameters:

  expr - Reference expression

  Returns:

  Returns code block and index

• findLocationAfter

  public static InsertionPoint findLocationAfter(com.github.javaparser.ast.expr.Expression expr)

  Finds the insert location after of given expression.

  Parameters:

  expr - Reference expression

  Returns:

  the insert location

• findLocationAtEnd

  public static InsertionPoint findLocationAtEnd(com.github.javaparser.ast.stmt.Statement statement)

  Finds the insert location at the end of the code block containing the given statement.

  Parameters:

  statement - The reference statement

  Returns:

  the insert location

• addFieldAfter

  public static void addFieldAfter(com.github.javaparser.ast.body.FieldDeclaration newField, com.github.javaparser.ast.body.FieldDeclaration reference)

  Adds a field declaration after the given reference field.

  Parameters:

  newField - the new field declaration

  reference - the reference field

• clone

  public static <T extends com.github.javaparser.ast.Node> T clone(T node)

  Clones the node in a way that does not mess up the lexical printer.

  Type Parameters:

  T - the type of the node

  Parameters:

  node - the node to clone

  Returns:

  the cloned node

• getAttachArgument

  public static Optional<com.github.javaparser.ast.expr.Expression> getAttachArgument(ComponentInfo component)

  Finds the attach argument reference of the given component.

  Parameters:

  component - the component

  Returns:

  the attach argument reference, if found

• getAttachArgumentOrThrow

  public static com.github.javaparser.ast.expr.Expression getAttachArgumentOrThrow(ComponentInfo component)

  Find the attach argument reference of given component or throws IllegalArgumentException if not found.

  Parameters:

  component -

  Returns:

  attach expression

• setNameExprScope

  public static boolean setNameExprScope(com.github.javaparser.ast.expr.MethodCallExpr newCall, com.github.javaparser.ast.expr.NameExpr nameExpr)

  Sets the name expression scope for the given method call. For a simple call like `foo.setBar()` this changes `foo` and for nested calls like `foo.baz().fo().a().b()` it also changes `foo`.

  Parameters:

  newCall - the method call to change

  nameExpr - the new scope

  Returns:

  true if the scope was changed, false otherwise

• typesEqual

  public static boolean typesEqual(com.github.javaparser.resolution.types.ResolvedType javaParserType, Class<?> javaReflectionType)

  Checks if the given type is equal to the given reflection type.

  Parameters:

  javaParserType - the Java parser type

  javaReflectionType - the Java reflection type

  Returns:

  true if the types are equal, false otherwise

• isArrayArgument

  public static boolean isArrayArgument(String className, String methodName, int argumentIndex)

  Uses reflection API for finding class name, method and the argument to find whether argument is array.
  Includes the methods from extended Composite class if it is extended.

  Parameters:

  className - full class name of a class.

  methodName - method name

  argumentIndex - argument to look up. It can exceed the method parameters, in that case the last argument is taken into account

  Returns:

  true if argument is an array, false otherwise

• appendExpressionAsNextSiblingInBlockAncestor

  public static boolean appendExpressionAsNextSiblingInBlockAncestor(com.github.javaparser.ast.Node original, com.github.javaparser.ast.stmt.Statement newExpression)

  Appends new expression to original one as sibling in a block statement.

  Parameters:

  original - Original expression

  newExpression - New expression

  Returns:

  true if added, otherwise false.

• getScopeIgnoreComposite

  public static Optional<com.github.javaparser.ast.expr.Expression> getScopeIgnoreComposite(ComponentInfo componentInfo, com.github.javaparser.ast.expr.MethodCallExpr expr)

  Returns the scope by ignoring the getContent() if component is in a composite container. Otherwise, returns the scope of method.
  

  • getContent().add(...) returns empty
  • this.getContent().add(...) returns this
  • setSomething() returns empty
  • abc.setSomething() returns abc
  • this.setSomething() returns this

  Parameters:

  componentInfo - Component Info

  expr - Method to get scope

  Returns:

  Scope of the method, empty otherwise.

• isNodeInCompositeClass

  public static boolean isNodeInCompositeClass(com.github.javaparser.ast.Node node)

  Checks if the given node is a child of a Composite

  Parameters:

  node - Any node in the tree

  Returns:

  true if child of a composite , false otherwise

• findConstructor

  public static Optional<Constructor<?>> findConstructor(Class<? extends Component> componentType, com.github.javaparser.ast.expr.ObjectCreationExpr objectCreationExpr)

  Finds constructor for the given component

  Parameters:

  componentType - Component class

  objectCreationExpr - Creation expression of the component.

  Returns:

  Constructor if found, empty otherwise.

• createComponentConstructor

  public static com.github.javaparser.ast.expr.ObjectCreationExpr createComponentConstructor(JavaComponent javaComponent, com.github.javaparser.ast.type.ClassOrInterfaceType componentType, String dataEntityRecordName)

  Creates the convenient component constructor for a new JavaComponent to be added to the code.

  Returns:

  ObjectCreationExpr for Component

• getSingleStringParamConstructor

  public static Optional<String> getSingleStringParamConstructor(com.github.javaparser.ast.type.ClassOrInterfaceType type, Set<String> setters)

  Returns the single String parameter name from mapped properties of the component that matches an existing single String parameter constructor of the component

  Parameters:

  type - The component type

  setters - The setters of the component

  Returns:

  The name of the property that is the setter of the constructor

• getMappedProperty

  public static String getMappedProperty(Constructor<?> c, int propertyIndex)

  Returns a property used in a constructor at the given index

  Parameters:

  c - The constructor

  propertyIndex - The index of the property

  Returns:

  The property name

• getNewComponentName

  public static String getNewComponentName(JavaComponent javaComponent, com.github.javaparser.ast.type.ClassOrInterfaceType type, InsertionPoint insertionPoint)

  Provides a free name to be used when adding a new component.

  Parameters:

  javaComponent - The JavaComponent to be added

  type - The type of the component

  insertionPoint - The insertion point

  Returns:

  A free variable name

• findCalls

  public static List<com.github.javaparser.ast.expr.MethodCallExpr> findCalls(Class<?> classWithMethods, ComponentInfo componentInfo)

  Find all calls done to methods in the given class through a reference to the given component.

  For instance, if you pass in Style.class, then it will find all invocations like button.getStyle().set("color","red"), button.getStyle().setColor("blue") and also Style s = button.getStyle(); s.setColor("black")

  Parameters:

  classWithMethods - the class the check for calls

  componentInfo - the component

  Returns:

  a list of method calls

• addFunctionCall

  @Nonnull public static com.github.javaparser.ast.expr.MethodCallExpr addFunctionCall(ComponentInfo componentInfo, String function, List<com.github.javaparser.ast.expr.Expression> parameterExpressions)

  Adds a function call to the given component.

  Parameters:

  componentInfo - the component

  function - the function to call

  parameterExpressions - the parameters to pass to the function

• getOutermostScope

  public static Optional<com.github.javaparser.ast.expr.Expression> getOutermostScope(com.github.javaparser.ast.expr.MethodCallExpr methodCallExpr)

  Gets the outermost scope for a chain of method calls.

  E.g. for foo.bar().baz().qux() it will return foo

  Parameters:

  methodCallExpr - The method call expression

  Returns:

  The outermost scope

• removeFromChainedStyleCall

  public static void removeFromChainedStyleCall(com.github.javaparser.ast.expr.MethodCallExpr methodCallExpr)

  Removes the given method call from a getStyle call chain.

  If the method call is the only style call, removes the whole statement.

  Parameters:

  methodCallExpr - the method call to remove