opendev/gerrit
Code Issues Proposed changes

Converter to Polymer2 classes.

Browse Source 
See readme.txt for more information about usages.

Change-Id: I60843b32bc56faa04ad2b70898ab1f5535a2ad71
This commit is contained in:
Dmitrii Filippov 2019-10-14 17:32:55 +02:00
parent 2f67ad2509
commit f0d5b6e49c
17 changed files with 2046 additions and 0 deletions

3
tools/polygerrit-updater/.gitignore vendored Normal file

@ -0,0 +1,3 @@
/.idea/
/node_modules/
/js/

18
tools/polygerrit-updater/package-lock.json generated Normal file

@ -0,0 +1,18 @@
{
"name": "polygerrit-updater",
"version": "1.0.0",
"lockfileVersion": 1,
"requires": true,
"dependencies": {
"@types/node": {
"version": "12.7.12",
"resolved": "https://registry.npmjs.org/@types/node/-/node-12.7.12.tgz",
"integrity": "sha512-KPYGmfD0/b1eXurQ59fXD1GBzhSQfz6/lKBxkaHX9dKTzjXbK68Zt7yGUxUsCS1jeTy/8aL+d9JEr+S54mpkWQ=="
},
"typescript": {
"version": "3.6.4",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-3.6.4.tgz",
"integrity": "sha512-unoCll1+l+YK4i4F8f22TaNVPRHcD9PA3yCuZ8g5e0qGqlVlJ/8FSateOLLSagn+Yg5+ZwuPkL8LFUc0Jcvksg=="
}
}
}

15
tools/polygerrit-updater/package.json Normal file

@ -0,0 +1,15 @@
{
"name": "polygerrit-updater",
"version": "1.0.0",
"description": "Polygerrit source code updater",
"scripts": {
"compile": "tsc",
"convert": "npm run compile && node js/src/index.js"
},
"author": "",
"license": "Apache-2.0",
"dependencies": {
"@types/node": "^12.7.12",
"typescript": "^3.6.4"
}
}

56
tools/polygerrit-updater/readme.txt Normal file

@ -0,0 +1,56 @@
This folder contains tool to update Polymer components to class based components.
This is a temporary tools, it will be removed in a few weeks.
How to use this tool: initial steps
1) Important - Commit and push all your changes. Otherwise, you can loose you work.
2) Ensure, that tools/polygerrit-updater is your current directory
3) Run
npm install
4) If you want to convert the whole project, run
npm run convert -- --i \
--root ../../polygerrit-ui --src app/elements --r \
--exclude app/elements/core/gr-reporting/gr-reporting.js \
app/elements/diff/gr-comment-api/gr-comment-api-mock.js \
app/elements/plugins/gr-dom-hooks/gr-dom-hooks.js
You can convert only specific files (can be useful if you want to convert some files in your change)
npm run convert -- --i \
--root ../../polygerrit-ui
--src app/elements/file1.js \
app/elements/folder/file2.js
4) Search for the following string in all .js files:
//This file has the following problems with comments:
If you find such string in a .js file - you must manually fix comments in this file.
(It is expected that you shouldn't have such problems)
5) Go to the gerrit root folder and run
npm run eslintfix
(If you are doing it for the first time, run the following command before in gerrit root folder:
npm run install)
Fix error after eslintfix (if exists)
6) If you are doing conversion for the whole project, make the followin changes:
a) Add
<link rel="import" href="../../../types/polymer-behaviors.js">
to
polygerrit-ui/app/elements/shared/gr-autocomplete-dropdown/gr-autocomplete-dropdown.html
b) Update polymer.json with the following rules:
"lint": {
"rules": ["polymer-2"],
"ignoreWarnings": ["deprecated-dom-call"]
}
5) Commit changed files.
6) You can update excluded files later.

131
tools/polygerrit-updater/src/funcToClassConversion/funcToClassBasedElementConverter.ts Normal file

@ -0,0 +1,131 @@
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import {LegacyLifecycleMethodsArray, LegacyPolymerComponent} from './polymerComponentParser';
import {LifecycleMethodsBuilder} from './lifecycleMethodsBuilder';
import {ClassBasedPolymerElement, PolymerElementBuilder} from './polymerElementBuilder';
import * as codeUtils from '../utils/codeUtils';
import * as ts from 'typescript';
export class PolymerFuncToClassBasedConverter {
public static convert(component: LegacyPolymerComponent): ClassBasedPolymerElement {
const legacySettings = component.componentSettings;
const reservedDeclarations = legacySettings.reservedDeclarations;
if(!reservedDeclarations.is) {
throw new Error("Legacy component doesn't have 'is' property");
}
const className = this.generateClassNameFromTagName(reservedDeclarations.is.data);
const updater = new PolymerElementBuilder(component, className);
updater.addIsAccessor(reservedDeclarations.is.data);
if(reservedDeclarations.properties) {
updater.addPolymerPropertiesAccessor(reservedDeclarations.properties);
}
updater.addMixin("Polymer.Element");
updater.addMixin("Polymer.LegacyElementMixin");
updater.addMixin("Polymer.GestureEventListeners");
if(reservedDeclarations._legacyUndefinedCheck) {
updater.addMixin("Polymer.LegacyDataMixin");
}
if(reservedDeclarations.behaviors) {
updater.addMixin("Polymer.mixinBehaviors", [reservedDeclarations.behaviors.data]);
const mixinNames = this.getMixinNamesFromBehaviors(reservedDeclarations.behaviors.data);
const jsDocLines = mixinNames.map(mixinName => {
return `@appliesMixin ${mixinName}`;
});
updater.addClassJSDocComments(jsDocLines);
}
if(reservedDeclarations.observers) {
updater.addPolymerPropertiesObservers(reservedDeclarations.observers.data);
}
if(reservedDeclarations.keyBindings) {
updater.addKeyBindings(reservedDeclarations.keyBindings.data);
}
const lifecycleBuilder = new LifecycleMethodsBuilder();
if (reservedDeclarations.listeners) {
lifecycleBuilder.addListeners(reservedDeclarations.listeners.data, legacySettings.ordinaryMethods);
}
if (reservedDeclarations.hostAttributes) {
lifecycleBuilder.addHostAttributes(reservedDeclarations.hostAttributes.data);
}
for(const name of LegacyLifecycleMethodsArray) {
const existingMethod = legacySettings.lifecycleMethods.get(name);
if(existingMethod) {
lifecycleBuilder.addLegacyLifecycleMethod(name, existingMethod)
}
}
const newLifecycleMethods = lifecycleBuilder.buildNewMethods();
updater.addLifecycleMethods(newLifecycleMethods);
updater.addOrdinaryMethods(legacySettings.ordinaryMethods);
updater.addOrdinaryGetAccessors(legacySettings.ordinaryGetAccessors);
updater.addOrdinaryShorthandProperties(legacySettings.ordinaryShorthandProperties);
updater.addOrdinaryPropertyAssignments(legacySettings.ordinaryPropertyAssignments);
return updater.build();
}
private static generateClassNameFromTagName(tagName: string) {
let result = "";
let nextUppercase = true;
for(const ch of tagName) {
if (ch === '-') {
nextUppercase = true;
continue;
}
result += nextUppercase ? ch.toUpperCase() : ch;
nextUppercase = false;
}
return result;
}
private static getMixinNamesFromBehaviors(behaviors: ts.ArrayLiteralExpression): string[] {
return behaviors.elements.map((expression) => {
const propertyAccessExpression = codeUtils.assertNodeKind(expression, ts.SyntaxKind.PropertyAccessExpression) as ts.PropertyAccessExpression;
const namespaceName = codeUtils.assertNodeKind(propertyAccessExpression.expression, ts.SyntaxKind.Identifier) as ts.Identifier;
const behaviorName = propertyAccessExpression.name;
if(namespaceName.text === 'Gerrit') {
let behaviorNameText = behaviorName.text;
const suffix = 'Behavior';
if(behaviorNameText.endsWith(suffix)) {
behaviorNameText =
behaviorNameText.substr(0, behaviorNameText.length - suffix.length);
}
const mixinName = behaviorNameText + 'Mixin';
return `${namespaceName.text}.${mixinName}`
} else if(namespaceName.text === 'Polymer') {
let behaviorNameText = behaviorName.text;
if(behaviorNameText === "IronFitBehavior") {
return "Polymer.IronFitMixin";
} else if(behaviorNameText === "IronOverlayBehavior") {
return "";
}
throw new Error(`Unsupported behavior: ${propertyAccessExpression.getText()}`);
}
throw new Error(`Unsupported behavior name ${expression.getFullText()}`)
}).filter(name => name.length > 0);
}
}

74
tools/polygerrit-updater/src/funcToClassConversion/legacyPolymerFuncReplacer.ts Normal file

@ -0,0 +1,74 @@
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import * as ts from 'typescript';
import * as codeUtils from '../utils/codeUtils'
import {LegacyPolymerComponent} from './polymerComponentParser';
import {ClassBasedPolymerElement} from './polymerElementBuilder';
export class LegacyPolymerFuncReplaceResult {
public constructor(
private readonly transformationResult: ts.TransformationResult<ts.SourceFile>,
public readonly leadingComments: string[]) {
}
public get file(): ts.SourceFile {
return this.transformationResult.transformed[0];
}
public dispose() {
this.transformationResult.dispose();
}
}
export class LegacyPolymerFuncReplacer {
private readonly callStatement: ts.ExpressionStatement;
private readonly parentBlock: ts.Block;
private readonly callStatementIndexInBlock: number;
public constructor(private readonly legacyComponent: LegacyPolymerComponent) {
this.callStatement = codeUtils.assertNodeKind(legacyComponent.polymerFuncCallExpr.parent, ts.SyntaxKind.ExpressionStatement);
this.parentBlock = codeUtils.assertNodeKind(this.callStatement.parent, ts.SyntaxKind.Block);
this.callStatementIndexInBlock = this.parentBlock.statements.indexOf(this.callStatement);
if(this.callStatementIndexInBlock < 0) {
throw new Error("Internal error! Couldn't find statement in its own parent");
}
}
public replace(classBasedElement: ClassBasedPolymerElement): LegacyPolymerFuncReplaceResult {
const classDeclarationWithComments = this.appendLeadingCommentToClassDeclaration(classBasedElement.classDeclaration);
return new LegacyPolymerFuncReplaceResult(
this.replaceLegacyPolymerFunction(classDeclarationWithComments.classDeclarationWithCommentsPlaceholder, classBasedElement.componentRegistration),
classDeclarationWithComments.leadingComments);
}
private appendLeadingCommentToClassDeclaration(classDeclaration: ts.ClassDeclaration): {classDeclarationWithCommentsPlaceholder: ts.ClassDeclaration, leadingComments: string[]} {
const text = this.callStatement.getFullText();
let classDeclarationWithCommentsPlaceholder = classDeclaration;
const leadingComments: string[] = [];
ts.forEachLeadingCommentRange(text, 0, (pos, end, kind, hasTrailingNewLine) => {
classDeclarationWithCommentsPlaceholder = codeUtils.addReplacableCommentBeforeNode(classDeclarationWithCommentsPlaceholder, String(leadingComments.length));
leadingComments.push(text.substring(pos, end));
});
return {
classDeclarationWithCommentsPlaceholder: classDeclarationWithCommentsPlaceholder,
leadingComments: leadingComments
}
}
private replaceLegacyPolymerFunction(classDeclaration: ts.ClassDeclaration, componentRegistration: ts.ExpressionStatement): ts.TransformationResult<ts.SourceFile> {
const newStatements = Array.from(this.parentBlock.statements);
newStatements.splice(this.callStatementIndexInBlock, 1, classDeclaration, componentRegistration);
const updatedBlock = ts.getMutableClone(this.parentBlock);
updatedBlock.statements = ts.createNodeArray(newStatements);
return codeUtils.replaceNode(this.legacyComponent.parsedFile, this.parentBlock, updatedBlock);
}
}

140
tools/polygerrit-updater/src/funcToClassConversion/lifecycleMethodsBuilder.ts Normal file

@ -0,0 +1,140 @@
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import * as ts from 'typescript';
import * as codeUtils from '../utils/codeUtils';
import {LegacyLifecycleMethodName, OrdinaryMethods} from './polymerComponentParser';
interface LegacyLifecycleMethodContent {
codeAtMethodStart: ts.Statement[];
existingMethod?: ts.MethodDeclaration;
codeAtMethodEnd: ts.Statement[];
}
export interface LifecycleMethod {
originalPos: number;//-1 - no original method exists
method: ts.MethodDeclaration;
name: LegacyLifecycleMethodName;
}
export class LifecycleMethodsBuilder {
private readonly methods: Map<LegacyLifecycleMethodName, LegacyLifecycleMethodContent> = new Map();
private getMethodContent(name: LegacyLifecycleMethodName): LegacyLifecycleMethodContent {
if(!this.methods.has(name)) {
this.methods.set(name, {
codeAtMethodStart: [],
codeAtMethodEnd: []
});
}
return this.methods.get(name)!;
}
public addListeners(legacyListeners: ts.ObjectLiteralExpression, legacyOrdinaryMethods: OrdinaryMethods) {
for(const listener of legacyListeners.properties) {
const propertyAssignment = codeUtils.assertNodeKind(listener, ts.SyntaxKind.PropertyAssignment) as ts.PropertyAssignment;
if(!propertyAssignment.name) {
throw new Error("Listener must have event name");
}
let eventNameLiteral: ts.StringLiteral;
let commentsToRestore: string[] = [];
if(propertyAssignment.name.kind === ts.SyntaxKind.StringLiteral) {
//We don't loose comment in this case, because we keep literal as is
eventNameLiteral = propertyAssignment.name;
} else if(propertyAssignment.name.kind === ts.SyntaxKind.Identifier) {
eventNameLiteral = ts.createStringLiteral(propertyAssignment.name.text);
commentsToRestore = codeUtils.getLeadingComments(propertyAssignment);
} else {
throw new Error(`Unsupported type ${ts.SyntaxKind[propertyAssignment.name.kind]}`);
}
const handlerLiteral = codeUtils.assertNodeKind(propertyAssignment.initializer, ts.SyntaxKind.StringLiteral) as ts.StringLiteral;
const handlerImpl = legacyOrdinaryMethods.get(handlerLiteral.text);
if(!handlerImpl) {
throw new Error(`Can't find event handler '${handlerLiteral.text}'`);
}
const eventHandlerAccess = ts.createPropertyAccess(ts.createThis(), handlerLiteral.text);
//ts.forEachChild(handler)
const args: ts.Identifier[] = handlerImpl.parameters.map((arg) => codeUtils.assertNodeKind(arg.name, ts.SyntaxKind.Identifier));
const eventHandlerCall = ts.createCall(eventHandlerAccess, [], args);
let arrowFunc = ts.createArrowFunction([], [], handlerImpl.parameters, undefined, undefined, eventHandlerCall);
arrowFunc = codeUtils.addNewLineBeforeNode(arrowFunc);
const methodContent = this.getMethodContent("created");
//See https://polymer-library.polymer-project.org/3.0/docs/devguide/gesture-events for a list of events
if(["down", "up", "tap", "track"].indexOf(eventNameLiteral.text) >= 0) {
const methodCall = ts.createCall(codeUtils.createNameExpression("Polymer.Gestures.addListener"), [], [ts.createThis(), eventNameLiteral, arrowFunc]);
methodContent.codeAtMethodEnd.push(ts.createExpressionStatement(methodCall));
}
else {
let methodCall = ts.createCall(ts.createPropertyAccess(ts.createThis(), "addEventListener"), [], [eventNameLiteral, arrowFunc]);
methodCall = codeUtils.restoreLeadingComments(methodCall, commentsToRestore);
methodContent.codeAtMethodEnd.push(ts.createExpressionStatement(methodCall));
}
}
}
public addHostAttributes(legacyHostAttributes: ts.ObjectLiteralExpression) {
for(const listener of legacyHostAttributes.properties) {
const propertyAssignment = codeUtils.assertNodeKind(listener, ts.SyntaxKind.PropertyAssignment) as ts.PropertyAssignment;
if(!propertyAssignment.name) {
throw new Error("Listener must have event name");
}
let attributeNameLiteral: ts.StringLiteral;
if(propertyAssignment.name.kind === ts.SyntaxKind.StringLiteral) {
attributeNameLiteral = propertyAssignment.name;
} else if(propertyAssignment.name.kind === ts.SyntaxKind.Identifier) {
attributeNameLiteral = ts.createStringLiteral(propertyAssignment.name.text);
} else {
throw new Error(`Unsupported type ${ts.SyntaxKind[propertyAssignment.name.kind]}`);
}
let attributeValueLiteral: ts.StringLiteral | ts.NumericLiteral;
if(propertyAssignment.initializer.kind === ts.SyntaxKind.StringLiteral) {
attributeValueLiteral = propertyAssignment.initializer as ts.StringLiteral;
} else if(propertyAssignment.initializer.kind === ts.SyntaxKind.NumericLiteral) {
attributeValueLiteral = propertyAssignment.initializer as ts.NumericLiteral;
} else {
throw new Error(`Unsupported type ${ts.SyntaxKind[propertyAssignment.initializer.kind]}`);
}
const methodCall = ts.createCall(ts.createPropertyAccess(ts.createThis(), "_ensureAttribute"), [], [attributeNameLiteral, attributeValueLiteral]);
this.getMethodContent("ready").codeAtMethodEnd.push(ts.createExpressionStatement(methodCall));
}
}
public addLegacyLifecycleMethod(name: LegacyLifecycleMethodName, method: ts.MethodDeclaration) {
const content = this.getMethodContent(name);
if(content.existingMethod) {
throw new Error(`Legacy lifecycle method ${name} already added`);
}
content.existingMethod = method;
}
public buildNewMethods(): LifecycleMethod[] {
const result = [];
for(const [name, content] of this.methods) {
const newMethod = this.createLifecycleMethod(name, content.existingMethod, content.codeAtMethodStart, content.codeAtMethodEnd);
if(!newMethod) continue;
result.push({
name,
originalPos: content.existingMethod ? content.existingMethod.pos : -1,
method: newMethod
})
}
return result;
}
private createLifecycleMethod(name: string, methodDecl: ts.MethodDeclaration | undefined, codeAtStart: ts.Statement[], codeAtEnd: ts.Statement[]): ts.MethodDeclaration | undefined {
return codeUtils.createMethod(name, methodDecl, codeAtStart, codeAtEnd, true);
}
}

301
tools/polygerrit-updater/src/funcToClassConversion/polymerComponentParser.ts Normal file

@ -0,0 +1,301 @@
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import * as ts from "typescript";
import * as fs from "fs";
import * as path from "path";
import { unexpectedValue } from "../utils/unexpectedValue";
import * as codeUtils from "../utils/codeUtils";
import {CommentsParser} from '../utils/commentsParser';
export class LegacyPolymerComponentParser {
public constructor(private readonly rootDir: string, private readonly htmlFiles: Set<string>) {
}
public async parse(jsFile: string): Promise<ParsedPolymerComponent | null> {
const sourceFile: ts.SourceFile = this.parseJsFile(jsFile);
const legacyComponent = this.tryParseLegacyComponent(sourceFile);
if (legacyComponent) {
return legacyComponent;
}
return null;
}
private parseJsFile(jsFile: string): ts.SourceFile {
return ts.createSourceFile(jsFile, fs.readFileSync(path.resolve(this.rootDir, jsFile)).toString(), ts.ScriptTarget.ES2015, true);
}
private tryParseLegacyComponent(sourceFile: ts.SourceFile): ParsedPolymerComponent | null {
const polymerFuncCalls: ts.CallExpression[] = [];
function addPolymerFuncCall(node: ts.Node) {
if(node.kind === ts.SyntaxKind.CallExpression) {
const callExpression: ts.CallExpression = node as ts.CallExpression;
if(callExpression.expression.kind === ts.SyntaxKind.Identifier) {
const identifier = callExpression.expression as ts.Identifier;
if(identifier.text === "Polymer") {
polymerFuncCalls.push(callExpression);
}
}
}
ts.forEachChild(node, addPolymerFuncCall);
}
addPolymerFuncCall(sourceFile);
if (polymerFuncCalls.length === 0) {
return null;
}
if (polymerFuncCalls.length > 1) {
throw new Error("Each .js file must contain only one Polymer component");
}
const parsedPath = path.parse(sourceFile.fileName);
const htmlFullPath = path.format({
dir: parsedPath.dir,
name: parsedPath.name,
ext: ".html"
});
if (!this.htmlFiles.has(htmlFullPath)) {
throw new Error("Legacy .js component dosn't have associated .html file");
}
const polymerFuncCall = polymerFuncCalls[0];
if(polymerFuncCall.arguments.length !== 1) {
throw new Error("The Polymer function must be called with exactly one parameter");
}
const argument = polymerFuncCall.arguments[0];
if(argument.kind !== ts.SyntaxKind.ObjectLiteralExpression) {
throw new Error("The parameter for Polymer function must be ObjectLiteralExpression (i.e. '{...}')");
}
const infoArg = argument as ts.ObjectLiteralExpression;
return {
jsFile: sourceFile.fileName,
htmlFile: htmlFullPath,
parsedFile: sourceFile,
polymerFuncCallExpr: polymerFuncCalls[0],
componentSettings: this.parseLegacyComponentSettings(infoArg),
};
}
private parseLegacyComponentSettings(info: ts.ObjectLiteralExpression): LegacyPolymerComponentSettings {
const props: Map<string, ts.ObjectLiteralElementLike> = new Map();
for(const property of info.properties) {
const name = property.name;
if (name === undefined) {
throw new Error("Property name is not defined");
}
switch(name.kind) {
case ts.SyntaxKind.Identifier:
case ts.SyntaxKind.StringLiteral:
if (props.has(name.text)) {
throw new Error(`Property ${name.text} appears more than once`);
}
props.set(name.text, property);
break;
case ts.SyntaxKind.ComputedPropertyName:
continue;
default:
unexpectedValue(ts.SyntaxKind[name.kind]);
}
}
if(props.has("_noAccessors")) {
throw new Error("_noAccessors is not supported");
}
const legacyLifecycleMethods: LegacyLifecycleMethods = new Map();
for(const name of LegacyLifecycleMethodsArray) {
const methodDecl = this.getLegacyMethodDeclaration(props, name);
if(methodDecl) {
legacyLifecycleMethods.set(name, methodDecl);
}
}
const ordinaryMethods: OrdinaryMethods = new Map();
const ordinaryShorthandProperties: OrdinaryShorthandProperties = new Map();
const ordinaryGetAccessors: OrdinaryGetAccessors = new Map();
const ordinaryPropertyAssignments: OrdinaryPropertyAssignments = new Map();
for(const [name, val] of props) {
if(RESERVED_NAMES.hasOwnProperty(name)) continue;
switch(val.kind) {
case ts.SyntaxKind.MethodDeclaration:
ordinaryMethods.set(name, val as ts.MethodDeclaration);
break;
case ts.SyntaxKind.ShorthandPropertyAssignment:
ordinaryShorthandProperties.set(name, val as ts.ShorthandPropertyAssignment);
break;
case ts.SyntaxKind.GetAccessor:
ordinaryGetAccessors.set(name, val as ts.GetAccessorDeclaration);
break;
case ts.SyntaxKind.PropertyAssignment:
ordinaryPropertyAssignments.set(name, val as ts.PropertyAssignment);
break;
default:
throw new Error(`Unsupported element kind: ${ts.SyntaxKind[val.kind]}`);
}
//ordinaryMethods.set(name, tsUtils.assertNodeKind(val, ts.SyntaxKind.MethodDeclaration) as ts.MethodDeclaration);
}
const eventsComments: string[] = this.getEventsComments(info.getFullText());
return {
reservedDeclarations: {
is: this.getStringLiteralValueWithComments(this.getLegacyPropertyInitializer(props, "is")),
_legacyUndefinedCheck: this.getBooleanLiteralValueWithComments(this.getLegacyPropertyInitializer(props, "_legacyUndefinedCheck")),
properties: this.getObjectLiteralExpressionWithComments(this.getLegacyPropertyInitializer(props, "properties")),
behaviors: this.getArrayLiteralExpressionWithComments(this.getLegacyPropertyInitializer(props, "behaviors")),
observers: this.getArrayLiteralExpressionWithComments(this.getLegacyPropertyInitializer(props, "observers")),
listeners: this.getObjectLiteralExpressionWithComments(this.getLegacyPropertyInitializer(props, "listeners")),
hostAttributes: this.getObjectLiteralExpressionWithComments(this.getLegacyPropertyInitializer(props, "hostAttributes")),
keyBindings: this.getObjectLiteralExpressionWithComments(this.getLegacyPropertyInitializer(props, "keyBindings")),
},
eventsComments: eventsComments,
lifecycleMethods: legacyLifecycleMethods,
ordinaryMethods: ordinaryMethods,
ordinaryShorthandProperties: ordinaryShorthandProperties,
ordinaryGetAccessors: ordinaryGetAccessors,
ordinaryPropertyAssignments: ordinaryPropertyAssignments,
};
}
private convertLegacyProeprtyInitializer<T>(initializer: LegacyPropertyInitializer | undefined, converter: (exp: ts.Expression) => T): DataWithComments<T> | undefined {
if(!initializer) {
return undefined;
}
return {
data: converter(initializer.data),
leadingComments: initializer.leadingComments,
}
}
private getObjectLiteralExpressionWithComments(initializer: LegacyPropertyInitializer | undefined): DataWithComments<ts.ObjectLiteralExpression> | undefined {
return this.convertLegacyProeprtyInitializer(initializer,
expr => codeUtils.getObjectLiteralExpression(expr));
}
private getStringLiteralValueWithComments(initializer: LegacyPropertyInitializer | undefined): DataWithComments<string> | undefined {
return this.convertLegacyProeprtyInitializer(initializer,
expr => codeUtils.getStringLiteralValue(expr));
}
private getBooleanLiteralValueWithComments(initializer: LegacyPropertyInitializer | undefined): DataWithComments<boolean> | undefined {
return this.convertLegacyProeprtyInitializer(initializer,
expr => codeUtils.getBooleanLiteralValue(expr));
}
private getArrayLiteralExpressionWithComments(initializer: LegacyPropertyInitializer | undefined): DataWithComments<ts.ArrayLiteralExpression> | undefined {
return this.convertLegacyProeprtyInitializer(initializer,
expr => codeUtils.getArrayLiteralExpression(expr));
}
private getLegacyPropertyInitializer(props: Map<String, ts.ObjectLiteralElementLike>, propName: string): LegacyPropertyInitializer | undefined {
const property = props.get(propName);
if (!property) {
return undefined;
}
const assignment = codeUtils.getPropertyAssignment(property);
if (!assignment) {
return undefined;
}
const comments: string[] = codeUtils.getLeadingComments(property)
.filter(c => !this.isEventComment(c));
return {
data: assignment.initializer,
leadingComments: comments,
};
}
private isEventComment(comment: string): boolean {
return comment.indexOf('@event') >= 0;
}
private getEventsComments(polymerComponentSource: string): string[] {
return CommentsParser.collectAllComments(polymerComponentSource)
.filter(c => this.isEventComment(c));
}
private getLegacyMethodDeclaration(props: Map<String, ts.ObjectLiteralElementLike>, propName: string): ts.MethodDeclaration | undefined {
const property = props.get(propName);
if (!property) {
return undefined;
}
return codeUtils.assertNodeKind(property, ts.SyntaxKind.MethodDeclaration) as ts.MethodDeclaration;
}
}
export type ParsedPolymerComponent = LegacyPolymerComponent;
export interface LegacyPolymerComponent {
jsFile: string;
htmlFile: string;
parsedFile: ts.SourceFile;
polymerFuncCallExpr: ts.CallExpression;
componentSettings: LegacyPolymerComponentSettings;
}
export interface LegacyReservedDeclarations {
is?: DataWithComments<string>;
_legacyUndefinedCheck?: DataWithComments<boolean>;
properties?: DataWithComments<ts.ObjectLiteralExpression>;
behaviors?: DataWithComments<ts.ArrayLiteralExpression>,
observers? :DataWithComments<ts.ArrayLiteralExpression>,
listeners? :DataWithComments<ts.ObjectLiteralExpression>,
hostAttributes?: DataWithComments<ts.ObjectLiteralExpression>,
keyBindings?: DataWithComments<ts.ObjectLiteralExpression>,
}
export const LegacyLifecycleMethodsArray = <const>["beforeRegister", "registered", "created", "ready", "attached" , "detached", "attributeChanged"];
export type LegacyLifecycleMethodName = typeof LegacyLifecycleMethodsArray[number];
export type LegacyLifecycleMethods = Map<LegacyLifecycleMethodName, ts.MethodDeclaration>;
export type OrdinaryMethods = Map<string, ts.MethodDeclaration>;
export type OrdinaryShorthandProperties = Map<string, ts.ShorthandPropertyAssignment>;
export type OrdinaryGetAccessors = Map<string, ts.GetAccessorDeclaration>;
export type OrdinaryPropertyAssignments = Map<string, ts.PropertyAssignment>;
export type ReservedName = LegacyLifecycleMethodName | keyof LegacyReservedDeclarations;
export const RESERVED_NAMES: {[x in ReservedName]: boolean} = {
attached: true,
detached: true,
ready: true,
created: true,
beforeRegister: true,
registered: true,
attributeChanged: true,
is: true,
_legacyUndefinedCheck: true,
properties: true,
behaviors: true,
observers: true,
listeners: true,
hostAttributes: true,
keyBindings: true,
};
export interface LegacyPolymerComponentSettings {
reservedDeclarations: LegacyReservedDeclarations;
lifecycleMethods: LegacyLifecycleMethods,
ordinaryMethods: OrdinaryMethods,
ordinaryShorthandProperties: OrdinaryShorthandProperties,
ordinaryGetAccessors: OrdinaryGetAccessors,
ordinaryPropertyAssignments: OrdinaryPropertyAssignments,
eventsComments: string[];
}
export interface DataWithComments<T> {
data: T;
leadingComments: string[];
}
type LegacyPropertyInitializer = DataWithComments<ts.Expression>;

142
tools/polygerrit-updater/src/funcToClassConversion/polymerElementBuilder.ts Normal file

@ -0,0 +1,142 @@
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import {DataWithComments, LegacyPolymerComponent, LegacyReservedDeclarations, OrdinaryGetAccessors, OrdinaryMethods, OrdinaryPropertyAssignments, OrdinaryShorthandProperties} from './polymerComponentParser';
import * as ts from 'typescript';
import * as codeUtils from '../utils/codeUtils';
import {LifecycleMethod} from './lifecycleMethodsBuilder';
import {PolymerClassBuilder} from '../utils/polymerClassBuilder';
import {SyntaxKind} from 'typescript';
export interface ClassBasedPolymerElement {
classDeclaration: ts.ClassDeclaration;
componentRegistration: ts.ExpressionStatement;
eventsComments: string[];
generatedComments: string[];
}
export class PolymerElementBuilder {
private readonly reservedDeclarations: LegacyReservedDeclarations;
private readonly classBuilder: PolymerClassBuilder;
private mixins: ts.ExpressionWithTypeArguments | null;
public constructor(private readonly legacyComponent: LegacyPolymerComponent, className: string) {
this.reservedDeclarations = legacyComponent.componentSettings.reservedDeclarations;
this.classBuilder = new PolymerClassBuilder(className);
this.mixins = null;
}
public addIsAccessor(tagName: string) {
this.classBuilder.addIsAccessor(this.createIsAccessor(tagName));
}
public addPolymerPropertiesAccessor(legacyProperties: DataWithComments<ts.ObjectLiteralExpression>) {
const returnStatement = ts.createReturn(legacyProperties.data);
const block = ts.createBlock([returnStatement]);
let propertiesAccessor = ts.createGetAccessor(undefined, [ts.createModifier(ts.SyntaxKind.StaticKeyword)], "properties", [], undefined, block);
if(legacyProperties.leadingComments.length > 0) {
propertiesAccessor = codeUtils.restoreLeadingComments(propertiesAccessor, legacyProperties.leadingComments);
}
this.classBuilder.addPolymerPropertiesAccessor(legacyProperties.data.pos, propertiesAccessor);
}
public addPolymerPropertiesObservers(legacyObservers: ts.ArrayLiteralExpression) {
const returnStatement = ts.createReturn(legacyObservers);
const block = ts.createBlock([returnStatement]);
const propertiesAccessor = ts.createGetAccessor(undefined, [ts.createModifier(ts.SyntaxKind.StaticKeyword)], "observers", [], undefined, block);
this.classBuilder.addPolymerObserversAccessor(legacyObservers.pos, propertiesAccessor);
}
public addKeyBindings(keyBindings: ts.ObjectLiteralExpression) {
//In Polymer 2 keyBindings must be a property with get accessor
const returnStatement = ts.createReturn(keyBindings);
const block = ts.createBlock([returnStatement]);
const keyBindingsAccessor = ts.createGetAccessor(undefined, [], "keyBindings", [], undefined, block);
this.classBuilder.addGetAccessor(keyBindings.pos, keyBindingsAccessor);
}
public addOrdinaryMethods(ordinaryMethods: OrdinaryMethods) {
for(const [name, method] of ordinaryMethods) {
this.classBuilder.addMethod(method.pos, method);
}
}
public addOrdinaryGetAccessors(ordinaryGetAccessors: OrdinaryGetAccessors) {
for(const [name, accessor] of ordinaryGetAccessors) {
this.classBuilder.addGetAccessor(accessor.pos, accessor);
}
}
public addOrdinaryShorthandProperties(ordinaryShorthandProperties: OrdinaryShorthandProperties) {
for (const [name, property] of ordinaryShorthandProperties) {
this.classBuilder.addClassFieldInitializer(property.name, property.name);
}
}
public addOrdinaryPropertyAssignments(ordinaryPropertyAssignments: OrdinaryPropertyAssignments) {
for (const [name, property] of ordinaryPropertyAssignments) {
const propertyName = codeUtils.assertNodeKind(property.name, ts.SyntaxKind.Identifier) as ts.Identifier;
this.classBuilder.addClassFieldInitializer(propertyName, property.initializer);
}
}
public addMixin(name: string, mixinArguments?: ts.Expression[]) {
let fullMixinArguments: ts.Expression[] = [];
if(mixinArguments) {
fullMixinArguments.push(...mixinArguments);
}
if(this.mixins) {
fullMixinArguments.push(this.mixins.expression);
}
if(fullMixinArguments.length > 0) {
this.mixins = ts.createExpressionWithTypeArguments([], ts.createCall(codeUtils.createNameExpression(name), [], fullMixinArguments.length > 0 ? fullMixinArguments : undefined));
}
else {
this.mixins = ts.createExpressionWithTypeArguments([], codeUtils.createNameExpression(name));
}
}
public addClassJSDocComments(lines: string[]) {
this.classBuilder.addClassJSDocComments(lines);
}
public build(): ClassBasedPolymerElement {
if(this.mixins) {
this.classBuilder.setBaseType(this.mixins);
}
const className = this.classBuilder.className;
const callExpression = ts.createCall(ts.createPropertyAccess(ts.createIdentifier("customElements"), "define"), undefined, [ts.createPropertyAccess(ts.createIdentifier(className), "is"), ts.createIdentifier(className)]);
const classBuilderResult = this.classBuilder.build();
return {
classDeclaration: classBuilderResult.classDeclaration,
generatedComments: classBuilderResult.generatedComments,
componentRegistration: ts.createExpressionStatement(callExpression),
eventsComments: this.legacyComponent.componentSettings.eventsComments,
};
}
private createIsAccessor(tagName: string): ts.GetAccessorDeclaration {
const returnStatement = ts.createReturn(ts.createStringLiteral(tagName));
const block = ts.createBlock([returnStatement]);
const accessor = ts.createGetAccessor([], [ts.createModifier(ts.SyntaxKind.StaticKeyword)], "is", [], undefined, block);
return codeUtils.addReplacableCommentAfterNode(accessor, "eventsComments");
}
public addLifecycleMethods(newLifecycleMethods: LifecycleMethod[]) {
for(const lifecycleMethod of newLifecycleMethods) {
this.classBuilder.addLifecycleMethod(lifecycleMethod.name, lifecycleMethod.originalPos, lifecycleMethod.method);
}
}
}

248
tools/polygerrit-updater/src/funcToClassConversion/updatedFileWriter.ts Normal file

@ -0,0 +1,248 @@
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import {LegacyPolymerComponent} from './polymerComponentParser';
import * as ts from 'typescript';
import * as codeUtils from '../utils/codeUtils';
import * as path from "path";
import * as fs from "fs";
import {LegacyPolymerFuncReplaceResult} from './legacyPolymerFuncReplacer';
import {CommentsParser} from '../utils/commentsParser';
export interface UpdatedFileWriterParameters {
out: string;
inplace: boolean;
writeOutput: boolean;
rootDir: string;
}
interface Replacement {
start: number;
length: number;
newText: string;
}
const elementRegistrationRegex = /^(\s*)customElements.define\((\w+).is, \w+\);$/m;
const maxLineLength = 80;
export class UpdatedFileWriter {
public constructor(private readonly component: LegacyPolymerComponent, private readonly params: UpdatedFileWriterParameters) {
}
public write(replaceResult: LegacyPolymerFuncReplaceResult, eventsComments: string[], generatedComments: string[]) {
const options: ts.PrinterOptions = {
removeComments: false,
newLine: ts.NewLineKind.LineFeed,
};
const printer = ts.createPrinter(options);
let newContent = codeUtils.applyNewLines(printer.printFile(replaceResult.file));
//ts printer doesn't keep original formatting of the file (spacing, new lines, comments, etc...).
//The following code tries restore original formatting
const existingComments = this.collectAllComments(newContent, []);
newContent = this.restoreEventsComments(newContent, eventsComments, existingComments);
newContent = this.restoreLeadingComments(newContent, replaceResult.leadingComments);
newContent = this.restoreFormating(printer, newContent);
newContent = this.splitLongLines(newContent);
newContent = this.addCommentsWarnings(newContent, generatedComments);
if (this.params.writeOutput) {
const outDir = this.params.inplace ? this.params.rootDir : this.params.out;
const fullOutPath = path.resolve(outDir, this.component.jsFile);
const fullOutDir = path.dirname(fullOutPath);
if (!fs.existsSync(fullOutDir)) {
fs.mkdirSync(fullOutDir, {
recursive: true,
mode: fs.lstatSync(this.params.rootDir).mode
});
}
fs.writeFileSync(fullOutPath, newContent);
}
}
private restoreEventsComments(content: string, eventsComments: string[], existingComments: Map<string, number>): string {
//In some cases Typescript compiler keep existing comments. These comments
// must not be restored here
eventsComments = eventsComments.filter(c => !existingComments.has(this.getNormalizedComment(c)));
return codeUtils.replaceComment(content, "eventsComments", "\n" + eventsComments.join("\n\n") + "\n");
}
private restoreLeadingComments(content: string, leadingComments: string[]): string {
return leadingComments.reduce(
(newContent, comment, commentIndex) =>
codeUtils.replaceComment(newContent, String(commentIndex), comment),
content);
}
private restoreFormating(printer: ts.Printer, newContent: string): string {
const originalFile = this.component.parsedFile;
const newFile = ts.createSourceFile(originalFile.fileName, newContent, originalFile.languageVersion, true, ts.ScriptKind.JS);
const textMap = new Map<ts.SyntaxKind, Map<string, Set<string>>>();
const comments = new Set<string>();
this.collectAllStrings(printer, originalFile, textMap);
const replacements: Replacement[] = [];
this.collectReplacements(printer, newFile, textMap, replacements);
replacements.sort((a, b) => b.start - a.start);
let result = newFile.getFullText();
let prevReplacement: Replacement | null = null;
for (const replacement of replacements) {
if (prevReplacement) {
if (replacement.start + replacement.length > prevReplacement.start) {
throw new Error('Internal error! Replacements must not intersect');
}
}
result = result.substring(0, replacement.start) + replacement.newText + result.substring(replacement.start + replacement.length);
prevReplacement = replacement;
}
return result;
}
private splitLongLines(content: string): string {
content = content.replace(elementRegistrationRegex, (match, indent, className) => {
if (match.length > maxLineLength) {
return `${indent}customElements.define(${className}.is,\n` +
`${indent} ${className});`;
}
else {
return match;
}
});
return content
.replace(
"Polymer.LegacyDataMixin(Polymer.GestureEventListeners(Polymer.LegacyElementMixin(Polymer.Element)))",
"Polymer.LegacyDataMixin(\nPolymer.GestureEventListeners(\nPolymer.LegacyElementMixin(\nPolymer.Element)))")
.replace(
"Polymer.GestureEventListeners(Polymer.LegacyElementMixin(Polymer.Element))",
"Polymer.GestureEventListeners(\nPolymer.LegacyElementMixin(\nPolymer.Element))");
}
private addCommentsWarnings(newContent: string, generatedComments: string[]): string {
const expectedComments = this.collectAllComments(this.component.parsedFile.getFullText(), generatedComments);
const newComments = this.collectAllComments(newContent, []);
const commentsWarnings = [];
for (const [text, count] of expectedComments) {
const newCount = newComments.get(text);
if (!newCount) {
commentsWarnings.push(`Comment '${text}' is missing in the new content.`);
}
else if (newCount != count) {
commentsWarnings.push(`Comment '${text}' appears ${newCount} times in the new file and ${count} times in the old file.`);
}
}
for (const [text, newCount] of newComments) {
if (!expectedComments.has(text)) {
commentsWarnings.push(`Comment '${text}' appears only in the new content`);
}
}
if (commentsWarnings.length === 0) {
return newContent;
}
let commentsProblemStr = "";
if (commentsWarnings.length > 0) {
commentsProblemStr = commentsWarnings.join("-----------------------------\n");
console.log(commentsProblemStr);
}
return "//This file has the following problems with comments:\n" + commentsProblemStr + "\n" + newContent;
}
private collectAllComments(content: string, additionalComments: string[]): Map<string, number> {
const comments = CommentsParser.collectAllComments(content);
comments.push(...additionalComments);
const result = new Map<string, number>();
for (const comment of comments) {
let normalizedComment = this.getNormalizedComment(comment);
const count = result.get(normalizedComment);
if (count) {
result.set(normalizedComment, count + 1);
} else {
result.set(normalizedComment, 1);
}
}
return result;
}
private getNormalizedComment(comment: string): string {
if(comment.startsWith('/**')) {
comment = comment.replace(/^\s+\*/gm, "*");
}
return comment;
}
private collectAllStrings(printer: ts.Printer, node: ts.Node, map: Map<ts.SyntaxKind, Map<string, Set<string>>>) {
const formattedText = printer.printNode(ts.EmitHint.Unspecified, node, node.getSourceFile())
const originalText = node.getFullText();
this.addIfNotExists(map, node.kind, formattedText, originalText);
ts.forEachChild(node, child => this.collectAllStrings(printer, child, map));
}
private collectReplacements(printer: ts.Printer, node: ts.Node, map: Map<ts.SyntaxKind, Map<string, Set<string>>>, replacements: Replacement[]) {
if(node.kind === ts.SyntaxKind.ThisKeyword || node.kind === ts.SyntaxKind.Identifier || node.kind === ts.SyntaxKind.StringLiteral || node.kind === ts.SyntaxKind.NumericLiteral) {
return;
}
const replacement = this.getReplacement(printer, node, map);
if(replacement) {
replacements.push(replacement);
return;
}
ts.forEachChild(node, child => this.collectReplacements(printer, child, map, replacements));
}
private addIfNotExists(map: Map<ts.SyntaxKind, Map<string, Set<string>>>, kind: ts.SyntaxKind, formattedText: string, originalText: string) {
let mapForKind = map.get(kind);
if(!mapForKind) {
mapForKind = new Map();
map.set(kind, mapForKind);
}
let existingOriginalText = mapForKind.get(formattedText);
if(!existingOriginalText) {
existingOriginalText = new Set<string>();
mapForKind.set(formattedText, existingOriginalText);
//throw new Error(`Different formatting of the same string exists. Kind: ${ts.SyntaxKind[kind]}.\nFormatting 1:\n${originalText}\nFormatting2:\n${existingOriginalText}\n `);
}
existingOriginalText.add(originalText);
}
private getReplacement(printer: ts.Printer, node: ts.Node, map: Map<ts.SyntaxKind, Map<string, Set<string>>>): Replacement | undefined {
const replacementsForKind = map.get(node.kind);
if(!replacementsForKind) {
return;
}
// Use printer instead of getFullText to "isolate" node content.
// node.getFullText returns text with indents from the original file.
const newText = printer.printNode(ts.EmitHint.Unspecified, node, node.getSourceFile());
const originalSet = replacementsForKind.get(newText);
if(!originalSet || originalSet.size === 0) {
return;
}
if(originalSet.size >= 2) {
console.log(`Multiple replacements possible. Formatting of some lines can be changed`);
}
const replacementText: string = originalSet.values().next().value;
const nodeText = node.getFullText();
return {
start: node.pos,
length: nodeText.length,//Do not use newText here!
newText: replacementText,
}
}
}

168
tools/polygerrit-updater/src/index.ts Normal file

@ -0,0 +1,168 @@
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import * as fs from "fs";
import * as path from "path";
import {LegacyPolymerComponent, LegacyPolymerComponentParser} from './funcToClassConversion/polymerComponentParser';
import {ClassBasedPolymerElement} from './funcToClassConversion/polymerElementBuilder';
import {PolymerFuncToClassBasedConverter} from './funcToClassConversion/funcToClassBasedElementConverter';
import {LegacyPolymerFuncReplacer} from './funcToClassConversion/legacyPolymerFuncReplacer';
import {UpdatedFileWriter} from './funcToClassConversion/updatedFileWriter';
import {CommandLineParser} from './utils/commandLineParser';
interface UpdaterParameters {
htmlFiles: Set<string>;
jsFiles: Set<string>;
out: string;
inplace: boolean;
writeOutput: boolean;
rootDir: string;
}
interface InputFilesFilter {
includeDir(path: string): boolean;
includeFile(path: string): boolean;
}
function addFile(filePath: string, params: UpdaterParameters, filter: InputFilesFilter) {
const parsedPath = path.parse(filePath);
const ext = parsedPath.ext.toLowerCase();
const relativePath = path.relative(params.rootDir, filePath);
if(!filter.includeFile(relativePath)) return;
if(relativePath.startsWith("../")) {
throw new Error(`${filePath} is not in rootDir ${params.rootDir}`);
}
if(ext === ".html") {
params.htmlFiles.add(relativePath);
} if(ext === ".js") {
params.jsFiles.add(relativePath);
}
}
function addDirectory(dirPath: string, params: UpdaterParameters, recursive: boolean, filter: InputFilesFilter): void {
const entries = fs.readdirSync(dirPath, {withFileTypes: true});
for(const entry of entries) {
const dirEnt = entry as fs.Dirent;
const fullPath = path.join(dirPath, dirEnt.name);
const relativePath = path.relative(params.rootDir, fullPath);
if(dirEnt.isDirectory()) {
if (!filter.includeDir(relativePath)) continue;
if(recursive) {
addDirectory(fullPath, params, recursive, filter);
}
}
else if(dirEnt.isFile()) {
addFile(fullPath, params, filter);
} else {
throw Error(`Unsupported dir entry '${entry.name}' in '${fullPath}'`);
}
}
}
async function updateLegacyComponent(component: LegacyPolymerComponent, params: UpdaterParameters) {
const classBasedElement: ClassBasedPolymerElement = PolymerFuncToClassBasedConverter.convert(component);
const replacer = new LegacyPolymerFuncReplacer(component);
const replaceResult = replacer.replace(classBasedElement);
try {
const writer = new UpdatedFileWriter(component, params);
writer.write(replaceResult, classBasedElement.eventsComments, classBasedElement.generatedComments);
}
finally {
replaceResult.dispose();
}
}
async function main() {
const params: UpdaterParameters = await getParams();
if(params.jsFiles.size === 0) {
console.log("No files found");
return;
}
const legacyPolymerComponentParser = new LegacyPolymerComponentParser(params.rootDir, params.htmlFiles)
for(const jsFile of params.jsFiles) {
console.log(`Processing ${jsFile}`);
const legacyComponent = await legacyPolymerComponentParser.parse(jsFile);
if(legacyComponent) {
await updateLegacyComponent(legacyComponent, params);
continue;
}
}
}
interface CommandLineParameters {
src: string[];
recursive: boolean;
excludes: string[];
out: string;
inplace: boolean;
noOutput: boolean;
rootDir: string;
}
async function getParams(): Promise<UpdaterParameters> {
const parser = new CommandLineParser({
src: CommandLineParser.createStringArrayOption("src", ".js file or folder to process", []),
recursive: CommandLineParser.createBooleanOption("r", "process folder recursive", false),
excludes: CommandLineParser.createStringArrayOption("exclude", "List of file prefixes to exclude. If relative file path starts with one of the prefixes, it will be excluded", []),
out: CommandLineParser.createStringOption("out", "Output folder.", null),
rootDir: CommandLineParser.createStringOption("root", "Root directory for src files", "/"),
inplace: CommandLineParser.createBooleanOption("i", "Update files inplace", false),
noOutput: CommandLineParser.createBooleanOption("noout", "Do everything, but do not write anything to files", false),
});
const commandLineParams: CommandLineParameters = parser.parse(process.argv) as CommandLineParameters;
const params: UpdaterParameters = {
htmlFiles: new Set(),
jsFiles: new Set(),
writeOutput: !commandLineParams.noOutput,
inplace: commandLineParams.inplace,
out: commandLineParams.out,
rootDir: path.resolve(commandLineParams.rootDir)
};
if(params.writeOutput && !params.inplace && !params.out) {
throw new Error("You should specify output directory (--out directory_name)");
}
const filter = new ExcludeFilesFilter(commandLineParams.excludes);
for(const srcPath of commandLineParams.src) {
const resolvedPath = path.resolve(params.rootDir, srcPath);
if(fs.lstatSync(resolvedPath).isFile()) {
addFile(resolvedPath, params, filter);
} else {
addDirectory(resolvedPath, params, commandLineParams.recursive, filter);
}
}
return params;
}
class ExcludeFilesFilter implements InputFilesFilter {
public constructor(private readonly excludes: string[]) {
}
includeDir(path: string): boolean {
return this.excludes.every(exclude => !path.startsWith(exclude));
}
includeFile(path: string): boolean {
return this.excludes.every(exclude => !path.startsWith(exclude));
}
}
main().then(() => {
process.exit(0);
}).catch(e => {
console.error(e);
process.exit(1);
});

183
tools/polygerrit-updater/src/utils/codeUtils.ts Normal file

@ -0,0 +1,183 @@
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import * as ts from 'typescript';
import {SyntaxKind} from 'typescript';
import {Node} from 'typescript';
export function assertNodeKind<T extends U, U extends ts.Node>(node: U, expectedKind: ts.SyntaxKind): T {
if (node.kind !== expectedKind) {
throw new Error(`Invlid node kind. Expected: ${ts.SyntaxKind[expectedKind]}, actual: ${ts.SyntaxKind[node.kind]}`);
}
return node as T;
}
export function assertNodeKindOrUndefined<T extends U, U extends ts.Node>(node: U | undefined, expectedKind: ts.SyntaxKind): T | undefined {
if (!node) {
return undefined;
}
return assertNodeKind<T, U>(node, expectedKind);
}
export function getPropertyAssignment(expression?: ts.ObjectLiteralElementLike): ts.PropertyAssignment | undefined {
return assertNodeKindOrUndefined(expression, ts.SyntaxKind.PropertyAssignment);
}
export function getStringLiteralValue(expression: ts.Expression): string {
const literal: ts.StringLiteral = assertNodeKind(expression, ts.SyntaxKind.StringLiteral);
return literal.text;
}
export function getBooleanLiteralValue(expression: ts.Expression): boolean {
if (expression.kind === ts.SyntaxKind.TrueKeyword) {
return true;
}
if (expression.kind === ts.SyntaxKind.FalseKeyword) {
return false;
}
throw new Error(`Invalid expression kind - ${expression.kind}`);
}
export function getObjectLiteralExpression(expression: ts.Expression): ts.ObjectLiteralExpression {
return assertNodeKind(expression, ts.SyntaxKind.ObjectLiteralExpression);
}
export function getArrayLiteralExpression(expression: ts.Expression): ts.ArrayLiteralExpression {
return assertNodeKind(expression, ts.SyntaxKind.ArrayLiteralExpression);
}
export function replaceNode(file: ts.SourceFile, originalNode: ts.Node, newNode: ts.Node): ts.TransformationResult<ts.SourceFile> {
const nodeReplacerTransformer: ts.TransformerFactory<ts.SourceFile> = (context: ts.TransformationContext) => {
const visitor: ts.Visitor = (node) => {
if(node === originalNode) {
return newNode;
}
return ts.visitEachChild(node, visitor, context);
};
return source => ts.visitNode(source, visitor);
};
return ts.transform(file, [nodeReplacerTransformer]);
}
export type NameExpression = ts.Identifier | ts.ThisExpression | ts.PropertyAccessExpression;
export function createNameExpression(fullPath: string): NameExpression {
const parts = fullPath.split(".");
let result: NameExpression = parts[0] === "this" ? ts.createThis() : ts.createIdentifier(parts[0]);
for(let i = 1; i < parts.length; i++) {
result = ts.createPropertyAccess(result, parts[i]);
}
return result;
}
const generatedCommentNewLineAfterText = "-Generated code - new line after - 9cb292bc-5d88-4c5e-88f4-49535c93beb9 -";
const generatedCommentNewLineBeforeText = "-Generated code - new line-before - 9cb292bc-5d88-4c5e-88f4-49535c93beb9 -";
const generatedCommentNewLineAfterRegExp = new RegExp("//" + generatedCommentNewLineAfterText, 'g');
const generatedCommentNewLineBeforeRegExp = new RegExp("//" + generatedCommentNewLineBeforeText + "\n", 'g');
const replacableCommentText = "- Replacepoint - 9cb292bc-5d88-4c5e-88f4-49535c93beb9 -";
export function addNewLineAfterNode<T extends ts.Node>(node: T): T {
const comment = ts.getSyntheticTrailingComments(node);
if(comment && comment.some(c => c.text === generatedCommentNewLineAfterText)) {
return node;
}
return ts.addSyntheticTrailingComment(node, ts.SyntaxKind.SingleLineCommentTrivia, generatedCommentNewLineAfterText, true);
}
export function addNewLineBeforeNode<T extends ts.Node>(node: T): T {
const comment = ts.getSyntheticLeadingComments(node);
if(comment && comment.some(c => c.text === generatedCommentNewLineBeforeText)) {
return node;
}
return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.SingleLineCommentTrivia, generatedCommentNewLineBeforeText, true);
}
export function applyNewLines(text: string): string {
return text.replace(generatedCommentNewLineAfterRegExp, "").replace(generatedCommentNewLineBeforeRegExp, "");
}
export function addReplacableCommentAfterNode<T extends ts.Node>(node: T, name: string): T {
return ts.addSyntheticTrailingComment(node, ts.SyntaxKind.SingleLineCommentTrivia, replacableCommentText + name, true);
}
export function addReplacableCommentBeforeNode<T extends ts.Node>(node: T, name: string): T {
return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.SingleLineCommentTrivia, replacableCommentText + name, true);
}
export function replaceComment(text: string, commentName: string, newContent: string): string {
return text.replace("//" + replacableCommentText + commentName, newContent);
}
export function createMethod(name: string, methodDecl: ts.MethodDeclaration | undefined, codeAtStart: ts.Statement[], codeAtEnd: ts.Statement[], callSuperMethod: boolean): ts.MethodDeclaration | undefined {
if(!methodDecl && (codeAtEnd.length > 0 || codeAtEnd.length > 0)) {
methodDecl = ts.createMethod([], [], undefined, name, undefined, [], [],undefined, ts.createBlock([]));
}
if(!methodDecl) {
return;
}
if (!methodDecl.body) {
throw new Error("Method must have a body");
}
if(methodDecl.parameters.length > 0) {
throw new Error("Methods with parameters are not supported");
}
let newStatements = [...codeAtStart];
if(callSuperMethod) {
const superCall: ts.CallExpression = ts.createCall(ts.createPropertyAccess(ts.createSuper(), assertNodeKind(methodDecl.name, ts.SyntaxKind.Identifier) as ts.Identifier), [], []);
const superCallExpression = ts.createExpressionStatement(superCall);
newStatements.push(superCallExpression);
}
newStatements.push(...codeAtEnd);
const newBody = ts.getMutableClone(methodDecl.body);
newStatements = newStatements.map(m => addNewLineAfterNode(m));
newStatements.splice(codeAtStart.length + 1, 0, ...newBody.statements);
newBody.statements = ts.createNodeArray(newStatements);
const newMethod = ts.getMutableClone(methodDecl);
newMethod.body = newBody;
return newMethod;
}
export function restoreLeadingComments<T extends Node>(node: T, originalComments: string[]): T {
if(originalComments.length === 0) {
return node;
}
for(const comment of originalComments) {
if(comment.startsWith("//")) {
node = ts.addSyntheticLeadingComment(node, SyntaxKind.SingleLineCommentTrivia, comment.substr(2), true);
} else if(comment.startsWith("/*")) {
if(!comment.endsWith("*/")) {
throw new Error(`Not support comment: ${comment}`);
}
node = ts.addSyntheticLeadingComment(node, SyntaxKind.MultiLineCommentTrivia, comment.substr(2, comment.length - 4), true);
} else {
throw new Error(`Not supported comment: ${comment}`);
}
}
return node;
}
export function getLeadingComments(node: ts.Node): string[] {
const nodeText = node.getFullText();
const commentRanges = ts.getLeadingCommentRanges(nodeText, 0);
if(!commentRanges) {
return [];
}
return commentRanges.map(range => nodeText.substring(range.pos, range.end))
}

134
tools/polygerrit-updater/src/utils/commandLineParser.ts Normal file

@ -0,0 +1,134 @@
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed un der the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
export class CommandLineParser {
public static createStringArrayOption(optionName: string, help: string, defaultValue: string[]): CommandLineArgument {
return new StringArrayOption(optionName, help, defaultValue);
}
public static createBooleanOption(optionName: string, help: string, defaultValue: boolean): CommandLineArgument {
return new BooleanOption(optionName, help, defaultValue);
}
public static createStringOption(optionName: string, help: string, defaultValue: string | null): CommandLineArgument {
return new StringOption(optionName, help, defaultValue);
}
public constructor(private readonly argumentTypes: {[name: string]: CommandLineArgument}) {
}
public parse(argv: string[]): object {
const result = Object.assign({});
let index = 2; //argv[0] - node interpreter, argv[1] - index.js
for(const argumentField in this.argumentTypes) {
result[argumentField] = this.argumentTypes[argumentField].getDefaultValue();
}
while(index < argv.length) {
let knownArgument = false;
for(const argumentField in this.argumentTypes) {
const argumentType = this.argumentTypes[argumentField];
const argumentValue = argumentType.tryRead(argv, index);
if(argumentValue) {
knownArgument = true;
index += argumentValue.consumed;
result[argumentField] = argumentValue.value;
break;
}
}
if(!knownArgument) {
throw new Error(`Unknown argument ${argv[index]}`);
}
}
return result;
}
}
interface CommandLineArgumentReadResult {
consumed: number;
value: any;
}
export interface CommandLineArgument {
getDefaultValue(): any;
tryRead(argv: string[], startIndex: number): CommandLineArgumentReadResult | null;
}
abstract class CommandLineOption implements CommandLineArgument {
protected constructor(protected readonly optionName: string, protected readonly help: string, private readonly defaultValue: any) {
}
public tryRead(argv: string[], startIndex: number): CommandLineArgumentReadResult | null {
if(argv[startIndex] !== "--" + this.optionName) {
return null;
}
const readArgumentsResult = this.readArguments(argv, startIndex + 1);
if(!readArgumentsResult) {
return null;
}
readArgumentsResult.consumed++; // Add option name
return readArgumentsResult;
}
public getDefaultValue(): any {
return this.defaultValue;
}
protected abstract readArguments(argv: string[], startIndex: number) : CommandLineArgumentReadResult | null;
}
class StringArrayOption extends CommandLineOption {
public constructor(optionName: string, help: string, defaultValue: string[]) {
super(optionName, help, defaultValue);
}
protected readArguments(argv: string[], startIndex: number): CommandLineArgumentReadResult {
const result = [];
let index = startIndex;
while(index < argv.length) {
if(argv[index].startsWith("--")) {
break;
}
result.push(argv[index]);
index++;
}
return {
consumed: index - startIndex,
value: result
}
}
}
class BooleanOption extends CommandLineOption {
public constructor(optionName: string, help: string, defaultValue: boolean) {
super(optionName, help, defaultValue);
}
protected readArguments(argv: string[], startIndex: number): CommandLineArgumentReadResult {
return {
consumed: 0,
value: true
}
}
}
class StringOption extends CommandLineOption {
public constructor(optionName: string, help: string, defaultValue: string | null) {
super(optionName, help, defaultValue);
}
protected readArguments(argv: string[], startIndex: number): CommandLineArgumentReadResult | null {
if(startIndex >= argv.length) {
return null;
}
return {
consumed: 1,
value: argv[startIndex]
}
}
}

79
tools/polygerrit-updater/src/utils/commentsParser.ts Normal file

@ -0,0 +1,79 @@
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
enum CommentScannerState {
Text,
SingleLineComment,
MultLineComment
}
export class CommentsParser {
public static collectAllComments(text: string): string[] {
const result: string[] = [];
let state = CommentScannerState.Text;
let pos = 0;
function readSingleLineComment() {
const startPos = pos;
while(pos < text.length && text[pos] !== '\n') {
pos++;
}
return text.substring(startPos, pos);
}
function readMultiLineComment() {
const startPos = pos;
while(pos < text.length) {
if(pos < text.length - 1 && text[pos] === '*' && text[pos + 1] === '/') {
pos += 2;
break;
}
pos++;
}
return text.substring(startPos, pos);
}
function skipString(lastChar: string) {
pos++;
while(pos < text.length) {
if(text[pos] === lastChar) {
pos++;
return;
} else if(text[pos] === '\\') {
pos+=2;
continue;
}
pos++;
}
}
while(pos < text.length - 1) {
if(text[pos] === '/' && text[pos + 1] === '/') {
result.push(readSingleLineComment());
} else if(text[pos] === '/' && text[pos + 1] === '*') {
result.push(readMultiLineComment());
} else if(text[pos] === "'") {
skipString("'");
} else if(text[pos] === '"') {
skipString('"');
} else if(text[pos] === '`') {
skipString('`');
} else if(text[pos] == '/') {
skipString('/');
} {
pos++;
}
}
return result;
}
}

270
tools/polygerrit-updater/src/utils/polymerClassBuilder.ts Normal file

@ -0,0 +1,270 @@
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import * as ts from 'typescript';
import * as codeUtils from './codeUtils';
import {LegacyLifecycleMethodName, LegacyLifecycleMethodsArray} from '../funcToClassConversion/polymerComponentParser';
import {SyntaxKind} from 'typescript';
enum PolymerClassMemberType {
IsAccessor,
Constructor,
PolymerPropertiesAccessor,
PolymerObserversAccessor,
Method,
ExistingLifecycleMethod,
NewLifecycleMethod,
GetAccessor,
}
type PolymerClassMember = PolymerClassIsAccessor | PolymerClassConstructor | PolymerClassExistingLifecycleMethod | PolymerClassNewLifecycleMethod | PolymerClassSimpleMember;
interface PolymerClassExistingLifecycleMethod {
member: ts.MethodDeclaration;
memberType: PolymerClassMemberType.ExistingLifecycleMethod;
name: string;
lifecycleOrder: number;
originalPos: number;
}
interface PolymerClassNewLifecycleMethod {
member: ts.MethodDeclaration;
memberType: PolymerClassMemberType.NewLifecycleMethod;
name: string;
lifecycleOrder: number;
originalPos: -1
}
interface PolymerClassIsAccessor {
member: ts.GetAccessorDeclaration;
memberType: PolymerClassMemberType.IsAccessor;
originalPos: -1
}
interface PolymerClassConstructor {
member: ts.ConstructorDeclaration;
memberType: PolymerClassMemberType.Constructor;
originalPos: -1
}
interface PolymerClassSimpleMember {
memberType: PolymerClassMemberType.PolymerPropertiesAccessor | PolymerClassMemberType.PolymerObserversAccessor | PolymerClassMemberType.Method | PolymerClassMemberType.GetAccessor;
member: ts.ClassElement;
originalPos: number;
}
export interface PolymerClassBuilderResult {
classDeclaration: ts.ClassDeclaration;
generatedComments: string[];
}
export class PolymerClassBuilder {
private readonly members: PolymerClassMember[] = [];
public readonly constructorStatements: ts.Statement[] = [];
private baseType: ts.ExpressionWithTypeArguments | undefined;
private classJsDocComments: string[];
public constructor(public readonly className: string) {
this.classJsDocComments = [];
}
public addIsAccessor(accessor: ts.GetAccessorDeclaration) {
this.members.push({
member: accessor,
memberType: PolymerClassMemberType.IsAccessor,
originalPos: -1
});
}
public addPolymerPropertiesAccessor(originalPos: number, accessor: ts.GetAccessorDeclaration) {
this.members.push({
member: accessor,
memberType: PolymerClassMemberType.PolymerPropertiesAccessor,
originalPos: originalPos
});
}
public addPolymerObserversAccessor(originalPos: number, accessor: ts.GetAccessorDeclaration) {
this.members.push({
member: accessor,
memberType: PolymerClassMemberType.PolymerObserversAccessor,
originalPos: originalPos
});
}
public addClassFieldInitializer(name: string | ts.Identifier, initializer: ts.Expression) {
const assignment = ts.createAssignment(ts.createPropertyAccess(ts.createThis(), name), initializer);
this.constructorStatements.push(codeUtils.addNewLineAfterNode(ts.createExpressionStatement(assignment)));
}
public addMethod(originalPos: number, method: ts.MethodDeclaration) {
this.members.push({
member: method,
memberType: PolymerClassMemberType.Method,
originalPos: originalPos
});
}
public addGetAccessor(originalPos: number, accessor: ts.GetAccessorDeclaration) {
this.members.push({
member: accessor,
memberType: PolymerClassMemberType.GetAccessor,
originalPos: originalPos
});
}
public addLifecycleMethod(name: LegacyLifecycleMethodName, originalPos: number, method: ts.MethodDeclaration) {
const lifecycleOrder = LegacyLifecycleMethodsArray.indexOf(name);
if(lifecycleOrder < 0) {
throw new Error(`Invalid lifecycle name`);
}
if(originalPos >= 0) {
this.members.push({
member: method,
memberType: PolymerClassMemberType.ExistingLifecycleMethod,
originalPos: originalPos,
name: name,
lifecycleOrder: lifecycleOrder
})
} else {
this.members.push({
member: method,
memberType: PolymerClassMemberType.NewLifecycleMethod,
name: name,
lifecycleOrder: lifecycleOrder,
originalPos: -1
})
}
}
public setBaseType(type: ts.ExpressionWithTypeArguments) {
if(this.baseType) {
throw new Error("Class can have only one base type");
}
this.baseType = type;
}
public build(): PolymerClassBuilderResult {
let heritageClauses: ts.HeritageClause[] = [];
if (this.baseType) {
const extendClause = ts.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [this.baseType]);
heritageClauses.push(extendClause);
}
const finalMembers: PolymerClassMember[] = [];
const isAccessors = this.members.filter(member => member.memberType === PolymerClassMemberType.IsAccessor);
if(isAccessors.length !== 1) {
throw new Error("Class must have exactly one 'is'");
}
finalMembers.push(isAccessors[0]);
const constructorMember = this.createConstructor();
if(constructorMember) {
finalMembers.push(constructorMember);
}
const newLifecycleMethods: PolymerClassNewLifecycleMethod[] = [];
this.members.forEach(member => {
if(member.memberType === PolymerClassMemberType.NewLifecycleMethod) {
newLifecycleMethods.push(member);
}
});
const methodsWithKnownPosition = this.members.filter(member => member.originalPos >= 0);
methodsWithKnownPosition.sort((a, b) => a.originalPos - b.originalPos);
finalMembers.push(...methodsWithKnownPosition);
for(const newLifecycleMethod of newLifecycleMethods) {
//Number of methods is small - use brute force solution
let closestNextIndex = -1;
let closestNextOrderDiff: number = LegacyLifecycleMethodsArray.length;
let closestPrevIndex = -1;
let closestPrevOrderDiff: number = LegacyLifecycleMethodsArray.length;
for (let i = 0; i < finalMembers.length; i++) {
const member = finalMembers[i];
if (member.memberType !== PolymerClassMemberType.NewLifecycleMethod && member.memberType !== PolymerClassMemberType.ExistingLifecycleMethod) {
continue;
}
const orderDiff = member.lifecycleOrder - newLifecycleMethod.lifecycleOrder;
if (orderDiff > 0) {
if (orderDiff < closestNextOrderDiff) {
closestNextIndex = i;
closestNextOrderDiff = orderDiff;
}
} else if (orderDiff < 0) {
if (orderDiff < closestPrevOrderDiff) {
closestPrevIndex = i;
closestPrevOrderDiff = orderDiff;
}
}
}
let insertIndex;
if (closestNextIndex !== -1 || closestPrevIndex !== -1) {
insertIndex = closestNextOrderDiff < closestPrevOrderDiff ?
closestNextIndex : closestPrevIndex + 1;
} else {
insertIndex = Math.max(
finalMembers.findIndex(m => m.memberType === PolymerClassMemberType.Constructor),
finalMembers.findIndex(m => m.memberType === PolymerClassMemberType.IsAccessor),
finalMembers.findIndex(m => m.memberType === PolymerClassMemberType.PolymerPropertiesAccessor),
finalMembers.findIndex(m => m.memberType === PolymerClassMemberType.PolymerObserversAccessor),
);
if(insertIndex < 0) {
insertIndex = finalMembers.length;
} else {
insertIndex++;//Insert after
}
}
finalMembers.splice(insertIndex, 0, newLifecycleMethod);
}
//Asserts about finalMembers
const nonConstructorMembers = finalMembers.filter(m => m.memberType !== PolymerClassMemberType.Constructor);
if(nonConstructorMembers.length !== this.members.length) {
throw new Error(`Internal error! Some methods are missed`);
}
let classDeclaration = ts.createClassDeclaration(undefined, undefined, this.className, undefined, heritageClauses, finalMembers.map(m => m.member))
const generatedComments: string[] = [];
if(this.classJsDocComments.length > 0) {
const commentContent = '*\n' + this.classJsDocComments.map(line => `* ${line}`).join('\n') + '\n';
classDeclaration = ts.addSyntheticLeadingComment(classDeclaration, ts.SyntaxKind.MultiLineCommentTrivia, commentContent, true);
generatedComments.push(`/*${commentContent}*/`);
}
return {
classDeclaration,
generatedComments,
};
}
private createConstructor(): PolymerClassConstructor | null {
if(this.constructorStatements.length === 0) {
return null;
}
let superCall: ts.CallExpression = ts.createCall(ts.createSuper(), [], []);
const superCallExpression = ts.createExpressionStatement(superCall);
const statements = [superCallExpression, ...this.constructorStatements];
const constructorDeclaration = ts.createConstructor([], [], [], ts.createBlock(statements, true));
return {
memberType: PolymerClassMemberType.Constructor,
member: constructorDeclaration,
originalPos: -1
};
}
public addClassJSDocComments(lines: string[]) {
this.classJsDocComments.push(...lines);
}
}

17
tools/polygerrit-updater/src/utils/unexpectedValue.ts Normal file

@ -0,0 +1,17 @@
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
export function unexpectedValue<T>(x: T): never {
throw new Error(`Unexpected value '${x}'`);
}

67
tools/polygerrit-updater/tsconfig.json Normal file

@ -0,0 +1,67 @@
{
"compilerOptions": {
/* Basic Options */
// "incremental": true, /* Enable incremental compilation */
"target": "es2015", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */
"module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
// "lib": [], /* Specify library files to be included in the compilation. */
// "allowJs": true, /* Allow javascript files to be compiled. */
// "checkJs": true, /* Report errors in .js files. */
// "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
// "declaration": true, /* Generates corresponding '.d.ts' file. */
// "declarationMap": true, /* Generates a sourcemap for each corresponding '.d.ts' file. */
"sourceMap": true, /* Generates corresponding '.map' file. */
// "outFile": "./", /* Concatenate and emit output to single file. */
"outDir": "./js", /* Redirect output structure to the directory. */
"rootDir": ".", /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
// "composite": true, /* Enable project compilation */
// "tsBuildInfoFile": "./", /* Specify file to store incremental compilation information */
// "removeComments": true, /* Do not emit comments to output. */
// "noEmit": true, /* Do not emit outputs. */
// "importHelpers": true, /* Import emit helpers from 'tslib'. */
// "downlevelIteration": true, /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
// "isolatedModules": true, /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
/* Strict Type-Checking Options */
"strict": true, /* Enable all strict type-checking options. */
"noImplicitAny": true, /* Raise error on expressions and declarations with an implied 'any' type. */
// "strictNullChecks": true, /* Enable strict null checks. */
// "strictFunctionTypes": true, /* Enable strict checking of function types. */
// "strictBindCallApply": true, /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
// "strictPropertyInitialization": true, /* Enable strict checking of property initialization in classes. */
// "noImplicitThis": true, /* Raise error on 'this' expressions with an implied 'any' type. */
// "alwaysStrict": true, /* Parse in strict mode and emit "use strict" for each source file. */
/* Additional Checks */
// "noUnusedLocals": true, /* Report errors on unused locals. */
// "noUnusedParameters": true, /* Report errors on unused parameters. */
// "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
// "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
/* Module Resolution Options */
"moduleResolution": "node", /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
"baseUrl": "./", /* Base directory to resolve non-absolute module names. */
"paths": {
"*": [ "node_modules/*" ]
}, /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
// "rootDirs": [], /* List of root folders whose combined content represents the structure of the project at runtime. */
// "typeRoots": [], /* List of folders to include type definitions from. */
// "types": [], /* Type declaration files to be included in compilation. */
"allowSyntheticDefaultImports": true, /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
"esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
// "preserveSymlinks": true, /* Do not resolve the real path of symlinks. */
// "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */
/* Source Map Options */
// "sourceRoot": "", /* Specify the location where debugger should locate TypeScript files instead of source locations. */
// "mapRoot": "", /* Specify the location where debugger should locate map files instead of generated locations. */
// "inlineSourceMap": true, /* Emit a single file with source maps instead of having a separate file. */
// "inlineSources": true, /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
/* Experimental Options */
// "experimentalDecorators": true, /* Enables experimental support for ES7 decorators. */
// "emitDecoratorMetadata": true, /* Enables experimental support for emitting type metadata for decorators. */
},
"include": ["./src/**/*"]
}