Merge pull request #339 from twilio/master-main-template

Master main template

Author: ktalebian

packages/create-flex-plugin/src/lib/__tests__/commands.test.ts

@@ -113,7 +113,7 @@ describe('commands', () => {
       };
       const parseGitHubUrl = jest
         .spyOn(github, 'parseGitHubUrl')
-        .mockReturnValue(info);
+        .mockResolvedValue(info);
       const downloadRepo = jest
         .spyOn(github, 'downloadRepo')
         .mockResolvedValue(null);

packages/create-flex-plugin/src/lib/commands.ts

@@ -61,7 +61,7 @@ export const setupConfiguration = (config: FlexPluginArguments): FlexPluginArgum
  * @param dir {string}                  the temp directory to save the downloaded file to
  */
 export const downloadFromGitHub = async (url: string, dir: string) => {
-  const info = github.parseGitHubUrl(url);
+  const info = await github.parseGitHubUrl(url);
 
   return await github.downloadRepo(info, dir);
 };

packages/create-flex-plugin/src/utils/__tests__/github.test.ts

@@ -26,24 +26,53 @@ describe('github', () => {
   });
 
   describe('parseGitHubUrl', () => {
-    it('should get repo and master ref', () => {
-      const resp = github.parseGitHubUrl(gitHubUrl);
+    const branchesWithMaster = [{ name: 'master' }, { name: 'feature-branch' }];
+    const branchesWithMain = [{ name: 'main' }, { name: 'feature-branch' }];
+    const branchesWithNeither = [{ name: 'something-else' }, { name: 'feature-branch' }];
+
+    it('should get repo with master ref', async () => {
+      mockAxios.onGet().reply(() => Promise.resolve([200, branchesWithMaster]));
+      const resp = await github.parseGitHubUrl(gitHubUrl);
 
       expect(resp.ref).toEqual('master');
       expect(resp.repo).toEqual('flex-plugin-builder');
       expect(resp.owner).toEqual('twilio');
     });
 
-    it('should get repo and some ref', () => {
-      const resp = github.parseGitHubUrl(`${gitHubUrl}/tree/some-ref`);
+    it('should get repo with main ref', async () => {
+      mockAxios.onGet().reply(() => Promise.resolve([200, branchesWithMain]));
+      const resp = await github.parseGitHubUrl(gitHubUrl);
+
+      expect(resp.ref).toEqual('main');
+      expect(resp.repo).toEqual('flex-plugin-builder');
+      expect(resp.owner).toEqual('twilio');
+    });
+
+    it('should reject because main/main is not found', async (done) => {
+      mockAxios.onGet().reply(() => Promise.resolve([200, branchesWithNeither]));
+      try {
+        await github.parseGitHubUrl(gitHubUrl);
+      } catch (e) {
+        expect(e.message).toEqual(github.ERROR_BRANCH_MASTER_MAIN);
+        done();
+      }
+    });
+
+    it('should get repo and some ref', async () => {
+      const resp = await github.parseGitHubUrl(`${gitHubUrl}/tree/some-ref`);
 
       expect(resp.ref).toEqual('some-ref');
       expect(resp.repo).toEqual('flex-plugin-builder');
       expect(resp.owner).toEqual('twilio');
     });
 
-    it('should fail to parse', () => {
-      expect(() => github.parseGitHubUrl('/broken')).toThrow();
+    it('should fail to parse', async (done) => {
+      try {
+        await github.parseGitHubUrl('/broken');
+      } catch (e) {
+        expect(e.message).toEqual(github.ERROR_GITHUB_URL_PARSE);
+        done();
+      }
     });
   });
 

packages/create-flex-plugin/src/utils/github.ts

@@ -9,6 +9,12 @@ export interface GitHubInfo {
   ref: string;
 }
 
+export interface GitHubBranches {
+  name: string;
+  commit: string;
+  protected: boolean;
+}
+
 export enum GitHubContentType {
   File = 'file',
   Dir = 'dir',
@@ -31,24 +37,46 @@ export interface GitHubContent {
   };
 }
 
+export const ERROR_GITHUB_URL_PARSE = 'Could not get owner and repo name from GitHub URL';
+export const ERROR_BRANCH_MASTER_MAIN = 'Could not find branch main or master on GitHub';
+
 /**
  * Parses the GitHub URL to extract owner and repo information
  *
  * @param url {string}  the GitHub URL
  * @return returns the {@link GitHubInfo}
  */
-export const parseGitHubUrl = (url: string): GitHubInfo => {
+export const parseGitHubUrl = async (url: string): Promise<GitHubInfo> => {
   const matches = url.match(/github\.com\/([0-9a-zA-Z-_]+)\/([0-9a-zA-Z-_]+)(\/tree\/([0-9a-zA-Z._-]+))?/);
 
   if (!matches || matches.length < 3) {
-    throw new Error('Could not get owner and repo name from GitHub URL');
+    throw new Error(ERROR_GITHUB_URL_PARSE);
   }
 
-  return {
+  const info: GitHubInfo = {
     owner: matches[1],
     repo: matches[2],
     ref: matches[4] || 'master',
   };
+
+  // Check whether master or main exists
+  if (info.ref === 'master' || info.ref === 'main') {
+    const branches = await axios.get<GitHubBranches[]>(`https://api.github.com/repos/${info.owner}/${info.repo}/branches`)
+      .then((resp) => resp.data);
+
+    const hasMaster = branches.find((branch) => branch.name === 'master');
+    const hasMain = branches.find((branch) => branch.name === 'main');
+
+    if (hasMain) {
+      info.ref = 'main';
+    } else if (hasMaster) {
+      info.ref = 'master';
+    } else {
+      throw new Error(ERROR_BRANCH_MASTER_MAIN);
+    }
+  }
+
+  return info;
 };
 
 /**