/** Reads an enumerated type declaration and returns it. */ private EnumElement readEnumElement(Location location, String documentation) { String name = reader.readName(); EnumElement.Builder builder = EnumElement.builder(location) .name(name) .documentation(documentation); ImmutableList.Builder<EnumConstantElement> constants = ImmutableList.builder(); ImmutableList.Builder<OptionElement> options = ImmutableList.builder(); reader.require('{'); while (true) { String valueDocumentation = reader.readDocumentation(); if (reader.peekChar('}')) break; Object declared = readDeclaration(valueDocumentation, Context.ENUM); if (declared instanceof EnumConstantElement) { constants.add((EnumConstantElement) declared); } else if (declared instanceof OptionElement) { options.add((OptionElement) declared); } } return builder.options(options.build()) .constants(constants.build()) .build(); }
static EnumType fromElement(ProtoType protoType, EnumElement enumElement) { ImmutableList<EnumConstant> constants = EnumConstant.fromElements(enumElement.constants()); Options options = new Options(Options.ENUM_OPTIONS, enumElement.options()); return new EnumType(protoType, enumElement.location(), enumElement.documentation(), enumElement.name(), constants, options); }
@Test public void addMultipleOptions() { OptionElement kitKat = OptionElement.create("kit", STRING, "kat"); OptionElement fooBar = OptionElement.create("foo", STRING, "bar"); EnumElement element = EnumElement.builder(location) .name("Enum") .options(ImmutableList.of(kitKat, fooBar)) .constants(ImmutableList.of( EnumConstantElement.builder(location).name("ONE").tag(1).build())) .build(); assertThat(element.options()).hasSize(2); }
@Test public void addMultipleConstants() { EnumConstantElement one = EnumConstantElement.builder(location).name("ONE").tag(1).build(); EnumConstantElement two = EnumConstantElement.builder(location).name("TWO").tag(2).build(); EnumConstantElement six = EnumConstantElement.builder(location).name("SIX").tag(6).build(); EnumElement element = EnumElement.builder(location) .name("Enum") .constants(ImmutableList.of(one, two, six)) .build(); assertThat(element.constants()).hasSize(3); }
@Test public void trailingSinglelineComment() { String proto = "" + "enum Test {\n" + " FOO = 1; /* Test all the things! */ \n" + " BAR = 2;/*Test all the things!*/\n" + "}"; ProtoFileElement parsed = ProtoParser.parse(location, proto); EnumElement enumElement = (EnumElement) parsed.types().get(0); EnumConstantElement foo = enumElement.constants().get(0); assertThat(foo.documentation()).isEqualTo("Test all the things!"); EnumConstantElement bar = enumElement.constants().get(1); assertThat(bar.documentation()).isEqualTo("Test all the things!"); }
@Test public void trailingMultilineComment() { String proto = "" + "enum Test {\n" + " FOO = 1; /* Test all the\n" + "things! */ \n" + "}"; ProtoFileElement parsed = ProtoParser.parse(location, proto); EnumElement enumElement = (EnumElement) parsed.types().get(0); EnumConstantElement value = enumElement.constants().get(0); assertThat(value.documentation()).isEqualTo("Test all the\nthings!"); }
@Override public final String toSchema() { StringBuilder builder = new StringBuilder(); appendDocumentation(builder, documentation()); builder.append("enum ") .append(name()) .append(" {"); if (!options().isEmpty()) { builder.append('\n'); for (OptionElement option : options()) { appendIndented(builder, option.toSchemaDeclaration()); } } if (!constants().isEmpty()) { builder.append('\n'); for (EnumConstantElement constant : constants()) { appendIndented(builder, constant.toSchema()); } } return builder.append("}\n").toString(); }
EnumElement toElement() { return EnumElement.builder(location) .name(name) .documentation(documentation) .constants(EnumConstant.toElements(constants)) .options(options.toElements()) .build(); } }
@Test public void simpleToSchema() { EnumElement element = EnumElement.builder(location) .name("Enum") .constants(ImmutableList.of( EnumConstantElement.builder(location).name("ONE").tag(1).build(), EnumConstantElement.builder(location).name("TWO").tag(2).build(), EnumConstantElement.builder(location).name("SIX").tag(6).build())) .build(); String expected = "" + "enum Enum {\n" + " ONE = 1;\n" + " TWO = 2;\n" + " SIX = 6;\n" + "}\n"; assertThat(element.toSchema()).isEqualTo(expected); }
@Test public void trailingCommentNotCombinedWhenEmpty() { String proto = "" + "enum Test {\n" + " // Test all...\n" + " FOO = 1; // \n" + "}"; ProtoFileElement parsed = ProtoParser.parse(location, proto); EnumElement enumElement = (EnumElement) parsed.types().get(0); EnumConstantElement value = enumElement.constants().get(0); assertThat(value.documentation()).isEqualTo("Test all..."); }
Builder(EnumElement source) { this.location = source.location(); this.name = source.name(); this.documentation = source.documentation(); this.options = source.options(); this.constants = source.constants(); } @Override
+ " extensions 1000 to max;\n" + "}\n"; TypeElement enumElement = EnumElement.builder(location.at(3, 3)) .name("CType") .constants(ImmutableList.of(EnumConstantElement.builder(location.at(4, 5))
@Test public void simpleWithOptionsToSchema() { EnumElement element = EnumElement.builder(location) .name("Enum").options(ImmutableList.of(OptionElement.create("kit", STRING, "kat"))) .constants(ImmutableList.of( EnumConstantElement.builder(location).name("ONE").tag(1).build(), EnumConstantElement.builder(location).name("TWO").tag(2).build(), EnumConstantElement.builder(location).name("SIX").tag(6).build())) .build(); String expected = "" + "enum Enum {\n" + " option kit = \"kat\";\n" + "\n" + " ONE = 1;\n" + " TWO = 2;\n" + " SIX = 6;\n" + "}\n"; assertThat(element.toSchema()).isEqualTo(expected); }
@Test public void enumValueTrailingComment() { String proto = "" + "enum Test {\n" + " FOO = 1; // Test all the things! \n" + "}"; ProtoFileElement parsed = ProtoParser.parse(location, proto); EnumElement enumElement = (EnumElement) parsed.types().get(0); EnumConstantElement value = enumElement.constants().get(0); assertThat(value.documentation()).isEqualTo("Test all the things!"); }
@Override public boolean equals(Object o) { if (o == this) { return true; } if (o instanceof EnumElement) { EnumElement that = (EnumElement) o; return (this.location.equals(that.location())) && (this.name.equals(that.name())) && (this.documentation.equals(that.documentation())) && (this.options.equals(that.options())) && (this.constants.equals(that.constants())); } return false; }
ProtoFileElement expected = ProtoFileElement.builder(location) .types(ImmutableList.<TypeElement>of( EnumElement.builder(location.at(5, 1)) .name("Topping") .documentation("What's on my waffles.\nAlso works on pancakes.")
@Test public void simpleWithDocumentationToSchema() { EnumElement element = EnumElement.builder(location) .name("Enum") .documentation("Hello") .constants(ImmutableList.of( EnumConstantElement.builder(location).name("ONE").tag(1).build(), EnumConstantElement.builder(location).name("TWO").tag(2).build(), EnumConstantElement.builder(location).name("SIX").tag(6).build())) .build(); String expected = "" + "// Hello\n" + "enum Enum {\n" + " ONE = 1;\n" + " TWO = 2;\n" + " SIX = 6;\n" + "}\n"; assertThat(element.toSchema()).isEqualTo(expected); }
@Test public void enumValueLeadingAndTrailingCommentsAreCombined() { String proto = "" + "enum Test {\n" + " // Test all...\n" + " FOO = 1; // ...the things!\n" + "}"; ProtoFileElement parsed = ProtoParser.parse(location, proto); EnumElement enumElement = (EnumElement) parsed.types().get(0); EnumConstantElement value = enumElement.constants().get(0); assertThat(value.documentation()).isEqualTo("Test all...\n...the things!"); }
static EnumType fromElement(ProtoType protoType, EnumElement enumElement) { ImmutableList<EnumConstant> constants = EnumConstant.fromElements(enumElement.constants()); Options options = new Options(Options.ENUM_OPTIONS, enumElement.options()); return new EnumType(protoType, enumElement.location(), enumElement.documentation(), enumElement.name(), constants, options); }