TsFmtFormatterStep.java

/*
 * Copyright 2016 DiffPlug
 *
 * 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.github.autostyle.npm;

import static java.util.Arrays.asList;
import static java.util.Objects.requireNonNull;

import com.github.autostyle.FormatterFunc;
import com.github.autostyle.FormatterStep;
import com.github.autostyle.Provisioner;
import com.github.autostyle.ThrowingEx;

import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class TsFmtFormatterStep {
  public static final String NAME = "tsfmt-format";

  @Deprecated
  public static FormatterStep create(Provisioner provisioner, File buildDir, @Nullable File npm, File baseDir, @Nullable TypedTsFmtConfigFile configFile, @Nullable Map<String, Object> inlineTsFmtSettings) {
    return create(defaultDevDependencies(), provisioner, buildDir, npm, configFile, inlineTsFmtSettings);
  }

  public static FormatterStep create(Map<String, String> versions, Provisioner provisioner, File buildDir, @Nullable File npm, @Nullable TypedTsFmtConfigFile configFile, @Nullable Map<String, Object> inlineTsFmtSettings) {
    requireNonNull(provisioner);
    requireNonNull(buildDir);
    return FormatterStep.createLazy(NAME,
        () -> new State(NAME, versions, provisioner, buildDir, npm, configFile, inlineTsFmtSettings),
        State::createFormatterFunc);
  }

  public static Map<String, String> defaultDevDependencies() {
    return defaultDevDependenciesWithTsFmt("7.2.2");
  }

  public static Map<String, String> defaultDevDependenciesWithTsFmt(String typescriptFormatter) {
    TreeMap<String, String> defaults = new TreeMap<>();
    defaults.put("typescript-formatter", typescriptFormatter);
    defaults.put("typescript", "3.3.3");
    defaults.put("tslint", "5.12.1");
    return defaults;
  }

  public static class State extends NpmFormatterStepStateBase implements Serializable {

    private static final long serialVersionUID = -3811104513825329168L;

    private final TreeMap<String, Object> inlineTsFmtSettings;

    private final File buildDir;

    @Nullable
    private final TypedTsFmtConfigFile configFile;

    @Deprecated
    public State(String stepName, Provisioner provisioner, File buildDir, @Nullable File npm, @Nullable TypedTsFmtConfigFile configFile, @Nullable Map<String, Object> inlineTsFmtSettings) throws IOException {
      this(stepName, defaultDevDependencies(), provisioner, buildDir, npm, configFile, inlineTsFmtSettings);
    }

    public State(String stepName, Map<String, String> versions, Provisioner provisioner, File buildDir, @Nullable File npm, @Nullable TypedTsFmtConfigFile configFile, @Nullable Map<String, Object> inlineTsFmtSettings) throws IOException {
      super(stepName,
          provisioner,
          new NpmConfig(
              replaceDevDependencies(readFileFromClasspath(TsFmtFormatterStep.class, "/com/github/autostyle/autostyle/npm/tsfmt-package.json"), new TreeMap<>(versions)),
              "typescript-formatter"),
          buildDir,
          npm);
      this.buildDir = requireNonNull(buildDir);
      this.configFile = configFile;
      this.inlineTsFmtSettings = inlineTsFmtSettings == null ? new TreeMap<>() : new TreeMap<>(inlineTsFmtSettings);
    }

    @Override
    @Nonnull
    public FormatterFunc createFormatterFunc() {

      Map<String, Object> tsFmtOptions = unifyOptions();

      final NodeJSWrapper nodeJSWrapper = nodeJSWrapper();
      final V8ObjectWrapper tsFmt = nodeJSWrapper.require(nodeModulePath());
      final V8ObjectWrapper formatterOptions = nodeJSWrapper.createNewObject(tsFmtOptions);

      final TsFmtResult[] tsFmtResult = new TsFmtResult[1];
      final Exception[] toThrow = new Exception[1];

      V8FunctionWrapper formatResultCallback = createFormatResultCallback(nodeJSWrapper, tsFmtResult, toThrow);

      /* var result = {
      fileName: fileName,
      settings: formatSettings,
      message: message, <-- string
      error: error, <-- boolean
      src: content,
      dest: formattedCode, <-- result
      }
      */
      return FormatterFunc.Closeable.of(() -> {
        asList(formatResultCallback, formatterOptions, tsFmt, nodeJSWrapper).forEach(ReflectiveObjectWrapper::release);
      }, input -> {
        tsFmtResult[0] = null;

        // function processString(fileName: string, content: string, opts: Options): Promise<Result> {

        try (
            V8ArrayWrapper processStringArgs = nodeJSWrapper.createNewArray("autostyle-format-string.ts", input, formatterOptions);
            V8ObjectWrapper promise = tsFmt.executeObjectFunction("processString", processStringArgs);
            V8ArrayWrapper callbacks = nodeJSWrapper.createNewArray(formatResultCallback)) {

          promise.executeVoidFunction("then", callbacks);

          while (tsFmtResult[0] == null && toThrow[0] == null) {
            nodeJSWrapper.handleMessage();
          }

          if (toThrow[0] != null) {
            throw ThrowingEx.asRuntime(toThrow[0]);
          }

          if (tsFmtResult[0] == null) {
            throw new IllegalStateException("should never happen");
          }
          if (tsFmtResult[0].isError()) {
            throw new RuntimeException(tsFmtResult[0].getMessage());
          }
          return tsFmtResult[0].getFormatted();
        }
      });
    }

    private V8FunctionWrapper createFormatResultCallback(NodeJSWrapper nodeJSWrapper, TsFmtResult[] outputTsFmtResult, Exception[] toThrow) {
      return nodeJSWrapper.createNewFunction((receiver, parameters) -> {
        try (final V8ObjectWrapper result = parameters.getObject(0)) {
          outputTsFmtResult[0] = new TsFmtResult(result.getString("message"), result.getBoolean("error"), result.getString("dest"));
        } catch (Exception e) {
          toThrow[0] = e;
        }
        return receiver;
      });
    }

    private Map<String, Object> unifyOptions() {
      Map<String, Object> unified = new HashMap<>();
      if (!this.inlineTsFmtSettings.isEmpty()) {
        File targetFile = new File(this.buildDir, "inline-tsfmt.json");
        SimpleJsonWriter.of(this.inlineTsFmtSettings).toJsonFile(targetFile);
        unified.put("tsfmt", true);
        unified.put("tsfmtFile", targetFile.getAbsolutePath());
      } else if (this.configFile != null) {
        unified.put(this.configFile.configFileEnabledOptionName(), Boolean.TRUE);
        unified.put(this.configFile.configFileOptionName(), this.configFile.absolutePath());
      }
      return unified;
    }
  }
}