fix: refactor non-constant property initializer for php, fixes #16

src/target-php/index.ts

@@ -1,6 +1,6 @@
 import { getInlineDeclarations } from '../parsers/dependency-resolver'
 import { keyBy } from 'lodash'
-import { isReserved } from './util'
+import { isReserved } from './utils/lang'
 import { Modules, generatePHPCode } from './compilers/ts2php'
 import { transformAstToPHP } from './transformers/index'
 import { Project } from 'ts-morph'

src/target-php/transformers/index.ts

@@ -1,4 +1,5 @@
-import { isReserved, removeObjectLiteralInitiator } from '../util'
+import { isReserved } from '../utils/lang'
+import { refactorMemberInitializer } from './refactor-member-initializer'
 import { SanSourceFile } from '../..'
 import { refactorFiltersProperty } from './refactor-filters-property'
 import { refactorComputedProperty } from './refactor-computed-property'
@@ -26,7 +27,7 @@ export function transformAstToPHP (sourceFile: SanSourceFile) {
             } else if (prop.getName() === 'filters') {
                 refactorFiltersProperty(prop, sanssr)
             }
-            removeObjectLiteralInitiator(sourceFile.tsSourceFile, clazz, prop)
+            refactorMemberInitializer(clazz, prop)
         }
     }
 

src/target-php/transformers/refactor-member-initializer.ts

@@ -0,0 +1,25 @@
+import { ClassDeclaration, TypeGuards, Expression, PropertyDeclaration } from 'ts-morph'
+
+export function refactorMemberInitializer (clazz: ClassDeclaration, prop: PropertyDeclaration) {
+    const initializer = prop.getInitializer()
+    if (!initializer || isConstant(initializer)) return
+
+    if (prop.isStatic()) {
+        const statement = clazz.getName() + '.' + prop.getName() + ' = ' + initializer.getFullText()
+        clazz.getSourceFile().addStatements(statement)
+    } else {
+        let statement = 'this.' + prop.getName() + ' = ' + initializer.getFullText()
+        if (!clazz.getConstructors().length) {
+            clazz.addConstructor()
+            statement = 'super()\n' + statement
+        }
+        const init = clazz.getConstructors()[0]
+        init.setBodyText(init.getBodyText() + '\n' + statement)
+    }
+    prop.removeInitializer()
+}
+
+function isConstant (expr: Expression) {
+    if (TypeGuards.isLiteralExpression(expr)) return true
+    return false
+}

src/target-php/utils/lang.ts

@@ -0,0 +1,8 @@
+const reservedNames = [/^list$/i]
+
+export function isReserved (name: string) {
+    for (const reserved of reservedNames) {
+        if (reserved.test(name)) return true
+    }
+    return false
+}

test/cases/property-initializer/component.ts

@@ -0,0 +1,12 @@
+import { Component } from 'san'
+
+const TEMPLATE = '<div><b title="{{title | real}}">{{title | real}}</b></div>'
+
+export default class MyComponent extends Component {
+    static template = TEMPLATE
+    static filters = {
+        real: function (x) {
+            return 'real' + x
+        }
+    }
+}

test/cases/property-initializer/data.json

@@ -0,0 +1,3 @@
+{
+    "title": "1"
+}

test/cases/property-initializer/result.html

@@ -0,0 +1 @@
+<div><!--s-data:{"title":"1"}--><b title="real1">real1</b></div>

test/cases/property-initializer/spec.js

@@ -0,0 +1,7 @@
+it('method', function () {
+    // [inject] init
+
+    const b = wrap.getElementsByTagName('b')[0]
+
+    expect(b.title).toBe('real1')
+})

test/unit/target-php/refactor-member-initializer.ts

@@ -0,0 +1,73 @@
+import { refactorMemberInitializer } from '../../../src/target-php/transformers/refactor-member-initializer'
+import { Project } from 'ts-morph'
+
+describe('refactorMemberInitializer()', function () {
+    const project = new Project()
+
+    it('should skip string literal static initializer', function () {
+        const sourceFile = project.createSourceFile('/tmp/static-str-literal', `
+        class Foo {
+            static staticLiteralStr: string = "foo"
+        }`)
+        const clazz = sourceFile.getClass('Foo')
+        for (const prop of clazz.getProperties()) {
+            refactorMemberInitializer(clazz, prop)
+        }
+        sourceFile.formatText()
+        const text = sourceFile.getFullText()
+
+        expect(text).toContain(`static staticLiteralStr: string = "foo"`)
+        expect(text).not.toContain(`Foo.staticLiteralStr =`)
+    })
+
+    it('should refactor string variable static initializer', function () {
+        const sourceFile = project.createSourceFile('/tmp/static-str-var', `
+        const str = "foo"
+        class Foo {
+            static staticLiteralStr: string = str
+        }`)
+        const clazz = sourceFile.getClass('Foo')
+        for (const prop of clazz.getProperties()) {
+            refactorMemberInitializer(clazz, prop)
+        }
+        sourceFile.formatText()
+        const text = sourceFile.getFullText()
+
+        expect(text).toContain(`static staticLiteralStr: string`)
+        expect(text).toContain(`Foo.staticLiteralStr = str`)
+    })
+
+    it('should skip string literal initializer', function () {
+        const sourceFile = project.createSourceFile('/tmp/str-literal', `
+        class Foo {
+            literalStr: string = "str"
+        }`)
+        const clazz = sourceFile.getClass('Foo')
+        for (const prop of clazz.getProperties()) {
+            refactorMemberInitializer(clazz, prop)
+        }
+        const text = sourceFile.getFullText()
+
+        expect(text).toContain(`literalStr: string = "str"`)
+        expect(text).not.toContain(`constructor()`)
+    })
+
+    it('should refactor string literal initializer', function () {
+        const sourceFile = project.createSourceFile('/tmp/str-var', `
+        const str = "foo"
+        class Foo {
+            literalStr: string = str
+        }`)
+        const clazz = sourceFile.getClass('Foo')
+        for (const prop of clazz.getProperties()) {
+            refactorMemberInitializer(clazz, prop)
+        }
+        sourceFile.formatText()
+        const text = sourceFile.getFullText()
+
+        expect(text).toContain(`literalStr: string\n`)
+        expect(text).toContain(`constructor() {`)
+        expect(text).toContain(`super()`)
+        expect(text).toContain(`this.literalStr = str`)
+    })
+})