submodule-version 1.1.4 → 2.0.2

package/dist/src/versionUtil.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionUtil = void 0;
+var ComapreMode;
+(function (ComapreMode) {
+    ComapreMode[ComapreMode["major"] = 0] = "major";
+    ComapreMode[ComapreMode["minor"] = 1] = "minor";
+    ComapreMode[ComapreMode["path"] = 2] = "path";
+})(ComapreMode || (ComapreMode = {}));
+const cleanup = (v) => v.replace(/^\^?~?/, '');
+const toArray = (v) => (cleanup(v).split('.').map(Number));
+const mode = (v) => {
+    // Minor and path can be vary. Only major should be same
+    if (v.startsWith('^'))
+        return ComapreMode.major;
+    // Path can be vary. Major and minor should be same
+    if (v.startsWith('~'))
+        return ComapreMode.minor;
+    // Everything should be same
+    return ComapreMode.path;
+};
+const compare = (baseVer, actualVer, compareMode) => {
+    const val = new Array(3).fill(null).reduce((acc, _, i) => {
+        // Alrady is not compatible
+        if (!acc)
+            return acc;
+        // Mode not include comparation, version should be same or hier
+        if (i > compareMode)
+            return actualVer[i] >= baseVer[i];
+        return baseVer[i] === actualVer[i];
+    }, true);
+    return val;
+};
+const pick = (allVersions, v) => {
+    if (v === '*')
+        return allVersions;
+    const vMode = mode(v);
+    const vArr = toArray(v);
+    return allVersions.filter(av => {
+        const avArr = toArray(av);
+        return compare(vArr, avArr, vMode);
+    });
+};
+const validate = (v, relative) => {
+    if (relative) {
+        if (v === '*')
+            return true;
+        return /^[\^$]?\d+\.\d+\.\d+$/.test(v);
+    }
+    return /^\d+\.\d+\.\d+$/.test(v);
+};
+const latest = (versions) => (cleanup([...versions].sort((v1, v2) => {
+    const v1Arr = toArray(v1);
+    const v2Arr = toArray(v2);
+    return v1Arr.reduce((acc, v1Val, i) => {
+        if (acc !== 0)
+            return acc;
+        const v2Val = v2Arr[i];
+        return v2Val - v1Val;
+    }, 0);
+})[0]));
+exports.versionUtil = {
+    compare,
+    pick,
+    validate,
+    latest,
+};
+//# sourceMappingURL=versionUtil.js.map

package/dist/src/versionUtil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"versionUtil.js","sourceRoot":"","sources":["../../src/versionUtil.ts"],"names":[],"mappings":"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"}

package/eslint.config.js

@@ -4,6 +4,11 @@ const globals = require('globals');
 module.exports = [
   ...soft,
   {
+    settings: {
+      react: {
+        "version": "100.0.0",
+      },
+    },
     languageOptions: {
       globals: globals.node,
       sourceType: "commonjs",

package/index-dev.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env ts-node
+
+import chalk from 'chalk';
+import { log } from './src/log';
+
+log.message(chalk.bgRed.white.bold(' RUNNED IN DEV MODE '));
+import './src/submoduleVersion';

package/index.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import './src/submoduleVersion';

package/jest.config.js

@@ -0,0 +1,9 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} **/
+module.exports = {
+  testMatch: ['<rootDir>/src/**/*.test.ts'],
+  moduleDirectories: ['node_modules'],
+  testEnvironment: "node",
+  transform: {
+    "^.+.tsx?$": ["ts-jest", {}],
+  },
+};

package/package.json

@@ -1,20 +1,30 @@
 {
   "name": "submodule-version",
   "description": "Git <S>ubmodule <V>ersioning tool",
-  "version": "1.1.4",
+  "version": "2.0.2",
   "bin": {
-    "sv": "index.js"
+    "sv": "dist/index.js",
+    "sv-dev": "index-dev.ts"
   },
   "scripts": {
-    "lint": "npx eslint"
+    "prepare": "npm run build",
+    "test": "npx jest",
+    "build": "npx tsc",
+    "lint": "npx eslint ./src"
   },
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@types/jest": "^29.5.13",
     "eslint": "9.9.1",
-    "eslint-config-soft": "^1.0.5"
+    "eslint-config-soft": "^1.0.5",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2"
   },
   "dependencies": {
+    "chalk": "^4.1.2",
+    "jest": "^29.7.0",
+    "typescript": "^5.6.2",
     "yargs": "^17.7.2"
   }
 }

package/src/__tests__/parseGitUrl.test.ts

@@ -0,0 +1,33 @@
+import { parseGitUrl } from '../parseGitUrl';
+
+describe('Parse git url', () => {
+  it('Without version', () => {
+    const url = 'git@github.com:Casique-front/audio-mixer.git';
+
+    expect(parseGitUrl(url)).toEqual({
+      url: 'git@github.com:Casique-front/audio-mixer.git',
+      version: undefined,
+      name: 'audio-mixer',
+    });
+  });
+
+  it('With version', () => {
+    const url = 'git@github.com:Casique-front/audio-mixer.git@1.0.1';
+
+    expect(parseGitUrl(url)).toEqual({
+      url: 'git@github.com:Casique-front/audio-mixer.git',
+      version: '1.0.1',
+      name: 'audio-mixer',
+    });
+  });
+
+  it('Wrong string', () => {
+    const url = 'xxx@version';
+
+    expect(parseGitUrl(url)).toEqual({
+      url: 'xxx@version',
+      version: null,
+      name: '',
+    });
+  });
+});

package/src/__tests__/versionUtil.test.ts

@@ -0,0 +1,60 @@
+import { versionUtil } from '../versionUtil';
+
+describe('Latest', () => {
+  it('Single version', () => {
+    const v = versionUtil.latest(['1.0.0']);
+
+    expect(v).toBe('1.0.0');
+  });
+
+  it('Path versions', () => {
+    const v = versionUtil.latest(['^1.0.0', '^1.0.1']);
+
+    expect(v).toBe('1.0.1');
+  });
+
+  it('Minor versions', () => {
+    const v = versionUtil.latest(['^1.1.0', '^1.0.23']);
+
+    expect(v).toBe('1.1.0');
+  });
+
+  it('Major versions', () => {
+    const v = versionUtil.latest(['^2.0.0', '^1.10.23']);
+
+    expect(v).toBe('2.0.0');
+  });
+});
+
+describe('Validate', () => {
+  it('Pass', () => {
+    expect(versionUtil.validate('')).toBe(false);
+    expect(versionUtil.validate('123')).toBe(false);
+    expect(versionUtil.validate('1.2.3')).toBe(true);
+    expect(versionUtil.validate('1.2.3', true)).toBe(true);
+    expect(versionUtil.validate('^1.2.3', true)).toBe(true);
+    expect(versionUtil.validate('^1.2.3')).toBe(false);
+    expect(versionUtil.validate('*')).toBe(false);
+    expect(versionUtil.validate('*', true)).toBe(true);
+  });
+});
+
+describe('Compare', () => {
+  it('Major mode', () => {
+    expect(versionUtil.compare([1, 2, 3], [1, 3, 4], 0)).toBe(true);
+    expect(versionUtil.compare([1, 3, 3], [1, 2, 4], 0)).toBe(false);
+    expect(versionUtil.compare([1, 2, 3], [1, 2, 4], 1)).toBe(true);
+    expect(versionUtil.compare([1, 2, 4], [1, 2, 3], 1)).toBe(false);
+  });
+
+  it('Minor mode', () => {
+    expect(versionUtil.compare([1, 2, 3], [1, 2, 4], 1)).toBe(true);
+    expect(versionUtil.compare([1, 2, 4], [1, 2, 3], 1)).toBe(false);
+  });
+
+  it('Path mode', () => {
+    expect(versionUtil.compare([1, 2, 3], [1, 2, 3], 2)).toBe(true);
+    expect(versionUtil.compare([1, 2, 4], [1, 2, 3], 2)).toBe(false);
+    expect(versionUtil.compare([1, 2, 3], [1, 2, 4], 2)).toBe(false);
+  });
+});

package/src/buildGraph.ts

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import { pkgJsonUtil } from './pkgJsonUtil';
+import { log } from './log';
+import { git } from './git';
+import { parseGitUrl } from './parseGitUrl';
+import { versionUtil } from './versionUtil';
+
+type TSV = Record<string, string>;
+
+interface ITreeEntry {
+  meta: {
+    version: string;
+    sv: TSV;
+  };
+  parents: Record<string, string>;
+}
+
+type TBaseTree = Record<string, ITreeEntry>;
+
+export interface IGraphEntry {
+  versions: string[];
+  parents: Record<string, string>;
+  used: string[];
+  version: string;
+}
+
+export const buildGraph = (): Record<string, IGraphEntry> | void => {
+  const baseJson = pkgJsonUtil.read();
+  const baseTree: TBaseTree = {};
+
+  if (!baseJson) return log.error('Not a npm project');
+  if (!baseJson.sv) return log.message('There is no dependencies');
+
+  const recursiveBuilder = (dependencies: TSV = {}, parent = '*') => {
+    Object.entries(dependencies).forEach(([url, version]) => {
+      const { name } = parseGitUrl(url);
+      const jsonPath = pkgJsonUtil.getPkgJsonPath(name);
+      if (!versionUtil.validate(version, true)) {
+        const em = `<${version}> for [${name}] in [${parent}]`;
+
+        return log.error('Unknown version', em);
+      }
+      if (!jsonPath) {
+        git.addSumbmodule(url);
+      }
+
+      const exists = baseTree[name] || null;
+      const mJson = exists ? null : pkgJsonUtil.read(name);
+
+      if (!version) return log.error('Module', name, 'not installed');
+
+      const meta = exists?.meta || { version: mJson.version, sv: mJson.sv };
+      const parents = exists?.parents || {};
+
+      baseTree[name] = {
+        meta,
+        parents: { ...parents, [parent]: version },
+      };
+
+      recursiveBuilder(meta.sv, name);
+    });
+  };
+
+  recursiveBuilder(baseJson.sv, baseJson.name);
+
+  const graph = Object.entries(baseTree).reduce((acc, [name, data]) => {
+    const versions = git.listVersions(name);
+    const { parents, meta } = data;
+
+    const used = Object.entries(parents).reduce((selective, [, v]) => (
+      versionUtil.pick(selective, v)
+    ), versions);
+
+    if (!used.length) {
+      const longestVersion = Object.values(parents).reduce((len, v) => (
+        v.length > len ? v.length : len
+      ), 0);
+
+      const formattedName = chalk.green.bold(name);
+      const baseMsg = `${chalk.red('Confilict')} for ${formattedName}:`;
+
+      const conflictMsg = Object.entries(parents).reduce((msg, [pName, v]) => {
+        const formatedV = chalk.bold.red(String(v).padEnd(longestVersion, ' '));
+
+        return [
+          ...msg,
+          `  - Version ${formatedV} used in ${chalk.green.bold(pName)}`,
+        ];
+      }, [baseMsg]);
+
+      log.error(conflictMsg.join('\n'));
+    }
+
+    if (!used.includes(meta.version)) {
+      git.checkout(name, versionUtil.latest(used));
+    }
+
+    return {
+      ...acc,
+      [name]: { versions, parents, used, version: meta.version },
+    };
+  }, {});
+
+  return graph;
+};

package/src/config.ts

@@ -0,0 +1,4 @@
+export const config = {
+  dir: 'modules',
+  tag: 'master',
+};

package/src/git.ts

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import path from 'path';
+import { config } from './config';
+import { log } from './log';
+import { parseGitUrl } from './parseGitUrl';
+import { versionUtil } from './versionUtil';
+
+const addSumbmodule = (url: string) => {
+  const { name } = parseGitUrl(url);
+  const module = path.join(config.dir, name);
+
+  try {
+    execSync(`git submodule add ${url} ${module}`);
+  } catch {
+    log.error(url, 'Is not a git repo');
+  }
+};
+
+const checkout = (name: string, version: string) => {
+  const module = path.join(config.dir, name);
+  const styledName = chalk.green.bold(name);
+  const styledVer = chalk.green.bold(version);
+  log.message('Checkout', styledName, 'to', styledVer);
+
+  try {
+    execSync(`git -C ${module} fetch`);
+    execSync(`git -C ${module} checkout ${version} -q`);
+  } catch {
+    log.error('Checkout failded');
+  };
+};
+
+const listVersions = (projectName: string) => {
+  const module = path.join(config.dir, projectName);
+  execSync(`git -C ${module} fetch`);
+  const res = execSync(`git -C ${module} tag -l`);
+  const tagList = res.toString().split(/\r?\n/);
+
+  return tagList.filter(tag => {
+    if (!tag) return false;
+
+    return versionUtil.validate(tag);
+  });
+};
+
+export const git = {
+  addSumbmodule,
+  checkout,
+  listVersions,
+};

package/src/install.ts

@@ -0,0 +1,47 @@
+import chalk from "chalk";
+import { parseGitUrl } from "./parseGitUrl";
+import { pkgJsonUtil } from "./pkgJsonUtil";
+import { log } from "./log";
+import { git } from "./git";
+import { versionUtil } from "./versionUtil";
+import { buildGraph } from "./buildGraph";
+
+interface IArg {
+  url: string;
+  target?: string;
+}
+
+/* Yargs typed as any */
+export const install = (arg: any) => {
+  const { target } = arg as IArg;
+  const { url, version, name } = parseGitUrl(arg.url);
+
+  if (!name) {
+    return log.error(chalk.red.bold(url), '- is not a git url!');
+  }
+
+  const targetPkg = pkgJsonUtil.read(target);
+  let installedPkg = pkgJsonUtil.read(name);
+
+  if (!installedPkg) {
+    git.addSumbmodule(url);
+    installedPkg = pkgJsonUtil.read(name);
+  }
+
+  const versions = git.listVersions(name);
+  const latestVersion = versionUtil.latest(versions);
+  const requestedVersion = version || latestVersion;
+
+  if (!versions.includes(requestedVersion)) {
+    const styledName = `Package ${chalk.bold.green(name)}`;
+    const styledVer = chalk.bgRed.bold.white(` ${requestedVersion} `);
+    const errMsg = `does not contain version ${styledVer}.`;
+    const styledVList = chalk.bold.green(versions.join(', '));
+    const helpMsg = `Use one from [${styledVList}]`;
+    log.error(styledName, errMsg, helpMsg);
+  }
+
+  targetPkg.sv[url] = `^${requestedVersion}`;
+  pkgJsonUtil.write(targetPkg, target);
+  buildGraph();
+};

package/src/log.ts

@@ -0,0 +1,16 @@
+import yargs from 'yargs';
+
+const message = (...args: string[]) => {
+  // eslint-disable-next-line no-console
+  console.log(...args);
+};
+
+const error = (...args: string[]) => {
+  message(...args);
+  yargs.exit(1, new Error(args.join(' ')));
+};
+
+export const log = {
+  message,
+  error,
+};

package/src/parseGitUrl.ts

@@ -0,0 +1,31 @@
+interface IParseResult {
+  name: string;
+  url: string;
+  version: string | null;
+}
+
+const PARSE_REGEX = /^(?<url>.*\.git)(@(?<version>.*))?$/;
+const NAME_REGEX = /\/(?<name>.*)\.git/;
+
+const makeEmptyObject = (url: string) => ({
+  name: '',
+  url,
+  version: null,
+});
+
+export const parseGitUrl = (url: string): IParseResult => {
+  const { groups } = PARSE_REGEX.exec(url) || {};
+
+  if (!groups || !groups.url) return makeEmptyObject(url);
+
+  const { groups: nameGroups } = NAME_REGEX.exec(url) || {};
+  const { name } = nameGroups || {};
+
+  if (!name) return makeEmptyObject(url);
+
+  return {
+    url: groups.url,
+    version: groups.version,
+    name,
+  };
+};

package/src/pkgJsonUtil.ts

@@ -0,0 +1,36 @@
+import fs from 'fs';
+import path from 'path';
+import { config } from './config';
+
+const JSON_NAME = 'package.json';
+
+const getPkgJsonPath = (name?: string) => {
+  const folder = name ? [config.dir, name] : [];
+  const jsonPath = path.join(process.cwd(), ...folder, JSON_NAME);
+  const isJsonExists = fs.existsSync(jsonPath);
+  if (!isJsonExists) return null;
+
+  return jsonPath;
+};
+
+const read = (name?: string) => {
+  const jsonPath = getPkgJsonPath(name);
+  if (!jsonPath) return null;
+  const jsonString = fs.readFileSync(jsonPath, 'utf-8');
+
+  return JSON.parse(jsonString);
+};
+
+const write = (data: Object, name?: string) => {
+  const jsonPath = getPkgJsonPath(name);
+  if (!jsonPath) return null;
+  fs.writeFileSync(jsonPath, JSON.stringify(data, null, 2));
+};
+
+export const pkgJsonUtil = {
+  getPkgJsonPath,
+  read,
+  write,
+};
+
+module.exports = { pkgJsonUtil };

package/src/submoduleVersion.ts

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import yargs from 'yargs';
+import { buildGraph } from './buildGraph';
+import { versionUtil } from './versionUtil';
+import { install } from './install';
+import { log } from './log';
+import { git } from './git';
+
+const mainProcess = () => {
+  buildGraph();
+  log.message(chalk.green.bold('Everything is up to date!🔥'));
+};
+
+const update = () => {
+  const graph = buildGraph();
+  if (!graph) return;
+  Object.entries(graph).forEach(([name, data]) => {
+    const { version, used } = data;
+    const latestVersion = versionUtil.latest(used);
+    if (latestVersion !== version) {
+      git.checkout(name, latestVersion);
+    }
+  });
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+yargs.scriptName('sv')
+  .usage('$0 <cmd> [args]')
+  .command(
+    ['validate', '$0', 'v'],
+    'Validate and install modules',
+    () => {},
+    mainProcess,
+  )
+  .command(
+    ['update', 'u'],
+    'Update git modules to actual versions',
+    () => {},
+    update,
+  )
+  .command(
+    ['install <url> [target]', 'i'],
+    'Install new submodule',
+    y => y.positional('url', {
+      type: 'string',
+      describe: 'Git submodule url',
+    }).positional('target', {
+      type: 'string',
+      describe: 'Target module name',
+    }),
+    install,
+  )
+  .help()
+  .argv;

package/src/versionUtil.ts

@@ -0,0 +1,82 @@
+enum ComapreMode {
+  major = 0,
+  minor = 1,
+  path = 2,
+}
+
+const cleanup = (v: string) => v.replace(/^\^?~?/, '');
+
+const toArray = (v: string): number[] => (
+  cleanup(v).split('.').map(Number)
+);
+
+const mode = (v: string) => {
+  // Minor and path can be vary. Only major should be same
+  if (v.startsWith('^')) return ComapreMode.major;
+  // Path can be vary. Major and minor should be same
+  if (v.startsWith('~')) return ComapreMode.minor;
+
+  // Everything should be same
+  return ComapreMode.path;
+};
+
+const compare = (
+  baseVer: number[],
+  actualVer: number[],
+  compareMode: ComapreMode,
+) => {
+  const val = new Array(3).fill(null).reduce((acc, _, i) => {
+    // Alrady is not compatible
+    if (!acc) return acc;
+    // Mode not include comparation, version should be same or hier
+    if (i > compareMode) return actualVer[i] >= baseVer[i];
+
+    return baseVer[i] === actualVer[i];
+  }, true);
+
+  return val;
+};
+
+const pick = (allVersions: string[], v: string) => {
+  if (v === '*') return allVersions;
+
+  const vMode = mode(v);
+  const vArr = toArray(v);
+
+  return allVersions.filter(av => {
+    const avArr = toArray(av);
+
+    return compare(vArr, avArr, vMode);
+  });
+};
+
+const validate = (v: string, relative?: boolean) => {
+  if (relative) {
+    if (v === '*') return true;
+
+    return /^[\^$]?\d+\.\d+\.\d+$/.test(v);
+  }
+
+  return /^\d+\.\d+\.\d+$/.test(v);
+};
+
+const latest = (versions: string[]) => (
+  cleanup([...versions].sort((v1, v2) => {
+    const v1Arr = toArray(v1);
+    const v2Arr = toArray(v2);
+
+    return v1Arr.reduce((acc, v1Val, i) => {
+      if (acc !== 0) return acc;
+      const v2Val = v2Arr[i];
+
+      return v2Val - v1Val;
+    }, 0);
+  })[0])
+);
+
+export const versionUtil = {
+  compare,
+  pick,
+  validate,
+  latest,
+};