first working version of patch maker

Author: David Sheldrick

README.md

@@ -0,0 +1,37 @@
+# patch-package
+
+### When forking just won't work, patch it.
+
+patch-package lets you easily fix bugs in (or add functionality to) packages in your
+`node_modules` folder and share the results with your team. You simply make the changes in situ,
+run `patch-package <package-name>` and patch-package will create a patch file
+for you to commit, which gets applied any time the contents of `node_modules` is updated by yarn/npm.
+
+## Set-up
+
+    yarn add -D patch-package
+
+In package.json
+
+    "scripts": {
+      "prepare": "patch-package"
+    }
+
+## Usage
+
+Make changes to the files of a particular module in your node_modules folder,
+e.g. react-native. Then run:
+
+    patch-package react-native
+
+If this is the first
+time you've used `patch-package`, it will create a folder called `patches` in
+the root dir of your app. Inside will be a file called `react-native:0.44.0.patch`
+which is a diff between normal old react-native and your special version. Commit this and you and your team will enjoy the same changes from here on out.
+
+Do exactly the same thing to update the patch file, or just delete it
+if you don't need the changes anymore.
+
+## License
+
+MIT

package.json

@@ -34,12 +34,15 @@
   "devDependencies": {
     "@types/app-root-path": "^1.2.4",
     "@types/node": "^7.0.18",
+    "@types/tmp": "^0.0.33",
     "jest": "^20.0.0",
     "ts-jest": "^20.0.1",
     "tslint": "^5.2.0",
     "typescript": "^2.3.2"
   },
   "dependencies": {
-    "app-root-path": "^2.0.1"
+    "app-root-path": "^2.0.1",
+    "shell-escape": "^0.2.0",
+    "tmp": "^0.0.31"
   }
 }

src/Npm.ts

@@ -0,0 +1,9 @@
+import { execSync as exec } from "child_process"
+import { PackageManager } from "./PackageManager"
+
+export default class Npm implements PackageManager {
+  constructor(public cwd: string) { }
+  public add(packageName: string, version: string) {
+    exec(`npm i ${packageName}@${version}`, { cwd: this.cwd })
+  }
+}

src/PackageManager.ts

@@ -0,0 +1,3 @@
+export interface PackageManager {
+  add(packageName: string, version: string): void
+}

src/Yarn.ts

@@ -0,0 +1,9 @@
+import { execSync as exec } from "child_process"
+import { PackageManager } from "./PackageManager"
+
+export default class Yarn implements PackageManager {
+  constructor(public cwd: string) { }
+  public add(packageName: string, version: string) {
+    exec(`yarn add ${packageName}@${version}`, { cwd: this.cwd })
+  }
+}

src/applyPatch.ts

@@ -0,0 +1,15 @@
+import { execSync as exec } from "child_process"
+
+export default function applyPatch(patchFilePath: string, packageName: string) {
+  try {
+    exec("patch --forward -p1 -i " + patchFilePath)
+    console.log(`Successfully patched ${packageName}`)
+  } catch (e) {
+    // patch cli tool has no way to fail gracefully if patch was already applied,
+    // so to check, we need to try a dry-run of applying the patch in reverse, and
+    // if that works it means the patch was already applied sucessfully. Otherwise
+    // the patch just failed for some reason.
+    exec("patch --reverse --dry-run -p1 -i " + patchFilePath)
+    console.log(`Already patched ${packageName}`)
+  }
+}

src/findPatches.ts

@@ -0,0 +1,41 @@
+import * as fs from "fs"
+import * as path from "path"
+import { env } from "process"
+
+export default function findPatchFiles(appPath: string): Array<{ patchFilePath: string, packageName: string }> {
+  const patchesDirectory = path.join(appPath, "patches")
+  if (!fs.existsSync(patchesDirectory)) {
+    return []
+  }
+  return fs
+    .readdirSync(patchesDirectory)
+    .filter((filename) => filename.match(/^.+!!.+\.patch$/))
+    .map((filename) => {
+      const [packageName, version] = filename.slice(0, -6).split(":")
+      const packageDir = path.join(appPath, "node_modules" + packageName)
+
+      if (!fs.exists(packageDir)) {
+        console.warn(`Patch file found for package ${packageName} which is not present in node_modules/`)
+        return null
+      }
+
+      const packageJson = require(path.join(packageDir, "package.json"))
+
+      if (packageJson.version !== version) {
+        console.warn(
+          `Patch file for package ${packageName}:${version} found,`
+          + ` but node_modules/${packageName} has version ${packageJson.version}`,
+        )
+        console.warn(
+          `Attempting to apply the patch anyway. Update the version number`
+          + ` in the patch filename ${path.join(patchesDirectory, filename)} to silence this warning.`,
+        )
+      }
+
+      return {
+        patchFilePath: path.resolve(patchesDirectory, filename),
+        packageName,
+      }
+    })
+    .filter(Boolean) as any
+}

src/getAppRootPath.ts

@@ -0,0 +1,11 @@
+import * as fs from "fs"
+import * as path from "path"
+import * as process from "process"
+
+export default function getAppRootPath() {
+  let cwd = process.cwd()
+  while (!fs.existsSync(path.join(cwd, "package.json"))) {
+    cwd = path.resolve(cwd, "../")
+  }
+  return cwd
+}

src/index.ts

@@ -1 +1,20 @@
-console.log("hello world")
+import { argv } from "process"
+import applyPatch from "./applyPatch"
+import findPatches from "./findPatches"
+import getAppRootPath from "./getAppRootPath"
+import makePatch from "./makePatch"
+
+const appPath = getAppRootPath()
+if (argv.length === 2) {
+  console.log("Applying patches...")
+  findPatches(appPath)
+    .forEach(({ patchFilePath, packageName }) => {
+      applyPatch(patchFilePath, packageName)
+    })
+} else {
+  console.log("Making patches")
+  const packageNames = [].slice.call(argv, 2)
+  packageNames.forEach((packageName: string) => {
+    makePatch(packageName, appPath)
+  })
+}

src/makePatch.ts

@@ -0,0 +1,51 @@
+import { execSync as exec } from "child_process"
+import * as fs from "fs"
+import * as path from "path"
+import * as shellEscape from "shell-escape"
+import * as tmp from "tmp"
+import Npm from "./Npm"
+import { PackageManager } from "./PackageManager"
+import Yarn from "./Yarn"
+
+export default function makePatch(packageName: string, appPath: string) {
+  const packagePath = path.join(appPath, "node_modules", packageName)
+  const packageJsonPath = path.join(packagePath, "package.json")
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error(`Unable to find local ${packageName} package.json at ${packageJsonPath}`)
+  }
+
+  const packageVersion = require(packageJsonPath).version
+
+  const tmpDir = tmp.dirSync({ unsafeCleanup: true })
+
+  try {
+    const packageManager = getPackageManager(tmpDir.name)
+
+    packageManager.add(packageName, packageVersion)
+
+    exec(`git init`, { cwd: tmpDir.name })
+    exec(shellEscape(["git", "add", "-f", path.join("node_modules", packageName)]), { cwd: tmpDir.name })
+    exec(shellEscape(["cp", "-RL", packagePath, path.join(tmpDir.name, "node_modules")]))
+    const patch = exec(`git diff`, { cwd: tmpDir.name }).toString()
+
+    const patchesDir = path.join(appPath, "patches")
+    if (!fs.existsSync(patchesDir)) {
+      fs.mkdirSync(patchesDir)
+    }
+
+    const patchFileName = `${packageName}:${packageVersion}.patch`
+    console.log(`Creating patch file ${patchFileName}`)
+    fs.writeFileSync(path.join(patchesDir, patchFileName), patch)
+  } finally {
+    tmpDir.removeCallback()
+  }
+}
+
+function getPackageManager(cwd: string): PackageManager {
+  try {
+    exec("which yarn")
+    return new Yarn(cwd)
+  } catch (e) {
+    return new Npm(cwd)
+  }
+}