feat(existing-vcs): handle self-hosted vcs hosts for existing remote details

Author: travi

package-lock.json

@@ -72,7 +72,7 @@
     "deepmerge": "^4.2.2",
     "execa": "^9.5.1",
     "filedirname": "^3.0.0",
-    "hosted-git-info": "^8.0.0",
+    "git-url-parse": "^16.1.0",
     "joi": "^17.1.1",
     "mustache": "4.2.0",
     "simple-git": "^3.16.0",

package.json

@@ -1,5 +1,5 @@
 import {simpleGit} from 'simple-git';
-import hostedGitInfo from 'hosted-git-info';
+import parseGitUrl from 'git-url-parse';
 import {warn} from '@travi/cli-messages';
 
 async function getExistingRemotes(git) {
@@ -17,9 +17,9 @@ async function getExistingRemotes(git) {
 export async function determineExistingVcsDetails({projectRoot}) {
   const git = simpleGit({baseDir: projectRoot});
   const remoteOrigin = await git.remote(['get-url', 'origin']);
-  const {user, project, type} = hostedGitInfo.fromUrl(remoteOrigin);
+  const {owner, name, host} = parseGitUrl(remoteOrigin.trimEnd());
 
-  return {vcs: {owner: user, name: project, host: type}};
+  return {vcs: {owner, name, host: 'github.com' === host ? 'github' : host}};
 }
 
 export async function defineRemoteOrigin(projectRoot, sshUrl) {

src/vcs/git/remotes.js

@@ -1,35 +1,54 @@
 import {simpleGit} from 'simple-git';
-import hostedGitInfo from 'hosted-git-info';
+import parseGitUrl from 'git-url-parse';
 
-import {describe, vi, it, expect} from 'vitest';
+import {describe, vi, it, expect, beforeEach} from 'vitest';
 import {when} from 'vitest-when';
 import any from '@travi/any';
 
 import {determineExistingVcsDetails, defineRemoteOrigin} from './remotes.js';
 
 vi.mock('simple-git');
-vi.mock('hosted-git-info');
+vi.mock('git-url-parse');
 
 describe('Git remote', () => {
   const projectRoot = any.string();
 
   describe('determine', () => {
+    const remote = vi.fn();
+    const remoteOrigin = any.url();
+    const repoName = any.word();
+    const vcsHostAccount = any.word();
+
+    beforeEach(() => {
+      when(simpleGit).calledWith({baseDir: projectRoot}).thenReturn({remote});
+    });
+
     it('should determine existing vcs details from the remote origin definition of the local repository', async () => {
-      const remote = vi.fn();
-      const remoteOrigin = any.url();
-      const repoName = any.word();
       const vcsHost = `F${any.word()})O${any.word()}O`;
-      const vcsHostAccount = any.word();
-      when(simpleGit).calledWith({baseDir: projectRoot}).thenReturn({remote});
-      when(remote).calledWith(['get-url', 'origin']).thenResolve(remoteOrigin);
-      when(hostedGitInfo.fromUrl)
+      when(remote).calledWith(['get-url', 'origin']).thenResolve(`${remoteOrigin}\n`);
+      when(parseGitUrl)
         .calledWith(remoteOrigin)
-        .thenReturn({user: vcsHostAccount, project: repoName, type: vcsHost.toLowerCase()});
+        .thenReturn({owner: vcsHostAccount, name: repoName, host: vcsHost.toLowerCase()});
 
       const {vcs: hostDetails} = await determineExistingVcsDetails({projectRoot});
 
       expect(hostDetails).toEqual({host: vcsHost.toLowerCase(), owner: vcsHostAccount, name: repoName});
     });
+
+    it(
+      'should return `github` when the host is determined to be `github.com` until that can be a breaking change',
+      async () => {
+        when(simpleGit).calledWith({baseDir: projectRoot}).thenReturn({remote});
+        when(remote).calledWith(['get-url', 'origin']).thenResolve(`${remoteOrigin}\n`);
+        when(parseGitUrl)
+          .calledWith(remoteOrigin)
+          .thenReturn({owner: vcsHostAccount, name: repoName, host: 'github.com'});
+
+        const {vcs: hostDetails} = await determineExistingVcsDetails({projectRoot});
+
+        expect(hostDetails).toEqual({host: 'github', owner: vcsHostAccount, name: repoName});
+      }
+    );
   });
 
   describe('define', () => {

src/vcs/git/remotes.test.js

@@ -10,7 +10,7 @@ export default async function scaffoldVcs({projectRoot, projectName, decisions,
     if (await alreadyVersionedByGit({projectRoot})) {
       info('Git repository already exists');
 
-      return {vcs: await determineExistingVcsDetails({projectRoot})};
+      return determineExistingVcsDetails({projectRoot});
     }
 
     const [{vcs: {host, owner, name, sshUrl}}] = await Promise.all([

src/vcs/scaffolder.js

@@ -49,7 +49,7 @@ describe('vcs scaffolder', () => {
     when(alreadyVersionedByGit).calledWith({projectRoot}).thenResolve(true);
     when(determineExistingVcsDetails).calledWith({projectRoot}).thenResolve(existingVcsDetails);
 
-    expect(await scaffoldVcs({projectRoot, decisions})).toEqual({vcs: existingVcsDetails});
+    expect(await scaffoldVcs({projectRoot, decisions})).toEqual(existingVcsDetails);
   });
 
   it('should not scaffold a repository or vcs host details when a repository should not be created', async () => {

src/vcs/scaffolder.test.js

@@ -8,6 +8,7 @@ import stubbedFs from 'mock-fs';
 import {Before, After, Given, When, setWorldConstructor} from '@cucumber/cucumber';
 import any from '@travi/any';
 import * as td from 'testdouble';
+import {assert} from 'chai';
 
 import {World} from '../support/world.mjs';
 
@@ -22,6 +23,7 @@ const stubbedNodeModules = stubbedFs.load(resolve(...projectPath, 'node_modules'
 
 Before({timeout: 20 * 1000}, async function () {
   this.projectRoot = process.cwd();
+  this.projectName = 'project-name';
   this.git = await td.replaceEsm('simple-git');
 
   // eslint-disable-next-line import/no-extraneous-dependencies,import/no-unresolved
@@ -49,7 +51,6 @@ When(/^the project is scaffolded$/, async function () {
   const chosenLanguage = this.getAnswerFor(questionNames.PROJECT_LANGUAGE) || 'Other';
   const vcsHost = this.getAnswerFor(questionNames.REPO_HOST);
 
-  this.projectName = 'project-name';
   this.projectDescription = any.sentence();
   this.projectHomepage = any.url();
 
@@ -65,9 +66,16 @@ When(/^the project is scaffolded$/, async function () {
       languages: {
         ...'Other' !== chosenLanguage && {
           [chosenLanguage]: {
-            scaffold: ({projectName}) => {
+            scaffold: ({projectName, vcs}) => {
               info(`Scaffolding ${chosenLanguage} language details for ${projectName}`);
 
+              if (repoShouldBeCreated && ((vcsHost && 'Other' !== vcsHost) || this.existingVcsHost)) {
+                assert.equal(vcs.name, this.projectName);
+                if ('GitHub' === this.existingVcsHost) {
+                  assert.equal(vcs.host, 'github');
+                }
+              }
+
               return this.languageScaffolderResults;
             },
             test: ({projectRoot}) => {

test/integration/features/step_definitions/common-steps.js

@@ -32,6 +32,7 @@ Given(/^the project should not be versioned in git$/, async function () {
 Given('the project root is already initialized as a git repository', async function () {
   this.existingVcsIgnoredFiles = any.listOf(any.word);
   this.existingVcsIgnoredDirectories = any.listOf(any.word);
+  this.existingVcsHost = 'GitHub';
 
   await fs.mkdir(`${process.cwd()}/.git`, {recursive: true});
   await fs.writeFile(

test/integration/features/step_definitions/vcs/git-steps.js

@@ -16,6 +16,7 @@ Given('the repository is hosted on {string}', async function (host) {
   this.repoHost = host;
   this.vcsOwner = any.word();
   this.vcsName = any.word();
+  this.setAnswerFor(questionNames.REPO_HOST, this.repoHost);
 });
 
 Then('the project repository is hosted on the chosen host', async function () {