loafle/openapi-generator-original
3
0
Fork 1
mirror of https://github.com/OpenAPITools/openapi-generator.git synced 2025-05-12 04:30:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added ANTLR. Fix Issue #20960 (#21230)

Browse Source 
* Added ANTLR. Started work on issue 20960

* Ran generation scripts

* Excluded ANTLR generated files from JavaDoc generation

* Whitespace fix
This commit is contained in:
DavidGrath 2025-05-11 15:31:54 +01:00 committed by GitHub
parent 6344bfa779
commit 2fd1ee66cc
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
16 changed files with 3374 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
modules/openapi-generator/pom.xml
View File

@ -145,6 +145,43 @@
<artifactId>maven-release-plugin</artifactId>
<version>${maven-release-plugin.version}</version>
</plugin>
<plugin>
<groupId>org.antlr</groupId>
<artifactId>antlr4-maven-plugin</artifactId>
<version>4.13.2</version>
<executions>
<execution>
<phase>generate-test-sources</phase>
<goals>
<goal>antlr4</goal>
</goals>
</execution>
</executions>
<configuration>
<sourceDirectory>${basedir}/src/test/antlr4</sourceDirectory>
<libDirectory>${basedir}/src/test/antlr4/imports</libDirectory>
<outputDirectory>${project.build.directory}/generated-test-sources/antlr4</outputDirectory>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<version>3.6.0</version>
<executions>
<execution>
<id>add-test-source</id>
<phase>generate-test-sources</phase>
<goals>
<goal>add-test-source</goal>
</goals>
<configuration>
<sources>
<source>${project.build.directory}/generated-test-sources/antlr4</source>
</sources>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<profiles>
@ -464,6 +501,12 @@
<artifactId>snakeyaml</artifactId>
<version>${snakeyaml.version}</version>
</dependency>
<dependency>
<groupId>org.antlr</groupId>
<artifactId>antlr4-runtime</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
<repositories>
<repository>

74
modules/openapi-generator/src/main/resources/kotlin-client/data_class.mustache vendored
View File

@ -202,14 +202,14 @@ import {{packageName}}.infrastructure.ITransformForStorage
{{#-first}}
// a set of all properties/fields (JSON key names)
{{/-first}}
openapiFields.add("{{baseName}}")
openapiFields.add("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}")
{{/allVars}}
{{#requiredVars}}
{{#-first}}
// a set of required properties/fields (JSON key names)
{{/-first}}
openapiRequiredFields.add("{{baseName}}")
openapiRequiredFields.add("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}")
{{/requiredVars}}
}
@ -248,26 +248,26 @@ import {{packageName}}.infrastructure.ITransformForStorage
{{#items.isModel}}
{{#required}}
// ensure the json data is an array
if (!jsonObj.get("{{{baseName}}}").isJsonArray) {
throw IllegalArgumentException(String.format("Expected the field `{{{baseName}}}` to be an array in the JSON string but got `%s`", jsonObj["{{{baseName}}}"].toString()))
if (!jsonObj.get("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}").isJsonArray) {
throw IllegalArgumentException(String.format("Expected the field `{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}` to be an array in the JSON string but got `%s`", jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].toString()))
}
// validate the required field `{{{baseName}}}` (array)
for (i in 0 until jsonObj.getAsJsonArray("{{{baseName}}}").size()) {
{{{items.dataType}}}.validateJsonElement(jsonObj.getAsJsonArray("{{{baseName}}}").get(i))
for (i in 0 until jsonObj.getAsJsonArray("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}").size()) {
{{{items.dataType}}}.validateJsonElement(jsonObj.getAsJsonArray("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}").get(i))
}
{{/required}}
{{^required}}
if (jsonObj["{{{baseName}}}"] != null && !jsonObj["{{{baseName}}}"].isJsonNull) {
if (jsonObj.getAsJsonArray("{{{baseName}}}") != null) {
if (jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"] != null && !jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].isJsonNull) {
if (jsonObj.getAsJsonArray("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}") != null) {
// ensure the json data is an array
require(jsonObj["{{{baseName}}}"].isJsonArray) {
String.format("Expected the field `{{{baseName}}}` to be an array in the JSON string but got `%s`", jsonObj["{{{baseName}}}"].toString())
require(jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].isJsonArray) {
String.format("Expected the field `{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}` to be an array in the JSON string but got `%s`", jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].toString())
}
// validate the optional field `{{{baseName}}}` (array)
for (i in 0 until jsonObj.getAsJsonArray("{{{baseName}}}").size()) {
{{{items.dataType}}}.validateJsonElement(jsonObj.getAsJsonArray("{{{baseName}}}").get(i))
for (i in 0 until jsonObj.getAsJsonArray("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}").size()) {
{{{items.dataType}}}.validateJsonElement(jsonObj.getAsJsonArray("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}").get(i))
}
}
}
@ -276,19 +276,19 @@ import {{packageName}}.infrastructure.ITransformForStorage
{{^items.isModel}}
{{^required}}
// ensure the optional json data is an array if present
if (jsonObj["{{{baseName}}}"] != null && !jsonObj["{{{baseName}}}"].isJsonNull) {
require(jsonObj["{{{baseName}}}"].isJsonArray()) {
String.format("Expected the field `{{{baseName}}}` to be an array in the JSON string but got `%s`", jsonObj["{{{baseName}}}"].toString())
if (jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"] != null && !jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].isJsonNull) {
require(jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].isJsonArray()) {
String.format("Expected the field `{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}` to be an array in the JSON string but got `%s`", jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].toString())
}
}
{{/required}}
{{#required}}
// ensure the required json array is present
requireNotNull(jsonObj["{{{baseName}}}"]) {
"Expected the field `{{{baseName}}}` to be an array in the JSON string but got `null`"
requireNotNull(jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"]) {
"Expected the field `{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}` to be an array in the JSON string but got `null`"
}
require(jsonObj["{{{baseName}}}"].isJsonArray()) {
String.format("Expected the field `{{{baseName}}}` to be an array in the JSON string but got `%s`", jsonObj["{{{baseName}}}"].toString())
require(jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].isJsonArray()) {
String.format("Expected the field `{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}` to be an array in the JSON string but got `%s`", jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].toString())
}
{{/required}}
{{/items.isModel}}
@ -296,42 +296,42 @@ import {{packageName}}.infrastructure.ITransformForStorage
{{^isContainer}}
{{#isString}}
{{#notRequiredOrIsNullable}}
if (jsonObj["{{{baseName}}}"] != null && !jsonObj["{{{baseName}}}"].isJsonNull) {
require(jsonObj.get("{{{baseName}}}").isJsonPrimitive) {
String.format("Expected the field `{{{baseName}}}` to be a primitive type in the JSON string but got `%s`", jsonObj["{{{baseName}}}"].toString())
if (jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"] != null && !jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].isJsonNull) {
require(jsonObj.get("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}").isJsonPrimitive) {
String.format("Expected the field `{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}` to be a primitive type in the JSON string but got `%s`", jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].toString())
}
}
{{/notRequiredOrIsNullable}}
{{^notRequiredOrIsNullable}}
require(jsonObj["{{{baseName}}}"].isJsonPrimitive) {
String.format("Expected the field `{{{baseName}}}` to be a primitive type in the JSON string but got `%s`", jsonObj["{{{baseName}}}"].toString())
require(jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].isJsonPrimitive) {
String.format("Expected the field `{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}` to be a primitive type in the JSON string but got `%s`", jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].toString())
}
{{/notRequiredOrIsNullable}}
{{/isString}}
{{#isModel}}
{{#required}}
// validate the required field `{{{baseName}}}`
{{{dataType}}}.validateJsonElement(jsonObj["{{{baseName}}}"])
{{{dataType}}}.validateJsonElement(jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"])
{{/required}}
{{^required}}
// validate the optional field `{{{baseName}}}`
if (jsonObj["{{{baseName}}}"] != null && !jsonObj["{{{baseName}}}"].isJsonNull) {
{{{dataType}}}.validateJsonElement(jsonObj["{{{baseName}}}"])
if (jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"] != null && !jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].isJsonNull) {
{{{dataType}}}.validateJsonElement(jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"])
}
{{/required}}
{{/isModel}}
{{#isEnum}}
{{#required}}
// validate the required field `{{{baseName}}}`
require({{{datatypeWithEnum}}}.values().any { it.value == jsonObj["{{{baseName}}}"].asString }) {
String.format("Expected the field `{{{baseName}}}` to be valid `{{{datatypeWithEnum}}}` enum value in the JSON string but got `%s`", jsonObj["{{{baseName}}}"].toString())
require({{{datatypeWithEnum}}}.values().any { it.value == jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].asString }) {
String.format("Expected the field `{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}` to be valid `{{{datatypeWithEnum}}}` enum value in the JSON string but got `%s`", jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].toString())
}
{{/required}}
{{^required}}
// validate the optional field `{{{baseName}}}`
if (jsonObj["{{{baseName}}}"] != null && !jsonObj["{{{baseName}}}"].isJsonNull) {
require({{{datatypeWithEnum}}}.values().any { it.value == jsonObj["{{{baseName}}}"].asString }) {
String.format("Expected the field `{{{baseName}}}` to be valid `{{{datatypeWithEnum}}}` enum value in the JSON string but got `%s`", jsonObj["{{{baseName}}}"].toString())
if (jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"] != null && !jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].isJsonNull) {
require({{{datatypeWithEnum}}}.values().any { it.value == jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].asString }) {
String.format("Expected the field `{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}` to be valid `{{{datatypeWithEnum}}}` enum value in the JSON string but got `%s`", jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].toString())
}
}
{{/required}}
@ -339,15 +339,15 @@ import {{packageName}}.infrastructure.ITransformForStorage
{{#isEnumRef}}
{{#required}}
// validate the required field `{{{baseName}}}`
require({{{dataType}}}.values().any { it.value == jsonObj["{{{baseName}}}"].asString }) {
String.format("Expected the field `{{{baseName}}}` to be valid `{{{dataType}}}` enum value in the JSON string but got `%s`", jsonObj["{{{baseName}}}"].toString())
require({{{dataType}}}.values().any { it.value == jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].asString }) {
String.format("Expected the field `{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}` to be valid `{{{dataType}}}` enum value in the JSON string but got `%s`", jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].toString())
}
{{/required}}
{{^required}}
// validate the optional field `{{{baseName}}}`
if (jsonObj["{{{baseName}}}"] != null && !jsonObj["{{{baseName}}}"].isJsonNull) {
require({{{dataType}}}.values().any { it.value == jsonObj["{{{baseName}}}"].asString }) {
String.format("Expected the field `{{{baseName}}}` to be valid `{{{dataType}}}` enum value in the JSON string but got `%s`", jsonObj["{{{baseName}}}"].toString())
if (jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"] != null && !jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].isJsonNull) {
require({{{dataType}}}.values().any { it.value == jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].asString }) {
String.format("Expected the field `{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}` to be valid `{{{dataType}}}` enum value in the JSON string but got `%s`", jsonObj["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"].toString())
}
}
{{/required}}

2
modules/openapi-generator/src/main/resources/kotlin-server/libraries/javalin5/data_class_opt_var.mustache vendored
View File

@ -2,5 +2,5 @@
/* {{{.}}} */
{{/description}}
{{#useBeanValidation}}{{>beanValidation}}{{>beanValidationModel}}{{/useBeanValidation}}
@field:com.fasterxml.jackson.annotation.JsonProperty("{{{baseName}}}")
@field:com.fasterxml.jackson.annotation.JsonProperty("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}")
{{>modelMutable}} {{{name}}}: {{#isEnum}}{{{classname}}}.{{{nameInPascalCase}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}? = {{{defaultValue}}}{{^defaultValue}}null{{/defaultValue}}

2
modules/openapi-generator/src/main/resources/kotlin-server/libraries/javalin5/data_class_req_var.mustache vendored
View File

@ -2,5 +2,5 @@
/* {{{.}}} */
{{/description}}
{{#useBeanValidation}}{{>beanValidation}}{{>beanValidationModel}}{{/useBeanValidation}}
@field:com.fasterxml.jackson.annotation.JsonProperty("{{{baseName}}}")
@field:com.fasterxml.jackson.annotation.JsonProperty("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}")
{{>modelMutable}} {{{name}}}: {{#isEnum}}{{{classname}}}.{{{nameInPascalCase}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}{{#isNullable}}?{{/isNullable}}{{#defaultValue}} = {{^isNumber}}{{{defaultValue}}}{{/isNumber}}{{#isNumber}}{{{dataType}}}("{{{defaultValue}}}"){{/isNumber}}{{/defaultValue}}

2
modules/openapi-generator/src/main/resources/kotlin-server/libraries/javalin6/data_class_opt_var.mustache vendored
View File

@ -2,5 +2,5 @@
/* {{{.}}} */
{{/description}}
{{#useBeanValidation}}{{>beanValidation}}{{>beanValidationModel}}{{/useBeanValidation}}
@field:com.fasterxml.jackson.annotation.JsonProperty("{{{baseName}}}")
@field:com.fasterxml.jackson.annotation.JsonProperty("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}")
{{>modelMutable}} {{{name}}}: {{#isEnum}}{{{classname}}}.{{{nameInPascalCase}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}? = {{{defaultValue}}}{{^defaultValue}}null{{/defaultValue}}

2
modules/openapi-generator/src/main/resources/kotlin-server/libraries/javalin6/data_class_req_var.mustache vendored
View File

@ -2,5 +2,5 @@
/* {{{.}}} */
{{/description}}
{{#useBeanValidation}}{{>beanValidation}}{{>beanValidationModel}}{{/useBeanValidation}}
@field:com.fasterxml.jackson.annotation.JsonProperty("{{{baseName}}}")
@field:com.fasterxml.jackson.annotation.JsonProperty("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}")
{{>modelMutable}} {{{name}}}: {{#isEnum}}{{{classname}}}.{{{nameInPascalCase}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}{{#isNullable}}?{{/isNullable}}{{#defaultValue}} = {{^isNumber}}{{{defaultValue}}}{{/isNumber}}{{#isNumber}}{{{dataType}}}("{{{defaultValue}}}"){{/isNumber}}{{/defaultValue}}

2
modules/openapi-generator/src/main/resources/kotlin-server/libraries/jaxrs-spec/data_class_opt_var.mustache vendored
View File

@ -2,5 +2,5 @@
/* {{{.}}} */
{{/description}}
@JsonProperty("{{{baseName}}}")
@JsonProperty("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}")
{{#useBeanValidation}}{{>beanValidation}}{{>beanValidationModel}}{{/useBeanValidation}} {{>modelMutable}} {{{name}}}: {{#isEnum}}{{classname}}.{{nameInPascalCase}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}? = {{{defaultValue}}}{{^defaultValue}}null{{/defaultValue}}

2
modules/openapi-generator/src/main/resources/kotlin-server/libraries/jaxrs-spec/data_class_req_var.mustache vendored
View File

@ -2,5 +2,5 @@
/* {{{.}}} */
{{/description}}
@JsonProperty("{{{baseName}}}")
@JsonProperty("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}")
{{#useBeanValidation}}{{>beanValidation}}{{>beanValidationModel}}{{/useBeanValidation}} {{>modelMutable}} {{{name}}}: {{#isEnum}}{{classname}}.{{nameInPascalCase}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}

1658
modules/openapi-generator/src/test/antlr4/imports/UnicodeClasses.g4 Normal file
View File

File diff suppressed because it is too large Load Diff

514
modules/openapi-generator/src/test/antlr4/org/openapitools/codegen/antlr4/KotlinLexer.g4 Normal file
View File

@ -0,0 +1,514 @@
/**
* Kotlin Grammar for ANTLR v4
*
* Based on:
* http://jetbrains.github.io/kotlin-spec/#_grammars_and_parsing
* and
* http://kotlinlang.org/docs/reference/grammar.html
*
* Tested on
* https://github.com/JetBrains/kotlin/tree/master/compiler/testData/psi
*/
// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false
// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine
// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true
lexer grammar KotlinLexer;
import UnicodeClasses;
ShebangLine: '#!' ~[\u000A\u000D]* -> channel(HIDDEN);
DelimitedComment: '/*' ( DelimitedComment | .)*? '*/' -> channel(HIDDEN);
LineComment: '//' ~[\u000A\u000D]* -> channel(HIDDEN);
WS: [\u0020\u0009\u000C] -> skip;
NL: '\u000A' | '\u000D' '\u000A';
//SEPARATORS & OPERATIONS
RESERVED : '...';
DOT : '.';
COMMA : ',';
LPAREN : '(' -> pushMode(Inside);
RPAREN : ')';
LSQUARE : '[' -> pushMode(Inside);
RSQUARE : ']';
LCURL : '{';
RCURL : '}';
MULT : '*';
MOD : '%';
DIV : '/';
ADD : '+';
SUB : '-';
INCR : '++';
DECR : '--';
CONJ : '&&';
DISJ : '||';
EXCL : '!';
COLON : ':';
SEMICOLON : ';';
ASSIGNMENT : '=';
ADD_ASSIGNMENT : '+=';
SUB_ASSIGNMENT : '-=';
MULT_ASSIGNMENT : '*=';
DIV_ASSIGNMENT : '/=';
MOD_ASSIGNMENT : '%=';
ARROW : '->';
DOUBLE_ARROW : '=>';
RANGE : '..';
COLONCOLON : '::';
Q_COLONCOLON : '?::';
DOUBLE_SEMICOLON : ';;';
HASH : '#';
AT : '@';
QUEST : '?';
ELVIS : '?:';
LANGLE : '<';
RANGLE : '>';
LE : '<=';
GE : '>=';
EXCL_EQ : '!=';
EXCL_EQEQ : '!==';
AS_SAFE : 'as?';
EQEQ : '==';
EQEQEQ : '===';
SINGLE_QUOTE : '\'';
//KEYWORDS
RETURN_AT : 'return@' Identifier;
CONTINUE_AT : 'continue@' Identifier;
BREAK_AT : 'break@' Identifier;
FILE : '@file';
PACKAGE : 'package';
IMPORT : 'import';
CLASS : 'class';
INTERFACE : 'interface';
FUN : 'fun';
OBJECT : 'object';
VAL : 'val';
VAR : 'var';
TYPE_ALIAS : 'typealias';
CONSTRUCTOR : 'constructor';
BY : 'by';
COMPANION : 'companion';
INIT : 'init';
THIS : 'this';
SUPER : 'super';
TYPEOF : 'typeof';
WHERE : 'where';
IF : 'if';
ELSE : 'else';
WHEN : 'when';
TRY : 'try';
CATCH : 'catch';
FINALLY : 'finally';
FOR : 'for';
DO : 'do';
WHILE : 'while';
THROW : 'throw';
RETURN : 'return';
CONTINUE : 'continue';
BREAK : 'break';
AS : 'as';
IS : 'is';
IN : 'in';
NOT_IS : '!is' (WS | NL)+;
NOT_IN : '!in' (WS | NL)+;
OUT : 'out';
FIELD : '@field';
PROPERTY : '@property';
GET : '@get';
SET : '@set';
GETTER : 'get';
SETTER : 'set';
RECEIVER : '@receiver';
PARAM : '@param';
SETPARAM : '@setparam';
DELEGATE : '@delegate';
DYNAMIC : 'dynamic';
//MODIFIERS
PUBLIC : 'public';
PRIVATE : 'private';
PROTECTED : 'protected';
INTERNAL : 'internal';
ENUM : 'enum';
SEALED : 'sealed';
ANNOTATION : 'annotation';
DATA : 'data';
INNER : 'inner';
TAILREC : 'tailrec';
OPERATOR : 'operator';
INLINE : 'inline';
INFIX : 'infix';
EXTERNAL : 'external';
SUSPEND : 'suspend';
OVERRIDE : 'override';
ABSTRACT : 'abstract';
FINAL : 'final';
OPEN : 'open';
CONST : 'const';
LATEINIT : 'lateinit';
VARARG : 'vararg';
NOINLINE : 'noinline';
CROSSINLINE : 'crossinline';
REIFIED : 'reified';
//
QUOTE_OPEN : '"' -> pushMode(LineString);
TRIPLE_QUOTE_OPEN : '"""' -> pushMode(MultiLineString);
RealLiteral: FloatLiteral | DoubleLiteral;
FloatLiteral: (DoubleLiteral | IntegerLiteral) [fF];
DoubleLiteral:
((DecDigitNoZero DecDigit* | '0')? '.' | (DecDigitNoZero (DecDigit | '_')* DecDigit)? '.') (
DecDigit+
| DecDigit (DecDigit | '_')+ DecDigit
| DecDigit+ [eE] ('+' | '-')? DecDigit+
| DecDigit+ [eE] ('+' | '-')? DecDigit (DecDigit | '_')+ DecDigit
| DecDigit (DecDigit | '_')+ DecDigit [eE] ('+' | '-')? DecDigit+
| DecDigit (DecDigit | '_')+ DecDigit [eE] ('+' | '-')? DecDigit (DecDigit | '_')+ DecDigit
)
;
LongLiteral: (IntegerLiteral | HexLiteral | BinLiteral) 'L';
IntegerLiteral:
(
'0'
| DecDigitNoZero DecDigit*
| DecDigitNoZero (DecDigit | '_')+ DecDigit
| DecDigitNoZero DecDigit* [eE] ('+' | '-')? DecDigit+
| DecDigitNoZero DecDigit* [eE] ('+' | '-')? DecDigit (DecDigit | '_')+ DecDigit
| DecDigitNoZero (DecDigit | '_')+ DecDigit [eE] ('+' | '-')? DecDigit+
| DecDigitNoZero (DecDigit | '_')+ DecDigit [eE] ('+' | '-')? DecDigit (DecDigit | '_')+ DecDigit
)
;
fragment DecDigit: UNICODE_CLASS_ND;
fragment DecDigitNoZero: UNICODE_CLASS_ND_NoZeros;
fragment UNICODE_CLASS_ND_NoZeros:
'\u0031' ..'\u0039'
| '\u0661' ..'\u0669'
| '\u06f1' ..'\u06f9'
| '\u07c1' ..'\u07c9'
| '\u0967' ..'\u096f'
| '\u09e7' ..'\u09ef'
| '\u0a67' ..'\u0a6f'
| '\u0ae7' ..'\u0aef'
| '\u0b67' ..'\u0b6f'
| '\u0be7' ..'\u0bef'
| '\u0c67' ..'\u0c6f'
| '\u0ce7' ..'\u0cef'
| '\u0d67' ..'\u0d6f'
| '\u0de7' ..'\u0def'
| '\u0e51' ..'\u0e59'
| '\u0ed1' ..'\u0ed9'
| '\u0f21' ..'\u0f29'
| '\u1041' ..'\u1049'
| '\u1091' ..'\u1099'
| '\u17e1' ..'\u17e9'
| '\u1811' ..'\u1819'
| '\u1947' ..'\u194f'
| '\u19d1' ..'\u19d9'
| '\u1a81' ..'\u1a89'
| '\u1a91' ..'\u1a99'
| '\u1b51' ..'\u1b59'
| '\u1bb1' ..'\u1bb9'
| '\u1c41' ..'\u1c49'
| '\u1c51' ..'\u1c59'
| '\ua621' ..'\ua629'
| '\ua8d1' ..'\ua8d9'
| '\ua901' ..'\ua909'
| '\ua9d1' ..'\ua9d9'
| '\ua9f1' ..'\ua9f9'
| '\uaa51' ..'\uaa59'
| '\uabf1' ..'\uabf9'
| '\uff11' ..'\uff19'
;
HexLiteral: '0' [xX] HexDigit (HexDigit | '_')*;
fragment HexDigit: [0-9a-fA-F];
BinLiteral: '0' [bB] BinDigit (BinDigit | '_')*;
fragment BinDigit: [01];
BooleanLiteral: 'true' | 'false';
NullLiteral: 'null';
Identifier: (Letter | '_') (Letter | '_' | DecDigit)* | '`' ~('`')+ '`';
LabelReference: '@' Identifier;
LabelDefinition: Identifier '@';
FieldIdentifier: '$' Identifier;
CharacterLiteral: '\'' (EscapeSeq | .) '\'';
fragment EscapeSeq: UniCharacterLiteral | EscapedIdentifier;
fragment UniCharacterLiteral: '\\' 'u' HexDigit HexDigit HexDigit HexDigit;
fragment EscapedIdentifier: '\\' ('t' | 'b' | 'r' | 'n' | '\'' | '"' | '\\' | '$');
fragment Letter:
UNICODE_CLASS_LL
| UNICODE_CLASS_LM
| UNICODE_CLASS_LO
| UNICODE_CLASS_LT
| UNICODE_CLASS_LU
| UNICODE_CLASS_NL
;
mode Inside;
Inside_RPAREN : ')' -> popMode, type(RPAREN);
Inside_RSQUARE : ']' -> popMode, type(RSQUARE);
Inside_LPAREN : LPAREN -> pushMode(Inside), type(LPAREN);
Inside_LSQUARE : LSQUARE -> pushMode(Inside), type(LSQUARE);
Inside_LCURL : LCURL -> type(LCURL);
Inside_RCURL : RCURL -> type(RCURL);
Inside_DOT : DOT -> type(DOT);
Inside_COMMA : COMMA -> type(COMMA);
Inside_MULT : MULT -> type(MULT);
Inside_MOD : MOD -> type(MOD);
Inside_DIV : DIV -> type(DIV);
Inside_ADD : ADD -> type(ADD);
Inside_SUB : SUB -> type(SUB);
Inside_INCR : INCR -> type(INCR);
Inside_DECR : DECR -> type(DECR);
Inside_CONJ : CONJ -> type(CONJ);
Inside_DISJ : DISJ -> type(DISJ);
Inside_EXCL : EXCL -> type(EXCL);
Inside_COLON : COLON -> type(COLON);
Inside_SEMICOLON : SEMICOLON -> type(SEMICOLON);
Inside_ASSIGNMENT : ASSIGNMENT -> type(ASSIGNMENT);
Inside_ADD_ASSIGNMENT : ADD_ASSIGNMENT -> type(ADD_ASSIGNMENT);
Inside_SUB_ASSIGNMENT : SUB_ASSIGNMENT -> type(SUB_ASSIGNMENT);
Inside_MULT_ASSIGNMENT : MULT_ASSIGNMENT -> type(MULT_ASSIGNMENT);
Inside_DIV_ASSIGNMENT : DIV_ASSIGNMENT -> type(DIV_ASSIGNMENT);
Inside_MOD_ASSIGNMENT : MOD_ASSIGNMENT -> type(MOD_ASSIGNMENT);
Inside_ARROW : ARROW -> type(ARROW);
Inside_DOUBLE_ARROW : DOUBLE_ARROW -> type(DOUBLE_ARROW);
Inside_RANGE : RANGE -> type(RANGE);
Inside_RESERVED : RESERVED -> type(RESERVED);
Inside_COLONCOLON : COLONCOLON -> type(COLONCOLON);
Inside_Q_COLONCOLON : Q_COLONCOLON -> type(Q_COLONCOLON);
Inside_DOUBLE_SEMICOLON : DOUBLE_SEMICOLON -> type(DOUBLE_SEMICOLON);
Inside_HASH : HASH -> type(HASH);
Inside_AT : AT -> type(AT);
Inside_QUEST : QUEST -> type(QUEST);
Inside_ELVIS : ELVIS -> type(ELVIS);
Inside_LANGLE : LANGLE -> type(LANGLE);
Inside_RANGLE : RANGLE -> type(RANGLE);
Inside_LE : LE -> type(LE);
Inside_GE : GE -> type(GE);
Inside_EXCL_EQ : EXCL_EQ -> type(EXCL_EQ);
Inside_EXCL_EQEQ : EXCL_EQEQ -> type(EXCL_EQEQ);
Inside_NOT_IS : NOT_IS -> type(NOT_IS);
Inside_NOT_IN : NOT_IN -> type(NOT_IN);
Inside_AS_SAFE : AS_SAFE -> type(AS_SAFE);
Inside_EQEQ : EQEQ -> type(EQEQ);
Inside_EQEQEQ : EQEQEQ -> type(EQEQEQ);
Inside_SINGLE_QUOTE : SINGLE_QUOTE -> type(SINGLE_QUOTE);
Inside_QUOTE_OPEN : QUOTE_OPEN -> pushMode(LineString), type(QUOTE_OPEN);
Inside_TRIPLE_QUOTE_OPEN:
TRIPLE_QUOTE_OPEN -> pushMode(MultiLineString), type(TRIPLE_QUOTE_OPEN)
;
Inside_VAL : VAL -> type(VAL);
Inside_VAR : VAR -> type(VAR);
Inside_OBJECT : OBJECT -> type(OBJECT);
Inside_SUPER : SUPER -> type(SUPER);
Inside_IN : IN -> type(IN);
Inside_OUT : OUT -> type(OUT);
Inside_FIELD : FIELD -> type(FIELD);
Inside_FILE : FILE -> type(FILE);
Inside_PROPERTY : PROPERTY -> type(PROPERTY);
Inside_GET : GET -> type(GET);
Inside_SET : SET -> type(SET);
Inside_RECEIVER : RECEIVER -> type(RECEIVER);
Inside_PARAM : PARAM -> type(PARAM);
Inside_SETPARAM : SETPARAM -> type(SETPARAM);
Inside_DELEGATE : DELEGATE -> type(DELEGATE);
Inside_THROW : THROW -> type(THROW);
Inside_RETURN : RETURN -> type(RETURN);
Inside_CONTINUE : CONTINUE -> type(CONTINUE);
Inside_BREAK : BREAK -> type(BREAK);
Inside_RETURN_AT : RETURN_AT -> type(RETURN_AT);
Inside_CONTINUE_AT : CONTINUE_AT -> type(CONTINUE_AT);
Inside_BREAK_AT : BREAK_AT -> type(BREAK_AT);
Inside_IF : IF -> type(IF);
Inside_ELSE : ELSE -> type(ELSE);
Inside_WHEN : WHEN -> type(WHEN);
Inside_TRY : TRY -> type(TRY);
Inside_CATCH : CATCH -> type(CATCH);
Inside_FINALLY : FINALLY -> type(FINALLY);
Inside_FOR : FOR -> type(FOR);
Inside_DO : DO -> type(DO);
Inside_WHILE : WHILE -> type(WHILE);
Inside_PUBLIC : PUBLIC -> type(PUBLIC);
Inside_PRIVATE : PRIVATE -> type(PRIVATE);
Inside_PROTECTED : PROTECTED -> type(PROTECTED);
Inside_INTERNAL : INTERNAL -> type(INTERNAL);
Inside_ENUM : ENUM -> type(ENUM);
Inside_SEALED : SEALED -> type(SEALED);
Inside_ANNOTATION : ANNOTATION -> type(ANNOTATION);
Inside_DATA : DATA -> type(DATA);
Inside_INNER : INNER -> type(INNER);
Inside_TAILREC : TAILREC -> type(TAILREC);
Inside_OPERATOR : OPERATOR -> type(OPERATOR);
Inside_INLINE : INLINE -> type(INLINE);
Inside_INFIX : INFIX -> type(INFIX);
Inside_EXTERNAL : EXTERNAL -> type(EXTERNAL);
Inside_SUSPEND : SUSPEND -> type(SUSPEND);
Inside_OVERRIDE : OVERRIDE -> type(OVERRIDE);
Inside_ABSTRACT : ABSTRACT -> type(ABSTRACT);
Inside_FINAL : FINAL -> type(FINAL);
Inside_OPEN : OPEN -> type(OPEN);
Inside_CONST : CONST -> type(CONST);
Inside_LATEINIT : LATEINIT -> type(LATEINIT);
Inside_VARARG : VARARG -> type(VARARG);
Inside_NOINLINE : NOINLINE -> type(NOINLINE);
Inside_CROSSINLINE : CROSSINLINE -> type(CROSSINLINE);
Inside_REIFIED : REIFIED -> type(REIFIED);
Inside_BooleanLiteral : BooleanLiteral -> type(BooleanLiteral);
Inside_IntegerLiteral : IntegerLiteral -> type(IntegerLiteral);
Inside_HexLiteral : HexLiteral -> type(HexLiteral);
Inside_BinLiteral : BinLiteral -> type(BinLiteral);
Inside_CharacterLiteral : CharacterLiteral -> type(CharacterLiteral);
Inside_RealLiteral : RealLiteral -> type(RealLiteral);
Inside_NullLiteral : NullLiteral -> type(NullLiteral);
Inside_LongLiteral: LongLiteral -> type(LongLiteral);
Inside_Identifier : Identifier -> type(Identifier);
Inside_LabelReference : LabelReference -> type(LabelReference);
Inside_LabelDefinition : LabelDefinition -> type(LabelDefinition);
Inside_Comment : (LineComment | DelimitedComment) -> channel(HIDDEN);
Inside_WS : WS -> skip;
Inside_NL : NL -> skip;
mode LineString;
QUOTE_CLOSE: '"' -> popMode;
LineStrRef: FieldIdentifier;
LineStrText: ~('\\' | '"' | '$')+ | '$';
LineStrEscapedChar: '\\' . | UniCharacterLiteral;
LineStrExprStart: '${' -> pushMode(StringExpression);
mode MultiLineString;
TRIPLE_QUOTE_CLOSE: MultiLineStringQuote? '"""' -> popMode;
MultiLineStringQuote: '"'+;
MultiLineStrRef: FieldIdentifier;
MultiLineStrText: ~('\\' | '"' | '$')+ | '$';
MultiLineStrEscapedChar: '\\' .;
MultiLineStrExprStart: '${' -> pushMode(StringExpression);
MultiLineNL: NL -> skip;
mode StringExpression;
StrExpr_RCURL: RCURL -> popMode, type(RCURL);
StrExpr_LPAREN : LPAREN -> pushMode(Inside), type(LPAREN);
StrExpr_LSQUARE : LSQUARE -> pushMode(Inside), type(LSQUARE);
StrExpr_RPAREN : ')' -> type(RPAREN);
StrExpr_RSQUARE : ']' -> type(RSQUARE);
StrExpr_LCURL : LCURL -> pushMode(StringExpression), type(LCURL);
StrExpr_DOT : DOT -> type(DOT);
StrExpr_COMMA : COMMA -> type(COMMA);
StrExpr_MULT : MULT -> type(MULT);
StrExpr_MOD : MOD -> type(MOD);
StrExpr_DIV : DIV -> type(DIV);
StrExpr_ADD : ADD -> type(ADD);
StrExpr_SUB : SUB -> type(SUB);
StrExpr_INCR : INCR -> type(INCR);
StrExpr_DECR : DECR -> type(DECR);
StrExpr_CONJ : CONJ -> type(CONJ);
StrExpr_DISJ : DISJ -> type(DISJ);
StrExpr_EXCL : EXCL -> type(EXCL);
StrExpr_COLON : COLON -> type(COLON);
StrExpr_SEMICOLON : SEMICOLON -> type(SEMICOLON);
StrExpr_ASSIGNMENT : ASSIGNMENT -> type(ASSIGNMENT);
StrExpr_ADD_ASSIGNMENT : ADD_ASSIGNMENT -> type(ADD_ASSIGNMENT);
StrExpr_SUB_ASSIGNMENT : SUB_ASSIGNMENT -> type(SUB_ASSIGNMENT);
StrExpr_MULT_ASSIGNMENT : MULT_ASSIGNMENT -> type(MULT_ASSIGNMENT);
StrExpr_DIV_ASSIGNMENT : DIV_ASSIGNMENT -> type(DIV_ASSIGNMENT);
StrExpr_MOD_ASSIGNMENT : MOD_ASSIGNMENT -> type(MOD_ASSIGNMENT);
StrExpr_ARROW : ARROW -> type(ARROW);
StrExpr_DOUBLE_ARROW : DOUBLE_ARROW -> type(DOUBLE_ARROW);
StrExpr_RANGE : RANGE -> type(RANGE);
StrExpr_COLONCOLON : COLONCOLON -> type(COLONCOLON);
StrExpr_Q_COLONCOLON : Q_COLONCOLON -> type(Q_COLONCOLON);
StrExpr_DOUBLE_SEMICOLON : DOUBLE_SEMICOLON -> type(DOUBLE_SEMICOLON);
StrExpr_HASH : HASH -> type(HASH);
StrExpr_AT : AT -> type(AT);
StrExpr_QUEST : QUEST -> type(QUEST);
StrExpr_ELVIS : ELVIS -> type(ELVIS);
StrExpr_LANGLE : LANGLE -> type(LANGLE);
StrExpr_RANGLE : RANGLE -> type(RANGLE);
StrExpr_LE : LE -> type(LE);
StrExpr_GE : GE -> type(GE);
StrExpr_EXCL_EQ : EXCL_EQ -> type(EXCL_EQ);
StrExpr_EXCL_EQEQ : EXCL_EQEQ -> type(EXCL_EQEQ);
StrExpr_AS : AS -> type(IS);
StrExpr_IS : IS -> type(IN);
StrExpr_IN : IN;
StrExpr_NOT_IS : NOT_IS -> type(NOT_IS);
StrExpr_NOT_IN : NOT_IN -> type(NOT_IN);
StrExpr_AS_SAFE : AS_SAFE -> type(AS_SAFE);
StrExpr_EQEQ : EQEQ -> type(EQEQ);
StrExpr_EQEQEQ : EQEQEQ -> type(EQEQEQ);
StrExpr_SINGLE_QUOTE : SINGLE_QUOTE -> type(SINGLE_QUOTE);
StrExpr_QUOTE_OPEN : QUOTE_OPEN -> pushMode(LineString), type(QUOTE_OPEN);
StrExpr_TRIPLE_QUOTE_OPEN:
TRIPLE_QUOTE_OPEN -> pushMode(MultiLineString), type(TRIPLE_QUOTE_OPEN)
;
StrExpr_BooleanLiteral : BooleanLiteral -> type(BooleanLiteral);
StrExpr_IntegerLiteral : IntegerLiteral -> type(IntegerLiteral);
StrExpr_HexLiteral : HexLiteral -> type(HexLiteral);
StrExpr_BinLiteral : BinLiteral -> type(BinLiteral);
StrExpr_CharacterLiteral : CharacterLiteral -> type(CharacterLiteral);
StrExpr_RealLiteral : RealLiteral -> type(RealLiteral);
StrExpr_NullLiteral : NullLiteral -> type(NullLiteral);
StrExpr_LongLiteral : LongLiteral -> type(LongLiteral);
StrExpr_Identifier : Identifier -> type(Identifier);
StrExpr_LabelReference : LabelReference -> type(LabelReference);
StrExpr_LabelDefinition : LabelDefinition -> type(LabelDefinition);
StrExpr_Comment : (LineComment | DelimitedComment) -> channel(HIDDEN);
StrExpr_WS : WS -> skip;
StrExpr_NL : NL -> skip;

819
modules/openapi-generator/src/test/antlr4/org/openapitools/codegen/antlr4/KotlinParser.g4 Normal file
View File

@ -0,0 +1,819 @@
/**
* Kotlin Grammar for ANTLR v4
*
* Based on:
* http://jetbrains.github.io/kotlin-spec/#_grammars_and_parsing
* and
* http://kotlinlang.org/docs/reference/grammar.html
*
* Tested on
* https://github.com/JetBrains/kotlin/tree/master/compiler/testData/psi
*/
// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false
// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging
parser grammar KotlinParser;
options {
tokenVocab = KotlinLexer;
}
kotlinFile
: NL* preamble anysemi* (topLevelObject (anysemi+ topLevelObject?)*)? EOF
;
script
: NL* preamble anysemi* (expression (anysemi+ expression?)*)? EOF
;
preamble
: fileAnnotations? packageHeader importList
;
fileAnnotations
: fileAnnotation+
;
fileAnnotation
: (FILE COLON (LSQUARE unescapedAnnotation+ RSQUARE | unescapedAnnotation) semi?)+
;
packageHeader
: (modifierList? PACKAGE identifier semi?)?
;
importList
: importHeader*
;
importHeader
: IMPORT identifier (DOT MULT | importAlias)? semi?
;
importAlias
: AS simpleIdentifier
;
topLevelObject
: classDeclaration
| objectDeclaration
| functionDeclaration
| propertyDeclaration
| typeAlias
;
classDeclaration
: modifierList? (CLASS | INTERFACE) NL* simpleIdentifier (NL* typeParameters)? (
NL* primaryConstructor
)? (NL* COLON NL* delegationSpecifiers)? (NL* typeConstraints)? (
NL* classBody
| NL* enumClassBody
)?
;
primaryConstructor
: modifierList? (CONSTRUCTOR NL*)? classParameters
;
classParameters
: LPAREN (classParameter (COMMA classParameter)* COMMA?)? RPAREN
;
classParameter
: modifierList? (VAL | VAR)? simpleIdentifier COLON type (ASSIGNMENT expression)?
;
delegationSpecifiers
: annotations* delegationSpecifier (NL* COMMA NL* annotations* delegationSpecifier)*
;
delegationSpecifier
: constructorInvocation
| userType
| explicitDelegation
;
constructorInvocation
: userType callSuffix
;
explicitDelegation
: userType NL* BY NL* expression
;
classBody
: LCURL NL* classMemberDeclaration* NL* RCURL
;
classMemberDeclaration
: (
classDeclaration
| functionDeclaration
| objectDeclaration
| companionObject
| propertyDeclaration
| anonymousInitializer
| secondaryConstructor
| typeAlias
) anysemi+
;
anonymousInitializer
: INIT NL* block
;
secondaryConstructor
: modifierList? CONSTRUCTOR NL* functionValueParameters (
NL* COLON NL* constructorDelegationCall
)? NL* block?
;
constructorDelegationCall
: THIS NL* valueArguments
| SUPER NL* valueArguments
;
enumClassBody
: LCURL NL* enumEntries? (NL* SEMICOLON NL* classMemberDeclaration*)? NL* RCURL
;
enumEntries
: (enumEntry NL*)+ SEMICOLON?
;
enumEntry
: annotations* simpleIdentifier (NL* valueArguments)? (NL* classBody)? (NL* COMMA)?
;
functionDeclaration
: modifierList? FUN (NL* type NL* DOT)? (NL* typeParameters)? (NL* receiverType NL* DOT)? (
NL* identifier
)? NL* functionValueParameters (NL* COLON NL* type)? (NL* typeConstraints)? (NL* functionBody)?
;
functionValueParameters
: LPAREN (functionValueParameter (COMMA functionValueParameter)* COMMA?)? RPAREN
;
functionValueParameter
: modifierList? parameter (ASSIGNMENT expression)?
;
parameter
: simpleIdentifier COLON type
;
receiverType
: typeModifierList? (parenthesizedType | nullableType | typeReference)
;
functionBody
: block
| ASSIGNMENT NL* expression
;
objectDeclaration
: modifierList? OBJECT NL* simpleIdentifier (NL* primaryConstructor)? (
NL* COLON NL* delegationSpecifiers
)? (NL* classBody)?
;
companionObject
: modifierList? COMPANION NL* modifierList? OBJECT (NL* simpleIdentifier)? (
NL* COLON NL* delegationSpecifiers
)? (NL* classBody)?
;
propertyDeclaration
: modifierList? (VAL | VAR) (NL* typeParameters)? (NL* type NL* DOT)? (
NL* (multiVariableDeclaration | variableDeclaration)
) (NL* typeConstraints)? (NL* (BY | ASSIGNMENT) NL* expression)? (
NL* getter (semi setter)?
| NL* setter (semi getter)?
)?
;
multiVariableDeclaration
: LPAREN variableDeclaration (COMMA variableDeclaration)* RPAREN
;
variableDeclaration
: simpleIdentifier (COLON type)?
;
getter
: modifierList? GETTER
| modifierList? GETTER NL* LPAREN RPAREN (NL* COLON NL* type)? NL* (
block
| ASSIGNMENT NL* expression
)
;
setter
: modifierList? SETTER
| modifierList? SETTER NL* LPAREN (annotations | parameterModifier)* (
simpleIdentifier
| parameter
) RPAREN NL* functionBody
;
typeAlias
: modifierList? TYPE_ALIAS NL* simpleIdentifier (NL* typeParameters)? NL* ASSIGNMENT NL* type
;
typeParameters
: LANGLE NL* typeParameter (NL* COMMA NL* typeParameter)* (NL* COMMA)? NL* RANGLE
;
typeParameter
: modifierList? NL* (simpleIdentifier | MULT) (NL* COLON NL* type)?
;
type
: typeModifierList? (functionType | parenthesizedType | nullableType | typeReference)
;
typeModifierList
: (annotations | SUSPEND NL*)+
;
parenthesizedType
: LPAREN type RPAREN
;
nullableType
: (typeReference | parenthesizedType) NL* QUEST+
;
typeReference
: LPAREN typeReference RPAREN
| userType
| DYNAMIC
;
functionType
: (functionTypeReceiver NL* DOT NL*)? functionTypeParameters NL* ARROW (NL* type)
;
functionTypeReceiver
: parenthesizedType
| nullableType
| typeReference
;
userType
: simpleUserType (NL* DOT NL* simpleUserType)*
;
simpleUserType
: simpleIdentifier (NL* typeArguments)?
;
//parameters for functionType
functionTypeParameters
: LPAREN NL* (parameter | type)? (NL* COMMA NL* (parameter | type))* (NL* COMMA)? NL* RPAREN
;
typeConstraints
: WHERE NL* typeConstraint (NL* COMMA NL* typeConstraint)*
;
typeConstraint
: annotations* simpleIdentifier NL* COLON NL* type
;
block
: LCURL statements RCURL
;
statements
: anysemi* (statement (anysemi+ statement?)*)?
;
statement
: declaration
| blockLevelExpression
;
blockLevelExpression
: annotations* NL* expression
;
declaration
: labelDefinition* (classDeclaration | functionDeclaration | propertyDeclaration | typeAlias)
;
expression
: disjunction (assignmentOperator disjunction)*
;
disjunction
: conjunction (NL* DISJ NL* conjunction)*
;
conjunction
: equalityComparison (NL* CONJ NL* equalityComparison)*
;
equalityComparison
: comparison (equalityOperation NL* comparison)*
;
comparison
: namedInfix (comparisonOperator NL* namedInfix)?
;
namedInfix
: elvisExpression ((inOperator NL* elvisExpression)+ | (isOperator NL* type))?
;
elvisExpression
: infixFunctionCall (NL* ELVIS NL* infixFunctionCall)*
;
infixFunctionCall
: rangeExpression (simpleIdentifier NL* rangeExpression)*
;
rangeExpression
: additiveExpression (RANGE NL* additiveExpression)*
;
additiveExpression
: multiplicativeExpression (additiveOperator NL* multiplicativeExpression)*
;
multiplicativeExpression
: typeRHS (multiplicativeOperation NL* typeRHS)*
;
typeRHS
: prefixUnaryExpression (NL* typeOperation prefixUnaryExpression)*
;
prefixUnaryExpression
: prefixUnaryOperation* postfixUnaryExpression
;
postfixUnaryExpression
: (atomicExpression | callableReference) postfixUnaryOperation*
;
atomicExpression
: parenthesizedExpression
| literalConstant
| functionLiteral
| thisExpression // THIS labelReference?
| superExpression // SUPER (LANGLE type RANGLE)? labelReference?
| conditionalExpression // ifExpression, whenExpression
| tryExpression
| objectLiteral
| jumpExpression
| loopExpression
| collectionLiteral
| simpleIdentifier
| VAL identifier
;
parenthesizedExpression
: LPAREN expression RPAREN
;
callSuffix
: typeArguments valueArguments? annotatedLambda*
| valueArguments annotatedLambda*
| annotatedLambda+
;
annotatedLambda
: unescapedAnnotation* LabelDefinition? NL* functionLiteral
;
arrayAccess
: LSQUARE (expression (COMMA expression)*)? RSQUARE
;
valueArguments
: LPAREN (valueArgument (COMMA valueArgument)* (NL* COMMA)?)? RPAREN
;
typeArguments
: LANGLE NL* typeProjection (NL* COMMA typeProjection)* (NL* COMMA)? NL* RANGLE QUEST?
;
typeProjection
: typeProjectionModifierList? type
| MULT
;
typeProjectionModifierList
: varianceAnnotation+
;
valueArgument
: (simpleIdentifier NL* ASSIGNMENT NL*)? MULT? NL* expression
;
literalConstant
: BooleanLiteral
| IntegerLiteral
| stringLiteral
| HexLiteral
| BinLiteral
| CharacterLiteral
| RealLiteral
| NullLiteral
| LongLiteral
;
stringLiteral
: lineStringLiteral
| multiLineStringLiteral
;
lineStringLiteral
: QUOTE_OPEN (lineStringContent | lineStringExpression)* QUOTE_CLOSE
;
multiLineStringLiteral
: TRIPLE_QUOTE_OPEN (
multiLineStringContent
| multiLineStringExpression
| lineStringLiteral
| MultiLineStringQuote
)* TRIPLE_QUOTE_CLOSE
;
lineStringContent
: LineStrText
| LineStrEscapedChar
| LineStrRef
;
lineStringExpression
: LineStrExprStart expression RCURL
;
multiLineStringContent
: MultiLineStrText
| MultiLineStrEscapedChar
| MultiLineStrRef
;
multiLineStringExpression
: MultiLineStrExprStart expression RCURL
;
functionLiteral
: annotations* (
LCURL NL* statements NL* RCURL
| LCURL NL* lambdaParameters NL* ARROW NL* statements NL* RCURL
)
;
lambdaParameters
: lambdaParameter? (NL* COMMA NL* lambdaParameter)*
;
lambdaParameter
: variableDeclaration
| multiVariableDeclaration (NL* COLON NL* type)?
;
// https://kotlinlang.org/docs/reference/grammar.html#objectLiteral
objectLiteral
: OBJECT (NL* COLON NL* delegationSpecifiers)? NL* classBody?
;
collectionLiteral
: LSQUARE expression? (COMMA expression)* RSQUARE
;
thisExpression
: THIS LabelReference?
;
superExpression
: SUPER (LANGLE NL* type NL* RANGLE)? LabelReference?
;
conditionalExpression
: ifExpression
| whenExpression
;
ifExpression
: IF NL* LPAREN expression RPAREN NL* controlStructureBody? SEMICOLON? (
NL* ELSE NL* controlStructureBody?
)?
;
controlStructureBody
: block
| expression
;
whenExpression
: WHEN NL* (LPAREN expression RPAREN)? NL* LCURL NL* (whenEntry NL*)* NL* RCURL
;
whenEntry
: whenCondition (NL* COMMA NL* whenCondition)* NL* ARROW NL* controlStructureBody semi?
| ELSE NL* ARROW NL* controlStructureBody
;
whenCondition
: expression
| rangeTest
| typeTest
;
rangeTest
: inOperator NL* expression
;
typeTest
: isOperator NL* type
;
tryExpression
: TRY NL* block (NL* catchBlock)* (NL* finallyBlock)?
;
catchBlock
: CATCH NL* LPAREN annotations* simpleIdentifier COLON userType RPAREN NL* block
;
finallyBlock
: FINALLY NL* block
;
loopExpression
: forExpression
| whileExpression
| doWhileExpression
;
forExpression
: FOR NL* LPAREN annotations* (variableDeclaration | multiVariableDeclaration) IN expression RPAREN NL* controlStructureBody?
;
whileExpression
: WHILE NL* LPAREN expression RPAREN NL* controlStructureBody?
;
doWhileExpression
: DO NL* controlStructureBody? NL* WHILE NL* LPAREN expression RPAREN
;
jumpExpression
: THROW NL* expression
| (RETURN | RETURN_AT) expression?
| CONTINUE
| CONTINUE_AT
| BREAK
| BREAK_AT
;
callableReference
: (userType (QUEST NL*)*)? NL* (COLONCOLON | Q_COLONCOLON) NL* (identifier | CLASS)
| THIS NL* COLONCOLON NL* CLASS
;
assignmentOperator
: ASSIGNMENT
| ADD_ASSIGNMENT
| SUB_ASSIGNMENT
| MULT_ASSIGNMENT
| DIV_ASSIGNMENT
| MOD_ASSIGNMENT
;
equalityOperation
: EXCL_EQ
| EXCL_EQEQ
| EQEQ
| EQEQEQ
;
comparisonOperator
: LANGLE
| RANGLE
| LE
| GE
;
inOperator
: IN
| NOT_IN
;
isOperator
: IS
| NOT_IS
;
additiveOperator
: ADD
| SUB
;
multiplicativeOperation
: MULT
| DIV
| MOD
;
typeOperation
: AS
| AS_SAFE
| COLON
;
prefixUnaryOperation
: INCR
| DECR
| ADD
| SUB
| EXCL
| annotations
| labelDefinition
;
postfixUnaryOperation
: INCR
| DECR
| EXCL EXCL
| callSuffix
| arrayAccess
| NL* memberAccessOperator postfixUnaryExpression
;
memberAccessOperator
: DOT
| QUEST DOT
;
modifierList
: (annotations | modifier)+
;
modifier
: (
classModifier
| memberModifier
| visibilityModifier
| varianceAnnotation
| functionModifier
| propertyModifier
| inheritanceModifier
| parameterModifier
| typeParameterModifier
) NL*
;
classModifier
: ENUM
| SEALED
| ANNOTATION
| DATA
| INNER
;
memberModifier
: OVERRIDE
| LATEINIT
;
visibilityModifier
: PUBLIC
| PRIVATE
| INTERNAL
| PROTECTED
;
varianceAnnotation
: IN
| OUT
;
functionModifier
: TAILREC
| OPERATOR
| INFIX
| INLINE
| EXTERNAL
| SUSPEND
;
propertyModifier
: CONST
;
inheritanceModifier
: ABSTRACT
| FINAL
| OPEN
;
parameterModifier
: VARARG
| NOINLINE
| CROSSINLINE
;
typeParameterModifier
: REIFIED
;
labelDefinition
: LabelDefinition NL*
;
annotations
: (annotation | annotationList) NL*
;
annotation
: annotationUseSiteTarget NL* COLON NL* unescapedAnnotation
| LabelReference (NL* DOT NL* simpleIdentifier)* (NL* typeArguments)? (NL* valueArguments)?
;
annotationList
: annotationUseSiteTarget COLON LSQUARE unescapedAnnotation+ RSQUARE
| AT LSQUARE unescapedAnnotation+ RSQUARE
;
annotationUseSiteTarget
: FIELD
| FILE
| PROPERTY
| GET
| SET
| RECEIVER
| PARAM
| SETPARAM
| DELEGATE
;
unescapedAnnotation
: identifier typeArguments? valueArguments?
;
identifier
: simpleIdentifier (NL* DOT simpleIdentifier)*
;
simpleIdentifier
: Identifier
//soft keywords:
| ABSTRACT
| ANNOTATION
| BY
| CATCH
| COMPANION
| CONSTRUCTOR
| CROSSINLINE
| DATA
| DYNAMIC
| ENUM
| EXTERNAL
| FINAL
| FINALLY
| GETTER
| IMPORT
| INFIX
| INIT
| INLINE
| INNER
| INTERNAL
| LATEINIT
| NOINLINE
| OPEN
| OPERATOR
| OUT
| OVERRIDE
| PRIVATE
| PROTECTED
| PUBLIC
| REIFIED
| SEALED
| TAILREC
| SETTER
| VARARG
| WHERE
//strong keywords
| CONST
| SUSPEND
;
semi
: NL+
| NL* SEMICOLON NL*
;
anysemi
: NL
| SEMICOLON
;

52
modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/KotlinClientCodegenModelTest.java
View File

@ -19,9 +19,17 @@ package org.openapitools.codegen.kotlin;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.media.*;
import lombok.Getter;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.ParseTreeWalker;
import org.openapitools.codegen.*;
import org.openapitools.codegen.antlr4.KotlinLexer;
import org.openapitools.codegen.antlr4.KotlinParser;
import org.openapitools.codegen.antlr4.KotlinParserBaseListener;
import org.openapitools.codegen.config.CodegenConfigurator;
import org.openapitools.codegen.languages.KotlinClientCodegen;
import org.openapitools.codegen.languages.KotlinServerCodegen;
import org.openapitools.codegen.testutils.ConfigAssert;
import org.testng.Assert;
import org.testng.annotations.DataProvider;
@ -30,11 +38,16 @@ import org.testng.annotations.Test;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.openapitools.codegen.CodegenConstants.*;
import static org.openapitools.codegen.languages.KotlinServerCodegen.Constants.INTERFACE_ONLY;
import static org.openapitools.codegen.languages.KotlinServerCodegen.Constants.RETURN_RESPONSE;
@SuppressWarnings("static-method")
public class KotlinClientCodegenModelTest {
@ -481,6 +494,45 @@ public class KotlinClientCodegenModelTest {
"val adapterkotlin.String", "val adapterjava.math.BigDecimal");
}
@Test(description = "Issue #20960")
private void givenSchemaObjectPropertyNameContainsDollarSignWhenGenerateThenDollarSignIsProperlyEscapedInAnnotation() throws Exception {
File output = Files.createTempDirectory("test").toFile().getCanonicalFile();
output.deleteOnExit();
KotlinClientCodegen codegen = new KotlinClientCodegen();
codegen.setOutputDir(output.getAbsolutePath());
Map<String, Object> properties = new HashMap<>();
// properties.put(CodegenConstants.LIBRARY, ClientLibrary.JVM_KTOR);
properties.put(CodegenConstants.ENUM_PROPERTY_NAMING, CodegenConstants.ENUM_PROPERTY_NAMING_TYPE.UPPERCASE.toString());
properties.put(SERIALIZATION_LIBRARY, KotlinClientCodegen.SERIALIZATION_LIBRARY_TYPE.gson.toString());
properties.put(KotlinClientCodegen.GENERATE_ONEOF_ANYOF_WRAPPERS, true);
properties.put(API_PACKAGE, "com.toasttab.service.scim.api");
properties.put(MODEL_PACKAGE, "com.toasttab.service.scim.models");
properties.put(PACKAGE_NAME, "com.toasttab.service.scim");
codegen.additionalProperties().putAll(properties);
new DefaultGenerator().opts(new ClientOptInput()
.openAPI(TestUtils.parseSpec("src/test/resources/3_1/issue_20960.yaml"))
.config(codegen))
.generate();
String outputPath = output.getAbsolutePath() + "/src/main/kotlin/com/toasttab/service/scim";
Path baseGroupModel = Paths.get(outputPath + "/models/BaseGroupMembersInner.kt");
String baseGroupModelContent = Files.readString(baseGroupModel);
KotlinLexer kotlinLexer = new KotlinLexer(CharStreams.fromString(baseGroupModelContent));
KotlinTestUtils.SyntaxErrorListener syntaxErrorListener = new KotlinTestUtils.SyntaxErrorListener();
kotlinLexer.addErrorListener(syntaxErrorListener);
CommonTokenStream commonTokenStream = new CommonTokenStream(kotlinLexer);
KotlinParser kotlinParser = new KotlinParser(commonTokenStream);
kotlinParser.addErrorListener(syntaxErrorListener);
ParseTree parseTree = kotlinParser.kotlinFile();
ParseTreeWalker parseTreeWalker = new ParseTreeWalker();
KotlinTestUtils.CustomKotlinParseListener customKotlinParseListener = new KotlinTestUtils.CustomKotlinParseListener();
parseTreeWalker.walk(customKotlinParseListener, parseTree);
Assert.assertEquals(syntaxErrorListener.getSyntaxErrorCount(), 0);
Assert.assertEquals(customKotlinParseListener.getStringReferenceCount(), 0);
}
private static class ModelNameTest {
private final String expectedName;
private final String expectedClassName;

65
modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/KotlinServerCodegenTest.java
View File

@ -1,10 +1,21 @@
package org.openapitools.codegen.kotlin;
import lombok.Getter;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.ParseTreeWalker;
import org.checkerframework.checker.units.qual.C;
import org.openapitools.codegen.ClientOptInput;
import org.openapitools.codegen.CodegenConstants;
import org.openapitools.codegen.DefaultGenerator;
import org.openapitools.codegen.TestUtils;
import org.openapitools.codegen.antlr4.KotlinLexer;
import org.openapitools.codegen.antlr4.KotlinParser;
import org.openapitools.codegen.antlr4.KotlinParserBaseListener;
import org.openapitools.codegen.languages.KotlinServerCodegen;
import org.openapitools.codegen.languages.KotlinSpringServerCodegen;
import org.testng.Assert;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import java.io.File;
@ -12,13 +23,14 @@ import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
import static org.openapitools.codegen.CodegenConstants.LIBRARY;
import static org.openapitools.codegen.CodegenConstants.*;
import static org.openapitools.codegen.TestUtils.assertFileContains;
import static org.openapitools.codegen.TestUtils.assertFileNotContains;
import static org.openapitools.codegen.languages.AbstractKotlinCodegen.USE_JAKARTA_EE;
import static org.openapitools.codegen.languages.KotlinServerCodegen.Constants.INTERFACE_ONLY;
import static org.openapitools.codegen.languages.KotlinServerCodegen.Constants.JAXRS_SPEC;
import static org.openapitools.codegen.languages.KotlinServerCodegen.Constants.*;
import static org.openapitools.codegen.languages.features.BeanValidationFeatures.USE_BEANVALIDATION;
public class KotlinServerCodegenTest {
@ -252,4 +264,51 @@ public class KotlinServerCodegenTest {
"@get:Size(max=50)"
);
}
@DataProvider(name = "dollarEscapeTest")
private Object[][] createData() {
return new Object[][]{
new Object[]{JAXRS_SPEC},
new Object[]{JAVALIN5},
new Object[]{JAVALIN6},
};
}
@Test(description = "Issue #20960", dataProvider = "dollarEscapeTest")
public void givenSchemaObjectPropertyNameContainsDollarSignWhenGenerateThenDollarSignIsProperlyEscapedInAnnotation(String library) throws Exception {
File output = Files.createTempDirectory("test").toFile().getCanonicalFile();
output.deleteOnExit();
KotlinServerCodegen codegen = new KotlinServerCodegen();
codegen.setOutputDir(output.getAbsolutePath());
Map<String, Object> properties = new HashMap<>();
properties.put(CodegenConstants.LIBRARY, library);
properties.put(CodegenConstants.ENUM_PROPERTY_NAMING, CodegenConstants.ENUM_PROPERTY_NAMING_TYPE.UPPERCASE.toString());
properties.put(INTERFACE_ONLY, true);
properties.put(RETURN_RESPONSE, true);
properties.put(API_PACKAGE, "com.toasttab.service.scim.api");
properties.put(MODEL_PACKAGE, "com.toasttab.service.scim.models");
properties.put(PACKAGE_NAME, "com.toasttab.service.scim");
codegen.additionalProperties().putAll(properties);
new DefaultGenerator().opts(new ClientOptInput()
.openAPI(TestUtils.parseSpec("src/test/resources/3_1/issue_20960.yaml"))
.config(codegen))
.generate();
String outputPath = output.getAbsolutePath() + "/src/main/kotlin/com/toasttab/service/scim";
Path baseGroupModel = Paths.get(outputPath + "/models/BaseGroupMembersInner.kt");
String baseGroupModelContent = Files.readString(baseGroupModel);
KotlinLexer kotlinLexer = new KotlinLexer(CharStreams.fromString(baseGroupModelContent));
KotlinTestUtils.SyntaxErrorListener syntaxErrorListener = new KotlinTestUtils.SyntaxErrorListener();
kotlinLexer.addErrorListener(syntaxErrorListener);
CommonTokenStream commonTokenStream = new CommonTokenStream(kotlinLexer);
KotlinParser kotlinParser = new KotlinParser(commonTokenStream);
kotlinParser.addErrorListener(syntaxErrorListener);
ParseTree parseTree = kotlinParser.kotlinFile();
ParseTreeWalker parseTreeWalker = new ParseTreeWalker();
KotlinTestUtils.CustomKotlinParseListener customKotlinParseListener = new KotlinTestUtils.CustomKotlinParseListener();
parseTreeWalker.walk(customKotlinParseListener, parseTree);
Assert.assertTrue(syntaxErrorListener.getSyntaxErrorCount() == 0);
Assert.assertTrue(customKotlinParseListener.getStringReferenceCount() == 0);
}
}

35
modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/KotlinTestUtils.java
View File

@ -1,6 +1,10 @@
package org.openapitools.codegen.kotlin;
import kotlin.script.experimental.jvm.util.KotlinJars;
import lombok.Getter;
import org.antlr.v4.runtime.BaseErrorListener;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.Recognizer;
import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
import org.jetbrains.kotlin.cli.common.config.ContentRootsKt;
import org.jetbrains.kotlin.cli.common.messages.MessageRenderer;
@ -15,6 +19,8 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys;
import org.jetbrains.kotlin.config.CompilerConfiguration;
import org.jetbrains.kotlin.config.JVMConfigurationKeys;
import org.jetbrains.kotlin.config.JvmTarget;
import org.openapitools.codegen.antlr4.KotlinParser;
import org.openapitools.codegen.antlr4.KotlinParserBaseListener;
import java.io.*;
import java.net.MalformedURLException;
@ -96,4 +102,33 @@ public class KotlinTestUtils {
return isDisposed;
}
}
public static class CustomKotlinParseListener extends KotlinParserBaseListener {
@Getter
private int stringReferenceCount = 0;
@Override
public void exitLineStringContent(KotlinParser.LineStringContentContext ctx) {
if(ctx.LineStrRef() != null) {
stringReferenceCount++;
}
}
@Override
public void exitMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx) {
if(ctx.MultiLineStrRef() != null) {
stringReferenceCount++;
}
}
}
public static class SyntaxErrorListener extends BaseErrorListener {
@Getter
private int syntaxErrorCount = 0;
@Override
public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) {
syntaxErrorCount++;
}
}
}

147
modules/openapi-generator/src/test/resources/3_1/issue_20960.yaml Normal file
View File

@ -0,0 +1,147 @@
# Slightly modified from the original
openapi: 3.1.0
info:
version: 5.0.5
title: Internal Users SCIM
description: ...
tags:
- name: Groups
description: ...
paths:
/v3/internal/scim/Groups/{id}:
get:
summary: 'Get group by id'
description: ...
externalDocs:
url: 'https://datatracker.ietf.org/doc/html/rfc7644#section-3.2'
description: 'RFC 7644, Section 3.2'
operationId: getGroup
tags:
- Groups
parameters:
- $ref: '#/components/parameters/GroupIdInPath'
responses:
'200':
description: Successful response
content:
application/scim+json:
schema:
$ref: '#/components/schemas/Group'
application/json:
schema:
$ref: '#/components/schemas/Group'
components:
parameters:
GroupIdInPath:
name: id
in: path
description: |
The unique identifier of a group
required: true
schema:
type: string
format: uuid
schemas:
Meta:
type: object
description: ...
externalDocs:
url: 'https://datatracker.ietf.org/doc/html/rfc7643#section-3.1'
description: 'RFC 7643, Section 3.1'
properties:
resourceType:
type: string
description: ...
examples:
- 'ResourceType'
created:
type: string
format: date-time
description: ...
examples:
- '2024-07-21T17:32:28Z'
lastModified:
type: string
format: date-time
description: ...
location:
type: string
description: ...
version:
type: string
description: ...
BaseGroup:
type: object
description: ...
externalDocs:
url: 'https://datatracker.ietf.org/doc/html/rfc7643#section-4'
description: 'RFC 7643, Section 4'
required:
- members
properties:
members:
type: array
description: ...
items:
type: object
required:
- value
- $refRequired
properties:
value:
type: string
format: uuid
description: ...
$ref:
type:
- "string"
- "null"
description: ...
$refRequired:
type:
- "string"
- "null"
description: ...
$refOneOf:
type: object
oneOf: [
{
"type": integer
},
{
"type": "boolean"
}
]
default: [ ] # default is for `PUT` request
Group:
type: object
description: ...
externalDocs:
url: 'https://datatracker.ietf.org/doc/html/rfc7643#section-4'
description: 'RFC 7643, Section 4'
required:
- schemas
- id
- displayName
- members
allOf:
- type: object
properties:
schemas:
type: array
description: ...
items:
type: string
id:
type: string
format: uuid
readOnly: true
description: ...
displayName:
type: string
readOnly: true
description: ...
- $ref: '#/components/schemas/BaseGroup'

1
pom.xml
View File

@ -269,6 +269,7 @@
<maxmemory>1g</maxmemory>
<failOnWarnings>false</failOnWarnings>
<doclint>none</doclint>
<excludePackageNames>org.openapitools.codegen.antlr4</excludePackageNames>
</configuration>
<executions>
<execution>