Age | Commit message (Collapse) | Author |
|
Add the ability to pass multiple suggestions to the binary. The diffs
will appear in the output one after another.
Also allow suggestions to be specified by their comment ID instead of
their full URL. This uses the Git repo's remote to determine the
owner-repo pair. When a URL argument is given, the owner-repo pair is
extracted from the URL.
It's now possible to call the binary like this:
$ git-sugpatch 459692838 \
> https://github.com/teddywing/suggestion-test/pull/1#discussion_r459691747
|
|
Store the suggestion references specified on the command line.
|
|
Remotes can be HTTP URLs or use SSH/SCP-style paths like:
git@github.com/teddywing/github-suggestion.git
We need to handle both regular URLs and the above style, which isn't
parseable by the 'url' crate.
Add a custom parsing function to get the owner and repo from this
format.
When trying to parse `OwnerRepo` from a string, first try to parse it as
a URL. If that fails with a `RelativeUrlWithoutBase` error, assume it's
the other style of reference.
|
|
|
|
Improve organisation.
|
|
We need the following values in order to build a `Client`:
* GitHub token
* Repo owner
* Repo name
Get the token from a command-line argument, or else the Git config, or
else an environment variable.
Get the repo identifiers from the repo's remote URL. Use the remote
specified as a command-line argument, otherwise get it from the Git
config, or else default to "origin".
TODO: Only try to get the owner-name pair from the remote if a comment
ID was given, not if a URL argument was passed.
|
|
|
|
Since this function returns an `OwnerRepo`, make it a method on the
struct.
|
|
Need to add other code to the library.
|
|
This will be used by the binaries.
|
|
Keep the binaries in the root crate, and add a new crate for the
`github-suggestion` library.
I want to add some library code to the CLI programs to extract common
functionality between the different binaries.
|
|
Going to use this for more cli-oriented code, so that the binaries can
share more logic.
|
|
This will allow us to accept suggestion IDs alone, without a full URL,
like the following:
$ git sugapply 459691747
# or
$ git sugapply --remote upstream 459691747
# or
$ git config github-suggestion.remote upstream
$ git sugapply 459691747
We do this by extracting the pair from the remote URL.
|
|
We need two segments in the path to parse the owner-repo combination.
|
|
Ended up not using this. Instead used 'git2' to generate the diff.
|
|
|
|
|
|
Didn't like the old name. Wanted to make the GitHub reference more
explicit. I remember it as "suggestion", since that's the name of the
GitHub feature, so "suggested" was confusing. The final "patch" seemed
redundant or unnecessary.
|
|
These weren't actual tests. I was using them to research different
implementation approaches.
|
|
Replace `unwrap`s with trys.
|
|
Remove the `unwrap` in this method and return a `Result`.
|
|
These methods are no longer used.
|
|
Extend the `Error` enum with new variants to capture the possible errors
from `diff()` and `diff_with_repo()`.
|
|
The newer `Suggestion.diff()` method fulfills the same need.
|
|
Wrap `Github` client errors.
|
|
I had written this to check the response from the server and the
'github-rs' library. Remove it since it makes a network request.
|
|
|
|
Planning to separate the `Suggestion` and `Client` code.
|
|
Don't apply the patch when it doesn't apply, instead fail with an error.
Previously, the `apply()` method would apply the patch to the lines from
`Suggestion`, even if the file was different from what the suggestion
expected. So, you could end up with the `Suggestion` lines being
overwritten with the suggestion text, even when they didn't match the
original side of the suggestion.
Fix this by getting the diff text from `diff_with_repo()` and applying
it using `git-apply`. This gives us a suitable error when the patch
doesn't apply to the file, leaving the file alone.
|
|
Add a test for diff generation. Split `diff()` into `diff_with_repo()`
to allow us to test with a new repo instead of defaulting to the current
one.
In the test, create a new Git repo using `git2`, add and commit a file,
and check that the diff generated by a Suggestion is correct.
Got the `IndexEntry` format from
https://docs.rs/git2/0.13.8/src/git2/index.rs.html#858-871.
|
|
Take a `BufRead`er instead of a file path to read from. This gives us
more flexibility.
We can't use the `Read` trait because of the error described in
b4a7561ccc1ed7dab6cd2c786902dec8c4ad9be6.
Fix the bug in `Suggestion.diff()` so that the suggestion is applied to
the commit it corresponds to instead of HEAD.
|
|
|
|
Create a patch file for the suggestion. Instead of building the patch
text manually, as in my earlier attempts (`patch` and `unified_diff`),
apply the patch to the file in memory, and then ask libgit2 to give us a
Git patch by comparing the original blob and the patched buffer.
Doing this because I was unsuccessful in manually composing a patch file
that Git would accept. I could create unified diffs that the `patch`
program would accept, but these wouldn't work with `git-apply`. My
current guess is that these didn't work because I didn't have both
before and after context in my manually-created patch files.
Since this tool is intended to be used with Git, I want a patch file
that will work transparently with Git utilities. The easiest alternative
to manually generating the patch file seemed to be to have Git create
the patch text.
Add a new binary, `git-sugpatch`, that outputs the patch text to
standard output.
TODO: This gets the original from the current HEAD in `apply_to()`. We
should instead be using the contents of `blob`, because the original is
not necessarily the working copy.
|
|
This is no longer absolutely necessary now that we have the
`suggestion_apply_to_writes_patch_to_writer` test.
|
|
|
|
Make the suggestion's line endings consistent with those used in the
file.
By default, the suggestion block we get from the GitHub API uses CRLF
line endings. These need to be converted to be consistent with the file
the change is being applied to.
|
|
Now that I fixed the line numbers in the code
(0ea9202eb81e18647b40563fd3dbc61b626ce2ec), we need to correct them in
the test as well. The empty line after the `r#"` delimiter is the first
line.
|
|
We had been using the enumerator's index, which starts at 0, but line
numbers start at 1. Use the correct line number.
|
|
Single-line changes weren't getting applied, because if only a single
line changed, the `original_start_line` field is null. That caused the
first `if` branch to always evaluate to true.
Swap the `if` branches to fix this.
|
|
We can't read from the original file, because we want to be able to use
that as the writer in `apply()`.
Previously, this would result in the original file simply being
truncated, as we weren't reading from the correct file.
To fix this, we need to give `apply_to()` both a reader and a writer.
Now, in `apply()`, we can pass it the temporary file to read, and the
original to write to.
Used a `Path` as an input to `apply_to()` instead of a `Read`er because
I got an error that didn't really make sense to me when I did so:
error[E0275]: overflow evaluating the requirement `&tokio_reactor::poll_evented::PollEvented<_>: std::io::Read`
|
= help: consider adding a `#![recursion_limit="256"]` attribute to your crate (`git_suggested_patch`)
= note: required because of the requirements on the impl of `std::io::Read` for `&tokio_reactor::poll_evented::PollEvented<tokio_reactor::poll_evented::PollEvented<_>>`
= note: required because of the requirements on the impl of `std::io::Read` for `&tokio_reactor::poll_evented::PollEvented<tokio_reactor::poll_evented::PollEvented<tokio_reactor::poll_evented::PollEvented<_>>>`
A search for the error message turned up a few active issues:
- https://github.com/rust-lang/rust/issues/57854
- https://github.com/rust-lang/rust/issues/62755
- https://github.com/rust-lang/rust/issues/39959
The above issues indicate that this could come from having a variable
with an inferred type. However, for the moment the issue isn't resolved,
and the error message doesn't indicate where the problem is actually
coming from. As I was unable to track down the source of the problem, I
decided not to bother using a `Read` argument.
|
|
This field can be null in the API response.
|
|
An executable to apply a suggested change to the appropriate file in the
repo.
Add a new `SuggestionUrl` type that allows us to extract the necessary
data to fetch a suggestion comment from the GitHub API using a GitHub
pull request comment URL.
|
|
Replace common code with a call to `Suggestion.apply_to()`.
|
|
I didn't feel like writing a test for `Suggestion.apply()`, which writes
files, so decided to write a different version that used the original
file and a writer.
Changed the `Suggestion.suggestion()` function to not prepend "+" to
suggestion lines so we can use the function to extract the suggested
lines unmodified from the comment. Kept the old version around as
`suggestion_patch()` because we may need it to generate patches.
Copied the code from `Suggestion.apply()`, except write the changes to
`writer` instead of the file at `Suggestion.path`.
|
|
Add the new fields from `Suggestion`.
|
|
The name "suggestion" sounds like the suggested diff change, when really
this field will be deserialised with the whole GitHub comment, including
adjacent text as well as the suggestion.
|
|
Haven't tested this yet.
To keep the original file's metadata, try writing the changes to the
original instead of the temporary file. First copy the original to a new
file that we can reference after truncating the original, then write the
change onto the original.
|
|
Not working yet, but the idea is to get the file referenced by the
suggestion and apply the suggested change directly to it.
Here, we read the original file, and write its contents to the new file,
replacing the lines modified by the suggestion with the suggested
change.
Currently doesn't work because you can't pass file instances to
`fs::rename`, only paths.
I'd like to try a slightly different system so I can keep the original
file's creation date. With the current system, it would be overwritten
by the new temporary file created to store the change.
|
|
|
|
Work out the code required to get a file blob's contents from a Git
repository using the 'git2' crate.
We'll be using this to get the original file for patching.
|