Summary

Add the beginnings of a Diff Tool layer.

Review Request #12599 — Created Sept. 14, 2022 and submitted Sept. 28, 2022, 12:50 a.m.

Information

Owner

chipx86

Repository

RBTools

Branch

release-4.x

Bugs

Depends On

Blocks

12600

Reviewers

Groups

rbtools

People

Description

To prepare for that, and to provide an opportunity for cleaning up any
code dealing with raw diffs, this change introduces a new
rbtools.diffs.tools module. This provides abstractions around invoking
diff tools and creating a normalized representation of results.

These will eventually be used in place of any execute() or
run_process() call around diff.

To start, this change adds the abstract base class, BaseDiffTool, and
a results class, DiffFileResult.

BaseDiffTool subclasses must set a couple of attributes:

diff_tool_id: A unique string for registration and identification.
name: A human-readable name for the diff tool (used for
errors/logging).

And implement some methods:

check_available(): Checks for presence/compatibility of the wrapped
diff tool.
run_diff_file(): Runs the diff tool for two files, converting the
provided flags to command line arguments, and returning a normalized
diff result.
get_install_instructions(): Optional, but is used for error messages
if no diff tool can be found.

Results of a run_diff_file() are represented by a DiffFileResult
object. This wraps a result byte stream that can be used by the caller,
along with some utility methods for getting the original/modified
headers or hunk data in different forms. This also contains state on
whether it diffed a binary file or a text file and whether there were
changes.

Currently, nothing uses this, and GNU Diff support isn't available.
Upcoming changes will flesh this out, providing a diff tool registry,
GNU diff support, SCMClient integration, and finally, Apple Diff
support.

Testing Done

Unit tests pass.

Tested these with some upcoming changes and verified this functionality
works.

Built the docs and checked for obvious errors.

Commits

Summary	ID
Add the beginnings of a Diff Tool layer. We've used GNU Diff as a standard dependency for many of our SCMs for many years now, as it's been readily available (either built-in or easy to install) on all target systems for ages. However, that is changing with the upcoming macOS Ventura release, which will replace GNU Diff with Apple Diff, a fork of some unknown version of BSD Diff. To prepare for that, and to provide an opportunity for cleaning up any code dealing with raw diffs, this change introduces a new `rbtools.diffs.tools` module. This provides abstractions around invoking diff tools and creating a normalized representation of results. These will eventually be used in place of any `execute()` or `run_process()` call around `diff`. To start, this change adds the abstract base class, `BaseDiffTool`, and a results class, `DiffFileResult`. `BaseDiffTool` subclasses must set a couple of attributes: * `diff_tool_id`: A unique string for registration and identification. * `name`: A human-readable name for the diff tool (used for errors/logging). And implement some methods: * `check_available()`: Checks for presence/compatibility of the wrapped diff tool. * `run_diff_file()`: Runs the diff tool for two files, converting the provided flags to command line arguments, and returning a normalized diff result. * `get_install_instructions()`: Optional, but is used for error messages if no diff tool can be found. Results of a `run_diff_file()` are represented by a `DiffFileResult` object. This wraps a result byte stream that can be used by the caller, along with some utility methods for getting the original/modified headers or hunk data in different forms. This also contains state on whether it diffed a binary file or a text file and whether there were changes. Currently, nothing uses this, and GNU Diff support isn't available. Upcoming changes will flesh this out, providing a diff tool registry, GNU diff support, SCMClient integration, and finally, Apple Diff support.	e3fde7d9fecf3d739a5275901d5d37d2bcd4c761

Summary

Add the beginnings of a Diff Tool layer.

We've used GNU Diff as a standard dependency for many of our SCMs for many years now, as it's been readily available (either built-in or easy to install) on all target systems for ages. However, that is changing with the upcoming macOS Ventura release, which will replace GNU Diff with Apple Diff, a fork of some unknown version of BSD Diff. To prepare for that, and to provide an opportunity for cleaning up any code dealing with raw diffs, this change introduces a new `rbtools.diffs.tools` module. This provides abstractions around invoking diff tools and creating a normalized representation of results. These will eventually be used in place of any `execute()` or `run_process()` call around `diff`. To start, this change adds the abstract base class, `BaseDiffTool`, and a results class, `DiffFileResult`. `BaseDiffTool` subclasses must set a couple of attributes: * `diff_tool_id`: A unique string for registration and identification. * `name`: A human-readable name for the diff tool (used for errors/logging). And implement some methods: * `check_available()`: Checks for presence/compatibility of the wrapped diff tool. * `run_diff_file()`: Runs the diff tool for two files, converting the provided flags to command line arguments, and returning a normalized diff result. * `get_install_instructions()`: Optional, but is used for error messages if no diff tool can be found. Results of a `run_diff_file()` are represented by a `DiffFileResult` object. This wraps a result byte stream that can be used by the caller, along with some utility methods for getting the original/modified headers or hunk data in different forms. This also contains state on whether it diffed a binary file or a text file and whether there were changes. Currently, nothing uses this, and GNU Diff support isn't available. Upcoming changes will flesh this out, providing a diff tool registry, GNU diff support, SCMClient integration, and finally, Apple Diff support.

e3fde7d9fecf3d739a5275901d5d37d2bcd4c761

Issues

Description	From	Last Updated
Add a Version Added: here.	maubin	Sept. 21, 2022, 7:02 p.m.
Add a Version Added: here.	maubin	Sept. 20, 2022, 11:35 a.m.
There's a 0 here that can be taken out.	maubin	Sept. 21, 2022, 7:02 p.m.
Missing a period at the end of this sentence. Maybe it could also use some info on what the default …	maubin	Sept. 22, 2022, 12:36 p.m.
Typo: speek -> speed	maubin	Sept. 21, 2022, 7:02 p.m.

flake8 passed.

JSHint passed.

Ship it!

```
Ship It!
```

rbtools/diffs/tests/test_diff_file_result.py (Diff revision 1)
The issue has been resolved. Show all issues
```
Add a Version Added: here.
```
rbtools/diffs/tests/test_diff_file_result.py (Diff revision 1)
The issue has been dropped. Show all issues
```
Add a Version Added: here.
```
rbtools/diffs/tools/base/diff_file_result.py (Diff revision 1)
The issue has been resolved. Show all issues
```
There's a 0 here that can be taken out.
```
rbtools/diffs/tools/base/diff_file_result.py (Diff revision 1)
The issue has been resolved. Show all issues
```
Typo: speek -> speed
```

Change Summary:


Renamed {orig,modified}_line_header properties to {orig,modified}_file_header in DiffFileResult.
Added parsed_{orig,modified}_file_header functions, for extracting the marker, filename, and extra info from header lines.
Added orig_path and modified_path attributes to DiffFileResult, which are the ones passed to the diff tool.
Added some missing Version Added.
Updated {orig,modified}_line_header and hunks to avoid work if has_text_differences=False.
Updated {orig,modified}_line_header to avoid returning non-headers, if encountered.
Fixed some docstring typos.

Commits:

	Summary	ID
	Add the beginnings of a Diff Tool layer. We've used GNU Diff as a standard dependency for many of our SCMs for many years now, as it's been readily available (either built-in or easy to install) on all target systems for ages. However, that is changing with the upcoming macOS Ventura release, which will replace GNU Diff with Apple Diff, a fork of some unknown version of BSD Diff. To prepare for that, and to provide an opportunity for cleaning up any code dealing with raw diffs, this change introduces a new `rbtools.diffs.tools` module. This provides abstractions around invoking diff tools and creating a normalized representation of results. These will eventually be used in place of any `execute()` or `run_process()` call around `diff`. To start, this change adds the abstract base class, `BaseDiffTool`, and a results class, `DiffFileResult`. `BaseDiffTool` subclasses must set a couple of attributes: * `diff_tool_id`: A unique string for registration and identification. * `name`: A human-readable name for the diff tool (used for errors/logging). And implement some methods: * `check_available()`: Checks for presence/compatibility of the wrapped diff tool. * `run_diff_file()`: Runs the diff tool for two files, converting the provided flags to command line arguments, and returning a normalized diff result. * `get_install_instructions()`: Optional, but is used for error messages if no diff tool can be found. Results of a `run_diff_file()` are represented by a `DiffFileResult` object. This wraps a result byte stream that can be used by the caller, along with some utility methods for getting the original/modified headers or hunk data in different forms. This also contains state on whether it diffed a binary file or a text file and whether there were changes. Currently, nothing uses this, and GNU Diff support isn't available. Upcoming changes will flesh this out, providing a diff tool registry, GNU diff support, SCMClient integration, and finally, Apple Diff support.	ce79281706321b36ca499e1332a769e191e20574
	Add the beginnings of a Diff Tool layer. We've used GNU Diff as a standard dependency for many of our SCMs for many years now, as it's been readily available (either built-in or easy to install) on all target systems for ages. However, that is changing with the upcoming macOS Ventura release, which will replace GNU Diff with Apple Diff, a fork of some unknown version of BSD Diff. To prepare for that, and to provide an opportunity for cleaning up any code dealing with raw diffs, this change introduces a new `rbtools.diffs.tools` module. This provides abstractions around invoking diff tools and creating a normalized representation of results. These will eventually be used in place of any `execute()` or `run_process()` call around `diff`. To start, this change adds the abstract base class, `BaseDiffTool`, and a results class, `DiffFileResult`. `BaseDiffTool` subclasses must set a couple of attributes: * `diff_tool_id`: A unique string for registration and identification. * `name`: A human-readable name for the diff tool (used for errors/logging). And implement some methods: * `check_available()`: Checks for presence/compatibility of the wrapped diff tool. * `run_diff_file()`: Runs the diff tool for two files, converting the provided flags to command line arguments, and returning a normalized diff result. * `get_install_instructions()`: Optional, but is used for error messages if no diff tool can be found. Results of a `run_diff_file()` are represented by a `DiffFileResult` object. This wraps a result byte stream that can be used by the caller, along with some utility methods for getting the original/modified headers or hunk data in different forms. This also contains state on whether it diffed a binary file or a text file and whether there were changes. Currently, nothing uses this, and GNU Diff support isn't available. Upcoming changes will flesh this out, providing a diff tool registry, GNU diff support, SCMClient integration, and finally, Apple Diff support.	1179e97afe7345929ce59b97adecb084a1b100a0

Diff:

Revision 2 (+3180)

Show changes

	docs/rbtools/api/coderef/index.rst
	rbtools/diffs/__init__.py
	rbtools/diffs/tests/__init__.py
	rbtools/diffs/tests/test_diff_file_result.py
	rbtools/diffs/tools/__init__.py
	rbtools/diffs/tools/base/__init__.py
	rbtools/diffs/tools/base/diff_file_result.py
	rbtools/diffs/tools/base/diff_tool.py

Checks run (2 succeeded)

flake8 passed.

JSHint passed.

Change Summary:

Actually added the missing Version Added this time.

Commits:

	Summary	ID
	Add the beginnings of a Diff Tool layer. We've used GNU Diff as a standard dependency for many of our SCMs for many years now, as it's been readily available (either built-in or easy to install) on all target systems for ages. However, that is changing with the upcoming macOS Ventura release, which will replace GNU Diff with Apple Diff, a fork of some unknown version of BSD Diff. To prepare for that, and to provide an opportunity for cleaning up any code dealing with raw diffs, this change introduces a new `rbtools.diffs.tools` module. This provides abstractions around invoking diff tools and creating a normalized representation of results. These will eventually be used in place of any `execute()` or `run_process()` call around `diff`. To start, this change adds the abstract base class, `BaseDiffTool`, and a results class, `DiffFileResult`. `BaseDiffTool` subclasses must set a couple of attributes: * `diff_tool_id`: A unique string for registration and identification. * `name`: A human-readable name for the diff tool (used for errors/logging). And implement some methods: * `check_available()`: Checks for presence/compatibility of the wrapped diff tool. * `run_diff_file()`: Runs the diff tool for two files, converting the provided flags to command line arguments, and returning a normalized diff result. * `get_install_instructions()`: Optional, but is used for error messages if no diff tool can be found. Results of a `run_diff_file()` are represented by a `DiffFileResult` object. This wraps a result byte stream that can be used by the caller, along with some utility methods for getting the original/modified headers or hunk data in different forms. This also contains state on whether it diffed a binary file or a text file and whether there were changes. Currently, nothing uses this, and GNU Diff support isn't available. Upcoming changes will flesh this out, providing a diff tool registry, GNU diff support, SCMClient integration, and finally, Apple Diff support.	1179e97afe7345929ce59b97adecb084a1b100a0
	Add the beginnings of a Diff Tool layer. We've used GNU Diff as a standard dependency for many of our SCMs for many years now, as it's been readily available (either built-in or easy to install) on all target systems for ages. However, that is changing with the upcoming macOS Ventura release, which will replace GNU Diff with Apple Diff, a fork of some unknown version of BSD Diff. To prepare for that, and to provide an opportunity for cleaning up any code dealing with raw diffs, this change introduces a new `rbtools.diffs.tools` module. This provides abstractions around invoking diff tools and creating a normalized representation of results. These will eventually be used in place of any `execute()` or `run_process()` call around `diff`. To start, this change adds the abstract base class, `BaseDiffTool`, and a results class, `DiffFileResult`. `BaseDiffTool` subclasses must set a couple of attributes: * `diff_tool_id`: A unique string for registration and identification. * `name`: A human-readable name for the diff tool (used for errors/logging). And implement some methods: * `check_available()`: Checks for presence/compatibility of the wrapped diff tool. * `run_diff_file()`: Runs the diff tool for two files, converting the provided flags to command line arguments, and returning a normalized diff result. * `get_install_instructions()`: Optional, but is used for error messages if no diff tool can be found. Results of a `run_diff_file()` are represented by a `DiffFileResult` object. This wraps a result byte stream that can be used by the caller, along with some utility methods for getting the original/modified headers or hunk data in different forms. This also contains state on whether it diffed a binary file or a text file and whether there were changes. Currently, nothing uses this, and GNU Diff support isn't available. Upcoming changes will flesh this out, providing a diff tool registry, GNU diff support, SCMClient integration, and finally, Apple Diff support.	e6db317f4132a612f04596ce0d92cd27a890e1dc

Diff:

Revision 3 (+3188)

Show changes

	docs/rbtools/api/coderef/index.rst
	rbtools/diffs/__init__.py
	rbtools/diffs/tests/__init__.py
	rbtools/diffs/tests/test_diff_file_result.py
	rbtools/diffs/tools/__init__.py
	rbtools/diffs/tools/base/__init__.py
	rbtools/diffs/tools/base/diff_file_result.py
	rbtools/diffs/tools/base/diff_tool.py

Checks run (2 succeeded)

flake8 passed.

JSHint passed.

Change Summary:

Updated DiffFileResult.iter_hunk_lines() to perform \r\r\n newline normalization and enable stripping of newlines by default.

Commits:

	Summary	ID
	Add the beginnings of a Diff Tool layer. We've used GNU Diff as a standard dependency for many of our SCMs for many years now, as it's been readily available (either built-in or easy to install) on all target systems for ages. However, that is changing with the upcoming macOS Ventura release, which will replace GNU Diff with Apple Diff, a fork of some unknown version of BSD Diff. To prepare for that, and to provide an opportunity for cleaning up any code dealing with raw diffs, this change introduces a new `rbtools.diffs.tools` module. This provides abstractions around invoking diff tools and creating a normalized representation of results. These will eventually be used in place of any `execute()` or `run_process()` call around `diff`. To start, this change adds the abstract base class, `BaseDiffTool`, and a results class, `DiffFileResult`. `BaseDiffTool` subclasses must set a couple of attributes: * `diff_tool_id`: A unique string for registration and identification. * `name`: A human-readable name for the diff tool (used for errors/logging). And implement some methods: * `check_available()`: Checks for presence/compatibility of the wrapped diff tool. * `run_diff_file()`: Runs the diff tool for two files, converting the provided flags to command line arguments, and returning a normalized diff result. * `get_install_instructions()`: Optional, but is used for error messages if no diff tool can be found. Results of a `run_diff_file()` are represented by a `DiffFileResult` object. This wraps a result byte stream that can be used by the caller, along with some utility methods for getting the original/modified headers or hunk data in different forms. This also contains state on whether it diffed a binary file or a text file and whether there were changes. Currently, nothing uses this, and GNU Diff support isn't available. Upcoming changes will flesh this out, providing a diff tool registry, GNU diff support, SCMClient integration, and finally, Apple Diff support.	e6db317f4132a612f04596ce0d92cd27a890e1dc
	Add the beginnings of a Diff Tool layer. We've used GNU Diff as a standard dependency for many of our SCMs for many years now, as it's been readily available (either built-in or easy to install) on all target systems for ages. However, that is changing with the upcoming macOS Ventura release, which will replace GNU Diff with Apple Diff, a fork of some unknown version of BSD Diff. To prepare for that, and to provide an opportunity for cleaning up any code dealing with raw diffs, this change introduces a new `rbtools.diffs.tools` module. This provides abstractions around invoking diff tools and creating a normalized representation of results. These will eventually be used in place of any `execute()` or `run_process()` call around `diff`. To start, this change adds the abstract base class, `BaseDiffTool`, and a results class, `DiffFileResult`. `BaseDiffTool` subclasses must set a couple of attributes: * `diff_tool_id`: A unique string for registration and identification. * `name`: A human-readable name for the diff tool (used for errors/logging). And implement some methods: * `check_available()`: Checks for presence/compatibility of the wrapped diff tool. * `run_diff_file()`: Runs the diff tool for two files, converting the provided flags to command line arguments, and returning a normalized diff result. * `get_install_instructions()`: Optional, but is used for error messages if no diff tool can be found. Results of a `run_diff_file()` are represented by a `DiffFileResult` object. This wraps a result byte stream that can be used by the caller, along with some utility methods for getting the original/modified headers or hunk data in different forms. This also contains state on whether it diffed a binary file or a text file and whether there were changes. Currently, nothing uses this, and GNU Diff support isn't available. Upcoming changes will flesh this out, providing a diff tool registry, GNU diff support, SCMClient integration, and finally, Apple Diff support.	bd72d4184b02d63cb0a5478358173a3a4cfbe14b

Diff:

Revision 4 (+3236)

Show changes

	docs/rbtools/api/coderef/index.rst
	rbtools/diffs/__init__.py
	rbtools/diffs/tests/__init__.py
	rbtools/diffs/tests/test_diff_file_result.py
	rbtools/diffs/tools/__init__.py
	rbtools/diffs/tools/base/__init__.py
	rbtools/diffs/tools/base/diff_file_result.py
	rbtools/diffs/tools/base/diff_tool.py

Checks run (2 succeeded)

flake8 passed.

JSHint passed.

rbtools/diffs/tools/base/diff_file_result.py (Diff revisions 1 - 4)

The issue has been resolved. Show all issues

Missing a period at the end of this sentence. Maybe it could also use some info on what the default regex pattern is.

Change Summary:

Updated the file_header_re documentation to be more explicit about requirements and usage, and to fix a missing period.

Commits:

	Summary	ID
	Add the beginnings of a Diff Tool layer. We've used GNU Diff as a standard dependency for many of our SCMs for many years now, as it's been readily available (either built-in or easy to install) on all target systems for ages. However, that is changing with the upcoming macOS Ventura release, which will replace GNU Diff with Apple Diff, a fork of some unknown version of BSD Diff. To prepare for that, and to provide an opportunity for cleaning up any code dealing with raw diffs, this change introduces a new `rbtools.diffs.tools` module. This provides abstractions around invoking diff tools and creating a normalized representation of results. These will eventually be used in place of any `execute()` or `run_process()` call around `diff`. To start, this change adds the abstract base class, `BaseDiffTool`, and a results class, `DiffFileResult`. `BaseDiffTool` subclasses must set a couple of attributes: * `diff_tool_id`: A unique string for registration and identification. * `name`: A human-readable name for the diff tool (used for errors/logging). And implement some methods: * `check_available()`: Checks for presence/compatibility of the wrapped diff tool. * `run_diff_file()`: Runs the diff tool for two files, converting the provided flags to command line arguments, and returning a normalized diff result. * `get_install_instructions()`: Optional, but is used for error messages if no diff tool can be found. Results of a `run_diff_file()` are represented by a `DiffFileResult` object. This wraps a result byte stream that can be used by the caller, along with some utility methods for getting the original/modified headers or hunk data in different forms. This also contains state on whether it diffed a binary file or a text file and whether there were changes. Currently, nothing uses this, and GNU Diff support isn't available. Upcoming changes will flesh this out, providing a diff tool registry, GNU diff support, SCMClient integration, and finally, Apple Diff support.	bd72d4184b02d63cb0a5478358173a3a4cfbe14b
	Add the beginnings of a Diff Tool layer. We've used GNU Diff as a standard dependency for many of our SCMs for many years now, as it's been readily available (either built-in or easy to install) on all target systems for ages. However, that is changing with the upcoming macOS Ventura release, which will replace GNU Diff with Apple Diff, a fork of some unknown version of BSD Diff. To prepare for that, and to provide an opportunity for cleaning up any code dealing with raw diffs, this change introduces a new `rbtools.diffs.tools` module. This provides abstractions around invoking diff tools and creating a normalized representation of results. These will eventually be used in place of any `execute()` or `run_process()` call around `diff`. To start, this change adds the abstract base class, `BaseDiffTool`, and a results class, `DiffFileResult`. `BaseDiffTool` subclasses must set a couple of attributes: * `diff_tool_id`: A unique string for registration and identification. * `name`: A human-readable name for the diff tool (used for errors/logging). And implement some methods: * `check_available()`: Checks for presence/compatibility of the wrapped diff tool. * `run_diff_file()`: Runs the diff tool for two files, converting the provided flags to command line arguments, and returning a normalized diff result. * `get_install_instructions()`: Optional, but is used for error messages if no diff tool can be found. Results of a `run_diff_file()` are represented by a `DiffFileResult` object. This wraps a result byte stream that can be used by the caller, along with some utility methods for getting the original/modified headers or hunk data in different forms. This also contains state on whether it diffed a binary file or a text file and whether there were changes. Currently, nothing uses this, and GNU Diff support isn't available. Upcoming changes will flesh this out, providing a diff tool registry, GNU diff support, SCMClient integration, and finally, Apple Diff support.	461cfe6a53cbf84332977f4440f4e2b61ee05fc5

Diff:

Revision 5 (+3242)

Show changes

	docs/rbtools/api/coderef/index.rst
	rbtools/diffs/__init__.py
	rbtools/diffs/tests/__init__.py
	rbtools/diffs/tests/test_diff_file_result.py
	rbtools/diffs/tools/__init__.py
	rbtools/diffs/tools/base/__init__.py
	rbtools/diffs/tools/base/diff_file_result.py
	rbtools/diffs/tools/base/diff_tool.py

Checks run (2 succeeded)

flake8 passed.

JSHint passed.

Ship it!

```
Ship It!
```

Change Summary:

Added missing unit tests for the iter_hunk_lines() changes (keep_newlines= and newline normalization).

Commits:

	Summary	ID
	Add the beginnings of a Diff Tool layer. We've used GNU Diff as a standard dependency for many of our SCMs for many years now, as it's been readily available (either built-in or easy to install) on all target systems for ages. However, that is changing with the upcoming macOS Ventura release, which will replace GNU Diff with Apple Diff, a fork of some unknown version of BSD Diff. To prepare for that, and to provide an opportunity for cleaning up any code dealing with raw diffs, this change introduces a new `rbtools.diffs.tools` module. This provides abstractions around invoking diff tools and creating a normalized representation of results. These will eventually be used in place of any `execute()` or `run_process()` call around `diff`. To start, this change adds the abstract base class, `BaseDiffTool`, and a results class, `DiffFileResult`. `BaseDiffTool` subclasses must set a couple of attributes: * `diff_tool_id`: A unique string for registration and identification. * `name`: A human-readable name for the diff tool (used for errors/logging). And implement some methods: * `check_available()`: Checks for presence/compatibility of the wrapped diff tool. * `run_diff_file()`: Runs the diff tool for two files, converting the provided flags to command line arguments, and returning a normalized diff result. * `get_install_instructions()`: Optional, but is used for error messages if no diff tool can be found. Results of a `run_diff_file()` are represented by a `DiffFileResult` object. This wraps a result byte stream that can be used by the caller, along with some utility methods for getting the original/modified headers or hunk data in different forms. This also contains state on whether it diffed a binary file or a text file and whether there were changes. Currently, nothing uses this, and GNU Diff support isn't available. Upcoming changes will flesh this out, providing a diff tool registry, GNU diff support, SCMClient integration, and finally, Apple Diff support.	461cfe6a53cbf84332977f4440f4e2b61ee05fc5
	Add the beginnings of a Diff Tool layer. We've used GNU Diff as a standard dependency for many of our SCMs for many years now, as it's been readily available (either built-in or easy to install) on all target systems for ages. However, that is changing with the upcoming macOS Ventura release, which will replace GNU Diff with Apple Diff, a fork of some unknown version of BSD Diff. To prepare for that, and to provide an opportunity for cleaning up any code dealing with raw diffs, this change introduces a new `rbtools.diffs.tools` module. This provides abstractions around invoking diff tools and creating a normalized representation of results. These will eventually be used in place of any `execute()` or `run_process()` call around `diff`. To start, this change adds the abstract base class, `BaseDiffTool`, and a results class, `DiffFileResult`. `BaseDiffTool` subclasses must set a couple of attributes: * `diff_tool_id`: A unique string for registration and identification. * `name`: A human-readable name for the diff tool (used for errors/logging). And implement some methods: * `check_available()`: Checks for presence/compatibility of the wrapped diff tool. * `run_diff_file()`: Runs the diff tool for two files, converting the provided flags to command line arguments, and returning a normalized diff result. * `get_install_instructions()`: Optional, but is used for error messages if no diff tool can be found. Results of a `run_diff_file()` are represented by a `DiffFileResult` object. This wraps a result byte stream that can be used by the caller, along with some utility methods for getting the original/modified headers or hunk data in different forms. This also contains state on whether it diffed a binary file or a text file and whether there were changes. Currently, nothing uses this, and GNU Diff support isn't available. Upcoming changes will flesh this out, providing a diff tool registry, GNU diff support, SCMClient integration, and finally, Apple Diff support.	e3fde7d9fecf3d739a5275901d5d37d2bcd4c761

Diff:

Revision 6 (+3518)

Show changes

	docs/rbtools/api/coderef/index.rst
	rbtools/diffs/__init__.py
	rbtools/diffs/tests/__init__.py
	rbtools/diffs/tests/test_diff_file_result.py
	rbtools/diffs/tools/__init__.py
	rbtools/diffs/tools/base/__init__.py
	rbtools/diffs/tools/base/diff_file_result.py
	rbtools/diffs/tools/base/diff_tool.py

Checks run (2 succeeded)

flake8 passed.

JSHint passed.

Ship it!

```
Ship It!
```

Status:: Completed
Change Summary:: Pushed to release-4.x (c3a724d)