"""Get the encoding specified by the Windows system-wide ANSI active code page."""

# locale.getencoding may work but is only in Python 3.11+. Use the registry instead.

import winreg

hklm_path = R"SYSTEM\CurrentControlSet\Control\Nls\CodePage"

with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, hklm_path) as key:

value, _ = winreg.QueryValueEx(key, "ACP")

"""Namespace of native-Windows bash.exe statuses. Affects what hook tests can pass.

@dataclass

class Inapplicable:

"""This system is not native Windows: either not Windows at all, or Cygwin."""

@dataclass

class Absent:

"""No command for bash.exe is found on the system."""

@dataclass

class Native:

"""Running bash.exe operates outside any WSL distribution (as with Git Bash)."""

@dataclass

class Wsl:

"""Running bash.exe calls bash in a WSL distribution."""

@dataclass

class WslNoDistro:

"""Running bash.exe tries to run bash on a WSL distribution, but none exists."""

process: "subprocess.CompletedProcess[bytes]"

message: str

@dataclass

class CheckError:

"""Running bash.exe fails in an unexpected error or gives unexpected output."""

process: "subprocess.CompletedProcess[bytes]"

message: str

@dataclass

class WinError:

"""bash.exe may exist but can't run. CreateProcessW fails unexpectedly."""

exception: OSError

@classmethod

def check(cls):

"""Check the status of the bash.exe that run_commit_hook will try to use.

if sys.platform != "win32":

return cls.Inapplicable()

try:

# Output rather than forwarding the test command's exit status so that if a

# failure occurs before we even get to this point, we will detect it. For

# information on ways to check for WSL, see https://superuser.com/a/1749811.

script = 'test -e /proc/sys/fs/binfmt_misc/WSLInterop; echo "$?"'

command = ["bash.exe", "-c", script]

process = subprocess.run(command, capture_output=True)

except FileNotFoundError:

return cls.Absent()

except OSError as error:

return cls.WinError(error)

text = cls._decode(process.stdout).rstrip() # stdout includes WSL's own errors.

if process.returncode == 1 and re.search(r"\bhttps://aka.ms/wslstore\b", text):

return cls.WslNoDistro(process, text)

if process.returncode != 0:

_logger.error("Error running bash.exe to check WSL status: %s", text)

return cls.CheckError(process, text)

if text == "0":

return cls.Wsl()

if text == "1":

return cls.Native()

_logger.error("Strange output checking WSL status: %s", text)

return cls.CheckError(process, text)

@staticmethod

def _decode(stdout):

"""Decode bash.exe output as best we can."""

# When bash.exe is the WSL wrapper but the output is from WSL itself rather than

# code running in a distribution, the output is often in UTF-16LE, which Windows

# uses internally. The UTF-16LE representation of a Windows-style line ending is

# rarely seen otherwise, so use it to detect this situation.

if b"\r\0\n\0" in stdout:

return stdout.decode("utf-16le")

# At this point, the output is either blank or probably not UTF-16LE. It's often

# UTF-8 from inside a WSL distro or non-WSL bash shell. Our test command only

# uses the ASCII subset, so we can safely guess a wrong code page for it. Errors

# from such an environment can contain any text, but unlike WSL's own messages,

# they go to stderr, not stdout. So we can try the system ANSI code page first.

acp = _get_windows_ansi_encoding()

try:

return stdout.decode(acp)

except UnicodeDecodeError:

pass

except LookupError as error:

_logger.warning(str(error)) # Message already says "Unknown encoding:".

# Assume UTF-8. If invalid, substitute Unicode replacement characters.

"""A helper to create a hook"""

hp = hook_path(name, git_dir)

hpd = osp.dirname(hp)

if not osp.isdir(hpd):

os.mkdir(hpd)

with open(hp, "wt") as fp:

fp.write(HOOKS_SHEBANG + content)

if make_exec:

os.chmod(hp, 0o744)

"""Build an index without using the writer under test."""

name = path.encode("utf-8")

entry = struct.pack(">10L20sH", 0, 0, 0, 0, 0, 0, mode, 0, 0, 0, b"a" * 20, min(len(name), 0xFFF)) + name

entry += b"\0" * (8 - len(entry) % 8)

data = b"DIRC" + struct.pack(">LL", 2, 1) + entry

@with_rw_repo("HEAD")

def test_checkout_rejects_unsafe_prefix(self, rw_repo):

with tempfile.TemporaryDirectory() as target:

with self.assertRaises(UnsafeOptionError):

rw_repo.index.checkout(prefix=f"{target}/")

rw_repo.index.checkout(prefix=f"{target}/", allow_unsafe_options=True)

self.assertTrue(osp.isfile(osp.join(target, "CHANGES")))

@with_rw_repo("HEAD")

def test_remove_rejects_pathspec_from_file(self, rw_repo):

with tempfile.TemporaryDirectory() as tdir:

pathspecs = Path(tdir) / "pathspecs"

pathspecs.write_bytes(b"unmatched-path-one\nunmatched-path-two")

for option_name in ("pathspec_from_file", "pathspec_from"):

with self.assertRaises(UnsafeOptionError):

rw_repo.index.remove(

[],

pathspec_file_nul=True,

**{option_name: str(pathspecs)},

)

@with_rw_repo("HEAD")

def test_remove_allows_explicit_pathspec_from_file(self, rw_repo):

with tempfile.TemporaryDirectory() as tdir:

pathspecs = Path(tdir) / "pathspecs"

pathspecs.write_bytes(b"CHANGES\0")

removed = rw_repo.index.remove(

[],

pathspec_from_file=str(pathspecs),

pathspec_file_nul=True,

allow_unsafe_options=True,

)

assert "CHANGES" in removed

def __init__(self, *args):

super().__init__(*args)

self._reset_progress()

def _assert_fprogress(self, entries):

self.assertEqual(len(entries), len(self._fprogress_map))

for _path, call_count in self._fprogress_map.items():

self.assertEqual(call_count, 2)

# END for each item in progress map

self._reset_progress()

def _fprogress(self, path, done, item):

self._fprogress_map.setdefault(path, 0)

curval = self._fprogress_map[path]

if curval == 0:

assert not done

if curval == 1:

assert done

self._fprogress_map[path] = curval + 1

def _fprogress_add(self, path, done, item):

"""Called as progress func - we keep track of the proper call order."""

assert item is not None

self._fprogress(path, done, item)

def _reset_progress(self):

# Maps paths to the count of calls.

self._fprogress_map = {}

def _assert_entries(self, entries):

for entry in entries:

assert isinstance(entry, BaseIndexEntry)

assert not osp.isabs(entry.path)

assert "\\" not in entry.path

# END for each entry

def test_index_file_base(self):

# Read from file.

index = IndexFile(self.rorepo, fixture_path("index"))

assert index.entries

assert index.version > 0

# Test entry.

entry = next(iter(index.entries.values()))

for attr in (

"path",

"ctime",

"mtime",

"dev",

"inode",

"mode",

"uid",

"gid",

"size",

"binsha",

"hexsha",

"stage",

):

getattr(entry, attr)

# END for each method

# Test update.

entries = index.entries

assert isinstance(index.update(), IndexFile)

assert entries is not index.entries

# Test stage.

index_merge = IndexFile(self.rorepo, fixture_path("index_merge"))

self.assertEqual(len(index_merge.entries), 106)

assert len([e for e in index_merge.entries.values() if e.stage != 0])

# Write the data - it must match the original.

tmpfile = tempfile.mktemp()

index_merge.write(tmpfile)

with open(tmpfile, "rb") as fp:

self.assertEqual(fp.read(), fixture("index_merge"))

os.remove(tmpfile)

@ddt.data(

def test_index_reader_and_writer_reject_unsafe_paths(self, path):

with pytest.raises(ValueError):

read_cache(BytesIO(_raw_index(path)))

entry = IndexEntry((0o100644, b"a" * 20, 0, path))

with pytest.raises(ValueError):

write_cache([entry], BytesIO())

@ddt.data(

def test_index_reader_and_writer_reject_gitmodules_symlinks(self, path):

"""An entry that turns .gitmodules into a symbolic link is rejected, while the

with pytest.raises(ValueError):

read_cache(BytesIO(_raw_index(path, mode=0o120000)))

with pytest.raises(ValueError):

write_cache([IndexEntry((0o120000, b"a" * 20, 0, path))], BytesIO())

assert next(iter(read_cache(BytesIO(_raw_index(path)))[1])) == (path, 0)

stream = BytesIO()

write_cache([IndexEntry((0o100644, b"a" * 20, 0, path))], stream)

stream.seek(0)

assert next(iter(read_cache(stream)[1])) == (path, 0)

@ddt.data("GI7EB~10", "GI7E~100", "GI7~1000", "GI~10000", "G~100000", "~1000000", "~9999999")

@with_rw_directory

def test_index_add_and_write_tree_reject_gitmodules_fallback_symlinks(self, rw_dir, path):

with Repo.init(rw_dir) as repo:

binsha = repo.odb.store(IStream("blob", 6, BytesIO(b"target"))).binsha

index = repo.index

for item in (Blob(repo, binsha, 0o120000, path), BaseIndexEntry((0o120000, binsha, 0, path))):

with pytest.raises(ValueError, match="submodule configuration"):

index.add([item], write=False)

assert not index.entries

index.entries[(path, 0)] = IndexEntry((0o120000, binsha, 0, path))

with pytest.raises(ValueError, match="submodule configuration"):

index.write_tree()

assert not Path(index.path).exists()

index.add([BaseIndexEntry((0o100644, binsha, 0, path))])

assert repo.index.entries[(path, 0)].mode == 0o100644

assert index.write_tree()[path].mode == 0o100644

def test_valid_unusual_index_names_round_trip(self):

names = ["a b", "a\nb", "a\tb", "name:value", "dir/.gitignore", "café"]

if os.name != "nt":

names.append("a\\b")

entries = [IndexEntry((0o100644, b"a" * 20, 0, name)) for name in sorted(names)]

stream = BytesIO()

write_cache(entries, stream)

stream.seek(0)

assert [entry.path for entry in read_cache(stream)[1].values()] == sorted(names)

def test_long_index_names_are_fully_validated(self):

prefix = "a/" + "nested/" * 650

with pytest.raises(ValueError):

read_cache(BytesIO(_raw_index(prefix + "../outside")))

name = prefix + "file"

assert next(iter(read_cache(BytesIO(_raw_index(name)))[1])) == (name, 0)

stream = BytesIO()

write_cache([IndexEntry((0o100644, b"a" * 20, 0, name))], stream)

stream.seek(0)

assert next(iter(read_cache(stream)[1])) == (name, 0)

def _cmp_tree_index(self, tree, index):

# Fail unless both objects contain the same paths and blobs.

if isinstance(tree, str):

tree = self.rorepo.commit(tree).tree

blist = []

for blob in tree.traverse(predicate=lambda e, d: e.type == "blob", branch_first=False):

assert (blob.path, 0) in index.entries

blist.append(blob)

# END for each blob in tree

if len(blist) != len(index.entries):

iset = {k[0] for k in index.entries.keys()}

bset = {b.path for b in blist}

raise AssertionError(

"CMP Failed: Missing entries in index: %s, missing in tree: %s" % (bset - iset, iset - bset)

)

# END assertion message

@with_rw_repo("0.1.6")

def test_index_lock_handling(self, rw_repo):

index = rw_repo.index

index_path = Path(index.path)

lock_path = Path(str(index_path) + ".lock")

before = index_path.read_bytes()

def fail_serialize(stream, ignore_extension_data):

assert lock_path.exists()

stream.write(b"partial index")

raise OSError("simulated index write failure")

with mock.patch.object(IndexFile, "_serialize", side_effect=fail_serialize):

for _ in range(2):

with pytest.raises(OSError, match="simulated index write failure"):

index.write()

assert not lock_path.exists()

assert index_path.read_bytes() == before

index.add([Blob(rw_repo, b"f" * 20, 0o100644, "foo")])

assert not lock_path.exists()

assert rw_repo.index.entries[("foo", 0)].mode == 0o100644

@with_rw_repo("0.1.6")

def test_read_tree_methods_reject_index_output(self, rw_repo):

output_path = (Path(rw_repo.working_tree_dir) / "alternate-index").as_posix()

unsafe_option = f"--index-output={output_path}"

with pytest.raises(UnsafeOptionError):

IndexFile.from_tree(rw_repo, unsafe_option)

with pytest.raises(UnsafeOptionError):

IndexFile.from_tree(rw_repo, "HEAD", index_output=output_path)

with pytest.raises(UnsafeOptionError):

rw_repo.index.reset(unsafe_option)

with pytest.raises(UnsafeOptionError):

rw_repo.index.merge_tree(unsafe_option)

with pytest.raises(UnsafeOptionError):

rw_repo.index.merge_tree("HEAD", base=unsafe_option)

@with_rw_repo("0.1.6")

def test_index_file_from_tree(self, rw_repo):

common_ancestor_sha = "5117c9c8a4d3af19a9958677e45cda9269de1541"

cur_sha = "4b43ca7ff72d5f535134241e7c797ddc9c7a3573"

other_sha = "39f85c4358b7346fee22169da9cad93901ea9eb9"

# Simple index from tree.

base_index = IndexFile.from_tree(rw_repo, common_ancestor_sha)

assert base_index.entries

self._cmp_tree_index(common_ancestor_sha, base_index)

# Merge two trees - it's like a fast-forward.

two_way_index = IndexFile.from_tree(rw_repo, common_ancestor_sha, cur_sha)

assert two_way_index.entries

self._cmp_tree_index(cur_sha, two_way_index)

# Merge three trees - here we have a merge conflict.

three_way_index = IndexFile.from_tree(rw_repo, common_ancestor_sha, cur_sha, other_sha)

assert len([e for e in three_way_index.entries.values() if e.stage != 0])

# ITERATE BLOBS

def merge_required(t):

return t[0] != 0

merge_blobs = list(three_way_index.iter_blobs(merge_required))

assert merge_blobs

assert merge_blobs[0][0] in (1, 2, 3)

assert isinstance(merge_blobs[0][1], Blob)

# Test BlobFilter.

prefix = "lib/git"

for _stage, blob in base_index.iter_blobs(BlobFilter([prefix])):

assert blob.path.startswith(prefix)

# Writing a tree should fail with an unmerged index.

self.assertRaises(UnmergedEntriesError, three_way_index.write_tree)

# Removed unmerged entries.

unmerged_blob_map = three_way_index.unmerged_blobs()

assert unmerged_blob_map

# Pick the first blob at the first stage we find and use it as resolved version.

three_way_index.resolve_blobs(line[0][1] for line in unmerged_blob_map.values())

tree = three_way_index.write_tree()

assert isinstance(tree, Tree)

num_blobs = 0

for blob in tree.traverse(predicate=lambda item, d: item.type == "blob"):

assert (blob.path, 0) in three_way_index.entries

num_blobs += 1

# END for each blob

self.assertEqual(num_blobs, len(three_way_index.entries))

@with_rw_repo("0.1.6")

def test_index_merge_tree(self, rw_repo):

# A bit out of place, but we need a different repo for this:

self.assertNotEqual(self.rorepo, rw_repo)

self.assertEqual(len({self.rorepo, self.rorepo, rw_repo, rw_repo}), 2)

# SINGLE TREE MERGE

# Current index is at the (virtual) cur_commit.

next_commit = "4c39f9da792792d4e73fc3a5effde66576ae128c"

parent_commit = rw_repo.head.commit.parents[0]

manifest_key = IndexFile.entry_key("MANIFEST.in", 0)

manifest_entry = rw_repo.index.entries[manifest_key]

rw_repo.index.merge_tree(next_commit)

# Only one change should be recorded.

assert manifest_entry.binsha != rw_repo.index.entries[manifest_key].binsha

rw_repo.index.reset(rw_repo.head)

self.assertEqual(rw_repo.index.entries[manifest_key].binsha, manifest_entry.binsha)

# FAKE MERGE

#############

# Add a change with a NULL sha that should conflict with next_commit. We pretend

# there was a change, but we do not even bother adding a proper sha for it

# (which makes things faster of course).

manifest_fake_entry = BaseIndexEntry((manifest_entry[0], b"\0" * 20, 0, manifest_entry[3]))

# Try write flag.

self._assert_entries(rw_repo.index.add([manifest_fake_entry], write=False))

# Add actually resolves the null-hex-sha for us as a feature, but we can edit

# the index manually.

assert rw_repo.index.entries[manifest_key].binsha != Object.NULL_BIN_SHA

# We must operate on the same index for this! It's a bit problematic as it might

# confuse people.

index = rw_repo.index

index.entries[manifest_key] = IndexEntry.from_base(manifest_fake_entry)

index.write()

self.assertEqual(rw_repo.index.entries[manifest_key].hexsha, Diff.NULL_HEX_SHA)

# Write an unchanged index (just for the fun of it).

rw_repo.index.write()

# A three way merge would result in a conflict and fails as the command will not

# overwrite any entries in our index and hence leave them unmerged. This is

# mainly a protection feature as the current index is not yet in a tree.

self.assertRaises(GitCommandError, index.merge_tree, next_commit, base=parent_commit)

# The only way to get the merged entries is to safe the current index away into

# a tree, which is like a temporary commit for us. This fails as well as the

# NULL sha does not have a corresponding object.

# NOTE: missing_ok is not a kwarg anymore, missing_ok is always true.

# self.assertRaises(GitCommandError, index.write_tree)

# If missing objects are okay, this would work though (they are always okay

# now). As we can't read back the tree with NULL_SHA, we rather set it to

# something else.

index.entries[manifest_key] = IndexEntry(manifest_entry[:1] + (hex_to_bin("f" * 40),) + manifest_entry[2:])

tree = index.write_tree()

# Now make a proper three way merge with unmerged entries.

unmerged_tree = IndexFile.from_tree(rw_repo, parent_commit, tree, next_commit)

unmerged_blobs = unmerged_tree.unmerged_blobs()

self.assertEqual(len(unmerged_blobs), 1)

self.assertEqual(list(unmerged_blobs.keys())[0], manifest_key[0])

@with_rw_repo("0.1.6")

def test_index_file_diffing(self, rw_repo):

# Default IndexFile instance points to our index.

index = IndexFile(rw_repo)

assert index.path is not None

assert len(index.entries)

# Write the file back.

index.write()

# Could sha it, or check stats.

# Test diff.

# Resetting the head will leave the index in a different state, and the diff

# will yield a few changes.

cur_head_commit = rw_repo.head.reference.commit

rw_repo.head.reset("HEAD~6", index=True, working_tree=False)

# Diff against same index is 0.

diff = index.diff()

self.assertEqual(len(diff), 0)

# Against HEAD as string, must be the same as it matches index.

diff = index.diff("HEAD")

self.assertEqual(len(diff), 0)

# Against previous head, there must be a difference.

diff = index.diff(cur_head_commit)

assert len(diff)

# We reverse the result.

adiff = index.diff(str(cur_head_commit), R=True)

odiff = index.diff(cur_head_commit, R=False) # Now its not reversed anymore.

assert adiff != odiff

self.assertEqual(odiff, diff) # Both unreversed diffs against HEAD.

# Against working copy - it's still at cur_commit.

wdiff = index.diff(None)

assert wdiff != adiff

assert wdiff != odiff

# Against something unusual.

self.assertRaises(ValueError, index.diff, int)

# Adjust the index to match an old revision.

cur_branch = rw_repo.active_branch

cur_commit = cur_branch.commit

rev_head_parent = "HEAD~1"

assert index.reset(rev_head_parent) is index

self.assertEqual(cur_branch, rw_repo.active_branch)

self.assertEqual(cur_commit, rw_repo.head.commit)

# There must be differences towards the working tree which is in the 'future'.

assert index.diff(None)

# Reset the working copy as well to current head, to pull 'back' as well.

new_data = b"will be reverted"

file_path = osp.join(rw_repo.working_tree_dir, "CHANGES")

with open(file_path, "wb") as fp:

fp.write(new_data)

index.reset(rev_head_parent, working_tree=True)

assert not index.diff(None)

self.assertEqual(cur_branch, rw_repo.active_branch)

self.assertEqual(cur_commit, rw_repo.head.commit)

with open(file_path, "rb") as fp:

assert fp.read() != new_data

# Test full checkout.

test_file = osp.join(rw_repo.working_tree_dir, "CHANGES")

with open(test_file, "ab") as fd:

fd.write(b"some data")

rval = index.checkout(None, force=True, fprogress=self._fprogress)

assert "CHANGES" in list(rval)

self._assert_fprogress([None])

assert osp.isfile(test_file)

os.remove(test_file)

rval = index.checkout(None, force=False, fprogress=self._fprogress)

assert "CHANGES" in list(rval)

self._assert_fprogress([None])

assert osp.isfile(test_file)

# Individual file.

os.remove(test_file)

rval = index.checkout(test_file, fprogress=self._fprogress)

self.assertEqual(list(rval)[0], "CHANGES")

self._assert_fprogress([test_file])

assert osp.exists(test_file)

# Checking out non-existing file throws.

self.assertRaises(CheckoutError, index.checkout, "doesnt_exist_ever.txt.that")

self.assertRaises(CheckoutError, index.checkout, paths=["doesnt/exist"])

# Check out file with modifications.

append_data = b"hello"

with open(test_file, "ab") as fp:

fp.write(append_data)

try:

index.checkout(test_file)

except CheckoutError as e:

# Detailed exceptions are only possible in older git versions.

if rw_repo.git.version_info < (2, 29):

self.assertEqual(len(e.failed_files), 1)

self.assertEqual(e.failed_files[0], osp.basename(test_file))

self.assertEqual(len(e.failed_files), len(e.failed_reasons))

self.assertIsInstance(e.failed_reasons[0], str)

self.assertEqual(len(e.valid_files), 0)

with open(test_file, "rb") as fd:

s = fd.read()

self.assertTrue(s.endswith(append_data), s)

else:

raise AssertionError("Exception CheckoutError not thrown")

# If we force it, it should work.

index.checkout(test_file, force=True)

assert not open(test_file, "rb").read().endswith(append_data)

# Check out directory.

rmtree(osp.join(rw_repo.working_tree_dir, "lib"))

rval = index.checkout("lib")

assert len(list(rval)) > 1

@with_rw_directory

def test_index_file_diff_null_tree_with_initial_index(self, rw_dir):

repo = Repo.init(rw_dir)

filename = ".gitkeep"

file_path = osp.join(repo.working_tree_dir, filename)

with open(file_path, "w") as fp:

fp.write("# Initial file\n")

index = repo.index

index.add([filename])

index.write()

index = IndexFile(repo)

self.assertEqual(len(index.diff(None)), 0)

diff = index.diff(NULL_TREE)

self.assertEqual(len(diff), 1)

self.assertEqual(diff[0].change_type, "A")

assert diff[0].new_file

self.assertEqual(diff[0].b_path, filename)

self.assertEqual(len(index.diff(NULL_TREE, paths=filename)), 1)

self.assertEqual(len(index.diff(NULL_TREE_SHA, paths=filename)), 1)

self.assertEqual(len(index.diff(NULL_TREE, paths="missing")), 0)

patch = index.diff(NULL_TREE, create_patch=True)

self.assertEqual(len(patch), 1)

self.assertIn(b"+# Initial file", patch[0].diff)

with self.assertRaises(GitCommandError) as exc_info:

index.diff(NULL_TREE, bogus_option=True)

self.assertIn("usage: git diff", exc_info.exception.stderr)

def _count_existing(self, repo, files):

"""Return count of files that actually exist in the repository directory."""

existing = 0

basedir = repo.working_tree_dir

for f in files:

existing += osp.isfile(osp.join(basedir, f))

# END for each deleted file

return existing

# END num existing helper

@ddt.data("write", "write_tree", "checkout", "cached_checkout")

@with_rw_directory

def test_index_boundaries_reject_injected_entries_before_side_effects(self, rw_dir, operation):

tmp_path = Path(rw_dir) / "repo"

with Repo.init(tmp_path) as repo:

index_path = Path(repo.index.path)

if operation == "checkout":

index_path.write_bytes(_raw_index("../outside"))

else:

repo.index.write()

before = index_path.read_bytes()

index = repo.index

if operation == "cached_checkout":

assert not index.entries

index_path.write_bytes(_raw_index("../outside"))

before = index_path.read_bytes()

operation = "checkout"

elif operation != "checkout":

index.entries[("../outside", 0)] = IndexEntry((0o100644, b"a" * 20, 0, "../outside"))

with pytest.raises(ValueError):

getattr(index, operation)()

assert index_path.read_bytes() == before

assert not (tmp_path.parent / "outside").exists()

@with_rw_repo("0.1.6")

def test_index_mutation(self, rw_repo):

with xfail_if_raises(

sys.platform == "win32" and (Git().config("core.symlinks") == "true" or symlinks_supported()),

raises=(FileNotFoundError, GitCommandError),

reason="Assumes symlinks are not created on Windows and opens a symlink to a nonexistent target.",

):

index = rw_repo.index

num_entries = len(index.entries)

cur_head = rw_repo.head

uname = "Thomas Müller"

umail = "sd@company.com"

with rw_repo.config_writer() as writer:

writer.set_value("user", "name", uname)

writer.set_value("user", "email", umail)

self.assertEqual(writer.get_value("user", "name"), uname)

# Remove all of the files, provide a wild mix of paths, BaseIndexEntries,

# IndexEntries.

def mixed_iterator():

count = 0

for entry in index.entries.values():

type_id = count % 5

if type_id == 0: # path (str)

yield entry.path

elif type_id == 1: # path (PathLike)

yield Path(entry.path)

elif type_id == 2: # path mock (PathLike)

yield PathLikeMock(entry.path)

elif type_id == 3: # path mock in a blob

yield Blob(rw_repo, entry.binsha, entry.mode, entry.path)

elif type_id == 4: # blob

yield Blob(rw_repo, entry.binsha, entry.mode, entry.path)

elif type_id == 5: # BaseIndexEntry

yield BaseIndexEntry(entry[:4])

elif type_id == 6: # IndexEntry

yield entry

else:

raise AssertionError("Invalid Type")

count += 1

# END for each entry

# END mixed iterator

deleted_files = index.remove(mixed_iterator(), working_tree=False)

assert deleted_files

self.assertEqual(self._count_existing(rw_repo, deleted_files), len(deleted_files))

self.assertEqual(len(index.entries), 0)

# Reset the index to undo our changes.

index.reset()

self.assertEqual(len(index.entries), num_entries)

# Remove with working copy.

deleted_files = index.remove(mixed_iterator(), working_tree=True)

assert deleted_files

self.assertEqual(self._count_existing(rw_repo, deleted_files), 0)

# Reset everything.

index.reset(working_tree=True)

self.assertEqual(self._count_existing(rw_repo, deleted_files), len(deleted_files))

# Invalid type.

self.assertRaises(TypeError, index.remove, [1])

# Absolute path.

deleted_files = index.remove([osp.join(rw_repo.working_tree_dir, "lib")], r=True)

assert len(deleted_files) > 1

self.assertRaises(ValueError, index.remove, ["/doesnt/exists"])

# TEST COMMITTING

# Commit changed index.

cur_commit = cur_head.commit

commit_message = "commit default head by Frèderic Çaufl€"

new_commit = index.commit(commit_message, head=False)

assert cur_commit != new_commit

self.assertEqual(new_commit.author.name, uname)

self.assertEqual(new_commit.author.email, umail)

self.assertEqual(new_commit.committer.name, uname)

self.assertEqual(new_commit.committer.email, umail)

self.assertEqual(new_commit.message, commit_message)

self.assertEqual(new_commit.parents[0], cur_commit)

self.assertEqual(len(new_commit.parents), 1)

self.assertEqual(cur_head.commit, cur_commit)

# Commit with other actor.

cur_commit = cur_head.commit

my_author = Actor("Frèderic Çaufl€", "author@example.com")

my_committer = Actor("Committing Frèderic Çaufl€", "committer@example.com")

commit_actor = index.commit(commit_message, author=my_author, committer=my_committer)

assert cur_commit != commit_actor

self.assertEqual(commit_actor.author.name, "Frèderic Çaufl€")

self.assertEqual(commit_actor.author.email, "author@example.com")

self.assertEqual(commit_actor.committer.name, "Committing Frèderic Çaufl€")

self.assertEqual(commit_actor.committer.email, "committer@example.com")

self.assertEqual(commit_actor.message, commit_message)

self.assertEqual(commit_actor.parents[0], cur_commit)

self.assertEqual(len(new_commit.parents), 1)

self.assertEqual(cur_head.commit, commit_actor)

self.assertEqual(cur_head.log()[-1].actor, my_committer)

# Commit with author_date and commit_date.

cur_commit = cur_head.commit

commit_message = "commit with dates by Avinash Sajjanshetty"

new_commit = index.commit(

commit_message,

author_date="2006-04-07T22:13:13",

commit_date="2005-04-07T22:13:13",

)

assert cur_commit != new_commit

print(new_commit.authored_date, new_commit.committed_date)

self.assertEqual(new_commit.message, commit_message)

self.assertEqual(new_commit.authored_date, 1144447993)

self.assertEqual(new_commit.committed_date, 1112911993)

# Same index, no parents.

commit_message = "index without parents"

commit_no_parents = index.commit(commit_message, parent_commits=[], head=True)

self.assertEqual(commit_no_parents.message, commit_message)

self.assertEqual(len(commit_no_parents.parents), 0)

self.assertEqual(cur_head.commit, commit_no_parents)

# same index, multiple parents.

commit_message = "Index with multiple parents\n commit with another line"

commit_multi_parent = index.commit(commit_message, parent_commits=(commit_no_parents, new_commit))

self.assertEqual(commit_multi_parent.message, commit_message)

self.assertEqual(len(commit_multi_parent.parents), 2)

self.assertEqual(commit_multi_parent.parents[0], commit_no_parents)

self.assertEqual(commit_multi_parent.parents[1], new_commit)

self.assertEqual(cur_head.commit, commit_multi_parent)

# Re-add all files in lib.

# Get the lib folder back on disk, but get an index without it.

index.reset(new_commit.parents[0], working_tree=True).reset(new_commit, working_tree=False)

lib_file_path = osp.join("lib", "git", "__init__.py")

assert (lib_file_path, 0) not in index.entries

assert osp.isfile(osp.join(rw_repo.working_tree_dir, lib_file_path))

# Directory.

entries = index.add(["lib"], fprogress=self._fprogress_add)

self._assert_entries(entries)

self._assert_fprogress(entries)

assert len(entries) > 1

# Glob.

entries = index.reset(new_commit).add([osp.join("lib", "git", "*.py")], fprogress=self._fprogress_add)

self._assert_entries(entries)

self._assert_fprogress(entries)

self.assertEqual(len(entries), 14)

# Same file.

entries = index.reset(new_commit).add(

[osp.join(rw_repo.working_tree_dir, "lib", "git", "head.py")] * 2,

fprogress=self._fprogress_add,

)

self._assert_entries(entries)

self.assertEqual(entries[0].mode & 0o644, 0o644)

# Would fail, test is too primitive to handle this case.

# self._assert_fprogress(entries)

self._reset_progress()

self.assertEqual(len(entries), 2)

# Missing path.

self.assertRaises(OSError, index.reset(new_commit).add, ["doesnt/exist/must/raise"])

# Blob from older revision overrides current index revision.

old_blob = new_commit.parents[0].tree.blobs[0]

entries = index.reset(new_commit).add([old_blob], fprogress=self._fprogress_add)

self._assert_entries(entries)

self._assert_fprogress(entries)

self.assertEqual(index.entries[(old_blob.path, 0)].hexsha, old_blob.hexsha)

self.assertEqual(len(entries), 1)

# Mode 0 not allowed.

null_hex_sha = Diff.NULL_HEX_SHA

null_bin_sha = b"\0" * 20

self.assertRaises(

ValueError,

index.reset(new_commit).add,

[BaseIndexEntry((0, null_bin_sha, 0, "doesntmatter"))],

)

# Add new file.

new_file_relapath = "my_new_file"

self._make_file(new_file_relapath, "hello world", rw_repo)

entries = index.reset(new_commit).add(

[BaseIndexEntry((0o10644, null_bin_sha, 0, new_file_relapath))],

fprogress=self._fprogress_add,

)

self._assert_entries(entries)

self._assert_fprogress(entries)

self.assertEqual(len(entries), 1)

self.assertNotEqual(entries[0].hexsha, null_hex_sha)

# Add symlink.

if sys.platform != "win32":

for target in ("/etc/nonexisting", "/etc/passwd", "/etc"):

basename = "my_real_symlink"

link_file = osp.join(rw_repo.working_tree_dir, basename)

os.symlink(target, link_file)

entries = index.reset(new_commit).add([link_file], fprogress=self._fprogress_add)

self._assert_entries(entries)

self._assert_fprogress(entries)

self.assertEqual(len(entries), 1)

self.assertTrue(S_ISLNK(entries[0].mode))

self.assertTrue(S_ISLNK(index.entries[index.entry_key("my_real_symlink", 0)].mode))