git-truck 0.8.2 → 0.8.6-experimental

package/.github/workflows/bump-version.yml

@@ -31,7 +31,7 @@ jobs:
           env:
             GITHUB_TOKEN: ${{ secrets.TOKEN }}
 
-        - run: npm install --package-lock-only
+        - run: npm install --package-lock-only --ignore-scripts
         - run: git add package-lock.json
         - run: git config user.email "version-bot@example.com"
         - run: git config user.name "Version Bot"

package/README.md

@@ -18,9 +18,9 @@ To check if these programs are installed, and what version you have, run `node -
 
 ## [Get started](#get-started)
 
-1. In your favorite shell (for example cmd, PowerShell, etc.), navigate to the root directory of a git project you want to visualize.
-2. Execute the command `npx git-truck@latest`. Click `y` if it asks you to download the tool. A blank browser-window will open and Git Truck will now start analyzing your project (This might take a while to run, especially on big projects, you can follow the progress in your terminal). If you get an error in the terminal, you can try installing the tool globally by running `npm i -g git-truck@latest` and then run `git-truck` instead.
-3. When Git Truck is done analyzing your project, it will show the visualization in your browser. Enjoy!
+1. Within a git repository, or a directory containing git repositories, run the command `npx git-truck@latest`.
+2. Press `y` if it asks you to download the package.
+3. The application will now open in your default browser.
 
 ## [I got an error or I want to give feedback, what do i do?](#i-got-an-error-or-i-want-to-give-feedback-what-do-i-do)
 
@@ -38,19 +38,23 @@ npx git-truck [args]
 
 ### [Arguments](#arguments)
 
-|    arg     |                              description                              |   default value    |
-| :--------: | :-------------------------------------------------------------------: | :----------------: |
-| `--branch` |                              branch name                              | checked out branch |
-|  `--path`  |                        path to git repository                         | current directory  |
-|  `--log`   | output log level. See [here](./src/analyzer/log.server.ts) for values |         -          |
-|  `--port`  |                      port to use for the program                      |        3000        |
+|         arg          |                              description                              |   default value    |
+| :------------------: | :-------------------------------------------------------------------: | :----------------: |
+|      `--branch`      |                              branch name                              | checked out branch |
+|       `--path`       |                 path to a folder or a git repository                  | current directory  |
+|       `--log`        | output log level. See [here](./src/analyzer/log.server.ts) for values |         -          |
+|       `--port`       |                      port to use for the program                      |        3000        |
+| `--invalidate-cache` |                    bypass analyzer cache manually                     |         -          |
+
+**Note:** Using `--invalidate-cache` will cause the analyzer to run every time the client talks to the server.
 
 ### [Configuration](#configuration)
 
 You can add a `truckconfig.json` file to the root of your project, where you can define the arguments you want.
-Additionally you can define which git-aliases should be considered as the same person.
+Additionally you can define which git-aliases should be considered as the same person using `unionedAuthors`. If provided, the first name in the array is used as the name of the person.
 You can also define files to ignore.
-Example:
+
+**Example:**
 
 ```json
 {
@@ -60,7 +64,7 @@ Example:
     ["Bob", "Bobby Bob"],
     ["Alice", "aliiii", "alice alice"]
   ],
-  "hiddenFiles": ["package-lock.json", "*.bin", "*.svg"]
+  "hiddenFiles": ["package-lock.json", "*.bin", "*.svg"],
+  "invalidateCache": true
 }
-
 ```

package/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require("./build/index.js")

package/dev.js

@@ -6,12 +6,14 @@ const open = require("open")
   const getPortLib = (await import("get-port"))
   const getPort = getPortLib.default
   const port = await getPort({
-    port: getPortLib.portNumbers(3000, 4000),
+    port: [80, ...getPortLib.portNumbers(3000, 4000)],
   })
 
+  process.env["PORT"] = port.toString()
+
   open("http://localhost:" + port)
   await runAll(
-    [`dev:node -- --port ${port} ${process.argv.join(" ")}`, "dev:remix"],
+    [`dev:node -- ${process.argv.slice(2).join(" ")}`, "dev:remix"],
     {
       parallel: true,
       stdout: process.stdout,

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "git-truck",
-  "version": "0.8.2",
+  "version": "0.8.6-experimental",
   "private": false,
   "description": "Visualizing a Git repository",
   "license": "MIT",
-  "main": "./build/index.js",
-  "bin": "./build/index.js",
+  "main": "./cli.js",
+  "bin": "./cli.js",
   "scripts": {
     "test": "jest --coverage",
     "clean": "rimraf -rf build public/build .cache .temp",
     "tsc": "tsc",
-    "build": "remix setup node && cross-env NODE_ENV=production remix build && node ./post-build.js",
+    "build": "remix setup node && cross-env NODE_ENV=production remix build",
     "dev": "cross-env NODE_ENV=development remix build && node dev.js",
     "dev:remix": "cross-env NODE_ENV=development remix watch",
     "postinstall": "npm run build",

package/server.ts

@@ -57,10 +57,7 @@ for usage instructions.`)
 
   const staticAssetsPath = join(__dirname, "../public/build")
   // Remix fingerprints its assets so we can cache forever.
-  app.use(
-    "/build",
-    express.static(staticAssetsPath, { immutable: true, maxAge: "1y" })
-  )
+  app.use("/build", express.static(staticAssetsPath, { immutable: true, maxAge: "1y" }))
 
   // Everything else (like favicon.ico) is cached for an hour. You may want to be
   // more aggressive with this caching.
@@ -76,16 +73,24 @@ for usage instructions.`)
     })
   )
 
+  let devServerPort: number | null = null
+  let userHasProvidedPort = false
   let minPort = 3000
 
-  if (args.port && !isNaN(parseInt(args.port))) minPort = parseInt(args.port)
+  if (args.port && !isNaN(parseInt(args.port))) {
+    minPort = parseInt(args.port)
+    userHasProvidedPort = true
+  }
+
+  if (process.env["PORT"] && !isNaN(parseInt(process.env["PORT"]))) {
+    devServerPort = parseInt(process.env["PORT"])
+  }
 
   const getPortLib = await import("get-port")
   const getPort = getPortLib.default
   const port = await getPort({
-    port: getPortLib.portNumbers(minPort, minPort + 1000),
+    port: devServerPort ?? [...(!userHasProvidedPort ? [80] : []), ...getPortLib.portNumbers(minPort, minPort + 1000)],
   })
-
   app.listen(port).once("listening", () => printOpen(port))
 })()
 
@@ -93,7 +98,7 @@ async function printOpen(port: number) {
   console.log()
   console.log(`Now listening on port ${port}`)
   if (process.env.NODE_ENV !== "development") {
-    const url = "http://localhost:" + port
+    const url = `http://localhost:${port}`
     console.log(`Opening ${url} in your browser`)
     await open(url)
   }

package/src/analyzer/analyze.server.ts

@@ -1,4 +1,4 @@
-import fsSync, { promises as fs } from "fs"
+import { promises as fs } from "fs"
 import {
   GitBlobObject,
   GitCommitObject,
@@ -7,25 +7,16 @@ import {
   AnalyzerData,
   AnalyzerDataInterfaceVersion,
   TruckUserConfig,
+  TruckConfig,
 } from "./model"
 import { log, setLogLevel } from "./log.server"
-import {
-  describeAsyncJob,
-  formatMs,
-  writeRepoToFile,
-  getCurrentBranch,
-  getRepoName,
-  getDefaultGitSettingValue,
-  resetGitSetting,
-  setGitSetting,
-} from "./util"
-import { GitCaller } from "./git-caller"
+import { describeAsyncJob, formatMs, writeRepoToFile, getDirName } from "./util.server"
+import { GitCaller } from "./git-caller.server"
 import { emptyGitCommitHash } from "./constants"
-import { resolve, isAbsolute, join } from "path"
+import { resolve, isAbsolute } from "path"
 import { performance } from "perf_hooks"
 import { getAuthorSet, hydrateData } from "./hydrate.server"
 import {} from "@remix-run/node"
-import { getArgs } from "./args.server"
 import ignore from "ignore"
 import { applyIgnore, applyMetrics, initMetrics, TreeCleanup } from "./postprocessing.server"
 import latestVersion from "latest-version"
@@ -35,25 +26,6 @@ import { exec } from "child_process"
 
 let repoDir = "."
 
-export async function findBranchHead(repo: string, branch: string | null) {
-  if (branch === null) branch = await getCurrentBranch(repo)
-
-  const gitFolder = join(repo, ".git")
-  if (!fsSync.existsSync(gitFolder)) {
-    throw Error(`${repo} is not a git repository`)
-  }
-  // Find file containing the branch head
-  const branchPath = join(gitFolder, "refs/heads/" + branch)
-  const absolutePath = join(process.cwd(), branchPath)
-  log.debug("Looking for branch head at " + absolutePath)
-
-  const branchHead = (await fs.readFile(branchPath, "utf-8")).trim()
-  log.debug(`${branch} -> [commit]${branchHead}`)
-  if (!branchHead) throw Error("Branch head not found")
-
-  return [branchHead, branch]
-}
-
 export async function analyzeCommitLight(hash: string): Promise<GitCommitObjectLight> {
   const rawContent = await GitCaller.getInstance().catFileCached(hash)
   const commitRegex =
@@ -181,9 +153,9 @@ export async function updateTruckConfig(repoDir: string, updaterFn: (tc: TruckUs
   await fs.writeFile(truckConfigPath, JSON.stringify(updatedConfig, null, 2))
 }
 
-export async function analyze(useCache = true) {
-  const args = await getArgs()
+export async function analyze(args: TruckConfig) {
   GitCaller.initInstance(args.path)
+  const git = GitCaller.getInstance()
 
   if (args?.log) {
     setLogLevel(args.log as string)
@@ -197,76 +169,74 @@ export async function analyze(useCache = true) {
   const hiddenFiles = args.hiddenFiles
 
   const start = performance.now()
-  const [branchHead, branchName] = await describeAsyncJob(
-    () => findBranchHead(repoDir, branch),
+  const [findBranchHeadResult, findBranchHeadError] = await describeAsyncJob(
+    () => git.findBranchHead(branch),
     "Finding branch head",
     "Found branch head",
     "Error finding branch head"
   )
-  const repoName = getRepoName(repoDir)
-
-  let data: AnalyzerData | null = null
+  const repoName = getDirName(repoDir)
 
-  const dataPath = getOutPathFromRepoAndBranch(repoName, branchName)
-  if (fsSync.existsSync(dataPath)) {
-    const path = getOutPathFromRepoAndBranch(repoName, branchName)
-    const cachedData = JSON.parse(await fs.readFile(path, "utf8")) as AnalyzerData
+  if (findBranchHeadError) throw findBranchHeadError
 
-    // Check if the current branchHead matches the hash of the analyzed commit from the cache
-    const branchHeadMatches = branchHead === cachedData.commit.hash
+  const [branchHead, branchName] = findBranchHeadResult
 
-    // Check if the data uses the most recent analyzer data interface
-    const dataVersionMatches = cachedData.interfaceVersion === AnalyzerDataInterfaceVersion
+  let data: AnalyzerData | null = null
 
-    const cacheConditions = {
-      branchHeadMatches,
-      dataVersionMatches,
-      refresh: !useCache,
-    }
+  if (!args.invalidateCache) {
+    const [cachedData, reasons] = await GitCaller.retrieveCachedResult({
+      repo: repoName,
+      branch: branchName,
+      branchHead: branchHead,
+    })
 
-    // Only return cached data if every criteria is met
-    if (Object.values(cacheConditions).every(Boolean)) {
+    if (cachedData) {
       data = {
         ...cachedData,
         hiddenFiles,
       }
     } else {
-      const reasons = Object.entries(cacheConditions)
-        .filter(([, value]) => !value)
-        .map(([key, value]) => `${key}: ${value}`)
-        .join(", ")
-      log.info(`Reanalyzing, since the following cache conditions were not met: ${reasons}`)
+      log.info(
+        `Reanalyzing, since the following cache conditions were not met:\n${reasons.map((r) => ` - ${r}`).join("\n")}`
+      )
     }
+  } else {
+    GitCaller.getInstance().setUseCache(false)
   }
 
   if (data === null) {
-    const quotePathDefaultValue = await getDefaultGitSettingValue(repoDir, "core.quotepath")
-    await setGitSetting(repoDir, "core.quotePath", "off")
-    const renamesDefaultValue = await getDefaultGitSettingValue(repoDir, "diff.renames")
-    await setGitSetting(repoDir, "diff.renames", "true")
-    const renameLimitDefaultValue = await getDefaultGitSettingValue(repoDir, "diff.renameLimit")
-    await setGitSetting(repoDir, "diff.renameLimit", "1000000")
+    const quotePathDefaultValue = await git.getDefaultGitSettingValue("core.quotepath")
+    await git.setGitSetting("core.quotePath", "off")
+    const renamesDefaultValue = await git.getDefaultGitSettingValue("diff.renames")
+    await git.setGitSetting("diff.renames", "true")
+    const renameLimitDefaultValue = await git.getDefaultGitSettingValue("diff.renameLimit")
+    await git.setGitSetting("diff.renameLimit", "1000000")
+    const hasUnstagedChanges = await git.hasUnstagedChanges()
 
     const runDateEpoch = Date.now()
-    const repoTree = await describeAsyncJob(
+    const [repoTree, repoTreeError] = await describeAsyncJob(
       () => analyzeCommit(repoName, branchHead),
       "Analyzing commit tree",
       "Commit tree analyzed",
       "Error analyzing commit tree"
     )
 
-    const hydratedRepoTree = await describeAsyncJob(
+    if (repoTreeError) throw repoTreeError
+
+    const [hydratedRepoTree, hydratedRepoTreeError] = await describeAsyncJob(
       () => hydrateData(repoDir, repoTree),
       "Hydrating commit tree",
       "Commit tree hydrated",
       "Error hydrating commit tree"
     )
 
-    await resetGitSetting(repoDir, "core.quotepath", quotePathDefaultValue)
-    await resetGitSetting(repoDir, "diff.renames", renamesDefaultValue)
-    await resetGitSetting(repoDir, "diff.renameLimit", renameLimitDefaultValue)
+    await git.resetGitSetting("core.quotepath", quotePathDefaultValue)
+    await git.resetGitSetting("diff.renames", renamesDefaultValue)
+    await git.resetGitSetting("diff.renameLimit", renameLimitDefaultValue)
+
+    const defaultOutPath = GitCaller.getCachePath(repoName, branchName)
+    if (hydratedRepoTreeError) throw hydratedRepoTreeError
 
-    const defaultOutPath = getOutPathFromRepoAndBranch(repoName, branchName)
     let outPath = resolve((args.out as string) ?? defaultOutPath)
     if (!isAbsolute(outPath)) outPath = resolve(process.cwd(), outPath)
 
@@ -289,6 +259,7 @@ export async function analyze(useCache = true) {
       currentVersion: pkg.version,
       latestVersion: latestV,
       lastRunEpoch: runDateEpoch,
+      hasUnstagedChanges,
     }
 
     await describeAsyncJob(
@@ -315,7 +286,3 @@ export async function analyze(useCache = true) {
 
   return data
 }
-
-export function getOutPathFromRepoAndBranch(repoName: string, branchName: string) {
-  return resolve(__dirname, "..", ".temp", repoName, `${branchName}.json`)
-}

package/src/analyzer/analyze.test.ts

@@ -1,30 +1,30 @@
-import { getCoAuthors } from "./coauthors.server"
-
-describe("getCoAuthors", () => {
-  it("Should return none", () => {
-    const actual = getCoAuthors("lorem ipsum\n\nCo-authored-by:")
-    expect(actual.length).toBe(0)
-  })
-
-  it("Should return none when empty input", () => {
-    const actual = getCoAuthors("")
-    expect(actual.length).toBe(0)
-  })
-
-  it("Should return 2 authors", () => {
-    const sampleDescription =
-      "did some stuff\n\nCo-authored-by: Bob Bobby <bob@example.com>\nCo-authored-by: Alice Lmao <alice@example.com>"
-    const expected = [
-      {
-        name: "Bob Bobby",
-        email: "bob@example.com",
-      },
-      {
-        name: "Alice Lmao",
-        email: "alice@example.com",
-      },
-    ]
-    const actual = getCoAuthors(sampleDescription)
-    expect(actual).toStrictEqual(expected)
-  })
-})
+import { getCoAuthors } from "./coauthors.server"
+
+describe("getCoAuthors", () => {
+  it("Should return none", () => {
+    const actual = getCoAuthors("lorem ipsum\n\nCo-authored-by:")
+    expect(actual.length).toBe(0)
+  })
+
+  it("Should return none when empty input", () => {
+    const actual = getCoAuthors("")
+    expect(actual.length).toBe(0)
+  })
+
+  it("Should return 2 authors", () => {
+    const sampleDescription =
+      "did some stuff\n\nCo-authored-by: Bob Bobby <bob@example.com>\nCo-authored-by: Alice Lmao <alice@example.com>"
+    const expected = [
+      {
+        name: "Bob Bobby",
+        email: "bob@example.com",
+      },
+      {
+        name: "Alice Lmao",
+        email: "alice@example.com",
+      },
+    ]
+    const actual = getCoAuthors(sampleDescription)
+    expect(actual).toStrictEqual(expected)
+  })
+})

package/src/analyzer/args.server.ts

@@ -2,6 +2,9 @@ import yargsParser from "yargs-parser"
 import { promises as fs } from "fs"
 import { resolve } from "path"
 import { TruckConfig, TruckUserConfig } from "./model"
+import { GitCaller } from "./git-caller.server"
+import { getBaseDirFromPath } from "./util.server"
+import { log } from "./log.server"
 
 export function parseArgs(rawArgs: string[] = process.argv.slice(2)) {
   return yargsParser(rawArgs, {
@@ -11,24 +14,35 @@ export function parseArgs(rawArgs: string[] = process.argv.slice(2)) {
   })
 }
 
-export async function getArgs(): Promise<TruckConfig> {
+export async function getArgsWithDefaults(): Promise<TruckConfig> {
   const args = parseArgs()
   const tempArgs = {
     path: ".",
-    branch: null,
     hiddenFiles: [] as string[],
     unionedAuthors: [] as string[][],
+    invalidateCache: false,
     ...args,
   }
 
+  return tempArgs
+}
+
+export async function getTruckConfigWithArgs(repo: string): Promise<TruckConfig> {
+  const args = await getArgsWithDefaults()
+
+  const pathIsRepo = await GitCaller.isGitRepo(args.path)
+  args.path = pathIsRepo ? getBaseDirFromPath(args.path) : args.path
+
   let config: TruckUserConfig = {}
   try {
-    const configContents = JSON.parse(await fs.readFile(resolve(tempArgs.path, "truckconfig.json"), "utf-8"))
+    const configContents = JSON.parse(await fs.readFile(resolve(args.path, repo, "truckconfig.json"), "utf-8"))
     config = configContents
-  } catch (e) {}
+  } catch (e) {
+    log.warn(`No truckconfig.json found in repo ${repo}`)
+  }
 
   return {
-    ...tempArgs,
+    ...args,
     ...config,
-  } as TruckConfig
+  }
 }

package/src/analyzer/constants.ts

@@ -1 +1 @@
-export const emptyGitCommitHash = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
+export const emptyGitCommitHash = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"