feat: barebones dependency conversion

package.json

@@ -30,12 +30,14 @@
     "@commitlint/cli": "17.8.0",
     "@commitlint/config-conventional": "17.8.0",
     "fs-extra": "11.1.1",
-    "husky": "8.0.3"
+    "husky": "8.0.3",
+    "lodash": "4.17.21"
   },
   "devDependencies": {
     "@types/chai": "4.3.5",
     "@types/fs-extra": "11.0.1",
     "@types/glob": "8.1.0",
+    "@types/lodash": "4.17.13",
     "@types/mocha": "10.0.1",
     "@types/mock-fs": "4.13.1",
     "@types/node": "20.8.6",

src/createPackage.ts

@@ -3,6 +3,7 @@ import { execSync } from 'child_process';
 import { copySolidityFiles } from './copySolidityFiles';
 import { PackageJson } from './types';
 import { createReadmeAndLicense } from './createReadmeAndLicense';
+import { parseGitmodulesDependencies } from './parseGitmodulesDependencies';
 import { ExportType } from './constants';
 
 export const createPackage = (
@@ -25,12 +26,14 @@ export const createPackage = (
   // Read and copy the input package.json
   const inputPackageJson = fse.readJsonSync('./package.json');
   if (!inputPackageJson) throw new Error('package.json not found');
+  const gitDependencies = parseGitmodulesDependencies();
   // Create custom package.json in the export directory
   const packageJson: PackageJson = {
     name: packageFullName,
     version: inputPackageJson.version,
     dependencies: {
       ...inputPackageJson.dependencies,
+      ...gitDependencies,
     },
   };
   fse.writeJsonSync(`${destinationDir}/package.json`, packageJson, { spaces: 4 });

src/parseGitmodulesDependencies.ts

@@ -0,0 +1,23 @@
+import { chunk } from 'lodash';
+import fse from 'fs-extra';
+
+export const parseGitmodulesDependencies = (): { [key: string]: string } => {
+  let iniAsStr;
+  try {
+    iniAsStr = fse.readFileSync('./.gitmodules', { encoding: 'utf8' });
+  } catch {
+    return {};
+  }
+  const matches = [...iniAsStr.matchAll(/(?:path|url) = (.*)/g)].map(regexMatch => regexMatch[1]);
+  if (matches.length == 0) return {};
+
+  // this assumes .gitmodules to be well formed, same amount of paths and urls
+  const dependencyPairs = chunk(matches, 2);
+
+  // and path is always before url
+  const dependencyObject = dependencyPairs.reduce<{ [key: string]: string }>((acc, curr) => {
+    acc[curr[0].replace('lib/', '')] = curr[1];
+    return acc;
+  }, {});
+  return dependencyObject;
+};

src/transformRemappings.ts

@@ -37,7 +37,7 @@ export const transformRemappings = (file: string): string => {
         line = line.replace(remappingOrigin, remappingDestination);
       }
 
-      line = line.replace(/(['""]).*node_modules\//, `$1`);
+      line = line.replace(/(['""]).*(?:node_modules|lib)\//, `$1`);
 
       return line;
     })

test/unit/parseGitmodulesDependencies.spec.ts

@@ -0,0 +1,129 @@
+import { expect } from 'chai';
+import mock from 'mock-fs';
+import { parseGitmodulesDependencies } from '../../src/parseGitmodulesDependencies';
+
+describe('parseGitmodulesDependencies', () => {
+  before(() => {
+    mock.restore();
+  });
+  after(() => {
+    mock.restore();
+  });
+
+  describe('with no gitmodules file', function () {
+    it('should return an empty dependency list', function () {
+      const parsedDependencies = parseGitmodulesDependencies();
+      expect(parsedDependencies).to.deep.eq({});
+    });
+  });
+
+  describe('with an empty file', function () {
+    before(() => {
+      mock({
+        '.gitmodules': '',
+      });
+    });
+    it('should return an empty dependency list', function () {
+      const parsedDependencies = parseGitmodulesDependencies();
+      expect(parsedDependencies).to.deep.eq({});
+    });
+  });
+
+  describe('with a file with several dependencies', function () {
+    before(() => {
+      mock({
+        '.gitmodules': `
+      [submodule "lib/forge-std"]
+        path = lib/forge-std
+        url = https://github.com/foundry-rs/forge-std
+      [submodule "lib/openzeppelin-contracts"]
+        path = lib/openzeppelin-contracts
+        url = https://github.com/OpenZeppelin/openzeppelin-contracts
+      `,
+      });
+    });
+    it('should be able to parse them', function () {
+      const parsedDependencies = parseGitmodulesDependencies();
+      expect(parsedDependencies['forge-std']).to.eq('https://github.com/foundry-rs/forge-std');
+      expect(parsedDependencies['openzeppelin-contracts']).to.eq(
+        'https://github.com/OpenZeppelin/openzeppelin-contracts',
+      );
+      expect(Object.keys(parsedDependencies)).to.have.length(2);
+    });
+  });
+
+  describe('with a file with extra (valid) keys besides path and url', function () {
+    before(() => {
+      mock({
+        '.gitmodules': `
+      [submodule "lib/forge-std"]
+        path = lib/forge-std
+        branch = .
+        url = https://github.com/foundry-rs/forge-std
+      [submodule "lib/openzeppelin-contracts"]
+        ignore = all
+        path = lib/openzeppelin-contracts
+        url = https://github.com/OpenZeppelin/openzeppelin-contracts
+      `,
+      });
+    });
+    it('should be able to parse them', function () {
+      const parsedDependencies = parseGitmodulesDependencies();
+      expect(parsedDependencies['forge-std']).to.eq('https://github.com/foundry-rs/forge-std');
+      expect(parsedDependencies['openzeppelin-contracts']).to.eq(
+        'https://github.com/OpenZeppelin/openzeppelin-contracts',
+      );
+      expect(Object.keys(parsedDependencies)).to.have.length(2);
+    });
+  });
+
+  describe('with a file where subsection keys are specified in multiple subsection definitions', function () {
+    before(() => {
+      // this is valid syntax according to git, but our regex 'parser' can't handle it
+      mock({
+        '.gitmodules': `
+      [submodule "lib/openzeppelin-contracts"]
+        url = https://github.com/OpenZeppelin/openzeppelin-contracts
+      [submodule "lib/forge-std"]
+        path = lib/forge-std
+      [submodule "lib/openzeppelin-contracts"]
+        path = lib/openzeppelin-contracts
+      [submodule "lib/forge-std"]
+        url = https://github.com/foundry-rs/forge-std
+      `,
+      });
+    });
+    it.skip('should be able to parse them', function () {
+      const parsedDependencies = parseGitmodulesDependencies();
+      expect(parsedDependencies['forge-std']).to.eq('https://github.com/foundry-rs/forge-std');
+      expect(parsedDependencies['openzeppelin-contracts']).to.eq(
+        'https://github.com/OpenZeppelin/openzeppelin-contracts',
+      );
+      expect(Object.keys(parsedDependencies)).to.have.length(2);
+    });
+  });
+
+  describe('with a file urls come before paths', function () {
+    before(() => {
+      // this is valid syntax according to git, but our regex 'parser' can't handle it
+      mock({
+        '.gitmodules': `
+      [submodule "lib/openzeppelin-contracts"]
+        url = https://github.com/OpenZeppelin/openzeppelin-contracts
+        path = lib/openzeppelin-contracts
+      [submodule "lib/forge-std"]
+        url = https://github.com/foundry-rs/forge-std
+        path = lib/forge-std
+      `,
+      });
+    });
+    it.skip('should be able to parse them', function () {
+      const parsedDependencies = parseGitmodulesDependencies();
+      expect(parsedDependencies['forge-std']).to.eq('https://github.com/foundry-rs/forge-std');
+      expect(parsedDependencies['openzeppelin-contracts']).to.eq(
+        'https://github.com/OpenZeppelin/openzeppelin-contracts',
+      );
+      expect(Object.keys(parsedDependencies)).to.have.length(2);
+    });
+  });
+});

test/unit/transformRemappings.spec.ts

@@ -115,6 +115,37 @@ describe('transformRemappings', () => {
     });
   });
 
+  describe('with remapping for path inside lib/', function () {
+    before(() => {
+      mock({
+        'remappings.txt': `
+          solmate/=lib/solmate/src/`,
+      });
+    });
+
+    it('should apply remapping and then remove lib from path', () => {
+      const fileContent = `
+                                  import {FixedPointMathLib} from 'solmate/utils/FixedPointMathLib.sol';
+                                  import 'solmate/utils/FixedPointMathLib.sol';
+                                  import "solmate/utils/FixedPointMathLib.sol";
+                                  import {FixedPointMathLib as FPL} from 'solmate/utils/FixedPointMathLib.sol';
+                                  import * as FPL from "solmate/utils/FixedPointMathLib.sol";
+                                `;
+
+      const transformedContent = transformRemappings(fileContent);
+
+      expect(transformedContent).to.include(
+        `import {FixedPointMathLib} from 'solmate/src/utils/FixedPointMathLib.sol';`,
+      );
+      expect(transformedContent).to.include(`import 'solmate/src/utils/FixedPointMathLib.sol';`);
+      expect(transformedContent).to.include(`import "solmate/src/utils/FixedPointMathLib.sol";`);
+      expect(transformedContent).to.include(
+        `import {FixedPointMathLib as FPL} from 'solmate/src/utils/FixedPointMathLib.sol';`,
+      );
+      expect(transformedContent).to.include(`import * as FPL from "solmate/src/utils/FixedPointMathLib.sol";`);
+    });
+  });
+
   it('should leave unrelated imports alone', () => {
     const fileContent = `
       import './Contract.sol';