Update dependency java-parser to v2

[renovate]

This PR contains the following updates:

Package	Change	Age	Adoption	Passing	Confidence
java-parser	0.3.2 -> 2.0.1

---

Release Notes

jhipster/prettier-java

v2.0.1

Compare Source

v2.0.0

Compare Source

v1.4.0

Compare Source

Enhancements

• Improve method invocation with lambda parameters (#​497)

Fixes

• Fix parsing of static imports of yield methods (#​499)
• Improve java-parser types signatures (#​496)

v1.3.1

Compare Source

Fixes

• Fix interface member detection to support inner records
  (From @​rnorth: #​492)
• Remove yarn-error.log file from releases

v1.2.0

Compare Source

Enhancements

• Supports of instance of pattern matching (#​476)

// Input
if (o instanceof Integer i || p instanceof Point || q instanceof Circle c || r instanceof Square) {
  formatted = String.format("int %d", i);
} else if (o instanceof Long l) {
  formatted = String.format("long %d", l);
} else if (o instanceof Double d) {
  formatted = String.format("double %f", d);
} else if (o instanceof String s) {
  formatted = String.format("String %s", s);
}

// Output
if (
  o instanceof Integer i ||
  p instanceof Point ||
  q instanceof Circle c ||
  r instanceof Square
) {
  formatted = String.format("int %d", i);
} else if (o instanceof Long l) {
  formatted = String.format("long %d", l);
} else if (o instanceof Double d) {
  formatted = String.format("double %f", d);
} else if (o instanceof String s) {
  formatted = String.format("String %s", s);
}

• Supports of sealed classes and interfaces (#​478)

// Input
public sealed class Rectangle
  implements Shape
  permits Square {

  private final double length;
  private final double height;

  public Rectangle(double length, double height) {
    this.length = length;
    this.height = height;
  }

  @​Override
  public double area() {
    return length * height;
  }
}

// Output
public sealed class Rectangle implements Shape permits Square {

  private final double length;
  private final double height;

  public Rectangle(double length, double height) {
    this.length = length;
    this.height = height;
  }

  @​Override
  public double area() {
    return length * height;
  }
}

Miscallenous

• Add copy/pastable Checkstyle configuration compatible with Prettier (#​477)

v1.1.1

Compare Source

Fixes

• Fix parsing records inside class declarations
  and records with simplified constructors
  (#​470)

Miscallenous

• Update links to Chevrotain library (From @​Austin-Scott: #​472)

v1.1.0

Compare Source

Enhancements

• Supports of Records (#​460)

// Input
public record Pet(
    @​NotNull String name, int age, String... others, Object @​Nullable... errorMessageArgs
  ) {
  public Pet {
    if (age < 0) {
      throw new IllegalArgumentException("Age cannot be negative");
    }

    if (name == null || name.isBlank()) {
      throw new IllegalArgumentException("Name cannot be blank");
    }
  }

  public void test() {}
}

// Output
public record Pet(
  @&#8203;NotNull String name, int age, String... others, Object @&#8203;Nullable... errorMessageArgs
) {
  public Pet {
    if (age < 0) {
      throw new IllegalArgumentException("Age cannot be negative");
    }

    if (name == null || name.isBlank()) {
      throw new IllegalArgumentException("Name cannot be blank");
    }
  }

  public void test() {}
}

v1.0.2

Compare Source

Fixes

• Keep space between annotation and type identifiers in unannClassType expressions (#​455)

// Input
class T {
  SomeClass.@​Valid SomeInnerClass someInnerClass = someClass.getInteractions().get(0);

  void process(
    Map.@&#8203;NonNull Entry<String, SkeletonConfiguration> entry,
    @&#8203;NonNull Map<String, Object> context
  ) {}
}

// Prettier 1.0.1
class T {
  SomeClass.@&#8203;ValidSomeInnerClass someInnerClass = someClass
    .getInteractions()
    .get(0);

  void process(
    Map.@&#8203;NonNullEntry<String, SkeletonConfiguration> entry,
    @&#8203;NonNull Map<String, Object> context
  ) {}
}

// Prettier 1.0.2
class T {

  SomeClass.@&#8203;Valid SomeInnerClass someInnerClass = someClass
    .getInteractions()
    .get(0);

  void process(
    Map.@&#8203;NonNull Entry<String, SkeletonConfiguration> entry,
    @&#8203;NonNull Map<String, Object> context
  ) {}
}

• Fix inconsistent indentation between chained method on method and new object (#​456)

// Input
class T {
  public void method() {
    new Foo(stuff, thing, "auaaaaaaaaa some very long stuff", "some more").bar(10);
    foo(stuff, thing, "some very longuuuuuuuuuuuuuu stuff", "some more").bar(10);
  }
}

// Prettier 1.0.1
class T {
  public void method() {
    new Foo(stuff, thing, "auaaaaaaaaa some very long stuff", "some more")
    .bar(10);
    foo(stuff, thing, "some very longuuuuuuuuuuuuuu stuff", "some more")
      .bar(10);
  }
}

// Prettier 1.0.2
class T {

  public void method() {
    new Foo(stuff, thing, "auaaaaaaaaa some very long stuff", "some more")
      .bar(10);
    foo(stuff, thing, "some very longuuuuuuuuuuuuuu stuff", "some more")
      .bar(10);
  }
}

• Fix unstable formatting for method invocations with only comments (#​457)

// Input
class T {
  public void method() {
    Arrays.asList(// a
                  // b
                  // c
                  // d
    );
  }
}

// Prettier 1.0.1
class T {
  public void method() {
    Arrays.asList(// b // a
    // c
    // d
    );
  }
}

// Prettier 1.0.2
class T {

  public void method() {
    Arrays.asList( // a
      // b
      // c
      // d
    );
  }
}

Miscellaneous

• Update lodash dependency to 4.17.21 (#​458)

v1.0.0

Compare Source

Enhancements

• Support of Java 15 ! 🚀

• Support of Text blocks

• Support of new switch rules and yield statements

• Improve throws rendering (From @​jhaber: #​384)

// Input

void throwException7(String string1, String string2, String string3, String string4) throws RuntimeException {
  throw new RuntimeException();
}

// Prettier 0.8.3

void throwException7(
  String string1,
  String string2,
  String string3,
  String string4
)
  throws RuntimeException {
  throw new RuntimeException();
}

// Prettier 1.0.0

void throwException7(
  String string1,
  String string2,
  String string3,
  String string4
) throws RuntimeException {
  throw new RuntimeException();
}

Fixes

• Parsing of unannPrimitiveType in primary (#​421)

Miscellaneous

• Update dependencies

v0.8.2

Compare Source

Fixes

• Revert: Parsing of unannPrimitiveType in primary (#​421).
  It was causing a breaking change in the java-parser

• uses exact dependencies when releasing a new version of java-parser and prettier-plugin-java

v0.8.1

Compare Source

Enhancements

• Generated a type definition for the Java parser (#​422)

Fixes

• Wrong indent in some chained methods invocation (#​404)

// Input
class Indent {

  void indetMethod() {
    assertThat(
      useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
      useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
      useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa
    );

    assertThat(
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa
      )
      .isEqualTo();

    assertThat(
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa
      )
      .isEqualTo()
      .anotherInvocation(
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa
      );

    myInstanceObject
      .assertThat(
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa
      )
      .isEqualTo();

  }
}

// Output
class Indent {

  void indetMethod() {
    assertThat(
      useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
      useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
      useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa
    );

    assertThat(
      useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
      useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
      useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa
    )
      .isEqualTo();

    assertThat(
      useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
      useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
      useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa
    )
      .isEqualTo()
      .anotherInvocation(
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa,
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa
      );

    myInstanceObject
      .assertThat(
        useraaaaaaaaaaojzapjzpozjapjzpoajzpozaaaaaaaaaaaMapperlaaaaaaaaaaaaaaaaaaaaaaaa
      )
      .isEqualTo();
  }
}

• Parsing of unannPrimitiveType in primary (#​421)

// Throws in Prettier 0.8.0
double[][]::new

// Prettier 0.9.0
double[][]::new

v0.8.0

Compare Source

Enhancements

• Possibility to run the Prettier Java package on every entrypoint defined in the following list (#​395):

  [
    "variableInitializerList",
    "block",
    "blockStatements",
    "blockStatement",
    "localVariableDeclarationStatement",
    "localVariableDeclaration",
    "localVariableType",
    "statement",
    "statementWithoutTrailingSubstatement",
    "emptyStatement",
    "labeledStatement",
    "expressionStatement",
    "statementExpression",
    "ifStatement",
    "assertStatement",
    "switchStatement",
    "switchBlock",
    "switchCase",
    "switchLabel",
    "enumConstantName",
    "whileStatement",
    "doStatement",
    "forStatement",
    "basicForStatement",
    "forInit",
    "forUpdate",
    "statementExpressionList",
    "enhancedForStatement",
    "breakStatement",
    "continueStatement",
    "returnStatement",
    "throwStatement",
    "synchronizedStatement",
    "tryStatement",
    "catches",
    "catchClause",
    "catchFormalParameter",
    "catchType",
    "finally",
    "tryWithResourcesStatement",
    "resourceSpecification",
    "resourceList",
    "resource",
    "resourceInit",
    "variableAccess",
    "isBasicForStatement",
    "isLocalVariableDeclaration",
    "classDeclaration",
    "normalClassDeclaration",
    "classModifier",
    "typeParameters",
    "typeParameterList",
    "superclass",
    "superinterfaces",
    "interfaceTypeList",
    "classBody",
    "classBodyDeclaration",
    "classMemberDeclaration",
    "fieldDeclaration",
    "fieldModifier",
    "variableDeclaratorList",
    "variableDeclarator",
    "variableDeclaratorId",
    "variableInitializer",
    "unannType",
    "unannPrimitiveType",
    "unannReferenceType",
    "unannClassOrInterfaceType",
    "unannClassType",
    "unannInterfaceType",
    "unannTypeVariable",
    "methodDeclaration",
    "methodModifier",
    "methodHeader",
    "result",
    "methodDeclarator",
    "receiverParameter",
    "formalParameterList",
    "formalParameter",
    "variableParaRegularParameter",
    "variableArityParameter",
    "variableModifier",
    "throws",
    "exceptionTypeList",
    "exceptionType",
    "methodBody",
    "instanceInitializer",
    "staticInitializer",
    "constructorDeclaration",
    "constructorModifier",
    "constructorDeclarator",
    "simpleTypeName",
    "constructorBody",
    "explicitConstructorInvocation",
    "unqualifiedExplicitConstructorInvocation",
    "qualifiedExplicitConstructorInvocation",
    "enumDeclaration",
    "enumBody",
    "enumConstantList",
    "enumConstant",
    "enumConstantModifier",
    "enumBodyDeclarations",
    "isClassDeclaration",
    "identifyClassBodyDeclarationType",
    "isDims",
    "constantExpression",
    "expression",
    "lambdaExpression",
    "lambdaParameters",
    "lambdaParametersWithBraces",
    "lambdaParameterList",
    "inferredLambdaParameterList",
    "explicitLambdaParameterList",
    "lambdaParameter",
    "regularLambdaParameter",
    "lambdaParameterType",
    "lambdaBody",
    "ternaryExpression",
    "binaryExpression",
    "unaryExpression",
    "unaryExpressionNotPlusMinus",
    "primary",
    "primaryPrefix",
    "primarySuffix",
    "fqnOrRefType",
    "fqnOrRefTypePartRest",
    "fqnOrRefTypePartCommon",
    "fqnOrRefTypePartFirst",
    "parenthesisExpression",
    "castExpression",
    "primitiveCastExpression",
    "referenceTypeCastExpression",
    "newExpression",
    "unqualifiedClassInstanceCreationExpression",
    "classOrInterfaceTypeToInstantiate",
    "typeArgumentsOrDiamond",
    "diamond",
    "methodInvocationSuffix",
    "argumentList",
    "arrayCreationExpression",
    "arrayCreationDefaultInitSuffix",
    "arrayCreationExplicitInitSuffix",
    "dimExprs",
    "dimExpr",
    "classLiteralSuffix",
    "arrayAccessSuffix",
    "methodReferenceSuffix",
    "identifyNewExpressionType",
    "isLambdaExpression",
    "isCastExpression",
    "isPrimitiveCastExpression",
    "isReferenceTypeCastExpression",
    "isRefTypeInMethodRef",
    "interfaceDeclaration",
    "normalInterfaceDeclaration",
    "interfaceModifier",
    "extendsInterfaces",
    "interfaceBody",
    "interfaceMemberDeclaration",
    "constantDeclaration",
    "constantModifier",
    "interfaceMethodDeclaration",
    "interfaceMethodModifier",
    "annotationTypeDeclaration",
    "annotationTypeBody",
    "annotationTypeMemberDeclaration",
    "annotationTypeElementDeclaration",
    "annotationTypeElementModifier",
    "defaultValue",
    "annotation",
    "elementValuePairList",
    "elementValuePair",
    "elementValue",
    "elementValueArrayInitializer",
    "elementValueList",
    "identifyInterfaceBodyDeclarationType",
    "identifyAnnotationBodyDeclarationType",
    "isSimpleElementValueAnnotation",
    "literal",
    "integerLiteral",
    "floatingPointLiteral",
    "booleanLiteral",
    "moduleName",
    "packageName",
    "typeName",
    "expressionName",
    "methodName",
    "packageOrTypeName",
    "ambiguousName",
    "compilationUnit",
    "ordinaryCompilationUnit",
    "modularCompilationUnit",
    "packageDeclaration",
    "packageModifier",
    "importDeclaration",
    "typeDeclaration",
    "moduleDeclaration",
    "moduleDirective",
    "requiresModuleDirective",
    "exportsModuleDirective",
    "opensModuleDirective",
    "usesModuleDirective",
    "providesModuleDirective",
    "requiresModifier",
    "isModuleCompilationUnit",
    "primitiveType",
    "numericType",
    "integralType",
    "floatingPointType",
    "referenceType",
    "classOrInterfaceType",
    "classType",
    "interfaceType",
    "typeVariable",
    "dims",
    "typeParameter",
    "typeParameterModifier",
    "typeBound",
    "additionalBound",
    "typeArguments",
    "typeArgumentList",
    "typeArgument",
    "wildcard",
    "wildcardBounds"
  ]

Fixes

Re-Writer

• Fix formatting of empty enums to not insert commas when trailing-comma is enabled #​385)

  // Input
  public enum Enum {
  }
  
  // Prettier v0.7.1
  public enum Enum {
    ,
  }
  
  // Prettier v0.8.0
  public enum Enum {}

• Fix formatting of enum with comments #​385)

Miscellaneous

• Update prettier dependency to 2.0.5 (#​379) & (#​400)
• Binary artefacts creation for each release (#​399)
• Document Maven plugin (#​394)

v0.7.1

Compare Source

Fixes

Re-Writer

• Fix stable formatting for fields and methods with annotations (#​369)

Miscellaneous

• Update prettier dependency to 1.19.1 (#​370)

v0.7.0

Compare Source

Enhancements

Re-Writer

• Add support for trailing commas option (#​354)

  For enumerations:

  // Input
  public enum Enum {
    ONE, TWO, THREE
  }
  
  // Output
  public enum Enum {
    ONE,
    TWO,
    THREE,
  }

  For arrays:

  // Input
  public class T {
    void t() {
      int[] ints = { 1, 2, 3, };
      int[] ints = { aVeryLongArrayValue, anotherVeryLongArrayValue, andYetAnotherVeryLongArrayValue };
    }
  }
  
  // Output
  public class T {
    void t() {
      int[] ints = { 1, 2, 3 };
      int[] ints = {
        aVeryLongArrayValue,
        anotherVeryLongArrayValue,
        andYetAnotherVeryLongArrayValue,
      };
    }
  }

• By default, remove trailing comma in arrays (#​354)

  // Input
  public class T {
    void t() {
      int[] ints = { 1, 2, 3, };
    }
  }
  
  // Output
  public class T {
    void t() {
      int[] ints = { 1, 2, 3 };
    }
  }

• Allow blank lines in enumerations' constant list (#​350)

  // Input
  public enum OtherEnum {
    ONE, TWO,
  
    THREE,
  
    FOUR,
    /* Five */
    FIVE,
  
    /* Six */
    SIX
  
  }
  
  // Output
  public enum OtherEnum {
    ONE,
    TWO,
  
    THREE,
  
    FOUR,
    /* Five */
    FIVE,
  
    /* Six */
    SIX
  }

• Always add a blank line between an enumeration's constants and declarations (#​351)

  // This input
  public enum EnumWithExtraCommaAndEnumBodyDeclarations {
    THIS_IS_GOOD("abc"),
    THIS_IS_FINE("abc");
    public static final String thisWillBeDeleted = "DELETED";
  }
  
  // will be formatted to this output
  public enum EnumWithExtraCommaAndEnumBodyDeclarations {
    THIS_IS_GOOD("abc"),
    THIS_IS_FINE("abc");
  
    public static final String thisWillBeDeleted = "DELETED";
  }

Fixes

Re-Writer

• Fix blank lines with empty statements (#​360)

  // Input
  public class Test {
    public TestField testField;;
  
    @​Override
    public void someMethod() {}
  }
  
  // Output (v0.6.0)
  public class Test {
    public TestField testField;
    @​Override
    public void someMethod() {}
  }
  
  // Output (v0.7.0)
  public class Test {
    public TestField testField;
  
    @​Override
    public void someMethod() {}
  }

• Fix line wrapping in switch statements (#​359)

  // Input
  public String shouldWrapEvenForSmallSwitchCases() {
    switch (answer) { case "YES": return "YES"; default: return "NO"; }
  }
  // Output (v0.6.0)
  public String shouldWrapEvenForSmallSwitchCases() {
    switch (answer) { case "YES": return "YES"; default: return "NO"; }
  }
  
  // Output (v0.7.0)
  public String shouldWrapEvenForSmallSwitchCases() {
    switch (answer) {
      case "YES":
        return "YES";
      default:
        return "NO";
    }
  }

• Fix stable reformating of comments in binary expression (#​353)

  // Input
  public boolean binaryOperationWithComments() {
    boolean a = one || two >> 1 // one
      // two
      // three
      || // five
      // four
      three;
  
    boolean b = one || two >> 1 // one
      // two
      // three
      ||
      three;
  
    boolean c = one || two >> 1 // one
      // two
      // three
      || three;
  
    return a || b || c;
  }
  
  // Output (v0.6.0)
  public boolean binaryOperationWithComments() {
    boolean a =
      one ||
      two >> 1 // two // one
      // three
      || // five
      // four
      three;
  
    boolean b =
      one ||
      two >> 1 // two // one
      // three
      ||
      three;
  
    boolean c =
      one ||
      two >> 1 // two // one
      // three
      ||
      three;
  
    return a || b || c;
  }
  
  // Output (v0.7.0)
  public boolean binaryOperationWithComments() {
    boolean a =
      one ||
      two >> 1 || // one
      // five
      // two
      // three
      // four
      three;
  
    boolean b =
      one ||
      two >> 1 || // one
      // two
      // three
      three;
  
    boolean c =
      one ||
      two >> 1 || // one
      // two
      // three
      three;
  
    return a || b || c;
  }

• Fix comments indentation when they are at the end of a block: indent the comments based on the block they are in (#​345)

  // Input
  public class T {
    int i;
    // comment
  }
  
  // Output (v0.6.0)
  public class T {
    int i;
  // comment
  }
  
  // Output (v0.7.0)
  public class T {
    int i;
    // comment
  }

• Fix respect of blank lines with comments (#​348)

  // Input
  void t() {
    int i;
    // comment
    int j;
  }
  
  // Output (v0.6.0)
  void t() {
    int i;
  
    // comment
    int j;
  }
  
  // Output (v0.7.0)
  void t() {
    int i;
    // comment
    int j;
  }

v0.6.0

Compare Source

Enhancements

Parser

• Optimize parser performance by reducing the global maxLookahead to 1 (#​321)

Re-Writer

• Support // formater-off and // formater-on comments to disable formating on some parts of the code (#​323)

  // Input
  // @​formatter:off
  public class PrettierIgnoreClass {
    public void myMethod(int param1, int param2, int param3, int param4, int param5, int param6, int param7, int param8, int param9, int param10) {
  
    }
  }
  // @​formatter:on
  public class PrettierIgnoreClass {
    public void myMethod(int param1, int param2, int param3, int param4, int param5, int param6, int param7, int param8, int param9, int param10) {
  
    }
  }

  // Output
  // @​formatter:off
  public class PrettierIgnoreClass {
    public void myMethod(int param1, int param2, int param3, int param4, int param5, int param6, int param7, int param8, int param9, int param10) {
  
    }
  }
  
  // @​formatter:on
  public class PrettierIgnoreClass {
  
    public void myMethod(
      int param1,
      int param2,
      int param3,
      int param4,
      int param5,
      int param6,
      int param7,
      int param8,
      int param9,
      int param10
    ) {}
  }

• Print enums' values on their own line (#​319)

  // Input
  public enum Enum {
    SOME_ENUM, ANOTHER_ENUM, LAST_ENUM
  }
  
  // Output
  public enum Enum {
    SOME_ENUM,
    ANOTHER_ENUM,
    LAST_ENUM
  }

• Remove extra comma in enums (#​319)

  // Input
  public enum EnumWithExtraComma {
    SOME_ENUM, ANOTHER_ENUM, LAST_ENUM,
  }
  
  // Output
  public enum Enum {
    SOME_ENUM,
    ANOTHER_ENUM,
    LAST_ENUM
  }

• Respect case when sorting imports (#​330)

  // Input
  import java.util.ArrayList;
  import java.util.function.Consumer;
  import java.util.functioN.Consumer;
  import java.util.function.ConsumerTwo;
  import java.util.List;
  import java.util.concurrent.Semaphore;
  import java.util.concurrent.*;
  import java.util.Map;
  
  // Output
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.*;
  import java.util.concurrent.Semaphore;
  import java.util.functioN.Consumer;
  import java.util.function.Consumer;
  import java.util.function.ConsumerTwo;

• Improve formatting of lambda expressions when they break (#​333)

  // Input && v0.5.1
  public void lambdaWithoutBracesWhichBreak() {
    call(x -> foo.isVeryVeryVeryLongConditionTrue() &&
    foo.isAnotherVeryVeryLongConditionTrue());
  }
  
  // Output
  public void lambdaWithoutBracesWhichBreak() {
    call(
      x ->
        foo.isVeryVeryVeryLongConditionTrue() &&
        foo.isAnotherVeryVeryLongConditionTrue()
    );
  }

• Don't indent binary operators (#​329)

  // Input && v0.5.1
  @​Annotation(
    "This operation with two very long string should break" +
      "in a very nice way"
  )
  public void method() {}
  
  // Output
  @​Annotation(
    "This operation with two very long string should break" +
    "in a very nice way"
  )
  public void method() {}

• Improve ternary expression line wrapping (#​318)

  // Input && v0.5.1
  return (columnIndex == null) ? ImmutableMap.<R, V>of()
    : new Column(columnIndex);
  
  // Output
  return (columnIndex == null)
    ? ImmutableMap.<R, V>of()
    : new Column(columnIndex);

• Improve formatting of variable initialization with methods (#​332)

  // Input && v0.5.1
  boolean willDrop = predictDropResponse.getSendResult().isIgnorableFailure() || predictDropResponse.getSendResult().isFatalError();
  
  // Output
  boolean willDrop =
    predictDropResponse.getSendResult().isIgnorableFailure() ||
    predictDropResponse.getSendResult().isFatalError();

Fixes

Parser

• Fix brackets considered as a cast with byte shifting or comparison
  (e.g. (left) << right or (left) < right). The parser is now able to parse completely the ElasticSearch Repository (#​325)

Re-Writer

• Fix stable reformating of variable declaration with comments (#​336)

  // Input && v0.5.1
  Map<String, String> map =
    // there is a random comment on this line up here
    // and then there is a separate comment on this line down here
    new HashMap<>(someMethodThatReturnsAMap());
  
  // Output
  Map<String, String> map =
    // there is a random comment on this line up here
    // and then there is a separate comment on this line down here
    new HashMap<>(someMethodThatReturnsAMap());

Miscellaneous

• Check stable reformating for repositories in tests (#​335)
• Add template for submitting an issue (#​340)

v0.5.1

Compare Source

Fixes

• Fix parsing and printing of variable arity parameters with dims (#​310)
• Fix package size (#​317)

v0.5.0

Compare Source

Enhancements

Parser

• Optimize parser initialisation (#​295)

Re-Writer

• Sort class, method and field modifiers (#​302). See this doc for more information

  // Input
  final private static @​Annotation String S = "abc";
  
  // Output
  @​Annotation
  private static final String S = "abc";

Fixes

Parser

• Fix lexer gap: align use of transitive keyword with the specs (#​297)

Re-Writer

• Fix enforcement of printWidth for nodes with leading comments (#​278)
• Fix switch statements indentation with comments (#​278)
• Fix unstable formating when wrapping in return statements (#​294)
• Fix variable arity parameters formating (#​304)

Miscellaneous

• Drop testing on Node 8 and add testing on Node 13

v0.4.0

Compare Source

Enhancements

• Upgrade Chevrotain to 6.5.0 (#​268)

• Split enum to one constant per line if too long (#​266)

public enum EnumWhichBreak {

  ONE_VALUE, TWO_VALUE, THREE_VALUE, FOUR_VALUE, FIVE_VALUE, SIX_VALUE, SEVEN_VALUE, EIGHT_VALUE, NINE_VALUE,
  TEN_VALUE

}

would be transformed in:

public enum EnumWhichBreak {
  ONE_VALUE,
  TWO_VALUE,
  THREE_VALUE,
  FOUR_VALUE,
  FIVE_VALUE,
  SIX_VALUE,
  SEVEN_VALUE,
  EIGHT_VALUE,
  NINE_VALUE,
  TEN_VALUE
}

When

public enum EnumWhichNotBreak {
  SOME_ENUM, ANOTHER_ENUM, LAST_ENUM
}

would be kept as it is:

public enum EnumWhichNotBreak {
  SOME_ENUM, ANOTHER_ENUM, LAST_ENUM
}

• Remove extra semicolons in enums when possible (#​266)

public enum EnumWhichNotBreak {
  SOME_ENUM, ANOTHER_ENUM, LAST_ENUM;
}

would be transformed in:

public enum EnumWhichNotBreak {
  SOME_ENUM, ANOTHER_ENUM, LAST_ENUM
}

when the following is kept as it is:

public enum Enum {
  THIS_IS_GOOD("abc"), THIS_IS_FINE("abc");
  public static final String thisWillBeDeleted = "DELETED";

  private final String value;

  public Enum(String value) {
    this.value = value;
  }

  public String toString() {
    return "STRING";
  }

• Organise imports according to Google style (#​273 and #​281)

package my.own.pkg;

import something.Different;
import java.utils.*;;;
import abc.def.Something;
import abc.def.Another;;;
import abc.def;
import static abc.def;
import  static something.Different;
import static  java.utils.*;;;
import static abc.def.Something;
import static abc.def.Another;;;
import one.last;;;

public class PackageAndImports {}

is transformed in:

package my.own.pkg;

import static abc.def;
import static abc.def.Another;
import static abc.def.Something;
import static java.utils.*;
import static something.Different;

import abc.def;
import abc.def.Another;
import abc.def.Something;
import java.utils.*;
import one.last;
import something.Different;

public class PackageAndImports {}

• Better display of local variable declarations (#​283)

public boolean localVariableDeclarationWhichBreak() {
  @​Nullable final BackupStatus lastStatus = BackupStatus.fromDbValue(backupRepository.getLastStatus());

  final BackupStatus lastStatus = BackupStatus.fromDbValue(backupRepository.getLastStatus());

  @​Nullable BackupStatus lastStatus = BackupStatus.fromDbValue(backupRepository.getLastStatus());

  BackupStatus lastStatus = BackupStatus.fromDbValue(backupRepository.getLastStatus());
}

public boolean localVariableDeclarationWhichDoNotBreak() {
  @​Nullable final BackupStatus lastStatus = value;

  final BackupStatus lastStatus = value;

  @​Nullable BackupStatus lastStatus = value;

  BackupStatus lastStatus = value;
}

is transformed in:

public boolean localVariableDeclarationWhichBreak() {
  @​Nullable
  final BackupStatus lastStatus = BackupStatus.fromDbValue(
    backupRepository.getLastStatus()
  );

  final BackupStatus lastStatus = BackupStatus.fromDbValue(
    backupRepository.getLastStatus()
  );

  @​Nullable
  BackupStatus lastStatus = BackupStatus.fromDbValue(
    backupRepository.getLastStatus()
  );

  BackupStatus lastStatus = BackupStatus.fromDbValue(
    backupRepository.getLastStatus()
  );
}

public boolean localVariableDeclarationWhichDoNotBreak() {
  @​Nullable
  final BackupStatus lastStatus = value;

  final BackupStatus lastStatus = value;

  @​Nullable
  BackupStatus lastStatus = value;

  BackupStatus lastStatus = value;
}

• Improve binary operations indentation (#​255):

Obj newObject = new Object().something().more().and().that().as().well().but().not().something();

Object.test.creation thisObject = classWithName.invocationOne().invocationTwo();

Object.test.creation thisObject1 = classWithName.invocationOne(argument1, argument2, argument3);

Object.test.creation thisObject2 = classWithName.invocationOne(argument1, argument2, argument3).invocationTwo();

Object.test.creation thisObject3 = classWithName.invocationOne().invocationTwo(argument1, argument2, argument3);

Object.test.creation thisObject4 = classWithName.invocationOne(argument1, argument2, argument3).invocationTwo(argument1, argument2);

Object.test.creation thisObject5 = classWithName.invocationOne(argument1WithAVeryVeryVeryVeryLongName, argument2, argument3).attributeOne.attributeTwo
    .invocationTwo(argument1, argument2).attributeThree.invocationThree();

Object.test.creation thisObject6 = classWithName.invocationOne(argument1, argument2,
    argument3).attributeOne.attributeTwo.invocationTwo(argument1, argument2).attributeThree.invocationThree();

is transformed in:

Obj newObject = new Object()
  .something()
  .more()
  .and()
  .that()
  .as()
  .well()
  .but()
  .not()
  .something();

Object.test.creation thisObject = classWithName
  .invocationOne()
  .invocationTwo();

Object.test.creation thisObject1 = classWithName.invocationOne(
  argument1,
  argument2,
  argument3
);

Object.test.creation thisObject2 = classWithName
  .invocationOne(argument1, argument2, argument3)
  .invocationTwo();

Object.test.creation thisObject3 = classWithName
  .invocationOne()
  .invocationTwo(argument1, argument2, argument3);

Object.test.creation thisObject4 = classWithName
  .invocationOne(argument1, argument2, argument3)
  .invocationTwo(argument1, argument2);

Object.test.creation thisObject5 = classWithName
  .invocationOne(
    argument1WithAVeryVeryVeryVeryLongName,
    argument2,
    argument3
  )
  .attributeOne.attributeTwo.invocationTwo(argument1, argument2)
  .attributeThree.invocationThree();

Object.test.creation thisObject6 = classWithName
  .invocationOne(argument1, argument2, argument3)
  .attributeOne.attributeTwo.invocationTwo(argument1, argument2)
  .attributeThree.invocationThree();

• Improve return statement rendering (#​255)

Object returnSomethingWhichDoNotBreak() {
  return oneVariable + secondVariable;
}

Object returnSomethingWhichBreak() {
  return oneVariable + secondVariable + thirdVariable + fourthVariable + fifthVariable + sixthVariable + seventhVariable;
}

Object returnSomethingWhichBreakAndAlreadyInParenthesis() {
  return (
      oneVariable +
          secondVariable +
          thirdVariable +
          fourthVariable +
          fifthVariable +
          sixthVariable +
          seventhVariable
  );
}

is transformed in:

Object returnSomethingWhichDoNotBreak() {
  return oneVariable + secondVariable;
}

Object returnSomethingWhichBreak() {
  return (
    oneVariable +
    secondVariable +
    thirdVariable +
    fourthVariable +
    fifthVariable +
    sixthVariable +
    seventhVariable
  );
}

Object returnSomethingWhichBreakAndAlreadyInParenthesis() {
  return (
    oneVariable +
    secondVariable +
    thirdVariable +
    fourthVariable +
    fifthVariable +
    sixthVariable +
    seventhVariable
  );
}

Fixed

• Add missing lodash dependency (#​265)
• Fix blocks comments formatting (#​280)

---

Configuration

📅 Schedule: At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, click this checkbox.

---

This PR has been generated by WhiteSource Renovate. View repository job log here.

[stale]

Is this still relevant? If so, what is blocking it? Is there anything you can do to help move it forward?

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs.

[renovate]

Renovate Ignore Notification

Because you closed this PR without merging, Renovate will ignore this update. You will not get PRs for any future 2.x releases. But if you manually upgrade to 2.x then Renovate will re-enable minor and patch updates automatically.

If you accidentally closed this PR, or if you changed your mind: rename this PR to get a fresh replacement PR.