simple custom snapshot

Author: GantMan

__tests__/__mocks__/examplePlugin.ts

@@ -1,43 +1,43 @@
-module.exports = (context) => {
+module.exports = context => {
   // Register this plugin
   context.addPlugin({
     name: 'Example Plugin',
     description: 'I help test plugins',
-    snapshot: async (context) => {
+    snapshot: async context => {
       context.addedSnapshot = true
     },
     rules: {
       checkThing: {
         check: async (rule, context) => {
           return {
             pass: true,
-            message: 'Yeah good check!'
+            message: 'Yeah good check!',
           }
         },
         snapshot: async (rule, context) => [
           {
             prop: 'semver',
-            value: '12.0.0'
-          }
+            value: '12.0.0',
+          },
         ],
         report: async (rule, context, report) => {
           // report.cliRules.push(['android', location, binaryVersion, desired])
           report.addCLI({
             binary: 'Android SDK',
             version: 10,
-            desired: 12
+            desired: 12,
           })
-        }
+        },
       },
       checkSecondThing: {
         check: async (rule, context) => {
           return {
             pass: false,
-            message: 'Boooo failed check'
+            message: 'Boooo failed check',
           }
-        }
-      }
-    }
+        },
+      },
+    },
   })
 
   return context

__tests__/__mocks__/mockContext.ts

@@ -24,7 +24,7 @@ const mockContext = {
     spin: jest.fn(() => ({
       stop: jest.fn(),
       fail: jest.fn(),
-      succeed: jest.fn()
+      succeed: jest.fn(),
     })),
     table: jest.fn(),
     xmark: jest.fn(),

__tests__/command_helpers/checkRequirement.ts

@@ -222,6 +222,5 @@ describe('checkRequirement', () => {
       const result = await checkRequirement(rule, context)
       expect(result).toEqual([customError])
     })
-
   })
 })

__tests__/command_helpers/checkRequirementPlugins.ts

@@ -44,5 +44,4 @@ describe('checkRequirement Plugins', () => {
     const result = await checkRequirement(rule, mockContext)
     expect(result).toEqual([error])
   })
-
 })

__tests__/command_helpers/updateRequirement.ts

@@ -1,6 +1,7 @@
 import { platform } from 'os'
 import { toPairs } from 'ramda'
-import context from 'gluegun'
+const examplePlugin = require('examplePlugin')
+const context = examplePlugin(require('mockContext'))
 
 import updateRequirement from '../../src/extensions/functions/updateRequirement'
 
@@ -121,7 +122,19 @@ describe('updateRequirement', () => {
       })
     })
 
-    describe('rule: !cli', () => {
+    describe('rule is custom', () => {
+      it('returns stuff', async () => {
+        const requirement = toPairs({
+          TestRequirement: [{ rule: 'custom', plugin: 'Example Plugin', name: 'checkThing' }],
+        })[0]
+
+        const result = await updateRequirement(requirement, settings, context)
+        expect(result).toEqual([["Setting checkThing 'semver' to '12.0.0'"]])
+        expect(spinner.stop.mock.calls.length).toEqual(1)
+      })
+    })
+
+    describe('rule: !== cli || custom', () => {
       it('returns an empty array', async () => {
         const requirement = toPairs({
           Yarn: [

src/extensions/functions/checkRequirement.ts

@@ -11,12 +11,13 @@ const checkDir = require('./checkDir')
 const checkFile = require('./checkFile')
 const checkShell = require('./checkShell')
 const skipRule = require('./skipRule')
+const findPluginInfo = require('./findPluginInfo')
 
 module.exports = async (
   requirement: SolidarityRequirementChunk,
   context: SolidarityRunContext
 ): Promise<void | object[]> => {
-  const { head, tail, pipe, flatten, map, filter } = require('ramda')
+  const { head, tail, pipe, flatten, map } = require('ramda')
 
   const { print } = context
   const requirementName: string = head(requirement)
@@ -116,12 +117,9 @@ module.exports = async (
           return addFailure(rule.error || `'${rule.command}' output did not match '${rule.match}'`)
         }
       case 'custom':
-        // find correct rule function
-        const correctPlugin = head(filter(plugin => plugin.name === rule.plugin, context._pluginsList))
-        if (correctPlugin === undefined) return addFailure(`Plugin not found '${rule.plugin}'`)
-        const customChecker = correctPlugin.rules && correctPlugin.rules[rule.name] && correctPlugin.rules[rule.name].check
-        if (correctPlugin && customChecker) {
-          const customResult = await customChecker(rule, context)
+        const customPluginRule = findPluginInfo(rule, context)
+        if (customPluginRule.success) {
+          const customResult = await customPluginRule.plugin.check(rule, context)
           if (customResult && customResult.pass) {
             return addSuccess(customResult.message)
           } else {
@@ -132,7 +130,7 @@ module.exports = async (
             return addFailure(rule.error || failMessage)
           }
         } else {
-          return addFailure(`NOT FOUND: Custom rule from '${rule.plugin}' plugin with check function '${rule.name}'`)
+          return addFailure(customPluginRule.message)
         }
       default:
         return addFailure('Encountered unknown rule')

src/extensions/functions/findPluginInfo.ts

@@ -0,0 +1,27 @@
+import { CustomRule, SolidarityRunContext, PluginFind } from '../../types'
+
+const { head, filter } = require('ramda')
+
+module.exports = (rule: CustomRule, context: SolidarityRunContext): PluginFind => {
+  // find correct rule function
+  const correctPlugin = head(filter(plugin => plugin.name === rule.plugin, context._pluginsList))
+  if (correctPlugin === undefined) {
+    return {
+      success: false,
+      message: `Plugin not found '${rule.plugin}'`,
+    }
+  } else {
+    const customRule = correctPlugin.rules && correctPlugin.rules[rule.name]
+    if (customRule) {
+      return {
+        success: true,
+        plugin: customRule,
+      }
+    } else {
+      return {
+        success: false,
+        message: `NOT FOUND: Custom rule from '${rule.plugin}' plugin with check function '${rule.name}'`,
+      }
+    }
+  }
+}

src/extensions/functions/updateRequirement.ts

@@ -1,4 +1,6 @@
 import { SolidarityRequirement, SolidarityRunContext } from '../../types'
+const findPluginInfo = require('./findPluginInfo')
+
 module.exports = async (
   requirement: SolidarityRequirement,
   settings: object,
@@ -18,10 +20,11 @@ module.exports = async (
   // check each rule for requirement
   const ruleChecks = await map(async rule => {
     // skip if we can't update
-    if (skipRule(rule.platform) || !rule.semver) return []
+    if (skipRule(rule.platform)) return []
     switch (rule.rule) {
       // Handle CLI rule update
       case 'cli':
+        if (!rule.semver) return []
         const updateResult = await checkCLIForUpdates(rule, context)
         ruleString = `Keep ${rule.binary} ${rule.semver}`
         if (updateResult) {
@@ -31,6 +34,27 @@ module.exports = async (
           spinner.succeed(ruleString)
           return []
         }
+      case 'custom':
+        const customPluginRule = findPluginInfo(rule, context)
+        if (customPluginRule.success) {
+          const customResult = await customPluginRule.plugin.snapshot(rule, context)
+          const changes = customResult.map(patch => {
+            rule[patch.prop] = patch.value
+            return `'${patch.prop}' to '${patch.value}'`
+          })
+
+          // report changes
+          if (changes.length > 0) {
+            const message = print.colors.green(`Setting ${rule.name} ${changes.join(', ')}`)
+            spinner.succeed(message)
+            return message
+          } else {
+            return []
+          }
+        } else {
+          spinner.fail(customPluginRule.message)
+          return customPluginRule.message
+        }
       default:
         return []
     }

src/types.ts

@@ -102,6 +102,12 @@ export interface CustomRule {
 // discriminated union for rule sets
 export type SolidarityRule = CLIRule | ENVRule | FSRule | ShellRule | CustomRule
 
+export interface PluginFind {
+  success: boolean
+  message?: string
+  plugin?: SolidarityRule
+}
+
 export enum SolidarityOutputMode {
   MODERATE,
   VERBOSE,