Add in_directory function to paths and add new options to word_join

Author: domdfcoding

domdf_python_tools/paths.py

@@ -40,6 +40,7 @@
 #
 
 # stdlib
+import contextlib
 import json
 import os
 import pathlib
@@ -279,6 +280,23 @@ def make_executable(filename: PathLike) -> None:
 	os.chmod(str(filename), st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
 
 
+@contextlib.contextmanager
+def in_directory(directory: PathLike):
+	"""
+	Context manager to change into the given directory for the
+	duration of the ``with`` block.
+
+	:param directory:
+	"""
+
+	oldwd = os.getcwd()
+	try:
+		os.chdir(str(directory))
+		yield
+	finally:
+		os.chdir(oldwd)
+
+
 class PathPlus(pathlib.Path):
 	"""
 	Subclass of :mod:`pathlib.Path` with additional methods and a default encoding of UTF-8.

domdf_python_tools/words.py

@@ -493,16 +493,31 @@ def as_text(value: Any) -> str:
 	return str(value)
 
 
-def word_join(iterable: Iterable[str], use_repr: bool = False, oxford: bool = False) -> str:
+def word_join(
+		iterable: Iterable[str],
+		use_repr: bool = False,
+		oxford: bool = False,
+		delimiter: str = ",",
+		connective: str = "and",
+		) -> str:
 	"""
 	Join the given list of strings in a natural manner, with 'and' to join the last two elements.
 
 	:param iterable:
 	:param use_repr: Whether to join the ``repr`` of each object.
 	:param oxford: Whether to use an oxford comma when joining the last two elements.
 		Always :py:obj:`False` if there are fewer than three elements.
+	:param delimiter: A single character to use between the words.
+	:param connective: The connective to join the final two words with.
+
+	.. versionchanged:: 0.11.0
+
+		Added ``delimiter`` and ``connective`` arguments.
+
 	"""
 
+	delimiter = f"{delimiter} "
+
 	if use_repr:
 		words = [repr(w) for w in iterable]
 	else:
@@ -516,6 +531,6 @@ def word_join(iterable: Iterable[str], use_repr: bool = False, oxford: bool = Fa
 		return " and ".join(words)
 	else:
 		if oxford:
-			return ", ".join(words[:-1]) + f", and {words[-1]}"
+			return delimiter.join(words[:-1]) + f"{delimiter}{connective} {words[-1]}"
 		else:
-			return ", ".join(words[:-1]) + f" and {words[-1]}"
+			return delimiter.join(words[:-1]) + f" {connective} {words[-1]}"

tests/test_paths.py

@@ -21,7 +21,7 @@
 
 # this package
 from domdf_python_tools import paths
-from domdf_python_tools.paths import PathPlus, clean_writer, copytree
+from domdf_python_tools.paths import PathPlus, clean_writer, copytree, in_directory
 from domdf_python_tools.testing import not_pypy, not_windows
 
 
@@ -594,3 +594,20 @@ def test_load_json(tmpdir):
 	}"""))
 
 	assert tmp_file.load_json() == {"key": "value", "int": 1234, "float": 12.34}
+
+
+def test_in_directory(tmp_pathplus):
+	cwd = os.getcwd()
+
+	with in_directory(tmp_pathplus):
+		assert str(os.getcwd()) == str(tmp_pathplus)
+
+	assert os.getcwd() == cwd
+
+	tmpdir = tmp_pathplus / "tmp"
+	tmpdir.maybe_make()
+
+	with in_directory(tmpdir):
+		assert str(os.getcwd()) == str(tmpdir)
+
+	assert os.getcwd() == cwd

tests/test_words.py

@@ -111,31 +111,37 @@ def test_as_text(value, expects):
 	assert words.as_text(value) == expects
 
 
-def test_word_join():
-	assert words.word_join([]) == ''
-
-	assert words.word_join(["bob"]) == "bob"
-	assert words.word_join(["bob", "alice"]) == "bob and alice"
-	assert words.word_join(["bob", "alice", "fred"]) == "bob, alice and fred"
-
-	assert words.word_join(["bob"], use_repr=True) == "'bob'"
-	assert words.word_join(["bob", "alice"], use_repr=True) == "'bob' and 'alice'"
-	assert words.word_join(["bob", "alice", "fred"], use_repr=True) == "'bob', 'alice' and 'fred'"
-
-	assert words.word_join(["bob"], use_repr=True, oxford=True) == "'bob'"
-	assert words.word_join(["bob", "alice"], use_repr=True, oxford=True) == "'bob' and 'alice'"
-	assert words.word_join(["bob", "alice", "fred"], use_repr=True, oxford=True) == "'bob', 'alice', and 'fred'"
-
-	assert words.word_join(()) == ''
-
-	assert words.word_join(("bob", )) == "bob"
-	assert words.word_join(("bob", "alice")) == "bob and alice"
-	assert words.word_join(("bob", "alice", "fred")) == "bob, alice and fred"
-
-	assert words.word_join(("bob", ), use_repr=True) == "'bob'"
-	assert words.word_join(("bob", "alice"), use_repr=True) == "'bob' and 'alice'"
-	assert words.word_join(("bob", "alice", "fred"), use_repr=True) == "'bob', 'alice' and 'fred'"
-
-	assert words.word_join(("bob", ), use_repr=True, oxford=True) == "'bob'"
-	assert words.word_join(("bob", "alice"), use_repr=True, oxford=True) == "'bob' and 'alice'"
-	assert words.word_join(("bob", "alice", "fred"), use_repr=True, oxford=True) == "'bob', 'alice', and 'fred'"
+@pytest.mark.parametrize(
+		"args, kwargs, expects",
+		[
+				(([], ), {}, ''),
+				(((), ), {}, ''),
+				((["bob"], ), {}, "bob"),
+				((["bob", "alice"], ), {}, "bob and alice"),
+				((["bob", "alice", "fred"], ), {}, "bob, alice and fred"),
+				((("bob", ), ), {}, "bob"),
+				((("bob", "alice"), ), {}, "bob and alice"),
+				((("bob", "alice", "fred"), ), {}, "bob, alice and fred"),
+				((("bob", ), ), {"delimiter": ';'}, "bob"),
+				((("bob", "alice"), ), {"delimiter": ';'}, "bob and alice"),
+				((("bob", "alice", "fred"), ), {"delimiter": ';'}, "bob; alice and fred"),
+				((["bob"], ), {"use_repr": True}, "'bob'"),
+				((["bob", "alice"], ), {"use_repr": True}, "'bob' and 'alice'"),
+				((["bob", "alice", "fred"], ), {"use_repr": True}, "'bob', 'alice' and 'fred'"),
+				((("bob", ), ), {"use_repr": True}, "'bob'"),
+				((("bob", "alice"), ), {"use_repr": True}, "'bob' and 'alice'"),
+				((("bob", "alice", "fred"), ), {"use_repr": True}, "'bob', 'alice' and 'fred'"),
+				((["bob"], ), {"use_repr": True, "oxford": True}, "'bob'"),
+				((["bob", "alice"], ), {"use_repr": True, "oxford": True}, "'bob' and 'alice'"),
+				((["bob", "alice", "fred"], ), {"use_repr": True, "oxford": True}, "'bob', 'alice', and 'fred'"),
+				((["bob", "alice", "fred"], ), {"use_repr": True, "oxford": True, "delimiter": ';'},
+					"'bob'; 'alice'; and 'fred'"),
+				((["bob", "alice", "fred"], ), {"use_repr": True, "oxford": True, "connective": 'or'},
+					"'bob', 'alice', or 'fred'"),
+				((("bob", ), ), {"use_repr": True, "oxford": True}, "'bob'"),
+				((("bob", "alice"), ), {"use_repr": True, "oxford": True}, "'bob' and 'alice'"),
+				((("bob", "alice", "fred"), ), {"use_repr": True, "oxford": True}, "'bob', 'alice', and 'fred'"),
+				]
+		)
+def test_word_join(args, kwargs, expects):
+	assert words.word_join(*args, **kwargs) == expects