概论

1
2
3
4
5
6
7
8
9

diff
--- a/file1.txt
+++ b/file1.txt
@@ -1,3 +1,4 @@
+This is an important line
This is the original file
-This is a line to delete
+This is a modified line
This is another line

1

git apply file1.patch

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

{
  "name": "my-package",
  "version": "1.0.0",
  "description": "My awesome package",
  "files": [
    "src",
    "index.js",
    "LICENSE"
  ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

async function diffFolders (folderA: string, folderB: string) {
  const folderAN = folderA.replace(/\\/g, '/')
  const folderBN = folderB.replace(/\\/g, '/')
  let stdout!: string
  let stderr!: string

  try {
    const result = await execa('git', ['-c', 'core.safecrlf=false', 'diff', '--src-prefix=a/', '--dst-prefix=b/', '--ignore-cr-at-eol', '--irreversible-delete', '--full-index', '--no-index', '--text', folderAN, folderBN], {
      cwd: process.cwd(),
      env: {
        ...process.env,
        GIT_CONFIG_NOSYSTEM: '1',
        HOME: '',
        XDG_CONFIG_HOME: '',
        USERPROFILE: '',
        // #endregion
      },
    })
    stdout = result.stdout
    stderr = result.stderr
  } catch (err: any) {
    stdout = err.stdout
    stderr = err.stderr
  }
  // we cannot rely on exit code, because --no-index implies --exit-code
  // i.e. git diff will exit with 1 if there were differences
  if (stderr.length > 0)
    throw new Error(`Unable to diff directories. Make sure you have a recent version of 'git' available in PATH.\nThe following error was reported by 'git':\n${stderr}`)

  return stdout
    .replace(new RegExp(`(a|b)(${escapeStringRegexp(`/${removeTrailingAndLeadingSlash(folderAN)}/`)})`, 'g'), '$1/')
    .replace(new RegExp(`(a|b)${escapeStringRegexp(`/${removeTrailingAndLeadingSlash(folderBN)}/`)}`, 'g'), '$1/')
    .replace(new RegExp(escapeStringRegexp(`${folderAN}/`), 'g'), '')
    .replace(new RegExp(escapeStringRegexp(`${folderBN}/`), 'g'), '')
    .replace(/\n\\ No newline at end of file$/, '')
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

/**
 * pnpm patch commit处理安装命令的处理程序
 * @param opts 安装命令的选项，包括 install.InstallCommandOptions 和 Config 的部分属性
 * @param params 参数列表，包含用户目录路径
 * @returns Promise，安装操作的结果
 */
export async function handler(
  opts: install.InstallCommandOptions & Pick<Config, 'patchesDir' | 'rootProjectManifest'>,
  params: string[]
) {
  // 获取用户变更代码目录，也就是pnpm patch commit命令的第一个参数
  const userDir = params[0]
  // 获取lockfile文件目录
  const lockfileDir = opts.lockfileDir ?? opts.dir ?? process.cwd()
  // 获取补丁目录名称
  const patchesDirName = normalizePath(path.normalize(opts.patchesDir ?? 'patches'))
  // 拼接补丁目录路径
  const patchesDir = path.join(lockfileDir, patchesDirName)
  // 创建补丁目录
  await fs.promises.mkdir(patchesDir, { recursive: true })
  // 从用户目录中读取补丁后的 package.json 文件
  const patchedPkgManifest = await readPackageJsonFromDir(userDir)
  // 获取补丁后的包名称和版本号
  const pkgNameAndVersion = `${patchedPkgManifest.name}@${patchedPkgManifest.version}`
  // 创建临时目录
  const srcDir = tempy.directory()
  // 将补丁后的包写入临时目录
  await writePackage(parseWantedDependency(pkgNameAndVersion), srcDir, opts)

  // 过滤并复制文件到临时目录
  const filteredFolder = await filterAndCopyFiles(userDir, tempy.directory())
  // 获取补丁内容
  const patchContent = await diffFolders(srcDir, filteredFolder)

  // 根据包名称和版本号生成补丁文件名
  const patchFileName = pkgNameAndVersion.replace('/', '__')
  // 将补丁内容写入补丁文件
  await fs.promises.writeFile(path.join(patchesDir, `${patchFileName}.patch`), patchContent, 'utf8')
  
  // 尝试读取项目清单文件和根项目package.json文件
  const { writeProjectManifest, manifest } = await tryReadProjectManifest(lockfileDir)
  const rootProjectManifest = opts.rootProjectManifest ?? manifest ?? {}

  // 如果项目清单中没有 pnpm 属性，则创建该属性
  if (!rootProjectManifest.pnpm) {
    rootProjectManifest.pnpm = {
      patchedDependencies: {},
    }
  }
  // 如果项目清单中的 pnpm 属性没有 patchedDependencies 属性，则创建该属性
  else if (!rootProjectManifest.pnpm.patchedDependencies) {
    rootProjectManifest.pnpm.patchedDependencies = {}
  }
  // 将补丁路径添加到根项目清单的 patchedDependencies 中
  rootProjectManifest.pnpm.patchedDependencies![pkgNameAndVersion] = `${patchesDirName}/${patchFileName}.patch`
  // 将更新后的根项目清单写入文件
  await writeProjectManifest(rootProjectManifest)

  // 如果存在选定的项目图谱，并且锁定文件目录存在于图谱中，则更新对应项目的清单
  if (opts?.selectedProjectsGraph?.[lockfileDir]) {
    opts.selectedProjectsGraph[lockfileDir].package.manifest = rootProjectManifest
  }

  // 如果存在所有项目的图谱，并且锁定文件目录存在于图谱中，则更新对应项目的清单
  if (opts?.allProjectsGraph?.[lockfileDir].package.manifest) {
    opts.allProjectsGraph[lockfileDir].package.manifest = rootProjectManifest
  }

  // 调用 install.handler() 完成安装操作
  return install.handler({
    ...opts,
    rawLocalConfig: {
      ...opts.rawLocalConfig,
      'frozen-lockfile': false,
    },
  })
}

async function filterAndCopyFiles(source: string, destination: string) {
  // 利用packlist获取源目录下的所有文件列表
  const files = await packlist({ path: source })
  // 如果文件列表为空，则返回源目录
  if (files.length === 0) {
    return source
  }
  // 复制文件到目标目录
  await Promise.all(
    files.map(async (file) => {
      const sourcePath = path.join(source, file)
      const destinationPath = path.join(destination, file)
      const destDir = path.dirname(destinationPath)
      await fs.promises.mkdir(destDir, { recursive: true })
      await fs.promises.copyFile(sourcePath, destinationPath)
    })
  )

  return destination
}