Unity-Technologies
/
quicktype
зеркало из https://github.com/Unity-Technologies/quicktype.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Pike: huge refactor. Integrate with test pipeline. Disable some tests.

This commit is contained in:
Mateusz Krawczuk 2019-01-15 18:09:05 +01:00
Родитель 4d05e53cbe
Коммит 8d8335da84
4 изменённых файлов: 243 добавлений и 62 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

6
script/dev
Просмотреть файл

@ -1,10 +1,10 @@
#!/usr/bin/env bash
docker pull schani/quicktype
docker build --cache-from schani/quicktype -t quicktype .
# docker pull schani/quicktype
docker build --cache-from quicktype -t quicktype .
docker run -it \
-p 3000:3000 \
--volume=$PWD:/quicktype \
--workdir="/quicktype" \
--entrypoint=/bin/bash \
quicktype
quicktype

216
src/quicktype-core/language/Pike.ts
Просмотреть файл

@ -1,4 +1,4 @@
import { ConvenienceRenderer } from "../ConvenienceRenderer";
import { ConvenienceRenderer, ForbiddenWordsInfo } from "../ConvenienceRenderer";
import { Name, Namer, funPrefixNamer } from "../Naming";
import { Option } from "../RendererOptions";
import { RenderContext } from "../Renderer";
@ -10,14 +10,68 @@ import { legalizeCharacters, isLetterOrUnderscoreOrDigit, stringEscape, makeName
export const pikeOptions = {};
const baseClassName = "JsonEncodable";
const keywords = [
"nomask",
"final",
"static",
"extern",
"private",
"local",
"public",
"protected",
"inline",
"optional",
"variant",
"void",
"mixed",
"array",
"__attribute__",
"__deprecated__",
"mapping",
"multiset",
"object",
"function",
"__func__",
"program",
"string",
"float",
"int",
"enum",
"typedef",
"if",
"do",
"for",
"while",
"else",
"foreach",
"catch",
"gauge",
"class",
"break",
"case",
"constant",
"continue",
"default",
"import",
"inherit",
"lambda",
"predef",
"return",
"sscanf",
"switch",
"typeof",
"global"
];
const conversionFunctionName = "TO_MIXED";
const legalizeName = legalizeCharacters(isLetterOrUnderscoreOrDigit);
const namingFunction = funPrefixNamer("namer", makeNameStyle("underscore", legalizeName));
const namedTypeNamingFunction = funPrefixNamer("namer", makeNameStyle("pascal", legalizeName));
const enumNamingFunction = funPrefixNamer("enumNamer", makeNameStyle("upper-underscore", legalizeName));
const namingFunction = funPrefixNamer("genericNamer", makeNameStyle("underscore", legalizeName));
const namedTypeNamingFunction = funPrefixNamer("typeNamer", makeNameStyle("pascal", legalizeName));
export class PikeTargetLanguage extends TargetLanguage {
constructor() {
super("Pike", ["pike", "pikelang"], "Pike");
super("Pike", ["pike", "pikelang"], "pmod");
}
protected getOptions(): Option<any>[] {
return [];
@ -30,17 +84,29 @@ export class PikeTargetLanguage extends TargetLanguage {
export class PikeRenderer extends ConvenienceRenderer {
protected emitSourceStructure(): void {
this.emitBaseClass();
this.emitInformationComment();
this.emitConversionFunction();
this.ensureBlankLine();
this.forEachTopLevel(
"leading",
(t, name) => {
this.emitTopLevelTypedef(t, name);
this.emitTopLevelConverter(name);
this.ensureBlankLine();
},
t => this.namedTypeToNameForTopLevel(t) === undefined
);
this.ensureBlankLine();
this.forEachNamedType(
"leading-and-interposing",
(c: ClassType, className: Name) => this.emitClass(c, className),
(c: ClassType, className: Name) => this.emitClassDefinition(c, className),
(e, n) => this.emitEnum(e, n),
(u, n) => this.emitUnion(u, n)
);
}
protected makeEnumCaseNamer(): Namer {
return namingFunction;
return enumNamingFunction;
}
protected makeNamedTypeNamer(): Namer {
return namedTypeNamingFunction;
@ -54,8 +120,20 @@ export class PikeRenderer extends ConvenienceRenderer {
return namingFunction;
}
protected forbiddenNamesForObjectProperties(): string[] {
return ["private", "protected", "public", "return"];
protected forbiddenNamesForGlobalNamespace(): string[] {
return [...keywords];
}
protected forbiddenForObjectProperties(_c: ClassType, _className: Name): ForbiddenWordsInfo {
return { names: [], includeGlobalForbidden: true };
}
protected forbiddenForEnumCases(_e: EnumType, _enumName: Name): ForbiddenWordsInfo {
return { names: [], includeGlobalForbidden: true };
}
protected forbiddenForUnionMembers(_u: UnionType, _unionName: Name): ForbiddenWordsInfo {
return { names: [], includeGlobalForbidden: true };
}
protected sourceFor(t: Type): MultiWord {
@ -91,58 +169,22 @@ export class PikeRenderer extends ConvenienceRenderer {
);
}
private emitBlock(line: Sourcelike, f: () => void): void {
this.emitLine(line, " {");
this.indent(f);
this.emitLine("}");
}
private emitBaseClass(): void {
this.emitBlock(["class ", baseClassName, ";"], () => {
this.emitBlock(["string encode_json() "], () => {
this.emitLine(["array(string) members = map(indices(this), lambda(string idx) {"]);
this.indent(() => {
this.emitLine(["return callablep(this[idx])? 0 : idx;"]);
});
this.emitLine(["});"]);
this.emitLine(["members -= ({0});"]);
this.ensureBlankLine();
this.emitLine(["array values = map(members, lambda(string idx) {"]);
this.indent(() => {
this.emitLine(["return this[idx];"]);
});
this.emitLine(["});"]);
this.ensureBlankLine();
this.emitLine(["return Standards.JSON.encode(mkmapping(members, values));"]);
});
});
}
private emitClassMembers(c: ClassType): void {
let table: Sourcelike[][] = [];
this.forEachClassProperty(c, "none", (name, jsonName, p) => {
const pikeType = this.sourceFor(p.type).source;
table.push([[pikeType, " "], [name, "; "], ['// json: "', stringEscape(jsonName), '"']]);
});
this.emitTable(table);
}
private emitClass(c: ClassType, className: Name): void {
protected emitClassDefinition(c: ClassType, className: Name): void {
this.emitDescription(this.descriptionForType(c));
this.emitBlock(["class ", className], () => {
this.emitLine(["inherit ", baseClassName, ";"]);
this.ensureBlankLine();
this.emitClassMembers(c);
this.ensureBlankLine();
this.emitEncodingFunction(c);
});
this.ensureBlankLine();
this.emitDecodingFunction(className, c);
}
protected emitEnum(e: EnumType, enumName: Name): void {
this.emitBlock([e.kind, " ", enumName], () => {
let table: Sourcelike[][] = [];
this.forEachEnumCase(e, "none", (name, jsonName) => {
table.push([[name, ", "], ['// json: "', stringEscape(jsonName), '"']]);
table.push([[name, ' = "', jsonName, '", '], ['// json: "', stringEscape(jsonName), '"']]);
});
this.emitTable(table);
});
@ -173,4 +215,76 @@ export class PikeRenderer extends ConvenienceRenderer {
";"
]);
}
private emitBlock(line: Sourcelike, f: () => void): void {
this.emitLine(line, " {");
this.indent(f);
this.emitLine("}");
}
private emitClassMembers(c: ClassType): void {
let table: Sourcelike[][] = [];
this.forEachClassProperty(c, "none", (name, jsonName, p) => {
const pikeType = this.sourceFor(p.type).source;
table.push([[pikeType, " "], [name, "; "], ['// json: "', stringEscape(jsonName), '"']]);
});
this.emitTable(table);
}
private emitInformationComment() {
this.emitLine(["// This source has been automatically generated by quicktype."]);
this.emitLine(["// ( https://github.com/quicktype/quicktype )"]);
this.ensureBlankLine();
this.emitLine(["// To use this code, simply import it into your project as a Pike module."]);
this.ensureBlankLine();
this.emitLine(["// To JSON-encode your object, you can pass it to `Standards.JSON.encode`"]);
this.emitLine(["// or call `encode_json` on it."]);
this.ensureBlankLine();
this.emitLine(["// To decode a JSON string, first pass it to `Standards.JSON.decode`,"]);
this.emitLine(["// and then pass the result to `<YourClass>_from_JSON`."]);
this.emitLine(["// It will return an instance of <YourClass>."]);
this.emitLine(["// Bear in mind that these functions have unexpected behavior,"]);
this.emitLine(["// and will likely throw an error, if the JSON string does not"]);
this.emitLine(["// match the expected interface, even if the JSON is valid."]);
this.emitLine([]);
this.ensureBlankLine();
}
private emitTopLevelTypedef(t: Type, name: Name) {
this.emitLine("typedef ", this.sourceFor(t).source, " ", name, ";");
}
private emitTopLevelConverter(name: Name) {
this.emitBlock([name, " ", name, "_from_JSON(mixed json)"], () => {
this.emitLine(["return map(json, ", name, "Element_from_JSON);"]);
});
}
private emitConversionFunction() {
this.emitLine(["#define ", conversionFunctionName, "(x) Standards.JSON.decode(Standards.JSON.encode(x))"]);
}
private emitEncodingFunction(c: ClassType) {
this.emitBlock(["string encode_json() "], () => {
this.emitLine(["mapping(string:mixed) json = ([]);"]);
this.ensureBlankLine();
this.forEachClassProperty(c, "none", (name, jsonName) => {
this.emitLine(['json["', jsonName, '"] = ', conversionFunctionName, "(", name, ");"]);
});
this.ensureBlankLine();
this.emitLine(["return Standards.JSON.encode(json, Standards.JSON.HUMAN_READABLE);"]);
});
}
private emitDecodingFunction(className: Name, c: ClassType) {
this.emitBlock([className, " ", className, "_from_JSON(mixed json)"], () => {
this.emitLine([className, " retval = ", className, "();"]);
this.ensureBlankLine();
this.forEachClassProperty(c, "none", (name, jsonName) => {
this.emitLine(["retval.", name, ' = json["', jsonName, '"];']);
});
this.ensureBlankLine();
this.emitLine(["return retval;"]);
});
}
}

12
test/fixtures/pike/main.pike поставляемый
Просмотреть файл

@ -1,11 +1,13 @@
// This is a dummy test fixture for Pike
// It will be finished when JSON decoding will be finished.
import .TopLevel;
int main (int argc, array(string) argv) {
Stdio.File f = Stdio.File(argv[1], "r");
//TopLevel from_json = decode_json_from_TopLevel(f.read());
//string to_json = Standards.JSON.encode(from_json);
write(f.read());
mixed json = Standards.JSON.decode(f.read());
TopLevel tl = TopLevel_from_JSON(json);
string to_json = Standards.JSON.encode(tl, Standards.JSON.HUMAN_READABLE);
write(to_json);
return 0;
}

71
test/languages.ts
Просмотреть файл

@ -841,11 +841,76 @@ export const PikeLanguage: Language = {
skipDiffViaSchema: [],
allowMissingNull: true,
features: ["union"],
output: "TopLevel.pike",
output: "TopLevel.pmod",
topLevel: "TopLevel",
skipJSON: [],
skipJSON: [
"github-events.json",
"us-senators.json",
"bug790.json",
"bug863.json",
"bug855-short.json",
"blns-object.json",
"bug427.json",
"identifiers.json",
"no-classes.json",
"name-style.json",
"nbl-stats.json",
"nst-test-suite.json",
"simple-identifiers.json",
"optional-union.json",
"00c36.json",
"7fbfb.json",
"c8c7e.json",
"cda6c.json",
"e53b5.json",
"ed095.json",
"7eb30.json",
"dd1ce.json",
"cb81e.json",
"c6cfd.json",
// Pike's Stdio.File.write() does not support wide strings.
"0b91a.json",
"29f47.json",
"337ed.json",
"33d2e.json",
"458db.json",
"6c155.json",
"6de06.json",
"734ad.json",
"8592b.json",
"9ac3b.json",
"cb0cc.json",
"d23d5.json",
"dc44f.json",
"dec3a.json",
"f22f5.json",
"f22f5.json",
// Pike's enums pollute the global namespace.
// Output pmod fails to compile if there are two enum keys with the same name.
"0b91a.json",
"0e0c2.json",
"1b409.json",
"2d4e2.json",
"2df80.json",
"e8b04.json"
],
skipMiscJSON: false,
skipSchema: [],
skipSchema: [
// Weird problems
"go-schema-pattern-properties.schema",
"class-with-additional.schema",
// Weird union-related problems
"class-map-union.schema",
"implicit-class-array-union.schema",
"integer-float-union.schema", // no implicit cast int <-> float in Pike
"keyword-unions.schema",
"minmax.schema",
// Pike's enums pollute the global namespace.
// Output pmod fails to compile if there are two enum keys with the same name.
"enum.schema",
"top-level-enum.schema",
"multi-type-enum.schema"
],
rendererOptions: {},
quickTestRendererOptions: [],
sourceFiles: ["src/Language/Pike.ts"]