feat: added script support

Author: Murat

src/__tests__/unit/tasks/appDelegateTask.spec.ts

@@ -194,7 +194,7 @@ describe('appDelegateTask', () => {
           prepend: '#import <Firebase.h>',
         },
         {
-          when: { test: 'random' },
+          when: 'test === "random"',
           block: 'didFinishLaunchingWithOptions',
           prepend: '[FIRApp configure];',
         },

src/__tests__/unit/tasks/scriptTask.spec.ts

@@ -0,0 +1,26 @@
+import { scriptTask } from '../../../tasks/scriptTask';
+import { ScriptTaskType } from '../../../types/mod.types';
+import { variables } from '../../../variables';
+
+describe('scriptTask', () => {
+  it('should work', async () => {
+    const task: ScriptTaskType = {
+      task: 'script',
+      actions: [
+        {
+          script: `
+            set('script', 'working')
+          `,
+        },
+      ],
+    };
+
+    await scriptTask({
+      configPath: 'path/to/config',
+      task: task,
+      packageName: 'test-package',
+    });
+
+    expect(variables.get('script')).toEqual('working');
+  });
+});

src/__tests__/unit/utils/applyContentModification.spec.ts

@@ -1,8 +1,8 @@
+require('../../mocks/mockAll');
+
 import { findOrCreateBlock } from '../../../tasks/buildGradleTask';
 import { applyContentModification } from '../../../utils/applyContentModification';
 
-require('../../mocks/mockAll');
-
 describe('applyContentModification', () => {
   it('should replace without search correctly', async () => {
     let content = `
@@ -30,6 +30,36 @@ buildscript {
         google();
     }
 }
+`);
+  });
+  it('should replace using script correctly', async () => {
+    let content = `
+buildscript {
+    ext {
+        jcenter();
+        jcenter();
+    }
+}
+`;
+    content = await applyContentModification({
+      action: {
+        block: 'buildscript.ext',
+        script: `
+          await replace("google();")
+        `,
+      },
+      findOrCreateBlock,
+      configPath: 'path/to/config',
+      packageName: 'package-name',
+      content,
+      indentation: 4,
+    });
+    expect(content).toMatch(`
+buildscript {
+    ext {
+        google();
+    }
+}
 `);
   });
 });

src/__tests__/unit/utils/upgrade/runUpgradeTasks.spec.ts

@@ -46,8 +46,7 @@ env:
   value: true
 steps:
   - task: app_delegate
-    when:
-      value: false
+    when: '!value'
     actions:
       - append: test`
     );

src/__tests__/unit/variables.spec.ts

@@ -84,9 +84,19 @@ describe('variables', () => {
       expect(replaced).toEqual('this is test');
     });
     it('should replace with description for non existing variables', () => {
-      const replaced = getText('this is $[test:description]');
+      const replaced = getText(
+        'this is $[get("nonExisting") ?? "description"]'
+      );
       expect(replaced).toEqual('this is description');
     });
+    it('should process script', () => {
+      const replaced = getText(`this is $[
+        set("test", false);
+        test = true;
+      ]`);
+      expect(replaced).toEqual('this is true');
+      expect(variables.get('test')).toEqual(true);
+    });
   });
   describe('transformTextInObject', () => {
     it('should return null', () => {

src/integrate.ts

@@ -13,12 +13,12 @@ import {
 import { AnalyzedPackages, LockProjectData } from './types/integrator.types';
 import { IntegrationConfig, PackageWithConfig } from './types/mod.types';
 import { analyzePackages } from './utils/analyzePackages';
+import { checkCondition } from './utils/checkCondition';
 import { getErrMessage } from './utils/getErrMessage';
 import { getPackageConfig } from './utils/getPackageConfig';
 import { logInfoNote } from './utils/logInfoNote';
 import { parseConfig } from './utils/parseConfig';
 import { runTask } from './utils/runTask';
-import { satisfies } from './utils/satisfies';
 import { setState } from './utils/setState';
 import { taskManager } from './utils/taskManager';
 import { topologicalSort } from './utils/topologicalSort';
@@ -260,10 +260,7 @@ export async function integrate(packageName?: string): Promise<void> {
         await logInfoNote(config.preInfo);
 
         for (const task of config.steps) {
-          if (
-            task.when &&
-            !satisfies(variables.getStore(), transformTextInObject(task.when))
-          ) {
+          if (task.when && !checkCondition(task.when)) {
             setState(task.name, {
               state: 'skipped',
               error: false,

src/processScript.ts

@@ -0,0 +1,112 @@
+/* eslint-disable @typescript-eslint/no-unused-vars,@typescript-eslint/no-implied-eval,no-shadow-restricted-names,@typescript-eslint/no-unsafe-call */
+import type { variables } from './variables';
+
+const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+
+export function processScript(
+  script: string,
+  _variables: typeof variables,
+  inline: boolean,
+  async: true,
+  ctx?: any
+): Promise<any>;
+export function processScript(
+  script: string,
+  _variables: typeof variables,
+  inline: boolean,
+  async: false,
+  ctx?: any
+): any;
+export function processScript(
+  script: string,
+  _variables: typeof variables,
+  inline: boolean,
+  async: boolean,
+  ctx?: any
+): any {
+  const randomEvalName = 'eval_' + Math.random().toString().substring(2);
+  const functionSet = {
+    get: function (variable: string): any {
+      return _variables.get(variable);
+    },
+    set: function (variable: string, value: any): any {
+      if (!_variables.has(variable))
+        Object.defineProperty(scope, variable, {
+          get(): any {
+            return _variables.get(variable);
+          },
+          set(value): any {
+            return _variables.set(variable, value);
+          },
+        });
+
+      _variables.set(variable, value);
+
+      return '';
+    },
+    json: function (object: any): string {
+      return JSON.stringify(object, null, 2);
+    },
+    parse: function (str: string): any {
+      return JSON.parse(str);
+    },
+    require: function () {
+      throw new Error('require is not allowed');
+    },
+    Function: function () {
+      throw new Error('Function is not allowed');
+    },
+    __import_not_allowed: function () {
+      throw new Error('import is not allowed');
+    },
+    globalThis: undefined,
+    global: undefined,
+  };
+  const scope = Object.assign(
+    Object.keys(globalThis).reduce(
+      (acc, k) => {
+        acc[k] = undefined;
+        return acc;
+      },
+      {} as Record<string, any>
+    ),
+    functionSet,
+    ctx
+  );
+
+  for (const storeKey in _variables.getStore()) {
+    Object.defineProperty(scope, randomEvalName, {
+      value: eval,
+    });
+    Object.defineProperty(scope, storeKey, {
+      get(): any {
+        return _variables.get(storeKey);
+      },
+      set(value): any {
+        return _variables.set(storeKey, value);
+      },
+    });
+  }
+  script = script.replace(/\bimport\(/g, '__import_not_allowed(');
+  script = 'var eval=undefined;' + script;
+
+  if (async) {
+    if (inline) {
+      return new AsyncFunction(
+        'script',
+        'with(this) { return eval(script) }'
+      ).call(scope, script);
+    } else {
+      return new AsyncFunction('with(this) { ' + script + ' }').call(scope);
+    }
+  }
+
+  if (inline) {
+    return new Function('script', 'with(this) { return eval(script) }').call(
+      scope,
+      script
+    );
+  } else {
+    return new Function('with(this) { ' + script + ' }').call(scope);
+  }
+}