fix: use shared config fns (#12)

2nthony · web-flow · commit 86075e9f02c4 · 2022-07-13T01:54:26.000+08:00
diff --git a/README.md b/README.md
@@ -25,8 +25,8 @@ $ ghq
 npx ghq-node
 ```
 
-```console
-ghq/1.0.1
+```
+ghq/0.0.0
 
 Usage:
   $ ghq <command> [options]
@@ -35,12 +35,14 @@ Commands:
   get [repo]     Clone/sync with a remote repository
   create [repo]  Create a new repository
   list [query]   List local repositories
-  root           Show repositories' root
+  config         Manage the ghq configuration file
+  root           Alias to `ghq config --get.root`
 
 For more info, run any command with the `--help` flag:
   $ ghq get --help
   $ ghq create --help
   $ ghq list --help
+  $ ghq config --help
   $ ghq root --help
 
 Options:
diff --git a/package.json b/package.json
@@ -34,6 +34,7 @@
     "prettier": "2.5.1",
     "tsup": "6.0.1",
     "typescript": "4.5.4",
+    "url-join": "^5.0.0",
     "vitest": "0.12.6"
   }
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
diff --git a/src/commands/config.ts b/src/commands/config.ts
@@ -1,4 +1,9 @@
-import { printConfig, writeUserConfig } from '../config'
+import {
+  existsUserConfig,
+  printConfig,
+  writeUserConfig,
+  ghqConfigFileName,
+} from '../config'
 import { Config, OptionalConfig, PluginApi } from '../types'
 
 export const config: PluginApi = {
@@ -11,6 +16,13 @@ export const config: PluginApi = {
       .example('ghq config --get.root')
       .option('-l, --list', 'List all')
       .action(async (options) => {
+        if (!(await existsUserConfig())) {
+          console.info(
+            '`' + ghqConfigFileName + '` file not found!',
+            'Fallback to default configs.\n',
+          )
+        }
+
         if (options.list) {
           await printConfig()
           return
diff --git a/src/commands/get.ts b/src/commands/get.ts
@@ -6,6 +6,7 @@ export const get: PluginApi = {
   extend(api) {
     api.cli
       .command('get [repo]', 'Clone/sync with a remote repository')
+      .alias('clone')
       .example('ghq get 2nthony/ghq')
       .example('ghq get github.com/2nthony/ghq')
       .example('ghq get https://github.com/2nthony/ghq')
diff --git a/src/commands/list.ts b/src/commands/list.ts
@@ -1,26 +1,29 @@
 import { PluginApi } from '../types'
 import path from 'path'
-import { rootPath } from '../shared'
 import { analyzeUrl } from '../shared/url'
 import { collectDirs } from '../fs'
 import { PathLike } from 'fs'
+import { resolveConfig } from '../config'
 
 export const list: PluginApi = {
   extend(api) {
     api.cli
       .command('list [query]', 'List local repositories')
+      .alias('ls')
       .option('-p, --full-path', 'Print full path', {
         default: false,
       })
       .action(async (query, { fullPath }) => {
+        const { root } = await resolveConfig()
+
         /**
          * deep `4` means:
          * 1 ~/ghq
          * 2 github.com
          * 3 user
          * 4 repo
          */
-        let entries = await collectDirs(rootPath, 4)
+        let entries = await collectDirs(root, 4)
 
         if (query) {
           entries = entries.filter((entry) => {
@@ -39,7 +42,7 @@ export const list: PluginApi = {
         }
 
         function relativeRootPath(entryPath: PathLike) {
-          return path.relative(rootPath, entryPath.toString())
+          return path.relative(root, entryPath.toString())
         }
 
         function print(entry: PathLike) {
diff --git a/src/commands/root.ts b/src/commands/root.ts
@@ -1,12 +1,11 @@
-import { rootPath } from '../shared'
+import { resolveConfig } from '../config'
 import { PluginApi } from '../types'
 
 export const root: PluginApi = {
   extend(api) {
-    api.cli
-      .command('root', "Show repositories' root (un-implemented)")
-      .action(() => {
-        console.info(rootPath)
-      })
+    api.cli.command('root', 'Alias to `ghq config --get.root`').action(() => {
+      const { root } = resolveConfig()
+      console.info(root)
+    })
   },
 }
diff --git a/src/config.ts b/src/config.ts
@@ -1,11 +1,10 @@
 import { Config, OptionalConfig } from './types'
 import { homedir } from 'os'
-import path from 'path'
-import { read, writeJson } from './fs'
-import { expandTildePath } from './path'
+import { exists, read, writeJson } from './fs'
+import { expandTildePath, join } from './path'
 
-const ghqConfigFileName = '.ghqrc'
-const userConfigFilePath = path.join(homedir(), ghqConfigFileName)
+export const ghqConfigFileName = '.ghqrc'
+export const userConfigFilePath = join(homedir(), ghqConfigFileName)
 
 const defaultConfig: Config = {
   root: '~/ghq',
@@ -27,19 +26,14 @@ export async function readConfig() {
   }
 }
 
-export async function readUserConfig(): Promise<OptionalConfig> {
-  const rawConfig = await read(userConfigFilePath)
-
-  if (!rawConfig) {
-    console.info(
-      '`' + ghqConfigFileName + '` file not found!',
-      'Fallback to default configs.\n',
-    )
-    return {}
-  }
+export async function existsUserConfig() {
+  return await exists(userConfigFilePath)
+}
 
+export async function readUserConfig(): Promise<OptionalConfig> {
   try {
-    return JSON.parse(rawConfig)
+    const rawConfig = await read(userConfigFilePath)
+    return rawConfig ? JSON.parse(rawConfig) : {}
   } catch {
     return {}
   }
diff --git a/src/fs.ts b/src/fs.ts
@@ -1,22 +1,24 @@
 import { PathLike } from 'fs'
 import fs from 'fs/promises'
-import path from 'path'
+import { join } from './path'
 import { Config } from './types'
 
 export async function makeDir(dirPath: PathLike) {
   return await fs.mkdir(dirPath, { recursive: true })
 }
 
-export async function exists(dirPath: PathLike) {
-  return await fs
-    .access(dirPath)
-    .then(() => true)
-    .catch(() => false)
+export async function exists(targetPath: PathLike) {
+  try {
+    await fs.access(targetPath)
+    return true
+  } catch {
+    return false
+  }
 }
 
-export async function read(targetPath: PathLike) {
+export async function read(filePath: PathLike) {
   try {
-    return await fs.readFile(targetPath, 'utf8')
+    return await fs.readFile(filePath, 'utf8')
   } catch {
     return ''
   }
@@ -37,6 +39,10 @@ export async function collectDirs(dirPath: PathLike, deep = 1) {
   await read(dirPath)
 
   async function read(currentDirPath: typeof dirPath) {
+    if (!(await exists(currentDirPath))) {
+      return
+    }
+
     currentDeep += 1
 
     if (currentDeep === deep) {
@@ -51,7 +57,7 @@ export async function collectDirs(dirPath: PathLike, deep = 1) {
     for (let index = 0; index < dirDirents.length; index++) {
       const dirent = dirDirents[index]
 
-      await read(path.join(currentDirPath.toString(), dirent.name))
+      await read(join(currentDirPath.toString(), dirent.name))
 
       /**
        * if this dirent is the last directory
diff --git a/src/git.ts b/src/git.ts
@@ -1,12 +1,13 @@
 import { execSync, spawn } from 'child_process'
-import path from 'path'
-import { rootPath } from './shared'
+import { resolveConfig } from './config'
 import { exists, makeDir } from './fs'
+import { join } from './path'
 import { analyzeUrl, composeUrl } from './shared/url'
 import { Repo } from './types'
 
-export function repoDest(repo: Repo) {
-  return path.join(rootPath, repo.host, repo.user, repo.name)
+export async function repoDest(repo: Repo) {
+  const { root } = await resolveConfig()
+  return join(root, repo.host, repo.user, repo.name)
 }
 
 function git(cmd: string, dest: string, ...args: string[]) {
@@ -19,7 +20,7 @@ export const username = getUsername()
 
 export async function clone(repoUrl: string, ...args: string[]) {
   const repo = analyzeUrl(repoUrl)
-  const dest = repoDest(repo)
+  const dest = await repoDest(repo)
 
   if (!(await exists(dest))) {
     await makeDir(dest)
@@ -30,7 +31,7 @@ export async function clone(repoUrl: string, ...args: string[]) {
 
 export async function init(repoUrl: string, ...args: string[]) {
   const repo = analyzeUrl(repoUrl)
-  const dest = repoDest(repo)
+  const dest = await repoDest(repo)
 
   if (!(await exists(dest))) {
     await makeDir(dest)
diff --git a/src/path.ts b/src/path.ts
@@ -3,8 +3,12 @@ import { homedir } from 'os'
 
 export function expandTildePath(pathWithTilde: string) {
   if (pathWithTilde[0] === '~') {
-    pathWithTilde = path.join(homedir(), pathWithTilde.slice(1))
+    pathWithTilde = join(homedir(), pathWithTilde.slice(1))
   }
 
-  return pathWithTilde
+  return path.normalize(pathWithTilde)
+}
+
+export function join(...p: string[]) {
+  return path.normalize(path.join(...p))
 }
diff --git a/src/shared/index.ts b/src/shared/index.ts
@@ -1,8 +1,3 @@
-import { homedir } from 'os'
-import path from 'path'
-
-export const rootPath = path.join(homedir(), 'ghq')
-
 export function parseOptionsToArgs(options: {
   [k: string]: any
 }): readonly string[] {
diff --git a/src/shared/url.ts b/src/shared/url.ts
@@ -1,7 +1,6 @@
-import path from 'path/posix'
-import { URL } from 'url'
 import { username } from '../git'
 import { Repo } from '../types'
+import urlJoin from 'url-join'
 
 // TODO: only github for now
 const re =
@@ -35,8 +34,7 @@ export function analyzeUrl(url: string): Repo {
 }
 
 export function composeUrl(repo: Repo) {
-  const url = new URL(repo.protocol + '//' + repo.host)
-  url.pathname = path.join(repo.user, repo.name)
+  const url = urlJoin(`${repo.protocol}//${repo.host}`, repo.user, repo.name)
 
-  return url.toString()
+  return url
 }
diff --git a/test/config.test.ts b/test/config.test.ts
@@ -0,0 +1,19 @@
+import { describe, expect, test } from 'vitest'
+import { readUserConfig, userConfigFilePath } from '../src/config'
+import { exists } from '../src/fs'
+
+describe('user config', async () => {
+  const existsConfigFile = await exists(userConfigFilePath)
+
+  test.runIf(existsConfigFile)('assert config', async () => {
+    const config = await readUserConfig()
+
+    expect(config).toBeTypeOf('object')
+  })
+
+  test.runIf(!existsConfigFile)('no config file', async () => {
+    const config = await readUserConfig()
+
+    expect(config).toEqual({})
+  })
+})
diff --git a/test/fs.test.ts b/test/fs.test.ts
@@ -1,38 +1,38 @@
 import { afterEach, beforeEach, describe, expect, test } from 'vitest'
 import os from 'os'
-import path from 'path'
 import fs from 'fs/promises'
 import { collectDirs, makeDir } from '../src/fs'
+import { join } from '../src/path'
 
 describe('collect dirs', () => {
   const tmpdir = os.tmpdir()
-  const test_dir_base = path.join(tmpdir, 'ghq')
-  const test_dir = path.join(test_dir_base, 'deep2', 'deep3', 'deep4')
+  const test_dir_base = join(tmpdir, 'ghq')
+  const test_dir = join(test_dir_base, 'deep2', 'deep3', 'deep4')
 
   beforeEach(async () => {
     await makeDir(test_dir)
   })
 
   afterEach(async () => {
-    await fs.rm(path.join(test_dir_base), {
+    await fs.rm(join(test_dir_base), {
       recursive: true,
       force: true,
     })
   })
 
   test('1', async () => {
     const dirs = await collectDirs(test_dir_base)
-    expect(dirs).toContain(path.join(test_dir_base))
+    expect(dirs).toContain(join(test_dir_base))
   })
 
   test('3', async () => {
     const dirs = await collectDirs(test_dir_base, 3)
-    expect(dirs).toContain(path.join(test_dir_base, 'deep2', 'deep3'))
+    expect(dirs).toContain(join(test_dir_base, 'deep2', 'deep3'))
   })
 
   test('4', async () => {
     const dirs = await collectDirs(test_dir_base, 4)
-    expect(dirs).toContain(path.join(test_dir_base, 'deep2', 'deep3', 'deep4'))
+    expect(dirs).toContain(join(test_dir_base, 'deep2', 'deep3', 'deep4'))
   })
 
   test('over deep will be empty', async () => {
diff --git a/test/git.test.ts b/test/git.test.ts
diff --git a/test/path.test.ts b/test/path.test.ts

Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,7 @@`
`34`	`34`	`"prettier": "2.5.1",`
`35`	`35`	`"tsup": "6.0.1",`
`36`	`36`	`"typescript": "4.5.4",`
	`37`	`+ "url-join": "^5.0.0",`
`37`	`38`	`"vitest": "0.12.6"`
`38`	`39`	`}`
`39`	`40`	`}`