def test_output_diff(capsys): """output_diff() prints Black-style diff output""" darker.__main__.print_diff( Path('a.py'), TextDocument.from_lines( ["unchanged", "removed", "kept 1", "2", "3", "4", "5", "6", "7", "changed"] ), TextDocument.from_lines( ["inserted", "unchanged", "kept 1", "2", "3", "4", "5", "6", "7", "Changed"] ), ) assert capsys.readouterr().out.splitlines() == [ '--- a.py', '+++ a.py', '@@ -1,5 +1,5 @@', '+inserted', ' unchanged', '-removed', ' kept 1', ' 2', ' 3', '@@ -7,4 +7,4 @@', ' 5', ' 6', ' 7', '-changed', '+Changed', ]
def test_verify_ast_unchanged(src_content, dst_content, expect): black_chunks: List[DiffChunk] = [(1, ("black", ), ("chunks", ))] edited_linenums = [1, 2] try: verify_ast_unchanged( TextDocument.from_lines([src_content]), TextDocument.from_lines(dst_content), black_chunks, edited_linenums, ) except NotEquivalentError: assert expect is AssertionError else: assert expect is None
def test_main_retval(check, changes, expect_retval): """main() return value is correct based on --check and the need to reformat files""" format_edited_parts = Mock() format_edited_parts.return_value = ([( Path("/dummy.py"), TextDocument.from_lines(["old"]), TextDocument.from_lines(["new"]), )] if changes else []) check_arg_maybe = ['--check'] if check else [] with patch.multiple('darker.__main__', format_edited_parts=format_edited_parts, modify_file=DEFAULT): retval = main(check_arg_maybe + ['a.py']) assert retval == expect_retval
def git_get_content_at_revision(path: Path, revision: str, cwd: Path) -> TextDocument: """Get unmodified text lines of a file at a Git revision :param path: The relative path of the file in the Git repository :param revision: The Git revision for which to get the file content, or ``WORKTREE`` to get what's on disk right now. :param cwd: The root of the Git repository """ if revision == WORKTREE: abspath = cwd / path mtime = datetime.utcfromtimestamp(abspath.stat().st_mtime) return TextDocument.from_str(abspath.read_text("utf-8"), f"{mtime} +0000") cmd = ["show", f"{revision}:./{path}"] logger.debug("[%s]$ %s", cwd, " ".join(cmd)) try: return TextDocument.from_lines( _git_check_output_lines(cmd, cwd, exit_on_error=False) ) except CalledProcessError as exc_info: if exc_info.returncode != 128: raise # The file didn't exist at the given revision. Act as if it was an empty # file, so all current lines appear as edited. return TextDocument()
def format_file( src: Path, from_line: int, to_line: int, config: str = None, ): black_args = BlackConfig(config=config) edited = worktree_content = TextDocument.from_file(src) max_context_lines = len(edited.lines) minimum_context_lines = BinarySearch(0, max_context_lines + 1) edited_linenums = list(range(from_line, to_line + 1)) while not minimum_context_lines.found: formatted = run_black(edited, black_args) opcodes = diff_and_get_opcodes(edited, formatted) black_chunks = list(opcodes_to_chunks(opcodes, edited, formatted)) chosen = TextDocument.from_lines( choose_lines(black_chunks, edited_linenums), encoding=worktree_content.encoding, newline=worktree_content.newline, ) try: verify_ast_unchanged(edited, chosen, black_chunks, edited_linenums) except NotEquivalentError: minimum_context_lines.respond(False) else: minimum_context_lines.respond(True) modify_file(src, chosen)
def test_edited_linenums_differ_revision_vs_lines(git_repo, context_lines, expect): """Tests for EditedLinenumsDiffer.revision_vs_lines()""" git_repo.add({'a.py': '1\n2\n3\n4\n5\n6\n7\n8\n'}, commit='Initial commit') content = TextDocument.from_lines( ["1", "2", "three", "4", "5", "6", "seven", "8"]) differ = EditedLinenumsDiffer(git_repo.root, RevisionRange("HEAD")) result = differ.revision_vs_lines(Path("a.py"), content, context_lines) assert result == expect
def test_apply_isort(encoding, newline): """Import sorting is applied correctly, with encoding and newline intact""" result = apply_isort( TextDocument.from_lines(ORIGINAL_SOURCE, encoding=encoding, newline=newline), Path("test1.py"), ) assert result.lines == ISORTED_SOURCE assert result.encoding == encoding assert result.newline == newline
def test_run_black(tmpdir, encoding, newline): """Running Black through its Python internal API gives correct results""" src = TextDocument.from_lines( [f"# coding: {encoding}", "print ( 'touché' )"], encoding=encoding, newline=newline, ) result = run_black(Path(tmpdir / "src.py"), src, BlackArgs()) assert result.lines == ( f"# coding: {encoding}", 'print("touché")', ) assert result.encoding == encoding assert result.newline == newline
dummy.write_text("dummy") result = list(get_path_ancestry(dummy)) assert result[-1] == tmpdir assert result[-2] == tmpdir.parent @pytest.mark.parametrize( "textdocument, expect", [ (TextDocument(), "utf-8"), (TextDocument(encoding="utf-8"), "utf-8"), (TextDocument(encoding="utf-16"), "utf-16"), (TextDocument.from_str(""), "utf-8"), (TextDocument.from_str("", encoding="utf-8"), "utf-8"), (TextDocument.from_str("", encoding="utf-16"), "utf-16"), (TextDocument.from_lines([]), "utf-8"), (TextDocument.from_lines([], encoding="utf-8"), "utf-8"), (TextDocument.from_lines([], encoding="utf-16"), "utf-16"), ], ) def test_textdocument_set_encoding(textdocument, expect): """TextDocument.encoding is correct from each constructor""" assert textdocument.encoding == expect @pytest.mark.parametrize( "textdocument, expect", [ (TextDocument(), ""), (TextDocument(lines=["zéro", "un"]), "zéro\nun\n"), (TextDocument(lines=["zéro", "un"], newline="\n"), "zéro\nun\n"),
def test_apply_isort(): result = apply_isort(TextDocument.from_lines(ORIGINAL_SOURCE), Path("test1.py")) assert result.lines == ISORTED_SOURCE
def format_edited_parts( git_root: Path, changed_files: Iterable[Path], revrange: RevisionRange, enable_isort: bool, black_args: BlackArgs, ) -> Generator[Tuple[Path, TextDocument, TextDocument], None, None]: """Black (and optional isort) formatting for chunks with edits since the last commit :param git_root: The root of the Git repository the files are in :param changed_files: Files which have been modified in the repository between the given Git revisions :param revrange: The Git revisions to compare :param enable_isort: ``True`` to also run ``isort`` first on each changed file :param black_args: Command-line arguments to send to ``black.FileMode`` :return: A generator which yields details about changes for each file which should be reformatted, and skips unchanged files. """ edited_linenums_differ = EditedLinenumsDiffer(git_root, revrange) for path_in_repo in sorted(changed_files): src = git_root / path_in_repo worktree_content = TextDocument.from_file(src) # 1. run isort if enable_isort: edited = apply_isort( worktree_content, src, black_args.get("config"), black_args.get("line_length"), ) else: edited = worktree_content max_context_lines = len(edited.lines) minimum_context_lines = BinarySearch(0, max_context_lines + 1) last_successful_reformat = None while not minimum_context_lines.found: context_lines = minimum_context_lines.get_next() if context_lines > 0: logger.debug( "Trying with %s lines of context for `git diff -U %s`", context_lines, src, ) # 2. diff the given revision and worktree for the file # 3. extract line numbers in the edited to-file for changed lines edited_linenums = edited_linenums_differ.revision_vs_lines( path_in_repo, edited, context_lines) if enable_isort and not edited_linenums and edited == worktree_content: logger.debug("No changes in %s after isort", src) break # 4. run black formatted = run_black(src, edited, black_args) logger.debug("Read %s lines from edited file %s", len(edited.lines), src) logger.debug("Black reformat resulted in %s lines", len(formatted.lines)) # 5. get the diff between the edited and reformatted file opcodes = diff_and_get_opcodes(edited, formatted) # 6. convert the diff into chunks black_chunks = list(opcodes_to_chunks(opcodes, edited, formatted)) # 7. choose reformatted content chosen = TextDocument.from_lines( choose_lines(black_chunks, edited_linenums), encoding=worktree_content.encoding, newline=worktree_content.newline, ) # 8. verify logger.debug( "Verifying that the %s original edited lines and %s reformatted lines " "parse into an identical abstract syntax tree", len(edited.lines), len(chosen.lines), ) try: verify_ast_unchanged(edited, chosen, black_chunks, edited_linenums) except NotEquivalentError: # Diff produced misaligned chunks which couldn't be reconstructed into # a partially re-formatted Python file which produces an identical AST. # Try again with a larger `-U<context_lines>` option for `git diff`, # or give up if `context_lines` is already very large. logger.debug( "AST verification of %s with %s lines of context failed", src, context_lines, ) minimum_context_lines.respond(False) else: minimum_context_lines.respond(True) last_successful_reformat = (src, worktree_content, chosen) if not last_successful_reformat: raise NotEquivalentError(path_in_repo) # 9. A re-formatted Python file which produces an identical AST was # created successfully - write an updated file or print the diff if # there were any changes to the original src, worktree_content, chosen = last_successful_reformat if chosen != worktree_content: # `result_str` is just `chosen_lines` concatenated with newlines. # We need both forms when showing diffs or modifying files. # Pass them both on to avoid back-and-forth conversion. yield src, worktree_content, chosen
def format_edited_parts( srcs: Iterable[Path], revrange: RevisionRange, enable_isort: bool, linter_cmdlines: List[str], black_args: BlackArgs, ) -> Generator[Tuple[Path, TextDocument, TextDocument], None, None]: """Black (and optional isort) formatting for chunks with edits since the last commit 1. run isort on each edited file (optional) 2. diff the given revision and worktree (optionally with isort modifications) for all file & dir paths on the command line 3. extract line numbers in each edited to-file for changed lines 4. run black on the contents of each edited to-file 5. get a diff between the edited to-file and the reformatted content 6. convert the diff into chunks, keeping original and reformatted content for each chunk 7. choose reformatted content for each chunk if there were any changed lines inside the chunk in the edited to-file, or choose the chunk's original contents if no edits were done in that chunk 8. verify that the resulting reformatted source code parses to an identical AST as the original edited to-file 9. write the reformatted source back to the original file 10. run linter subprocesses for all edited files (11.-14. optional) 11. diff the given revision and worktree (after isort and Black reformatting) for each file reported by a linter 12. extract line numbers in each file reported by a linter for changed lines 13. print only linter error lines which fall on changed lines :param srcs: Directories and files to re-format :param revrange: The Git revision against which to compare the working tree :param enable_isort: ``True`` to also run ``isort`` first on each changed file :param linter_cmdlines: The command line(s) for running linters on the changed files. :param black_args: Command-line arguments to send to ``black.FileMode`` :return: A generator which yields details about changes for each file which should be reformatted, and skips unchanged files. """ git_root = get_common_root(srcs) changed_files = git_get_modified_files(srcs, revrange, git_root) edited_linenums_differ = EditedLinenumsDiffer(git_root, revrange) for path_in_repo in sorted(changed_files): src = git_root / path_in_repo worktree_content = TextDocument.from_file(src) # 1. run isort if enable_isort: edited = apply_isort( worktree_content, src, black_args.get("config"), black_args.get("line_length"), ) else: edited = worktree_content max_context_lines = len(edited.lines) for context_lines in range(max_context_lines + 1): # 2. diff the given revision and worktree for the file # 3. extract line numbers in the edited to-file for changed lines edited_linenums = edited_linenums_differ.revision_vs_lines( path_in_repo, edited, context_lines ) if enable_isort and not edited_linenums and edited == worktree_content: logger.debug("No changes in %s after isort", src) break # 4. run black formatted = run_black(src, edited, black_args) logger.debug("Read %s lines from edited file %s", len(edited.lines), src) logger.debug("Black reformat resulted in %s lines", len(formatted.lines)) # 5. get the diff between the edited and reformatted file opcodes = diff_and_get_opcodes(edited, formatted) # 6. convert the diff into chunks black_chunks = list(opcodes_to_chunks(opcodes, edited, formatted)) # 7. choose reformatted content chosen = TextDocument.from_lines( choose_lines(black_chunks, edited_linenums), encoding=worktree_content.encoding, newline=worktree_content.newline, ) # 8. verify logger.debug( "Verifying that the %s original edited lines and %s reformatted lines " "parse into an identical abstract syntax tree", len(edited.lines), len(chosen.lines), ) try: verify_ast_unchanged(edited, chosen, black_chunks, edited_linenums) except NotEquivalentError: # Diff produced misaligned chunks which couldn't be reconstructed into # a partially re-formatted Python file which produces an identical AST. # Try again with a larger `-U<context_lines>` option for `git diff`, # or give up if `context_lines` is already very large. if context_lines == max_context_lines: raise logger.debug( "AST verification failed. " "Trying again with %s lines of context for `git diff -U`", context_lines + 1, ) continue else: # 9. A re-formatted Python file which produces an identical AST was # created successfully - write an updated file or print the diff if # there were any changes to the original if chosen != worktree_content: yield src, worktree_content, chosen break # 10. run linter subprocesses for all edited files (11.-14. optional) # 11. diff the given revision and worktree (after isort and Black reformatting) for # each file reported by a linter # 12. extract line numbers in each file reported by a linter for changed lines # 13. print only linter error lines which fall on changed lines for linter_cmdline in linter_cmdlines: run_linter(linter_cmdline, git_root, changed_files, revrange)
def test_run_black(tmpdir): src = TextDocument.from_lines(["print ( '42' )"]) result = run_black(Path(tmpdir / "src.py"), src, BlackArgs()) assert result.lines == ('print("42")', )