| Age | Commit message (Collapse) | Author |
|---|
|
+ Del extra spaces, import os.path as osp
|
|
Thanks to @yarikoptic for catching this one !
|
|
It ain't pretty, but should do the job.
Related to #514
|
|
Relying on the destructor will not work, even though
the code used to rely on it.
Now we handle failures more explicitly. Far from perfect,
but a good start for a fix.
Fixes #514
|
|
It's not optimal, as we can now return one of two types
which are only compatible in the most basic ways.
However, it is better than before, I presume.
Fixes #510
|
|
It's entirely untested if this repo still does the right thing,
but I'd think it does.
Fixes #504
|
|
Update Remotes section
The Remotes section was missing some pretty important info.
|
|
Assure that gpgsig is not initialized with None
to allow the automatic deserialization to kick in.
Fixes #500
|
|
|
|
is_dirty supports path. Fixes #482.
|
|
|
|
|
|
- add a second line to commit messages with the "BAD MESSAGE" text
- read in the log and confirm that the seond line is not in the log file
|
|
That way, we do not have to figure the change type out by
examining the diff object.
It's implemented in a way that should yield more desireable results
as we keep the change-type that git is providing us with.
Fixes #493
|
|
That way, we will not only get the summary line
contained in the blame, but fetch the full message.
This is more costly than the previous implementation
allowed it to be, but being less surprising/correct
certainly is the preferred behaviour here.
Fixes #485
|
|
Previously, the following fields on Diff instances were assumed to be
passed in as unicode strings:
- `a_path`
- `b_path`
- `rename_from`
- `rename_to`
However, since Git natively records paths as bytes, these may
potentially not have a valid unicode representation.
This patch changes the Diff instance to instead take the following
equivalent fields that should be raw bytes instead:
- `a_rawpath`
- `b_rawpath`
- `raw_rename_from`
- `raw_rename_to`
NOTE ON BACKWARD COMPATIBILITY:
The original `a_path`, `b_path`, etc. fields are still available as
properties (rather than slots). These properties now dynamically decode
the raw bytes into a unicode string (performing the potentially
destructive operation of replacing invalid unicode chars by "�"'s).
This means that all code using Diffs should remain backward compatible.
The only exception is when people would manually construct Diff
instances by calling the constructor directly, in which case they should
now pass in bytes rather than unicode strings.
See also the discussion on
https://github.com/gitpython-developers/GitPython/pull/467
|
|
It usually fails on branches, which doesn't help
assessing PRs.
|
|
Adding support for git remote set-url/get-url API to Remote
|
|
gitpython-developers/fix-dont-choke-on-invalid-unicode-paths
Don't choke on (legitimately) invalidly encoded Unicode paths
|
|
I see no need in verifying the status code.
It's enough to just get the error.
|
|
Both commands enable handling of a little known feature
of git, which is to support multiple URL for one remote.
You can add multiple url using the `set_url` subcommand of
`git remote`. As listing them is also handy, there's a
nice method to do it, using `get_url`.
* adding set_url method that maps to the git remote set-url command¶
* can be used to set an URL, or replace an URL with optional positional arg¶
* can be used to add, delete URL with kwargs (matching set-url options)¶
* adding add_url, delete_url methods that wraps around set_url for conveniency¶
* adding urls property that yields an iterator over the setup urls for a remote¶
* adding a test suite that checks all use case scenarii of this added API.¶
Signed-off-by: Guyzmo <guyzmo+github@m0g.net>
|
|
|
|
|
|
Please exclude the particular assertion instead.
Related to
https://github.com/gitpython-developers/GitPython/commit/a3f24f64a20d1e09917288f67fd21969f4444acd#commitcomment-17691581
|
|
gitpython-developers/fix-for-invalid-data-in-commits
Add test case as example of Git commit with invalid data
|
|
gitpython-developers/fix-octal-escaped-path-parser-bug
Fix bug in diff parser output
|
|
This is a real commit from the microjs.com open source project, see
https://github.com/madrobby/microjs.com/commit/7e8457c17850d0991763941213dcb403d80f39f8,
which is declared to be encoded in UTF-8, but contains invalid bytes.
This makes GitPython choke on it while decoding. Rather than choking,
this should instead accept the error and replace the invalid bytes by
the � (\x80) char.
|
|
|
|
The diff --patch parser was missing some edge case where Git would
encode non-ASCII chars in path names as octals, but these weren't
decoded properly.
\360\237\222\251.txt
Decoded via utf-8, that will return:
💩.txt
|
|
Don't allow `, ` prefixes or suffixes in messages.
Fixes #438
|
|
Opt to split lines by the new line character instead of letting
`splitlines()` do this. This helps catch the issue when there are
special characters in the line, particular the commit summary section.
|
|
Need spaces in Emacs style encoding comment
|
|
Fixes #426
|
|
Although it's hard to see, PEP-0263 does have ws delimiting the 'coding' string.
This commit will fix the root cause of (at least) one bug: https://lists.fedoraproject.org/archives/list/eclipse-sig@lists.fedoraproject.org/thread/5XQ5JRHG6DPPMGRDU7TA2AO4EYS2H7AG/
|
|
Who would have thought we ever go 2.0 ;).
|
|
Add support for getting "aware" datetime info
|
|
Specifically "string_escape" does not exist as an encoding anymore.
|
|
This specifically covers the cases where unsafe chars occur in path
names, and git-diff -p will escape those.
From the git-diff-tree manpage:
> 3. TAB, LF, double quote and backslash characters in pathnames are
> represented as \t, \n, \" and \\, respectively. If there is need
> for such substitution then the whole pathname is put in double
> quotes.
This patch checks whether or not this has happened and will unescape
those paths accordingly.
One thing to note here is that, depending on the position in the patch
format, those paths may be prefixed with an a/ or b/. I've specifically
made sure to never interpret a path that actually starts with a/ or b/
incorrectly.
Example of that subtlety below. Here, the actual file path is
"b/normal". On the diff file that gets encoded as "b/b/normal".
diff --git a/b/normal b/b/normal
new file mode 100644
index 0000000000000000000000000000000000000000..eaf5f7510320b6a327fb308379de2f94d8859a54
--- /dev/null
+++ b/b/normal
@@ -0,0 +1 @@
+dummy content
Here, we prefer the "---" and "+++" lines' values. Note that these
paths start with a/ or b/. The only exception is the value "/dev/null",
which is handled as a special case.
Suppose now the file gets moved "b/moved", the output of that diff would
then be this:
diff --git a/b/normal b/b/moved
similarity index 100%
rename from b/normal
rename to b/moved
We prefer the "rename" lines' values in this case (the "diff" line is
always a last resort). Take note that those lines are not prefixed with
a/ or b/, but the ones in the "diff" line are (just like the ones in
"---" or "+++" lines).
|
|
|
|
This adds 2 properties to commits. Their values are derived from the
existing data stored on them, but this makes them more conveniently
queryable:
- authored_datetime
- committed_datetime
These return "aware" datetimes, so they are effectively companions to
their raw timestamp equivalents, respectively `authored_date` and
`committed_date`.
These datetime instances are convenient structures since they show the
author-local commit date and their UTC offset.
|
|
Some Git command line options are allowed to be repeated multiple times.
Examples of this are the -C flag which may occur more than once to
"strengthen" its effect, or the -L flag on Git blames, to select
multiple blocks of lines to blame.
$ git diff -C -C HEAD~1 HEAD
$ git blame -L 1-3 -L 12-18 HEAD -- somefile.py
This patch supports passing a list/tuple as the value part for kwargs,
so that the generated Git command contain the repeated options.
|
|
|
|
The a_path and b_path cannot reliably be read from the first diff line
as it's ambiguous. From the git-diff manpage:
> The a/ and b/ filenames are the same unless rename/copy is involved.
> Especially, **even for a creation or a deletion**, /dev/null is not
> used in place of the a/ or b/ filenames.
This patch changes the a_path and b_path detection to read it from the
more reliable locations further down the diff headers. Two use cases
are fixed by this:
- As the man page snippet above states, for new/deleted files the a
or b path will now be properly None.
- File names with spaces in it are now properly parsed.
Working on this patch, I realized the --- and +++ lines really belong to
the diff header, not the diff contents. This means that when parsing
the patch format, the --- and +++ will now be swallowed, and not end up
anymore as part of the diff contents. The diff contents now always
start with an @@ line.
This may be a breaking change for some users that rely on this
behaviour. However, those users could now access that information more
reliably via the normal Diff properties a_path and b_path now.
|
|
enrich-incremental-blame-output
|
|
Returning this now to avoid having to change the function's return value
structure later on if we want to emit more information.
|
|
|
|
This enabled getting diff patches for root commits.
|
|
Add incremental blame support
|
|
|
|
Issue #407
|
