fix(merge): allow merges of new folders with the same name (#61)

* allow merges of new folders with the same name

* add more unit tests

---------

Co-authored-by: Alex Titarenko <3290313+alex-titarenko@users.noreply.github.com>

Author: alex-titarenko

src/errors/MergeConflictError.ts

@@ -0,0 +1,18 @@
+import { BaseError } from './BaseError'
+
+export type MergeConflictErrorData = {
+  filePath: string
+}
+
+export class MergeConflictError extends BaseError<MergeConflictErrorData> {
+  public static readonly code = 'MergeConflictError'
+
+  constructor(filePath: string) {
+    super(
+      `Automatic merge failed with a conflict in the following path: ${filePath}.`,
+      MergeConflictError.code,
+      { filePath }
+    )
+  }
+}
+

src/errors/index.ts

@@ -15,6 +15,7 @@ export * from './InvalidFilepathError'
 export * from './InvalidOidError'
 export * from './InvalidRefNameError'
 export * from './MaxDepthError'
+export * from './MergeConflictError'
 export * from './MergeNotSupportedError'
 export * from './MissingNameError'
 export * from './MissingParameterError'

src/utils/mergeTree.ts

@@ -1,17 +1,16 @@
-import { Buffer } from 'buffer'
+import { BlobMergeCallback, BlobMergeCallbackParams, Cache, WalkerEntry } from '../models'
 
+import { Buffer } from 'buffer'
 import { FileSystem } from '../models/FileSystem'
-import { BlobMergeCallback, BlobMergeCallbackParams, Cache, WalkerEntry } from '../models'
+import { GitTree } from '../models/GitTree'
+import { MergeConflictError } from 'git-essentials/errors'
 import { TREE } from '../commands/TREE'
 import { _walk } from '../commands/walk'
-import { MergeNotSupportedError } from '../errors/MergeNotSupportedError'
-import { GitTree } from '../models/GitTree'
-import { _writeObject as writeObject } from '../storage/writeObject'
-
 import { basename } from './basename'
 import { isBinary } from './isBinary'
 import { join } from './join'
 import { mergeFile } from './mergeFile'
+import { _writeObject as writeObject } from '../storage/writeObject'
 
 type MergeTreeParams = {
   /** A file system helper. */
@@ -140,7 +139,19 @@ export async function mergeTree({
             (base && (await base.type()) !== 'blob') ||
             (theirs && (await theirs.type()) !== 'blob')
           ) {
-            throw new MergeNotSupportedError()
+            if (
+              (ours && (await ours.type()) === 'tree') &&
+              !base &&
+              (theirs && (await theirs.type()) === 'tree')) {
+                return {
+                  mode: await theirs.mode(),
+                  path,
+                  oid: await theirs.oid(),
+                  type: await theirs.type(),
+                }
+            }
+
+            throw new MergeConflictError(filepath)
           }
 
           // Modifications
@@ -307,7 +318,7 @@ async function defaultBlobMergeCallback({
       !theirContent ||
       isBinary(theirContent)
     ) {
-      throw new MergeNotSupportedError('Merge of binary data is not supported.')
+      throw new MergeConflictError(filePath)
     }
 
     // if both sides made changes do a merge
@@ -322,7 +333,7 @@ async function defaultBlobMergeCallback({
 
     if (!cleanMerge) {
       // all other types of conflicts fail
-      throw new MergeNotSupportedError('Merge with conflicts is not supported.')
+      throw new MergeConflictError(filePath)
     }
 
     const mode =
@@ -331,6 +342,6 @@ async function defaultBlobMergeCallback({
         : await our.mode()
     return { mergedText: mergedText, mode: mode }
   } else {
-    throw new MergeNotSupportedError()
+    throw new MergeConflictError(filePath)
   }
 }

tests/merge.test.ts

@@ -1,13 +1,23 @@
-import { merge, resolveRef, log, BlobMergeCallback, checkout } from 'git-essentials'
-import { MissingNameError, MergeNotSupportedError } from 'git-essentials/errors'
+import * as path from './helpers/path'
+
+import {
+  BlobMergeCallback,
+  add,
+  branch,
+  checkout,
+  commit,
+  init,
+  log,
+  merge,
+  resolveRef
+} from 'git-essentials'
+import { FsFixtureData, makeFsFixture } from './helpers/makeFsFixture'
+import { MergeConflictError, MergeNotSupportedError, MissingNameError } from 'git-essentials/errors'
 
-import { makeFsFixture, FsFixtureData } from './helpers/makeFsFixture'
 import { expectToFailWithTypeAsync } from './helpers/assertionHelper'
-
 import mergeFsFixtureData from './fixtures/fs/merge.json'
 import mergeNoFastForwardFsFixtureData from './fixtures/fs/merge-no-ff.json'
 
-
 const author = {
   name: 'Mr. Test',
   email: 'mrtest@example.com',
@@ -257,7 +267,7 @@ describe('merge', () => {
     }
 
     // assert
-    await expectToFailWithTypeAsync(action, MergeNotSupportedError)
+    await expectToFailWithTypeAsync(action, MergeConflictError)
   })
 
   it("merge two branches that modified the same file (no conflict)'", async () => {
@@ -302,7 +312,7 @@ describe('merge', () => {
     }
 
     // assert
-    await expectToFailWithTypeAsync(action, MergeNotSupportedError)
+    await expectToFailWithTypeAsync(action, MergeConflictError)
   })
 
   it("merge two branches that modified the same file, custom conflict resolver (prefer our changes)", async () => {
@@ -385,3 +395,162 @@ describe('merge', () => {
     expect(conflictedFile).toBe('text\nfile\nwas\nmodified\n')
   })
 })
+
+describe('merge-e2e', () => {
+  const branch1Name = 'branch1'
+  const branch2Name = 'branch2'
+  const newDirName = 'new-dir'
+
+  it('merge new folders with the same name', async () => {
+    // ARRANGE
+    const { fs, dir } = await makeFsFixture()
+
+    // initializing new repo
+    await init({ fs, dir, defaultBranch: branch1Name })
+    await commit({ fs, dir, message: 'first commit', author: { name: 'author0' } })
+    await branch({ fs, dir, ref: branch2Name, checkout: false })
+
+    // writing files to the branch1
+    await fs.mkdir(path.resolve(dir, newDirName))
+    await fs.writeFile(path.resolve(dir, newDirName, 'new-file.txt'), 'some content')
+    await fs.writeFile(path.resolve(dir, newDirName, 'new-file1.txt'), 'some content 1')
+    await add({ fs, dir, filepath: path.resolve(newDirName, 'new-file.txt') })
+    await add({ fs, dir, filepath: path.resolve(newDirName, 'new-file1.txt') })
+    await commit({ fs, dir, message: 'add files', author: { name: 'author1' } })
+
+    // writing files to the branch2
+    await checkout({ fs, dir, ref: branch2Name })
+    await fs.mkdir(path.resolve(dir, newDirName))
+    await fs.writeFile(path.resolve(dir, newDirName, 'new-file.txt'), 'some content')
+    await fs.writeFile(path.resolve(dir, newDirName, 'new-file2.txt'), 'some content 2')
+    await add({ fs, dir, filepath: path.resolve(newDirName, 'new-file.txt') })
+    await add({ fs, dir, filepath: path.resolve(newDirName, 'new-file2.txt') })
+    await commit({ fs, dir, message: 'add files', author: { name: 'author2' } })
+
+    // switching back to the branch1
+    await checkout({ fs, dir, ref: branch1Name })
+
+    // ACT
+    const m = await merge({ fs, dir, ours: branch1Name, theirs: branch2Name, author: { name: 'author3' } })
+    await checkout({ fs, dir, ref: branch1Name })
+
+    // ASSERT
+    expect(m.alreadyMerged).toBeFalsy()
+    expect(m.mergeCommit).toBeTruthy()
+    const newDirFiles = await fs.readdir(path.resolve(dir, newDirName))
+    expect(newDirFiles.length).toBe(3)
+  })
+
+  it('merge subfolders with new parent folder with the same name', async () => {
+    // ARRANGE
+    const { fs, dir } = await makeFsFixture()
+
+    // initializing new repo
+    await init({ fs, dir, defaultBranch: branch1Name })
+    await commit({ fs, dir, message: 'first commit', author: { name: 'author0' } })
+    await branch({ fs, dir, ref: branch2Name, checkout: false })
+
+    // writing files to the branch1
+    await fs.mkdir(path.resolve(dir, newDirName))
+    await fs.mkdir(path.resolve(dir, newDirName, 'sub-folder1'))
+    await fs.writeFile(path.resolve(dir, newDirName, 'sub-folder1', 'new-file.txt'), 'some content 1')
+    await add({ fs, dir, filepath: path.resolve(newDirName, 'sub-folder1', 'new-file.txt') })
+    await commit({ fs, dir, message: 'add files', author: { name: 'author1' } })
+
+    // writing files to a branch2
+    await checkout({ fs, dir, ref: branch2Name })
+    await fs.mkdir(path.resolve(dir, newDirName))
+    await fs.mkdir(path.resolve(dir, newDirName, 'sub-folder2'))
+    await fs.writeFile(path.resolve(dir, newDirName, 'sub-folder2', 'new-file.txt'), 'some content 2')
+    await add({ fs, dir, filepath: path.resolve(newDirName, 'sub-folder2', 'new-file.txt') })
+    await commit({ fs, dir, message: 'add files', author: { name: 'author2' } })
+
+    // switching back to the branch1
+    await checkout({ fs, dir, ref: branch1Name })
+
+    // ACT
+    const m = await merge({ fs, dir, ours: branch1Name, theirs: branch2Name, author: { name: 'author3' } })
+    await checkout({ fs, dir, ref: branch1Name })
+
+    // ASSERT
+    expect(m.alreadyMerged).toBeFalsy()
+    expect(m.mergeCommit).toBeTruthy()
+    const newDirFiles = await fs.readdir(path.resolve(dir, newDirName))
+    expect(newDirFiles.length).toBe(2)
+  })
+
+  it('merge subfolders with the same name who have a new parent with the same name', async () => {
+    // ARRANGE
+    const { fs, dir } = await makeFsFixture()
+
+    // initializing new repo
+    await init({ fs, dir, defaultBranch: branch1Name })
+    await commit({ fs, dir, message: 'first commit', author: { name: 'author0' } })
+    await branch({ fs, dir, ref: branch2Name, checkout: false })
+
+    // writing files to the branch1
+    await fs.mkdir(path.resolve(dir, newDirName))
+    await fs.mkdir(path.resolve(dir, newDirName, 'sub-folder'))
+    await fs.writeFile(path.resolve(dir, newDirName, 'sub-folder', 'new-file1.txt'), 'some content 1')
+    await add({ fs, dir, filepath: path.resolve(newDirName, 'sub-folder', 'new-file1.txt') })
+    await commit({ fs, dir, message: 'add files', author: { name: 'author1' } })
+
+    // writing files to a branch2
+    await checkout({ fs, dir, ref: branch2Name })
+    await fs.mkdir(path.resolve(dir, newDirName))
+    await fs.mkdir(path.resolve(dir, newDirName, 'sub-folder'))
+    await fs.writeFile(path.resolve(dir, newDirName, 'sub-folder', 'new-file2.txt'), 'some content 2')
+    await add({ fs, dir, filepath: path.resolve(newDirName, 'sub-folder', 'new-file2.txt') })
+    await commit({ fs, dir, message: 'add files', author: { name: 'author2' } })
+
+    // switching back to the branch1
+    await checkout({ fs, dir, ref: branch1Name })
+
+    // ACT
+    const m = await merge({ fs, dir, ours: branch1Name, theirs: branch2Name, author: { name: 'author3' } })
+    await checkout({ fs, dir, ref: branch1Name })
+
+    // ASSERT
+    expect(m.alreadyMerged).toBeFalsy()
+    expect(m.mergeCommit).toBeTruthy()
+    const newDirFiles = await fs.readdir(path.resolve(dir, newDirName))
+    expect(newDirFiles.length).toBe(1)
+    const newSubDirFiles = await fs.readdir(path.resolve(dir, newDirName, 'sub-folder'))
+    expect(newSubDirFiles.length).toBe(2)
+  })
+
+  it('merge new folder and file with the same name should fail', async () => {
+    // ARRANGE
+    const { fs, dir } = await makeFsFixture()
+
+    // initializing new repo
+    await init({ fs, dir, defaultBranch: branch1Name })
+    await commit({ fs, dir, message: 'first commit', author: { name: 'author0' } })
+    await branch({ fs, dir, ref: branch2Name, checkout: false })
+
+    // writing files to the branch1
+    await fs.mkdir(path.resolve(dir, newDirName))
+    await fs.writeFile(path.resolve(dir, newDirName, 'new-file.txt'), 'some content')
+    await fs.writeFile(path.resolve(dir, newDirName, 'new-file1.txt'), 'some content 1')
+    await add({ fs, dir, filepath: path.resolve(newDirName, 'new-file.txt') })
+    await add({ fs, dir, filepath: path.resolve(newDirName, 'new-file1.txt') })
+    await commit({ fs, dir, message: 'add files', author: { name: 'author1' } })
+
+    // writing files to the branch2
+    await checkout({ fs, dir, ref: branch2Name })
+    await fs.writeFile(path.resolve(dir, newDirName), 'some content')
+    await add({ fs, dir, filepath: newDirName })
+    await commit({ fs, dir, message: 'add files', author: { name: 'author2' } })
+
+    // switching back to the branch1
+    await checkout({ fs, dir, ref: branch1Name })
+
+    // ACT
+    const action = async () => {
+      await merge({ fs, dir, ours: branch1Name, theirs: branch2Name, author: { name: 'author3' } })
+    }
+
+    // ASSERT
+    await expectToFailWithTypeAsync(action, MergeConflictError)
+  })
+})