android/jps-plugin/testSrc/org/jetbrains/jps/android/AndroidBuildTestingCommandExecutor.java

package org.jetbrains.jps.android;

import com.intellij.openapi.util.Pair;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.io.FileUtilRt;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.util.ArrayUtil;
import com.intellij.util.containers.HashMap;
import com.intellij.util.containers.HashSet;
import org.jetbrains.android.util.AndroidBuildTestingManager;
import org.jetbrains.annotations.NotNull;

import java.io.*;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author Eugene.Kudelevsky
 */
abstract class AndroidBuildTestingCommandExecutor implements AndroidBuildTestingManager.MyCommandExecutor {
  public static final String ENTRY_HEADER = "______ENTRY_";

  private volatile StringWriter myStringWriter = new StringWriter();
  private final List<Pair<String, Pattern>> myPathPatterns = new ArrayList<Pair<String, Pattern>>();

  private final Set<String> myCheckedJars = new HashSet<String>();

  public void addPathPrefix(@NotNull String id, @NotNull String prefix) {
    myPathPatterns.add(Pair.create(id, Pattern.compile("(" + FileUtil.toSystemIndependentName(prefix) + ").*")));
  }

  public void addRegexPathPattern(@NotNull String id, @NotNull String regex) {
    myPathPatterns.add(Pair.create(id, Pattern.compile("(" + regex + ")")));
  }

  public void addRegexPathPatternPrefix(@NotNull String id, @NotNull String regex) {
    myPathPatterns.add(Pair.create(id, Pattern.compile("(" + regex + ").*")));
  }

  @NotNull
  @Override
  public Process createProcess(@NotNull String[] args, @NotNull Map<? extends String, ? extends String> environment) {
    startNewEntry();
    final String[] argsToLog = processArgs(args);
    logString(StringUtil.join(argsToLog, "\n"));

    if (environment.size() > 0) {
      final StringBuilder envBuilder = new StringBuilder();

      for (Map.Entry<? extends String, ? extends String> entry : environment.entrySet()) {
        if (envBuilder.length() > 0) {
          envBuilder.append(", ");
        }
        final String value = progessArg(entry.getValue());
        envBuilder.append(entry.getKey()).append("=").append(value);
      }
      logString("\nenv: " + envBuilder.toString());
    }
    logString("\n\n");
    try {
      return doCreateProcess(args, environment);
    }
    catch (RuntimeException e) {
      throw e;
    }
    catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  @Override
  public void log(@NotNull String s) {
    startNewEntry();
    final String[] args = s.split("\\n");
    logString(StringUtil.join(processArgs(args), "\n"));
    logString("\n\n");
  }

  @Override
  public void checkJarContent(@NotNull String jarId, @NotNull String jarPath) {
    doCheckJar(jarId, jarPath);
    myCheckedJars.add(jarId);
  }

  protected void doCheckJar(@NotNull String jarId, @NotNull String jarPath) {
  }

  private synchronized void startNewEntry() {
    logString(ENTRY_HEADER + "\n");
  }

  private synchronized void logString(String s) {
    myStringWriter.write(s);
  }

  private String[] processArgs(String[] args) {
    final String[] result = new String[args.length];

    for (int i = 0; i < result.length; i++) {
      result[i] = progessArg(args[i]);
    }
    return result;
  }

  private String progessArg(String arg) {
    final String[] subargs = arg.split(File.pathSeparator);
    final StringBuilder builder = new StringBuilder();

    for (int i = 0; i < subargs.length; i++) {
      String subarg = subargs[i];
      String s = FileUtil.toSystemIndependentName(subarg);

      if (s.endsWith(".exe")) {
        s = FileUtilRt.getNameWithoutExtension(s);
      }
      for (Pair<String, Pattern> pair : myPathPatterns) {
        final String id = pair.getFirst();
        final Pattern prefixPattern = pair.getSecond();
        final Matcher matcher = prefixPattern.matcher(s);

        if (matcher.matches()) {
          s = "$" + id + "$" + s.substring(matcher.group(1).length());
        }
      }
      builder.append(s);

      if (i < subargs.length - 1) {
        builder.append(File.pathSeparator);
      }
    }
    return builder.toString();
  }

  @NotNull
  protected abstract Process doCreateProcess(@NotNull String[] args, @NotNull Map<? extends String, ? extends String> environment)
    throws Exception;

  @NotNull
  public synchronized String getLog() {
    return myStringWriter.toString();
  }

  public synchronized void clear() {
    myStringWriter = new StringWriter();
    myCheckedJars.clear();
  }

  @NotNull
  protected Set<String> getCheckedJars() {
    return myCheckedJars;
  }

  public static String normalizeExpectedLog(@NotNull String expectedLog, @NotNull String actualLog) {

    final String[] actualEntries = actualLog.split(AndroidBuildTestingCommandExecutor.ENTRY_HEADER);
    final List<String> actualEntryList = new ArrayList<String>();

    for (String entry : actualEntries) {
      final String s = entry.trim();

      if (s.length() == 0) {
        continue;
      }
      actualEntryList.add(s);
    }
    final Map<String, MyLogEntry> id2logEntry = new HashMap<String, MyLogEntry>();
    final String[] entries = expectedLog.split(AndroidBuildTestingCommandExecutor.ENTRY_HEADER);

    for (String entry : entries) {
      final String s = entry.trim();

      if (s.length() == 0) {
        continue;
      }
      final int newLineIdx = s.indexOf('\n');
      final int colonIdx = s.indexOf(':');
      assert colonIdx >= 0 && colonIdx < newLineIdx;

      final String id = s.substring(0, colonIdx);
      final String depIdsStr = s.substring(colonIdx + 1, newLineIdx);
      final String[] depIds = depIdsStr.length() > 0
                              ? depIdsStr.trim().split(",")
                              : ArrayUtil.EMPTY_STRING_ARRAY;
      final String content = s.substring(newLineIdx + 1).trim();
      id2logEntry.put(id, new MyLogEntry(content, depIds));
    }
    final List<String> addedEntries = new ArrayList<String>();
    final Set<String> addedEntriesSet = new HashSet<String>();

    while (addedEntries.size() < id2logEntry.size()) {
      final List<String> candidates = new ArrayList<String>();

      for (Map.Entry<String, MyLogEntry> entry : id2logEntry.entrySet()) {
        final String id = entry.getKey();

        if (addedEntriesSet.contains(id)) {
          continue;
        }
        final MyLogEntry logEntry = entry.getValue();
        boolean canBeAdded = true;

        for (String depId : logEntry.myDepIds) {
          if (!addedEntriesSet.contains(depId)) {
            canBeAdded = false;
            break;
          }
        }

        if (canBeAdded) {
          candidates.add(id);
        }
      }

      if (candidates.size() == 0) {
        throw new RuntimeException("The log graph contains cycles");
      }
      boolean added = false;

      if (actualEntryList.size() > addedEntries.size()) {
        final String actualEntryContent = actualEntryList.get(addedEntries.size());

        for (String id : candidates) {
          if (id2logEntry.get(id).myContent.equals(actualEntryContent)) {
            addedEntries.add(id);
            addedEntriesSet.add(id);
            added = true;
            break;
          }
        }
      }

      if (!added) {
        addedEntriesSet.addAll(candidates);
        addedEntries.addAll(candidates);
      }
    }
    final StringBuilder builder = new StringBuilder();

    for (String id : addedEntries) {
      final MyLogEntry entry = id2logEntry.get(id);
      builder.append(entry.myContent).append("\n\n");
    }
    return builder.toString();
  }

  public static String normalizeLog(@NotNull String log) {
    final String[] entries = log.split(AndroidBuildTestingCommandExecutor.ENTRY_HEADER);
    final StringBuilder result = new StringBuilder();

    for (String entry : entries) {
      final String s = entry.trim();

      if (s.length() == 0) {
        continue;
      }
      result.append(s).append("\n\n");
    }
    return result.toString();
  }

  protected static class MyProcess extends Process {

    private final int myExitValue;
    private final String myOutputText;
    private final String myErrorText;

    protected MyProcess(int exitValue, @NotNull String outputText, @NotNull String errorText) {
      myExitValue = exitValue;
      myOutputText = outputText;
      myErrorText = errorText;
    }

    @Override
    public OutputStream getOutputStream() {
      throw new UnsupportedOperationException();
    }

    @Override
    public InputStream getInputStream() {
      return stringToInputStream(myOutputText);
    }

    @Override
    public InputStream getErrorStream() {
      return stringToInputStream(myErrorText);
    }

    private static ByteArrayInputStream stringToInputStream(String s) {
      return new ByteArrayInputStream(s.getBytes(Charset.defaultCharset()));
    }

    @Override
    public int waitFor() throws InterruptedException {
      return exitValue();
    }

    @Override
    public int exitValue() {
      return myExitValue;
    }

    @Override
    public void destroy() {
    }
  }

  private static class MyLogEntry {
    final String myContent;
    final String[] myDepIds;

    private MyLogEntry(@NotNull String content, @NotNull String[] depIds) {
      myContent = content;
      myDepIds = depIds;
    }
  }
}