@neurodevs/meta-node 0.7.0 → 0.9.0

package/src/modules/ImplAutomodule.ts

@@ -1,25 +1,23 @@
 import { exec as execSync } from 'child_process'
-import { readFile, writeFile } from 'fs/promises'
-import path from 'path'
+import { readFile } from 'fs/promises'
 import { promisify } from 'util'
-import { pathExists } from 'fs-extra'
-
-export default class ImplAutomodule implements Automodule {
-    public static Class?: AutomoduleConstructor
+import { Automodule, BaseAutomoduleOptions } from '../types'
+import AbstractAutomodule from './AbstractAutomodule'
+
+export default class ImplAutomodule
+    extends AbstractAutomodule
+    implements Automodule
+{
+    public static Class?: ImplAutomoduleConstructor
     public static exec = promisify(execSync)
-    public static pathExists = pathExists
     public static readFile = readFile
-    public static writeFile = writeFile
 
-    private testSaveDir: string
-    private moduleSaveDir: string
-    private fakeSaveDir: string
     private interfaceName: string
     private implName: string
 
     private originalIndexFile!: string
 
-    protected constructor(options: AutomoduleOptions) {
+    protected constructor(options: ImplAutomoduleOptions) {
         const {
             testSaveDir,
             moduleSaveDir,
@@ -28,84 +26,35 @@ export default class ImplAutomodule implements Automodule {
             implName,
         } = options
 
-        this.testSaveDir = testSaveDir
-        this.moduleSaveDir = moduleSaveDir
-        this.fakeSaveDir = fakeSaveDir
+        super({
+            testSaveDir,
+            moduleSaveDir,
+            fakeSaveDir,
+        })
+
         this.interfaceName = interfaceName
         this.implName = implName
     }
 
-    public static Create(options: AutomoduleOptions) {
+    public static Create(options: ImplAutomoduleOptions) {
         return new (this.Class ?? this)(options)
     }
 
     public async run() {
-        await this.throwIfDirectoriesDoNotExist()
-
-        await this.createTestFile()
-        await this.createModuleFile()
-        await this.createFakeFile()
-
+        await this.generateFiles()
         await this.updateIndexFileExports()
         await this.bumpMinorVersion()
     }
 
-    private async throwIfDirectoriesDoNotExist() {
-        await this.throwIfTestDirDoesNotExist()
-        await this.throwIfModuleDirDoesNotExist()
-        await this.throwIfFakeDirDoesNotExist()
-    }
-
-    private async throwIfTestDirDoesNotExist() {
-        const testDirExists = await this.pathExists(this.testSaveDir)
-
-        if (!testDirExists) {
-            this.throw(`testSaveDir does not exist: ${this.testSaveDir}!`)
-        }
-    }
-
-    private async throwIfModuleDirDoesNotExist() {
-        const moduleDirExists = await this.pathExists(this.moduleSaveDir)
-
-        if (!moduleDirExists) {
-            this.throw(`moduleSaveDir does not exist: ${this.moduleSaveDir}!`)
-        }
-    }
-
-    private async throwIfFakeDirDoesNotExist() {
-        const fakeDirExists = await this.pathExists(this.fakeSaveDir)
-
-        if (!fakeDirExists) {
-            this.throw(`fakeSaveDir does not exist: ${this.fakeSaveDir}!`)
-        }
-    }
-
-    private throw(err: string) {
-        throw new Error(err)
-    }
-
-    private async createTestFile() {
-        await this.writeFile(this.testFileName, this.testFilePattern)
-    }
-
-    private get testFileName() {
-        return path.join(this.testSaveDir, `${this.implName}.test.ts`)
-    }
-
-    private async createModuleFile() {
-        await this.writeFile(this.moduleFileName, this.moduleFilePattern)
-    }
-
-    private get moduleFileName() {
-        return path.join(this.moduleSaveDir, `${this.implName}.ts`)
-    }
-
-    private async createFakeFile() {
-        await this.writeFile(this.fakeFileName, this.fakeFilePattern)
-    }
-
-    private get fakeFileName() {
-        return path.join(this.fakeSaveDir, `Fake${this.interfaceName}.ts`)
+    private async generateFiles() {
+        await this.runAbstract({
+            testFileName: `${this.implName}.test.ts`,
+            testFileContent: this.testFilePattern,
+            moduleFileName: `${this.implName}.ts`,
+            moduleFileContent: this.moduleFilePattern,
+            fakeFileName: `Fake${this.interfaceName}.ts`,
+            fakeFileContent: this.fakeFilePattern,
+        })
     }
 
     private async updateIndexFileExports() {
@@ -142,18 +91,10 @@ export default class ImplAutomodule implements Automodule {
         return ImplAutomodule.exec
     }
 
-    private get pathExists() {
-        return ImplAutomodule.pathExists
-    }
-
     private get readFile() {
         return ImplAutomodule.readFile
     }
 
-    private get writeFile() {
-        return ImplAutomodule.writeFile
-    }
-
     private get testFilePattern() {
         return `
             import AbstractSpruceTest, { test, assert } from '@sprucelabs/test-utils'
@@ -161,10 +102,10 @@ export default class ImplAutomodule implements Automodule {
 
             export default class ${this.implName}Test extends AbstractSpruceTest {
                 private static instance: ${this.interfaceName}
-                
+
                 protected static async beforeEach() {
                     await super.beforeEach()
-                    
+
                     this.instance = this.${this.implName}()
                 }
                 
@@ -231,18 +172,11 @@ export default class ImplAutomodule implements Automodule {
     }
 }
 
-export interface Automodule {
-    run(): Promise<void>
-}
-
-export type AutomoduleConstructor = new (
-    options: AutomoduleOptions
+export type ImplAutomoduleConstructor = new (
+    options: ImplAutomoduleOptions
 ) => Automodule
 
-export interface AutomoduleOptions {
-    testSaveDir: string
-    moduleSaveDir: string
-    fakeSaveDir: string
+export interface ImplAutomoduleOptions extends BaseAutomoduleOptions {
     interfaceName: string
     implName: string
 }

package/src/modules/NpmAutopackage.ts

@@ -1,11 +1,12 @@
 import { exec as execSync } from 'child_process'
 import { readFile, writeFile } from 'fs/promises'
+import { chdir } from 'process'
 import { promisify } from 'util'
 import { pathExists } from 'fs-extra'
 
 export default class NpmAutopackage implements Autopackage {
     public static Class?: AutopackageConstructor
-    public static chdir = process.chdir
+    public static chdir = chdir
     public static exec = promisify(execSync)
     public static fetch = fetch
     public static pathExists = pathExists
@@ -57,7 +58,7 @@ export default class NpmAutopackage implements Autopackage {
 
         this.chdirToPackageDir()
         await this.spruceCreateModule()
-        await this.updatePackage()
+        await this.updatePackageJson()
         await this.updateGitignore()
         await this.setupVscode()
     }
@@ -165,12 +166,12 @@ export default class NpmAutopackage implements Autopackage {
         await this.exec('git push')
     }
 
-    private async updatePackage() {
+    private async updatePackageJson() {
         this.originalJsonFile = await this.loadPackageJsonFile()
 
         if (!this.isPackageUpToDate) {
             console.log('Updating package.json...')
-            await this.updatePackageJson()
+            await this.updatePackageJsonFile()
             await this.commitUpdatePackage()
         }
     }
@@ -189,7 +190,7 @@ export default class NpmAutopackage implements Autopackage {
         )
     }
 
-    private async updatePackageJson() {
+    private async updatePackageJsonFile() {
         const ordered = this.orderJsonKeys(this.updatedJsonFile, [
             'name',
             'version',
@@ -278,7 +279,7 @@ export default class NpmAutopackage implements Autopackage {
         if (!this.isGitignoreUpdated) {
             console.log('Updating .gitignore...')
 
-            await this.addBuildDirToGitignore()
+            await this.updateGitignoreFile()
             await this.commitUpdateGitignore()
         }
     }
@@ -301,7 +302,7 @@ export default class NpmAutopackage implements Autopackage {
         return lines.includes('build/')
     }
 
-    private async addBuildDirToGitignore() {
+    private async updateGitignoreFile() {
         await this.writeFile(this.gitignorePath, '\nbuild/\n', {
             encoding: 'utf-8',
             flag: 'a',

package/src/modules/UiAutomodule.ts

@@ -0,0 +1,143 @@
+import { pathExists } from 'fs-extra'
+import { Automodule, BaseAutomoduleOptions } from '../types'
+import AbstractAutomodule from './AbstractAutomodule'
+
+export default class UiAutomodule
+    extends AbstractAutomodule
+    implements Automodule
+{
+    public static Class?: UiAutomoduleConstructor
+    public static pathExists = pathExists
+
+    protected componentName: string
+    protected componentNameKebabCase: string
+
+    protected constructor(options: UiAutomoduleOptions) {
+        const { testSaveDir, moduleSaveDir, fakeSaveDir, componentName } =
+            options
+
+        super({
+            testSaveDir,
+            moduleSaveDir,
+            fakeSaveDir,
+        })
+
+        this.componentName = componentName
+        this.componentNameKebabCase = this.toKebabCase(componentName)
+    }
+
+    public static Create(options: UiAutomoduleOptions) {
+        return new (this.Class ?? this)(options)
+    }
+
+    private toKebabCase(str: string): string {
+        return str
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[\s_]+/g, '-')
+            .toLowerCase()
+    }
+
+    public async run() {
+        await this.runAbstract({
+            testFileName: `${this.componentName}.test.tsx`,
+            testFileContent: this.testFileTemplate,
+            moduleFileName: `${this.componentName}.tsx`,
+            moduleFileContent: this.moduleFilePattern,
+            fakeFileName: `Fake${this.componentName}.tsx`,
+            fakeFileContent: this.fakeFilePattern,
+        })
+    }
+
+    private get testFileTemplate() {
+        return `
+            import { test, assert } from '@sprucelabs/test-utils'
+            import { render, RenderResult } from '@testing-library/react'
+            import ${this.componentName} from '../../ui/${this.componentName}'
+            import AbstractPackageTest from '../AbstractPackageTest'
+
+            export default class ${this.componentName}Test extends AbstractPackageTest {
+                private static result: RenderResult
+
+                protected static async beforeEach() {
+                    await super.beforeEach()
+
+                    this.result = this.render()
+                }
+
+                @test()
+                protected static async rendersComponent() {
+                    assert.isTruthy(this.result, 'Failed to render component!')
+                }
+
+                @test()
+                protected static async rendersTopLevelDivWithExpectedClass() {
+                    assert.isEqual(
+                        this.div.className,
+                        this.className,
+                        'Incorrect class for top-level div!'
+                    )
+                }
+
+                private static get div() {
+                    return this.getByTestId(this.className)
+                }
+
+                private static get getByTestId() {
+                    return this.result.getByTestId
+                }
+
+                private static readonly className = '${this.toKebabCase(this.componentName)}'
+
+                protected static render() {
+                    return render(<${this.componentName} />)
+                }
+            }
+        `
+    }
+
+    private get moduleFilePattern() {
+        return `
+            import React from 'react'
+
+            const ${this.componentName}: React.FC = () => {
+                return (
+                    <div
+                        className="${this.componentNameKebabCase}"
+                        data-testid="${this.componentNameKebabCase}"
+                    />
+                )
+            }
+
+            export default ${this.componentName}
+        `
+    }
+
+    private get fakeFilePattern() {
+        return `
+            import React from 'react'
+            import { ${this.componentName}Props } from '../ui/${this.componentName}'
+
+            export let last${this.componentName}Props: ${this.componentName}Props | undefined
+
+            const Fake${this.componentName}: React.FC<${this.componentName}Props> = (
+                props: ${this.componentName}Props
+            ) => {
+                last${this.componentName}Props = props
+
+                return (
+                    <div data-testid="${this.componentNameKebabCase}" />
+                )
+            }
+
+            export default Fake${this.componentName}
+        `
+    }
+}
+
+export type UiAutomoduleConstructor = new (
+    options: UiAutomoduleOptions
+) => Automodule
+
+export interface UiAutomoduleOptions extends BaseAutomoduleOptions {
+    componentName: string
+}

package/src/scripts/runUiAutomodule.ts

@@ -0,0 +1,23 @@
+import UiAutomodule from '../modules/UiAutomodule'
+
+async function main() {
+    console.log('\nRunning automodule...')
+
+    const instance = UiAutomodule.Create({
+        testSaveDir:
+            '/Users/ericthecurious/dev/meta-node/src/__tests__/modules',
+        moduleSaveDir: '/Users/ericthecurious/dev/meta-node/src/modules',
+        fakeSaveDir:
+            '/Users/ericthecurious/dev/meta-node/src/testDoubles/Autothingy',
+        componentName: 'Autothingy',
+    })
+
+    await instance.run()
+
+    console.log('Finished running automodule!\n')
+}
+
+main().catch((err) => {
+    console.error(err)
+    process.exit(1)
+})

package/src/testDoubles/Automodule/FakeAutomodule.ts

@@ -1,15 +1,17 @@
-import { Automodule, AutomoduleOptions } from '../../modules/ImplAutomodule'
+import { ImplAutomoduleOptions } from '../../modules/ImplAutomodule'
+import { UiAutomoduleOptions } from '../../modules/UiAutomodule'
+import { Automodule } from '../../types'
 
-export default class FakeAutomodule implements Automodule {
-    public static callsToConstructor: AutomoduleOptions[] = []
+export default class FakeImplAutomodule implements Automodule {
+    public static callsToConstructor: FakeAutomoduleOptions[] = []
     public static numCallsToRun = 0
 
-    public constructor(options: AutomoduleOptions) {
-        FakeAutomodule.callsToConstructor.push(options)
+    public constructor(options: FakeAutomoduleOptions) {
+        FakeImplAutomodule.callsToConstructor.push(options)
     }
 
     public async run() {
-        FakeAutomodule.numCallsToRun++
+        FakeImplAutomodule.numCallsToRun++
     }
 
     public static resetTestDouble() {
@@ -17,3 +19,5 @@ export default class FakeAutomodule implements Automodule {
         this.numCallsToRun = 0
     }
 }
+
+export type FakeAutomoduleOptions = ImplAutomoduleOptions | UiAutomoduleOptions

package/src/types.ts

@@ -0,0 +1,9 @@
+export interface Automodule {
+    run(): Promise<void>
+}
+
+export interface BaseAutomoduleOptions {
+    testSaveDir: string
+    moduleSaveDir: string
+    fakeSaveDir: string
+}

package/build/scripts/runAutomodule.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"runAutomodule.js","sourceRoot":"","sources":["../../src/scripts/runAutomodule.ts"],"names":[],"mappings":";;;;;AAAA,+EAAsD;AAEtD,KAAK,UAAU,IAAI;IACf,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAA;IAEtC,MAAM,QAAQ,GAAG,wBAAc,CAAC,MAAM,CAAC;QACnC,WAAW,EACP,2DAA2D;QAC/D,aAAa,EAAE,iDAAiD;QAChE,WAAW,EACP,gEAAgE;QACpE,aAAa,EAAE,YAAY;QAC3B,QAAQ,EAAE,mBAAmB;KAChC,CAAC,CAAA;IAEF,MAAM,QAAQ,CAAC,GAAG,EAAE,CAAA;IAEpB,OAAO,CAAC,GAAG,CAAC,gCAAgC,CAAC,CAAA;AACjD,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACjB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAClB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;AACnB,CAAC,CAAC,CAAA"}