/** Returns the FormatterStep (whose state will be calculated lazily). */ public FormatterStep build() { return FormatterStep.createLazy(formatterName + formatterStepExt, this::get, stateToFormatter); }
/** * @param name * The name of the formatter step * @param state * If the rule has any state, this state must contain all of it * @param stateToFormatter * A pure function which generates a formatting function using * only the state supplied by state and nowhere else. * @return A FormatterStep */ public static <State extends Serializable> FormatterStep create( String name, State state, ThrowingEx.Function<State, FormatterFunc> stateToFormatter) { Objects.requireNonNull(state, "state"); return createLazy(name, () -> state, stateToFormatter); }
private static FormatterStep create(String version, Provisioner provisioner, boolean isScript, Map<String, String> userData) { Objects.requireNonNull(version, "version"); Objects.requireNonNull(provisioner, "provisioner"); return FormatterStep.createLazy(NAME, () -> new State(version, provisioner, isScript, userData), State::createFormat); }
public static FormatterStep create(String name, String regex, String replacement) { Objects.requireNonNull(name, "name"); Objects.requireNonNull(regex, "regex"); Objects.requireNonNull(replacement, "replacement"); return FormatterStep.createLazy(name, () -> new State(Pattern.compile(regex, Pattern.UNIX_LINES | Pattern.MULTILINE), replacement), State::toFormatter); }
public static FormatterStep create(String name, CharSequence target, CharSequence replacement) { Objects.requireNonNull(name, "name"); Objects.requireNonNull(target, "target"); Objects.requireNonNull(replacement, "replacement"); return FormatterStep.createLazy(name, () -> new State(target, replacement), State::toFormatter); }
public static FormatterStep create(String version, Provisioner provisioner, @Nullable File configFile) { Objects.requireNonNull(version, "version"); Objects.requireNonNull(provisioner, "provisioner"); return FormatterStep.createLazy(NAME, () -> new State(version, provisioner, configFile), State::createFormat); }
public static FormatterStep create(Iterable<File> files) { return FormatterStep.createLazy(NAME, () -> new State(files), State::createFormat); }
private FormatterStep createFrom(List<String> importOrder) { return FormatterStep.createLazy("importOrder", () -> new State(importOrder, lineFormat), State::toFormatter); }
public static FormatterStep create(Provisioner provisioner, File buildDir, @Nullable File npm, PrettierConfig prettierConfig) { requireNonNull(provisioner); requireNonNull(buildDir); return FormatterStep.createLazy(NAME, () -> new State(NAME, provisioner, buildDir, npm, prettierConfig), State::createFormatterFunc); }
/** Creates a step which formats everything - code, import order, and unused imports. */ public static FormatterStep create(String version, String style, Provisioner provisioner) { Objects.requireNonNull(version, "version"); Objects.requireNonNull(style, "style"); Objects.requireNonNull(provisioner, "provisioner"); return FormatterStep.createLazy(NAME, () -> new State(NAME, version, style, provisioner), State::createFormat); }
public static FormatterStep create(Provisioner provisioner, File buildDir, @Nullable File npm, File baseDir, @Nullable TypedTsFmtConfigFile configFile, @Nullable Map<String, Object> inlineTsFmtSettings) { requireNonNull(provisioner); requireNonNull(buildDir); requireNonNull(baseDir); return FormatterStep.createLazy(NAME, () -> new State(NAME, provisioner, buildDir, npm, baseDir, configFile, inlineTsFmtSettings), State::createFormatterFunc); }
/** * Creates a FormatterStep which forces the start of each file to match the license header * contained in the given file. */ public static FormatterStep createFromFile(File licenseHeaderFile, Charset encoding, String delimiter, String yearSeparator) { Objects.requireNonNull(licenseHeaderFile, "licenseHeaderFile"); Objects.requireNonNull(encoding, "encoding"); Objects.requireNonNull(delimiter, "delimiter"); Objects.requireNonNull(yearSeparator, "yearSeparator"); return FormatterStep.createLazy(LicenseHeaderStep.NAME, () -> new LicenseHeaderStep(licenseHeaderFile, encoding, delimiter, yearSeparator), step -> step::format); }
/** * Adds the given custom step, which is constructed lazily for performance reasons. * * The resulting function will receive a string with unix-newlines, and it must return a string unix newlines. * * If you're getting errors about `closure cannot be cast to com.diffplug.common.base.Throwing$Function`, then use * {@link #customLazyGroovy(String, ThrowingEx.Supplier)}. */ public void customLazy(String name, ThrowingEx.Supplier<FormatterFunc> formatterSupplier) { Objects.requireNonNull(name, "name"); Objects.requireNonNull(formatterSupplier, "formatterSupplier"); addStep(FormatterStep.createLazy(name, () -> globalState, unusedState -> formatterSupplier.get())); }
public static FormatterStep create(Provisioner provisioner) { Objects.requireNonNull(provisioner, "provisioner"); return FormatterStep.createLazy(NAME, () -> new GoogleJavaFormatStep.State(NAME, GoogleJavaFormatStep.defaultVersion(), provisioner), GoogleJavaFormatStep.State::createRemoveUnusedImportsOnly); } }
/** Creates a formatter step for the given version and settings file. */ public static FormatterStep create(String version, Supplier<Map<String, ?>> properties, Provisioner provisioner) { Objects.requireNonNull(version, "version"); Objects.requireNonNull(properties, "properties"); Objects.requireNonNull(provisioner, "provisioner"); return FormatterStep.createLazy(NAME, () -> new State(JarState.from(MAVEN_COORDINATE + version, provisioner), properties.get()), State::createFormat); }
/** Returns the FormatterStep (whose state will be calculated lazily). */ public FormatterStep build() { return FormatterStep.createLazy(formatterName + formatterStepExt, this::get, stateToFormatter); }