com.intellij.lang.javascript.psi.JSExpression Java Examples

private static ImmutableList<JSLiteralExpression> getModuleDeclarations(
    ImmutableList<JSFile> jsFiles) {
  return findChildrenOfType(jsFiles, JSCallExpression.class).stream()
      .filter(
          call -> {
            JSExpression method = call.getMethodExpression();
            return method != null
                && (Objects.equals(method.getText(), "goog.provide")
                    || Objects.equals(method.getText(), "goog.module"));
          })
      .map(JSCallExpression::getArguments)
      .filter(a -> a.length == 1)
      .map(a -> a[0])
      .filter(JSLiteralExpression.class::isInstance)
      .map(JSLiteralExpression.class::cast)
      .filter(JSLiteralExpression::isQuotedLiteral)
      .collect(toImmutableList());
}
 

public static String getEnvironmentFromTemplateTag(String tagText, PsiElement host) {
    if (RELAY_QL_TEMPLATE_TAG.equals(tagText)) {
        return RELAY_ENVIRONMENT;
    }
    if (GRAPHQL_TEMPLATE_TAG.equals(tagText) || GRAPHQL_EXPERIMENTAL_TEMPLATE_TAG.equals(tagText)) {
        if(host instanceof JSStringTemplateExpression) {
            final JSExpression[] arguments = ((JSStringTemplateExpression) host).getArguments();
            if(arguments.length > 0) {
                // one or more placeholders inside the tagged template text, so consider it templated graphql
                return GRAPHQL_TEMPLATE_ENVIRONMENT;
            }
        }
        return GRAPHQL_ENVIRONMENT;
    }
    if (GQL_TEMPLATE_TAG.equals(tagText)) {
        return PropertiesComponent.getInstance(host.getProject()).getValue(PROJECT_GQL_ENV, DEFAULT_GQL_ENVIRONMENT);
    }
    
    if (APOLLO_GQL_TEMPLATE_TAG.equals(tagText)) {
        return APOLLO_ENVIRONMENT;
    }
    // fallback
    return GRAPHQL_ENVIRONMENT;
}
 

@Test
public void testWhenMixinArrayIsNull()
{
    Map<String, String> propertyMap = new HashMap<String, String>();
    propertyMap.put("property 1", "value");

    JSExpression[] arguments = new JSExpression[] {
            new MockJSLiteralExpression("test class"),
            new MockJSLiteralExpression("null"),
            new MockJSObjectLiteralExpression(propertyMap)
    };

    JSCallExpression callExpression = new MockJSCallExpression(arguments);
    Object[] statements = new Object[] {callExpression, null};

    DeclareStatementItems result = resolver.getDeclareStatementFromParsedStatement(statements);
    assertNotNull(result);
}
 

@Test
public void testWhenFirstArgumentIsAClassName()
{
    Map<String, String> propertyMap = new HashMap<String, String>();
    propertyMap.put("property 1", "value");

    JSExpression[] arguments = new JSExpression[] {
            new MockJSLiteralExpression("test class"),
            new MockJSArrayLiteralExpression(new String[] { "define 1", "define 2"}),
            new MockJSObjectLiteralExpression(propertyMap)
    };

    JSCallExpression callExpression = new MockJSCallExpression(arguments);
    Object[] statements = new Object[] {callExpression, null};

    DeclareStatementItems result = resolver.getDeclareStatementFromParsedStatement(statements);
    assertEquals(2, result.getExpressionsToMixin().length);
    assertEquals(1, result.getMethodsToConvert().length);
}
 

@Test
public void classNameIsRetrieved()
{
    Map<String, String> propertyMap = new HashMap<String, String>();
    propertyMap.put("property 1", "value");

    JSExpression[] arguments = new JSExpression[] {
            new MockJSLiteralExpression("test class"),
            new MockJSArrayLiteralExpression(new String[] { "define 1", "define 2"}),
            new MockJSObjectLiteralExpression(propertyMap)
    };

    JSCallExpression callExpression = new MockJSCallExpression(arguments);
    Object[] statements = new Object[] {callExpression, null};

    DeclareStatementItems result = resolver.getDeclareStatementFromParsedStatement(statements);
    assertEquals("test class", result.getClassName().getText());
}
 

@Test
public void testWhenFirstArgumentIsNull()
{
    Map<String, String> propertyMap = new HashMap<String, String>();
    propertyMap.put("property 1", "value");

    JSExpression[] arguments = new JSExpression[] {
            BasicPsiElements.Null(),
            new MockJSObjectLiteralExpression(propertyMap)
    };

    JSCallExpression callExpression = new MockJSCallExpression(arguments);
    Object[] statements = new Object[] {callExpression, null};

    DeclareStatementItems result = resolver.getDeclareStatementFromParsedStatement(statements);
    assertEquals(0, result.getExpressionsToMixin().length);
    assertEquals(1, result.getMethodsToConvert().length);
}
 

@Test
public void testTheBasicHappyPath()
{
    Map<String, String> propertyMap = new HashMap<String, String>();
    propertyMap.put("property 1", "value");

    JSExpression[] arguments = new JSExpression[] {
            new MockJSArrayLiteralExpression(new String[] { "mixin1", "mixin2"}),
            new MockJSObjectLiteralExpression(propertyMap)
    };

    JSCallExpression callExpression = new MockJSCallExpression(arguments);
    Object[] statements = new Object[] {callExpression, null};

    DeclareStatementItems result = resolver.getDeclareStatementFromParsedStatement(statements);
    assertEquals(2, result.getExpressionsToMixin().length);
    assertEquals(1, result.getMethodsToConvert().length);
}
 

@Test
public void indexPropertyIsConverted()
{
    List<JSExpressionStatement> methods = new ArrayList<JSExpressionStatement>();
    methods.add(new MockJSExpressionStatement(new MockJSAssignmentExpression(new MockJSDefinitionExpressionWithIndexedProperty("util", "'-test-'"), "value")));

    String result = converter.buildUtilPatternString(null, new JSExpression[0], methods, "util");
    assertTrue(result.contains("-test-': value"));
}
 

private static boolean isImportingTestSuite(PsiElement element) {
  JSCallExpression call = PsiTreeUtil.getChildOfType(element, JSCallExpression.class);
  if (call == null || !Objects.equals(call.getMethodExpression().getText(), "goog.require")) {
    return false;
  }
  JSExpression[] arguments = call.getArguments();
  if (arguments.length != 1) {
    return false;
  }
  if (!(arguments[0] instanceof JSLiteralExpression)) {
    return false;
  }
  JSLiteralExpression literal = (JSLiteralExpression) arguments[0];
  return Objects.equals(literal.getStringValue(), "goog.testing.testSuite");
}
 

@Test
public void testPropertyIsGenerated()
{
    List<JSExpressionStatement> methods = new ArrayList<JSExpressionStatement>();
    methods.add(new MockJSExpressionStatement(new MockJSAssignmentExpression("util.", "property", "'value'")));

    String result = converter.buildUtilPatternString(null, new JSExpression[0], methods, "util");
    assertTrue(result.contains("property: 'value'"));
}
 

public MockJSArrayLiteralExpression(String[] defines) {
    super(mock(ASTNode.class));

    expressions = new JSExpression[defines.length];
    for(int i=0;i<defines.length;i++)
    {
        expressions[i] = new MockJSLiteralExpression(defines[i]);
    }
}
 

public static JSExpression expressionFromText(final String text)
{
    return new JSExpressionImpl(mock(ASTNode.class)) {
        @Override
        public String getText()
        {
            return text;
        }
    };
}
 

public JSExpression getCollection() {
    final ASTNode myNode = getNode();
    final ASTNode secondExpression = myNode.findChildByType(
            JSElementTypes.EXPRESSIONS, myNode.findChildByType(JSTokenTypes.IN_KEYWORD)
    );
    return secondExpression != null ? (JSExpression) secondExpression.getPsi() : null;
}
 

public JSExpression getCollection() {
    final ASTNode myNode = getNode();
    final ASTNode secondExpression = myNode.findChildByType(
            JSElementTypes.EXPRESSIONS, myNode.findChildByType(JSTokenTypes.IN_KEYWORD)
    );
    return secondExpression != null ? (JSExpression) secondExpression.getPsi() : null;
}
 

@Override
public JSExpression[] getChildren()
{
    if(definition == null)
    {
        return new JSExpression[] { new MockJSDefinitionExpression(definitionNamespace, definitionName), BasicPsiElements.expressionFromText(content) };
    }
    else
    {
        return new JSExpression[] { this.definition, BasicPsiElements.expressionFromText(content)};
    }
}
 

@Override
public JSExpression[] getExpressions()
{
    return expressions;
}
 

public Set<String> getDojoModulesInHtmlFile(PsiFile file)
{
    final Set<String> modules = new HashSet<String>();

    file.acceptChildren(new JSRecursiveElementVisitor() {
        @Override
        public void visitJSCallExpression(JSCallExpression node) {
            if(!node.getText().startsWith("require"))
            {
                super.visitJSCallExpression(node);
                return;
            }

            if(node.getArguments().length > 0 && node.getArguments()[0] instanceof JSArrayLiteralExpression)
            {
                JSArrayLiteralExpression arguments = (JSArrayLiteralExpression) node.getArguments()[0];
                for(JSExpression literal : arguments.getExpressions())
                {
                    String literalText = literal.getText().replaceAll("'", "").replaceAll("\"", "");

                    if(!isDojoModule(literalText))
                    {
                        modules.add(literalText);
                    }
                }
            }

            super.visitJSCallExpression(node);
        }
    });

    file.acceptChildren(new XmlRecursiveElementVisitor() {
        @Override
        public void visitXmlTag(XmlTag tag) {
            super.visitXmlTag(tag);
        }

        @Override
        public void visitXmlAttribute(XmlAttribute attribute) {
            if(attribute.getName().equals("data-dojo-type"))
            {
                if(!isDojoModule(attribute.getValue()))
                {
                    modules.add(attribute.getValue());
                }
            }

            super.visitXmlAttribute(attribute);
        }
    });

    return modules;
}
 

public DeclareStatementItems(JSExpression[] expressionsToMixin, JSProperty[] methodsToConvert, JSElement returnStatement) {
    this.expressionsToMixin = expressionsToMixin;
    this.methodsToConvert = methodsToConvert;
    this.declareContainingStatement = returnStatement;
}
 

public DeclareStatementItems(JSLiteralExpression className, JSExpression[] expressionsToMixin, JSProperty[] methodsToConvert, JSElement declareContainingStatement) {
    this(expressionsToMixin, methodsToConvert, declareContainingStatement);

    this.className = className;
}
 

public JSExpression[] getExpressionsToMixin() {
    return expressionsToMixin;
}
 

/**
 * Determines if one module references another module, and returns a result if it does
 *
 * @param newModuleName the referenced module's name
 * @param statement the module's parsed define statement
 * @param targetFile the module file
 * @return
 */
protected @Nullable MatchResult getMatch(@NotNull String newModuleName, @NotNull DefineStatement statement, @NotNull PsiFile targetFile)
{
    // smoke test
    if(!statement.getArguments().getText().contains(moduleName))
    {
        return null;
    }

    // get a list of possible modules and their syntax
    LinkedHashMap<String, PsiFile> results = new ImportResolver().getChoicesFromFiles(possibleFiles, libraries, moduleName, targetFile, false, true);

    // go through the defines and determine if there is a match
    int matchIndex = -1;
    String matchedString = "";
    String matchedPostfix = "";
    char quote = '\'';

    for(int i=0;i<statement.getArguments().getExpressions().length;i++)
    {
        JSExpression argument = statement.getArguments().getExpressions()[i];

        if(argument.getText().contains("\""))
        {
            quote = '"';
        }

        String argumentText = argument.getText().replaceAll("'", "").replaceAll("\"", "");
        if(argumentText.contains(moduleName))
        {
            StringBuilder b = new StringBuilder(argumentText);
            b.replace(argumentText.lastIndexOf(moduleName), argumentText.lastIndexOf(moduleName) + moduleName.length(), newModuleName );
            argumentText = b.toString();
        }

        // in case it's a plugin
        // TODO unit test please !
        String modulePath = NameResolver.getModulePath(argumentText);
        String finalArgumentText = modulePath + NameResolver.getModuleName(argumentText);
        String pluginPostFix = NameResolver.getAMDPluginResourceIfPossible(argumentText, true);

        if(results.containsKey(finalArgumentText))
        {
            matchIndex = i;
            matchedString = finalArgumentText;
            matchedPostfix = pluginPostFix;
            break;
        }
    }

    if(matchIndex == -1)
    {
        return null;
    }

    return new MatchResult(targetFile, matchIndex, matchedString, quote, matchedPostfix, null, statement.getCallExpression());
}
 

@Override
public JSExpression getExpression()
{
    return new MockJSIndexedPropertyAccessExpression(definitionName);
}
 

@Override
public JSExpression getExpression()
{
    return expression;
}
 

public void setExpressions(JSExpression[] expressions) {
    this.expressions = expressions;
}
 

@Override
public JSExpression getExpression()
{
    return new MockJSReferenceExpression(definitionName);
}
 

@Override
public JSExpression getIndexExpression()
{
    return BasicPsiElements.expressionFromText(this.value);
}
 

@Override
public JSExpression[] getArguments()
{
    return arguments;
}
 

public MockJSCallExpression(JSExpression[] arguments) {
    super(mock(ASTNode.class));

    this.arguments = arguments;
}
 

public MockJSExpressionStatement(JSExpression expression) {
    super(mock(ASTNode.class));

    this.expression = expression;
}