blaze-base/src/com/google/idea/blaze/base/issueparser/BlazeIssueParser.java - intellij - Git at Google

 /*
  * Copyright 2016 The Bazel Authors. All rights reserved.
  *
  * 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 com.google.idea.blaze.base.issueparser;

 import com.google.common.base.Predicate;
 import com.google.common.collect.Lists;
 import com.google.idea.blaze.base.model.primitives.TargetExpression;
 import com.google.idea.blaze.base.model.primitives.WorkspacePath;
 import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
 import com.google.idea.blaze.base.projectview.ProjectViewManager;
 import com.google.idea.blaze.base.projectview.ProjectViewSet;
 import com.google.idea.blaze.base.projectview.section.ListSection;
 import com.google.idea.blaze.base.projectview.section.Section;
 import com.google.idea.blaze.base.projectview.section.SectionKey;
 import com.google.idea.blaze.base.projectview.section.sections.TargetSection;
 import com.google.idea.blaze.base.scope.output.IssueOutput;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import java.io.File;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import static com.google.common.base.Preconditions.checkState;

 /**
  * Parses blaze output for compile errors.
  */
 public class BlazeIssueParser {

   private static class ParseResult {

     public static final ParseResult NEEDS_MORE_INPUT = new ParseResult(true, null);

     public static final ParseResult NO_RESULT = new ParseResult(false, null);

     private boolean needsMoreInput;
     @Nullable private IssueOutput output;

     private ParseResult(boolean needsMoreInput, IssueOutput output) {
       this.needsMoreInput = needsMoreInput;
       this.output = output;
     }

     public static ParseResult needsMoreInput() {
       return NEEDS_MORE_INPUT;
     }

     public static ParseResult output(IssueOutput output) {
       return new ParseResult(false, output);
     }

     public static ParseResult noResult() {
       return NO_RESULT;
     }
   }

   interface Parser {
     @NotNull
     ParseResult parse(@NotNull String currentLine, @NotNull List<String> previousLines);
   }

   static abstract class SingleLineParser implements Parser {
     @NotNull
     Pattern pattern;

     SingleLineParser(@NotNull String regex) {
       pattern = Pattern.compile(regex);
     }

     @Override
     public ParseResult parse(@NotNull String currentLine, @NotNull List<String> multilineMatchResult) {
       checkState(multilineMatchResult.isEmpty(), "SingleLineParser recieved multiple lines of input");
       return parse(currentLine);
     }

     ParseResult parse(@NotNull String line) {
       Matcher matcher = pattern.matcher(line);
       if (matcher.find()) {
         return ParseResult.output(createIssue(matcher));
       }
       return ParseResult.noResult();
     }

     @Nullable
     protected abstract IssueOutput createIssue(@NotNull Matcher matcher);
   }

   static class CompileParser extends SingleLineParser {
     @NotNull
     private final WorkspaceRoot workspaceRoot;

     public CompileParser(@NotNull WorkspaceRoot workspaceRoot) {
       super("(.*?):([0-9]+):([0-9]+:)? (error|warning): (.*)");
       this.workspaceRoot = workspaceRoot;
     }

     @Override
     protected IssueOutput createIssue(@NotNull Matcher matcher) {
       final File file;
       try {
         String fileName = matcher.group(1);
         final WorkspacePath workspacePath;
         if (fileName.startsWith("//depot/google3/")) {
           workspacePath = new WorkspacePath(fileName.substring("//depot/google3/".length()));
         } else if (fileName.startsWith("/")) {
           workspacePath = workspaceRoot.workspacePathFor(new File(fileName));
         } else {
           workspacePath = new WorkspacePath(fileName);
         }
         file = workspaceRoot.fileForPath(workspacePath);
       }
       catch (IllegalArgumentException e) {
         // Ignore -- malformed error message
         return null;
       }

       IssueOutput.Category type = matcher.group(4).equals("error")
                                   ? IssueOutput.Category.ERROR
                                   : IssueOutput.Category.WARNING;
       return IssueOutput.issue(type, matcher.group(5))
         .inFile(file)
         .onLine(Integer.parseInt(matcher.group(2)))
         .build();
     }
   }

   static class TracebackParser implements Parser {
     private static final Pattern PATTERN = Pattern.compile("(ERROR): (.*?):([0-9]+):([0-9]+): (Traceback \\(most recent call last\\):)");

     @NotNull
     @Override
     public ParseResult parse(@NotNull String currentLine, @NotNull List<String> previousLines) {
       if (previousLines.isEmpty()) {
         if (PATTERN.matcher(currentLine).find()) {
           return ParseResult.needsMoreInput();
         }
         else {
           return ParseResult.noResult();
         }
       }

       if (currentLine.startsWith("\t")) {
         return ParseResult.needsMoreInput();
       }
       else {
         Matcher matcher = PATTERN.matcher(previousLines.get(0));
         checkState(matcher.find(), "Found a match in the first line previously, but now it isn't there.");
         StringBuilder message = new StringBuilder(matcher.group(5));
         for (int i = 1; i < previousLines.size(); ++i) {
           message.append(System.lineSeparator())
             .append(previousLines.get(i));
         }
         message.append(System.lineSeparator())
           .append(currentLine);
         return ParseResult.output(IssueOutput.error(message.toString())
                                     .inFile(new File(matcher.group(2)))
                                     .onLine(Integer.parseInt(matcher.group(3)))
                                     .build());
       }
     }
   }

   static class BuildParser extends SingleLineParser {
     BuildParser() {
       super("(ERROR): (.*?):([0-9]+):([0-9]+): (.*)");
     }

     @Override
     protected IssueOutput createIssue(@NotNull Matcher matcher) {
       return IssueOutput.error(matcher.group(5))
         .inFile(new File(matcher.group(2)))
         .onLine(Integer.parseInt(matcher.group(3)))
         .build();
     }
   }

   static class LinelessBuildParser extends SingleLineParser {
     LinelessBuildParser() {
       super("(ERROR): (.*?):char offsets [0-9]+--[0-9]+: (.*)");
     }

     @Override
     protected IssueOutput createIssue(@NotNull Matcher matcher) {
       return IssueOutput.error(matcher.group(3))
         .inFile(new File(matcher.group(2)))
         .build();
     }
   }

   static class ProjectViewLabelParser extends SingleLineParser {

     @Nullable private final ProjectViewSet projectViewSet;

     ProjectViewLabelParser(
       @Nullable ProjectViewSet projectViewSet) {
       super("no such target '(.*)': target .*? not declared in package .*? defined by");
       this.projectViewSet = projectViewSet;
     }

     @Override
     protected IssueOutput createIssue(@NotNull Matcher matcher) {
       File file = null;
       if (projectViewSet != null) {
         String targetString = matcher.group(1);
         final TargetExpression targetExpression = TargetExpression.fromString(targetString);
         file = projectViewFileWithSection(projectViewSet, TargetSection.KEY, new Predicate<ListSection<TargetExpression>>() {
           @Override
           public boolean apply(@NotNull ListSection<TargetExpression> targetSection) {
             return targetSection.items().contains(targetExpression);
           }
         });
       }

       return IssueOutput.error(matcher.group(0))
         .inFile(file)
         .build();
     }
   }

   static class InvalidTargetProjectViewPackageParser extends SingleLineParser {
     @Nullable private final ProjectViewSet projectViewSet;

     InvalidTargetProjectViewPackageParser(
       @Nullable ProjectViewSet projectViewSet,
       String regex) {
       super(regex);
       this.projectViewSet = projectViewSet;
     }

     @Override
     protected IssueOutput createIssue(@NotNull Matcher matcher) {
       File file = null;
       if (projectViewSet != null) {
         final String packageString = matcher.group(1);
         file = projectViewFileWithSection(projectViewSet, TargetSection.KEY, targetSection -> {
           for (TargetExpression targetExpression : targetSection.items()) {
             if (targetExpression.toString().startsWith("//" + packageString + ":")) {
               return true;
             }
           }
           return false;
         });
       }

       return IssueOutput.error(matcher.group(0))
         .inFile(file)
         .build();
     }
   }

   @Nullable
   private static <T, SectionType extends Section<T>> File projectViewFileWithSection(
     @NotNull ProjectViewSet projectViewSet,
     @NotNull SectionKey<T, SectionType> key,
     @NotNull Predicate<SectionType> predicate) {
     for (ProjectViewSet.ProjectViewFile projectViewFile : projectViewSet.getProjectViewFiles()) {
       SectionType section = projectViewFile.projectView.getSectionOfType(key);
       if (section != null && predicate.apply(section)) {
         return projectViewFile.projectViewFile;
       }
     }
     return null;
   }

   @NotNull private List<Parser> parsers = Lists.newArrayList();
   /** The parser that requested more lines of input during the last call to {@link #parseIssue(String)}. */
   @Nullable private Parser multilineMatchingParser;
   @NotNull private List<String> multilineMatchResult = new ArrayList<>();

   public BlazeIssueParser(
     @Nullable Project project,
     @NotNull WorkspaceRoot workspaceRoot) {

     ProjectViewSet projectViewSet = project != null ? ProjectViewManager.getInstance(project).getProjectViewSet() : null;

     parsers.add(new CompileParser(workspaceRoot));
     parsers.add(new TracebackParser());
     parsers.add(new BuildParser());
     parsers.add(new LinelessBuildParser());
     parsers.add(new ProjectViewLabelParser(projectViewSet));
     parsers.add(new InvalidTargetProjectViewPackageParser(projectViewSet, "no such package '(.*)': BUILD file not found on package path"));
     parsers.add(new InvalidTargetProjectViewPackageParser(projectViewSet, "no targets found beneath '(.*)'"));
     parsers.add(new InvalidTargetProjectViewPackageParser(projectViewSet, "ERROR: invalid target format '(.*)'"));
   }


   @Nullable
   public IssueOutput parseIssue(String line) {

     List<Parser> parsers = this.parsers;
     if (multilineMatchingParser != null) {
       parsers = Lists.newArrayList(multilineMatchingParser);
     }

     for (Parser parser : parsers) {
       ParseResult issue = parser.parse(line, multilineMatchResult);
       if (issue.needsMoreInput) {
         multilineMatchingParser = parser;
         multilineMatchResult.add(line);
         return null;
       }
       else {
         multilineMatchingParser = null;
         multilineMatchResult = new ArrayList<>();
       }

       if (issue.output != null) {
         return issue.output;
       }
     }

     return null;
   }
 }
	/*
	* Copyright 2016 The Bazel Authors. All rights reserved.
	*
	* 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 com.google.idea.blaze.base.issueparser;

	import com.google.common.base.Predicate;
	import com.google.common.collect.Lists;
	import com.google.idea.blaze.base.model.primitives.TargetExpression;
	import com.google.idea.blaze.base.model.primitives.WorkspacePath;
	import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
	import com.google.idea.blaze.base.projectview.ProjectViewManager;
	import com.google.idea.blaze.base.projectview.ProjectViewSet;
	import com.google.idea.blaze.base.projectview.section.ListSection;
	import com.google.idea.blaze.base.projectview.section.Section;
	import com.google.idea.blaze.base.projectview.section.SectionKey;
	import com.google.idea.blaze.base.projectview.section.sections.TargetSection;
	import com.google.idea.blaze.base.scope.output.IssueOutput;
	import com.intellij.openapi.project.Project;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;

	import java.io.File;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import static com.google.common.base.Preconditions.checkState;

	/**
	* Parses blaze output for compile errors.
	*/
	public class BlazeIssueParser {

	private static class ParseResult {

	public static final ParseResult NEEDS_MORE_INPUT = new ParseResult(true, null);

	public static final ParseResult NO_RESULT = new ParseResult(false, null);

	private boolean needsMoreInput;
	@Nullable private IssueOutput output;

	private ParseResult(boolean needsMoreInput, IssueOutput output) {
	this.needsMoreInput = needsMoreInput;
	this.output = output;
	}

	public static ParseResult needsMoreInput() {
	return NEEDS_MORE_INPUT;
	}

	public static ParseResult output(IssueOutput output) {
	return new ParseResult(false, output);
	}

	public static ParseResult noResult() {
	return NO_RESULT;
	}
	}

	interface Parser {
	@NotNull
	ParseResult parse(@NotNull String currentLine, @NotNull List<String> previousLines);
	}

	static abstract class SingleLineParser implements Parser {
	@NotNull
	Pattern pattern;

	SingleLineParser(@NotNull String regex) {
	pattern = Pattern.compile(regex);
	}

	@Override
	public ParseResult parse(@NotNull String currentLine, @NotNull List<String> multilineMatchResult) {
	checkState(multilineMatchResult.isEmpty(), "SingleLineParser recieved multiple lines of input");
	return parse(currentLine);
	}

	ParseResult parse(@NotNull String line) {
	Matcher matcher = pattern.matcher(line);
	if (matcher.find()) {
	return ParseResult.output(createIssue(matcher));
	}
	return ParseResult.noResult();
	}

	@Nullable
	protected abstract IssueOutput createIssue(@NotNull Matcher matcher);
	}

	static class CompileParser extends SingleLineParser {
	@NotNull
	private final WorkspaceRoot workspaceRoot;

	public CompileParser(@NotNull WorkspaceRoot workspaceRoot) {
	super("(.?):([0-9]+):([0-9]+:)? (error\|warning): (.)");
	this.workspaceRoot = workspaceRoot;
	}

	@Override
	protected IssueOutput createIssue(@NotNull Matcher matcher) {
	final File file;
	try {
	String fileName = matcher.group(1);
	final WorkspacePath workspacePath;
	if (fileName.startsWith("//depot/google3/")) {
	workspacePath = new WorkspacePath(fileName.substring("//depot/google3/".length()));
	} else if (fileName.startsWith("/")) {
	workspacePath = workspaceRoot.workspacePathFor(new File(fileName));
	} else {
	workspacePath = new WorkspacePath(fileName);
	}
	file = workspaceRoot.fileForPath(workspacePath);
	}
	catch (IllegalArgumentException e) {
	// Ignore -- malformed error message
	return null;
	}

	IssueOutput.Category type = matcher.group(4).equals("error")
	? IssueOutput.Category.ERROR
	: IssueOutput.Category.WARNING;
	return IssueOutput.issue(type, matcher.group(5))
	.inFile(file)
	.onLine(Integer.parseInt(matcher.group(2)))
	.build();
	}
	}

	static class TracebackParser implements Parser {
	private static final Pattern PATTERN = Pattern.compile("(ERROR): (.*?):([0-9]+):([0-9]+): (Traceback \\(most recent call last\\):)");

	@NotNull
	@Override
	public ParseResult parse(@NotNull String currentLine, @NotNull List<String> previousLines) {
	if (previousLines.isEmpty()) {
	if (PATTERN.matcher(currentLine).find()) {
	return ParseResult.needsMoreInput();
	}
	else {
	return ParseResult.noResult();
	}
	}

	if (currentLine.startsWith("\t")) {
	return ParseResult.needsMoreInput();
	}
	else {
	Matcher matcher = PATTERN.matcher(previousLines.get(0));
	checkState(matcher.find(), "Found a match in the first line previously, but now it isn't there.");
	StringBuilder message = new StringBuilder(matcher.group(5));
	for (int i = 1; i < previousLines.size(); ++i) {
	message.append(System.lineSeparator())
	.append(previousLines.get(i));
	}
	message.append(System.lineSeparator())
	.append(currentLine);
	return ParseResult.output(IssueOutput.error(message.toString())
	.inFile(new File(matcher.group(2)))
	.onLine(Integer.parseInt(matcher.group(3)))
	.build());
	}
	}
	}

	static class BuildParser extends SingleLineParser {
	BuildParser() {
	super("(ERROR): (.?):([0-9]+):([0-9]+): (.)");
	}

	@Override
	protected IssueOutput createIssue(@NotNull Matcher matcher) {
	return IssueOutput.error(matcher.group(5))
	.inFile(new File(matcher.group(2)))
	.onLine(Integer.parseInt(matcher.group(3)))
	.build();
	}
	}

	static class LinelessBuildParser extends SingleLineParser {
	LinelessBuildParser() {
	super("(ERROR): (.?):char offsets [0-9]+--[0-9]+: (.)");
	}

	@Override
	protected IssueOutput createIssue(@NotNull Matcher matcher) {
	return IssueOutput.error(matcher.group(3))
	.inFile(new File(matcher.group(2)))
	.build();
	}
	}

	static class ProjectViewLabelParser extends SingleLineParser {

	@Nullable private final ProjectViewSet projectViewSet;

	ProjectViewLabelParser(
	@Nullable ProjectViewSet projectViewSet) {
	super("no such target '(.)': target .? not declared in package .*? defined by");
	this.projectViewSet = projectViewSet;
	}

	@Override
	protected IssueOutput createIssue(@NotNull Matcher matcher) {
	File file = null;
	if (projectViewSet != null) {
	String targetString = matcher.group(1);
	final TargetExpression targetExpression = TargetExpression.fromString(targetString);
	file = projectViewFileWithSection(projectViewSet, TargetSection.KEY, new Predicate<ListSection<TargetExpression>>() {
	@Override
	public boolean apply(@NotNull ListSection<TargetExpression> targetSection) {
	return targetSection.items().contains(targetExpression);
	}
	});
	}

	return IssueOutput.error(matcher.group(0))
	.inFile(file)
	.build();
	}
	}

	static class InvalidTargetProjectViewPackageParser extends SingleLineParser {
	@Nullable private final ProjectViewSet projectViewSet;

	InvalidTargetProjectViewPackageParser(
	@Nullable ProjectViewSet projectViewSet,
	String regex) {
	super(regex);
	this.projectViewSet = projectViewSet;
	}

	@Override
	protected IssueOutput createIssue(@NotNull Matcher matcher) {
	File file = null;
	if (projectViewSet != null) {
	final String packageString = matcher.group(1);
	file = projectViewFileWithSection(projectViewSet, TargetSection.KEY, targetSection -> {
	for (TargetExpression targetExpression : targetSection.items()) {
	if (targetExpression.toString().startsWith("//" + packageString + ":")) {
	return true;
	}
	}
	return false;
	});
	}

	return IssueOutput.error(matcher.group(0))
	.inFile(file)
	.build();
	}
	}

	@Nullable
	private static <T, SectionType extends Section<T>> File projectViewFileWithSection(
	@NotNull ProjectViewSet projectViewSet,
	@NotNull SectionKey<T, SectionType> key,
	@NotNull Predicate<SectionType> predicate) {
	for (ProjectViewSet.ProjectViewFile projectViewFile : projectViewSet.getProjectViewFiles()) {
	SectionType section = projectViewFile.projectView.getSectionOfType(key);
	if (section != null && predicate.apply(section)) {
	return projectViewFile.projectViewFile;
	}
	}
	return null;
	}

	@NotNull private List<Parser> parsers = Lists.newArrayList();
	/** The parser that requested more lines of input during the last call to {@link #parseIssue(String)}. */
	@Nullable private Parser multilineMatchingParser;
	@NotNull private List<String> multilineMatchResult = new ArrayList<>();

	public BlazeIssueParser(
	@Nullable Project project,
	@NotNull WorkspaceRoot workspaceRoot) {

	ProjectViewSet projectViewSet = project != null ? ProjectViewManager.getInstance(project).getProjectViewSet() : null;

	parsers.add(new CompileParser(workspaceRoot));
	parsers.add(new TracebackParser());
	parsers.add(new BuildParser());
	parsers.add(new LinelessBuildParser());
	parsers.add(new ProjectViewLabelParser(projectViewSet));
	parsers.add(new InvalidTargetProjectViewPackageParser(projectViewSet, "no such package '(.*)': BUILD file not found on package path"));
	parsers.add(new InvalidTargetProjectViewPackageParser(projectViewSet, "no targets found beneath '(.*)'"));
	parsers.add(new InvalidTargetProjectViewPackageParser(projectViewSet, "ERROR: invalid target format '(.*)'"));
	}


	@Nullable
	public IssueOutput parseIssue(String line) {

	List<Parser> parsers = this.parsers;
	if (multilineMatchingParser != null) {
	parsers = Lists.newArrayList(multilineMatchingParser);
	}

	for (Parser parser : parsers) {
	ParseResult issue = parser.parse(line, multilineMatchResult);
	if (issue.needsMoreInput) {
	multilineMatchingParser = parser;
	multilineMatchResult.add(line);
	return null;
	}
	else {
	multilineMatchingParser = null;
	multilineMatchResult = new ArrayList<>();
	}

	if (issue.output != null) {
	return issue.output;
	}
	}

	return null;
	}
	}