formatted code

Author: septs

.eslintrc

@@ -2,7 +2,11 @@
   "root": true,
   "parser": "@typescript-eslint/parser",
   "plugins": ["@typescript-eslint"],
-  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended", "prettier/@typescript-eslint"],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "prettier/@typescript-eslint"
+  ],
   "rules": {
     "@typescript-eslint/no-explicit-any": 0,
     "@typescript-eslint/explicit-module-boundary-types": 0

.prettierrc

@@ -1,3 +1,5 @@
 {
-  "printWidth": 160
+  "quoteProps": "consistent",
+  "singleQuote": true,
+  "trailingComma": "all"
 }

README.md

@@ -10,7 +10,7 @@ Forked from [git-rev-sync-js](https://github.com/kurttheviking/git-rev-sync-js).
 ## usage
 
 ```typescript
-import git from "@nice-labs/git-rev";
+import git from '@nice-labs/git-rev';
 
 // short commit-hash
 console.log(git.commitHash(true)); // 75bf4ee

src/exec.ts

@@ -1,13 +1,20 @@
-import { execFileSync } from "child_process";
+import { execFileSync } from 'child_process';
 
-export type ExecValue = string | number | ExecValue[] | undefined | null | false | Record<string, boolean | undefined | null>;
+export type ExecValue =
+  | string
+  | number
+  | ExecValue[]
+  | undefined
+  | null
+  | false
+  | Record<string, boolean | undefined | null>;
 
 export const git = (values: ExecValue[], cwd?: string) =>
-  execFileSync("git", pattern(values), {
+  execFileSync('git', pattern(values), {
     cwd,
     shell: false,
-    stdio: ["inherit", "pipe", "pipe"],
-    encoding: "utf-8",
+    stdio: ['inherit', 'pipe', 'pipe'],
+    encoding: 'utf-8',
     maxBuffer: 0xffff, // 65535 bytes
     timeout: 60000, // one minute
   }).trim();
@@ -19,9 +26,9 @@ function pattern(...rest: ExecValue[]) {
       continue;
     } else if (Array.isArray(value)) {
       values = values.concat(pattern(...value));
-    } else if (typeof value === "string" || typeof value === "number") {
+    } else if (typeof value === 'string' || typeof value === 'number') {
       values = values.concat([String(value)]);
-    } else if (typeof value === "object") {
+    } else if (typeof value === 'object') {
       values = values.concat(Object.keys(value).filter((key) => value[key]));
     }
   }

src/git-agent.ts

@@ -1,16 +1,16 @@
-import { Git } from "./git";
+import { Git } from './git';
 
 export class GitAgent extends Git {
   public commit(message: string) {
-    this.git("commit", "-am", message);
+    this.git('commit', '-am', message);
   }
 
   public createTag(tag: string) {
-    this.git("tag", tag);
+    this.git('tag', tag);
   }
 
   public createBranch(name: string, remoteName?: string) {
-    this.git("branch", name);
+    this.git('branch', name);
     if (remoteName) {
       const branch = this.branchName();
       this.checkoutBranch(name);
@@ -25,31 +25,35 @@ export class GitAgent extends Git {
 
   public deleteBranch(name: string, remoteName?: string) {
     if (remoteName) {
-      return this.git("push", remoteName, "--delete", name);
+      return this.git('push', remoteName, '--delete', name);
     }
-    return this.git("branch", "--delete", name);
+    return this.git('branch', '--delete', name);
   }
 
   public checkoutBranch(name: string) {
-    this.git("checkout", name);
+    this.git('checkout', name);
   }
 
   public push(options?: PushOptions) {
     const opts = {
-      "--force": options?.force ?? false,
-      "--tags": options?.includeTags ?? false,
-      "--no-verify": !options?.verify,
+      '--force': options?.force ?? false,
+      '--tags': options?.includeTags ?? false,
+      '--no-verify': !options?.verify,
     };
-    const track = options?.track && ["--set-upstream", options?.remoteName ?? "origin", this.branchName()];
-    this.git("push", opts, track);
+    const track = options?.track && [
+      '--set-upstream',
+      options?.remoteName ?? 'origin',
+      this.branchName(),
+    ];
+    this.git('push', opts, track);
   }
 
   public getField(name: string) {
-    return this.git("config", "--get", name);
+    return this.git('config', '--get', name);
   }
 
   public setField(name: string, value: string) {
-    return this.git("config", name, value);
+    return this.git('config', name, value);
   }
 }
 

src/git-base.ts

@@ -1,4 +1,4 @@
-import { ExecValue, git } from "./exec";
+import { ExecValue, git } from './exec';
 
 export { ExecValue };
 

src/git.ts

@@ -1,13 +1,13 @@
-import { basename } from "path";
-import { ExecValue, GitBase } from "./git-base";
+import { basename } from 'path';
+import { ExecValue, GitBase } from './git-base';
 
 export class Git extends GitBase {
   public constructor(cwd?: string) {
     super(cwd);
   }
 
   public getTopLevel() {
-    return this.git("rev-parse", "--show-toplevel");
+    return this.git('rev-parse', '--show-toplevel');
   }
 
   public isRepository() {
@@ -19,91 +19,98 @@ export class Git extends GitBase {
     return true;
   }
 
-  public branchName(rev = "HEAD") {
-    return this.git("rev-parse", "--abbrev-ref", rev);
+  public branchName(rev = 'HEAD') {
+    return this.git('rev-parse', '--abbrev-ref', rev);
   }
 
-  public commitHash(short: boolean | number = false, rev = "HEAD") {
-    const makeShort = () => (typeof short === "number" && `--short=${short}`) || (short && "--short");
-    return this.git("rev-parse", makeShort(), rev);
+  public commitHash(short: boolean | number = false, rev = 'HEAD') {
+    const makeShort = () =>
+      (typeof short === 'number' && `--short=${short}`) || (short && '--short');
+    return this.git('rev-parse', makeShort(), rev);
   }
 
   public commitDate(rev?: string) {
-    return new Date(this.logN1("%aI", rev));
+    return new Date(this.logN1('%aI', rev));
   }
 
   public commitCount() {
-    return Number.parseInt(this.git("rev-list", "--all", "--count"), 10);
+    return Number.parseInt(this.git('rev-list', '--all', '--count'), 10);
   }
 
   public message(rev?: string) {
-    return this.logN1("%B", rev);
+    return this.logN1('%B', rev);
   }
 
   public describe(...values: ExecValue[]) {
-    return this.git("describe", ...values);
+    return this.git('describe', ...values);
   }
 
   public tag(options?: TagOptions) {
     return this.describe(
-      "--always",
-      "--tag",
-      "--abbrev=0",
-      { "--dirty": options?.markDirty, "--first-parent": options?.firstParent },
-      options?.match && ["--match", options?.match]
+      '--always',
+      '--tag',
+      '--abbrev=0',
+      { '--dirty': options?.markDirty, '--first-parent': options?.firstParent },
+      options?.match && ['--match', options?.match],
     );
   }
 
-  public log<T extends keyof any>(fields?: Record<T, string>, n?: number): Record<T, string>[];
+  public log<T extends keyof any>(
+    fields?: Record<T, string>,
+    n?: number,
+  ): Record<T, string>[];
   public log(fields?: string[], n?: number): string[][];
   public log(fields?: string, n?: number): string[];
   public log(fields?: any, n?: number) {
     if (fields === undefined) {
-      fields = { hash: "%H", date: "%s", subject: "%cI", name: "%an" };
+      fields = { hash: '%H', date: '%s', subject: '%cI', name: '%an' };
     }
     const pretty = `--pretty=format:${JSON.stringify(fields)},`;
     const count = n && `--max-count=${n}`;
-    const result = this.git("log", "--abbrev-commit", count, pretty);
+    const result = this.git('log', '--abbrev-commit', count, pretty);
     return JSON.parse(`[${result.slice(0, -1)}]`);
   }
 
-  public logN1(format: string, rev = "HEAD"): string {
+  public logN1(format: string, rev = 'HEAD'): string {
     const pretty = `--pretty=format:${format}`;
-    return this.git("log", "-1", pretty, rev);
+    return this.git('log', '-1', pretty, rev);
   }
 
-  public remoteURL(name = "origin") {
-    return this.git("remote", "get-url", name);
+  public remoteURL(name = 'origin') {
+    return this.git('remote', 'get-url', name);
   }
 
   public hasUnstagedChanges() {
-    return this.isDirty(this.git("write-tree"));
+    return this.isDirty(this.git('write-tree'));
   }
 
-  public isDirty(rev = "HEAD") {
-    return this.git("diff-index", rev, "--").length > 0;
+  public isDirty(rev = 'HEAD') {
+    return this.git('diff-index', rev, '--').length > 0;
   }
 
   public isTagDirty() {
     try {
-      this.describe("--exact-match", "--tags");
+      this.describe('--exact-match', '--tags');
     } catch (err) {
-      if (err.message.includes("no tag exactly matches")) {
+      if (err.message.includes('no tag exactly matches')) {
         return true;
       }
       throw err;
     }
     return false;
   }
 
-  public isUpdateToDate(branchName = this.branchName(), remoteName = "origin") {
-    this.git("fetch", remoteName, branchName);
-    return this.commitHash(false, "HEAD") === this.commitHash(false, `${remoteName}/${branchName}`);
+  public isUpdateToDate(branchName = this.branchName(), remoteName = 'origin') {
+    this.git('fetch', remoteName, branchName);
+    return (
+      this.commitHash(false, 'HEAD') ===
+      this.commitHash(false, `${remoteName}/${branchName}`)
+    );
   }
 
-  public repositoryName(remoteName = "origin") {
+  public repositoryName(remoteName = 'origin') {
     const url = this.remoteURL(remoteName);
-    return basename(url, ".git");
+    return basename(url, '.git');
   }
 }
 

src/index.ts

@@ -1,7 +1,7 @@
-import { Git } from "./git";
+import { Git } from './git';
 
-export { Git, TagOptions } from "./git";
-export { GitAgent, PushOptions } from "./git-agent";
-export { GitBase } from "./git-base";
+export { Git, TagOptions } from './git';
+export { GitAgent, PushOptions } from './git-agent';
+export { GitBase } from './git-base';
 
 export default new Git();

test/git-agent.spec.ts

@@ -1,17 +1,17 @@
-import { assert } from "chai";
-import "mocha";
-import rimraf from "rimraf";
+import { assert } from 'chai';
+import 'mocha';
+import rimraf from 'rimraf';
 
-import { GitAgent } from "../src";
-import { cloneBundle, mkdtemp, writeFile } from "./utils";
+import { GitAgent } from '../src';
+import { cloneBundle, mkdtemp, writeFile } from './utils';
 
-describe("git-agent", () => {
+describe('git-agent', () => {
   let git: GitAgent;
 
   before(() => {
     const cwd = mkdtemp();
     cloneBundle(cwd);
-    writeFile(cwd, "updated");
+    writeFile(cwd, 'updated');
     git = new GitAgent(cwd);
   });
 
@@ -20,30 +20,30 @@ describe("git-agent", () => {
   });
 
   it(".checkoutBranch('master')", () => {
-    git.checkoutBranch("master");
+    git.checkoutBranch('master');
   });
 
   it(".createBranch('sample')", () => {
-    git.createBranch("sample");
+    git.createBranch('sample');
   });
 
   it(".checkoutBranch('sample')", () => {
-    git.checkoutBranch("sample");
+    git.checkoutBranch('sample');
   });
 
   it(".commit('Commit made by test')", () => {
-    git.commit("Commit made by test");
+    git.commit('Commit made by test');
   });
 
   it(".createTag('sample')", () => {
-    const tagName = "sample";
+    const tagName = 'sample';
     git.createTag(tagName);
     assert.equal(git.tag(), tagName);
   });
 
-  it(".setField and .getField", () => {
-    const name = "foo.bar";
-    const value = "example";
+  it('.setField and .getField', () => {
+    const name = 'foo.bar';
+    const value = 'example';
     git.setField(name, value);
     assert.equal(git.getField(name), value);
   });