fix(core): update

ts/mod_format/format.cleanup.ts

@@ -0,0 +1,19 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+
+import { logger } from '../gitzone.logging.js';
+import { Project } from '../classes.project.js';
+
+const filesToDelete = ['defaults.yml', 'yarn.lock', 'package-lock.json', 'tslint.json'];
+
+export const run = async (projectArg: Project) => {
+  for (const relativeFilePath of filesToDelete) {
+    const fileExists = plugins.smartfile.fs.fileExistsSync(relativeFilePath);
+    if (fileExists) {
+      logger.log('info', `Found ${relativeFilePath}! Removing it!`);
+      plugins.smartfile.fs.removeSync(plugins.path.join(paths.cwd, relativeFilePath));
+    } else {
+      logger.log('info', `Project is free of ${relativeFilePath}`);
+    }
+  }
+};

ts/mod_format/format.copy.ts

@@ -0,0 +1,6 @@
+import type { Project } from '../classes.project.js';
+import * as plugins from '../plugins.js';
+
+export const run = async (projectArg: Project) => {
+  const gitzoneConfig = await projectArg.gitzoneConfig;
+}

ts/mod_format/format.gitignore.ts

@@ -0,0 +1,21 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+
+import { Project } from '../classes.project.js';
+
+import { logger } from '../gitzone.logging.js';
+const gitignorePath = plugins.path.join(paths.cwd, './.gitignore');
+
+export const run = async (projectArg: Project) => {
+  const gitignoreExists = await plugins.smartfile.fs.fileExists(gitignorePath);
+  const templateModule = await import('../mod_template/index.js');
+  const ciTemplate = await templateModule.getTemplate('gitignore');
+  if (gitignoreExists) {
+    // lets get the existing gitignore file
+    const existingGitIgnoreString = plugins.smartfile.fs.toStringSync(gitignorePath);
+    let customPart = existingGitIgnoreString.split('# custom\n')[1];
+    customPart ? null : (customPart = '');
+  }
+  ciTemplate.writeToDisk(paths.cwd);
+  logger.log('info', 'Added a .gitignore!');
+};

ts/mod_format/format.license.ts

@@ -0,0 +1,24 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+import { Project } from '../classes.project.js';
+
+import { logger } from '../gitzone.logging.js';
+
+const incompatibleLicenses: string[] = [
+  "AGPL",
+  "GPL",
+  "SSPL",
+];
+
+export const run = async (projectArg: Project) => {
+  const licenseChecker = await plugins.smartlegal.createLicenseChecker();
+  const licenseCheckResult = await licenseChecker.excludeLicenseWithinPath(paths.cwd, incompatibleLicenses);
+  if (licenseCheckResult.failingModules.length === 0) {
+    logger.log('info', 'Success -> licenses passed!');
+  } else {
+    logger.log('error', 'Error -> licenses failed. Here is why:');
+    for (const failedModule of licenseCheckResult.failingModules) {
+      console.log(`${failedModule.name} fails with license ${failedModule.license}`);
+    }
+  }
+};

ts/mod_format/format.npmextra.ts

@@ -0,0 +1,70 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+import * as gulpFunction from '@push.rocks/gulp-function';
+import { Project } from '../classes.project.js';
+
+/**
+ * runs the npmextra file checking
+ */
+export const run = async (projectArg: Project) => {
+  const formatSmartstream = new plugins.smartstream.StreamWrapper([
+    plugins.smartgulp.src([`npmextra.json`]),
+    gulpFunction.forEach(async (fileArg: plugins.smartfile.SmartFile) => {
+      const fileString = fileArg.contents.toString();
+      const npmextraJson = JSON.parse(fileString);
+
+      if (!npmextraJson.gitzone) {
+        npmextraJson.gitzone = {};
+      }
+
+      const expectedRepoInformation: string[] = [
+        'projectType',
+        'module.githost',
+        'module.gitscope',
+        'module.gitrepo',
+        'module.description',
+        'module.npmPackagename',
+        'module.license',
+      ];
+
+      const interactInstance = new plugins.smartinteract.SmartInteract();
+      for (const expectedRepoInformationItem of expectedRepoInformation) {
+        if (!plugins.smartobject.smartGet(npmextraJson.gitzone, expectedRepoInformationItem)) {
+          interactInstance.addQuestions([
+            {
+              message: `What is the value of ${expectedRepoInformationItem}`,
+              name: expectedRepoInformationItem,
+              type: 'input',
+              default: 'undefined variable',
+            },
+          ]);
+        }
+      }
+
+      const answerbucket = await interactInstance.runQueue();
+      for (const expectedRepoInformationItem of expectedRepoInformation) {
+        const cliProvidedValue = answerbucket.getAnswerFor(expectedRepoInformationItem);
+        if (cliProvidedValue) {
+          plugins.smartobject.smartAdd(
+            npmextraJson.gitzone,
+            expectedRepoInformationItem,
+            cliProvidedValue
+          );
+        }
+      }
+
+      // delete obsolete
+      // tbd
+
+      if (!npmextraJson.npmci) {
+        npmextraJson.npmci = {};
+      }
+
+      fileArg.setContentsFromString(JSON.stringify(npmextraJson, null, 2));
+    }),
+    plugins.smartgulp.replace(),
+  ]);
+  await formatSmartstream.run().catch((error) => {
+    console.log(error);
+  });
+};

ts/mod_format/format.packagejson.ts

@@ -0,0 +1,120 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+import * as gulpFunction from '@push.rocks/gulp-function';
+import { Project } from '../classes.project.js';
+
+import { logger } from '../gitzone.logging.js';
+
+/**
+ * ensures a certain dependency
+ */
+const ensureDependency = async (
+  packageJsonObjectArg: any,
+  position: 'dep' | 'devDep' | 'everywhere',
+  constraint: 'exclude' | 'include' | 'latest',
+  dependencyArg: string
+) => {};
+
+export const run = async (projectArg: Project) => {
+  const formatStreamWrapper = new plugins.smartstream.StreamWrapper([
+    plugins.smartgulp.src([`package.json`]),
+    gulpFunction.forEach(async (fileArg: plugins.smartfile.SmartFile) => {
+      const npmextraConfig = new plugins.npmextra.Npmextra(paths.cwd);
+      const gitzoneData: any = npmextraConfig.dataFor('gitzone', {});
+      const fileString = fileArg.contents.toString();
+      const packageJson = JSON.parse(fileString);
+
+      // metadata
+      packageJson.repository = {
+        "type": "git",
+        "url": `git+https://${gitzoneData.module.githost}/${gitzoneData.module.gitscope}/${gitzoneData.module.gitrepo}.git`
+      };
+      packageJson.bugs = {
+        "url": `https://${gitzoneData.module.githost}/${gitzoneData.module.gitscope}/${gitzoneData.module.gitrepo}/issues`
+      },
+      packageJson.homepage = `https://${gitzoneData.module.githost}/${gitzoneData.module.gitscope}/${gitzoneData.module.gitrepo}#readme`;
+
+
+      // Check for module type
+      if (!packageJson.type) {
+        logger.log('info', `setting packageJson.type to "module"`);
+        packageJson.type = 'module';
+      }
+
+      // Check for private or public
+      if (packageJson.private !== undefined) {
+        logger.log('info', 'Success -> found private/public info in package.json!');
+      } else {
+        logger.log('error', 'found no private boolean! Setting it to private for now!');
+        packageJson.private = true;
+      }
+
+      // Check for license
+      if (packageJson.license) {
+        logger.log('info', 'Success -> found license in package.json!');
+      } else {
+        logger.log('error', 'found no license! Setting it to UNLICENSED for now!');
+        packageJson.license = 'UNLICENSED';
+      }
+
+      // Check for build script
+      if (packageJson.scripts.build) {
+        logger.log('info', 'Success -> found build script in package.json!');
+      } else {
+        logger.log('error', 'found no build script! Putting a placeholder there for now!');
+        packageJson.scripts.build = `echo "Not needed for now"`;
+      }
+
+      // Check for buildDocs script
+      if (!packageJson.scripts.buildDocs) {
+        logger.log('info', 'found no buildDocs script! Putting tsdoc script there now.');
+        packageJson.scripts.buildDocs = `tsdoc`;
+      }
+
+      // check package.json
+      if (!packageJson.main) {
+        logger.log('error', 'no "main" property');
+        process.exit(0);
+      }
+      if (!packageJson.typings) {
+        logger.log('error', 'no "typings" property');
+        process.exit(0);
+      }
+      if (!packageJson.browserslist) {
+        packageJson.browserslist = ['last 1 chrome versions'];
+      }
+      if (!packageJson.main.includes('dist_') || !packageJson.typings.includes('dist_')) {
+        logger.log('error', 'check packagesJson main and typings');
+        process.exit(0);
+      }
+
+      // check for files
+      packageJson.files = [
+        'ts/**/*',
+        'ts_web/**/*',
+        'dist/**/*',
+        'dist_*/**/*',
+        'dist_ts/**/*',
+        'dist_ts_web/**/*',
+        'assets/**/*',
+        'cli.js',
+        'npmextra.json',
+        'readme.md',
+      ];
+
+      // check for dependencies
+      await ensureDependency(packageJson, 'devDep', 'latest', '@push.rocks/tapbundle');
+      await ensureDependency(packageJson, 'devDep', 'latest', '@git.zone/tstest');
+      await ensureDependency(packageJson, 'devDep', 'latest', '@git.zone/tsbuild');
+
+      // exclude
+      // TODO
+
+      fileArg.setContentsFromString(JSON.stringify(packageJson, null, 2));
+    }),
+    plugins.smartgulp.replace(),
+  ]);
+  await formatStreamWrapper.run().catch((error) => {
+    console.log(error);
+  });
+};

ts/mod_format/format.prettier.ts

@@ -0,0 +1,58 @@
+import * as plugins from './mod.plugins.js';
+import prettier from 'prettier';
+import { Project } from '../classes.project.js';
+
+import { logger } from '../gitzone.logging.js';
+
+const prettierDefaultTypeScriptConfig: prettier.Options = {
+  printWidth: 100,
+  parser: 'typescript',
+  singleQuote: true,
+};
+
+const prettierDefaultMarkdownConfig: prettier.Options = {
+  singleQuote: true,
+  printWidth: 100,
+  parser: 'markdown',
+};
+
+const filesToFormat = [`ts/**/*.ts`, `test/**/*.ts`, `readme.md`, `docs/**/*.md`];
+
+const choosePrettierConfig = (fileArg: plugins.smartfile.SmartFile) => {
+  switch (fileArg.parsedPath.ext) {
+    case '.ts':
+      return prettierDefaultTypeScriptConfig;
+    case '.md':
+      return prettierDefaultMarkdownConfig;
+    default:
+      return {};
+  }
+};
+
+const prettierTypeScriptPipestop = plugins.through2.obj(
+  async (fileArg: plugins.smartfile.SmartFile, enc, cb) => {
+    const fileString = fileArg.contentBuffer.toString();
+    const chosenConfig = choosePrettierConfig(fileArg);
+    const filePasses = prettier.check(fileString, chosenConfig);
+    if (filePasses) {
+      logger.log('info', `OK! -> ${fileArg.path} passes!`);
+      cb(null);
+    } else {
+      logger.log('info', `${fileArg.path} is being reformated!`);
+      const formatedFileString = await prettier.format(fileString, chosenConfig);
+      fileArg.setContentsFromString(formatedFileString);
+      cb(null, fileArg);
+    }
+  }
+);
+
+export const run = async (projectArg: Project) => {
+  const formatStreamWrapper = new plugins.smartstream.StreamWrapper([
+    plugins.smartgulp.src(filesToFormat),
+    prettierTypeScriptPipestop,
+    plugins.smartgulp.replace(),
+  ]);
+  await formatStreamWrapper.run().catch((error) => {
+    console.log(error);
+  });
+};

ts/mod_format/format.readme.ts

@@ -0,0 +1,47 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+import { GitzoneConfig } from '../classes.gitzoneconfig.js';
+import { Project } from '../classes.project.js';
+
+export const run = async (projectArg: Project) => {
+  const readmePath = plugins.path.join(paths.cwd, 'readme.md');
+  const readmeFile = await plugins.smartfile.SmartFile.fromFilePath(readmePath);
+
+  // lets do our transformation
+
+  let usageInfo: string = '';
+  const gitzoneConfig = await GitzoneConfig.fromCwd();
+
+  if (readmeFile) {
+    const readmeFileString = readmeFile.contentBuffer.toString();
+    const stringArray1 = readmeFileString.split('## Usage\n');
+    if (stringArray1[1]) {
+      const stringArray2 = stringArray1[1].split(
+        '\nFor further information read the linked docs at the top of this readme.'
+      );
+      const stringArray3 = stringArray2[0].split('\n\n## Contribution');
+      usageInfo = stringArray3[0];
+    }
+  }
+
+  if (gitzoneConfig.data.module && gitzoneConfig.data.module.license === 'MIT') {
+    usageInfo +=
+      '\n\n## Contribution\n\n' +
+      'We are always happy for code contributions. If you are not the code contributing type that is ok. ' +
+      'Still, maintaining Open Source repositories takes considerable time and thought. ' +
+      'If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: ' +
+      'You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)\n';
+  }
+
+  const templateModule = await import('../mod_template/index.js');
+  const readmeTemplate = await templateModule.getTemplate('readme');
+  console.log(gitzoneConfig.data);
+  await readmeTemplate.supplyVariables({
+    module: {
+      ...gitzoneConfig.data.module,
+    },
+    usageInfo,
+  });
+  await readmeTemplate.askCliForMissingVariables();
+  await readmeTemplate.writeToDisk(paths.cwd);
+};

ts/mod_format/format.templates.ts

@@ -0,0 +1,71 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+
+import { logger } from '../gitzone.logging.js';
+import { Project } from '../classes.project.js';
+
+/**
+ * takes care of updating files from templates
+ */
+export const run = async (project: Project) => {
+  const templateModule = await import('../mod_template/index.js');
+
+  // update tslint
+  // getting template
+  const tslintTemplate = await templateModule.getTemplate('tslint');
+  await tslintTemplate.writeToDisk(paths.cwd);
+  logger.log('info', 'Updated tslint.json!');
+
+  // update vscode
+  const vscodeTemplate = await templateModule.getTemplate('vscode');
+  await vscodeTemplate.writeToDisk(paths.cwd);
+  logger.log('info', `Updated vscode template!`);
+
+  // update gitlab ci and Dockerfile
+  switch (project.gitzoneConfig.data.projectType) {
+    case 'npm':
+    case 'wcc':
+      if (project.gitzoneConfig.data.npmciOptions.npmAccessLevel === 'public') {
+        const ciTemplateDefault = await templateModule.getTemplate('ci_default');
+        ciTemplateDefault.writeToDisk(paths.cwd);
+      } else {
+        const ciTemplateDefault = await templateModule.getTemplate('ci_default_private');
+        ciTemplateDefault.writeToDisk(paths.cwd);
+      }
+      logger.log('info', 'Updated .gitlabci.yml!');
+      break;
+    case 'service':
+    case 'website':
+      const ciTemplateDocker = await templateModule.getTemplate('ci_docker');
+      await ciTemplateDocker.writeToDisk(paths.cwd);
+      logger.log('info', 'Updated .gitlabci.yml!');
+
+      // lets care about docker
+      const dockerTemplate = await templateModule.getTemplate('dockerfile_service');
+      dockerTemplate.writeToDisk(paths.cwd);
+      logger.log('info', 'Updated Dockerfile!');
+
+      // lets care about cli
+      const cliTemplate = await templateModule.getTemplate('cli');
+      await cliTemplate.writeToDisk(paths.cwd);
+      logger.log('info', 'Updated cli.ts.js and cli.js!');
+      break;
+    default:
+      break;
+  }
+
+  // update html
+  if (project.gitzoneConfig.data.projectType === 'website') {
+    const websiteUpdateTemplate = await templateModule.getTemplate('website_update');
+    await websiteUpdateTemplate.writeToDisk(paths.cwd);
+    logger.log('info', `Updated html for website!`);
+  } else if (project.gitzoneConfig.data.projectType === 'service') {
+    const websiteUpdateTemplate = await templateModule.getTemplate('service_update');
+    await websiteUpdateTemplate.writeToDisk(paths.cwd);
+    logger.log('info', `Updated html for element template!`);
+  } else if (project.gitzoneConfig.data.projectType === 'wcc') {
+    const wccUpdateTemplate = await templateModule.getTemplate('wcc_update');
+    await wccUpdateTemplate.writeToDisk(paths.cwd);
+    logger.log('info', `Updated html for wcc template!`);
+  }
+};

ts/mod_format/index.ts

@@ -0,0 +1,38 @@
+import * as plugins from './mod.plugins.js';
+import { Project } from '../classes.project.js';
+
+export let run = async (write: boolean = true): Promise<any> => {
+  const project = await Project.fromCwd();
+
+  // cleanup
+  const formatCleanup = await import('./format.cleanup.js');
+  await formatCleanup.run(project);
+
+  // npmextra
+  const formatNpmextra = await import('./format.npmextra.js');
+  await formatNpmextra.run(project);
+
+  // license
+  const formatLicense = await import('./format.license.js');
+  await formatLicense.run(project);
+
+  // format package.json
+  const formatPackageJson = await import('./format.packagejson.js');
+  await formatPackageJson.run(project);
+
+  // format .gitlab-ci.yml
+  const formatTemplates = await import('./format.templates.js');
+  await formatTemplates.run(project);
+
+  // format .gitignore
+  const formatGitignore = await import('./format.gitignore.js');
+  await formatGitignore.run(project);
+
+  // format TypeScript
+  const formatPrettier = await import('./format.prettier.js');
+  await formatPrettier.run(project);
+
+  // format readme.md
+  const formatReadme = await import('./format.readme.js');
+  // await formatReadme.run();
+};

ts/mod_format/mod.plugins.ts

@@ -0,0 +1,13 @@
+export * from '../plugins.js';
+
+import * as lik from '@push.rocks/lik';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartgulp from '@push.rocks/smartgulp';
+import * as smartinteract from '@push.rocks/smartinteract';
+import * as smartlegal from '@push.rocks/smartlegal';
+import * as smartobject from '@push.rocks/smartobject';
+import * as smartnpm from '@push.rocks/smartnpm';
+import * as smartstream from '@push.rocks/smartstream';
+import * as through2 from 'through2';
+
+export { lik, smartfile, smartgulp, smartinteract, smartlegal, smartobject, smartnpm, smartstream, through2 };