Merge pull request spotbugs#104 from h3xstream/master

Add basic syntax highlighter spotbugs#84

Author: h3xstream

pom.xml

@@ -54,6 +54,8 @@
     <sonar-java.version>4.0</sonar-java.version>
     <fbcontrib.version>7.0.0</fbcontrib.version>
     <findsecbugs.version>1.6.0</findsecbugs.version>
+
+
   </properties>
 
   <dependencies>
@@ -210,6 +212,15 @@
       <type>test-jar</type>
       <scope>test</scope>
     </dependency>
+
+
+    <!-- Utilities use by the lexer -->
+    <dependency>
+      <groupId>org.sonarsource.sslr</groupId>
+      <artifactId>sslr-core</artifactId>
+      <version>1.21</version>
+    </dependency>
+
   </dependencies>
 
   <build>

src/main/java/org/sonar/plugins/findbugs/FindbugsPlugin.java

@@ -21,6 +21,7 @@
 
 import org.sonar.api.Plugin;
 import org.sonar.plugins.findbugs.language.Jsp;
+import org.sonar.plugins.findbugs.language.JspSyntaxSensor;
 import org.sonar.plugins.findbugs.profiles.FindbugsContribProfile;
 import org.sonar.plugins.findbugs.profiles.FindbugsProfile;
 import org.sonar.plugins.findbugs.profiles.FindbugsSecurityAuditProfile;
@@ -39,7 +40,10 @@ public class FindbugsPlugin implements Plugin {
   @Override
   public void define(Context context) {
     context.addExtensions(FindbugsConfiguration.getPropertyDefinitions());
-    context.addExtensions(Arrays.asList(Jsp.class,
+    context.addExtensions(Arrays.asList(
+            Jsp.class,
+            JspSyntaxSensor.class,
+
             FindbugsSensor.class,
             FindbugsConfiguration.class,
             FindbugsExecutor.class,

src/main/java/org/sonar/plugins/findbugs/FindbugsSensor.java

@@ -45,9 +45,6 @@
 import org.sonar.plugins.java.Java;
 import org.sonar.plugins.java.api.JavaResourceLocator;
 
-import java.util.HashSet;
-import java.util.Set;
-
 public class FindbugsSensor implements Sensor {
 
   private static final Logger LOG = LoggerFactory.getLogger(FindbugsSensor.class);
@@ -195,7 +192,7 @@ protected void insertIssue(ActiveRule rule, InputFile resource, int line, String
    * @return File handle of the original class file analyzed
    */
   private File findOriginalClassForBug(String className) {
-    String sourceFile = javaResourceLocator.findSourceFileKeyByClassName(className);
+    String sourceFile = byteCodeResourceLocator.findSourceFileKeyByClassName(className,javaResourceLocator);
     if (sourceFile == null) {
       return null;
     }

src/main/java/org/sonar/plugins/findbugs/language/JspLexer.java

@@ -0,0 +1,75 @@
+/*
+ * SonarSource :: Web :: Sonar Plugin
+ * Copyright (c) 2010-2017 SonarSource SA and Matthijs Galesloot
+ * sonarqube@googlegroups.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.sonar.plugins.findbugs.language;
+
+import com.sonar.sslr.api.TokenType;
+import com.sonar.sslr.impl.Lexer;
+import com.sonar.sslr.impl.channel.BlackHoleChannel;
+import com.sonar.sslr.impl.channel.BomCharacterChannel;
+import com.sonar.sslr.impl.channel.IdentifierAndKeywordChannel;
+import com.sonar.sslr.impl.channel.UnknownCharacterChannel;
+
+import java.nio.charset.Charset;
+
+import static com.sonar.sslr.impl.channel.RegexpChannelBuilder.commentRegexp;
+import static com.sonar.sslr.impl.channel.RegexpChannelBuilder.regexp;
+
+final class JspLexer {
+
+  private JspLexer() {
+  }
+
+  public static Lexer create(Charset charset) {
+    return Lexer.builder()
+      .withCharset(charset)
+
+      .withFailIfNoChannelToConsumeOneCharacter(true)
+
+      .withChannel(new BomCharacterChannel())
+      .withChannel(new BlackHoleChannel("\\s++"))
+
+      .withChannel(regexp(JspTokenType.DOCTYPE, "<!DOCTYPE.*>"))
+
+      .withChannel(regexp(JspTokenType.TAG, "</?[:\\w]+>?"))
+      .withChannel(regexp(JspTokenType.TAG, "/?>"))
+
+      // JSP comment
+      .withChannel(commentRegexp("<%--[\\w\\W]*?%>"))
+      // HTML comment
+      .withChannel(commentRegexp("<!--[\\w\\W]*?-->"))
+      // C comment
+      .withChannel(commentRegexp("/\\*[\\w\\W]*?\\*/"))
+      // CPP comment
+      .withChannel(commentRegexp("//[^\n\r]*"))
+
+      //JSP Scriptlet
+      .withChannel(regexp(JspTokenType.EXPRESSION, "<%[\\w\\W]*?%>"))
+      //EL Expression
+      .withChannel(regexp(JspTokenType.EXPRESSION, "\\$\\{[\\w\\W]*?\\}"))
+
+      .withChannel(regexp(JspTokenType.ATTRIBUTE, "=[\"']{1}[\\w\\W]*?[\"']{1}"))
+      .withChannel(regexp(JspTokenType.ATTRIBUTE, "=[^\\s'\"=<>`]++"))
+
+      .withChannel(new IdentifierAndKeywordChannel("\\w++", true, new TokenType[]{}))
+
+      .withChannel(new UnknownCharacterChannel())
+
+      .build();
+  }
+
+}

src/main/java/org/sonar/plugins/findbugs/language/JspSyntaxSensor.java

@@ -0,0 +1,79 @@
+package org.sonar.plugins.findbugs.language;
+
+import com.google.common.collect.ImmutableList;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.sonar.api.batch.fs.FilePredicates;
+import org.sonar.api.batch.fs.FileSystem;
+import org.sonar.api.batch.fs.InputFile;
+import org.sonar.api.batch.rule.CheckFactory;
+import org.sonar.api.batch.sensor.Sensor;
+import org.sonar.api.batch.sensor.SensorContext;
+import org.sonar.api.batch.sensor.SensorDescriptor;
+import org.sonar.api.issue.NoSonarFilter;
+import org.sonar.api.measures.FileLinesContextFactory;
+import org.sonar.plugins.findbugs.language.lex.PageLexer;
+import org.sonar.plugins.findbugs.language.visitor.HtmlAstScanner;
+import org.sonar.plugins.findbugs.language.visitor.NoSonarScanner;
+import org.sonar.plugins.findbugs.language.visitor.WebSourceCode;
+
+import java.io.FileReader;
+
+public class JspSyntaxSensor implements Sensor {
+
+    private static final Logger LOG = LoggerFactory.getLogger(JspSyntaxSensor.class);
+
+    private final NoSonarFilter noSonarFilter;
+    private final FileLinesContextFactory fileLinesContextFactory;
+
+    public JspSyntaxSensor(NoSonarFilter noSonarFilter, FileLinesContextFactory fileLinesContextFactory, CheckFactory checkFactory) {
+        this.noSonarFilter = noSonarFilter;
+        this.fileLinesContextFactory = fileLinesContextFactory;
+    }
+
+    @Override
+    public void describe(SensorDescriptor descriptor) {
+        descriptor
+                .name(Jsp.KEY)
+                .onlyOnFileType(InputFile.Type.MAIN)
+                .onlyOnLanguage(Jsp.KEY);
+    }
+
+    @Override
+    public void execute(SensorContext sensorContext) {
+        final PageLexer lexer = new PageLexer();
+
+        FileSystem fileSystem = sensorContext.fileSystem();
+
+        final HtmlAstScanner scanner = setupScanner(sensorContext);
+
+        FilePredicates predicates = fileSystem.predicates();
+        Iterable<InputFile> inputFiles = fileSystem.inputFiles(
+                predicates.and(
+                        predicates.hasType(InputFile.Type.MAIN),
+                        predicates.hasLanguage(Jsp.KEY))
+        );
+
+        for (InputFile inputFile : inputFiles) {
+            WebSourceCode sourceCode = new WebSourceCode(inputFile);
+
+            try (FileReader reader = new FileReader(inputFile.file())) {
+                scanner.scan(lexer.parse(reader), sourceCode, fileSystem.encoding());
+
+            } catch (Exception e) {
+                LOG.error("Cannot analyze file " + inputFile.file().getAbsolutePath(), e);
+            }
+        }
+    }
+
+    /**
+     * Create PageScanner with Visitors.
+     */
+    private HtmlAstScanner setupScanner(SensorContext context) {
+        HtmlAstScanner scanner = new HtmlAstScanner(ImmutableList.of(
+                new JspTokensVisitor(context),
+                new NoSonarScanner(noSonarFilter)));
+
+        return scanner;
+    }
+}

src/main/java/org/sonar/plugins/findbugs/language/JspTokenType.java

@@ -0,0 +1,44 @@
+/*
+ * SonarSource :: Web :: Sonar Plugin
+ * Copyright (c) 2010-2017 SonarSource SA and Matthijs Galesloot
+ * sonarqube@googlegroups.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.sonar.plugins.findbugs.language;
+
+import com.sonar.sslr.api.AstNode;
+import com.sonar.sslr.api.TokenType;
+
+public enum JspTokenType implements TokenType {
+  TAG,
+  EXPRESSION,
+  ATTRIBUTE,
+  DOCTYPE;
+
+  @Override
+  public String getName() {
+    return name();
+  }
+
+  @Override
+  public String getValue() {
+    return name();
+  }
+
+  @Override
+  public boolean hasToBeSkippedFromAst(AstNode node) {
+    return false;
+  }
+
+}

src/main/java/org/sonar/plugins/findbugs/language/JspTokensVisitor.java

@@ -0,0 +1,93 @@
+/*
+ * SonarSource :: Web :: Sonar Plugin
+ * Copyright (c) 2010-2017 SonarSource SA and Matthijs Galesloot
+ * sonarqube@googlegroups.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.sonar.plugins.findbugs.language;
+
+import com.sonar.sslr.api.GenericTokenType;
+import com.sonar.sslr.api.Token;
+import com.sonar.sslr.api.TokenType;
+import com.sonar.sslr.api.Trivia;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.sonar.api.batch.fs.InputFile;
+import org.sonar.api.batch.sensor.SensorContext;
+import org.sonar.api.batch.sensor.cpd.NewCpdTokens;
+import org.sonar.api.batch.sensor.highlighting.NewHighlighting;
+import org.sonar.api.batch.sensor.highlighting.TypeOfText;
+import org.sonar.plugins.findbugs.language.node.Node;
+import org.sonar.plugins.findbugs.language.visitor.DefaultNodeVisitor;
+
+import java.util.List;
+
+public class JspTokensVisitor extends DefaultNodeVisitor {
+
+  private static final Logger LOG = LoggerFactory.getLogger(JspTokensVisitor.class);
+
+  private final SensorContext context;
+
+  public JspTokensVisitor(SensorContext context) {
+    this.context = context;
+  }
+
+  @Override
+  public void startDocument(List<Node> nodes) {
+    try {
+      highlightAndDuplicate();
+    } catch (IllegalArgumentException e) {
+      LOG.warn("Giving up highlighting/handling duplication for file " + getWebSourceCode().inputFile(), e);
+    }
+  }
+
+  private void highlightAndDuplicate() {
+    NewHighlighting highlighting = context.newHighlighting();
+    InputFile inputFile = getWebSourceCode().inputFile();
+    highlighting.onFile(inputFile);
+
+    NewCpdTokens cpdTokens = context.newCpdTokens();
+    cpdTokens.onFile(inputFile);
+
+    for (Token token : JspLexer.create(context.fileSystem().encoding()).lex(inputFile.file())) {
+      TokenType tokenType = token.getType();
+      if (!tokenType.equals(GenericTokenType.EOF)) {
+        TokenLocation tokenLocation = new TokenLocation(token);
+        cpdTokens.addToken(tokenLocation.startLine(), tokenLocation.startCharacter(), tokenLocation.endLine(), tokenLocation.endCharacter(), token.getValue());
+      }
+      if (tokenType.equals(JspTokenType.DOCTYPE)) {
+        highlight(highlighting, token, TypeOfText.STRUCTURED_COMMENT);
+      } else if (tokenType.equals(JspTokenType.EXPRESSION)) {
+        highlight(highlighting, token, TypeOfText.ANNOTATION);
+      } else if (tokenType.equals(JspTokenType.TAG)) {
+        highlight(highlighting, token, TypeOfText.KEYWORD);
+      } else if (tokenType.equals(JspTokenType.ATTRIBUTE)) {
+        TokenLocation tokenLocation = new TokenLocation(token);
+        highlighting.highlight(tokenLocation.startLine(), tokenLocation.startCharacter() + /* = */ 1, tokenLocation.endLine(), tokenLocation.endCharacter(), TypeOfText.STRING);
+      }
+      for (Trivia trivia : token.getTrivia()) {
+        highlight(highlighting, trivia.getToken(), TypeOfText.COMMENT);
+      }
+    }
+
+    highlighting.save();
+    cpdTokens.save();
+  }
+
+  private static void highlight(NewHighlighting highlighting, Token token, TypeOfText typeOfText) {
+    TokenLocation tokenLocation = new TokenLocation(token);
+    highlighting.highlight(tokenLocation.startLine(), tokenLocation.startCharacter(), tokenLocation.endLine(), tokenLocation.endCharacter(), typeOfText);
+  }
+
+}