@sprucelabs/spruce-cli 22.1.12 → 22.2.0

package/src/.spruce/errors/spruceCli/testFailed.schema.ts

@@ -1,30 +1,32 @@
 import { SchemaRegistry } from '@sprucelabs/schema'
 import { SpruceErrors } from '../errors.types'
 
-const testFailedSchema: SpruceErrors.SpruceCli.TestFailedSchema = {
-    id: 'testFailed',
-    namespace: 'SpruceCli',
-    name: 'Test failed',
-    fields: {
-        /** . */
-        fileName: {
-            type: 'text',
-            isRequired: true,
-            options: undefined,
-        },
-        /** . */
-        testName: {
-            type: 'text',
-            isRequired: true,
-            options: undefined,
-        },
-        /** . */
-        errorMessage: {
-            type: 'text',
-            isRequired: true,
-            options: undefined,
-        },
-    },
+
+
+const testFailedSchema: SpruceErrors.SpruceCli.TestFailedSchema  = {
+	id: 'testFailed',
+	namespace: 'SpruceCli',
+	name: 'Test failed',
+	    fields: {
+	            /** . */
+	            'fileName': {
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	            /** . */
+	            'testName': {
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	            /** . */
+	            'errorMessage': {
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	    }
 }
 
 SchemaRegistry.getInstance().trackSchema(testFailedSchema)

package/src/.spruce/errors/spruceCli/themeExists.schema.ts

@@ -1,11 +1,14 @@
 import { SchemaRegistry } from '@sprucelabs/schema'
 import { SpruceErrors } from '../errors.types'
 
-const themeExistsSchema: SpruceErrors.SpruceCli.ThemeExistsSchema = {
-    id: 'themeExists',
-    namespace: 'SpruceCli',
-    name: 'Theme exists',
-    fields: {},
+
+
+const themeExistsSchema: SpruceErrors.SpruceCli.ThemeExistsSchema  = {
+	id: 'themeExists',
+	namespace: 'SpruceCli',
+	name: 'Theme exists',
+	    fields: {
+	    }
 }
 
 SchemaRegistry.getInstance().trackSchema(themeExistsSchema)

package/src/.spruce/errors/spruceCli/transportAlreadyExists.schema.ts

@@ -1,21 +1,22 @@
 import { SchemaRegistry } from '@sprucelabs/schema'
 import { SpruceErrors } from '../errors.types'
 
-const transportAlreadyExistsSchema: SpruceErrors.SpruceCli.TransportAlreadyExistsSchema =
-    {
-        id: 'transportAlreadyExists',
-        namespace: 'SpruceCli',
-        name: 'transport already exists',
-        fields: {
-            /** Transport name. */
-            name: {
-                label: 'Transport name',
-                type: 'text',
-                isRequired: true,
-                options: undefined,
-            },
-        },
-    }
+
+
+const transportAlreadyExistsSchema: SpruceErrors.SpruceCli.TransportAlreadyExistsSchema  = {
+	id: 'transportAlreadyExists',
+	namespace: 'SpruceCli',
+	name: 'transport already exists',
+	    fields: {
+	            /** Transport name. */
+	            'name': {
+	                label: 'Transport name',
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	    }
+}
 
 SchemaRegistry.getInstance().trackSchema(transportAlreadyExistsSchema)
 

package/src/.spruce/errors/spruceCli/viewPluginAlreadyExists.schema.ts

@@ -1,20 +1,21 @@
 import { SchemaRegistry } from '@sprucelabs/schema'
 import { SpruceErrors } from '../errors.types'
 
-const viewPluginAlreadyExistsSchema: SpruceErrors.SpruceCli.ViewPluginAlreadyExistsSchema =
-    {
-        id: 'viewPluginAlreadyExists',
-        namespace: 'SpruceCli',
-        name: 'View plugin already exists',
-        fields: {
-            /** . */
-            name: {
-                type: 'text',
-                isRequired: true,
-                options: undefined,
-            },
-        },
-    }
+
+
+const viewPluginAlreadyExistsSchema: SpruceErrors.SpruceCli.ViewPluginAlreadyExistsSchema  = {
+	id: 'viewPluginAlreadyExists',
+	namespace: 'SpruceCli',
+	name: 'View plugin already exists',
+	    fields: {
+	            /** . */
+	            'name': {
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	    }
+}
 
 SchemaRegistry.getInstance().trackSchema(viewPluginAlreadyExistsSchema)
 

package/src/.spruce/errors/spruceCli/vscodeNotInstalled.schema.ts

@@ -1,13 +1,15 @@
 import { SchemaRegistry } from '@sprucelabs/schema'
 import { SpruceErrors } from '../errors.types'
 
-const vscodeNotInstalledSchema: SpruceErrors.SpruceCli.VscodeNotInstalledSchema =
-    {
-        id: 'vscodeNotInstalled',
-        namespace: 'SpruceCli',
-        name: 'vscode not installed',
-        fields: {},
-    }
+
+
+const vscodeNotInstalledSchema: SpruceErrors.SpruceCli.VscodeNotInstalledSchema  = {
+	id: 'vscodeNotInstalled',
+	namespace: 'SpruceCli',
+	name: 'vscode not installed',
+	    fields: {
+	    }
+}
 
 SchemaRegistry.getInstance().trackSchema(vscodeNotInstalledSchema)
 

package/src/GlobalEmitter.ts

@@ -39,7 +39,6 @@ export const globalContract = buildEventContract({
             }),
         },
         'skill.register-dashboard-widgets': {},
-
         'test.register-abstract-test-classes': {
             responsePayloadSchema: buildSchema({
                 id: 'registerAbstractTestClassResponsePayload',

package/src/__tests__/behavioral/views/CreatingAnAppViewController.test.ts

@@ -0,0 +1,158 @@
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { test, assert, errorAssert, generateId } from '@sprucelabs/test-utils'
+import CreateAppAction from '../../../features/view/actions/CreateAppAction'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
+import testUtil from '../../../tests/utilities/test.utility'
+
+export default class CreatingAnAppViewControllerTest extends AbstractSkillTest {
+    protected static skillCacheKey = 'views'
+    private static avcPath: string
+
+    private static action: CreateAppAction
+    private static lastExecution: {
+        actionCode: string
+        featureCode: string
+    }[] = []
+
+    protected static async beforeAll(): Promise<void> {
+        await super.beforeAll()
+        this.avcPath = this.resolvePath('src/App.avc.ts')
+    }
+
+    protected static async beforeEach(): Promise<void> {
+        await super.beforeEach()
+
+        this.action = this.Action('view', 'createApp')
+        await this.cli.on('feature.will-execute', (payload) => {
+            this.lastExecution.push(payload)
+        })
+    }
+
+    @test()
+    protected static async generatesExpectedFile() {
+        const results = await this.execute()
+        assert.isFalsy(results.errors)
+
+        testUtil.assertFileByPathInGeneratedFiles(this.avcPath, results.files)
+
+        assert.doesInclude(results.files, {
+            action: 'generated',
+            name: 'App.avc.ts',
+            path: this.avcPath,
+        })
+
+        assert.doesInclude(results.files, {
+            action: 'generated',
+            name: 'views.ts',
+            path: this.combinedViewsPath,
+        })
+    }
+
+    @test()
+    protected static async syncsViewsOnCreation() {
+        debugger
+        assert.doesInclude(this.lastExecution, {
+            actionCode: 'sync',
+            featureCode: 'view',
+        })
+        assert.isEqual(this.lastExecution[1].actionCode, 'sync')
+        assert.isTrue(
+            diskUtil.doesFileExist(this.combinedViewsPath),
+            'views.ts does not exist'
+        )
+    }
+
+    @test()
+    protected static async throwsIfAppAlreadyExists() {
+        await this.executeAndAssertThrowsAvcExists()
+    }
+
+    @test()
+    protected static async avcIncludesExpectedContents() {
+        const contents = diskUtil.readFile(this.avcPath)
+        assert.doesInclude(
+            contents,
+            'export default class AppViewControllerImpl extends AbstractAppViewController'
+        )
+
+        assert.doesInclude(
+            contents,
+            'public async (_options: AppViewControllerLoadOptions)'
+        )
+    }
+
+    @test()
+    protected static async generatedFilesAreValid() {
+        await this.Service('typeChecker').check(this.avcPath)
+        await this.assertCombinedViewsFileIsValid()
+    }
+
+    @test()
+    protected static async doesNotDropAppIntoSkillViewTypes() {
+        const expected = `interface ViewControllerMap {}`
+        this.assertCombinedViewsContains(expected)
+    }
+
+    @test()
+    protected static async callsHeartwoodImportFunctionAsExpected() {
+        this.assertCombinedViewsContains(
+            'heartwood({ vcs, pluginsByName, App: AppViewControllerImpl })'
+        )
+    }
+
+    @test()
+    protected static async throwsEvenIfAppAvcMoves() {
+        const destination = this.resolvePath(`src/${generateId()}/App.avc.ts`)
+        diskUtil.moveFile(this.avcPath, destination)
+
+        await this.executeAndAssertThrowsAvcExists()
+        this.avcPath = destination
+    }
+
+    @test()
+    protected static async canRenameAppAvcAndItUpdatesCombinedViews() {
+        const contents = diskUtil.readFile(this.avcPath)
+        const updatedContents = contents.replace(
+            'AppViewControllerImpl',
+            'NewAppViewControllerImpl'
+        )
+        diskUtil.writeFile(this.avcPath, updatedContents)
+        await this.Action('view', 'sync').execute({})
+
+        this.assertCombinedViewsContains(
+            'heartwood({ vcs, pluginsByName, App: NewAppViewControllerImpl })'
+        )
+
+        await this.assertCombinedViewsFileIsValid()
+    }
+
+    private static async assertCombinedViewsFileIsValid() {
+        await this.Service('typeChecker').check(this.combinedViewsPath)
+    }
+
+    private static assertCombinedViewsContains(expected: string) {
+        const contents = diskUtil.readFile(this.combinedViewsPath)
+        assert.doesInclude(
+            contents.replace(/\s/g, ''),
+            expected.replace(/\s/g, ''),
+            `The combined views file does not include the expected contents.`
+        )
+    }
+
+    private static get combinedViewsPath() {
+        return this.resolveHashSprucePath('views', 'views.ts')
+    }
+
+    private static async executeAndAssertThrowsAvcExists() {
+        const results = await this.execute()
+        assert.isTruthy(results.errors)
+        errorAssert.assertError(
+            results.errors[0],
+            'APP_VIEW_CONTROLLER_ALREADY_EXISTS'
+        )
+    }
+
+    private static async execute() {
+        return await this.action.execute()
+    }
+}

package/src/__tests__/behavioral/views/KeepingViewsInSync.test.ts

@@ -20,7 +20,7 @@ export default class KeepingViewsInSyncTest extends AbstractSkillTest {
 
     @test()
     protected static async syncingWithNoViewsGeneratesNothing() {
-        const results = await this.action.execute({})
+        const results = await this.action.execute()
         assert.isFalsy(results.errors)
         assert.isFalsy(results.files)
     }

package/src/__tests__/behavioral/views/plugins/CreatingAViewPlugin.test.ts

@@ -92,7 +92,7 @@ export default class CreatingAViewPluginTest extends AbstractSkillTest {
 `
 
         this.assertCombinedFileIncludes(expected)
-        this.assertCombinedFileIncludes('heartwood(vcs, pluginsByName)')
+        this.assertCombinedFileIncludes('heartwood({ vcs, pluginsByName })')
     }
 
     @test()

package/src/__tests__/implementation/TerminalInterface.test.ts

@@ -1,4 +1,8 @@
-import AbstractSpruceTest, { test, assert } from '@sprucelabs/test-utils'
+import AbstractSpruceTest, {
+    test,
+    assert,
+    errorAssert,
+} from '@sprucelabs/test-utils'
 import TerminalInterface from '../../interfaces/TerminalInterface'
 
 export default class TerminalInterfaceTest extends AbstractSpruceTest {
@@ -33,6 +37,15 @@ export default class TerminalInterfaceTest extends AbstractSpruceTest {
         assert.isTrue(this.wasOraHit)
     }
 
+    @test()
+    protected static async askingToPromptThrowsIfInCi() {
+        process.env.CIRCLECI = 'true'
+        const err = await assert.doesThrowAsync(() =>
+            this.ui.prompt({ type: 'text' })
+        )
+        errorAssert.assertError(err, 'CANNOT_PROMPT_IN_CI')
+    }
+
     private static async startLoading() {
         await this.ui.startLoading()
     }

package/src/cli/Cli.ts

@@ -223,8 +223,7 @@ export default class Cli implements CliInterface {
             actionFactory,
             ui,
             emitter,
-            //@ts-ignore
-            featureInstallerFactory: () => featureInstaller,
+            featureInstallerFactory: () => featureInstaller!,
         })
 
         featureInstaller =

package/src/errors/SpruceError.ts

@@ -269,6 +269,14 @@ export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
                 message = `A view plugin by the name ${options.name} already exists!`
                 break
 
+            case 'CANNOT_PROMPT_IN_CI':
+                message = 'A cannot prompt in ci just happened!'
+                break
+
+            case 'APP_VIEW_CONTROLLER_ALREADY_EXISTS':
+                message = `You already have an AppViewController! Run \`spruce sync.views\` if you are having issues.`
+                break
+
             default:
                 message = super.friendlyMessage()
         }

package/src/errors/appViewControllerAlreadyExists.builder.ts

@@ -0,0 +1,7 @@
+import { buildErrorSchema } from '@sprucelabs/schema'
+
+export default buildErrorSchema({
+    id: 'appViewControllerAlreadyExists',
+    name: 'App view controller already exists',
+    fields: {},
+})

package/src/errors/cannotPromptInCi.builder.ts

@@ -0,0 +1,7 @@
+import { buildErrorSchema } from '@sprucelabs/schema'
+
+export default buildErrorSchema({
+    id: 'cannotPromptInCi',
+    name: 'cannot prompt in ci',
+    fields: {},
+})

package/src/features/view/actions/CreateAppAction.ts

@@ -0,0 +1,33 @@
+import { buildSchema } from '@sprucelabs/schema'
+import actionUtil from '../../../utilities/action.utility'
+import AbstractAction from '../../AbstractAction'
+import { FeatureActionResponse } from '../../features.types'
+
+export default class CreateAppAction extends AbstractAction<OptionsSchema> {
+    public optionsSchema = optionsSchema
+    public invocationMessage = 'Creating new app view controller... '
+
+    public async execute(): Promise<FeatureActionResponse> {
+        const writer = this.Writer('view', {})
+        const files = await writer.writeAppViewController(this.cwd)
+
+        const results = await this.Action('view', 'sync').execute({})
+        const merged = actionUtil.mergeActionResults(
+            {
+                files,
+            },
+            results
+        )
+
+        debugger
+
+        return merged
+    }
+}
+
+const optionsSchema = buildSchema({
+    id: 'createAppViewControllerOptions',
+    fields: {},
+})
+
+type OptionsSchema = typeof optionsSchema

package/src/features/view/actions/SyncAction.ts

@@ -1,5 +1,5 @@
 import globby from '@sprucelabs/globby'
-import { buildSchema, SchemaValues } from '@sprucelabs/schema'
+import { buildSchema } from '@sprucelabs/schema'
 import { diskUtil, namesUtil } from '@sprucelabs/spruce-skill-utils'
 import {
     VcTemplateItem,
@@ -16,12 +16,10 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
     public commandAliases = ['sync.views']
     public invocationMessage = 'Syncing view controller types... 🌲'
 
-    public async execute(
-        _options: SchemaValues<OptionsSchema>
-    ): Promise<FeatureActionResponse> {
+    public async execute(): Promise<FeatureActionResponse> {
         const targetDir = diskUtil.resolvePath(this.cwd, 'src')
         const matches = await globby(
-            ['**/*.svc.ts', '**/*.vc.ts', '**/*.view.plugin.ts'],
+            ['**/*.svc.ts', '**/*.vc.ts', '**/*.view.plugin.ts', '**/*.avc.ts'],
             {
                 cwd: targetDir,
             }
@@ -35,12 +33,13 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
         const introspect = introspectionUtil.introspect(paths)
 
         const vcTemplateItems: VcTemplateItem[] = []
+        let appTemplateItem: VcTemplateItem | undefined
         const svcTemplateItems: VcTemplateItem[] = []
         const viewPluginItems: ViewControllerPluginItem[] = []
 
         introspect.forEach(({ classes }) => {
             for (const thisClass of classes) {
-                const { vc, svc, plugin } =
+                const { vc, svc, plugin, avc } =
                     this.mapIntrospectedClassToTemplateItem(thisClass)
 
                 if (vc) {
@@ -49,6 +48,8 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
                     viewPluginItems.push(plugin)
                 } else if (svc) {
                     svcTemplateItems.push(svc)
+                } else if (avc) {
+                    appTemplateItem = avc
                 } else {
                     throw new Error('Unexpected class type.')
                 }
@@ -63,6 +64,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
                 vcTemplateItems,
                 svcTemplateItems,
                 viewPluginItems,
+                appTemplateItem,
             }
         )
 
@@ -75,6 +77,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
         vc?: VcTemplateItem
         svc?: VcTemplateItem
         plugin?: ViewControllerPluginItem
+        avc?: VcTemplateItem
     } {
         const item = {
             id: c.staticProperties.id,
@@ -84,10 +87,13 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
 
         let vc: VcTemplateItem | undefined
         let svc: VcTemplateItem | undefined
+        let avc: VcTemplateItem | undefined
         let plugin: ViewControllerPluginItem | undefined
 
         if (c.classPath.endsWith('.svc.ts')) {
             svc = item
+        } else if (c.classPath.endsWith('avc.ts')) {
+            avc = item
         } else if (c.classPath.endsWith('view.plugin.ts')) {
             const nameCamel = c.classPath.match(/([^/]+).view.plugin.ts$/)![1]
             plugin = { ...item, nameCamel }
@@ -95,7 +101,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
             vc = item
         }
 
-        return { svc, vc, plugin }
+        return { svc, vc, plugin, avc }
     }
 }
 

package/src/features/view/writers/ViewWriter.ts

@@ -214,4 +214,23 @@ export default class ViewWriter extends AbstractWriter {
         )
         return { path, filename }
     }
+
+    public async writeAppViewController(cwd: string) {
+        const match = await globby(cwd + '/**/App.avc.ts')
+
+        if (match.length > 0) {
+            throw new SpruceError({
+                code: 'APP_VIEW_CONTROLLER_ALREADY_EXISTS',
+            })
+        }
+
+        const destination = diskUtil.resolvePath(cwd, 'src', 'App.avc.ts')
+        const contents = this.templates.appViewController()
+
+        return this.writeFileIfChangedMixinResults(
+            destination,
+            contents,
+            'Your new app view controller!'
+        )
+    }
 }

package/src/interfaces/TerminalInterface.ts

@@ -414,6 +414,11 @@ export default class TerminalInterface implements GraphicsInterface {
         definition: T
     ): Promise<FieldDefinitionValueType<T>> {
         this.isPromptActive = true
+
+        if (isCi()) {
+            throw new SpruceError({ code: 'CANNOT_PROMPT_IN_CI' })
+        }
+
         const name = generateInquirerFieldName()
         const fieldDefinition: FieldDefinitions = definition
         const { defaultValue } = fieldDefinition

package/src/tests/fixtures/ViewFixture.ts

@@ -24,7 +24,7 @@ export default class ViewFixture {
             options
         )
 
-        await this.syncAction.execute({})
+        await this.syncAction.execute()
 
         return files[0]
     }

package/src/utilities/isCi.ts

@@ -1,6 +1,10 @@
 export default function isCi() {
     const env = process.env
 
+    if (process.env.IS_TESTING_SELF) {
+        return false
+    }
+
     if (
         [
             'TRAVIS',