Page Menu
Home
Software Heritage
Search
Configure Global Search
Log In
Files
F9338503
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Flag For Later
Size
340 KB
Subscribers
None
View Options
This file is larger than 256 KB, so syntax highlighting was skipped.
diff --git a/.gitignore b/.gitignore
index eaa127a1..d1a876fd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,27 +1,28 @@
_trial_temp
build
build-pypy
MANIFEST
dist
apidocs
*,cover
.testrepository
*.pyc
*.pyd
*.pyo
*.so
*~
*.swp
*.swh
*.swn
*.swo
docs/tutorial/index.html
dulwich.egg-info/
.tox/
.idea/
.coverage
htmlcov/
docs/api/*.txt
.mypy_cache/
.eggs
dulwich.dist-info
+.stestr
diff --git a/.stestr.conf b/.stestr.conf
new file mode 100644
index 00000000..64964357
--- /dev/null
+++ b/.stestr.conf
@@ -0,0 +1,2 @@
+[DEFAULT]
+test_path=dulwich/tests
diff --git a/NEWS b/NEWS
index 29a4749f..41df77cb 100644
--- a/NEWS
+++ b/NEWS
@@ -1,2279 +1,2287 @@
+0.20.27 2022-01-04
+
+ * Allow adding files to repository in pre-commit hook.
+ (Jelmer Vernooij, #916)
+
+ * Raise SubmoduleEncountered in ``tree_lookup_path``.
+ (Jelmer Vernooij)
+
0.20.26 2021-10-29
* Support os.PathLike arguments to Repo.stage().
(Jan Wiśniewski, #907)
* Drop support for Python 3.5. (Jelmer Vernooij)
* Add ``dulwich.porcelain._reset_file``.
(Ded_Secer)
* Add ``Repo.unstage``. (Ded_Secer)
0.20.25 2021-08-23
* Fix ``dulwich`` script when installed via setup.py.
(Dan Villiom Podlaski Christiansen)
* Make default file mask consistent
with Git. (Dan Villiom Podlaski Christiansen, #884)
0.20.24 2021-07-18
* config: disregard UTF-8 BOM when reading file.
(Dan Villiom Podlaski Christiansen)
* Skip lines with spaces only in .gitignore. (Andrey Torsunov, #878)
* Add a separate HTTPProxyUnauthorized exception for 407 errors.
(Jelmer Vernooij, #822)
* Split out a AbstractHTTPGitClient class.
(Jelmer Vernooij)
0.20.23 2021-05-24
* Fix installation of GPG during package publishing.
(Ruslan Kuprieiev)
0.20.22 2021-05-24
* Prevent removal of refs directory when the last ref is
deleted. (Jelmer Vernooij)
* Fix filename: MERGE_HEADS => MERGE_HEAD.
(Jelmer Vernooij, #861)
* For ignored directories, porcelain.add and porcelain.status now only return
the path to directory itself in the list of ignored paths. Previously, paths
for all files within the directory would also be included in the list.
(Peter Rowlands, #853)
* Provide depth argument to ``determine_wants``.
(Peter Rowlands)
* Various tag signature handling improvements.
(Daniel Murphy)
* Add separate Tag.verify(). (Peter Rowlands)
* Add support for version 3 index files. (Jelmer Vernooij)
* Fix autocrlf=input handling. (Peter Rowlands, Boris Feld)
* Attempt to find C Git global config on Windows.
(Peter Rowlands)
API CHANGES
* The APIs for writing and reading individual index entries have changed
to handle lists of (name, entry) tuples rather than tuples.
0.20.21 2021-03-20
* Add basic support for a GcsObjectStore that stores
pack files in gcs. (Jelmer Vernooij)
* In porcelain.push, default to local active branch.
(Jelmer Vernooij, #846)
* Support fetching symrefs.
(Jelmer Vernooij, #485, #847)
* Add aarch64 wheel building.
(odidev, Jelmer Vernooij)
0.20.20 2021-03-03
* Implement ``Stash.drop``. (Peter Rowlands)
* Support untracked symlinks to paths outside the
repository. (Peter Rowlands, #842)
0.20.19 2021-02-11
* Fix handling of negative matches in nested gitignores.
(Corentin Hembise, #836)
0.20.18 2021-02-04
* Fix formatting in setup.py. (Jelmer Vernooij)
* Add release configuration. (Jelmer Vernooij)
0.20.17 2021-02-04
* credentials: ignore end-of-line character. (Georges Racinet)
* Fix failure in get_untracked_paths when the repository contains symlinks.
(#830, #793, mattseddon)
* docs: Clarify that Git objects are created on `git add`.
(Utku Gultopu)
0.20.16 2021-01-16
* Add flag to only attempt to fetch ignored untracked files when specifically requested.
(Matt Seddon)
0.20.15 2020-12-23
* Add some functions for parsing and writing bundles.
(Jelmer Vernooij)
* Add ``no_verify`` flag to ``porcelain.commit`` and ``Repo.do_commit``.
(Peter Rowlands)
* Remove dependency on external mock module.
(Matěj Cepl, #820)
0.20.14 2020-11-26
* Fix some stash functions on Python 3. (Peter Rowlands)
* Fix handling of relative paths in alternates files on Python 3.
(Georges Racinet)
0.20.13 2020-11-22
* Add py.typed to allow type checking. (David Caro)
* Add tests demonstrating a bug in the walker code.
(Doug Hellman)
0.20.11 2020-10-30
* Fix wheels build on Linux. (Ruslan Kuprieiev)
* Enable wheels build for Python 3.9 on Linux. (Jelmer Vernooij)
0.20.8 2020-10-29
* Build wheels on Mac OS X / Windows for Python 3.9.
(Jelmer Vernooij)
0.20.7 2020-10-29
* Check core.repositoryformatversion. (Jelmer Vernooij, #803)
* Fix ACK/NACK handling in archive command handling in dulwich.client.
(DzmitrySudnik, #805)
0.20.6 2020-08-29
* Add a ``RefsContainer.watch`` interface.
(Jelmer Vernooij, #751)
* Fix pushing of new branches from porcelain.push.
(Jelmer Vernooij, #788)
* Honor shallows when pushing from a shallow clone.
(Jelmer Vernooij, #794)
* Fix porcelain.path_to_tree_path for Python 3.5.
(Boris Feld, #777)
* Add support for honor proxy environment variables for HTTP.
(Aurélien Campéas, #797)
0.20.5 2020-06-22
* Print a clearer exception when setup.py is executed on Python < 3.5.
(Jelmer Vernooij, #783)
* Send an empty pack to clients if they requested objects, even if they
already have those objects. Thanks to Martijn Pieters for
the detailed bug report. (Jelmer Vernooij, #781)
* porcelain.pull: Don't ask for objects that we already have.
(Jelmer Vernooij, #782)
* Add LCA implementation. (Kevin Hendricks)
* Add functionality for finding the merge base. (Kevin Hendricks)
* Check for diverged branches during push.
(Jelmer Vernooij, #494)
* Check for fast-forward during pull. (Jelmer Vernooij, #666)
* Return a SendPackResult object from
GitClient.send_pack(). (Jelmer Vernooij)
* ``GitClient.send_pack`` now sets the ``ref_status`` attribute
on its return value to a dictionary mapping ref names
to error messages. Previously, it raised UpdateRefsError
if any of the refs failed to update.
(Jelmer Vernooij, #780)
* Add a ``porcelain.Error`` object that most errors in porcelain
derive from. (Jelmer Vernooij)
* Fix argument parsing in dulwich command-line app.
(Jelmer Vernooij, #784)
0.20.3 2020-06-14
* Add support for remembering remote refs after push/pull.
(Jelmer Vernooij, #752)
* Support passing tree and output encoding to
dulwich.patch.unified_diff. (Jelmer Vernooij, #763)
* Fix pushing of new refs over HTTP(S) when there are
no new objects to be sent.
(Jelmer Vernooij, #739)
* Raise new error HTTPUnauthorized when the server sends
back a 401. The client can then retry with credentials.
(Jelmer Vernooij, #691)
* Move the guts of bin/dulwich to dulwich.cli, so it is easier to
test or import. (Jelmer Vernooij)
* Install dulwich script from entry_points when setuptools is available,
making it slightly easier to use on Windows. (Jelmer Vernooij, #540)
* Set python_requires>=3.5 in setup.py. (Manuel Jacob)
0.20.2 2020-06-01
* Brown bag release to fix uploads of Windows wheels.
0.20.1 2020-06-01
* Publish binary wheels for: Windows, Linux, Mac OS X.
(Jelmer Vernooij, #711, #710, #629)
0.20.0 2020-06-01
* Drop support for Python 2. (Jelmer Vernooij)
* Only return files from the loose store that look like git objects.
(Nicolas Dandrimont)
* Ignore agent= capability if sent by client.
(Jelmer Vernooij)
* Don't break when encountering block devices.
(Jelmer Vernooij)
* Decode URL paths in HttpGitClient using utf-8 rather than file system
encoding. (Manuel Jacob)
* Fix pushing from a shallow clone.
(Brecht Machiels, #705)
0.19.16 2020-04-17
* Don't send "deepen None" to server if graph walker
supports shallow. (Jelmer Vernooij, #747)
* Support tweaking the compression level for
loose objects through the "core.looseCompression" and
"core.compression" settings. (Jelmer Vernooij)
* Support tweaking the compression level for
pack objects through the "core.packCompression" and
"core.compression" settings. (Jelmer Vernooij)
* Add a "dulwich.contrib.diffstat" module.
(Kevin Hendricks)
0.19.15 2020-01-26
* Properly handle files that are just executable for the
current user. (Jelmer Vernooij, #734)
* Fix handling of stored encoding in
``dulwich.porcelain.get_object_by_path`` on Python 3.
(Jelmer Vernooij)
* Support the include_trees and rename_detector arguments
at the same time when diffing trees.
(Jelmer Vernooij)
0.19.14 2019-11-30
* Strip superfluous <> around email. (monnerat)
* Stop checking for ref validity client-side. Users can
still call check_wants manually. (Jelmer Vernooij)
* Switch over to Google-style docstrings.
(Jelmer Vernooij)
* Add a ``dulwich.porcelain.active_branch`` function.
(Jelmer Vernooij)
* Cleanup new directory if clone fails. (Jelmer Vernooij, #733)
* Expand "~" in global exclude path. (Jelmer Vernooij)
0.19.13 2019-08-19
BUG FIXES
* Avoid ``PermissionError``, since it is Python3-specific.
(Jelmer Vernooij)
* Fix regression that added a dependency on C git for the
test suite. (Jelmer Vernooij, #720)
* Fix compatibility with Python 3.8 - mostly deprecation warnings.
(Jelmer Vernooij)
0.19.12 2019-08-13
BUG FIXES
* Update directory detection for `get_unstaged_changes` for Python 3.
(Boris Feld, #684)
* Add a basic ``porcelain.clean``. (Lane Barlow, #398)
* Fix output format of ``porcelain.diff`` to match that of
C Git. (Boris Feld)
* Return a 404 not found error when repository is not found.
* Mark ``.git`` directories as hidden on Windows.
(Martin Packman, #585)
* Implement ``RefsContainer.__iter__``
(Jelmer Vernooij, #717)
* Don't trust modes if they can't be modified after a file has been created.
(Jelmer Vernooij, #719)
0.19.11 2019-02-07
IMPROVEMENTS
* Use fullname from gecos field, if available.
(Jelmer Vernooij)
* Support ``GIT_AUTHOR_NAME`` / ``GIT_AUTHOR_EMAIL``.
(Jelmer Vernooij)
* Add support for short ids in parse_commit. (Jelmer Vernooij)
* Add support for ``prune`` and ``prune_tags`` arguments
to ``porcelain.fetch``. (Jelmer Vernooij, #681)
BUG FIXES
* Fix handling of race conditions when new packs appear.
(Jelmer Vernooij)
0.19.10 2018-01-15
IMPROVEMENTS
* Add `dulwich.porcelain.write_tree`.
(Jelmer Vernooij)
* Support reading ``MERGE_HEADS`` in ``Repo.do_commit``.
(Jelmer Vernooij)
* Import from ``collections.abc`` rather than ``collections`` where
applicable. Required for 3.8 compatibility.
(Jelmer Vernooij)
* Support plain strings as refspec arguments to
``dulwich.porcelain.push``. (Jelmer Vernooij)
* Add support for creating signed tags.
(Jelmer Vernooij, #542)
BUG FIXES
* Handle invalid ref that pretends to be a sub-folder under a valid ref.
(KS Chan)
0.19.9 2018-11-17
BUG FIXES
* Avoid fetching ghosts in ``Repo.fetch``.
(Jelmer Vernooij)
* Preserve port and username in parsed HTTP URLs.
(Jelmer Vernooij)
* Add basic server side implementation of ``git-upload-archive``.
(Jelmer Vernooij)
0.19.8 2018-11-06
* Fix encoding when reading README file in setup.py.
(egor <egor@sourced.tech>, #668)
0.19.7 2018-11-05
CHANGES
* Drop support for Python 3 < 3.4. This is because
pkg_resources (which get used by setuptools and mock)
no longer supports 3.3 and earlier. (Jelmer Vernooij)
IMPROVEMENTS
* Support ``depth`` argument to ``GitClient.fetch_pack`` and support
fetching and updating shallow metadata. (Jelmer Vernooij, #240)
BUG FIXES
* Don't write to stdout and stderr when they are not available
(such as is the case for pythonw). (Sylvia van Os, #652)
* Fix compatibility with newer versions of git, which expect CONTENT_LENGTH
to be set to 0 for empty body requests. (Jelmer Vernooij, #657)
* Raise an exception client-side when a caller tries to request
SHAs that are not directly referenced the servers' refs.
(Jelmer Vernooij)
* Raise more informative errors when unable to connect to repository
over SSH or subprocess. (Jelmer Vernooij)
* Handle commit identity fields with multiple ">" characters.
(Nicolas Dandrimont)
IMPROVEMENTS
* ``dulwich.porcelain.get_object_by_path`` method for easily
accessing a path in another tree. (Jelmer Vernooij)
* Support the ``i18n.commitEncoding`` setting in config.
(Jelmer Vernooij)
0.19.6 2018-08-11
BUG FIXES
* Fix support for custom transport arguments in ``dulwich.porcelain.clone``.
(Semyon Slepov)
* Fix compatibility with Python 3.8 (Jelmer Vernooij, Daniel M. Capella)
* Fix some corner cases in ``path_to_tree_path``. (Romain Keramitas)
* Support paths as bytestrings in various places in ``dulwich.index``
(Jelmer Vernooij)
* Avoid setup.cfg for now, since it seems to break pypi metadata.
(Jelmer Vernooij, #658)
0.19.5 2018-07-08
IMPROVEMENTS
* Add ``porcelain.describe``. (Sylvia van Os)
BUG FIXES
* Fix regression in ``dulwich.porcelain.clone`` that prevented cloning
of remote repositories. (Jelmer Vernooij, #639)
* Don't leave around empty parent directories for removed refs.
(Damien Tournoud, #640)
0.19.4 2018-06-24
IMPROVEMENTS
* Add ``porcelain.ls_files``. (Jelmer Vernooij)
* Add ``Index.items``. (Jelmer Vernooij)
BUG FIXES
* Avoid unicode characters (e.g. the digraph ij in my surname) in setup.cfg,
since setuptools doesn't deal well with them. See
https://github.com/pypa/setuptools/issues/1062. (Jelmer Vernooij, #637)
0.19.3 2018-06-17
IMPROVEMENTS
* Add really basic `dulwich.porcelain.fsck` implementation.
(Jelmer Vernooij)
* When the `DULWICH_PDB` environment variable is set, make
SIGQUIT open pdb in the 'dulwich' command.
* Add `checkout` argument to `Repo.clone`.
(Jelmer Vernooij, #503)
* Add `Repo.get_shallow` method. (Jelmer Vernooij)
* Add basic `dulwich.stash` module. (Jelmer Vernooij)
* Support a `prefix` argument to `dulwich.archive.tar_stream`.
(Jelmer Vernooij)
BUG FIXES
* Fix handling of encoding for tags. (Jelmer Vernooij, #608)
* Fix tutorial tests on Python 3. (Jelmer Vernooij, #573)
* Fix remote refs created by `porcelain.fetch`. (Daniel Andersson, #623)
* More robust pack creation on Windows. (Daniel Andersson)
* Fix recursive option for `porcelain.ls_tree`. (Romain Keramitas)
TESTS
* Some improvements to paramiko tests. (Filipp Frizzy)
0.19.2 2018-04-07
BUG FIXES
* Fix deprecated Index.iterblobs method.
(Jelmer Vernooij)
0.19.1 2018-04-05
IMPROVEMENTS
* Add 'dulwich.mailmap' file for reading mailmap files.
(Jelmer Vernooij)
* Dulwich no longer depends on urllib3[secure]. Instead,
"dulwich[https]" can be used to pull in the necessary
dependencies for HTTPS support. (Jelmer Vernooij, #616)
* Support the `http.sslVerify` and `http.sslCAInfo`
configuration options. (Jelmer Vernooij)
* Factor out `dulwich.client.parse_rsync_url` function.
(Jelmer Vernooij)
* Fix repeat HTTP requests using the same smart HTTP client.
(Jelmer Vernooij)
* New 'client.PLinkSSHVendor' for creating connections using PuTTY's plink.exe.
(Adam Bradley, Filipp Frizzy)
* Only pass in `key_filename` and `password` to SSHVendor
implementations if those parameters are set.
(This helps with older SSHVendor implementations)
(Jelmer Vernooij)
API CHANGES
* Index.iterblobs has been renamed to Index.iterobjects.
(Jelmer Vernooij)
0.19.0 2018-03-10
BUG FIXES
* Make `dulwich.archive` set the gzip header file modification time so that
archives created from the same Git tree are always identical.
(#577, Jonas Haag)
* Allow comment characters (#, ;) within configuration file strings
(Daniel Andersson, #579)
* Raise exception when passing in invalid author/committer values
to Repo.do_commit(). (Jelmer Vernooij, #602)
IMPROVEMENTS
* Add a fastimport ``extra``. (Jelmer Vernooij)
* Start writing reflog entries. (Jelmer Vernooij)
* Add ability to use password and keyfile ssh options with SSHVendor. (Filipp Kucheryavy)
* Add ``change_type_same`` flag to ``tree_changes``.
(Jelmer Vernooij)
API CHANGES
* ``GitClient.send_pack`` now accepts a ``generate_pack_data``
rather than a ``generate_pack_contents`` function for
performance reasons. (Jelmer Vernooij)
* Dulwich now uses urllib3 internally for HTTP requests.
The `opener` argument to `dulwich.client.HttpGitClient` that took a
`urllib2` opener instance has been replaced by a `pool_manager` argument
that takes a `urllib3` pool manager instance.
(Daniel Andersson)
0.18.6 2017-11-11
BUG FIXES
* Fix handling of empty repositories in ``porcelain.clone``.
(#570, Jelmer Vernooij)
* Raise an error when attempting to add paths that are not under the
repository. (Jelmer Vernooij)
* Fix error message for missing trailing ]. (Daniel Andersson)
* Raise EmptyFileException when corruption (in the form of an empty
file) is detected. (Antoine R. Dumont, #582)
IMPROVEMENTS
* Enforce date field parsing consistency. This also add checks on
those date fields for potential overflow.
(Antoine R. Dumont, #567)
0.18.5 2017-10-29
BUG FIXES
* Fix cwd for hooks. (Fabian Grünbichler)
* Fix setting of origin in config when non-standard origin is passed into
``Repo.clone``. (Kenneth Lareau, #565)
* Prevent setting SSH arguments from SSH URLs when using SSH through a
subprocess. Note that Dulwich doesn't support cloning submodules.
(CVE-2017-16228) (Jelmer Vernooij)
IMPROVEMENTS
* Silently ignored directories in ``Repo.stage``.
(Jelmer Vernooij, #564)
API CHANGES
* GitFile now raises ``FileLocked`` when encountering a lock
rather than OSError(EEXIST). (Jelmer Vernooij)
0.18.4 2017-10-01
BUG FIXES
* Make default User-Agent start with "git/" because GitHub won't response to
HTTP smart server requests otherwise (and reply with a 404).
(Jelmer vernooij, #562)
0.18.3 2017-09-03
BUG FIXES
* Read config during porcelain operations that involve remotes.
(Jelmer Vernooij, #545)
* Fix headers of empty chunks in unified diffs. (Taras Postument, #543)
* Properly follow redirects over HTTP. (Jelmer Vernooij, #117)
IMPROVEMENTS
* Add ``dulwich.porcelain.update_head``. (Jelmer Vernooij, #439)
* ``GitClient.fetch_pack`` now returns symrefs.
(Jelmer Vernooij, #485)
* The server now supports providing symrefs.
(Jelmer Vernooij, #485)
* Add ``dulwich.object_store.commit_tree_changes`` to incrementally
commit changes to a tree structure. (Jelmer Vernooij)
* Add basic ``PackBasedObjectStore.repack`` method.
(Jelmer Vernooij, Earl Chew, #296, #549, #552)
0.18.2 2017-08-01
TEST FIXES
* Use constant timestamp so tests pass in all timezones, not just BST.
(Jelmer Vernooij)
0.18.1 2017-07-31
BUG FIXES
* Fix syntax error in dulwich.contrib.test_swift_smoke.
(Jelmer Vernooij)
0.18.0 2017-07-31
BUG FIXES
* Fix remaining tests on Windows. (Jelmer Vernooij, #493)
* Fix build of C extensions with Python 3 on Windows.
(Jelmer Vernooij)
* Pass 'mkdir' argument onto Repo.init_bare in Repo.clone.
(Jelmer Vernooij, #504)
* In ``dulwich.porcelain.add``, if no files are specified,
add from current working directory rather than repository root.
(Jelmer Vernooij, #521)
* Properly deal with submodules in 'porcelain.status'.
(Jelmer Vernooij, #517)
* ``dulwich.porcelain.remove`` now actually removes files from
disk, not just from the index. (Jelmer Vernooij, #488)
* Fix handling of "reset" command with markers and without
"from". (Antoine Pietri)
* Fix handling of "merge" command with markers. (Antoine Pietri)
* Support treeish argument to porcelain.reset(), rather than
requiring a ref/commit id. (Jelmer Vernooij)
* Handle race condition when mtime doesn't change between writes/reads.
(Jelmer Vernooij, #541)
* Fix ``dulwich.porcelain.show`` on commits with Python 3.
(Jelmer Vernooij, #532)
IMPROVEMENTS
* Add basic support for reading ignore files in ``dulwich.ignore``.
``dulwich.porcelain.add`` and ``dulwich.porcelain.status`` now honor
ignores. (Jelmer Vernooij, Segev Finer, #524, #526)
* New ``dulwich.porcelain.check_ignore`` command.
(Jelmer Vernooij)
* ``dulwich.porcelain.status`` now supports a ``ignored`` argument.
(Jelmer Vernooij)
DOCUMENTATION
* Clarified docstrings for Client.{send_pack,fetch_pack} implementations.
(Jelmer Vernooij, #523)
0.17.3 2017-03-20
PLATFORM SUPPORT
* List Python 3.3 as supported. (Jelmer Vernooij, #513)
BUG FIXES
* Fix compatibility with pypy 3. (Jelmer Vernooij)
0.17.2 2017-03-19
BUG FIXES
* Add workaround for
https://bitbucket.org/pypy/pypy/issues/2499/cpyext-pystring_asstring-doesnt-work,
fixing Dulwich when used with C extensions on pypy < 5.6. (Victor Stinner)
* Properly quote config values with a '#' character in them.
(Jelmer Vernooij, #511)
0.17.1 2017-03-01
IMPROVEMENTS
* Add basic 'dulwich pull' command. (Jelmer Vernooij)
BUG FIXES
* Cope with existing submodules during pull.
(Jelmer Vernooij, #505)
0.17.0 2017-03-01
TEST FIXES
* Skip test that requires sync to synchronize filesystems if os.sync is
not available. (Koen Martens)
IMPROVEMENTS
* Implement MemoryRepo.{set_description,get_description}.
(Jelmer Vernooij)
* Raise exception in Repo.stage() when absolute paths are
passed in. Allow passing in relative paths to
porcelain.add().(Jelmer Vernooij)
BUG FIXES
* Handle multi-line quoted values in config files.
(Jelmer Vernooij, #495)
* Allow porcelain.clone of repository without HEAD.
(Jelmer Vernooij, #501)
* Support passing tag ids to Walker()'s include argument.
(Jelmer Vernooij)
* Don't strip trailing newlines from extra headers.
(Nicolas Dandrimont)
* Set bufsize=0 for subprocess interaction with SSH client.
Fixes hangs on Python 3. (René Stern, #434)
* Don't drop first slash for SSH paths, except for those
starting with "~". (Jelmer Vernooij, René Stern, #463)
* Properly log off after retrieving just refs.
(Jelmer Vernooij)
0.16.3 2016-01-14
TEST FIXES
* Remove racy check that relies on clock time changing between writes.
(Jelmer Vernooij)
IMPROVEMENTS
* Add porcelain.remote_add. (Jelmer Vernooij)
0.16.2 2016-01-14
IMPROVEMENTS
* Fixed failing test-cases on windows.
(Koen Martens)
API CHANGES
* Repo is now a context manager, so that it can be easily
closed using a ``with`` statement. (Søren Løvborg)
TEST FIXES
* Only run worktree list compat tests against git 2.7.0,
when 'git worktree list' was introduced. (Jelmer Vernooij)
BUG FIXES
* Ignore filemode when building index when core.filemode
is false.
(Koen Martens)
* Initialize core.filemode configuration setting by
probing the filesystem for trustable permissions.
(Koen Martens)
* Fix ``porcelain.reset`` to respect the comittish argument.
(Koen Martens)
* Fix dulwich.porcelain.ls_remote() on Python 3.
(#471, Jelmer Vernooij)
* Allow both unicode and byte strings for host paths
in dulwich.client. (#435, Jelmer Vernooij)
* Add remote from porcelain.clone. (#466, Jelmer Vernooij)
* Fix unquoting of credentials before passing to urllib2.
(#475, Volodymyr Holovko)
* Cope with submodules in `build_index_from_tree`.
(#477, Jelmer Vernooij)
* Handle deleted files in `get_unstaged_changes`.
(#483, Doug Hellmann)
* Don't overwrite files when they haven't changed in
`build_file_from_blob`.
(#479, Benoît HERVIER)
* Check for existence of index file before opening pack.
Fixes a race when new packs are being added.
(#482, wme)
0.16.1 2016-12-25
BUG FIXES
* Fix python3 compatibility for dulwich.contrib.release_robot.
(Jelmer Vernooij)
0.16.0 2016-12-24
IMPROVEMENTS
* Add support for worktrees. See `git-worktree(1)` and
`gitrepository-layout(5)`. (Laurent Rineau)
* Add support for `commondir` file in Git control
directories. (Laurent Rineau)
* Add support for passwords in HTTP URLs.
(Jon Bain, Mika Mäenpää)
* Add `release_robot` script to contrib,
allowing easy finding of current version based on Git tags.
(Mark Mikofski)
* Add ``Blob.splitlines`` method.
(Jelmer Vernooij)
BUG FIXES
* Fix handling of ``Commit.tree`` being set to an actual
tree object rather than a tree id. (Jelmer Vernooij)
* Return remote refs from LocalGitClient.fetch_pack(),
consistent with the documentation for that method.
(#461, Jelmer Vernooij)
* Fix handling of unknown URL schemes in get_transport_and_path.
(#465, Jelmer Vernooij)
0.15.0 2016-10-09
BUG FIXES
* Allow missing trailing LF when reading service name from
HTTP servers. (Jelmer Vernooij, Andrew Shadura, #442)
* Fix dulwich.porcelain.pull() on Python3. (Jelmer Vernooij, #451)
* Properly pull in tags during dulwich.porcelain.clone.
(Jelmer Vernooij, #408)
CHANGES
* Changed license from "GNU General Public License, version 2.0 or later"
to "Apache License, version 2.0 or later or GNU General Public License,
version 2.0 or later". (#153)
IMPROVEMENTS
* Add ``dulwich.porcelain.ls_tree`` implementation. (Jelmer Vernooij)
0.14.1 2016-07-05
BUG FIXES
* Fix regression removing untouched refs when pushing over SSH.
(Jelmer Vernooij #441)
* Skip Python3 tests for SWIFT contrib module, as it has not yet
been ported.
0.14.0 2016-07-03
BUG FIXES
* Fix ShaFile.id after modification of a copied ShaFile.
(Félix Mattrat, Jelmer Vernooij)
* Support removing refs from porcelain.push.
(Jelmer Vernooij, #437)
* Stop magic protocol ref `capabilities^{}` from leaking out
to clients. (Jelmer Vernooij, #254)
IMPROVEMENTS
* Add `dulwich.config.parse_submodules` function.
* Add `RefsContainer.follow` method. (#438)
0.13.0 2016-04-24
IMPROVEMENTS
* Support `ssh://` URLs in get_transport_and_path_from_url().
(Jelmer Vernooij, #402)
* Support missing empty line after headers in Git commits and tags.
(Nicolas Dandrimont, #413)
* Fix `dulwich.porcelain.status` when used in empty trees.
(Jelmer Vernooij, #415)
* Return copies of objects in MemoryObjectStore rather than
references, making the behaviour more consistent with that of
DiskObjectStore. (Félix Mattrat, Jelmer Vernooij)
* Fix ``dulwich.web`` on Python3. (#295, Jonas Haag)
CHANGES
* Drop support for Python 2.6.
* Fix python3 client web support. (Jelmer Vernooij)
BUG FIXES
* Fix hang on Gzip decompression. (Jonas Haag)
* Don't rely on working tell() and seek() methods
on wsgi.input. (Jonas Haag)
* Support fastexport/fastimport functionality on python3 with newer
versions of fastimport (>= 0.9.5). (Jelmer Vernooij, Félix Mattrat)
0.12.0 2015-12-13
IMPROVEMENTS
* Add a `dulwich.archive` module that can create tarballs.
Based on code from Jonas Haag in klaus.
* Add a `dulwich.reflog` module for reading and writing reflogs.
(Jelmer Vernooij)
* Fix handling of ambiguous refs in `parse_ref` to make
it match the behaviour described in https://git-scm.com/docs/gitrevisions.
(Chris Bunney)
* Support Python3 in C modules. (Lele Gaifax)
BUG FIXES
* Simplify handling of SSH command invocation.
Fixes quoting of paths. Thanks, Thomas Liebetraut. (#384)
* Fix inconsistent handling of trailing slashes for DictRefsContainer. (#383)
* Add hack to support thin packs duing fetch(), albeit while requiring the
entire pack file to be loaded into memory. (jsbain)
CHANGES
* This will be the last release to support Python 2.6.
0.11.2 2015-09-18
IMPROVEMENTS
* Add support for agent= capability. (Jelmer Vernooij, #298)
* Add support for quiet capability. (Jelmer Vernooij)
CHANGES
* The ParamikoSSHVendor class has been moved to
* dulwich.contrib.paramiko_vendor, as it's currently untested.
(Jelmer Vernooij, #364)
0.11.1 2015-09-13
Fix-up release to exclude broken blame.py file.
0.11.0 2015-09-13
IMPROVEMENTS
* Extended Python3 support to most of the codebase.
(Gary van der Merwe, Jelmer Vernooij)
* The `Repo` object has a new `close` method that can be called to close any
open resources. (Gary van der Merwe)
* Support 'git.bat' in SubprocessGitClient on Windows.
(Stefan Zimmermann)
* Advertise 'ofs-delta' capability in receive-pack server side
capabilities. (Jelmer Vernooij)
* Switched `default_local_git_client_cls` to `LocalGitClient`.
(Gary van der Merwe)
* Add `porcelain.ls_remote` and `GitClient.get_refs`.
(Michael Edgar)
* Add `Repo.discover` method. (B. M. Corser)
* Add `dulwich.objectspec.parse_refspec`. (Jelmer Vernooij)
* Add `porcelain.pack_objects` and `porcelain.repack`.
(Jelmer Vernooij)
BUG FIXES
* Fix handling of 'done' in graph walker and implement the
'no-done' capability. (Tommy Yu, #88)
* Avoid recursion limit issues resolving deltas. (William Grant, #81)
* Allow arguments in local client binary path overrides.
(Jelmer Vernooij)
* Fix handling of commands with arguments in paramiko SSH
client. (Andreas Klöckner, Jelmer Vernooij, #363)
* Fix parsing of quoted strings in configs. (Jelmer Vernooij, #305)
0.10.1 2015-03-25
BUG FIXES
* Return `ApplyDeltaError` when encountering delta errors
in both C extensions and native delta application code.
(Jelmer Vernooij, #259)
0.10.0 2015-03-22
BUG FIXES
* In dulwich.index.build_index_from_tree, by default
refuse to create entries that start with .git/.
(Jelmer Vernooij, CVE-2014-9706)
* Fix running of testsuite when installed.
(Jelmer Vernooij, #223)
* Use a block cache in _find_content_rename_candidates(),
improving performance. (Mike Williams)
* Add support for ``core.protectNTFS`` setting.
(Jelmer Vernooij)
* Fix TypeError when fetching empty updates.
(Hwee Miin Koh)
* Resolve delta refs when pulling into a MemoryRepo.
(Max Shawabkeh, #256)
* Fix handling of tags of non-commits in missing object finder.
(Augie Fackler, #211)
* Explicitly disable mmap on plan9 where it doesn't work.
(Jeff Sickel)
IMPROVEMENTS
* New public method `Repo.reset_index`. (Jelmer Vernooij)
* Prevent duplicate parsing of loose files in objects
directory when reading. Thanks to David Keijser for the
report. (Jelmer Vernooij, #231)
0.9.9 2015-03-20
SECURITY BUG FIXES
* Fix buffer overflow in C implementation of pack apply_delta().
(CVE-2015-0838)
Thanks to Ivan Fratric of the Google Security Team for
reporting this issue.
(Jelmer Vernooij)
0.9.8 2014-11-30
BUG FIXES
* Various fixes to improve test suite running on Windows.
(Gary van der Merwe)
* Limit delta copy length to 64K in v2 pack files. (Robert Brown)
* Strip newline from final ACKed SHA while fetching packs.
(Michael Edgar)
* Remove assignment to PyList_SIZE() that was causing segfaults on
pypy. (Jelmer Vernooij, #196)
IMPROVEMENTS
* Add porcelain 'receive-pack' and 'upload-pack'. (Jelmer Vernooij)
* Handle SIGINT signals in bin/dulwich. (Jelmer Vernooij)
* Add 'status' support to bin/dulwich. (Jelmer Vernooij)
* Add 'branch_create', 'branch_list', 'branch_delete' porcelain.
(Jelmer Vernooij)
* Add 'fetch' porcelain. (Jelmer Vernooij)
* Add 'tag_delete' porcelain. (Jelmer Vernooij)
* Add support for serializing/deserializing 'gpgsig' attributes in Commit.
(Jelmer Vernooij)
CHANGES
* dul-web is now available as 'dulwich web-daemon'.
(Jelmer Vernooij)
* dulwich.porcelain.tag has been renamed to tag_create.
dulwich.porcelain.list_tags has been renamed to tag_list.
(Jelmer Vernooij)
API CHANGES
* Restore support for Python 2.6. (Jelmer Vernooij, Gary van der Merwe)
0.9.7 2014-06-08
BUG FIXES
* Fix tests dependent on hash ordering. (Michael Edgar)
* Support staging symbolic links in Repo.stage.
(Robert Brown)
* Ensure that all files object are closed when running the test suite.
(Gary van der Merwe)
* When writing OFS_DELTA pack entries, write correct offset.
(Augie Fackler)
* Fix handler of larger copy operations in packs. (Augie Fackler)
* Various fixes to improve test suite running on Windows.
(Gary van der Merwe)
* Fix logic for extra adds of identical files in rename detector.
(Robert Brown)
IMPROVEMENTS
* Add porcelain 'status'. (Ryan Faulkner)
* Add porcelain 'daemon'. (Jelmer Vernooij)
* Add `dulwich.greenthreads` module which provides support
for concurrency of some object store operations.
(Fabien Boucher)
* Various changes to improve compatibility with Python 3.
(Gary van der Merwe, Hannu Valtonen, michael-k)
* Add OpenStack Swift backed repository implementation
in dulwich.contrib. See README.swift for details. (Fabien Boucher)
API CHANGES
* An optional close function can be passed to the Protocol class. This will
be called by its close method. (Gary van der Merwe)
* All classes with close methods are now context managers, so that they can
be easily closed using a `with` statement. (Gary van der Merwe)
* Remove deprecated `num_objects` argument to `write_pack` methods.
(Jelmer Vernooij)
OTHER CHANGES
* The 'dul-daemon' script has been removed. The same functionality
is now available as 'dulwich daemon'. (Jelmer Vernooij)
0.9.6 2014-04-23
IMPROVEMENTS
* Add support for recursive add in 'git add'.
(Ryan Faulkner, Jelmer Vernooij)
* Add porcelain 'list_tags'. (Ryan Faulkner)
* Add porcelain 'push'. (Ryan Faulkner)
* Add porcelain 'pull'. (Ryan Faulkner)
* Support 'http.proxy' in HttpGitClient.
(Jelmer Vernooij, #1096030)
* Support 'http.useragent' in HttpGitClient.
(Jelmer Vernooij)
* In server, wait for clients to send empty list of
wants when talking to empty repository.
(Damien Tournoud)
* Various changes to improve compatibility with
Python 3. (Gary van der Merwe)
BUG FIXES
* Support unseekable 'wsgi.input' streams.
(Jonas Haag)
* Raise TypeError when passing unicode() object
to Repo.__getitem__.
(Jonas Haag)
* Fix handling of `reset` command in dulwich.fastexport.
(Jelmer Vernooij, #1249029)
* In client, don't wait for server to close connection
first. Fixes hang when used against GitHub
server implementation. (Siddharth Agarwal)
* DeltaChainIterator: fix a corner case where an object is inflated as an
object already in the repository.
(Damien Tournoud, #135)
* Stop leaking file handles during pack reload. (Damien Tournoud)
* Avoid reopening packs during pack cache reload. (Jelmer Vernooij)
API CHANGES
* Drop support for Python 2.6. (Jelmer Vernooij)
0.9.5 2014-02-23
IMPROVEMENTS
* Add porcelain 'tag'. (Ryan Faulkner)
* New module `dulwich.objectspec` for parsing strings referencing
objects and commit ranges. (Jelmer Vernooij)
* Add shallow branch support. (milki)
* Allow passing urllib2 `opener` into HttpGitClient.
(Dov Feldstern, #909037)
CHANGES
* Drop support for Python 2.4 and 2.5. (Jelmer Vernooij)
API CHANGES
* Remove long deprecated ``Repo.commit``, ``Repo.get_blob``,
``Repo.tree`` and ``Repo.tag``. (Jelmer Vernooij)
* Remove long deprecated ``Repo.revision_history`` and ``Repo.ref``.
(Jelmer Vernooij)
* Remove long deprecated ``Tree.entries``. (Jelmer Vernooij)
BUG FIXES
* Raise KeyError rather than TypeError when passing in
unicode object of length 20 or 40 to Repo.__getitem__.
(Jelmer Vernooij)
* Use 'rm' rather than 'unlink' in tests, since the latter
does not exist on OpenBSD and other platforms.
(Dmitrij D. Czarkoff)
0.9.4 2013-11-30
IMPROVEMENTS
* Add ssh_kwargs attribute to ParamikoSSHVendor. (milki)
* Add Repo.set_description(). (Víðir Valberg Guðmundsson)
* Add a basic `dulwich.porcelain` module. (Jelmer Vernooij, Marcin Kuzminski)
* Various performance improvements for object access.
(Jelmer Vernooij)
* New function `get_transport_and_path_from_url`,
similar to `get_transport_and_path` but only
supports URLs.
(Jelmer Vernooij)
* Add support for file:// URLs in `get_transport_and_path_from_url`.
(Jelmer Vernooij)
* Add LocalGitClient implementation.
(Jelmer Vernooij)
BUG FIXES
* Support filesystems with 64bit inode and device numbers.
(André Roth)
CHANGES
* Ref handling has been moved to dulwich.refs.
(Jelmer Vernooij)
API CHANGES
* Remove long deprecated RefsContainer.set_ref().
(Jelmer Vernooij)
* Repo.ref() is now deprecated in favour of Repo.refs[].
(Jelmer Vernooij)
FEATURES
* Add support for graftpoints. (milki)
0.9.3 2013-09-27
BUG FIXES
* Fix path for stdint.h in MANIFEST.in. (Jelmer Vernooij)
0.9.2 2013-09-26
BUG FIXES
* Include stdint.h in MANIFEST.in (Mark Mikofski)
0.9.1 2013-09-22
BUG FIXES
* Support lookups of 40-character refs in BaseRepo.__getitem__. (Chow Loong Jin, Jelmer Vernooij)
* Fix fetching packs with side-band-64k capability disabled. (David Keijser, Jelmer Vernooij)
* Several fixes in send-pack protocol behaviour - handling of empty pack files and deletes.
(milki, #1063087)
* Fix capability negotiation when fetching packs over HTTP.
(#1072461, William Grant)
* Enforce determine_wants returning an empty list rather than None. (Fabien Boucher, Jelmer Vernooij)
* In the server, support pushes just removing refs. (Fabien Boucher, Jelmer Vernooij)
IMPROVEMENTS
* Support passing a single revision to BaseRepo.get_walker() rather than a list of revisions.
(Alberto Ruiz)
* Add `Repo.get_description` method. (Jelmer Vernooij)
* Support thin packs in Pack.iterobjects() and Pack.get_raw().
(William Grant)
* Add `MemoryObjectStore.add_pack` and `MemoryObjectStore.add_thin_pack` methods.
(David Bennett)
* Add paramiko-based SSH vendor. (Aaron O'Mullan)
* Support running 'dulwich.server' and 'dulwich.web' using 'python -m'.
(Jelmer Vernooij)
* Add ObjectStore.close(). (Jelmer Vernooij)
* Raise appropriate NotImplementedError when encountering dumb HTTP servers.
(Jelmer Vernooij)
API CHANGES
* SSHVendor.connect_ssh has been renamed to SSHVendor.run_command.
(Jelmer Vernooij)
* ObjectStore.add_pack() now returns a 3-tuple. The last element will be an
abort() method that can be used to cancel the pack operation.
(Jelmer Vernooij)
0.9.0 2013-05-31
BUG FIXES
* Push efficiency - report missing objects only. (#562676, Artem Tikhomirov)
* Use indentation consistent with C Git in config files.
(#1031356, Curt Moore, Jelmer Vernooij)
* Recognize and skip binary files in diff function.
(Takeshi Kanemoto)
* Fix handling of relative paths in dulwich.client.get_transport_and_path.
(Brian Visel, #1169368)
* Preserve ordering of entries in configuration.
(Benjamin Pollack)
* Support ~ expansion in SSH client paths. (milki, #1083439)
* Support relative paths in alternate paths.
(milki, Michel Lespinasse, #1175007)
* Log all error messages from wsgiref server to the logging module. This
makes the test suit quiet again. (Gary van der Merwe)
* Support passing None for empty tree in changes_from_tree.
(Kevin Watters)
* Support fetching empty repository in client. (milki, #1060462)
IMPROVEMENTS:
* Add optional honor_filemode flag to build_index_from_tree.
(Mark Mikofski)
* Support core/filemode setting when building trees. (Jelmer Vernooij)
* Add chapter on tags in tutorial. (Ryan Faulkner)
FEATURES
* Add support for mergetags. (milki, #963525)
* Add support for posix shell hooks. (milki)
0.8.7 2012-11-27
BUG FIXES
* Fix use of alternates in ``DiskObjectStore``.{__contains__,__iter__}.
(Dmitriy)
* Fix compatibility with Python 2.4. (David Carr)
0.8.6 2012-11-09
API CHANGES
* dulwich.__init__ no longer imports client, protocol, repo and
server modules. (Jelmer Vernooij)
FEATURES
* ConfigDict now behaves more like a dictionary.
(Adam 'Cezar' Jenkins, issue #58)
* HTTPGitApplication now takes an optional
`fallback_app` argument. (Jonas Haag, issue #67)
* Support for large pack index files. (Jameson Nash)
TESTING
* Make index entry tests a little bit less strict, to cope with
slightly different behaviour on various platforms.
(Jelmer Vernooij)
* ``setup.py test`` (available when setuptools is installed) now
runs all tests, not just the basic unit tests.
(Jelmer Vernooij)
BUG FIXES
* Commit._deserialize now actually deserializes the current state rather than
the previous one. (Yifan Zhang, issue #59)
* Handle None elements in lists of TreeChange objects. (Alex Holmes)
* Support cloning repositories without HEAD set.
(D-Key, Jelmer Vernooij, issue #69)
* Support ``MemoryRepo.get_config``. (Jelmer Vernooij)
* In ``get_transport_and_path``, pass extra keyword arguments on to
HttpGitClient. (Jelmer Vernooij)
0.8.5 2012-03-29
BUG FIXES
* Avoid use of 'with' in dulwich.index. (Jelmer Vernooij)
* Be a little bit strict about OS behaviour in index tests.
Should fix the tests on Debian GNU/kFreeBSD. (Jelmer Vernooij)
0.8.4 2012-03-28
BUG FIXES
* Options on the same line as sections in config files are now supported.
(Jelmer Vernooij, #920553)
* Only negotiate capabilities that are also supported by the server.
(Rod Cloutier, Risto Kankkunen)
* Fix parsing of invalid timezone offsets with two minus signs.
(Jason R. Coombs, #697828)
* Reset environment variables during tests, to avoid
test isolation leaks reading ~/.gitconfig. (Risto Kankkunen)
TESTS
* $HOME is now explicitly specified for tests that use it to read
``~/.gitconfig``, to prevent test isolation issues.
(Jelmer Vernooij, #920330)
FEATURES
* Additional arguments to get_transport_and_path are now passed
on to the constructor of the transport. (Sam Vilain)
* The WSGI server now transparently handles when a git client submits data
using Content-Encoding: gzip.
(David Blewett, Jelmer Vernooij)
* Add dulwich.index.build_index_from_tree(). (milki)
0.8.3 2012-01-21
FEATURES
* The config parser now supports the git-config file format as
described in git-config(1) and can write git config files.
(Jelmer Vernooij, #531092, #768687)
* ``Repo.do_commit`` will now use the user identity from
.git/config or ~/.gitconfig if none was explicitly specified.
(Jelmer Vernooij)
BUG FIXES
* Allow ``determine_wants`` methods to include the zero sha in their
return value. (Jelmer Vernooij)
0.8.2 2011-12-18
BUG FIXES
* Cope with different zlib buffer sizes in sha1 file parser.
(Jelmer Vernooij)
* Fix get_transport_and_path for HTTP/HTTPS URLs.
(Bruno Renié)
* Avoid calling free_objects() on NULL in error cases. (Chris Eberle)
* Fix use --bare argument to 'dulwich init'. (Chris Eberle)
* Properly abort connections when the determine_wants function
raises an exception. (Jelmer Vernooij, #856769)
* Tweak xcodebuild hack to deal with more error output.
(Jelmer Vernooij, #903840)
FEATURES
* Add support for retrieving tarballs from remote servers.
(Jelmer Vernooij, #379087)
* New method ``update_server_info`` which generates data
for dumb server access. (Jelmer Vernooij, #731235)
0.8.1 2011-10-31
FEATURES
* Repo.do_commit has a new argument 'ref'.
* Repo.do_commit has a new argument 'merge_heads'. (Jelmer Vernooij)
* New ``Repo.get_walker`` method. (Jelmer Vernooij)
* New ``Repo.clone`` method. (Jelmer Vernooij, #725369)
* ``GitClient.send_pack`` now supports the 'side-band-64k' capability.
(Jelmer Vernooij)
* ``HttpGitClient`` which supports the smart server protocol over
HTTP. "dumb" access is not yet supported. (Jelmer Vernooij, #373688)
* Add basic support for alternates. (Jelmer Vernooij, #810429)
CHANGES
* unittest2 or python >= 2.7 is now required for the testsuite.
testtools is no longer supported. (Jelmer Vernooij, #830713)
BUG FIXES
* Fix compilation with older versions of MSVC. (Martin gz)
* Special case 'refs/stash' as a valid ref. (Jelmer Vernooij, #695577)
* Smart protocol clients can now change refs even if they are
not uploading new data. (Jelmer Vernooij, #855993)
* Don't compile C extensions when running in pypy.
(Ronny Pfannschmidt, #881546)
* Use different name for strnlen replacement function to avoid clashing
with system strnlen. (Jelmer Vernooij, #880362)
API CHANGES
* ``Repo.revision_history`` is now deprecated in favor of ``Repo.get_walker``.
(Jelmer Vernooij)
0.8.0 2011-08-07
FEATURES
* New DeltaChainIterator abstract class for quickly iterating all objects in
a pack, with implementations for pack indexing and inflation.
(Dave Borowitz)
* New walk module with a Walker class for customizable commit walking.
(Dave Borowitz)
* New tree_changes_for_merge function in diff_tree. (Dave Borowitz)
* Easy rename detection in RenameDetector even without find_copies_harder.
(Dave Borowitz)
BUG FIXES
* Avoid storing all objects in memory when writing pack.
(Jelmer Vernooij, #813268)
* Support IPv6 for git:// connections. (Jelmer Vernooij, #801543)
* Improve performance of Repo.revision_history(). (Timo Schmid, #535118)
* Fix use of SubprocessWrapper on Windows. (Paulo Madeira, #670035)
* Fix compilation on newer versions of Mac OS X (Lion and up). (Ryan McKern, #794543)
* Prevent raising ValueError for correct refs in RefContainer.__delitem__.
* Correctly return a tuple from MemoryObjectStore.get_raw. (Dave Borowitz)
* Fix a bug in reading the pack checksum when there are fewer than 20 bytes
left in the buffer. (Dave Borowitz)
* Support ~ in git:// URL paths. (Jelmer Vernooij, #813555)
* Make ShaFile.__eq__ work when other is not a ShaFile. (Dave Borowitz)
* ObjectStore.get_graph_walker() now no longer yields the same
revision more than once. This has a significant improvement for
performance when wide revision graphs are involved.
(Jelmer Vernooij, #818168)
* Teach ReceivePackHandler how to read empty packs. (Dave Borowitz)
* Don't send a pack with duplicates of the same object. (Dave Borowitz)
* Teach the server how to serve a clone of an empty repo. (Dave Borowitz)
* Correctly advertise capabilities during receive-pack. (Dave Borowitz)
* Fix add/add and add/rename conflicts in tree_changes_for_merge.
(Dave Borowitz)
* Use correct MIME types in web server. (Dave Borowitz)
API CHANGES
* write_pack no longer takes the num_objects argument and requires an object
to be passed in that is iterable (rather than an iterator) and that
provides __len__. (Jelmer Vernooij)
* write_pack_data has been renamed to write_pack_objects and no longer takes a
num_objects argument. (Jelmer Vernooij)
* take_msb_bytes, read_zlib_chunks, unpack_objects, and
PackStreamReader.read_objects now take an additional argument indicating a
crc32 to compute. (Dave Borowitz)
* PackObjectIterator was removed; its functionality is still exposed by
PackData.iterobjects. (Dave Borowitz)
* Add a sha arg to write_pack_object to incrementally compute a SHA.
(Dave Borowitz)
* Include offset in PackStreamReader results. (Dave Borowitz)
* Move PackStreamReader from server to pack. (Dave Borowitz)
* Extract a check_length_and_checksum, compute_file_sha, and
pack_object_header pack helper functions. (Dave Borowitz)
* Extract a compute_file_sha function. (Dave Borowitz)
* Remove move_in_thin_pack as a separate method; add_thin_pack now completes
the thin pack and moves it in in one step. Remove ThinPackData as well.
(Dave Borowitz)
* Custom buffer size in read_zlib_chunks. (Dave Borowitz)
* New UnpackedObject data class that replaces ad-hoc tuples in the return
value of unpack_object and various DeltaChainIterator methods.
(Dave Borowitz)
* Add a lookup_path convenience method to Tree. (Dave Borowitz)
* Optionally create RenameDetectors without passing in tree SHAs.
(Dave Borowitz)
* Optionally include unchanged entries in RenameDetectors. (Dave Borowitz)
* Optionally pass a RenameDetector to tree_changes. (Dave Borowitz)
* Optionally pass a request object through to server handlers. (Dave Borowitz)
TEST CHANGES
* If setuptools is installed, "python setup.py test" will now run the testsuite.
(Jelmer Vernooij)
* Add a new build_pack test utility for building packs from a simple spec.
(Dave Borowitz)
* Add a new build_commit_graph test utility for building commits from a
simple spec. (Dave Borowitz)
0.7.1 2011-04-12
BUG FIXES
* Fix double decref in _diff_tree.c. (Ted Horst, #715528)
* Fix the build on Windows. (Pascal Quantin)
* Fix get_transport_and_path compatibility with pre-2.6.5 versions of Python.
(Max Bowsher, #707438)
* BaseObjectStore.determine_wants_all no longer breaks on zero SHAs.
(Jelmer Vernooij)
* write_tree_diff() now supports submodules.
(Jelmer Vernooij)
* Fix compilation for XCode 4 and older versions of distutils.sysconfig.
(Daniele Sluijters)
IMPROVEMENTS
* Sphinxified documentation. (Lukasz Balcerzak)
* Add Pack.keep.(Marc Brinkmann)
API CHANGES
* The order of the parameters to Tree.add(name, mode, sha) has changed, and
is now consistent with the rest of Dulwich. Existing code will still
work but print a DeprecationWarning. (Jelmer Vernooij, #663550)
* Tree.entries() is now deprecated in favour of Tree.items() and
Tree.iteritems(). (Jelmer Vernooij)
0.7.0 2011-01-21
FEATURES
* New `dulwich.diff_tree` module for simple content-based rename detection.
(Dave Borowitz)
* Add Tree.items(). (Jelmer Vernooij)
* Add eof() and unread_pkt_line() methods to Protocol. (Dave Borowitz)
* Add write_tree_diff(). (Jelmer Vernooij)
* Add `serve_command` function for git server commands as executables.
(Jelmer Vernooij)
* dulwich.client.get_transport_and_path now supports rsync-style repository URLs.
(Dave Borowitz, #568493)
BUG FIXES
* Correct short-circuiting operation for no-op fetches in the server.
(Dave Borowitz)
* Support parsing git mbox patches without a version tail, as generated by
Mercurial. (Jelmer Vernooij)
* Fix dul-receive-pack and dul-upload-pack. (Jelmer Vernooij)
* Zero-padded file modes in Tree objects no longer trigger an exception but
the check code warns about them. (Augie Fackler, #581064)
* Repo.init() now honors the mkdir flag. (#671159)
* The ref format is now checked when setting a ref rather than when reading it back.
(Dave Borowitz, #653527)
* Make sure pack files are closed correctly. (Tay Ray Chuan)
DOCUMENTATION
* Run the tutorial inside the test suite. (Jelmer Vernooij)
* Reorganized and updated the tutorial. (Jelmer Vernooij, Dave Borowitz, #610550,
#610540)
0.6.2 2010-10-16
BUG FIXES
* HTTP server correctly handles empty CONTENT_LENGTH. (Dave Borowitz)
* Don't error when creating GitFiles with the default mode. (Dave Borowitz)
* ThinPackData.from_file now works with resolve_ext_ref callback.
(Dave Borowitz)
* Provide strnlen() on mingw32 which doesn't have it. (Hans Kolek)
* Set bare=true in the configuratin for bare repositories. (Dirk Neumann)
FEATURES
* Use slots for core objects to save up on memory. (Jelmer Vernooij)
* Web server supports streaming progress/pack output. (Dave Borowitz)
* New public function dulwich.pack.write_pack_header. (Dave Borowitz)
* Distinguish between missing files and read errors in HTTP server.
(Dave Borowitz)
* Initial work on support for fastimport using python-fastimport.
(Jelmer Vernooij)
* New dulwich.pack.MemoryPackIndex class. (Jelmer Vernooij)
* Delegate SHA peeling to the object store. (Dave Borowitz)
TESTS
* Use GitFile when modifying packed-refs in tests. (Dave Borowitz)
* New tests in test_web with better coverage and fewer ad-hoc mocks.
(Dave Borowitz)
* Standardize quote delimiters in test_protocol. (Dave Borowitz)
* Fix use when testtools is installed. (Jelmer Vernooij)
* Add trivial test for write_pack_header. (Jelmer Vernooij)
* Refactor some of dulwich.tests.compat.server_utils. (Dave Borowitz)
* Allow overwriting id property of objects in test utils. (Dave Borowitz)
* Use real in-memory objects rather than stubs for server tests.
(Dave Borowitz)
* Clean up MissingObjectFinder. (Dave Borowitz)
API CHANGES
* ObjectStore.iter_tree_contents now walks contents in depth-first, sorted
order. (Dave Borowitz)
* ObjectStore.iter_tree_contents can optionally yield tree objects as well.
(Dave Borowitz).
* Add side-band-64k support to ReceivePackHandler. (Dave Borowitz)
* Change server capabilities methods to classmethods. (Dave Borowitz)
* Tweak server handler injection. (Dave Borowitz)
* PackIndex1 and PackIndex2 now subclass FilePackIndex, which is
itself a subclass of PackIndex. (Jelmer Vernooij)
DOCUMENTATION
* Add docstrings for various functions in dulwich.objects. (Jelmer Vernooij)
* Clean up docstrings in dulwich.protocol. (Dave Borowitz)
* Explicitly specify allowed protocol commands to
ProtocolGraphWalker.read_proto_line. (Dave Borowitz)
* Add utility functions to DictRefsContainer. (Dave Borowitz)
0.6.1 2010-07-22
BUG FIXES
* Fix memory leak in C implementation of sorted_tree_items. (Dave Borowitz)
* Use correct path separators for named repo files. (Dave Borowitz)
* python > 2.7 and testtools-based test runners will now also pick up skipped
tests correctly. (Jelmer Vernooij)
FEATURES
* Move named file initilization to BaseRepo. (Dave Borowitz)
* Add logging utilities and git/HTTP server logging. (Dave Borowitz)
* The GitClient interface has been cleaned up and instances are now reusable.
(Augie Fackler)
* Allow overriding paths to executables in GitSSHClient.
(Ross Light, Jelmer Vernooij, #585204)
* Add PackBasedObjectStore.pack_loose_objects(). (Jelmer Vernooij)
TESTS
* Add tests for sorted_tree_items and C implementation. (Dave Borowitz)
* Add a MemoryRepo that stores everything in memory. (Dave Borowitz)
* Quiet logging output from web tests. (Dave Borowitz)
* More flexible version checking for compat tests. (Dave Borowitz)
* Compat tests for servers with and without side-band-64k. (Dave Borowitz)
CLEANUP
* Clean up file headers. (Dave Borowitz)
TESTS
* Use GitFile when modifying packed-refs in tests. (Dave Borowitz)
API CHANGES
* dulwich.pack.write_pack_index_v{1,2} now take a file-like object
rather than a filename. (Jelmer Vernooij)
* Make dul-daemon/dul-web trivial wrappers around server functionality.
(Dave Borowitz)
* Move reference WSGI handler to web.py. (Dave Borowitz)
* Factor out _report_status in ReceivePackHandler. (Dave Borowitz)
* Factor out a function to convert a line to a pkt-line. (Dave Borowitz)
0.6.0 2010-05-22
note: This list is most likely incomplete for 0.6.0.
BUG FIXES
* Fix ReceivePackHandler to disallow removing refs without delete-refs.
(Dave Borowitz)
* Deal with capabilities required by the client, even if they
can not be disabled in the server. (Dave Borowitz)
* Fix trailing newlines in generated patch files.
(Jelmer Vernooij)
* Implement RefsContainer.__contains__. (Jelmer Vernooij)
* Cope with \r in ref files on Windows. (
http://github.com/jelmer/dulwich/issues/#issue/13, Jelmer Vernooij)
* Fix GitFile breakage on Windows. (Anatoly Techtonik, #557585)
* Support packed ref deletion with no peeled refs. (Augie Fackler)
* Fix send pack when there is nothing to fetch. (Augie Fackler)
* Fix fetch if no progress function is specified. (Augie Fackler)
* Allow double-staging of files that are deleted in the index.
(Dave Borowitz)
* Fix RefsContainer.add_if_new to support dangling symrefs.
(Dave Borowitz)
* Non-existant index files in non-bare repositories are now treated as
empty. (Dave Borowitz)
* Always update ShaFile.id when the contents of the object get changed.
(Jelmer Vernooij)
* Various Python2.4-compatibility fixes. (Dave Borowitz)
* Fix thin pack handling. (Dave Borowitz)
FEATURES
* Add include-tag capability to server. (Dave Borowitz)
* New dulwich.fastexport module that can generate fastexport
streams. (Jelmer Vernooij)
* Implemented BaseRepo.__contains__. (Jelmer Vernooij)
* Add __setitem__ to DictRefsContainer. (Dave Borowitz)
* Overall improvements checking Git objects. (Dave Borowitz)
* Packs are now verified while they are received. (Dave Borowitz)
TESTS
* Add framework for testing compatibility with C Git. (Dave Borowitz)
* Add various tests for the use of non-bare repositories. (Dave Borowitz)
* Cope with diffstat not being available on all platforms.
(Tay Ray Chuan, Jelmer Vernooij)
* Add make_object and make_commit convenience functions to test utils.
(Dave Borowitz)
API BREAKAGES
* The 'committer' and 'message' arguments to Repo.do_commit() have
been swapped. 'committer' is now optional. (Jelmer Vernooij)
* Repo.get_blob, Repo.commit, Repo.tag and Repo.tree are now deprecated.
(Jelmer Vernooij)
* RefsContainer.set_ref() was renamed to RefsContainer.set_symbolic_ref(),
for clarity. (Jelmer Vernooij)
API CHANGES
* The primary serialization APIs in dulwich.objects now work
with chunks of strings rather than with full-text strings.
(Jelmer Vernooij)
0.5.02010-03-03
BUG FIXES
* Support custom fields in commits (readonly). (Jelmer Vernooij)
* Improved ref handling. (Dave Borowitz)
* Rework server protocol to be smarter and interoperate with cgit client.
(Dave Borowitz)
* Add a GitFile class that uses the same locking protocol for writes as
cgit. (Dave Borowitz)
* Cope with forward slashes correctly in the index on Windows.
(Jelmer Vernooij, #526793)
FEATURES
* --pure option to setup.py to allow building/installing without the C
extensions. (Hal Wine, Anatoly Techtonik, Jelmer Vernooij, #434326)
* Implement Repo.get_config(). (Jelmer Vernooij, Augie Fackler)
* HTTP dumb and smart server. (Dave Borowitz)
* Add abstract baseclass for Repo that does not require file system
operations. (Dave Borowitz)
0.4.1 2010-01-03
FEATURES
* Add ObjectStore.iter_tree_contents(). (Jelmer Vernooij)
* Add Index.changes_from_tree(). (Jelmer Vernooij)
* Add ObjectStore.tree_changes(). (Jelmer Vernooij)
* Add functionality for writing patches in dulwich.patch.
(Jelmer Vernooij)
0.4.0 2009-10-07
DOCUMENTATION
* Added tutorial.
API CHANGES
* dulwich.object_store.tree_lookup_path will now return the mode and
sha of the object found rather than the object itself.
BUG FIXES
* Use binascii.hexlify / binascii.unhexlify for better performance.
* Cope with extra unknown data in index files by ignoring it (for now).
* Add proper error message when server unexpectedly hangs up. (#415843)
* Correctly write opcode for equal in create_delta.
0.3.3 2009-07-23
FEATURES
* Implement ShaFile.__hash__().
* Implement Tree.__len__()
BUG FIXES
* Check for 'objects' and 'refs' directories
when looking for a Git repository. (#380818)
0.3.2 2009-05-20
BUG FIXES
* Support the encoding field in Commits.
* Some Windows compatibility fixes.
* Fixed several issues in commit support.
FEATURES
* Basic support for handling submodules.
0.3.1 2009-05-13
FEATURES
* Implemented Repo.__getitem__, Repo.__setitem__ and Repo.__delitem__ to
access content.
API CHANGES
* Removed Repo.set_ref, Repo.remove_ref, Repo.tags, Repo.get_refs and
Repo.heads in favor of Repo.refs, a dictionary-like object for accessing
refs.
BUG FIXES
* Removed import of 'sha' module in objects.py, which was causing
deprecation warnings on Python 2.6.
0.3.0 2009-05-10
FEATURES
* A new function 'commit_tree' has been added that can commit a tree
based on an index.
BUG FIXES
* The memory usage when generating indexes has been significantly reduced.
* A memory leak in the C implementation of parse_tree has been fixed.
* The send-pack smart server command now works. (Thanks Scott Chacon)
* The handling of short timestamps (less than 10 digits) has been fixed.
* The handling of timezones has been fixed.
0.2.1 2009-04-30
BUG FIXES
* Fix compatibility with Python2.4.
0.2.0 2009-04-30
FEATURES
* Support for activity reporting in smart protocol client.
* Optional C extensions for better performance in a couple of
places that are performance-critical.
0.1.1 2009-03-13
BUG FIXES
* Fixed regression in Repo.find_missing_objects()
* Don't fetch ^{} objects from remote hosts, as requesting them
causes a hangup.
* Always write pack to disk completely before calculating checksum.
FEATURES
* Allow disabling thin packs when talking to remote hosts.
0.1.0 2009-01-24
* Initial release.
diff --git a/PKG-INFO b/PKG-INFO
index 4433a294..3f3f472b 100644
--- a/PKG-INFO
+++ b/PKG-INFO
@@ -1,127 +1,127 @@
Metadata-Version: 2.1
Name: dulwich
-Version: 0.20.26
+Version: 0.20.27
Summary: Python Git Library
Home-page: https://www.dulwich.io/
Author: Jelmer Vernooij
Author-email: jelmer@jelmer.uk
License: Apachev2 or later or GPLv2
Project-URL: Bug Tracker, https://github.com/dulwich/dulwich/issues
Project-URL: Repository, https://www.dulwich.io/code/
Project-URL: GitHub, https://github.com/dulwich/dulwich
Keywords: git vcs
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Operating System :: POSIX
Classifier: Operating System :: Microsoft :: Windows
Classifier: Topic :: Software Development :: Version Control
Requires-Python: >=3.6
Provides-Extra: fastimport
Provides-Extra: https
Provides-Extra: pgp
Provides-Extra: watch
License-File: COPYING
License-File: AUTHORS
Dulwich
=======
This is the Dulwich project.
It aims to provide an interface to git repos (both local and remote) that
doesn't call out to git directly but instead uses pure Python.
**Main website**: <https://www.dulwich.io/>
**License**: Apache License, version 2 or GNU General Public License, version 2 or later.
The project is named after the part of London that Mr. and Mrs. Git live in
in the particular Monty Python sketch.
Installation
------------
By default, Dulwich' setup.py will attempt to build and install the optional C
extensions. The reason for this is that they significantly improve the performance
since some low-level operations that are executed often are much slower in CPython.
If you don't want to install the C bindings, specify the --pure argument to setup.py::
$ python setup.py --pure install
or if you are installing from pip::
$ pip install dulwich --global-option="--pure"
Note that you can also specify --global-option in a
`requirements.txt <https://pip.pypa.io/en/stable/reference/pip_install/#requirement-specifiers>`_
file, e.g. like this::
dulwich --global-option=--pure
Getting started
---------------
Dulwich comes with both a lower-level API and higher-level plumbing ("porcelain").
For example, to use the lower level API to access the commit message of the
last commit::
>>> from dulwich.repo import Repo
>>> r = Repo('.')
>>> r.head()
'57fbe010446356833a6ad1600059d80b1e731e15'
>>> c = r[r.head()]
>>> c
<Commit 015fc1267258458901a94d228e39f0a378370466>
>>> c.message
'Add note about encoding.\n'
And to print it using porcelain::
>>> from dulwich import porcelain
>>> porcelain.log('.', max_entries=1)
--------------------------------------------------
commit: 57fbe010446356833a6ad1600059d80b1e731e15
Author: Jelmer Vernooij <jelmer@jelmer.uk>
Date: Sat Apr 29 2017 23:57:34 +0000
Add note about encoding.
Further documentation
---------------------
The dulwich documentation can be found in docs/ and built by running ``make
doc``. It can also be found `on the web <https://www.dulwich.io/docs/>`_.
Help
----
There is a *#dulwich* IRC channel on the `OFTC <https://www.oftc.net/>`_, and
`dulwich-announce <https://groups.google.com/forum/#!forum/dulwich-announce>`_
and `dulwich-discuss <https://groups.google.com/forum/#!forum/dulwich-discuss>`_
mailing lists.
Contributing
------------
For a full list of contributors, see the git logs or `AUTHORS <AUTHORS>`_.
If you'd like to contribute to Dulwich, see the `CONTRIBUTING <CONTRIBUTING.rst>`_
file and `list of open issues <https://github.com/dulwich/dulwich/issues>`_.
Supported versions of Python
----------------------------
At the moment, Dulwich supports (and is tested on) CPython 3.6 and later and
Pypy.
diff --git a/dulwich.egg-info/PKG-INFO b/dulwich.egg-info/PKG-INFO
index 4433a294..3f3f472b 100644
--- a/dulwich.egg-info/PKG-INFO
+++ b/dulwich.egg-info/PKG-INFO
@@ -1,127 +1,127 @@
Metadata-Version: 2.1
Name: dulwich
-Version: 0.20.26
+Version: 0.20.27
Summary: Python Git Library
Home-page: https://www.dulwich.io/
Author: Jelmer Vernooij
Author-email: jelmer@jelmer.uk
License: Apachev2 or later or GPLv2
Project-URL: Bug Tracker, https://github.com/dulwich/dulwich/issues
Project-URL: Repository, https://www.dulwich.io/code/
Project-URL: GitHub, https://github.com/dulwich/dulwich
Keywords: git vcs
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Operating System :: POSIX
Classifier: Operating System :: Microsoft :: Windows
Classifier: Topic :: Software Development :: Version Control
Requires-Python: >=3.6
Provides-Extra: fastimport
Provides-Extra: https
Provides-Extra: pgp
Provides-Extra: watch
License-File: COPYING
License-File: AUTHORS
Dulwich
=======
This is the Dulwich project.
It aims to provide an interface to git repos (both local and remote) that
doesn't call out to git directly but instead uses pure Python.
**Main website**: <https://www.dulwich.io/>
**License**: Apache License, version 2 or GNU General Public License, version 2 or later.
The project is named after the part of London that Mr. and Mrs. Git live in
in the particular Monty Python sketch.
Installation
------------
By default, Dulwich' setup.py will attempt to build and install the optional C
extensions. The reason for this is that they significantly improve the performance
since some low-level operations that are executed often are much slower in CPython.
If you don't want to install the C bindings, specify the --pure argument to setup.py::
$ python setup.py --pure install
or if you are installing from pip::
$ pip install dulwich --global-option="--pure"
Note that you can also specify --global-option in a
`requirements.txt <https://pip.pypa.io/en/stable/reference/pip_install/#requirement-specifiers>`_
file, e.g. like this::
dulwich --global-option=--pure
Getting started
---------------
Dulwich comes with both a lower-level API and higher-level plumbing ("porcelain").
For example, to use the lower level API to access the commit message of the
last commit::
>>> from dulwich.repo import Repo
>>> r = Repo('.')
>>> r.head()
'57fbe010446356833a6ad1600059d80b1e731e15'
>>> c = r[r.head()]
>>> c
<Commit 015fc1267258458901a94d228e39f0a378370466>
>>> c.message
'Add note about encoding.\n'
And to print it using porcelain::
>>> from dulwich import porcelain
>>> porcelain.log('.', max_entries=1)
--------------------------------------------------
commit: 57fbe010446356833a6ad1600059d80b1e731e15
Author: Jelmer Vernooij <jelmer@jelmer.uk>
Date: Sat Apr 29 2017 23:57:34 +0000
Add note about encoding.
Further documentation
---------------------
The dulwich documentation can be found in docs/ and built by running ``make
doc``. It can also be found `on the web <https://www.dulwich.io/docs/>`_.
Help
----
There is a *#dulwich* IRC channel on the `OFTC <https://www.oftc.net/>`_, and
`dulwich-announce <https://groups.google.com/forum/#!forum/dulwich-announce>`_
and `dulwich-discuss <https://groups.google.com/forum/#!forum/dulwich-discuss>`_
mailing lists.
Contributing
------------
For a full list of contributors, see the git logs or `AUTHORS <AUTHORS>`_.
If you'd like to contribute to Dulwich, see the `CONTRIBUTING <CONTRIBUTING.rst>`_
file and `list of open issues <https://github.com/dulwich/dulwich/issues>`_.
Supported versions of Python
----------------------------
At the moment, Dulwich supports (and is tested on) CPython 3.6 and later and
Pypy.
diff --git a/dulwich.egg-info/SOURCES.txt b/dulwich.egg-info/SOURCES.txt
index 75bc62eb..a9f8ea6e 100644
--- a/dulwich.egg-info/SOURCES.txt
+++ b/dulwich.egg-info/SOURCES.txt
@@ -1,243 +1,254 @@
.coveragerc
.deepsource.toml
.flake8
.gitignore
.mailmap
+.stestr.conf
.testr.conf
AUTHORS
CODE_OF_CONDUCT.md
CONTRIBUTING.rst
COPYING
MANIFEST.in
Makefile
NEWS
README.rst
README.swift.rst
SECURITY.md
TODO
dulwich.cfg
releaser.conf
requirements.txt
setup.cfg
setup.py
status.yaml
tox.ini
.github/workflows/pythonpackage.yml
.github/workflows/pythonpublish.yml
bin/dul-receive-pack
bin/dul-upload-pack
bin/dulwich
devscripts/PREAMBLE.c
devscripts/PREAMBLE.py
devscripts/replace-preamble.sh
docs/Makefile
docs/conf.py
docs/index.txt
docs/make.bat
docs/performance.txt
docs/protocol.txt
docs/api/index.txt
docs/tutorial/.gitignore
docs/tutorial/Makefile
docs/tutorial/conclusion.txt
docs/tutorial/encoding.txt
docs/tutorial/file-format.txt
docs/tutorial/index.txt
docs/tutorial/introduction.txt
docs/tutorial/object-store.txt
docs/tutorial/porcelain.txt
docs/tutorial/remote.txt
docs/tutorial/repo.txt
docs/tutorial/tag.txt
dulwich/__init__.py
dulwich/__main__.py
dulwich/_diff_tree.c
dulwich/_objects.c
dulwich/_pack.c
dulwich/archive.py
dulwich/bundle.py
dulwich/cli.py
dulwich/client.py
dulwich/config.py
dulwich/diff_tree.py
dulwich/errors.py
dulwich/fastexport.py
dulwich/file.py
dulwich/graph.py
dulwich/greenthreads.py
dulwich/hooks.py
dulwich/ignore.py
dulwich/index.py
dulwich/lfs.py
dulwich/line_ending.py
dulwich/log_utils.py
dulwich/lru_cache.py
dulwich/mailmap.py
dulwich/object_store.py
dulwich/objects.py
dulwich/objectspec.py
dulwich/pack.py
dulwich/patch.py
dulwich/porcelain.py
dulwich/protocol.py
dulwich/py.typed
dulwich/reflog.py
dulwich/refs.py
dulwich/repo.py
dulwich/server.py
dulwich/stash.py
dulwich/stdint.h
dulwich/walk.py
dulwich/web.py
dulwich.egg-info/PKG-INFO
dulwich.egg-info/SOURCES.txt
dulwich.egg-info/dependency_links.txt
dulwich.egg-info/entry_points.txt
dulwich.egg-info/not-zip-safe
dulwich.egg-info/requires.txt
dulwich.egg-info/top_level.txt
+dulwich/../docs/tutorial/conclusion.txt
+dulwich/../docs/tutorial/encoding.txt
+dulwich/../docs/tutorial/file-format.txt
+dulwich/../docs/tutorial/index.txt
+dulwich/../docs/tutorial/introduction.txt
+dulwich/../docs/tutorial/object-store.txt
+dulwich/../docs/tutorial/porcelain.txt
+dulwich/../docs/tutorial/remote.txt
+dulwich/../docs/tutorial/repo.txt
+dulwich/../docs/tutorial/tag.txt
dulwich/cloud/__init__.py
dulwich/cloud/gcs.py
dulwich/contrib/README.md
dulwich/contrib/__init__.py
dulwich/contrib/diffstat.py
dulwich/contrib/paramiko_vendor.py
dulwich/contrib/release_robot.py
dulwich/contrib/swift.py
dulwich/contrib/test_paramiko_vendor.py
dulwich/contrib/test_release_robot.py
dulwich/contrib/test_swift.py
dulwich/contrib/test_swift_smoke.py
dulwich/tests/__init__.py
dulwich/tests/test_archive.py
dulwich/tests/test_blackbox.py
dulwich/tests/test_bundle.py
dulwich/tests/test_client.py
dulwich/tests/test_config.py
dulwich/tests/test_diff_tree.py
dulwich/tests/test_fastexport.py
dulwich/tests/test_file.py
dulwich/tests/test_grafts.py
dulwich/tests/test_graph.py
dulwich/tests/test_greenthreads.py
dulwich/tests/test_hooks.py
dulwich/tests/test_ignore.py
dulwich/tests/test_index.py
dulwich/tests/test_lfs.py
dulwich/tests/test_line_ending.py
dulwich/tests/test_lru_cache.py
dulwich/tests/test_mailmap.py
dulwich/tests/test_missing_obj_finder.py
dulwich/tests/test_object_store.py
dulwich/tests/test_objects.py
dulwich/tests/test_objectspec.py
dulwich/tests/test_pack.py
dulwich/tests/test_patch.py
dulwich/tests/test_porcelain.py
dulwich/tests/test_protocol.py
dulwich/tests/test_reflog.py
dulwich/tests/test_refs.py
dulwich/tests/test_repository.py
dulwich/tests/test_server.py
dulwich/tests/test_stash.py
dulwich/tests/test_utils.py
dulwich/tests/test_walk.py
dulwich/tests/test_web.py
dulwich/tests/utils.py
dulwich/tests/compat/__init__.py
dulwich/tests/compat/server_utils.py
dulwich/tests/compat/test_client.py
dulwich/tests/compat/test_pack.py
dulwich/tests/compat/test_patch.py
dulwich/tests/compat/test_porcelain.py
dulwich/tests/compat/test_repository.py
dulwich/tests/compat/test_server.py
dulwich/tests/compat/test_utils.py
dulwich/tests/compat/test_web.py
dulwich/tests/compat/utils.py
dulwich/tests/data/blobs/11/11111111111111111111111111111111111111
dulwich/tests/data/blobs/6f/670c0fb53f9463760b7295fbb814e965fb20c8
dulwich/tests/data/blobs/95/4a536f7819d40e6f637f849ee187dd10066349
dulwich/tests/data/blobs/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391
dulwich/tests/data/commits/0d/89f20333fbb1d2f3a94da77f4981373d8f4310
dulwich/tests/data/commits/5d/ac377bdded4c9aeb8dff595f0faeebcc8498cc
dulwich/tests/data/commits/60/dacdc733de308bb77bb76ce0fb0f9b44c9769e
dulwich/tests/data/indexes/index
dulwich/tests/data/packs/pack-bc63ddad95e7321ee734ea11a7a62d314e0d7481.idx
dulwich/tests/data/packs/pack-bc63ddad95e7321ee734ea11a7a62d314e0d7481.pack
dulwich/tests/data/repos/.gitattributes
dulwich/tests/data/repos/issue88_expect_ack_nak_client.export
dulwich/tests/data/repos/issue88_expect_ack_nak_other.export
dulwich/tests/data/repos/issue88_expect_ack_nak_server.export
dulwich/tests/data/repos/server_new.export
dulwich/tests/data/repos/server_old.export
dulwich/tests/data/repos/a.git/HEAD
dulwich/tests/data/repos/a.git/packed-refs
dulwich/tests/data/repos/a.git/objects/28/237f4dc30d0d462658d6b937b08a0f0b6ef55a
dulwich/tests/data/repos/a.git/objects/2a/72d929692c41d8554c07f6301757ba18a65d91
dulwich/tests/data/repos/a.git/objects/4e/f30bbfe26431a69c3820d3a683df54d688f2ec
dulwich/tests/data/repos/a.git/objects/4f/2e6529203aa6d44b5af6e3292c837ceda003f9
dulwich/tests/data/repos/a.git/objects/7d/9a07d797595ef11344549b8d08198e48c15364
dulwich/tests/data/repos/a.git/objects/a2/96d0bb611188cabb256919f36bc30117cca005
dulwich/tests/data/repos/a.git/objects/a9/0fa2d900a17e99b433217e988c4eb4a2e9a097
dulwich/tests/data/repos/a.git/objects/b0/931cadc54336e78a1d980420e3268903b57a50
dulwich/tests/data/repos/a.git/objects/ff/d47d45845a8f6576491e1edb97e3fe6a850e7f
dulwich/tests/data/repos/a.git/refs/heads/master
dulwich/tests/data/repos/a.git/refs/tags/mytag
dulwich/tests/data/repos/empty.git/HEAD
dulwich/tests/data/repos/empty.git/config
dulwich/tests/data/repos/empty.git/objects/info/.gitignore
dulwich/tests/data/repos/empty.git/objects/pack/.gitignore
dulwich/tests/data/repos/empty.git/refs/heads/.gitignore
dulwich/tests/data/repos/empty.git/refs/tags/.gitignore
dulwich/tests/data/repos/ooo_merge.git/HEAD
dulwich/tests/data/repos/ooo_merge.git/objects/29/69be3e8ee1c0222396a5611407e4769f14e54b
dulwich/tests/data/repos/ooo_merge.git/objects/38/74e9c60a6d149c44c928140f250d81e6381520
dulwich/tests/data/repos/ooo_merge.git/objects/6f/670c0fb53f9463760b7295fbb814e965fb20c8
dulwich/tests/data/repos/ooo_merge.git/objects/70/c190eb48fa8bbb50ddc692a17b44cb781af7f6
dulwich/tests/data/repos/ooo_merge.git/objects/76/01d7f6231db6a57f7bbb79ee52e4d462fd44d1
dulwich/tests/data/repos/ooo_merge.git/objects/90/182552c4a85a45ec2a835cadc3451bebdfe870
dulwich/tests/data/repos/ooo_merge.git/objects/95/4a536f7819d40e6f637f849ee187dd10066349
dulwich/tests/data/repos/ooo_merge.git/objects/b2/a2766a2879c209ab1176e7e778b81ae422eeaa
dulwich/tests/data/repos/ooo_merge.git/objects/f5/07291b64138b875c28e03469025b1ea20bc614
dulwich/tests/data/repos/ooo_merge.git/objects/f9/e39b120c68182a4ba35349f832d0e4e61f485c
dulwich/tests/data/repos/ooo_merge.git/objects/fb/5b0425c7ce46959bec94d54b9a157645e114f5
dulwich/tests/data/repos/ooo_merge.git/refs/heads/master
dulwich/tests/data/repos/refs.git/HEAD
dulwich/tests/data/repos/refs.git/packed-refs
dulwich/tests/data/repos/refs.git/objects/3b/9e5457140e738c2dcd39bf6d7acf88379b90d1
dulwich/tests/data/repos/refs.git/objects/3e/c9c43c84ff242e3ef4a9fc5bc111fd780a76a8
dulwich/tests/data/repos/refs.git/objects/42/d06bd4b77fed026b154d16493e5deab78f02ec
dulwich/tests/data/repos/refs.git/objects/a1/8114c31713746a33a2e70d9914d1ef3e781425
dulwich/tests/data/repos/refs.git/objects/cd/a609072918d7b70057b6bef9f4c2537843fcfe
dulwich/tests/data/repos/refs.git/objects/df/6800012397fb85c56e7418dd4eb9405dee075c
dulwich/tests/data/repos/refs.git/refs/heads/40-char-ref-aaaaaaaaaaaaaaaaaa
dulwich/tests/data/repos/refs.git/refs/heads/loop
dulwich/tests/data/repos/refs.git/refs/heads/master
dulwich/tests/data/repos/refs.git/refs/tags/refs-0.2
dulwich/tests/data/repos/simple_merge.git/HEAD
dulwich/tests/data/repos/simple_merge.git/objects/0d/89f20333fbb1d2f3a94da77f4981373d8f4310
dulwich/tests/data/repos/simple_merge.git/objects/1b/6318f651a534b38f9c7aedeebbd56c1e896853
dulwich/tests/data/repos/simple_merge.git/objects/29/69be3e8ee1c0222396a5611407e4769f14e54b
dulwich/tests/data/repos/simple_merge.git/objects/4c/ffe90e0a41ad3f5190079d7c8f036bde29cbe6
dulwich/tests/data/repos/simple_merge.git/objects/5d/ac377bdded4c9aeb8dff595f0faeebcc8498cc
dulwich/tests/data/repos/simple_merge.git/objects/60/dacdc733de308bb77bb76ce0fb0f9b44c9769e
dulwich/tests/data/repos/simple_merge.git/objects/6f/670c0fb53f9463760b7295fbb814e965fb20c8
dulwich/tests/data/repos/simple_merge.git/objects/70/c190eb48fa8bbb50ddc692a17b44cb781af7f6
dulwich/tests/data/repos/simple_merge.git/objects/90/182552c4a85a45ec2a835cadc3451bebdfe870
dulwich/tests/data/repos/simple_merge.git/objects/95/4a536f7819d40e6f637f849ee187dd10066349
dulwich/tests/data/repos/simple_merge.git/objects/ab/64bbdcc51b170d21588e5c5d391ee5c0c96dfd
dulwich/tests/data/repos/simple_merge.git/objects/d4/bdad6549dfedf25d3b89d21f506aff575b28a7
dulwich/tests/data/repos/simple_merge.git/objects/d8/0c186a03f423a81b39df39dc87fd269736ca86
dulwich/tests/data/repos/simple_merge.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391
dulwich/tests/data/repos/simple_merge.git/refs/heads/master
dulwich/tests/data/repos/submodule/dotgit
dulwich/tests/data/tags/71/033db03a03c6a36721efcf1968dd8f8e0cf023
dulwich/tests/data/trees/70/c190eb48fa8bbb50ddc692a17b44cb781af7f6
examples/clone.py
examples/config.py
examples/diff.py
examples/gcs.py
examples/latest_change.py
examples/memoryrepo.py
examples/rename-branch.py
\ No newline at end of file
diff --git a/dulwich/__init__.py b/dulwich/__init__.py
index 888b48f0..cb4d9056 100644
--- a/dulwich/__init__.py
+++ b/dulwich/__init__.py
@@ -1,25 +1,25 @@
# __init__.py -- The git module of dulwich
# Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
# Copyright (C) 2008 Jelmer Vernooij <jelmer@jelmer.uk>
#
# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
# General Public License as public by the Free Software Foundation; version 2.0
# or (at your option) any later version. You can redistribute it and/or
# modify it under the terms of either of these two licenses.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# You should have received a copy of the licenses; if not, see
# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
# License, Version 2.0.
#
"""Python implementation of the Git file formats and protocols."""
-__version__ = (0, 20, 26)
+__version__ = (0, 20, 27)
diff --git a/dulwich/hooks.py b/dulwich/hooks.py
index 85de5f09..001abe42 100644
--- a/dulwich/hooks.py
+++ b/dulwich/hooks.py
@@ -1,206 +1,206 @@
# hooks.py -- for dealing with git hooks
# Copyright (C) 2012-2013 Jelmer Vernooij and others.
#
# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
# General Public License as public by the Free Software Foundation; version 2.0
# or (at your option) any later version. You can redistribute it and/or
# modify it under the terms of either of these two licenses.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# You should have received a copy of the licenses; if not, see
# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
# License, Version 2.0.
#
"""Access to hooks."""
import os
import subprocess
from dulwich.errors import (
HookError,
)
class Hook(object):
"""Generic hook object."""
def execute(self, *args):
"""Execute the hook with the given args
Args:
args: argument list to hook
Raises:
HookError: hook execution failure
Returns:
a hook may return a useful value
"""
raise NotImplementedError(self.execute)
class ShellHook(Hook):
"""Hook by executable file
Implements standard githooks(5) [0]:
[0] http://www.kernel.org/pub/software/scm/git/docs/githooks.html
"""
def __init__(
self,
name,
path,
numparam,
pre_exec_callback=None,
post_exec_callback=None,
cwd=None,
):
"""Setup shell hook definition
Args:
name: name of hook for error messages
path: absolute path to executable file
numparam: number of requirements parameters
pre_exec_callback: closure for setup before execution
Defaults to None. Takes in the variable argument list from the
execute functions and returns a modified argument list for the
shell hook.
post_exec_callback: closure for cleanup after execution
Defaults to None. Takes in a boolean for hook success and the
modified argument list and returns the final hook return value
if applicable
cwd: working directory to switch to when executing the hook
"""
self.name = name
self.filepath = path
self.numparam = numparam
self.pre_exec_callback = pre_exec_callback
self.post_exec_callback = post_exec_callback
self.cwd = cwd
def execute(self, *args):
"""Execute the hook with given args"""
if len(args) != self.numparam:
raise HookError(
"Hook %s executed with wrong number of args. \
Expected %d. Saw %d. args: %s"
% (self.name, self.numparam, len(args), args)
)
if self.pre_exec_callback is not None:
args = self.pre_exec_callback(*args)
try:
ret = subprocess.call([self.filepath] + list(args), cwd=self.cwd)
if ret != 0:
if self.post_exec_callback is not None:
self.post_exec_callback(0, *args)
raise HookError(
"Hook %s exited with non-zero status %d" % (self.name, ret)
)
if self.post_exec_callback is not None:
return self.post_exec_callback(1, *args)
except OSError: # no file. silent failure.
if self.post_exec_callback is not None:
self.post_exec_callback(0, *args)
class PreCommitShellHook(ShellHook):
"""pre-commit shell hook"""
- def __init__(self, controldir):
+ def __init__(self, cwd, controldir):
filepath = os.path.join(controldir, "hooks", "pre-commit")
- ShellHook.__init__(self, "pre-commit", filepath, 0, cwd=controldir)
+ ShellHook.__init__(self, "pre-commit", filepath, 0, cwd=cwd)
class PostCommitShellHook(ShellHook):
"""post-commit shell hook"""
def __init__(self, controldir):
filepath = os.path.join(controldir, "hooks", "post-commit")
ShellHook.__init__(self, "post-commit", filepath, 0, cwd=controldir)
class CommitMsgShellHook(ShellHook):
"""commit-msg shell hook
Args:
args[0]: commit message
Returns:
new commit message or None
"""
def __init__(self, controldir):
filepath = os.path.join(controldir, "hooks", "commit-msg")
def prepare_msg(*args):
import tempfile
(fd, path) = tempfile.mkstemp()
with os.fdopen(fd, "wb") as f:
f.write(args[0])
return (path,)
def clean_msg(success, *args):
if success:
with open(args[0], "rb") as f:
new_msg = f.read()
os.unlink(args[0])
return new_msg
os.unlink(args[0])
ShellHook.__init__(
self, "commit-msg", filepath, 1, prepare_msg, clean_msg, controldir
)
class PostReceiveShellHook(ShellHook):
"""post-receive shell hook"""
def __init__(self, controldir):
self.controldir = controldir
filepath = os.path.join(controldir, "hooks", "post-receive")
- ShellHook.__init__(self, "post-receive", filepath, 0)
+ ShellHook.__init__(self, "post-receive", path=filepath, numparam=0)
def execute(self, client_refs):
# do nothing if the script doesn't exist
if not os.path.exists(self.filepath):
return None
try:
env = os.environ.copy()
env["GIT_DIR"] = self.controldir
p = subprocess.Popen(
self.filepath,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
env=env,
)
# client_refs is a list of (oldsha, newsha, ref)
in_data = b"\n".join([b" ".join(ref) for ref in client_refs])
out_data, err_data = p.communicate(in_data)
if (p.returncode != 0) or err_data:
err_fmt = b"post-receive exit code: %d\n" + b"stdout:\n%s\nstderr:\n%s"
err_msg = err_fmt % (p.returncode, out_data, err_data)
raise HookError(err_msg.decode('utf-8', 'backslashreplace'))
return out_data
except OSError as err:
raise HookError(repr(err))
diff --git a/dulwich/object_store.py b/dulwich/object_store.py
index 551f9c1f..f6b0db48 100644
--- a/dulwich/object_store.py
+++ b/dulwich/object_store.py
@@ -1,1604 +1,1604 @@
# object_store.py -- Object store for git objects
# Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@jelmer.uk>
# and others
#
# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
# General Public License as public by the Free Software Foundation; version 2.0
# or (at your option) any later version. You can redistribute it and/or
# modify it under the terms of either of these two licenses.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# You should have received a copy of the licenses; if not, see
# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
# License, Version 2.0.
#
"""Git object store interfaces and implementation."""
from io import BytesIO
import os
import stat
import sys
from dulwich.diff_tree import (
tree_changes,
walk_trees,
)
from dulwich.errors import (
NotTreeError,
)
from dulwich.file import GitFile
from dulwich.objects import (
Commit,
ShaFile,
Tag,
Tree,
ZERO_SHA,
hex_to_sha,
sha_to_hex,
hex_to_filename,
S_ISGITLINK,
object_class,
valid_hexsha,
)
from dulwich.pack import (
Pack,
PackData,
PackInflater,
PackFileDisappeared,
load_pack_index_file,
iter_sha1,
pack_objects_to_data,
write_pack_header,
write_pack_index_v2,
write_pack_data,
write_pack_object,
compute_file_sha,
PackIndexer,
PackStreamCopier,
)
from dulwich.protocol import DEPTH_INFINITE
from dulwich.refs import ANNOTATED_TAG_SUFFIX
INFODIR = "info"
PACKDIR = "pack"
# use permissions consistent with Git; just readable by everyone
# TODO: should packs also be non-writable on Windows? if so, that
# would requite some rather significant adjustments to the test suite
PACK_MODE = 0o444 if sys.platform != "win32" else 0o644
class BaseObjectStore(object):
"""Object store interface."""
def determine_wants_all(self, refs, depth=None):
def _want_deepen(sha):
if not depth:
return False
if depth == DEPTH_INFINITE:
return True
return depth > self._get_depth(sha)
return [
sha
for (ref, sha) in refs.items()
if (sha not in self or _want_deepen(sha))
and not ref.endswith(ANNOTATED_TAG_SUFFIX)
and not sha == ZERO_SHA
]
def iter_shas(self, shas):
"""Iterate over the objects for the specified shas.
Args:
shas: Iterable object with SHAs
Returns: Object iterator
"""
return ObjectStoreIterator(self, shas)
def contains_loose(self, sha):
"""Check if a particular object is present by SHA1 and is loose."""
raise NotImplementedError(self.contains_loose)
def contains_packed(self, sha):
"""Check if a particular object is present by SHA1 and is packed."""
raise NotImplementedError(self.contains_packed)
def __contains__(self, sha):
"""Check if a particular object is present by SHA1.
This method makes no distinction between loose and packed objects.
"""
return self.contains_packed(sha) or self.contains_loose(sha)
@property
def packs(self):
"""Iterable of pack objects."""
raise NotImplementedError
def get_raw(self, name):
"""Obtain the raw text for an object.
Args:
name: sha for the object.
Returns: tuple with numeric type and object contents.
"""
raise NotImplementedError(self.get_raw)
def __getitem__(self, sha):
"""Obtain an object by SHA1."""
type_num, uncomp = self.get_raw(sha)
return ShaFile.from_raw_string(type_num, uncomp, sha=sha)
def __iter__(self):
"""Iterate over the SHAs that are present in this store."""
raise NotImplementedError(self.__iter__)
def add_object(self, obj):
"""Add a single object to this object store."""
raise NotImplementedError(self.add_object)
def add_objects(self, objects, progress=None):
"""Add a set of objects to this object store.
Args:
objects: Iterable over a list of (object, path) tuples
"""
raise NotImplementedError(self.add_objects)
def add_pack_data(self, count, pack_data, progress=None):
"""Add pack data to this object store.
Args:
num_items: Number of items to add
pack_data: Iterator over pack data tuples
"""
if count == 0:
# Don't bother writing an empty pack file
return
f, commit, abort = self.add_pack()
try:
write_pack_data(
f,
count,
pack_data,
progress,
compression_level=self.pack_compression_level,
)
except BaseException:
abort()
raise
else:
return commit()
def tree_changes(
self,
source,
target,
want_unchanged=False,
include_trees=False,
change_type_same=False,
rename_detector=None,
):
"""Find the differences between the contents of two trees
Args:
source: SHA1 of the source tree
target: SHA1 of the target tree
want_unchanged: Whether unchanged files should be reported
include_trees: Whether to include trees
change_type_same: Whether to report files changing
type in the same entry.
Returns: Iterator over tuples with
(oldpath, newpath), (oldmode, newmode), (oldsha, newsha)
"""
for change in tree_changes(
self,
source,
target,
want_unchanged=want_unchanged,
include_trees=include_trees,
change_type_same=change_type_same,
rename_detector=rename_detector,
):
yield (
(change.old.path, change.new.path),
(change.old.mode, change.new.mode),
(change.old.sha, change.new.sha),
)
def iter_tree_contents(self, tree_id, include_trees=False):
"""Iterate the contents of a tree and all subtrees.
Iteration is depth-first pre-order, as in e.g. os.walk.
Args:
tree_id: SHA1 of the tree.
include_trees: If True, include tree objects in the iteration.
Returns: Iterator over TreeEntry namedtuples for all the objects in a
tree.
"""
for entry, _ in walk_trees(self, tree_id, None):
if (
entry.mode is not None and not stat.S_ISDIR(entry.mode)
) or include_trees:
yield entry
def find_missing_objects(
self,
haves,
wants,
shallow=None,
progress=None,
get_tagged=None,
get_parents=lambda commit: commit.parents,
depth=None,
):
"""Find the missing objects required for a set of revisions.
Args:
haves: Iterable over SHAs already in common.
wants: Iterable over SHAs of objects to fetch.
shallow: Set of shallow commit SHA1s to skip
progress: Simple progress function that will be called with
updated progress strings.
get_tagged: Function that returns a dict of pointed-to sha ->
tag sha for including tags.
get_parents: Optional function for getting the parents of a
commit.
Returns: Iterator over (sha, path) pairs.
"""
finder = MissingObjectFinder(
self,
haves,
wants,
shallow,
progress,
get_tagged,
get_parents=get_parents,
)
return iter(finder.next, None)
def find_common_revisions(self, graphwalker):
"""Find which revisions this store has in common using graphwalker.
Args:
graphwalker: A graphwalker object.
Returns: List of SHAs that are in common
"""
haves = []
sha = next(graphwalker)
while sha:
if sha in self:
haves.append(sha)
graphwalker.ack(sha)
sha = next(graphwalker)
return haves
def generate_pack_contents(self, have, want, shallow=None, progress=None):
"""Iterate over the contents of a pack file.
Args:
have: List of SHA1s of objects that should not be sent
want: List of SHA1s of objects that should be sent
shallow: Set of shallow commit SHA1s to skip
progress: Optional progress reporting method
"""
missing = self.find_missing_objects(have, want, shallow, progress)
return self.iter_shas(missing)
def generate_pack_data(
self, have, want, shallow=None, progress=None, ofs_delta=True
):
"""Generate pack data objects for a set of wants/haves.
Args:
have: List of SHA1s of objects that should not be sent
want: List of SHA1s of objects that should be sent
shallow: Set of shallow commit SHA1s to skip
ofs_delta: Whether OFS deltas can be included
progress: Optional progress reporting method
"""
# TODO(jelmer): More efficient implementation
return pack_objects_to_data(
self.generate_pack_contents(have, want, shallow, progress)
)
def peel_sha(self, sha):
"""Peel all tags from a SHA.
Args:
sha: The object SHA to peel.
Returns: The fully-peeled SHA1 of a tag object, after peeling all
intermediate tags; if the original ref does not point to a tag,
this will equal the original SHA1.
"""
obj = self[sha]
obj_class = object_class(obj.type_name)
while obj_class is Tag:
obj_class, sha = obj.object
obj = self[sha]
return obj
def _collect_ancestors(
self,
heads,
- common=set(),
- shallow=set(),
+ common=frozenset(),
+ shallow=frozenset(),
get_parents=lambda commit: commit.parents,
):
"""Collect all ancestors of heads up to (excluding) those in common.
Args:
heads: commits to start from
common: commits to end at, or empty set to walk repository
completely
get_parents: Optional function for getting the parents of a
commit.
Returns: a tuple (A, B) where A - all commits reachable
from heads but not present in common, B - common (shared) elements
that are directly reachable from heads
"""
bases = set()
commits = set()
queue = []
queue.extend(heads)
while queue:
e = queue.pop(0)
if e in common:
bases.add(e)
elif e not in commits:
commits.add(e)
if e in shallow:
continue
cmt = self[e]
queue.extend(get_parents(cmt))
return (commits, bases)
def _get_depth(
self, head, get_parents=lambda commit: commit.parents, max_depth=None,
):
"""Return the current available depth for the given head.
For commits with multiple parents, the largest possible depth will be
returned.
Args:
head: commit to start from
get_parents: optional function for getting the parents of a commit
max_depth: maximum depth to search
"""
if head not in self:
return 0
current_depth = 1
queue = [(head, current_depth)]
while queue and (max_depth is None or current_depth < max_depth):
e, depth = queue.pop(0)
current_depth = max(current_depth, depth)
cmt = self[e]
if isinstance(cmt, Tag):
_cls, sha = cmt.object
cmt = self[sha]
queue.extend(
(parent, depth + 1)
for parent in get_parents(cmt)
if parent in self
)
return current_depth
def close(self):
"""Close any files opened by this object store."""
# Default implementation is a NO-OP
class PackBasedObjectStore(BaseObjectStore):
def __init__(self, pack_compression_level=-1):
self._pack_cache = {}
self.pack_compression_level = pack_compression_level
@property
def alternates(self):
return []
def contains_packed(self, sha):
"""Check if a particular object is present by SHA1 and is packed.
This does not check alternates.
"""
for pack in self.packs:
try:
if sha in pack:
return True
except PackFileDisappeared:
pass
return False
def __contains__(self, sha):
"""Check if a particular object is present by SHA1.
This method makes no distinction between loose and packed objects.
"""
if self.contains_packed(sha) or self.contains_loose(sha):
return True
for alternate in self.alternates:
if sha in alternate:
return True
return False
def _add_cached_pack(self, base_name, pack):
"""Add a newly appeared pack to the cache by path."""
prev_pack = self._pack_cache.get(base_name)
if prev_pack is not pack:
self._pack_cache[base_name] = pack
if prev_pack:
prev_pack.close()
def _clear_cached_packs(self):
pack_cache = self._pack_cache
self._pack_cache = {}
while pack_cache:
(name, pack) = pack_cache.popitem()
pack.close()
def _iter_cached_packs(self):
return self._pack_cache.values()
def _update_pack_cache(self):
raise NotImplementedError(self._update_pack_cache)
def close(self):
self._clear_cached_packs()
@property
def packs(self):
"""List with pack objects."""
return list(self._iter_cached_packs()) + list(self._update_pack_cache())
def _iter_alternate_objects(self):
"""Iterate over the SHAs of all the objects in alternate stores."""
for alternate in self.alternates:
for alternate_object in alternate:
yield alternate_object
def _iter_loose_objects(self):
"""Iterate over the SHAs of all loose objects."""
raise NotImplementedError(self._iter_loose_objects)
def _get_loose_object(self, sha):
raise NotImplementedError(self._get_loose_object)
def _remove_loose_object(self, sha):
raise NotImplementedError(self._remove_loose_object)
def _remove_pack(self, name):
raise NotImplementedError(self._remove_pack)
def pack_loose_objects(self):
"""Pack loose objects.
Returns: Number of objects packed
"""
objects = set()
for sha in self._iter_loose_objects():
objects.add((self._get_loose_object(sha), None))
self.add_objects(list(objects))
for obj, path in objects:
self._remove_loose_object(obj.id)
return len(objects)
def repack(self):
"""Repack the packs in this repository.
Note that this implementation is fairly naive and currently keeps all
objects in memory while it repacks.
"""
loose_objects = set()
for sha in self._iter_loose_objects():
loose_objects.add(self._get_loose_object(sha))
objects = {(obj, None) for obj in loose_objects}
old_packs = {p.name(): p for p in self.packs}
for name, pack in old_packs.items():
objects.update((obj, None) for obj in pack.iterobjects())
# The name of the consolidated pack might match the name of a
# pre-existing pack. Take care not to remove the newly created
# consolidated pack.
consolidated = self.add_objects(objects)
old_packs.pop(consolidated.name(), None)
for obj in loose_objects:
self._remove_loose_object(obj.id)
for name, pack in old_packs.items():
self._remove_pack(pack)
self._update_pack_cache()
return len(objects)
def __iter__(self):
"""Iterate over the SHAs that are present in this store."""
self._update_pack_cache()
for pack in self._iter_cached_packs():
try:
for sha in pack:
yield sha
except PackFileDisappeared:
pass
for sha in self._iter_loose_objects():
yield sha
for sha in self._iter_alternate_objects():
yield sha
def contains_loose(self, sha):
"""Check if a particular object is present by SHA1 and is loose.
This does not check alternates.
"""
return self._get_loose_object(sha) is not None
def get_raw(self, name):
"""Obtain the raw fulltext for an object.
Args:
name: sha for the object.
Returns: tuple with numeric type and object contents.
"""
if name == ZERO_SHA:
raise KeyError(name)
if len(name) == 40:
sha = hex_to_sha(name)
hexsha = name
elif len(name) == 20:
sha = name
hexsha = None
else:
raise AssertionError("Invalid object name %r" % (name,))
for pack in self._iter_cached_packs():
try:
return pack.get_raw(sha)
except (KeyError, PackFileDisappeared):
pass
if hexsha is None:
hexsha = sha_to_hex(name)
ret = self._get_loose_object(hexsha)
if ret is not None:
return ret.type_num, ret.as_raw_string()
# Maybe something else has added a pack with the object
# in the mean time?
for pack in self._update_pack_cache():
try:
return pack.get_raw(sha)
except KeyError:
pass
for alternate in self.alternates:
try:
return alternate.get_raw(hexsha)
except KeyError:
pass
raise KeyError(hexsha)
def add_objects(self, objects, progress=None):
"""Add a set of objects to this object store.
Args:
objects: Iterable over (object, path) tuples, should support
__len__.
Returns: Pack object of the objects written.
"""
return self.add_pack_data(*pack_objects_to_data(objects), progress=progress)
class DiskObjectStore(PackBasedObjectStore):
"""Git-style object store that exists on disk."""
def __init__(self, path, loose_compression_level=-1, pack_compression_level=-1):
"""Open an object store.
Args:
path: Path of the object store.
loose_compression_level: zlib compression level for loose objects
pack_compression_level: zlib compression level for pack objects
"""
super(DiskObjectStore, self).__init__(
pack_compression_level=pack_compression_level
)
self.path = path
self.pack_dir = os.path.join(self.path, PACKDIR)
self._alternates = None
self.loose_compression_level = loose_compression_level
self.pack_compression_level = pack_compression_level
def __repr__(self):
return "<%s(%r)>" % (self.__class__.__name__, self.path)
@classmethod
def from_config(cls, path, config):
try:
default_compression_level = int(
config.get((b"core",), b"compression").decode()
)
except KeyError:
default_compression_level = -1
try:
loose_compression_level = int(
config.get((b"core",), b"looseCompression").decode()
)
except KeyError:
loose_compression_level = default_compression_level
try:
pack_compression_level = int(
config.get((b"core",), "packCompression").decode()
)
except KeyError:
pack_compression_level = default_compression_level
return cls(path, loose_compression_level, pack_compression_level)
@property
def alternates(self):
if self._alternates is not None:
return self._alternates
self._alternates = []
for path in self._read_alternate_paths():
self._alternates.append(DiskObjectStore(path))
return self._alternates
def _read_alternate_paths(self):
try:
f = GitFile(os.path.join(self.path, INFODIR, "alternates"), "rb")
except FileNotFoundError:
return
with f:
for line in f.readlines():
line = line.rstrip(b"\n")
if line.startswith(b"#"):
continue
if os.path.isabs(line):
yield os.fsdecode(line)
else:
yield os.fsdecode(os.path.join(os.fsencode(self.path), line))
def add_alternate_path(self, path):
"""Add an alternate path to this object store."""
try:
os.mkdir(os.path.join(self.path, INFODIR))
except FileExistsError:
pass
alternates_path = os.path.join(self.path, INFODIR, "alternates")
with GitFile(alternates_path, "wb") as f:
try:
orig_f = open(alternates_path, "rb")
except FileNotFoundError:
pass
else:
with orig_f:
f.write(orig_f.read())
f.write(os.fsencode(path) + b"\n")
if not os.path.isabs(path):
path = os.path.join(self.path, path)
self.alternates.append(DiskObjectStore(path))
def _update_pack_cache(self):
"""Read and iterate over new pack files and cache them."""
try:
pack_dir_contents = os.listdir(self.pack_dir)
except FileNotFoundError:
self.close()
return []
pack_files = set()
for name in pack_dir_contents:
if name.startswith("pack-") and name.endswith(".pack"):
# verify that idx exists first (otherwise the pack was not yet
# fully written)
idx_name = os.path.splitext(name)[0] + ".idx"
if idx_name in pack_dir_contents:
pack_name = name[: -len(".pack")]
pack_files.add(pack_name)
# Open newly appeared pack files
new_packs = []
for f in pack_files:
if f not in self._pack_cache:
pack = Pack(os.path.join(self.pack_dir, f))
new_packs.append(pack)
self._pack_cache[f] = pack
# Remove disappeared pack files
for f in set(self._pack_cache) - pack_files:
self._pack_cache.pop(f).close()
return new_packs
def _get_shafile_path(self, sha):
# Check from object dir
return hex_to_filename(self.path, sha)
def _iter_loose_objects(self):
for base in os.listdir(self.path):
if len(base) != 2:
continue
for rest in os.listdir(os.path.join(self.path, base)):
sha = os.fsencode(base + rest)
if not valid_hexsha(sha):
continue
yield sha
def _get_loose_object(self, sha):
path = self._get_shafile_path(sha)
try:
return ShaFile.from_path(path)
except FileNotFoundError:
return None
def _remove_loose_object(self, sha):
os.remove(self._get_shafile_path(sha))
def _remove_pack(self, pack):
try:
del self._pack_cache[os.path.basename(pack._basename)]
except KeyError:
pass
pack.close()
os.remove(pack.data.path)
os.remove(pack.index.path)
def _get_pack_basepath(self, entries):
suffix = iter_sha1(entry[0] for entry in entries)
# TODO: Handle self.pack_dir being bytes
suffix = suffix.decode("ascii")
return os.path.join(self.pack_dir, "pack-" + suffix)
def _complete_thin_pack(self, f, path, copier, indexer):
"""Move a specific file containing a pack into the pack directory.
Note: The file should be on the same file system as the
packs directory.
Args:
f: Open file object for the pack.
path: Path to the pack file.
copier: A PackStreamCopier to use for writing pack data.
indexer: A PackIndexer for indexing the pack.
"""
entries = list(indexer)
# Update the header with the new number of objects.
f.seek(0)
write_pack_header(f, len(entries) + len(indexer.ext_refs()))
# Must flush before reading (http://bugs.python.org/issue3207)
f.flush()
# Rescan the rest of the pack, computing the SHA with the new header.
new_sha = compute_file_sha(f, end_ofs=-20)
# Must reposition before writing (http://bugs.python.org/issue3207)
f.seek(0, os.SEEK_CUR)
# Complete the pack.
for ext_sha in indexer.ext_refs():
assert len(ext_sha) == 20
type_num, data = self.get_raw(ext_sha)
offset = f.tell()
crc32 = write_pack_object(
f,
type_num,
data,
sha=new_sha,
compression_level=self.pack_compression_level,
)
entries.append((ext_sha, offset, crc32))
pack_sha = new_sha.digest()
f.write(pack_sha)
f.close()
# Move the pack in.
entries.sort()
pack_base_name = self._get_pack_basepath(entries)
target_pack = pack_base_name + ".pack"
if sys.platform == "win32":
# Windows might have the target pack file lingering. Attempt
# removal, silently passing if the target does not exist.
try:
os.remove(target_pack)
except FileNotFoundError:
pass
os.rename(path, target_pack)
# Write the index.
index_file = GitFile(pack_base_name + ".idx", "wb", mask=PACK_MODE)
try:
write_pack_index_v2(index_file, entries, pack_sha)
index_file.close()
finally:
index_file.abort()
# Add the pack to the store and return it.
final_pack = Pack(pack_base_name)
final_pack.check_length_and_checksum()
self._add_cached_pack(pack_base_name, final_pack)
return final_pack
def add_thin_pack(self, read_all, read_some):
"""Add a new thin pack to this object store.
Thin packs are packs that contain deltas with parents that exist
outside the pack. They should never be placed in the object store
directly, and always indexed and completed as they are copied.
Args:
read_all: Read function that blocks until the number of
requested bytes are read.
read_some: Read function that returns at least one byte, but may
not return the number of bytes requested.
Returns: A Pack object pointing at the now-completed thin pack in the
objects/pack directory.
"""
import tempfile
fd, path = tempfile.mkstemp(dir=self.path, prefix="tmp_pack_")
with os.fdopen(fd, "w+b") as f:
os.chmod(path, PACK_MODE)
indexer = PackIndexer(f, resolve_ext_ref=self.get_raw)
copier = PackStreamCopier(read_all, read_some, f, delta_iter=indexer)
copier.verify()
return self._complete_thin_pack(f, path, copier, indexer)
def move_in_pack(self, path):
"""Move a specific file containing a pack into the pack directory.
Note: The file should be on the same file system as the
packs directory.
Args:
path: Path to the pack file.
"""
with PackData(path) as p:
entries = p.sorted_entries()
basename = self._get_pack_basepath(entries)
index_name = basename + ".idx"
if not os.path.exists(index_name):
with GitFile(index_name, "wb", mask=PACK_MODE) as f:
write_pack_index_v2(f, entries, p.get_stored_checksum())
for pack in self.packs:
if pack._basename == basename:
return pack
target_pack = basename + ".pack"
if sys.platform == "win32":
# Windows might have the target pack file lingering. Attempt
# removal, silently passing if the target does not exist.
try:
os.remove(target_pack)
except FileNotFoundError:
pass
os.rename(path, target_pack)
final_pack = Pack(basename)
self._add_cached_pack(basename, final_pack)
return final_pack
def add_pack(self):
"""Add a new pack to this object store.
Returns: Fileobject to write to, a commit function to
call when the pack is finished and an abort
function.
"""
import tempfile
fd, path = tempfile.mkstemp(dir=self.pack_dir, suffix=".pack")
f = os.fdopen(fd, "wb")
os.chmod(path, PACK_MODE)
def commit():
f.flush()
os.fsync(fd)
f.close()
if os.path.getsize(path) > 0:
return self.move_in_pack(path)
else:
os.remove(path)
return None
def abort():
f.close()
os.remove(path)
return f, commit, abort
def add_object(self, obj):
"""Add a single object to this object store.
Args:
obj: Object to add
"""
path = self._get_shafile_path(obj.id)
dir = os.path.dirname(path)
try:
os.mkdir(dir)
except FileExistsError:
pass
if os.path.exists(path):
return # Already there, no need to write again
with GitFile(path, "wb", mask=PACK_MODE) as f:
f.write(
obj.as_legacy_object(compression_level=self.loose_compression_level)
)
@classmethod
def init(cls, path):
try:
os.mkdir(path)
except FileExistsError:
pass
os.mkdir(os.path.join(path, "info"))
os.mkdir(os.path.join(path, PACKDIR))
return cls(path)
class MemoryObjectStore(BaseObjectStore):
"""Object store that keeps all objects in memory."""
def __init__(self):
super(MemoryObjectStore, self).__init__()
self._data = {}
self.pack_compression_level = -1
def _to_hexsha(self, sha):
if len(sha) == 40:
return sha
elif len(sha) == 20:
return sha_to_hex(sha)
else:
raise ValueError("Invalid sha %r" % (sha,))
def contains_loose(self, sha):
"""Check if a particular object is present by SHA1 and is loose."""
return self._to_hexsha(sha) in self._data
def contains_packed(self, sha):
"""Check if a particular object is present by SHA1 and is packed."""
return False
def __iter__(self):
"""Iterate over the SHAs that are present in this store."""
return iter(self._data.keys())
@property
def packs(self):
"""List with pack objects."""
return []
def get_raw(self, name):
"""Obtain the raw text for an object.
Args:
name: sha for the object.
Returns: tuple with numeric type and object contents.
"""
obj = self[self._to_hexsha(name)]
return obj.type_num, obj.as_raw_string()
def __getitem__(self, name):
return self._data[self._to_hexsha(name)].copy()
def __delitem__(self, name):
"""Delete an object from this store, for testing only."""
del self._data[self._to_hexsha(name)]
def add_object(self, obj):
"""Add a single object to this object store."""
self._data[obj.id] = obj.copy()
def add_objects(self, objects, progress=None):
"""Add a set of objects to this object store.
Args:
objects: Iterable over a list of (object, path) tuples
"""
for obj, path in objects:
self.add_object(obj)
def add_pack(self):
"""Add a new pack to this object store.
Because this object store doesn't support packs, we extract and add the
individual objects.
Returns: Fileobject to write to and a commit function to
call when the pack is finished.
"""
f = BytesIO()
def commit():
p = PackData.from_file(BytesIO(f.getvalue()), f.tell())
f.close()
for obj in PackInflater.for_pack_data(p, self.get_raw):
self.add_object(obj)
def abort():
pass
return f, commit, abort
def _complete_thin_pack(self, f, indexer):
"""Complete a thin pack by adding external references.
Args:
f: Open file object for the pack.
indexer: A PackIndexer for indexing the pack.
"""
entries = list(indexer)
# Update the header with the new number of objects.
f.seek(0)
write_pack_header(f, len(entries) + len(indexer.ext_refs()))
# Rescan the rest of the pack, computing the SHA with the new header.
new_sha = compute_file_sha(f, end_ofs=-20)
# Complete the pack.
for ext_sha in indexer.ext_refs():
assert len(ext_sha) == 20
type_num, data = self.get_raw(ext_sha)
write_pack_object(f, type_num, data, sha=new_sha)
pack_sha = new_sha.digest()
f.write(pack_sha)
def add_thin_pack(self, read_all, read_some):
"""Add a new thin pack to this object store.
Thin packs are packs that contain deltas with parents that exist
outside the pack. Because this object store doesn't support packs, we
extract and add the individual objects.
Args:
read_all: Read function that blocks until the number of
requested bytes are read.
read_some: Read function that returns at least one byte, but may
not return the number of bytes requested.
"""
f, commit, abort = self.add_pack()
try:
indexer = PackIndexer(f, resolve_ext_ref=self.get_raw)
copier = PackStreamCopier(read_all, read_some, f, delta_iter=indexer)
copier.verify()
self._complete_thin_pack(f, indexer)
except BaseException:
abort()
raise
else:
commit()
class ObjectIterator(object):
"""Interface for iterating over objects."""
def iterobjects(self):
raise NotImplementedError(self.iterobjects)
class ObjectStoreIterator(ObjectIterator):
"""ObjectIterator that works on top of an ObjectStore."""
def __init__(self, store, sha_iter):
"""Create a new ObjectIterator.
Args:
store: Object store to retrieve from
sha_iter: Iterator over (sha, path) tuples
"""
self.store = store
self.sha_iter = sha_iter
self._shas = []
def __iter__(self):
"""Yield tuple with next object and path."""
for sha, path in self.itershas():
yield self.store[sha], path
def iterobjects(self):
"""Iterate over just the objects."""
for o, path in self:
yield o
def itershas(self):
"""Iterate over the SHAs."""
for sha in self._shas:
yield sha
for sha in self.sha_iter:
self._shas.append(sha)
yield sha
def __contains__(self, needle):
"""Check if an object is present.
Note: This checks if the object is present in
the underlying object store, not if it would
be yielded by the iterator.
Args:
needle: SHA1 of the object to check for
"""
if needle == ZERO_SHA:
return False
return needle in self.store
def __getitem__(self, key):
"""Find an object by SHA1.
Note: This retrieves the object from the underlying
object store. It will also succeed if the object would
not be returned by the iterator.
"""
return self.store[key]
def __len__(self):
"""Return the number of objects."""
return len(list(self.itershas()))
def empty(self):
import warnings
warnings.warn("Use bool() instead.", DeprecationWarning)
return self._empty()
def _empty(self):
it = self.itershas()
try:
next(it)
except StopIteration:
return True
else:
return False
def __bool__(self):
"""Indicate whether this object has contents."""
return not self._empty()
def tree_lookup_path(lookup_obj, root_sha, path):
"""Look up an object in a Git tree.
Args:
lookup_obj: Callback for retrieving object by SHA1
root_sha: SHA1 of the root tree
path: Path to lookup
Returns: A tuple of (mode, SHA) of the resulting path.
"""
tree = lookup_obj(root_sha)
if not isinstance(tree, Tree):
raise NotTreeError(root_sha)
return tree.lookup_path(lookup_obj, path)
def _collect_filetree_revs(obj_store, tree_sha, kset):
"""Collect SHA1s of files and directories for specified tree.
Args:
obj_store: Object store to get objects by SHA from
tree_sha: tree reference to walk
kset: set to fill with references to files and directories
"""
filetree = obj_store[tree_sha]
for name, mode, sha in filetree.iteritems():
if not S_ISGITLINK(mode) and sha not in kset:
kset.add(sha)
if stat.S_ISDIR(mode):
_collect_filetree_revs(obj_store, sha, kset)
def _split_commits_and_tags(obj_store, lst, ignore_unknown=False):
"""Split object id list into three lists with commit, tag, and other SHAs.
Commits referenced by tags are included into commits
list as well. Only SHA1s known in this repository will get
through, and unless ignore_unknown argument is True, KeyError
is thrown for SHA1 missing in the repository
Args:
obj_store: Object store to get objects by SHA1 from
lst: Collection of commit and tag SHAs
ignore_unknown: True to skip SHA1 missing in the repository
silently.
Returns: A tuple of (commits, tags, others) SHA1s
"""
commits = set()
tags = set()
others = set()
for e in lst:
try:
o = obj_store[e]
except KeyError:
if not ignore_unknown:
raise
else:
if isinstance(o, Commit):
commits.add(e)
elif isinstance(o, Tag):
tags.add(e)
tagged = o.object[1]
c, t, o = _split_commits_and_tags(
obj_store, [tagged], ignore_unknown=ignore_unknown
)
commits |= c
tags |= t
others |= o
else:
others.add(e)
return (commits, tags, others)
class MissingObjectFinder(object):
"""Find the objects missing from another object store.
Args:
object_store: Object store containing at least all objects to be
sent
haves: SHA1s of commits not to send (already present in target)
wants: SHA1s of commits to send
progress: Optional function to report progress to.
get_tagged: Function that returns a dict of pointed-to sha -> tag
sha for including tags.
get_parents: Optional function for getting the parents of a commit.
tagged: dict of pointed-to sha -> tag sha for including tags
"""
def __init__(
self,
object_store,
haves,
wants,
shallow=None,
progress=None,
get_tagged=None,
get_parents=lambda commit: commit.parents,
):
self.object_store = object_store
if shallow is None:
shallow = set()
self._get_parents = get_parents
# process Commits and Tags differently
# Note, while haves may list commits/tags not available locally,
# and such SHAs would get filtered out by _split_commits_and_tags,
# wants shall list only known SHAs, and otherwise
# _split_commits_and_tags fails with KeyError
have_commits, have_tags, have_others = _split_commits_and_tags(
object_store, haves, True
)
want_commits, want_tags, want_others = _split_commits_and_tags(
object_store, wants, False
)
# all_ancestors is a set of commits that shall not be sent
# (complete repository up to 'haves')
all_ancestors = object_store._collect_ancestors(
have_commits, shallow=shallow, get_parents=self._get_parents
)[0]
# all_missing - complete set of commits between haves and wants
# common - commits from all_ancestors we hit into while
# traversing parent hierarchy of wants
missing_commits, common_commits = object_store._collect_ancestors(
want_commits,
all_ancestors,
shallow=shallow,
get_parents=self._get_parents,
)
self.sha_done = set()
# Now, fill sha_done with commits and revisions of
# files and directories known to be both locally
# and on target. Thus these commits and files
# won't get selected for fetch
for h in common_commits:
self.sha_done.add(h)
cmt = object_store[h]
_collect_filetree_revs(object_store, cmt.tree, self.sha_done)
# record tags we have as visited, too
for t in have_tags:
self.sha_done.add(t)
missing_tags = want_tags.difference(have_tags)
missing_others = want_others.difference(have_others)
# in fact, what we 'want' is commits, tags, and others
# we've found missing
wants = missing_commits.union(missing_tags)
wants = wants.union(missing_others)
self.objects_to_send = set([(w, None, False) for w in wants])
if progress is None:
self.progress = lambda x: None
else:
self.progress = progress
self._tagged = get_tagged and get_tagged() or {}
def add_todo(self, entries):
self.objects_to_send.update([e for e in entries if not e[0] in self.sha_done])
def next(self):
while True:
if not self.objects_to_send:
return None
(sha, name, leaf) = self.objects_to_send.pop()
if sha not in self.sha_done:
break
if not leaf:
o = self.object_store[sha]
if isinstance(o, Commit):
self.add_todo([(o.tree, "", False)])
elif isinstance(o, Tree):
self.add_todo(
[
(s, n, not stat.S_ISDIR(m))
for n, m, s in o.iteritems()
if not S_ISGITLINK(m)
]
)
elif isinstance(o, Tag):
self.add_todo([(o.object[1], None, False)])
if sha in self._tagged:
self.add_todo([(self._tagged[sha], None, True)])
self.sha_done.add(sha)
self.progress(("counting objects: %d\r" % len(self.sha_done)).encode("ascii"))
return (sha, name)
__next__ = next
class ObjectStoreGraphWalker(object):
"""Graph walker that finds what commits are missing from an object store.
:ivar heads: Revisions without descendants in the local repo
:ivar get_parents: Function to retrieve parents in the local repo
"""
def __init__(self, local_heads, get_parents, shallow=None):
"""Create a new instance.
Args:
local_heads: Heads to start search with
get_parents: Function for finding the parents of a SHA1.
"""
self.heads = set(local_heads)
self.get_parents = get_parents
self.parents = {}
if shallow is None:
shallow = set()
self.shallow = shallow
def ack(self, sha):
"""Ack that a revision and its ancestors are present in the source."""
if len(sha) != 40:
raise ValueError("unexpected sha %r received" % sha)
ancestors = set([sha])
# stop if we run out of heads to remove
while self.heads:
for a in ancestors:
if a in self.heads:
self.heads.remove(a)
# collect all ancestors
new_ancestors = set()
for a in ancestors:
ps = self.parents.get(a)
if ps is not None:
new_ancestors.update(ps)
self.parents[a] = None
# no more ancestors; stop
if not new_ancestors:
break
ancestors = new_ancestors
def next(self):
"""Iterate over ancestors of heads in the target."""
if self.heads:
ret = self.heads.pop()
try:
ps = self.get_parents(ret)
except KeyError:
return None
self.parents[ret] = ps
self.heads.update([p for p in ps if p not in self.parents])
return ret
return None
__next__ = next
def commit_tree_changes(object_store, tree, changes):
"""Commit a specified set of changes to a tree structure.
This will apply a set of changes on top of an existing tree, storing new
objects in object_store.
changes are a list of tuples with (path, mode, object_sha).
Paths can be both blobs and trees. See the mode and
object sha to None deletes the path.
This method works especially well if there are only a small
number of changes to a big tree. For a large number of changes
to a large tree, use e.g. commit_tree.
Args:
object_store: Object store to store new objects in
and retrieve old ones from.
tree: Original tree root
changes: changes to apply
Returns: New tree root object
"""
# TODO(jelmer): Save up the objects and add them using .add_objects
# rather than with individual calls to .add_object.
nested_changes = {}
for (path, new_mode, new_sha) in changes:
try:
(dirname, subpath) = path.split(b"/", 1)
except ValueError:
if new_sha is None:
del tree[path]
else:
tree[path] = (new_mode, new_sha)
else:
nested_changes.setdefault(dirname, []).append((subpath, new_mode, new_sha))
for name, subchanges in nested_changes.items():
try:
orig_subtree = object_store[tree[name][1]]
except KeyError:
orig_subtree = Tree()
subtree = commit_tree_changes(object_store, orig_subtree, subchanges)
if len(subtree) == 0:
del tree[name]
else:
tree[name] = (stat.S_IFDIR, subtree.id)
object_store.add_object(tree)
return tree
class OverlayObjectStore(BaseObjectStore):
"""Object store that can overlay multiple object stores."""
def __init__(self, bases, add_store=None):
self.bases = bases
self.add_store = add_store
def add_object(self, object):
if self.add_store is None:
raise NotImplementedError(self.add_object)
return self.add_store.add_object(object)
def add_objects(self, objects, progress=None):
if self.add_store is None:
raise NotImplementedError(self.add_object)
return self.add_store.add_objects(objects, progress)
@property
def packs(self):
ret = []
for b in self.bases:
ret.extend(b.packs)
return ret
def __iter__(self):
done = set()
for b in self.bases:
for o_id in b:
if o_id not in done:
yield o_id
done.add(o_id)
def get_raw(self, sha_id):
for b in self.bases:
try:
return b.get_raw(sha_id)
except KeyError:
pass
raise KeyError(sha_id)
def contains_packed(self, sha):
for b in self.bases:
if b.contains_packed(sha):
return True
return False
def contains_loose(self, sha):
for b in self.bases:
if b.contains_loose(sha):
return True
return False
def read_packs_file(f):
"""Yield the packs listed in a packs file."""
for line in f.read().splitlines():
if not line:
continue
(kind, name) = line.split(b" ", 1)
if kind != b"P":
continue
yield os.fsdecode(name)
class BucketBasedObjectStore(PackBasedObjectStore):
"""Object store implementation that uses a bucket store like S3 as backend.
"""
def _iter_loose_objects(self):
"""Iterate over the SHAs of all loose objects."""
return iter([])
def _get_loose_object(self, sha):
return None
def _remove_loose_object(self, sha):
# Doesn't exist..
pass
def _remove_pack(self, name):
raise NotImplementedError(self._remove_pack)
def _iter_pack_names(self):
raise NotImplementedError(self._iter_pack_names)
def _get_pack(self, name):
raise NotImplementedError(self._get_pack)
def _update_pack_cache(self):
pack_files = set(self._iter_pack_names())
# Open newly appeared pack files
new_packs = []
for f in pack_files:
if f not in self._pack_cache:
pack = self._get_pack(f)
new_packs.append(pack)
self._pack_cache[f] = pack
# Remove disappeared pack files
for f in set(self._pack_cache) - pack_files:
self._pack_cache.pop(f).close()
return new_packs
def _upload_pack(self, basename, pack_file, index_file):
raise NotImplementedError
def add_pack(self):
"""Add a new pack to this object store.
Returns: Fileobject to write to, a commit function to
call when the pack is finished and an abort
function.
"""
import tempfile
pf = tempfile.SpooledTemporaryFile()
def commit():
if pf.tell() == 0:
pf.close()
return None
pf.seek(0)
p = PackData(pf.name, pf)
entries = p.sorted_entries()
basename = iter_sha1(entry[0] for entry in entries).decode('ascii')
idxf = tempfile.SpooledTemporaryFile()
checksum = p.get_stored_checksum()
write_pack_index_v2(idxf, entries, checksum)
idxf.seek(0)
idx = load_pack_index_file(basename + '.idx', idxf)
for pack in self.packs:
if pack.get_stored_checksum() == p.get_stored_checksum():
p.close()
idx.close()
return pack
pf.seek(0)
idxf.seek(0)
self._upload_pack(basename, pf, idxf)
final_pack = Pack.from_objects(p, idx)
self._add_cached_pack(basename, final_pack)
return final_pack
return pf, commit, pf.close
diff --git a/dulwich/objects.py b/dulwich/objects.py
index 8bdb4017..74ade5c1 100644
--- a/dulwich/objects.py
+++ b/dulwich/objects.py
@@ -1,1559 +1,1569 @@
# objects.py -- Access to base git objects
# Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
# Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@jelmer.uk>
#
# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
# General Public License as public by the Free Software Foundation; version 2.0
# or (at your option) any later version. You can redistribute it and/or
# modify it under the terms of either of these two licenses.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# You should have received a copy of the licenses; if not, see
# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
# License, Version 2.0.
#
"""Access to base git objects."""
import binascii
from io import BytesIO
from collections import namedtuple
import os
import posixpath
import stat
from typing import (
Optional,
Dict,
Iterable,
Union,
Type,
)
import warnings
import zlib
from hashlib import sha1
from dulwich.errors import (
ChecksumMismatch,
NotBlobError,
NotCommitError,
NotTagError,
NotTreeError,
ObjectFormatException,
FileFormatException,
)
from dulwich.file import GitFile
ZERO_SHA = b"0" * 40
# Header fields for commits
_TREE_HEADER = b"tree"
_PARENT_HEADER = b"parent"
_AUTHOR_HEADER = b"author"
_COMMITTER_HEADER = b"committer"
_ENCODING_HEADER = b"encoding"
_MERGETAG_HEADER = b"mergetag"
_GPGSIG_HEADER = b"gpgsig"
# Header fields for objects
_OBJECT_HEADER = b"object"
_TYPE_HEADER = b"type"
_TAG_HEADER = b"tag"
_TAGGER_HEADER = b"tagger"
S_IFGITLINK = 0o160000
MAX_TIME = 9223372036854775807 # (2**63) - 1 - signed long int max
BEGIN_PGP_SIGNATURE = b"-----BEGIN PGP SIGNATURE-----"
class EmptyFileException(FileFormatException):
"""An unexpectedly empty file was encountered."""
def S_ISGITLINK(m):
"""Check if a mode indicates a submodule.
Args:
m: Mode to check
Returns: a ``boolean``
"""
return stat.S_IFMT(m) == S_IFGITLINK
def _decompress(string):
dcomp = zlib.decompressobj()
dcomped = dcomp.decompress(string)
dcomped += dcomp.flush()
return dcomped
def sha_to_hex(sha):
"""Takes a string and returns the hex of the sha within"""
hexsha = binascii.hexlify(sha)
- assert len(hexsha) == 40, "Incorrect length of sha1 string: %d" % hexsha
+ assert len(hexsha) == 40, "Incorrect length of sha1 string: %s" % hexsha
return hexsha
def hex_to_sha(hex):
"""Takes a hex sha and returns a binary sha"""
assert len(hex) == 40, "Incorrect length of hexsha: %s" % hex
try:
return binascii.unhexlify(hex)
except TypeError as exc:
if not isinstance(hex, bytes):
raise
raise ValueError(exc.args[0])
def valid_hexsha(hex):
if len(hex) != 40:
return False
try:
binascii.unhexlify(hex)
except (TypeError, binascii.Error):
return False
else:
return True
def hex_to_filename(path, hex):
"""Takes a hex sha and returns its filename relative to the given path."""
# os.path.join accepts bytes or unicode, but all args must be of the same
# type. Make sure that hex which is expected to be bytes, is the same type
# as path.
if getattr(path, "encode", None) is not None:
hex = hex.decode("ascii")
dir = hex[:2]
file = hex[2:]
# Check from object dir
return os.path.join(path, dir, file)
def filename_to_hex(filename):
"""Takes an object filename and returns its corresponding hex sha."""
# grab the last (up to) two path components
names = filename.rsplit(os.path.sep, 2)[-2:]
errmsg = "Invalid object filename: %s" % filename
assert len(names) == 2, errmsg
base, rest = names
assert len(base) == 2 and len(rest) == 38, errmsg
hex = (base + rest).encode("ascii")
hex_to_sha(hex)
return hex
def object_header(num_type: int, length: int) -> bytes:
"""Return an object header for the given numeric type and text length."""
return object_class(num_type).type_name + b" " + str(length).encode("ascii") + b"\0"
def serializable_property(name: str, docstring: Optional[str] = None):
"""A property that helps tracking whether serialization is necessary."""
def set(obj, value):
setattr(obj, "_" + name, value)
obj._needs_serialization = True
def get(obj):
return getattr(obj, "_" + name)
return property(get, set, doc=docstring)
def object_class(type):
"""Get the object class corresponding to the given type.
Args:
type: Either a type name string or a numeric type.
Returns: The ShaFile subclass corresponding to the given type, or None if
type is not a valid type name/number.
"""
return _TYPE_MAP.get(type, None)
def check_hexsha(hex, error_msg):
"""Check if a string is a valid hex sha string.
Args:
hex: Hex string to check
error_msg: Error message to use in exception
Raises:
ObjectFormatException: Raised when the string is not valid
"""
if not valid_hexsha(hex):
raise ObjectFormatException("%s %s" % (error_msg, hex))
def check_identity(identity, error_msg):
"""Check if the specified identity is valid.
This will raise an exception if the identity is not valid.
Args:
identity: Identity string
error_msg: Error message to use in exception
"""
email_start = identity.find(b"<")
email_end = identity.find(b">")
if (
email_start < 0
or email_end < 0
or email_end <= email_start
or identity.find(b"<", email_start + 1) >= 0
or identity.find(b">", email_end + 1) >= 0
or not identity.endswith(b">")
):
raise ObjectFormatException(error_msg)
def check_time(time_seconds):
"""Check if the specified time is not prone to overflow error.
This will raise an exception if the time is not valid.
Args:
time_info: author/committer/tagger info
"""
# Prevent overflow error
if time_seconds > MAX_TIME:
raise ObjectFormatException("Date field should not exceed %s" % MAX_TIME)
def git_line(*items):
"""Formats items into a space separated line."""
return b" ".join(items) + b"\n"
class FixedSha(object):
"""SHA object that behaves like hashlib's but is given a fixed value."""
__slots__ = ("_hexsha", "_sha")
def __init__(self, hexsha):
if getattr(hexsha, "encode", None) is not None:
hexsha = hexsha.encode("ascii")
if not isinstance(hexsha, bytes):
raise TypeError("Expected bytes for hexsha, got %r" % hexsha)
self._hexsha = hexsha
self._sha = hex_to_sha(hexsha)
def digest(self):
"""Return the raw SHA digest."""
return self._sha
def hexdigest(self):
"""Return the hex SHA digest."""
return self._hexsha.decode("ascii")
class ShaFile(object):
"""A git SHA file."""
__slots__ = ("_chunked_text", "_sha", "_needs_serialization")
type_name = None # type: bytes
type_num = None # type: int
@staticmethod
def _parse_legacy_object_header(magic, f):
"""Parse a legacy object, creating it but not reading the file."""
bufsize = 1024
decomp = zlib.decompressobj()
header = decomp.decompress(magic)
start = 0
end = -1
while end < 0:
extra = f.read(bufsize)
header += decomp.decompress(extra)
magic += extra
end = header.find(b"\0", start)
start = len(header)
header = header[:end]
type_name, size = header.split(b" ", 1)
try:
int(size) # sanity check
except ValueError as e:
raise ObjectFormatException("Object size not an integer: %s" % e)
obj_class = object_class(type_name)
if not obj_class:
raise ObjectFormatException("Not a known type: %s" % type_name)
return obj_class()
def _parse_legacy_object(self, map):
"""Parse a legacy object, setting the raw string."""
text = _decompress(map)
header_end = text.find(b"\0")
if header_end < 0:
raise ObjectFormatException("Invalid object header, no \\0")
self.set_raw_string(text[header_end + 1 :])
def as_legacy_object_chunks(self, compression_level=-1):
"""Return chunks representing the object in the experimental format.
Returns: List of strings
"""
compobj = zlib.compressobj(compression_level)
yield compobj.compress(self._header())
for chunk in self.as_raw_chunks():
yield compobj.compress(chunk)
yield compobj.flush()
def as_legacy_object(self, compression_level=-1):
"""Return string representing the object in the experimental format."""
return b"".join(
self.as_legacy_object_chunks(compression_level=compression_level)
)
def as_raw_chunks(self):
"""Return chunks with serialization of the object.
Returns: List of strings, not necessarily one per line
"""
if self._needs_serialization:
self._sha = None
self._chunked_text = self._serialize()
self._needs_serialization = False
return self._chunked_text
def as_raw_string(self):
"""Return raw string with serialization of the object.
Returns: String object
"""
return b"".join(self.as_raw_chunks())
def __bytes__(self):
"""Return raw string serialization of this object."""
return self.as_raw_string()
def __hash__(self):
"""Return unique hash for this object."""
return hash(self.id)
def as_pretty_string(self):
"""Return a string representing this object, fit for display."""
return self.as_raw_string()
def set_raw_string(self, text, sha=None):
"""Set the contents of this object from a serialized string."""
if not isinstance(text, bytes):
raise TypeError("Expected bytes for text, got %r" % text)
self.set_raw_chunks([text], sha)
def set_raw_chunks(self, chunks, sha=None):
"""Set the contents of this object from a list of chunks."""
self._chunked_text = chunks
self._deserialize(chunks)
if sha is None:
self._sha = None
else:
self._sha = FixedSha(sha)
self._needs_serialization = False
@staticmethod
def _parse_object_header(magic, f):
"""Parse a new style object, creating it but not reading the file."""
num_type = (ord(magic[0:1]) >> 4) & 7
obj_class = object_class(num_type)
if not obj_class:
raise ObjectFormatException("Not a known type %d" % num_type)
return obj_class()
def _parse_object(self, map):
"""Parse a new style object, setting self._text."""
# skip type and size; type must have already been determined, and
# we trust zlib to fail if it's otherwise corrupted
byte = ord(map[0:1])
used = 1
while (byte & 0x80) != 0:
byte = ord(map[used : used + 1])
used += 1
raw = map[used:]
self.set_raw_string(_decompress(raw))
@classmethod
def _is_legacy_object(cls, magic):
b0 = ord(magic[0:1])
b1 = ord(magic[1:2])
word = (b0 << 8) + b1
return (b0 & 0x8F) == 0x08 and (word % 31) == 0
@classmethod
def _parse_file(cls, f):
map = f.read()
if not map:
raise EmptyFileException("Corrupted empty file detected")
if cls._is_legacy_object(map):
obj = cls._parse_legacy_object_header(map, f)
obj._parse_legacy_object(map)
else:
obj = cls._parse_object_header(map, f)
obj._parse_object(map)
return obj
def __init__(self):
"""Don't call this directly"""
self._sha = None
self._chunked_text = []
self._needs_serialization = True
def _deserialize(self, chunks):
raise NotImplementedError(self._deserialize)
def _serialize(self):
raise NotImplementedError(self._serialize)
@classmethod
def from_path(cls, path):
"""Open a SHA file from disk."""
with GitFile(path, "rb") as f:
return cls.from_file(f)
@classmethod
def from_file(cls, f):
"""Get the contents of a SHA file on disk."""
try:
obj = cls._parse_file(f)
obj._sha = None
return obj
except (IndexError, ValueError):
raise ObjectFormatException("invalid object header")
@staticmethod
def from_raw_string(type_num, string, sha=None):
"""Creates an object of the indicated type from the raw string given.
Args:
type_num: The numeric type of the object.
string: The raw uncompressed contents.
sha: Optional known sha for the object
"""
obj = object_class(type_num)()
obj.set_raw_string(string, sha)
return obj
@staticmethod
def from_raw_chunks(type_num, chunks, sha=None):
"""Creates an object of the indicated type from the raw chunks given.
Args:
type_num: The numeric type of the object.
chunks: An iterable of the raw uncompressed contents.
sha: Optional known sha for the object
"""
obj = object_class(type_num)()
obj.set_raw_chunks(chunks, sha)
return obj
@classmethod
def from_string(cls, string):
"""Create a ShaFile from a string."""
obj = cls()
obj.set_raw_string(string)
return obj
def _check_has_member(self, member, error_msg):
"""Check that the object has a given member variable.
Args:
member: the member variable to check for
error_msg: the message for an error if the member is missing
Raises:
ObjectFormatException: with the given error_msg if member is
missing or is None
"""
if getattr(self, member, None) is None:
raise ObjectFormatException(error_msg)
def check(self):
"""Check this object for internal consistency.
Raises:
ObjectFormatException: if the object is malformed in some way
ChecksumMismatch: if the object was created with a SHA that does
not match its contents
"""
# TODO: if we find that error-checking during object parsing is a
# performance bottleneck, those checks should be moved to the class's
# check() method during optimization so we can still check the object
# when necessary.
old_sha = self.id
try:
self._deserialize(self.as_raw_chunks())
self._sha = None
new_sha = self.id
except Exception as e:
raise ObjectFormatException(e)
if old_sha != new_sha:
raise ChecksumMismatch(new_sha, old_sha)
def _header(self):
return object_header(self.type, self.raw_length())
def raw_length(self):
"""Returns the length of the raw string of this object."""
ret = 0
for chunk in self.as_raw_chunks():
ret += len(chunk)
return ret
def sha(self):
"""The SHA1 object that is the name of this object."""
if self._sha is None or self._needs_serialization:
# this is a local because as_raw_chunks() overwrites self._sha
new_sha = sha1()
new_sha.update(self._header())
for chunk in self.as_raw_chunks():
new_sha.update(chunk)
self._sha = new_sha
return self._sha
def copy(self):
"""Create a new copy of this SHA1 object from its raw string"""
obj_class = object_class(self.get_type())
return obj_class.from_raw_string(self.get_type(), self.as_raw_string(), self.id)
@property
def id(self):
"""The hex SHA of this object."""
return self.sha().hexdigest().encode("ascii")
def get_type(self):
"""Return the type number for this object class."""
return self.type_num
def set_type(self, type):
"""Set the type number for this object class."""
self.type_num = type
# DEPRECATED: use type_num or type_name as needed.
type = property(get_type, set_type)
def __repr__(self):
return "<%s %s>" % (self.__class__.__name__, self.id)
def __ne__(self, other):
"""Check whether this object does not match the other."""
return not isinstance(other, ShaFile) or self.id != other.id
def __eq__(self, other):
"""Return True if the SHAs of the two objects match."""
return isinstance(other, ShaFile) and self.id == other.id
def __lt__(self, other):
"""Return whether SHA of this object is less than the other."""
if not isinstance(other, ShaFile):
raise TypeError
return self.id < other.id
def __le__(self, other):
"""Check whether SHA of this object is less than or equal to the other."""
if not isinstance(other, ShaFile):
raise TypeError
return self.id <= other.id
def __cmp__(self, other):
"""Compare the SHA of this object with that of the other object."""
if not isinstance(other, ShaFile):
raise TypeError
return cmp(self.id, other.id) # noqa: F821
class Blob(ShaFile):
"""A Git Blob object."""
__slots__ = ()
type_name = b"blob"
type_num = 3
def __init__(self):
super(Blob, self).__init__()
self._chunked_text = []
self._needs_serialization = False
def _get_data(self):
return self.as_raw_string()
def _set_data(self, data):
self.set_raw_string(data)
data = property(
_get_data, _set_data, doc="The text contained within the blob object."
)
def _get_chunked(self):
return self._chunked_text
def _set_chunked(self, chunks):
self._chunked_text = chunks
def _serialize(self):
return self._chunked_text
def _deserialize(self, chunks):
self._chunked_text = chunks
chunked = property(
_get_chunked,
_set_chunked,
doc="The text in the blob object, as chunks (not necessarily lines)",
)
@classmethod
def from_path(cls, path):
blob = ShaFile.from_path(path)
if not isinstance(blob, cls):
raise NotBlobError(path)
return blob
def check(self):
"""Check this object for internal consistency.
Raises:
ObjectFormatException: if the object is malformed in some way
"""
super(Blob, self).check()
def splitlines(self):
"""Return list of lines in this blob.
This preserves the original line endings.
"""
chunks = self.chunked
if not chunks:
return []
if len(chunks) == 1:
return chunks[0].splitlines(True)
remaining = None
ret = []
for chunk in chunks:
lines = chunk.splitlines(True)
if len(lines) > 1:
ret.append((remaining or b"") + lines[0])
ret.extend(lines[1:-1])
remaining = lines[-1]
elif len(lines) == 1:
if remaining is None:
remaining = lines.pop()
else:
remaining += lines.pop()
if remaining is not None:
ret.append(remaining)
return ret
def _parse_message(chunks):
"""Parse a message with a list of fields and a body.
Args:
chunks: the raw chunks of the tag or commit object.
Returns: iterator of tuples of (field, value), one per header line, in the
order read from the text, possibly including duplicates. Includes a
field named None for the freeform tag/commit text.
"""
f = BytesIO(b"".join(chunks))
k = None
v = ""
eof = False
def _strip_last_newline(value):
"""Strip the last newline from value"""
if value and value.endswith(b"\n"):
return value[:-1]
return value
# Parse the headers
#
# Headers can contain newlines. The next line is indented with a space.
# We store the latest key as 'k', and the accumulated value as 'v'.
for line in f:
if line.startswith(b" "):
# Indented continuation of the previous line
v += line[1:]
else:
if k is not None:
# We parsed a new header, return its value
yield (k, _strip_last_newline(v))
if line == b"\n":
# Empty line indicates end of headers
break
(k, v) = line.split(b" ", 1)
else:
# We reached end of file before the headers ended. We still need to
# return the previous header, then we need to return a None field for
# the text.
eof = True
if k is not None:
yield (k, _strip_last_newline(v))
yield (None, None)
if not eof:
# We didn't reach the end of file while parsing headers. We can return
# the rest of the file as a message.
yield (None, f.read())
f.close()
class Tag(ShaFile):
"""A Git Tag object."""
type_name = b"tag"
type_num = 4
__slots__ = (
"_tag_timezone_neg_utc",
"_name",
"_object_sha",
"_object_class",
"_tag_time",
"_tag_timezone",
"_tagger",
"_message",
"_signature",
)
def __init__(self):
super(Tag, self).__init__()
self._tagger = None
self._tag_time = None
self._tag_timezone = None
self._tag_timezone_neg_utc = False
self._signature = None
@classmethod
def from_path(cls, filename):
tag = ShaFile.from_path(filename)
if not isinstance(tag, cls):
raise NotTagError(filename)
return tag
def check(self):
"""Check this object for internal consistency.
Raises:
ObjectFormatException: if the object is malformed in some way
"""
super(Tag, self).check()
self._check_has_member("_object_sha", "missing object sha")
self._check_has_member("_object_class", "missing object type")
self._check_has_member("_name", "missing tag name")
if not self._name:
raise ObjectFormatException("empty tag name")
check_hexsha(self._object_sha, "invalid object sha")
if getattr(self, "_tagger", None):
check_identity(self._tagger, "invalid tagger")
self._check_has_member("_tag_time", "missing tag time")
check_time(self._tag_time)
last = None
for field, _ in _parse_message(self._chunked_text):
if field == _OBJECT_HEADER and last is not None:
raise ObjectFormatException("unexpected object")
elif field == _TYPE_HEADER and last != _OBJECT_HEADER:
raise ObjectFormatException("unexpected type")
elif field == _TAG_HEADER and last != _TYPE_HEADER:
raise ObjectFormatException("unexpected tag name")
elif field == _TAGGER_HEADER and last != _TAG_HEADER:
raise ObjectFormatException("unexpected tagger")
last = field
def _serialize(self):
chunks = []
chunks.append(git_line(_OBJECT_HEADER, self._object_sha))
chunks.append(git_line(_TYPE_HEADER, self._object_class.type_name))
chunks.append(git_line(_TAG_HEADER, self._name))
if self._tagger:
if self._tag_time is None:
chunks.append(git_line(_TAGGER_HEADER, self._tagger))
else:
chunks.append(
git_line(
_TAGGER_HEADER,
self._tagger,
str(self._tag_time).encode("ascii"),
format_timezone(self._tag_timezone, self._tag_timezone_neg_utc),
)
)
if self._message is not None:
chunks.append(b"\n") # To close headers
chunks.append(self._message)
if self._signature is not None:
chunks.append(self._signature)
return chunks
def _deserialize(self, chunks):
"""Grab the metadata attached to the tag"""
self._tagger = None
self._tag_time = None
self._tag_timezone = None
self._tag_timezone_neg_utc = False
for field, value in _parse_message(chunks):
if field == _OBJECT_HEADER:
self._object_sha = value
elif field == _TYPE_HEADER:
obj_class = object_class(value)
if not obj_class:
raise ObjectFormatException("Not a known type: %s" % value)
self._object_class = obj_class
elif field == _TAG_HEADER:
self._name = value
elif field == _TAGGER_HEADER:
(
self._tagger,
self._tag_time,
(self._tag_timezone, self._tag_timezone_neg_utc),
) = parse_time_entry(value)
elif field is None:
if value is None:
self._message = None
self._signature = None
else:
try:
sig_idx = value.index(BEGIN_PGP_SIGNATURE)
except ValueError:
self._message = value
self._signature = None
else:
self._message = value[:sig_idx]
self._signature = value[sig_idx:]
else:
raise ObjectFormatException("Unknown field %s" % field)
def _get_object(self):
"""Get the object pointed to by this tag.
Returns: tuple of (object class, sha).
"""
return (self._object_class, self._object_sha)
def _set_object(self, value):
(self._object_class, self._object_sha) = value
self._needs_serialization = True
object = property(_get_object, _set_object)
name = serializable_property("name", "The name of this tag")
tagger = serializable_property(
"tagger", "Returns the name of the person who created this tag"
)
tag_time = serializable_property(
"tag_time",
"The creation timestamp of the tag. As the number of seconds "
"since the epoch",
)
tag_timezone = serializable_property(
"tag_timezone", "The timezone that tag_time is in."
)
message = serializable_property("message", "the message attached to this tag")
signature = serializable_property("signature", "Optional detached GPG signature")
def sign(self, keyid: Optional[str] = None):
import gpg
with gpg.Context(armor=True) as c:
if keyid is not None:
key = c.get_key(keyid)
with gpg.Context(armor=True, signers=[key]) as ctx:
self.signature, unused_result = ctx.sign(
self.as_raw_string(),
mode=gpg.constants.sig.mode.DETACH,
)
else:
self.signature, unused_result = c.sign(
self.as_raw_string(), mode=gpg.constants.sig.mode.DETACH
)
def verify(self, keyids: Optional[Iterable[str]] = None):
"""Verify GPG signature for this tag (if it is signed).
Args:
keyids: Optional iterable of trusted keyids for this tag.
If this tag is not signed by any key in keyids verification will
fail. If not specified, this function only verifies that the tag
has a valid signature.
Raises:
gpg.errors.BadSignatures: if GPG signature verification fails
gpg.errors.MissingSignatures: if tag was not signed by a key
specified in keyids
"""
if self._signature is None:
return
import gpg
with gpg.Context() as ctx:
data, result = ctx.verify(
self.as_raw_string()[: -len(self._signature)],
signature=self._signature,
)
if keyids:
keys = [
ctx.get_key(key)
for key in keyids
]
for key in keys:
for subkey in keys:
for sig in result.signatures:
if subkey.can_sign and subkey.fpr == sig.fpr:
return
raise gpg.errors.MissingSignatures(
result, keys, results=(data, result)
)
class TreeEntry(namedtuple("TreeEntry", ["path", "mode", "sha"])):
"""Named tuple encapsulating a single tree entry."""
def in_path(self, path):
"""Return a copy of this entry with the given path prepended."""
if not isinstance(self.path, bytes):
raise TypeError("Expected bytes for path, got %r" % path)
return TreeEntry(posixpath.join(path, self.path), self.mode, self.sha)
def parse_tree(text, strict=False):
"""Parse a tree text.
Args:
text: Serialized text to parse
Returns: iterator of tuples of (name, mode, sha)
Raises:
ObjectFormatException: if the object was malformed in some way
"""
count = 0
length = len(text)
while count < length:
mode_end = text.index(b" ", count)
mode_text = text[count:mode_end]
if strict and mode_text.startswith(b"0"):
raise ObjectFormatException("Invalid mode '%s'" % mode_text)
try:
mode = int(mode_text, 8)
except ValueError:
raise ObjectFormatException("Invalid mode '%s'" % mode_text)
name_end = text.index(b"\0", mode_end)
name = text[mode_end + 1 : name_end]
count = name_end + 21
sha = text[name_end + 1 : count]
if len(sha) != 20:
raise ObjectFormatException("Sha has invalid length")
hexsha = sha_to_hex(sha)
yield (name, mode, hexsha)
def serialize_tree(items):
"""Serialize the items in a tree to a text.
Args:
items: Sorted iterable over (name, mode, sha) tuples
Returns: Serialized tree text as chunks
"""
for name, mode, hexsha in items:
yield (
("%04o" % mode).encode("ascii") + b" " + name + b"\0" + hex_to_sha(hexsha)
)
def sorted_tree_items(entries, name_order):
"""Iterate over a tree entries dictionary.
Args:
name_order: If True, iterate entries in order of their name. If
False, iterate entries in tree order, that is, treat subtree entries as
having '/' appended.
entries: Dictionary mapping names to (mode, sha) tuples
Returns: Iterator over (name, mode, hexsha)
"""
key_func = name_order and key_entry_name_order or key_entry
for name, entry in sorted(entries.items(), key=key_func):
mode, hexsha = entry
# Stricter type checks than normal to mirror checks in the C version.
mode = int(mode)
if not isinstance(hexsha, bytes):
raise TypeError("Expected bytes for SHA, got %r" % hexsha)
yield TreeEntry(name, mode, hexsha)
def key_entry(entry):
"""Sort key for tree entry.
Args:
entry: (name, value) tuplee
"""
(name, value) = entry
if stat.S_ISDIR(value[0]):
name += b"/"
return name
def key_entry_name_order(entry):
"""Sort key for tree entry in name order."""
return entry[0]
def pretty_format_tree_entry(name, mode, hexsha, encoding="utf-8"):
"""Pretty format tree entry.
Args:
name: Name of the directory entry
mode: Mode of entry
hexsha: Hexsha of the referenced object
Returns: string describing the tree entry
"""
if mode & stat.S_IFDIR:
kind = "tree"
else:
kind = "blob"
return "%04o %s %s\t%s\n" % (
mode,
kind,
hexsha.decode("ascii"),
name.decode(encoding, "replace"),
)
+class SubmoduleEncountered(Exception):
+ """A submodule was encountered while resolving a path."""
+
+ def __init__(self, path, sha):
+ self.path = path
+ self.sha = sha
+
+
class Tree(ShaFile):
"""A Git tree object"""
type_name = b"tree"
type_num = 2
__slots__ = "_entries"
def __init__(self):
super(Tree, self).__init__()
self._entries = {}
@classmethod
def from_path(cls, filename):
tree = ShaFile.from_path(filename)
if not isinstance(tree, cls):
raise NotTreeError(filename)
return tree
def __contains__(self, name):
return name in self._entries
def __getitem__(self, name):
return self._entries[name]
def __setitem__(self, name, value):
"""Set a tree entry by name.
Args:
name: The name of the entry, as a string.
value: A tuple of (mode, hexsha), where mode is the mode of the
entry as an integral type and hexsha is the hex SHA of the entry as
a string.
"""
mode, hexsha = value
self._entries[name] = (mode, hexsha)
self._needs_serialization = True
def __delitem__(self, name):
del self._entries[name]
self._needs_serialization = True
def __len__(self):
return len(self._entries)
def __iter__(self):
return iter(self._entries)
def add(self, name, mode, hexsha):
"""Add an entry to the tree.
Args:
mode: The mode of the entry as an integral type. Not all
possible modes are supported by git; see check() for details.
name: The name of the entry, as a string.
hexsha: The hex SHA of the entry as a string.
"""
if isinstance(name, int) and isinstance(mode, bytes):
(name, mode) = (mode, name)
warnings.warn(
"Please use Tree.add(name, mode, hexsha)",
category=DeprecationWarning,
stacklevel=2,
)
self._entries[name] = mode, hexsha
self._needs_serialization = True
def iteritems(self, name_order=False):
"""Iterate over entries.
Args:
name_order: If True, iterate in name order instead of tree
order.
Returns: Iterator over (name, mode, sha) tuples
"""
return sorted_tree_items(self._entries, name_order)
def items(self):
"""Return the sorted entries in this tree.
Returns: List with (name, mode, sha) tuples
"""
return list(self.iteritems())
def _deserialize(self, chunks):
"""Grab the entries in the tree"""
try:
parsed_entries = parse_tree(b"".join(chunks))
except ValueError as e:
raise ObjectFormatException(e)
# TODO: list comprehension is for efficiency in the common (small)
# case; if memory efficiency in the large case is a concern, use a
# genexp.
self._entries = dict([(n, (m, s)) for n, m, s in parsed_entries])
def check(self):
"""Check this object for internal consistency.
Raises:
ObjectFormatException: if the object is malformed in some way
"""
super(Tree, self).check()
last = None
allowed_modes = (
stat.S_IFREG | 0o755,
stat.S_IFREG | 0o644,
stat.S_IFLNK,
stat.S_IFDIR,
S_IFGITLINK,
# TODO: optionally exclude as in git fsck --strict
stat.S_IFREG | 0o664,
)
for name, mode, sha in parse_tree(b"".join(self._chunked_text), True):
check_hexsha(sha, "invalid sha %s" % sha)
if b"/" in name or name in (b"", b".", b"..", b".git"):
raise ObjectFormatException(
"invalid name %s" % name.decode("utf-8", "replace")
)
if mode not in allowed_modes:
raise ObjectFormatException("invalid mode %06o" % mode)
entry = (name, (mode, sha))
if last:
if key_entry(last) > key_entry(entry):
raise ObjectFormatException("entries not sorted")
if name == last[0]:
raise ObjectFormatException("duplicate entry %s" % name)
last = entry
def _serialize(self):
return list(serialize_tree(self.iteritems()))
def as_pretty_string(self):
text = []
for name, mode, hexsha in self.iteritems():
text.append(pretty_format_tree_entry(name, mode, hexsha))
return "".join(text)
def lookup_path(self, lookup_obj, path):
"""Look up an object in a Git tree.
Args:
lookup_obj: Callback for retrieving object by SHA1
path: Path to lookup
Returns: A tuple of (mode, SHA) of the resulting path.
"""
parts = path.split(b"/")
sha = self.id
mode = None
- for p in parts:
+ for i, p in enumerate(parts):
if not p:
continue
+ if mode is not None and S_ISGITLINK(mode):
+ raise SubmoduleEncountered(b'/'.join(parts[:i]), sha)
obj = lookup_obj(sha)
if not isinstance(obj, Tree):
raise NotTreeError(sha)
mode, sha = obj[p]
return mode, sha
def parse_timezone(text):
"""Parse a timezone text fragment (e.g. '+0100').
Args:
text: Text to parse.
Returns: Tuple with timezone as seconds difference to UTC
and a boolean indicating whether this was a UTC timezone
prefixed with a negative sign (-0000).
"""
# cgit parses the first character as the sign, and the rest
# as an integer (using strtol), which could also be negative.
# We do the same for compatibility. See #697828.
if not text[0] in b"+-":
raise ValueError("Timezone must start with + or - (%(text)s)" % vars())
sign = text[:1]
offset = int(text[1:])
if sign == b"-":
offset = -offset
unnecessary_negative_timezone = offset >= 0 and sign == b"-"
signum = (offset < 0) and -1 or 1
offset = abs(offset)
hours = int(offset / 100)
minutes = offset % 100
return (
signum * (hours * 3600 + minutes * 60),
unnecessary_negative_timezone,
)
def format_timezone(offset, unnecessary_negative_timezone=False):
"""Format a timezone for Git serialization.
Args:
offset: Timezone offset as seconds difference to UTC
unnecessary_negative_timezone: Whether to use a minus sign for
UTC or positive timezones (-0000 and --700 rather than +0000 / +0700).
"""
if offset % 60 != 0:
raise ValueError("Unable to handle non-minute offset.")
if offset < 0 or unnecessary_negative_timezone:
sign = "-"
offset = -offset
else:
sign = "+"
return ("%c%02d%02d" % (sign, offset / 3600, (offset / 60) % 60)).encode("ascii")
def parse_time_entry(value):
"""Parse time entry behavior
Args:
value: Bytes representing a git commit/tag line
Raises:
ObjectFormatException in case of parsing error (malformed
field date)
Returns: Tuple of (author, time, (timezone, timezone_neg_utc))
"""
try:
sep = value.rindex(b"> ")
except ValueError:
return (value, None, (None, False))
try:
person = value[0 : sep + 1]
rest = value[sep + 2 :]
timetext, timezonetext = rest.rsplit(b" ", 1)
time = int(timetext)
timezone, timezone_neg_utc = parse_timezone(timezonetext)
except ValueError as e:
raise ObjectFormatException(e)
return person, time, (timezone, timezone_neg_utc)
def parse_commit(chunks):
"""Parse a commit object from chunks.
Args:
chunks: Chunks to parse
Returns: Tuple of (tree, parents, author_info, commit_info,
encoding, mergetag, gpgsig, message, extra)
"""
parents = []
extra = []
tree = None
author_info = (None, None, (None, None))
commit_info = (None, None, (None, None))
encoding = None
mergetag = []
message = None
gpgsig = None
for field, value in _parse_message(chunks):
# TODO(jelmer): Enforce ordering
if field == _TREE_HEADER:
tree = value
elif field == _PARENT_HEADER:
parents.append(value)
elif field == _AUTHOR_HEADER:
author_info = parse_time_entry(value)
elif field == _COMMITTER_HEADER:
commit_info = parse_time_entry(value)
elif field == _ENCODING_HEADER:
encoding = value
elif field == _MERGETAG_HEADER:
mergetag.append(Tag.from_string(value + b"\n"))
elif field == _GPGSIG_HEADER:
gpgsig = value
elif field is None:
message = value
else:
extra.append((field, value))
return (
tree,
parents,
author_info,
commit_info,
encoding,
mergetag,
gpgsig,
message,
extra,
)
class Commit(ShaFile):
"""A git commit object"""
type_name = b"commit"
type_num = 1
__slots__ = (
"_parents",
"_encoding",
"_extra",
"_author_timezone_neg_utc",
"_commit_timezone_neg_utc",
"_commit_time",
"_author_time",
"_author_timezone",
"_commit_timezone",
"_author",
"_committer",
"_tree",
"_message",
"_mergetag",
"_gpgsig",
)
def __init__(self):
super(Commit, self).__init__()
self._parents = []
self._encoding = None
self._mergetag = []
self._gpgsig = None
self._extra = []
self._author_timezone_neg_utc = False
self._commit_timezone_neg_utc = False
@classmethod
def from_path(cls, path):
commit = ShaFile.from_path(path)
if not isinstance(commit, cls):
raise NotCommitError(path)
return commit
def _deserialize(self, chunks):
(
self._tree,
self._parents,
author_info,
commit_info,
self._encoding,
self._mergetag,
self._gpgsig,
self._message,
self._extra,
) = parse_commit(chunks)
(
self._author,
self._author_time,
(self._author_timezone, self._author_timezone_neg_utc),
) = author_info
(
self._committer,
self._commit_time,
(self._commit_timezone, self._commit_timezone_neg_utc),
) = commit_info
def check(self):
"""Check this object for internal consistency.
Raises:
ObjectFormatException: if the object is malformed in some way
"""
super(Commit, self).check()
self._check_has_member("_tree", "missing tree")
self._check_has_member("_author", "missing author")
self._check_has_member("_committer", "missing committer")
self._check_has_member("_author_time", "missing author time")
self._check_has_member("_commit_time", "missing commit time")
for parent in self._parents:
check_hexsha(parent, "invalid parent sha")
check_hexsha(self._tree, "invalid tree sha")
check_identity(self._author, "invalid author")
check_identity(self._committer, "invalid committer")
check_time(self._author_time)
check_time(self._commit_time)
last = None
for field, _ in _parse_message(self._chunked_text):
if field == _TREE_HEADER and last is not None:
raise ObjectFormatException("unexpected tree")
elif field == _PARENT_HEADER and last not in (
_PARENT_HEADER,
_TREE_HEADER,
):
raise ObjectFormatException("unexpected parent")
elif field == _AUTHOR_HEADER and last not in (
_TREE_HEADER,
_PARENT_HEADER,
):
raise ObjectFormatException("unexpected author")
elif field == _COMMITTER_HEADER and last != _AUTHOR_HEADER:
raise ObjectFormatException("unexpected committer")
elif field == _ENCODING_HEADER and last != _COMMITTER_HEADER:
raise ObjectFormatException("unexpected encoding")
last = field
# TODO: optionally check for duplicate parents
def _serialize(self):
chunks = []
tree_bytes = self._tree.id if isinstance(self._tree, Tree) else self._tree
chunks.append(git_line(_TREE_HEADER, tree_bytes))
for p in self._parents:
chunks.append(git_line(_PARENT_HEADER, p))
chunks.append(
git_line(
_AUTHOR_HEADER,
self._author,
str(self._author_time).encode("ascii"),
format_timezone(self._author_timezone, self._author_timezone_neg_utc),
)
)
chunks.append(
git_line(
_COMMITTER_HEADER,
self._committer,
str(self._commit_time).encode("ascii"),
format_timezone(self._commit_timezone, self._commit_timezone_neg_utc),
)
)
if self.encoding:
chunks.append(git_line(_ENCODING_HEADER, self.encoding))
for mergetag in self.mergetag:
mergetag_chunks = mergetag.as_raw_string().split(b"\n")
chunks.append(git_line(_MERGETAG_HEADER, mergetag_chunks[0]))
# Embedded extra header needs leading space
for chunk in mergetag_chunks[1:]:
chunks.append(b" " + chunk + b"\n")
# No trailing empty line
if chunks[-1].endswith(b" \n"):
chunks[-1] = chunks[-1][:-2]
for k, v in self.extra:
if b"\n" in k or b"\n" in v:
raise AssertionError("newline in extra data: %r -> %r" % (k, v))
chunks.append(git_line(k, v))
if self.gpgsig:
sig_chunks = self.gpgsig.split(b"\n")
chunks.append(git_line(_GPGSIG_HEADER, sig_chunks[0]))
for chunk in sig_chunks[1:]:
chunks.append(git_line(b"", chunk))
chunks.append(b"\n") # There must be a new line after the headers
chunks.append(self._message)
return chunks
tree = serializable_property("tree", "Tree that is the state of this commit")
def _get_parents(self):
"""Return a list of parents of this commit."""
return self._parents
def _set_parents(self, value):
"""Set a list of parents of this commit."""
self._needs_serialization = True
self._parents = value
parents = property(
_get_parents,
_set_parents,
doc="Parents of this commit, by their SHA1.",
)
def _get_extra(self):
"""Return extra settings of this commit."""
return self._extra
extra = property(
_get_extra,
doc="Extra header fields not understood (presumably added in a "
"newer version of git). Kept verbatim so the object can "
"be correctly reserialized. For private commit metadata, use "
"pseudo-headers in Commit.message, rather than this field.",
)
author = serializable_property("author", "The name of the author of the commit")
committer = serializable_property(
"committer", "The name of the committer of the commit"
)
message = serializable_property("message", "The commit message")
commit_time = serializable_property(
"commit_time",
"The timestamp of the commit. As the number of seconds since the " "epoch.",
)
commit_timezone = serializable_property(
"commit_timezone", "The zone the commit time is in"
)
author_time = serializable_property(
"author_time",
"The timestamp the commit was written. As the number of "
"seconds since the epoch.",
)
author_timezone = serializable_property(
"author_timezone", "Returns the zone the author time is in."
)
encoding = serializable_property("encoding", "Encoding of the commit message.")
mergetag = serializable_property("mergetag", "Associated signed tag.")
gpgsig = serializable_property("gpgsig", "GPG Signature.")
OBJECT_CLASSES = (
Commit,
Tree,
Blob,
Tag,
)
_TYPE_MAP = {} # type: Dict[Union[bytes, int], Type[ShaFile]]
for cls in OBJECT_CLASSES:
_TYPE_MAP[cls.type_name] = cls
_TYPE_MAP[cls.type_num] = cls
# Hold on to the pure-python implementations for testing
_parse_tree_py = parse_tree
_sorted_tree_items_py = sorted_tree_items
try:
# Try to import C versions
from dulwich._objects import parse_tree, sorted_tree_items # type: ignore
except ImportError:
pass
diff --git a/dulwich/repo.py b/dulwich/repo.py
index 235e7177..29b0e669 100644
--- a/dulwich/repo.py
+++ b/dulwich/repo.py
@@ -1,1705 +1,1704 @@
# repo.py -- For dealing with git repositories.
# Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
# Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@jelmer.uk>
#
# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
# General Public License as public by the Free Software Foundation; version 2.0
# or (at your option) any later version. You can redistribute it and/or
# modify it under the terms of either of these two licenses.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# You should have received a copy of the licenses; if not, see
# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
# License, Version 2.0.
#
"""Repository access.
This module contains the base class for git repositories
(BaseRepo) and an implementation which uses a repository on
local disk (Repo).
"""
from io import BytesIO
import os
import sys
import stat
import time
from typing import Optional, Tuple, TYPE_CHECKING, List, Dict, Union, Iterable
if TYPE_CHECKING:
# There are no circular imports here, but we try to defer imports as long
# as possible to reduce start-up time for anything that doesn't need
# these imports.
from dulwich.config import StackedConfig, ConfigFile
from dulwich.index import Index
from dulwich.errors import (
NoIndexPresent,
NotBlobError,
NotCommitError,
NotGitRepository,
NotTreeError,
NotTagError,
CommitError,
RefFormatError,
HookError,
)
from dulwich.file import (
GitFile,
)
from dulwich.object_store import (
DiskObjectStore,
MemoryObjectStore,
BaseObjectStore,
ObjectStoreGraphWalker,
)
from dulwich.objects import (
check_hexsha,
valid_hexsha,
Blob,
Commit,
ShaFile,
Tag,
Tree,
)
from dulwich.pack import (
pack_objects_to_data,
)
from dulwich.hooks import (
Hook,
PreCommitShellHook,
PostCommitShellHook,
CommitMsgShellHook,
PostReceiveShellHook,
)
from dulwich.line_ending import BlobNormalizer, TreeBlobNormalizer
from dulwich.refs import ( # noqa: F401
ANNOTATED_TAG_SUFFIX,
check_ref_format,
RefsContainer,
DictRefsContainer,
InfoRefsContainer,
DiskRefsContainer,
read_packed_refs,
read_packed_refs_with_peeled,
write_packed_refs,
SYMREF,
)
import warnings
CONTROLDIR = ".git"
OBJECTDIR = "objects"
REFSDIR = "refs"
REFSDIR_TAGS = "tags"
REFSDIR_HEADS = "heads"
INDEX_FILENAME = "index"
COMMONDIR = "commondir"
GITDIR = "gitdir"
WORKTREES = "worktrees"
BASE_DIRECTORIES = [
["branches"],
[REFSDIR],
[REFSDIR, REFSDIR_TAGS],
[REFSDIR, REFSDIR_HEADS],
["hooks"],
["info"],
]
DEFAULT_REF = b"refs/heads/master"
class InvalidUserIdentity(Exception):
"""User identity is not of the format 'user <email>'"""
def __init__(self, identity):
self.identity = identity
def _get_default_identity() -> Tuple[str, str]:
import getpass
import socket
username = getpass.getuser()
try:
import pwd
except ImportError:
fullname = None
else:
try:
gecos = pwd.getpwnam(username).pw_gecos
except KeyError:
fullname = None
else:
fullname = gecos.split(",")[0]
if not fullname:
fullname = username
email = os.environ.get("EMAIL")
if email is None:
email = "{}@{}".format(username, socket.gethostname())
return (fullname, email)
def get_user_identity(config: "StackedConfig", kind: Optional[str] = None) -> bytes:
"""Determine the identity to use for new commits.
If kind is set, this first checks
GIT_${KIND}_NAME and GIT_${KIND}_EMAIL.
If those variables are not set, then it will fall back
to reading the user.name and user.email settings from
the specified configuration.
If that also fails, then it will fall back to using
the current users' identity as obtained from the host
system (e.g. the gecos field, $EMAIL, $USER@$(hostname -f).
Args:
kind: Optional kind to return identity for,
usually either "AUTHOR" or "COMMITTER".
Returns:
A user identity
"""
user = None # type: Optional[bytes]
email = None # type: Optional[bytes]
if kind:
user_uc = os.environ.get("GIT_" + kind + "_NAME")
if user_uc is not None:
user = user_uc.encode("utf-8")
email_uc = os.environ.get("GIT_" + kind + "_EMAIL")
if email_uc is not None:
email = email_uc.encode("utf-8")
if user is None:
try:
user = config.get(("user",), "name")
except KeyError:
user = None
if email is None:
try:
email = config.get(("user",), "email")
except KeyError:
email = None
default_user, default_email = _get_default_identity()
if user is None:
user = default_user.encode("utf-8")
if email is None:
email = default_email.encode("utf-8")
if email.startswith(b"<") and email.endswith(b">"):
email = email[1:-1]
return user + b" <" + email + b">"
def check_user_identity(identity):
"""Verify that a user identity is formatted correctly.
Args:
identity: User identity bytestring
Raises:
InvalidUserIdentity: Raised when identity is invalid
"""
try:
fst, snd = identity.split(b" <", 1)
except ValueError:
raise InvalidUserIdentity(identity)
if b">" not in snd:
raise InvalidUserIdentity(identity)
def parse_graftpoints(
graftpoints: Iterable[bytes],
) -> Dict[bytes, List[bytes]]:
"""Convert a list of graftpoints into a dict
Args:
graftpoints: Iterator of graftpoint lines
Each line is formatted as:
<commit sha1> <parent sha1> [<parent sha1>]*
Resulting dictionary is:
<commit sha1>: [<parent sha1>*]
https://git.wiki.kernel.org/index.php/GraftPoint
"""
grafts = {}
for line in graftpoints:
raw_graft = line.split(None, 1)
commit = raw_graft[0]
if len(raw_graft) == 2:
parents = raw_graft[1].split()
else:
parents = []
for sha in [commit] + parents:
check_hexsha(sha, "Invalid graftpoint")
grafts[commit] = parents
return grafts
def serialize_graftpoints(graftpoints: Dict[bytes, List[bytes]]) -> bytes:
"""Convert a dictionary of grafts into string
The graft dictionary is:
<commit sha1>: [<parent sha1>*]
Each line is formatted as:
<commit sha1> <parent sha1> [<parent sha1>]*
https://git.wiki.kernel.org/index.php/GraftPoint
"""
graft_lines = []
for commit, parents in graftpoints.items():
if parents:
graft_lines.append(commit + b" " + b" ".join(parents))
else:
graft_lines.append(commit)
return b"\n".join(graft_lines)
def _set_filesystem_hidden(path):
"""Mark path as to be hidden if supported by platform and filesystem.
On win32 uses SetFileAttributesW api:
<https://docs.microsoft.com/windows/desktop/api/fileapi/nf-fileapi-setfileattributesw>
"""
if sys.platform == "win32":
import ctypes
from ctypes.wintypes import BOOL, DWORD, LPCWSTR
FILE_ATTRIBUTE_HIDDEN = 2
SetFileAttributesW = ctypes.WINFUNCTYPE(BOOL, LPCWSTR, DWORD)(
("SetFileAttributesW", ctypes.windll.kernel32)
)
if isinstance(path, bytes):
path = os.fsdecode(path)
if not SetFileAttributesW(path, FILE_ATTRIBUTE_HIDDEN):
pass # Could raise or log `ctypes.WinError()` here
# Could implement other platform specific filesytem hiding here
class ParentsProvider(object):
def __init__(self, store, grafts={}, shallows=[]):
self.store = store
self.grafts = grafts
self.shallows = set(shallows)
def get_parents(self, commit_id, commit=None):
try:
return self.grafts[commit_id]
except KeyError:
pass
if commit_id in self.shallows:
return []
if commit is None:
commit = self.store[commit_id]
return commit.parents
class BaseRepo(object):
"""Base class for a git repository.
:ivar object_store: Dictionary-like object for accessing
the objects
:ivar refs: Dictionary-like object with the refs in this
repository
"""
def __init__(self, object_store: BaseObjectStore, refs: RefsContainer):
"""Open a repository.
This shouldn't be called directly, but rather through one of the
base classes, such as MemoryRepo or Repo.
Args:
object_store: Object store to use
refs: Refs container to use
"""
self.object_store = object_store
self.refs = refs
self._graftpoints = {} # type: Dict[bytes, List[bytes]]
self.hooks = {} # type: Dict[str, Hook]
def _determine_file_mode(self) -> bool:
"""Probe the file-system to determine whether permissions can be trusted.
Returns: True if permissions can be trusted, False otherwise.
"""
raise NotImplementedError(self._determine_file_mode)
def _init_files(self, bare: bool) -> None:
"""Initialize a default set of named files."""
from dulwich.config import ConfigFile
self._put_named_file("description", b"Unnamed repository")
f = BytesIO()
cf = ConfigFile()
cf.set("core", "repositoryformatversion", "0")
if self._determine_file_mode():
cf.set("core", "filemode", True)
else:
cf.set("core", "filemode", False)
cf.set("core", "bare", bare)
cf.set("core", "logallrefupdates", True)
cf.write_to_file(f)
self._put_named_file("config", f.getvalue())
self._put_named_file(os.path.join("info", "exclude"), b"")
def get_named_file(self, path):
"""Get a file from the control dir with a specific name.
Although the filename should be interpreted as a filename relative to
the control dir in a disk-based Repo, the object returned need not be
pointing to a file in that location.
Args:
path: The path to the file, relative to the control dir.
Returns: An open file object, or None if the file does not exist.
"""
raise NotImplementedError(self.get_named_file)
def _put_named_file(self, path, contents):
"""Write a file to the control dir with the given name and contents.
Args:
path: The path to the file, relative to the control dir.
contents: A string to write to the file.
"""
raise NotImplementedError(self._put_named_file)
def _del_named_file(self, path):
"""Delete a file in the contrl directory with the given name."""
raise NotImplementedError(self._del_named_file)
def open_index(self):
"""Open the index for this repository.
Raises:
NoIndexPresent: If no index is present
Returns: The matching `Index`
"""
raise NotImplementedError(self.open_index)
def fetch(self, target, determine_wants=None, progress=None, depth=None):
"""Fetch objects into another repository.
Args:
target: The target repository
determine_wants: Optional function to determine what refs to
fetch.
progress: Optional progress function
depth: Optional shallow fetch depth
Returns: The local refs
"""
if determine_wants is None:
determine_wants = target.object_store.determine_wants_all
count, pack_data = self.fetch_pack_data(
determine_wants,
target.get_graph_walker(),
progress=progress,
depth=depth,
)
target.object_store.add_pack_data(count, pack_data, progress)
return self.get_refs()
def fetch_pack_data(
self,
determine_wants,
graph_walker,
progress,
get_tagged=None,
depth=None,
):
"""Fetch the pack data required for a set of revisions.
Args:
determine_wants: Function that takes a dictionary with heads
and returns the list of heads to fetch.
graph_walker: Object that can iterate over the list of revisions
to fetch and has an "ack" method that will be called to acknowledge
that a revision is present.
progress: Simple progress function that will be called with
updated progress strings.
get_tagged: Function that returns a dict of pointed-to sha ->
tag sha for including tags.
depth: Shallow fetch depth
Returns: count and iterator over pack data
"""
# TODO(jelmer): Fetch pack data directly, don't create objects first.
objects = self.fetch_objects(
determine_wants, graph_walker, progress, get_tagged, depth=depth
)
return pack_objects_to_data(objects)
def fetch_objects(
self,
determine_wants,
graph_walker,
progress,
get_tagged=None,
depth=None,
):
"""Fetch the missing objects required for a set of revisions.
Args:
determine_wants: Function that takes a dictionary with heads
and returns the list of heads to fetch.
graph_walker: Object that can iterate over the list of revisions
to fetch and has an "ack" method that will be called to acknowledge
that a revision is present.
progress: Simple progress function that will be called with
updated progress strings.
get_tagged: Function that returns a dict of pointed-to sha ->
tag sha for including tags.
depth: Shallow fetch depth
Returns: iterator over objects, with __len__ implemented
"""
if depth not in (None, 0):
raise NotImplementedError("depth not supported yet")
refs = {}
for ref, sha in self.get_refs().items():
try:
obj = self.object_store[sha]
except KeyError:
warnings.warn(
"ref %s points at non-present sha %s"
% (ref.decode("utf-8", "replace"), sha.decode("ascii")),
UserWarning,
)
continue
else:
if isinstance(obj, Tag):
refs[ref + ANNOTATED_TAG_SUFFIX] = obj.object[1]
refs[ref] = sha
wants = determine_wants(refs)
if not isinstance(wants, list):
raise TypeError("determine_wants() did not return a list")
shallows = getattr(graph_walker, "shallow", frozenset())
unshallows = getattr(graph_walker, "unshallow", frozenset())
if wants == []:
# TODO(dborowitz): find a way to short-circuit that doesn't change
# this interface.
if shallows or unshallows:
# Do not send a pack in shallow short-circuit path
return None
return []
# If the graph walker is set up with an implementation that can
# ACK/NAK to the wire, it will write data to the client through
# this call as a side-effect.
haves = self.object_store.find_common_revisions(graph_walker)
# Deal with shallow requests separately because the haves do
# not reflect what objects are missing
if shallows or unshallows:
# TODO: filter the haves commits from iter_shas. the specific
# commits aren't missing.
haves = []
parents_provider = ParentsProvider(self.object_store, shallows=shallows)
def get_parents(commit):
return parents_provider.get_parents(commit.id, commit)
return self.object_store.iter_shas(
self.object_store.find_missing_objects(
haves,
wants,
self.get_shallow(),
progress,
get_tagged,
get_parents=get_parents,
)
)
def generate_pack_data(self, have, want, progress=None, ofs_delta=None):
"""Generate pack data objects for a set of wants/haves.
Args:
have: List of SHA1s of objects that should not be sent
want: List of SHA1s of objects that should be sent
ofs_delta: Whether OFS deltas can be included
progress: Optional progress reporting method
"""
return self.object_store.generate_pack_data(
have,
want,
shallow=self.get_shallow(),
progress=progress,
ofs_delta=ofs_delta,
)
def get_graph_walker(self, heads=None):
"""Retrieve a graph walker.
A graph walker is used by a remote repository (or proxy)
to find out which objects are present in this repository.
Args:
heads: Repository heads to use (optional)
Returns: A graph walker object
"""
if heads is None:
heads = [
sha
for sha in self.refs.as_dict(b"refs/heads").values()
if sha in self.object_store
]
parents_provider = ParentsProvider(self.object_store)
return ObjectStoreGraphWalker(
heads, parents_provider.get_parents, shallow=self.get_shallow()
)
def get_refs(self) -> Dict[bytes, bytes]:
"""Get dictionary with all refs.
Returns: A ``dict`` mapping ref names to SHA1s
"""
return self.refs.as_dict()
def head(self) -> bytes:
"""Return the SHA1 pointed at by HEAD."""
return self.refs[b"HEAD"]
def _get_object(self, sha, cls):
assert len(sha) in (20, 40)
ret = self.get_object(sha)
if not isinstance(ret, cls):
if cls is Commit:
raise NotCommitError(ret)
elif cls is Blob:
raise NotBlobError(ret)
elif cls is Tree:
raise NotTreeError(ret)
elif cls is Tag:
raise NotTagError(ret)
else:
raise Exception(
"Type invalid: %r != %r" % (ret.type_name, cls.type_name)
)
return ret
def get_object(self, sha: bytes) -> ShaFile:
"""Retrieve the object with the specified SHA.
Args:
sha: SHA to retrieve
Returns: A ShaFile object
Raises:
KeyError: when the object can not be found
"""
return self.object_store[sha]
def parents_provider(self):
return ParentsProvider(
self.object_store,
grafts=self._graftpoints,
shallows=self.get_shallow(),
)
def get_parents(self, sha: bytes, commit: Commit = None) -> List[bytes]:
"""Retrieve the parents of a specific commit.
If the specific commit is a graftpoint, the graft parents
will be returned instead.
Args:
sha: SHA of the commit for which to retrieve the parents
commit: Optional commit matching the sha
Returns: List of parents
"""
return self.parents_provider().get_parents(sha, commit)
def get_config(self):
"""Retrieve the config object.
Returns: `ConfigFile` object for the ``.git/config`` file.
"""
raise NotImplementedError(self.get_config)
def get_description(self):
"""Retrieve the description for this repository.
Returns: String with the description of the repository
as set by the user.
"""
raise NotImplementedError(self.get_description)
def set_description(self, description):
"""Set the description for this repository.
Args:
description: Text to set as description for this repository.
"""
raise NotImplementedError(self.set_description)
def get_config_stack(self) -> "StackedConfig":
"""Return a config stack for this repository.
This stack accesses the configuration for both this repository
itself (.git/config) and the global configuration, which usually
lives in ~/.gitconfig.
Returns: `Config` instance for this repository
"""
from dulwich.config import StackedConfig
backends = [self.get_config()] + StackedConfig.default_backends()
return StackedConfig(backends, writable=backends[0])
def get_shallow(self):
"""Get the set of shallow commits.
Returns: Set of shallow commits.
"""
f = self.get_named_file("shallow")
if f is None:
return set()
with f:
return {line.strip() for line in f}
def update_shallow(self, new_shallow, new_unshallow):
"""Update the list of shallow objects.
Args:
new_shallow: Newly shallow objects
new_unshallow: Newly no longer shallow objects
"""
shallow = self.get_shallow()
if new_shallow:
shallow.update(new_shallow)
if new_unshallow:
shallow.difference_update(new_unshallow)
if shallow:
self._put_named_file(
"shallow", b"".join([sha + b"\n" for sha in shallow])
)
else:
self._del_named_file("shallow")
def get_peeled(self, ref):
"""Get the peeled value of a ref.
Args:
ref: The refname to peel.
Returns: The fully-peeled SHA1 of a tag object, after peeling all
intermediate tags; if the original ref does not point to a tag,
this will equal the original SHA1.
"""
cached = self.refs.get_peeled(ref)
if cached is not None:
return cached
return self.object_store.peel_sha(self.refs[ref]).id
def get_walker(self, include=None, *args, **kwargs):
"""Obtain a walker for this repository.
Args:
include: Iterable of SHAs of commits to include along with their
ancestors. Defaults to [HEAD]
exclude: Iterable of SHAs of commits to exclude along with their
ancestors, overriding includes.
order: ORDER_* constant specifying the order of results.
Anything other than ORDER_DATE may result in O(n) memory usage.
reverse: If True, reverse the order of output, requiring O(n)
memory.
max_entries: The maximum number of entries to yield, or None for
no limit.
paths: Iterable of file or subtree paths to show entries for.
rename_detector: diff.RenameDetector object for detecting
renames.
follow: If True, follow path across renames/copies. Forces a
default rename_detector.
since: Timestamp to list commits after.
until: Timestamp to list commits before.
queue_cls: A class to use for a queue of commits, supporting the
iterator protocol. The constructor takes a single argument, the
Walker.
Returns: A `Walker` object
"""
from dulwich.walk import Walker
if include is None:
include = [self.head()]
if isinstance(include, str):
include = [include]
kwargs["get_parents"] = lambda commit: self.get_parents(commit.id, commit)
return Walker(self.object_store, include, *args, **kwargs)
def __getitem__(self, name):
"""Retrieve a Git object by SHA1 or ref.
Args:
name: A Git object SHA1 or a ref name
Returns: A `ShaFile` object, such as a Commit or Blob
Raises:
KeyError: when the specified ref or object does not exist
"""
if not isinstance(name, bytes):
raise TypeError(
"'name' must be bytestring, not %.80s" % type(name).__name__
)
if len(name) in (20, 40):
try:
return self.object_store[name]
except (KeyError, ValueError):
pass
try:
return self.object_store[self.refs[name]]
except RefFormatError:
raise KeyError(name)
def __contains__(self, name: bytes) -> bool:
"""Check if a specific Git object or ref is present.
Args:
name: Git object SHA1 or ref name
"""
if len(name) == 20 or (len(name) == 40 and valid_hexsha(name)):
return name in self.object_store or name in self.refs
else:
return name in self.refs
def __setitem__(self, name: bytes, value: Union[ShaFile, bytes]):
"""Set a ref.
Args:
name: ref name
value: Ref value - either a ShaFile object, or a hex sha
"""
if name.startswith(b"refs/") or name == b"HEAD":
if isinstance(value, ShaFile):
self.refs[name] = value.id
elif isinstance(value, bytes):
self.refs[name] = value
else:
raise TypeError(value)
else:
raise ValueError(name)
def __delitem__(self, name: bytes):
"""Remove a ref.
Args:
name: Name of the ref to remove
"""
if name.startswith(b"refs/") or name == b"HEAD":
del self.refs[name]
else:
raise ValueError(name)
def _get_user_identity(self, config: "StackedConfig", kind: str = None) -> bytes:
"""Determine the identity to use for new commits."""
# TODO(jelmer): Deprecate this function in favor of get_user_identity
return get_user_identity(config)
def _add_graftpoints(self, updated_graftpoints: Dict[bytes, List[bytes]]):
"""Add or modify graftpoints
Args:
updated_graftpoints: Dict of commit shas to list of parent shas
"""
# Simple validation
for commit, parents in updated_graftpoints.items():
for sha in [commit] + parents:
check_hexsha(sha, "Invalid graftpoint")
self._graftpoints.update(updated_graftpoints)
def _remove_graftpoints(self, to_remove: List[bytes] = []) -> None:
"""Remove graftpoints
Args:
to_remove: List of commit shas
"""
for sha in to_remove:
del self._graftpoints[sha]
def _read_heads(self, name):
f = self.get_named_file(name)
if f is None:
return []
with f:
return [line.strip() for line in f.readlines() if line.strip()]
def do_commit( # noqa: C901
self,
message=None,
committer=None,
author=None,
commit_timestamp=None,
commit_timezone=None,
author_timestamp=None,
author_timezone=None,
tree=None,
encoding=None,
ref=b"HEAD",
merge_heads=None,
no_verify=False,
):
"""Create a new commit.
If not specified, `committer` and `author` default to
get_user_identity(..., 'COMMITTER')
and get_user_identity(..., 'AUTHOR') respectively.
Args:
message: Commit message
committer: Committer fullname
author: Author fullname
commit_timestamp: Commit timestamp (defaults to now)
commit_timezone: Commit timestamp timezone (defaults to GMT)
author_timestamp: Author timestamp (defaults to commit
timestamp)
author_timezone: Author timestamp timezone
(defaults to commit timestamp timezone)
tree: SHA1 of the tree root to use (if not specified the
current index will be committed).
encoding: Encoding
ref: Optional ref to commit to (defaults to current branch)
merge_heads: Merge heads (defaults to .git/MERGE_HEAD)
no_verify: Skip pre-commit and commit-msg hooks
Returns:
New commit SHA1
"""
+ try:
+ if not no_verify:
+ self.hooks["pre-commit"].execute()
+ except HookError as e:
+ raise CommitError(e)
+ except KeyError: # no hook defined, silent fallthrough
+ pass
+
c = Commit()
if tree is None:
index = self.open_index()
c.tree = index.commit(self.object_store)
else:
if len(tree) != 40:
raise ValueError("tree must be a 40-byte hex sha string")
c.tree = tree
- try:
- if not no_verify:
- self.hooks["pre-commit"].execute()
- except HookError as e:
- raise CommitError(e)
- except KeyError: # no hook defined, silent fallthrough
- pass
-
config = self.get_config_stack()
if merge_heads is None:
merge_heads = self._read_heads("MERGE_HEAD")
if committer is None:
committer = get_user_identity(config, kind="COMMITTER")
check_user_identity(committer)
c.committer = committer
if commit_timestamp is None:
# FIXME: Support GIT_COMMITTER_DATE environment variable
commit_timestamp = time.time()
c.commit_time = int(commit_timestamp)
if commit_timezone is None:
# FIXME: Use current user timezone rather than UTC
commit_timezone = 0
c.commit_timezone = commit_timezone
if author is None:
author = get_user_identity(config, kind="AUTHOR")
c.author = author
check_user_identity(author)
if author_timestamp is None:
# FIXME: Support GIT_AUTHOR_DATE environment variable
author_timestamp = commit_timestamp
c.author_time = int(author_timestamp)
if author_timezone is None:
author_timezone = commit_timezone
c.author_timezone = author_timezone
if encoding is None:
try:
encoding = config.get(("i18n",), "commitEncoding")
except KeyError:
pass # No dice
if encoding is not None:
c.encoding = encoding
if message is None:
# FIXME: Try to read commit message from .git/MERGE_MSG
raise ValueError("No commit message specified")
try:
if no_verify:
c.message = message
else:
c.message = self.hooks["commit-msg"].execute(message)
if c.message is None:
c.message = message
except HookError as e:
raise CommitError(e)
except KeyError: # no hook defined, message not modified
c.message = message
if ref is None:
# Create a dangling commit
c.parents = merge_heads
self.object_store.add_object(c)
else:
try:
old_head = self.refs[ref]
c.parents = [old_head] + merge_heads
self.object_store.add_object(c)
ok = self.refs.set_if_equals(
ref,
old_head,
c.id,
message=b"commit: " + message,
committer=committer,
timestamp=commit_timestamp,
timezone=commit_timezone,
)
except KeyError:
c.parents = merge_heads
self.object_store.add_object(c)
ok = self.refs.add_if_new(
ref,
c.id,
message=b"commit: " + message,
committer=committer,
timestamp=commit_timestamp,
timezone=commit_timezone,
)
if not ok:
# Fail if the atomic compare-and-swap failed, leaving the
# commit and all its objects as garbage.
raise CommitError("%s changed during commit" % (ref,))
self._del_named_file("MERGE_HEAD")
try:
self.hooks["post-commit"].execute()
except HookError as e: # silent failure
warnings.warn("post-commit hook failed: %s" % e, UserWarning)
except KeyError: # no hook defined, silent fallthrough
pass
return c.id
def read_gitfile(f):
"""Read a ``.git`` file.
The first line of the file should start with "gitdir: "
Args:
f: File-like object to read from
Returns: A path
"""
cs = f.read()
if not cs.startswith("gitdir: "):
raise ValueError("Expected file to start with 'gitdir: '")
return cs[len("gitdir: ") :].rstrip("\n")
class UnsupportedVersion(Exception):
"""Unsupported repository version."""
def __init__(self, version):
self.version = version
class Repo(BaseRepo):
"""A git repository backed by local disk.
To open an existing repository, call the contructor with
the path of the repository.
To create a new repository, use the Repo.init class method.
"""
def __init__(self, root, object_store=None, bare=None):
hidden_path = os.path.join(root, CONTROLDIR)
if bare is None:
if (os.path.isfile(hidden_path) or
os.path.isdir(os.path.join(hidden_path, OBJECTDIR))):
bare = False
elif (os.path.isdir(os.path.join(root, OBJECTDIR)) and
os.path.isdir(os.path.join(root, REFSDIR))):
bare = True
else:
raise NotGitRepository(
"No git repository was found at %(path)s" % dict(path=root)
)
self.bare = bare
if bare is False:
if os.path.isfile(hidden_path):
with open(hidden_path, "r") as f:
path = read_gitfile(f)
- self.bare = False
self._controldir = os.path.join(root, path)
else:
self._controldir = hidden_path
else:
self._controldir = root
commondir = self.get_named_file(COMMONDIR)
if commondir is not None:
with commondir:
self._commondir = os.path.join(
self.controldir(),
os.fsdecode(commondir.read().rstrip(b"\r\n")),
)
else:
self._commondir = self._controldir
self.path = root
config = self.get_config()
try:
format_version = int(config.get("core", "repositoryformatversion"))
except KeyError:
format_version = 0
if format_version != 0:
raise UnsupportedVersion(format_version)
if object_store is None:
object_store = DiskObjectStore.from_config(
os.path.join(self.commondir(), OBJECTDIR), config
)
refs = DiskRefsContainer(
self.commondir(), self._controldir, logger=self._write_reflog
)
BaseRepo.__init__(self, object_store, refs)
self._graftpoints = {}
graft_file = self.get_named_file(
os.path.join("info", "grafts"), basedir=self.commondir()
)
if graft_file:
with graft_file:
self._graftpoints.update(parse_graftpoints(graft_file))
graft_file = self.get_named_file("shallow", basedir=self.commondir())
if graft_file:
with graft_file:
self._graftpoints.update(parse_graftpoints(graft_file))
- self.hooks["pre-commit"] = PreCommitShellHook(self.controldir())
+ self.hooks["pre-commit"] = PreCommitShellHook(self.path, self.controldir())
self.hooks["commit-msg"] = CommitMsgShellHook(self.controldir())
self.hooks["post-commit"] = PostCommitShellHook(self.controldir())
self.hooks["post-receive"] = PostReceiveShellHook(self.controldir())
def _write_reflog(
self, ref, old_sha, new_sha, committer, timestamp, timezone, message
):
from .reflog import format_reflog_line
path = os.path.join(self.controldir(), "logs", os.fsdecode(ref))
try:
os.makedirs(os.path.dirname(path))
except FileExistsError:
pass
if committer is None:
config = self.get_config_stack()
committer = self._get_user_identity(config)
check_user_identity(committer)
if timestamp is None:
timestamp = int(time.time())
if timezone is None:
timezone = 0 # FIXME
with open(path, "ab") as f:
f.write(
format_reflog_line(
old_sha, new_sha, committer, timestamp, timezone, message
)
+ b"\n"
)
@classmethod
def discover(cls, start="."):
"""Iterate parent directories to discover a repository
Return a Repo object for the first parent directory that looks like a
Git repository.
Args:
start: The directory to start discovery from (defaults to '.')
"""
remaining = True
path = os.path.abspath(start)
while remaining:
try:
return cls(path)
except NotGitRepository:
path, remaining = os.path.split(path)
raise NotGitRepository(
"No git repository was found at %(path)s" % dict(path=start)
)
def controldir(self):
"""Return the path of the control directory."""
return self._controldir
def commondir(self):
"""Return the path of the common directory.
For a main working tree, it is identical to controldir().
For a linked working tree, it is the control directory of the
main working tree."""
return self._commondir
def _determine_file_mode(self):
"""Probe the file-system to determine whether permissions can be trusted.
Returns: True if permissions can be trusted, False otherwise.
"""
fname = os.path.join(self.path, ".probe-permissions")
with open(fname, "w") as f:
f.write("")
st1 = os.lstat(fname)
try:
os.chmod(fname, st1.st_mode ^ stat.S_IXUSR)
except PermissionError:
return False
st2 = os.lstat(fname)
os.unlink(fname)
mode_differs = st1.st_mode != st2.st_mode
st2_has_exec = (st2.st_mode & stat.S_IXUSR) != 0
return mode_differs and st2_has_exec
def _put_named_file(self, path, contents):
"""Write a file to the control dir with the given name and contents.
Args:
path: The path to the file, relative to the control dir.
contents: A string to write to the file.
"""
path = path.lstrip(os.path.sep)
with GitFile(os.path.join(self.controldir(), path), "wb") as f:
f.write(contents)
def _del_named_file(self, path):
try:
os.unlink(os.path.join(self.controldir(), path))
except FileNotFoundError:
return
def get_named_file(self, path, basedir=None):
"""Get a file from the control dir with a specific name.
Although the filename should be interpreted as a filename relative to
the control dir in a disk-based Repo, the object returned need not be
pointing to a file in that location.
Args:
path: The path to the file, relative to the control dir.
basedir: Optional argument that specifies an alternative to the
control dir.
Returns: An open file object, or None if the file does not exist.
"""
# TODO(dborowitz): sanitize filenames, since this is used directly by
# the dumb web serving code.
if basedir is None:
basedir = self.controldir()
path = path.lstrip(os.path.sep)
try:
return open(os.path.join(basedir, path), "rb")
except FileNotFoundError:
return None
def index_path(self):
"""Return path to the index file."""
return os.path.join(self.controldir(), INDEX_FILENAME)
def open_index(self) -> "Index":
"""Open the index for this repository.
Raises:
NoIndexPresent: If no index is present
Returns: The matching `Index`
"""
from dulwich.index import Index
if not self.has_index():
raise NoIndexPresent()
return Index(self.index_path())
def has_index(self):
"""Check if an index is present."""
# Bare repos must never have index files; non-bare repos may have a
# missing index file, which is treated as empty.
return not self.bare
def stage(self, fs_paths: Union[str, bytes, os.PathLike, Iterable[Union[str, bytes, os.PathLike]]]) -> None:
"""Stage a set of paths.
Args:
fs_paths: List of paths, relative to the repository path
"""
root_path_bytes = os.fsencode(self.path)
if isinstance(fs_paths, (str, bytes, os.PathLike)):
fs_paths = [fs_paths]
fs_paths = list(fs_paths)
from dulwich.index import (
blob_from_path_and_stat,
index_entry_from_stat,
_fs_to_tree_path,
)
index = self.open_index()
blob_normalizer = self.get_blob_normalizer()
for fs_path in fs_paths:
if not isinstance(fs_path, bytes):
fs_path = os.fsencode(fs_path)
if os.path.isabs(fs_path):
raise ValueError(
"path %r should be relative to "
"repository root, not absolute" % fs_path
)
tree_path = _fs_to_tree_path(fs_path)
full_path = os.path.join(root_path_bytes, fs_path)
try:
st = os.lstat(full_path)
except OSError:
# File no longer exists
try:
del index[tree_path]
except KeyError:
pass # already removed
else:
if not stat.S_ISREG(st.st_mode) and not stat.S_ISLNK(st.st_mode):
try:
del index[tree_path]
except KeyError:
pass
else:
blob = blob_from_path_and_stat(full_path, st)
blob = blob_normalizer.checkin_normalize(blob, fs_path)
self.object_store.add_object(blob)
index[tree_path] = index_entry_from_stat(st, blob.id, 0)
index.write()
def unstage(self, fs_paths: List[str]):
"""unstage specific file in the index
Args:
fs_paths: a list of files to unstage,
relative to the repository path
"""
from dulwich.index import (
IndexEntry,
_fs_to_tree_path,
)
index = self.open_index()
try:
tree_id = self[b'HEAD'].tree
except KeyError:
# no head mean no commit in the repo
for fs_path in fs_paths:
tree_path = _fs_to_tree_path(fs_path)
del index[tree_path]
index.write()
return
for fs_path in fs_paths:
tree_path = _fs_to_tree_path(fs_path)
try:
tree_entry = self.object_store[tree_id].lookup_path(
self.object_store.__getitem__, tree_path)
except KeyError:
# if tree_entry didnt exist, this file was being added, so
# remove index entry
try:
del index[tree_path]
continue
except KeyError:
raise KeyError("file '%s' not in index" % (tree_path.decode()))
st = None
try:
st = os.lstat(os.path.join(self.path, fs_path))
except FileNotFoundError:
pass
index_entry = IndexEntry(
ctime=(self[b'HEAD'].commit_time, 0),
mtime=(self[b'HEAD'].commit_time, 0),
dev=st.st_dev if st else 0,
ino=st.st_ino if st else 0,
mode=tree_entry[0],
uid=st.st_uid if st else 0,
gid=st.st_gid if st else 0,
size=len(self[tree_entry[1]].data),
sha=tree_entry[1],
flags=0,
extended_flags=0
)
index[tree_path] = index_entry
index.write()
def clone(
self,
target_path,
mkdir=True,
bare=False,
origin=b"origin",
checkout=None,
):
"""Clone this repository.
Args:
target_path: Target path
mkdir: Create the target directory
bare: Whether to create a bare repository
origin: Base name for refs in target repository
cloned from this repository
Returns: Created repository as `Repo`
"""
if not bare:
target = self.init(target_path, mkdir=mkdir)
else:
if checkout:
raise ValueError("checkout and bare are incompatible")
target = self.init_bare(target_path, mkdir=mkdir)
self.fetch(target)
encoded_path = self.path
if not isinstance(encoded_path, bytes):
encoded_path = os.fsencode(encoded_path)
ref_message = b"clone: from " + encoded_path
target.refs.import_refs(
b"refs/remotes/" + origin,
self.refs.as_dict(b"refs/heads"),
message=ref_message,
)
target.refs.import_refs(
b"refs/tags", self.refs.as_dict(b"refs/tags"), message=ref_message
)
try:
target.refs.add_if_new(
DEFAULT_REF, self.refs[DEFAULT_REF], message=ref_message
)
except KeyError:
pass
target_config = target.get_config()
target_config.set(("remote", "origin"), "url", encoded_path)
target_config.set(
("remote", "origin"),
"fetch",
"+refs/heads/*:refs/remotes/origin/*",
)
target_config.write_to_path()
# Update target head
head_chain, head_sha = self.refs.follow(b"HEAD")
if head_chain and head_sha is not None:
target.refs.set_symbolic_ref(b"HEAD", head_chain[-1], message=ref_message)
target[b"HEAD"] = head_sha
if checkout is None:
checkout = not bare
if checkout:
# Checkout HEAD to target dir
target.reset_index()
return target
def reset_index(self, tree=None):
"""Reset the index back to a specific tree.
Args:
tree: Tree SHA to reset to, None for current HEAD tree.
"""
from dulwich.index import (
build_index_from_tree,
validate_path_element_default,
validate_path_element_ntfs,
)
if tree is None:
tree = self[b"HEAD"].tree
config = self.get_config()
honor_filemode = config.get_boolean(b"core", b"filemode", os.name != "nt")
if config.get_boolean(b"core", b"core.protectNTFS", os.name == "nt"):
validate_path_element = validate_path_element_ntfs
else:
validate_path_element = validate_path_element_default
return build_index_from_tree(
self.path,
self.index_path(),
self.object_store,
tree,
honor_filemode=honor_filemode,
validate_path_element=validate_path_element,
)
def get_config(self) -> "ConfigFile":
"""Retrieve the config object.
Returns: `ConfigFile` object for the ``.git/config`` file.
"""
from dulwich.config import ConfigFile
path = os.path.join(self._controldir, "config")
try:
return ConfigFile.from_path(path)
except FileNotFoundError:
ret = ConfigFile()
ret.path = path
return ret
def get_description(self):
"""Retrieve the description of this repository.
Returns: A string describing the repository or None.
"""
path = os.path.join(self._controldir, "description")
try:
with GitFile(path, "rb") as f:
return f.read()
except FileNotFoundError:
return None
def __repr__(self):
return "<Repo at %r>" % self.path
def set_description(self, description):
"""Set the description for this repository.
Args:
description: Text to set as description for this repository.
"""
self._put_named_file("description", description)
@classmethod
def _init_maybe_bare(cls, path, controldir, bare, object_store=None):
for d in BASE_DIRECTORIES:
os.mkdir(os.path.join(controldir, *d))
if object_store is None:
object_store = DiskObjectStore.init(os.path.join(controldir, OBJECTDIR))
ret = cls(path, bare=bare, object_store=object_store)
ret.refs.set_symbolic_ref(b"HEAD", DEFAULT_REF)
ret._init_files(bare)
return ret
@classmethod
def init(cls, path, mkdir=False):
"""Create a new repository.
Args:
path: Path in which to create the repository
mkdir: Whether to create the directory
Returns: `Repo` instance
"""
if mkdir:
os.mkdir(path)
controldir = os.path.join(path, CONTROLDIR)
os.mkdir(controldir)
_set_filesystem_hidden(controldir)
return cls._init_maybe_bare(path, controldir, False)
@classmethod
def _init_new_working_directory(cls, path, main_repo, identifier=None, mkdir=False):
"""Create a new working directory linked to a repository.
Args:
path: Path in which to create the working tree.
main_repo: Main repository to reference
identifier: Worktree identifier
mkdir: Whether to create the directory
Returns: `Repo` instance
"""
if mkdir:
os.mkdir(path)
if identifier is None:
identifier = os.path.basename(path)
main_worktreesdir = os.path.join(main_repo.controldir(), WORKTREES)
worktree_controldir = os.path.join(main_worktreesdir, identifier)
gitdirfile = os.path.join(path, CONTROLDIR)
with open(gitdirfile, "wb") as f:
f.write(b"gitdir: " + os.fsencode(worktree_controldir) + b"\n")
try:
os.mkdir(main_worktreesdir)
except FileExistsError:
pass
try:
os.mkdir(worktree_controldir)
except FileExistsError:
pass
with open(os.path.join(worktree_controldir, GITDIR), "wb") as f:
f.write(os.fsencode(gitdirfile) + b"\n")
with open(os.path.join(worktree_controldir, COMMONDIR), "wb") as f:
f.write(b"../..\n")
with open(os.path.join(worktree_controldir, "HEAD"), "wb") as f:
f.write(main_repo.head() + b"\n")
r = cls(path)
r.reset_index()
return r
@classmethod
def init_bare(cls, path, mkdir=False, object_store=None):
"""Create a new bare repository.
``path`` should already exist and be an empty directory.
Args:
path: Path to create bare repository in
Returns: a `Repo` instance
"""
if mkdir:
os.mkdir(path)
return cls._init_maybe_bare(path, path, True, object_store=object_store)
create = init_bare
def close(self):
"""Close any files opened by this repository."""
self.object_store.close()
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
def get_blob_normalizer(self):
"""Return a BlobNormalizer object"""
# TODO Parse the git attributes files
git_attributes = {}
config_stack = self.get_config_stack()
try:
tree = self.object_store[self.refs[b"HEAD"]].tree
return TreeBlobNormalizer(
config_stack,
git_attributes,
self.object_store,
tree,
)
except KeyError:
return BlobNormalizer(config_stack, git_attributes)
class MemoryRepo(BaseRepo):
"""Repo that stores refs, objects, and named files in memory.
MemoryRepos are always bare: they have no working tree and no index, since
those have a stronger dependency on the filesystem.
"""
def __init__(self):
from dulwich.config import ConfigFile
self._reflog = []
refs_container = DictRefsContainer({}, logger=self._append_reflog)
BaseRepo.__init__(self, MemoryObjectStore(), refs_container)
self._named_files = {}
self.bare = True
self._config = ConfigFile()
self._description = None
def _append_reflog(self, *args):
self._reflog.append(args)
def set_description(self, description):
self._description = description
def get_description(self):
return self._description
def _determine_file_mode(self):
"""Probe the file-system to determine whether permissions can be trusted.
Returns: True if permissions can be trusted, False otherwise.
"""
return sys.platform != "win32"
def _put_named_file(self, path, contents):
"""Write a file to the control dir with the given name and contents.
Args:
path: The path to the file, relative to the control dir.
contents: A string to write to the file.
"""
self._named_files[path] = contents
def _del_named_file(self, path):
try:
del self._named_files[path]
except KeyError:
pass
def get_named_file(self, path, basedir=None):
"""Get a file from the control dir with a specific name.
Although the filename should be interpreted as a filename relative to
the control dir in a disk-baked Repo, the object returned need not be
pointing to a file in that location.
Args:
path: The path to the file, relative to the control dir.
Returns: An open file object, or None if the file does not exist.
"""
contents = self._named_files.get(path, None)
if contents is None:
return None
return BytesIO(contents)
def open_index(self):
"""Fail to open index for this repo, since it is bare.
Raises:
NoIndexPresent: Raised when no index is present
"""
raise NoIndexPresent()
def get_config(self):
"""Retrieve the config object.
Returns: `ConfigFile` object.
"""
return self._config
@classmethod
def init_bare(cls, objects, refs):
"""Create a new bare repository in memory.
Args:
objects: Objects for the new repository,
as iterable
refs: Refs as dictionary, mapping names
to object SHA1s
"""
ret = cls()
for obj in objects:
ret.object_store.add_object(obj)
for refname, sha in refs.items():
ret.refs.add_if_new(refname, sha)
ret._init_files(bare=True)
return ret
diff --git a/dulwich/tests/test_hooks.py b/dulwich/tests/test_hooks.py
index b3fb0e29..6e416f1d 100644
--- a/dulwich/tests/test_hooks.py
+++ b/dulwich/tests/test_hooks.py
@@ -1,192 +1,192 @@
# test_hooks.py -- Tests for executing hooks
#
# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
# General Public License as public by the Free Software Foundation; version 2.0
# or (at your option) any later version. You can redistribute it and/or
# modify it under the terms of either of these two licenses.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# You should have received a copy of the licenses; if not, see
# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
# License, Version 2.0.
#
"""Tests for executing hooks."""
import os
import stat
import shutil
import sys
import tempfile
from dulwich import errors
from dulwich.hooks import (
PreCommitShellHook,
PostCommitShellHook,
CommitMsgShellHook,
)
from dulwich.tests import TestCase
class ShellHookTests(TestCase):
def setUp(self):
super(ShellHookTests, self).setUp()
if os.name != "posix":
self.skipTest("shell hook tests requires POSIX shell")
self.assertTrue(os.path.exists("/bin/sh"))
def test_hook_pre_commit(self):
repo_dir = os.path.join(tempfile.mkdtemp())
os.mkdir(os.path.join(repo_dir, "hooks"))
self.addCleanup(shutil.rmtree, repo_dir)
pre_commit_fail = """#!/bin/sh
exit 1
"""
pre_commit_success = """#!/bin/sh
exit 0
"""
pre_commit_cwd = (
"""#!/bin/sh
if [ "$(pwd)" != '"""
+ repo_dir
+ """' ]; then
echo "Expected path '"""
+ repo_dir
+ """', got '$(pwd)'"
exit 1
fi
exit 0
"""
)
pre_commit = os.path.join(repo_dir, "hooks", "pre-commit")
- hook = PreCommitShellHook(repo_dir)
+ hook = PreCommitShellHook(repo_dir, repo_dir)
with open(pre_commit, "w") as f:
f.write(pre_commit_fail)
os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
self.assertRaises(errors.HookError, hook.execute)
if sys.platform != "darwin":
# Don't bother running this test on darwin since path
# canonicalization messages with our simple string comparison.
with open(pre_commit, "w") as f:
f.write(pre_commit_cwd)
os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
hook.execute()
with open(pre_commit, "w") as f:
f.write(pre_commit_success)
os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
hook.execute()
def test_hook_commit_msg(self):
repo_dir = os.path.join(tempfile.mkdtemp())
os.mkdir(os.path.join(repo_dir, "hooks"))
self.addCleanup(shutil.rmtree, repo_dir)
commit_msg_fail = """#!/bin/sh
exit 1
"""
commit_msg_success = """#!/bin/sh
exit 0
"""
commit_msg_cwd = (
"""#!/bin/sh
if [ "$(pwd)" = '"""
+ repo_dir
+ "' ]; then exit 0; else exit 1; fi\n"
)
commit_msg = os.path.join(repo_dir, "hooks", "commit-msg")
hook = CommitMsgShellHook(repo_dir)
with open(commit_msg, "w") as f:
f.write(commit_msg_fail)
os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
self.assertRaises(errors.HookError, hook.execute, b"failed commit")
if sys.platform != "darwin":
# Don't bother running this test on darwin since path
# canonicalization messages with our simple string comparison.
with open(commit_msg, "w") as f:
f.write(commit_msg_cwd)
os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
hook.execute(b"cwd test commit")
with open(commit_msg, "w") as f:
f.write(commit_msg_success)
os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
hook.execute(b"empty commit")
def test_hook_post_commit(self):
(fd, path) = tempfile.mkstemp()
os.close(fd)
repo_dir = os.path.join(tempfile.mkdtemp())
os.mkdir(os.path.join(repo_dir, "hooks"))
self.addCleanup(shutil.rmtree, repo_dir)
post_commit_success = (
"""#!/bin/sh
rm """
+ path
+ "\n"
)
post_commit_fail = """#!/bin/sh
exit 1
"""
post_commit_cwd = (
"""#!/bin/sh
if [ "$(pwd)" = '"""
+ repo_dir
+ "' ]; then exit 0; else exit 1; fi\n"
)
post_commit = os.path.join(repo_dir, "hooks", "post-commit")
hook = PostCommitShellHook(repo_dir)
with open(post_commit, "w") as f:
f.write(post_commit_fail)
os.chmod(post_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
self.assertRaises(errors.HookError, hook.execute)
if sys.platform != "darwin":
# Don't bother running this test on darwin since path
# canonicalization messages with our simple string comparison.
with open(post_commit, "w") as f:
f.write(post_commit_cwd)
os.chmod(post_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
hook.execute()
with open(post_commit, "w") as f:
f.write(post_commit_success)
os.chmod(post_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
hook.execute()
self.assertFalse(os.path.exists(path))
diff --git a/dulwich/tests/test_object_store.py b/dulwich/tests/test_object_store.py
index 68789aac..2f0329f2 100644
--- a/dulwich/tests/test_object_store.py
+++ b/dulwich/tests/test_object_store.py
@@ -1,796 +1,805 @@
# test_object_store.py -- tests for object_store.py
# Copyright (C) 2008 Jelmer Vernooij <jelmer@jelmer.uk>
#
# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
# General Public License as public by the Free Software Foundation; version 2.0
# or (at your option) any later version. You can redistribute it and/or
# modify it under the terms of either of these two licenses.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# You should have received a copy of the licenses; if not, see
# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
# License, Version 2.0.
#
"""Tests for the object store interface."""
from contextlib import closing
from io import BytesIO
from unittest import skipUnless
import os
import shutil
import stat
import sys
import tempfile
from dulwich.index import (
commit_tree,
)
from dulwich.errors import (
NotTreeError,
)
from dulwich.objects import (
sha_to_hex,
Blob,
Tree,
TreeEntry,
EmptyFileException,
+ SubmoduleEncountered,
+ S_IFGITLINK,
)
from dulwich.object_store import (
DiskObjectStore,
MemoryObjectStore,
OverlayObjectStore,
ObjectStoreGraphWalker,
commit_tree_changes,
read_packs_file,
tree_lookup_path,
)
from dulwich.pack import (
REF_DELTA,
write_pack_objects,
)
from dulwich.protocol import DEPTH_INFINITE
from dulwich.tests import (
TestCase,
)
from dulwich.tests.utils import (
make_object,
make_tag,
build_pack,
)
try:
from unittest.mock import patch
except ImportError:
patch = None # type: ignore
testobject = make_object(Blob, data=b"yummy data")
class ObjectStoreTests(object):
def test_determine_wants_all(self):
self.assertEqual(
[b"1" * 40],
self.store.determine_wants_all({b"refs/heads/foo": b"1" * 40}),
)
def test_determine_wants_all_zero(self):
self.assertEqual(
[], self.store.determine_wants_all({b"refs/heads/foo": b"0" * 40})
)
@skipUnless(patch, "Required mock.patch")
def test_determine_wants_all_depth(self):
self.store.add_object(testobject)
refs = {b"refs/heads/foo": testobject.id}
with patch.object(self.store, "_get_depth", return_value=1) as m:
self.assertEqual(
[], self.store.determine_wants_all(refs, depth=0)
)
self.assertEqual(
[testobject.id],
self.store.determine_wants_all(refs, depth=DEPTH_INFINITE),
)
m.assert_not_called()
self.assertEqual(
[], self.store.determine_wants_all(refs, depth=1)
)
m.assert_called_with(testobject.id)
self.assertEqual(
[testobject.id], self.store.determine_wants_all(refs, depth=2)
)
def test_get_depth(self):
self.assertEqual(
0, self.store._get_depth(testobject.id)
)
self.store.add_object(testobject)
self.assertEqual(
1, self.store._get_depth(testobject.id, get_parents=lambda x: [])
)
parent = make_object(Blob, data=b"parent data")
self.store.add_object(parent)
self.assertEqual(
2,
self.store._get_depth(
testobject.id,
get_parents=lambda x: [parent.id] if x == testobject else [],
),
)
def test_iter(self):
self.assertEqual([], list(self.store))
def test_get_nonexistant(self):
self.assertRaises(KeyError, lambda: self.store[b"a" * 40])
def test_contains_nonexistant(self):
self.assertFalse((b"a" * 40) in self.store)
def test_add_objects_empty(self):
self.store.add_objects([])
def test_add_commit(self):
# TODO: Argh, no way to construct Git commit objects without
# access to a serialized form.
self.store.add_objects([])
def test_store_resilience(self):
"""Test if updating an existing stored object doesn't erase the
object from the store.
"""
test_object = make_object(Blob, data=b"data")
self.store.add_object(test_object)
test_object_id = test_object.id
test_object.data = test_object.data + b"update"
stored_test_object = self.store[test_object_id]
self.assertNotEqual(test_object.id, stored_test_object.id)
self.assertEqual(stored_test_object.id, test_object_id)
def test_add_object(self):
self.store.add_object(testobject)
self.assertEqual(set([testobject.id]), set(self.store))
self.assertTrue(testobject.id in self.store)
r = self.store[testobject.id]
self.assertEqual(r, testobject)
def test_add_objects(self):
data = [(testobject, "mypath")]
self.store.add_objects(data)
self.assertEqual(set([testobject.id]), set(self.store))
self.assertTrue(testobject.id in self.store)
r = self.store[testobject.id]
self.assertEqual(r, testobject)
def test_tree_changes(self):
blob_a1 = make_object(Blob, data=b"a1")
blob_a2 = make_object(Blob, data=b"a2")
blob_b = make_object(Blob, data=b"b")
for blob in [blob_a1, blob_a2, blob_b]:
self.store.add_object(blob)
blobs_1 = [(b"a", blob_a1.id, 0o100644), (b"b", blob_b.id, 0o100644)]
tree1_id = commit_tree(self.store, blobs_1)
blobs_2 = [(b"a", blob_a2.id, 0o100644), (b"b", blob_b.id, 0o100644)]
tree2_id = commit_tree(self.store, blobs_2)
change_a = (
(b"a", b"a"),
(0o100644, 0o100644),
(blob_a1.id, blob_a2.id),
)
self.assertEqual([change_a], list(self.store.tree_changes(tree1_id, tree2_id)))
self.assertEqual(
[
change_a,
((b"b", b"b"), (0o100644, 0o100644), (blob_b.id, blob_b.id)),
],
list(self.store.tree_changes(tree1_id, tree2_id, want_unchanged=True)),
)
def test_iter_tree_contents(self):
blob_a = make_object(Blob, data=b"a")
blob_b = make_object(Blob, data=b"b")
blob_c = make_object(Blob, data=b"c")
for blob in [blob_a, blob_b, blob_c]:
self.store.add_object(blob)
blobs = [
(b"a", blob_a.id, 0o100644),
(b"ad/b", blob_b.id, 0o100644),
(b"ad/bd/c", blob_c.id, 0o100755),
(b"ad/c", blob_c.id, 0o100644),
(b"c", blob_c.id, 0o100644),
]
tree_id = commit_tree(self.store, blobs)
self.assertEqual(
[TreeEntry(p, m, h) for (p, h, m) in blobs],
list(self.store.iter_tree_contents(tree_id)),
)
def test_iter_tree_contents_include_trees(self):
blob_a = make_object(Blob, data=b"a")
blob_b = make_object(Blob, data=b"b")
blob_c = make_object(Blob, data=b"c")
for blob in [blob_a, blob_b, blob_c]:
self.store.add_object(blob)
blobs = [
(b"a", blob_a.id, 0o100644),
(b"ad/b", blob_b.id, 0o100644),
(b"ad/bd/c", blob_c.id, 0o100755),
]
tree_id = commit_tree(self.store, blobs)
tree = self.store[tree_id]
tree_ad = self.store[tree[b"ad"][1]]
tree_bd = self.store[tree_ad[b"bd"][1]]
expected = [
TreeEntry(b"", 0o040000, tree_id),
TreeEntry(b"a", 0o100644, blob_a.id),
TreeEntry(b"ad", 0o040000, tree_ad.id),
TreeEntry(b"ad/b", 0o100644, blob_b.id),
TreeEntry(b"ad/bd", 0o040000, tree_bd.id),
TreeEntry(b"ad/bd/c", 0o100755, blob_c.id),
]
actual = self.store.iter_tree_contents(tree_id, include_trees=True)
self.assertEqual(expected, list(actual))
def make_tag(self, name, obj):
tag = make_tag(obj, name=name)
self.store.add_object(tag)
return tag
def test_peel_sha(self):
self.store.add_object(testobject)
tag1 = self.make_tag(b"1", testobject)
tag2 = self.make_tag(b"2", testobject)
tag3 = self.make_tag(b"3", testobject)
for obj in [testobject, tag1, tag2, tag3]:
self.assertEqual(testobject, self.store.peel_sha(obj.id))
def test_get_raw(self):
self.store.add_object(testobject)
self.assertEqual(
(Blob.type_num, b"yummy data"), self.store.get_raw(testobject.id)
)
def test_close(self):
# For now, just check that close doesn't barf.
self.store.add_object(testobject)
self.store.close()
class OverlayObjectStoreTests(ObjectStoreTests, TestCase):
def setUp(self):
TestCase.setUp(self)
self.bases = [MemoryObjectStore(), MemoryObjectStore()]
self.store = OverlayObjectStore(self.bases, self.bases[0])
class MemoryObjectStoreTests(ObjectStoreTests, TestCase):
def setUp(self):
TestCase.setUp(self)
self.store = MemoryObjectStore()
def test_add_pack(self):
o = MemoryObjectStore()
f, commit, abort = o.add_pack()
try:
b = make_object(Blob, data=b"more yummy data")
write_pack_objects(f, [(b, None)])
except BaseException:
abort()
raise
else:
commit()
def test_add_pack_emtpy(self):
o = MemoryObjectStore()
f, commit, abort = o.add_pack()
commit()
def test_add_thin_pack(self):
o = MemoryObjectStore()
blob = make_object(Blob, data=b"yummy data")
o.add_object(blob)
f = BytesIO()
entries = build_pack(
f,
[
(REF_DELTA, (blob.id, b"more yummy data")),
],
store=o,
)
o.add_thin_pack(f.read, None)
packed_blob_sha = sha_to_hex(entries[0][3])
self.assertEqual(
(Blob.type_num, b"more yummy data"), o.get_raw(packed_blob_sha)
)
def test_add_thin_pack_empty(self):
o = MemoryObjectStore()
f = BytesIO()
entries = build_pack(f, [], store=o)
self.assertEqual([], entries)
o.add_thin_pack(f.read, None)
class PackBasedObjectStoreTests(ObjectStoreTests):
def tearDown(self):
for pack in self.store.packs:
pack.close()
def test_empty_packs(self):
self.assertEqual([], list(self.store.packs))
def test_pack_loose_objects(self):
b1 = make_object(Blob, data=b"yummy data")
self.store.add_object(b1)
b2 = make_object(Blob, data=b"more yummy data")
self.store.add_object(b2)
b3 = make_object(Blob, data=b"even more yummy data")
b4 = make_object(Blob, data=b"and more yummy data")
self.store.add_objects([(b3, None), (b4, None)])
self.assertEqual({b1.id, b2.id, b3.id, b4.id}, set(self.store))
self.assertEqual(1, len(self.store.packs))
self.assertEqual(2, self.store.pack_loose_objects())
self.assertNotEqual([], list(self.store.packs))
self.assertEqual(0, self.store.pack_loose_objects())
def test_repack(self):
b1 = make_object(Blob, data=b"yummy data")
self.store.add_object(b1)
b2 = make_object(Blob, data=b"more yummy data")
self.store.add_object(b2)
b3 = make_object(Blob, data=b"even more yummy data")
b4 = make_object(Blob, data=b"and more yummy data")
self.store.add_objects([(b3, None), (b4, None)])
b5 = make_object(Blob, data=b"and more data")
b6 = make_object(Blob, data=b"and some more data")
self.store.add_objects([(b5, None), (b6, None)])
self.assertEqual({b1.id, b2.id, b3.id, b4.id, b5.id, b6.id}, set(self.store))
self.assertEqual(2, len(self.store.packs))
self.assertEqual(6, self.store.repack())
self.assertEqual(1, len(self.store.packs))
self.assertEqual(0, self.store.pack_loose_objects())
def test_repack_existing(self):
b1 = make_object(Blob, data=b"yummy data")
self.store.add_object(b1)
b2 = make_object(Blob, data=b"more yummy data")
self.store.add_object(b2)
self.store.add_objects([(b1, None), (b2, None)])
self.store.add_objects([(b2, None)])
self.assertEqual({b1.id, b2.id}, set(self.store))
self.assertEqual(2, len(self.store.packs))
self.assertEqual(2, self.store.repack())
self.assertEqual(1, len(self.store.packs))
self.assertEqual(0, self.store.pack_loose_objects())
self.assertEqual({b1.id, b2.id}, set(self.store))
self.assertEqual(1, len(self.store.packs))
self.assertEqual(2, self.store.repack())
self.assertEqual(1, len(self.store.packs))
self.assertEqual(0, self.store.pack_loose_objects())
class DiskObjectStoreTests(PackBasedObjectStoreTests, TestCase):
def setUp(self):
TestCase.setUp(self)
self.store_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, self.store_dir)
self.store = DiskObjectStore.init(self.store_dir)
def tearDown(self):
TestCase.tearDown(self)
PackBasedObjectStoreTests.tearDown(self)
def test_loose_compression_level(self):
alternate_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, alternate_dir)
alternate_store = DiskObjectStore(alternate_dir, loose_compression_level=6)
b2 = make_object(Blob, data=b"yummy data")
alternate_store.add_object(b2)
def test_alternates(self):
alternate_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, alternate_dir)
alternate_store = DiskObjectStore(alternate_dir)
b2 = make_object(Blob, data=b"yummy data")
alternate_store.add_object(b2)
store = DiskObjectStore(self.store_dir)
self.assertRaises(KeyError, store.__getitem__, b2.id)
store.add_alternate_path(alternate_dir)
self.assertIn(b2.id, store)
self.assertEqual(b2, store[b2.id])
def test_read_alternate_paths(self):
store = DiskObjectStore(self.store_dir)
abs_path = os.path.abspath(os.path.normpath("/abspath"))
# ensures in particular existence of the alternates file
store.add_alternate_path(abs_path)
self.assertEqual(set(store._read_alternate_paths()), {abs_path})
store.add_alternate_path("relative-path")
self.assertIn(
os.path.join(store.path, "relative-path"),
set(store._read_alternate_paths()),
)
# arguably, add_alternate_path() could strip comments.
# Meanwhile it's more convenient to use it than to import INFODIR
store.add_alternate_path("# comment")
for alt_path in store._read_alternate_paths():
self.assertNotIn("#", alt_path)
def test_file_modes(self):
self.store.add_object(testobject)
path = self.store._get_shafile_path(testobject.id)
mode = os.stat(path).st_mode
packmode = "0o100444" if sys.platform != "win32" else "0o100666"
self.assertEqual(oct(mode), packmode)
def test_corrupted_object_raise_exception(self):
"""Corrupted sha1 disk file should raise specific exception"""
self.store.add_object(testobject)
self.assertEqual(
(Blob.type_num, b"yummy data"), self.store.get_raw(testobject.id)
)
self.assertTrue(self.store.contains_loose(testobject.id))
self.assertIsNotNone(self.store._get_loose_object(testobject.id))
path = self.store._get_shafile_path(testobject.id)
old_mode = os.stat(path).st_mode
os.chmod(path, 0o600)
with open(path, "wb") as f: # corrupt the file
f.write(b"")
os.chmod(path, old_mode)
expected_error_msg = "Corrupted empty file detected"
try:
self.store.contains_loose(testobject.id)
except EmptyFileException as e:
self.assertEqual(str(e), expected_error_msg)
try:
self.store._get_loose_object(testobject.id)
except EmptyFileException as e:
self.assertEqual(str(e), expected_error_msg)
# this does not change iteration on loose objects though
self.assertEqual([testobject.id], list(self.store._iter_loose_objects()))
def test_tempfile_in_loose_store(self):
self.store.add_object(testobject)
self.assertEqual([testobject.id], list(self.store._iter_loose_objects()))
# add temporary files to the loose store
for i in range(256):
dirname = os.path.join(self.store_dir, "%02x" % i)
if not os.path.isdir(dirname):
os.makedirs(dirname)
fd, n = tempfile.mkstemp(prefix="tmp_obj_", dir=dirname)
os.close(fd)
self.assertEqual([testobject.id], list(self.store._iter_loose_objects()))
def test_add_alternate_path(self):
store = DiskObjectStore(self.store_dir)
self.assertEqual([], list(store._read_alternate_paths()))
store.add_alternate_path("/foo/path")
self.assertEqual(["/foo/path"], list(store._read_alternate_paths()))
store.add_alternate_path("/bar/path")
self.assertEqual(
["/foo/path", "/bar/path"], list(store._read_alternate_paths())
)
def test_rel_alternative_path(self):
alternate_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, alternate_dir)
alternate_store = DiskObjectStore(alternate_dir)
b2 = make_object(Blob, data=b"yummy data")
alternate_store.add_object(b2)
store = DiskObjectStore(self.store_dir)
self.assertRaises(KeyError, store.__getitem__, b2.id)
store.add_alternate_path(os.path.relpath(alternate_dir, self.store_dir))
self.assertEqual(list(alternate_store), list(store.alternates[0]))
self.assertIn(b2.id, store)
self.assertEqual(b2, store[b2.id])
def test_pack_dir(self):
o = DiskObjectStore(self.store_dir)
self.assertEqual(os.path.join(self.store_dir, "pack"), o.pack_dir)
def test_add_pack(self):
o = DiskObjectStore(self.store_dir)
f, commit, abort = o.add_pack()
try:
b = make_object(Blob, data=b"more yummy data")
write_pack_objects(f, [(b, None)])
except BaseException:
abort()
raise
else:
commit()
def test_add_thin_pack(self):
o = DiskObjectStore(self.store_dir)
try:
blob = make_object(Blob, data=b"yummy data")
o.add_object(blob)
f = BytesIO()
entries = build_pack(
f,
[
(REF_DELTA, (blob.id, b"more yummy data")),
],
store=o,
)
with o.add_thin_pack(f.read, None) as pack:
packed_blob_sha = sha_to_hex(entries[0][3])
pack.check_length_and_checksum()
self.assertEqual(sorted([blob.id, packed_blob_sha]), list(pack))
self.assertTrue(o.contains_packed(packed_blob_sha))
self.assertTrue(o.contains_packed(blob.id))
self.assertEqual(
(Blob.type_num, b"more yummy data"),
o.get_raw(packed_blob_sha),
)
finally:
o.close()
def test_add_thin_pack_empty(self):
with closing(DiskObjectStore(self.store_dir)) as o:
f = BytesIO()
entries = build_pack(f, [], store=o)
self.assertEqual([], entries)
o.add_thin_pack(f.read, None)
class TreeLookupPathTests(TestCase):
def setUp(self):
TestCase.setUp(self)
self.store = MemoryObjectStore()
blob_a = make_object(Blob, data=b"a")
blob_b = make_object(Blob, data=b"b")
blob_c = make_object(Blob, data=b"c")
for blob in [blob_a, blob_b, blob_c]:
self.store.add_object(blob)
blobs = [
(b"a", blob_a.id, 0o100644),
(b"ad/b", blob_b.id, 0o100644),
(b"ad/bd/c", blob_c.id, 0o100755),
(b"ad/c", blob_c.id, 0o100644),
(b"c", blob_c.id, 0o100644),
+ (b"d", blob_c.id, S_IFGITLINK),
]
self.tree_id = commit_tree(self.store, blobs)
def get_object(self, sha):
return self.store[sha]
def test_lookup_blob(self):
o_id = tree_lookup_path(self.get_object, self.tree_id, b"a")[1]
self.assertTrue(isinstance(self.store[o_id], Blob))
def test_lookup_tree(self):
o_id = tree_lookup_path(self.get_object, self.tree_id, b"ad")[1]
self.assertTrue(isinstance(self.store[o_id], Tree))
o_id = tree_lookup_path(self.get_object, self.tree_id, b"ad/bd")[1]
self.assertTrue(isinstance(self.store[o_id], Tree))
o_id = tree_lookup_path(self.get_object, self.tree_id, b"ad/bd/")[1]
self.assertTrue(isinstance(self.store[o_id], Tree))
+ def test_lookup_submodule(self):
+ tree_lookup_path(self.get_object, self.tree_id, b"d")[1]
+ self.assertRaises(
+ SubmoduleEncountered, tree_lookup_path, self.get_object,
+ self.tree_id, b"d/a")
+
def test_lookup_nonexistent(self):
self.assertRaises(
KeyError, tree_lookup_path, self.get_object, self.tree_id, b"j"
)
def test_lookup_not_tree(self):
self.assertRaises(
NotTreeError,
tree_lookup_path,
self.get_object,
self.tree_id,
b"ad/b/j",
)
class ObjectStoreGraphWalkerTests(TestCase):
def get_walker(self, heads, parent_map):
new_parent_map = dict(
[(k * 40, [(p * 40) for p in ps]) for (k, ps) in parent_map.items()]
)
return ObjectStoreGraphWalker(
[x * 40 for x in heads], new_parent_map.__getitem__
)
def test_ack_invalid_value(self):
gw = self.get_walker([], {})
self.assertRaises(ValueError, gw.ack, "tooshort")
def test_empty(self):
gw = self.get_walker([], {})
self.assertIs(None, next(gw))
gw.ack(b"a" * 40)
self.assertIs(None, next(gw))
def test_descends(self):
gw = self.get_walker([b"a"], {b"a": [b"b"], b"b": []})
self.assertEqual(b"a" * 40, next(gw))
self.assertEqual(b"b" * 40, next(gw))
def test_present(self):
gw = self.get_walker([b"a"], {b"a": [b"b"], b"b": []})
gw.ack(b"a" * 40)
self.assertIs(None, next(gw))
def test_parent_present(self):
gw = self.get_walker([b"a"], {b"a": [b"b"], b"b": []})
self.assertEqual(b"a" * 40, next(gw))
gw.ack(b"a" * 40)
self.assertIs(None, next(gw))
def test_child_ack_later(self):
gw = self.get_walker([b"a"], {b"a": [b"b"], b"b": [b"c"], b"c": []})
self.assertEqual(b"a" * 40, next(gw))
self.assertEqual(b"b" * 40, next(gw))
gw.ack(b"a" * 40)
self.assertIs(None, next(gw))
def test_only_once(self):
# a b
# | |
# c d
# \ /
# e
gw = self.get_walker(
[b"a", b"b"],
{
b"a": [b"c"],
b"b": [b"d"],
b"c": [b"e"],
b"d": [b"e"],
b"e": [],
},
)
walk = []
acked = False
walk.append(next(gw))
walk.append(next(gw))
# A branch (a, c) or (b, d) may be done after 2 steps or 3 depending on
# the order walked: 3-step walks include (a, b, c) and (b, a, d), etc.
if walk == [b"a" * 40, b"c" * 40] or walk == [b"b" * 40, b"d" * 40]:
gw.ack(walk[0])
acked = True
walk.append(next(gw))
if not acked and walk[2] == b"c" * 40:
gw.ack(b"a" * 40)
elif not acked and walk[2] == b"d" * 40:
gw.ack(b"b" * 40)
walk.append(next(gw))
self.assertIs(None, next(gw))
self.assertEqual([b"a" * 40, b"b" * 40, b"c" * 40, b"d" * 40], sorted(walk))
self.assertLess(walk.index(b"a" * 40), walk.index(b"c" * 40))
self.assertLess(walk.index(b"b" * 40), walk.index(b"d" * 40))
class CommitTreeChangesTests(TestCase):
def setUp(self):
super(CommitTreeChangesTests, self).setUp()
self.store = MemoryObjectStore()
self.blob_a = make_object(Blob, data=b"a")
self.blob_b = make_object(Blob, data=b"b")
self.blob_c = make_object(Blob, data=b"c")
for blob in [self.blob_a, self.blob_b, self.blob_c]:
self.store.add_object(blob)
blobs = [
(b"a", self.blob_a.id, 0o100644),
(b"ad/b", self.blob_b.id, 0o100644),
(b"ad/bd/c", self.blob_c.id, 0o100755),
(b"ad/c", self.blob_c.id, 0o100644),
(b"c", self.blob_c.id, 0o100644),
]
self.tree_id = commit_tree(self.store, blobs)
def test_no_changes(self):
self.assertEqual(
self.store[self.tree_id],
commit_tree_changes(self.store, self.store[self.tree_id], []),
)
def test_add_blob(self):
blob_d = make_object(Blob, data=b"d")
new_tree = commit_tree_changes(
self.store, self.store[self.tree_id], [(b"d", 0o100644, blob_d.id)]
)
self.assertEqual(
new_tree[b"d"],
(33188, b"c59d9b6344f1af00e504ba698129f07a34bbed8d"),
)
def test_add_blob_in_dir(self):
blob_d = make_object(Blob, data=b"d")
new_tree = commit_tree_changes(
self.store,
self.store[self.tree_id],
[(b"e/f/d", 0o100644, blob_d.id)],
)
self.assertEqual(
new_tree.items(),
[
TreeEntry(path=b"a", mode=stat.S_IFREG | 0o100644, sha=self.blob_a.id),
TreeEntry(
path=b"ad",
mode=stat.S_IFDIR,
sha=b"0e2ce2cd7725ff4817791be31ccd6e627e801f4a",
),
TreeEntry(path=b"c", mode=stat.S_IFREG | 0o100644, sha=self.blob_c.id),
TreeEntry(
path=b"e",
mode=stat.S_IFDIR,
sha=b"6ab344e288724ac2fb38704728b8896e367ed108",
),
],
)
e_tree = self.store[new_tree[b"e"][1]]
self.assertEqual(
e_tree.items(),
[
TreeEntry(
path=b"f",
mode=stat.S_IFDIR,
sha=b"24d2c94d8af232b15a0978c006bf61ef4479a0a5",
)
],
)
f_tree = self.store[e_tree[b"f"][1]]
self.assertEqual(
f_tree.items(),
[TreeEntry(path=b"d", mode=stat.S_IFREG | 0o100644, sha=blob_d.id)],
)
def test_delete_blob(self):
new_tree = commit_tree_changes(
self.store, self.store[self.tree_id], [(b"ad/bd/c", None, None)]
)
self.assertEqual(set(new_tree), {b"a", b"ad", b"c"})
ad_tree = self.store[new_tree[b"ad"][1]]
self.assertEqual(set(ad_tree), {b"b", b"c"})
class TestReadPacksFile(TestCase):
def test_read_packs(self):
self.assertEqual(
["pack-1.pack"],
list(
read_packs_file(
BytesIO(
b"""P pack-1.pack
"""
)
)
),
)
diff --git a/dulwich/tests/test_repository.py b/dulwich/tests/test_repository.py
index 05034888..f8975cad 100644
--- a/dulwich/tests/test_repository.py
+++ b/dulwich/tests/test_repository.py
@@ -1,1374 +1,1420 @@
# -*- coding: utf-8 -*-
# test_repository.py -- tests for repository.py
# Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
#
# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
# General Public License as public by the Free Software Foundation; version 2.0
# or (at your option) any later version. You can redistribute it and/or
# modify it under the terms of either of these two licenses.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# You should have received a copy of the licenses; if not, see
# <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
# and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
# License, Version 2.0.
#
"""Tests for the repository."""
import glob
import locale
import os
import shutil
import stat
import sys
import tempfile
import warnings
from dulwich import errors
from dulwich import porcelain
from dulwich.object_store import (
tree_lookup_path,
)
from dulwich import objects
from dulwich.config import Config
from dulwich.errors import NotGitRepository
from dulwich.repo import (
InvalidUserIdentity,
Repo,
MemoryRepo,
check_user_identity,
UnsupportedVersion,
)
from dulwich.tests import (
TestCase,
skipIf,
)
from dulwich.tests.utils import (
open_repo,
tear_down_repo,
setup_warning_catcher,
)
missing_sha = b"b91fa4d900e17e99b433218e988c4eb4a3e9a097"
class CreateRepositoryTests(TestCase):
def assertFileContentsEqual(self, expected, repo, path):
f = repo.get_named_file(path)
if not f:
self.assertEqual(expected, None)
else:
with f:
self.assertEqual(expected, f.read())
def _check_repo_contents(self, repo, expect_bare):
self.assertEqual(expect_bare, repo.bare)
self.assertFileContentsEqual(b"Unnamed repository", repo, "description")
self.assertFileContentsEqual(b"", repo, os.path.join("info", "exclude"))
self.assertFileContentsEqual(None, repo, "nonexistent file")
barestr = b"bare = " + str(expect_bare).lower().encode("ascii")
with repo.get_named_file("config") as f:
config_text = f.read()
self.assertTrue(barestr in config_text, "%r" % config_text)
expect_filemode = sys.platform != "win32"
barestr = b"filemode = " + str(expect_filemode).lower().encode("ascii")
with repo.get_named_file("config") as f:
config_text = f.read()
self.assertTrue(barestr in config_text, "%r" % config_text)
if isinstance(repo, Repo):
expected_mode = '0o100644' if expect_filemode else '0o100666'
expected = {
'HEAD': expected_mode,
'config': expected_mode,
'description': expected_mode,
}
actual = {
f[len(repo._controldir) + 1:]: oct(os.stat(f).st_mode)
for f in glob.glob(os.path.join(repo._controldir, '*'))
if os.path.isfile(f)
}
self.assertEqual(expected, actual)
def test_create_memory(self):
repo = MemoryRepo.init_bare([], {})
self._check_repo_contents(repo, True)
def test_create_disk_bare(self):
tmp_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
repo = Repo.init_bare(tmp_dir)
self.assertEqual(tmp_dir, repo._controldir)
self._check_repo_contents(repo, True)
def test_create_disk_non_bare(self):
tmp_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
repo = Repo.init(tmp_dir)
self.assertEqual(os.path.join(tmp_dir, ".git"), repo._controldir)
self._check_repo_contents(repo, False)
def test_create_disk_non_bare_mkdir(self):
tmp_dir = tempfile.mkdtemp()
target_dir = os.path.join(tmp_dir, "target")
self.addCleanup(shutil.rmtree, tmp_dir)
repo = Repo.init(target_dir, mkdir=True)
self.assertEqual(os.path.join(target_dir, ".git"), repo._controldir)
self._check_repo_contents(repo, False)
def test_create_disk_bare_mkdir(self):
tmp_dir = tempfile.mkdtemp()
target_dir = os.path.join(tmp_dir, "target")
self.addCleanup(shutil.rmtree, tmp_dir)
repo = Repo.init_bare(target_dir, mkdir=True)
self.assertEqual(target_dir, repo._controldir)
self._check_repo_contents(repo, True)
class MemoryRepoTests(TestCase):
def test_set_description(self):
r = MemoryRepo.init_bare([], {})
description = b"Some description"
r.set_description(description)
self.assertEqual(description, r.get_description())
class RepositoryRootTests(TestCase):
def mkdtemp(self):
return tempfile.mkdtemp()
def open_repo(self, name):
temp_dir = self.mkdtemp()
repo = open_repo(name, temp_dir)
self.addCleanup(tear_down_repo, repo)
return repo
def test_simple_props(self):
r = self.open_repo("a.git")
self.assertEqual(r.controldir(), r.path)
def test_setitem(self):
r = self.open_repo("a.git")
r[b"refs/tags/foo"] = b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"
self.assertEqual(
b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", r[b"refs/tags/foo"].id
)
def test_getitem_unicode(self):
r = self.open_repo("a.git")
test_keys = [
(b"refs/heads/master", True),
(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", True),
(b"11" * 19 + b"--", False),
]
for k, contained in test_keys:
self.assertEqual(k in r, contained)
# Avoid deprecation warning under Py3.2+
if getattr(self, "assertRaisesRegex", None):
assertRaisesRegexp = self.assertRaisesRegex
else:
assertRaisesRegexp = self.assertRaisesRegexp
for k, _ in test_keys:
assertRaisesRegexp(
TypeError,
"'name' must be bytestring, not int",
r.__getitem__,
12,
)
def test_delitem(self):
r = self.open_repo("a.git")
del r[b"refs/heads/master"]
self.assertRaises(KeyError, lambda: r[b"refs/heads/master"])
del r[b"HEAD"]
self.assertRaises(KeyError, lambda: r[b"HEAD"])
self.assertRaises(ValueError, r.__delitem__, b"notrefs/foo")
def test_get_refs(self):
r = self.open_repo("a.git")
self.assertEqual(
{
b"HEAD": b"a90fa2d900a17e99b433217e988c4eb4a2e9a097",
b"refs/heads/master": b"a90fa2d900a17e99b433217e988c4eb4a2e9a097",
b"refs/tags/mytag": b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a",
b"refs/tags/mytag-packed": b"b0931cadc54336e78a1d980420e3268903b57a50",
},
r.get_refs(),
)
def test_head(self):
r = self.open_repo("a.git")
self.assertEqual(r.head(), b"a90fa2d900a17e99b433217e988c4eb4a2e9a097")
def test_get_object(self):
r = self.open_repo("a.git")
obj = r.get_object(r.head())
self.assertEqual(obj.type_name, b"commit")
def test_get_object_non_existant(self):
r = self.open_repo("a.git")
self.assertRaises(KeyError, r.get_object, missing_sha)
def test_contains_object(self):
r = self.open_repo("a.git")
self.assertTrue(r.head() in r)
self.assertFalse(b"z" * 40 in r)
def test_contains_ref(self):
r = self.open_repo("a.git")
self.assertTrue(b"HEAD" in r)
def test_get_no_description(self):
r = self.open_repo("a.git")
self.assertIs(None, r.get_description())
def test_get_description(self):
r = self.open_repo("a.git")
with open(os.path.join(r.path, "description"), "wb") as f:
f.write(b"Some description")
self.assertEqual(b"Some description", r.get_description())
def test_set_description(self):
r = self.open_repo("a.git")
description = b"Some description"
r.set_description(description)
self.assertEqual(description, r.get_description())
def test_contains_missing(self):
r = self.open_repo("a.git")
self.assertFalse(b"bar" in r)
def test_get_peeled(self):
# unpacked ref
r = self.open_repo("a.git")
tag_sha = b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a"
self.assertNotEqual(r[tag_sha].sha().hexdigest(), r.head())
self.assertEqual(r.get_peeled(b"refs/tags/mytag"), r.head())
# packed ref with cached peeled value
packed_tag_sha = b"b0931cadc54336e78a1d980420e3268903b57a50"
parent_sha = r[r.head()].parents[0]
self.assertNotEqual(r[packed_tag_sha].sha().hexdigest(), parent_sha)
self.assertEqual(r.get_peeled(b"refs/tags/mytag-packed"), parent_sha)
# TODO: add more corner cases to test repo
def test_get_peeled_not_tag(self):
r = self.open_repo("a.git")
self.assertEqual(r.get_peeled(b"HEAD"), r.head())
def test_get_parents(self):
r = self.open_repo("a.git")
self.assertEqual(
[b"2a72d929692c41d8554c07f6301757ba18a65d91"],
r.get_parents(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"),
)
r.update_shallow([b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"], None)
self.assertEqual([], r.get_parents(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"))
def test_get_walker(self):
r = self.open_repo("a.git")
# include defaults to [r.head()]
self.assertEqual(
[e.commit.id for e in r.get_walker()],
[r.head(), b"2a72d929692c41d8554c07f6301757ba18a65d91"],
)
self.assertEqual(
[
e.commit.id
for e in r.get_walker([b"2a72d929692c41d8554c07f6301757ba18a65d91"])
],
[b"2a72d929692c41d8554c07f6301757ba18a65d91"],
)
self.assertEqual(
[
e.commit.id
for e in r.get_walker(b"2a72d929692c41d8554c07f6301757ba18a65d91")
],
[b"2a72d929692c41d8554c07f6301757ba18a65d91"],
)
def assertFilesystemHidden(self, path):
if sys.platform != "win32":
return
import ctypes
from ctypes.wintypes import DWORD, LPCWSTR
GetFileAttributesW = ctypes.WINFUNCTYPE(DWORD, LPCWSTR)(
("GetFileAttributesW", ctypes.windll.kernel32)
)
self.assertTrue(2 & GetFileAttributesW(path))
def test_init_existing(self):
tmp_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
t = Repo.init(tmp_dir)
self.addCleanup(t.close)
self.assertEqual(os.listdir(tmp_dir), [".git"])
self.assertFilesystemHidden(os.path.join(tmp_dir, ".git"))
def test_init_mkdir(self):
tmp_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
repo_dir = os.path.join(tmp_dir, "a-repo")
t = Repo.init(repo_dir, mkdir=True)
self.addCleanup(t.close)
self.assertEqual(os.listdir(repo_dir), [".git"])
self.assertFilesystemHidden(os.path.join(repo_dir, ".git"))
def test_init_mkdir_unicode(self):
repo_name = u"\xa7"
try:
os.fsencode(repo_name)
except UnicodeEncodeError:
self.skipTest("filesystem lacks unicode support")
tmp_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
repo_dir = os.path.join(tmp_dir, repo_name)
t = Repo.init(repo_dir, mkdir=True)
self.addCleanup(t.close)
self.assertEqual(os.listdir(repo_dir), [".git"])
self.assertFilesystemHidden(os.path.join(repo_dir, ".git"))
@skipIf(sys.platform == "win32", "fails on Windows")
def test_fetch(self):
r = self.open_repo("a.git")
tmp_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
t = Repo.init(tmp_dir)
self.addCleanup(t.close)
r.fetch(t)
self.assertIn(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", t)
self.assertIn(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", t)
self.assertIn(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", t)
self.assertIn(b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a", t)
self.assertIn(b"b0931cadc54336e78a1d980420e3268903b57a50", t)
@skipIf(sys.platform == "win32", "fails on Windows")
def test_fetch_ignores_missing_refs(self):
r = self.open_repo("a.git")
missing = b"1234566789123456789123567891234657373833"
r.refs[b"refs/heads/blah"] = missing
tmp_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
t = Repo.init(tmp_dir)
self.addCleanup(t.close)
r.fetch(t)
self.assertIn(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", t)
self.assertIn(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", t)
self.assertIn(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", t)
self.assertIn(b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a", t)
self.assertIn(b"b0931cadc54336e78a1d980420e3268903b57a50", t)
self.assertNotIn(missing, t)
def test_clone(self):
r = self.open_repo("a.git")
tmp_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
with r.clone(tmp_dir, mkdir=False) as t:
self.assertEqual(
{
b"HEAD": b"a90fa2d900a17e99b433217e988c4eb4a2e9a097",
b"refs/remotes/origin/master": b"a90fa2d900a17e99b433217e988c4eb4a2e9a097",
b"refs/heads/master": b"a90fa2d900a17e99b433217e988c4eb4a2e9a097",
b"refs/tags/mytag": b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a",
b"refs/tags/mytag-packed": b"b0931cadc54336e78a1d980420e3268903b57a50",
},
t.refs.as_dict(),
)
shas = [e.commit.id for e in r.get_walker()]
self.assertEqual(
shas, [t.head(), b"2a72d929692c41d8554c07f6301757ba18a65d91"]
)
c = t.get_config()
encoded_path = r.path
if not isinstance(encoded_path, bytes):
encoded_path = os.fsencode(encoded_path)
self.assertEqual(encoded_path, c.get((b"remote", b"origin"), b"url"))
self.assertEqual(
b"+refs/heads/*:refs/remotes/origin/*",
c.get((b"remote", b"origin"), b"fetch"),
)
def test_clone_no_head(self):
temp_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, temp_dir)
repo_dir = os.path.join(os.path.dirname(__file__), "data", "repos")
dest_dir = os.path.join(temp_dir, "a.git")
shutil.copytree(os.path.join(repo_dir, "a.git"), dest_dir, symlinks=True)
r = Repo(dest_dir)
del r.refs[b"refs/heads/master"]
del r.refs[b"HEAD"]
t = r.clone(os.path.join(temp_dir, "b.git"), mkdir=True)
self.assertEqual(
{
b"refs/tags/mytag": b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a",
b"refs/tags/mytag-packed": b"b0931cadc54336e78a1d980420e3268903b57a50",
},
t.refs.as_dict(),
)
def test_clone_empty(self):
"""Test clone() doesn't crash if HEAD points to a non-existing ref.
This simulates cloning server-side bare repository either when it is
still empty or if user renames master branch and pushes private repo
to the server.
Non-bare repo HEAD always points to an existing ref.
"""
r = self.open_repo("empty.git")
tmp_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
r.clone(tmp_dir, mkdir=False, bare=True)
def test_clone_bare(self):
r = self.open_repo("a.git")
tmp_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
t = r.clone(tmp_dir, mkdir=False)
t.close()
def test_clone_checkout_and_bare(self):
r = self.open_repo("a.git")
tmp_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
self.assertRaises(
ValueError, r.clone, tmp_dir, mkdir=False, checkout=True, bare=True
)
def test_merge_history(self):
r = self.open_repo("simple_merge.git")
shas = [e.commit.id for e in r.get_walker()]
self.assertEqual(
shas,
[
b"5dac377bdded4c9aeb8dff595f0faeebcc8498cc",
b"ab64bbdcc51b170d21588e5c5d391ee5c0c96dfd",
b"4cffe90e0a41ad3f5190079d7c8f036bde29cbe6",
b"60dacdc733de308bb77bb76ce0fb0f9b44c9769e",
b"0d89f20333fbb1d2f3a94da77f4981373d8f4310",
],
)
def test_out_of_order_merge(self):
"""Test that revision history is ordered by date, not parent order."""
r = self.open_repo("ooo_merge.git")
shas = [e.commit.id for e in r.get_walker()]
self.assertEqual(
shas,
[
b"7601d7f6231db6a57f7bbb79ee52e4d462fd44d1",
b"f507291b64138b875c28e03469025b1ea20bc614",
b"fb5b0425c7ce46959bec94d54b9a157645e114f5",
b"f9e39b120c68182a4ba35349f832d0e4e61f485c",
],
)
def test_get_tags_empty(self):
r = self.open_repo("ooo_merge.git")
self.assertEqual({}, r.refs.as_dict(b"refs/tags"))
def test_get_config(self):
r = self.open_repo("ooo_merge.git")
self.assertIsInstance(r.get_config(), Config)
def test_get_config_stack(self):
r = self.open_repo("ooo_merge.git")
self.assertIsInstance(r.get_config_stack(), Config)
def test_common_revisions(self):
"""
This test demonstrates that ``find_common_revisions()`` actually
returns common heads, not revisions; dulwich already uses
``find_common_revisions()`` in such a manner (see
``Repo.fetch_objects()``).
"""
expected_shas = set([b"60dacdc733de308bb77bb76ce0fb0f9b44c9769e"])
# Source for objects.
r_base = self.open_repo("simple_merge.git")
# Re-create each-side of the merge in simple_merge.git.
#
# Since the trees and blobs are missing, the repository created is
# corrupted, but we're only checking for commits for the purpose of
# this test, so it's immaterial.
r1_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, r1_dir)
r1_commits = [
b"ab64bbdcc51b170d21588e5c5d391ee5c0c96dfd", # HEAD
b"60dacdc733de308bb77bb76ce0fb0f9b44c9769e",
b"0d89f20333fbb1d2f3a94da77f4981373d8f4310",
]
r2_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, r2_dir)
r2_commits = [
b"4cffe90e0a41ad3f5190079d7c8f036bde29cbe6", # HEAD
b"60dacdc733de308bb77bb76ce0fb0f9b44c9769e",
b"0d89f20333fbb1d2f3a94da77f4981373d8f4310",
]
r1 = Repo.init_bare(r1_dir)
for c in r1_commits:
r1.object_store.add_object(r_base.get_object(c))
r1.refs[b"HEAD"] = r1_commits[0]
r2 = Repo.init_bare(r2_dir)
for c in r2_commits:
r2.object_store.add_object(r_base.get_object(c))
r2.refs[b"HEAD"] = r2_commits[0]
# Finally, the 'real' testing!
shas = r2.object_store.find_common_revisions(r1.get_graph_walker())
self.assertEqual(set(shas), expected_shas)
shas = r1.object_store.find_common_revisions(r2.get_graph_walker())
self.assertEqual(set(shas), expected_shas)
def test_shell_hook_pre_commit(self):
if os.name != "posix":
self.skipTest("shell hook tests requires POSIX shell")
pre_commit_fail = """#!/bin/sh
exit 1
"""
pre_commit_success = """#!/bin/sh
exit 0
"""
repo_dir = os.path.join(self.mkdtemp())
self.addCleanup(shutil.rmtree, repo_dir)
r = Repo.init(repo_dir)
self.addCleanup(r.close)
pre_commit = os.path.join(r.controldir(), "hooks", "pre-commit")
with open(pre_commit, "w") as f:
f.write(pre_commit_fail)
os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
self.assertRaises(
errors.CommitError,
r.do_commit,
- "failed commit",
- committer="Test Committer <test@nodomain.com>",
- author="Test Author <test@nodomain.com>",
+ b"failed commit",
+ committer=b"Test Committer <test@nodomain.com>",
+ author=b"Test Author <test@nodomain.com>",
commit_timestamp=12345,
commit_timezone=0,
author_timestamp=12345,
author_timezone=0,
)
with open(pre_commit, "w") as f:
f.write(pre_commit_success)
os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
commit_sha = r.do_commit(
b"empty commit",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
)
self.assertEqual([], r[commit_sha].parents)
def test_shell_hook_commit_msg(self):
if os.name != "posix":
self.skipTest("shell hook tests requires POSIX shell")
commit_msg_fail = """#!/bin/sh
exit 1
"""
commit_msg_success = """#!/bin/sh
exit 0
"""
repo_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
r = Repo.init(repo_dir)
self.addCleanup(r.close)
commit_msg = os.path.join(r.controldir(), "hooks", "commit-msg")
with open(commit_msg, "w") as f:
f.write(commit_msg_fail)
os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
self.assertRaises(
errors.CommitError,
r.do_commit,
b"failed commit",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12345,
commit_timezone=0,
author_timestamp=12345,
author_timezone=0,
)
with open(commit_msg, "w") as f:
f.write(commit_msg_success)
os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
commit_sha = r.do_commit(
b"empty commit",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
)
self.assertEqual([], r[commit_sha].parents)
+ def test_shell_hook_pre_commit_add_files(self):
+ if os.name != "posix":
+ self.skipTest("shell hook tests requires POSIX shell")
+
+ pre_commit_contents = """#!%(executable)s
+import sys
+sys.path.extend(':'.join(%(path)s))
+from dulwich.repo import Repo
+
+with open('foo', 'w') as f:
+ f.write('newfile')
+
+r = Repo('.')
+r.stage(['foo'])
+""" % {'executable': sys.executable, 'path': repr(sys.path)}
+
+ repo_dir = os.path.join(self.mkdtemp())
+ self.addCleanup(shutil.rmtree, repo_dir)
+ r = Repo.init(repo_dir)
+ self.addCleanup(r.close)
+
+ with open(os.path.join(repo_dir, 'blah'), 'w') as f:
+ f.write('blah')
+
+ r.stage(['blah'])
+
+ pre_commit = os.path.join(r.controldir(), "hooks", "pre-commit")
+
+ with open(pre_commit, "w") as f:
+ f.write(pre_commit_contents)
+ os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
+
+ commit_sha = r.do_commit(
+ b"new commit",
+ committer=b"Test Committer <test@nodomain.com>",
+ author=b"Test Author <test@nodomain.com>",
+ commit_timestamp=12395,
+ commit_timezone=0,
+ author_timestamp=12395,
+ author_timezone=0,
+ )
+ self.assertEqual([], r[commit_sha].parents)
+
+ tree = r[r[commit_sha].tree]
+ self.assertEqual(set([b'blah', b'foo']), set(tree))
+
def test_shell_hook_post_commit(self):
if os.name != "posix":
self.skipTest("shell hook tests requires POSIX shell")
repo_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
r = Repo.init(repo_dir)
self.addCleanup(r.close)
(fd, path) = tempfile.mkstemp(dir=repo_dir)
os.close(fd)
post_commit_msg = (
"""#!/bin/sh
rm """
+ path
+ """
"""
)
root_sha = r.do_commit(
b"empty commit",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12345,
commit_timezone=0,
author_timestamp=12345,
author_timezone=0,
)
self.assertEqual([], r[root_sha].parents)
post_commit = os.path.join(r.controldir(), "hooks", "post-commit")
with open(post_commit, "wb") as f:
f.write(post_commit_msg.encode(locale.getpreferredencoding()))
os.chmod(post_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
commit_sha = r.do_commit(
b"empty commit",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12345,
commit_timezone=0,
author_timestamp=12345,
author_timezone=0,
)
self.assertEqual([root_sha], r[commit_sha].parents)
self.assertFalse(os.path.exists(path))
post_commit_msg_fail = """#!/bin/sh
exit 1
"""
with open(post_commit, "w") as f:
f.write(post_commit_msg_fail)
os.chmod(post_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
warnings.simplefilter("always", UserWarning)
self.addCleanup(warnings.resetwarnings)
warnings_list, restore_warnings = setup_warning_catcher()
self.addCleanup(restore_warnings)
commit_sha2 = r.do_commit(
b"empty commit",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12345,
commit_timezone=0,
author_timestamp=12345,
author_timezone=0,
)
expected_warning = UserWarning(
"post-commit hook failed: Hook post-commit exited with "
"non-zero status 1",
)
for w in warnings_list:
if type(w) == type(expected_warning) and w.args == expected_warning.args:
break
else:
raise AssertionError(
"Expected warning %r not in %r" % (expected_warning, warnings_list)
)
self.assertEqual([commit_sha], r[commit_sha2].parents)
def test_as_dict(self):
def check(repo):
self.assertEqual(
repo.refs.subkeys(b"refs/tags"),
repo.refs.subkeys(b"refs/tags/"),
)
self.assertEqual(
repo.refs.as_dict(b"refs/tags"),
repo.refs.as_dict(b"refs/tags/"),
)
self.assertEqual(
repo.refs.as_dict(b"refs/heads"),
repo.refs.as_dict(b"refs/heads/"),
)
bare = self.open_repo("a.git")
tmp_dir = self.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
with bare.clone(tmp_dir, mkdir=False) as nonbare:
check(nonbare)
check(bare)
def test_working_tree(self):
temp_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, temp_dir)
worktree_temp_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, worktree_temp_dir)
r = Repo.init(temp_dir)
self.addCleanup(r.close)
root_sha = r.do_commit(
b"empty commit",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12345,
commit_timezone=0,
author_timestamp=12345,
author_timezone=0,
)
r.refs[b"refs/heads/master"] = root_sha
w = Repo._init_new_working_directory(worktree_temp_dir, r)
self.addCleanup(w.close)
new_sha = w.do_commit(
b"new commit",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12345,
commit_timezone=0,
author_timestamp=12345,
author_timezone=0,
)
w.refs[b"HEAD"] = new_sha
self.assertEqual(
os.path.abspath(r.controldir()), os.path.abspath(w.commondir())
)
self.assertEqual(r.refs.keys(), w.refs.keys())
self.assertNotEqual(r.head(), w.head())
class BuildRepoRootTests(TestCase):
"""Tests that build on-disk repos from scratch.
Repos live in a temp dir and are torn down after each test. They start with
a single commit in master having single file named 'a'.
"""
def get_repo_dir(self):
return os.path.join(tempfile.mkdtemp(), "test")
def setUp(self):
super(BuildRepoRootTests, self).setUp()
self._repo_dir = self.get_repo_dir()
os.makedirs(self._repo_dir)
r = self._repo = Repo.init(self._repo_dir)
self.addCleanup(tear_down_repo, r)
self.assertFalse(r.bare)
self.assertEqual(b"ref: refs/heads/master", r.refs.read_ref(b"HEAD"))
self.assertRaises(KeyError, lambda: r.refs[b"refs/heads/master"])
with open(os.path.join(r.path, "a"), "wb") as f:
f.write(b"file contents")
r.stage(["a"])
commit_sha = r.do_commit(
b"msg",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12345,
commit_timezone=0,
author_timestamp=12345,
author_timezone=0,
)
self.assertEqual([], r[commit_sha].parents)
self._root_commit = commit_sha
def test_get_shallow(self):
self.assertEqual(set(), self._repo.get_shallow())
with open(os.path.join(self._repo.path, ".git", "shallow"), "wb") as f:
f.write(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097\n")
self.assertEqual(
{b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"},
self._repo.get_shallow(),
)
def test_update_shallow(self):
self._repo.update_shallow(None, None) # no op
self.assertEqual(set(), self._repo.get_shallow())
self._repo.update_shallow([b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"], None)
self.assertEqual(
{b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"},
self._repo.get_shallow(),
)
self._repo.update_shallow(
[b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"],
[b"f9e39b120c68182a4ba35349f832d0e4e61f485c"],
)
self.assertEqual(
{b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"},
self._repo.get_shallow(),
)
self._repo.update_shallow(
None, [b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"]
)
self.assertEqual(set(), self._repo.get_shallow())
self.assertEqual(
False,
os.path.exists(os.path.join(self._repo.controldir(), "shallow")),
)
def test_build_repo(self):
r = self._repo
self.assertEqual(b"ref: refs/heads/master", r.refs.read_ref(b"HEAD"))
self.assertEqual(self._root_commit, r.refs[b"refs/heads/master"])
expected_blob = objects.Blob.from_string(b"file contents")
self.assertEqual(expected_blob.data, r[expected_blob.id].data)
actual_commit = r[self._root_commit]
self.assertEqual(b"msg", actual_commit.message)
def test_commit_modified(self):
r = self._repo
with open(os.path.join(r.path, "a"), "wb") as f:
f.write(b"new contents")
r.stage(["a"])
commit_sha = r.do_commit(
b"modified a",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
)
self.assertEqual([self._root_commit], r[commit_sha].parents)
a_mode, a_id = tree_lookup_path(r.get_object, r[commit_sha].tree, b"a")
self.assertEqual(stat.S_IFREG | 0o644, a_mode)
self.assertEqual(b"new contents", r[a_id].data)
@skipIf(not getattr(os, "symlink", None), "Requires symlink support")
def test_commit_symlink(self):
r = self._repo
os.symlink("a", os.path.join(r.path, "b"))
r.stage(["a", "b"])
commit_sha = r.do_commit(
b"Symlink b",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
)
self.assertEqual([self._root_commit], r[commit_sha].parents)
b_mode, b_id = tree_lookup_path(r.get_object, r[commit_sha].tree, b"b")
self.assertTrue(stat.S_ISLNK(b_mode))
self.assertEqual(b"a", r[b_id].data)
def test_commit_merge_heads_file(self):
tmp_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmp_dir)
r = Repo.init(tmp_dir)
with open(os.path.join(r.path, "a"), "w") as f:
f.write("initial text")
c1 = r.do_commit(
b"initial commit",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
)
with open(os.path.join(r.path, "a"), "w") as f:
f.write("merged text")
with open(os.path.join(r.path, ".git", "MERGE_HEAD"), "w") as f:
f.write("c27a2d21dd136312d7fa9e8baabb82561a1727d0\n")
r.stage(["a"])
commit_sha = r.do_commit(
b"deleted a",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
)
self.assertEqual(
[c1, b"c27a2d21dd136312d7fa9e8baabb82561a1727d0"],
r[commit_sha].parents,
)
def test_commit_deleted(self):
r = self._repo
os.remove(os.path.join(r.path, "a"))
r.stage(["a"])
commit_sha = r.do_commit(
b"deleted a",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
)
self.assertEqual([self._root_commit], r[commit_sha].parents)
self.assertEqual([], list(r.open_index()))
tree = r[r[commit_sha].tree]
self.assertEqual([], list(tree.iteritems()))
def test_commit_follows(self):
r = self._repo
r.refs.set_symbolic_ref(b"HEAD", b"refs/heads/bla")
commit_sha = r.do_commit(
b"commit with strange character",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
ref=b"HEAD",
)
self.assertEqual(commit_sha, r[b"refs/heads/bla"].id)
def test_commit_encoding(self):
r = self._repo
commit_sha = r.do_commit(
b"commit with strange character \xee",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
encoding=b"iso8859-1",
)
self.assertEqual(b"iso8859-1", r[commit_sha].encoding)
def test_compression_level(self):
r = self._repo
c = r.get_config()
c.set(("core",), "compression", "3")
c.set(("core",), "looseCompression", "4")
c.write_to_path()
r = Repo(self._repo_dir)
self.assertEqual(r.object_store.loose_compression_level, 4)
def test_repositoryformatversion(self):
r = self._repo
c = r.get_config()
c.set(("core",), "repositoryformatversion", "2")
c.write_to_path()
self.assertRaises(UnsupportedVersion, Repo, self._repo_dir)
def test_commit_encoding_from_config(self):
r = self._repo
c = r.get_config()
c.set(("i18n",), "commitEncoding", "iso8859-1")
c.write_to_path()
commit_sha = r.do_commit(
b"commit with strange character \xee",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
)
self.assertEqual(b"iso8859-1", r[commit_sha].encoding)
def test_commit_config_identity(self):
# commit falls back to the users' identity if it wasn't specified
r = self._repo
c = r.get_config()
c.set((b"user",), b"name", b"Jelmer")
c.set((b"user",), b"email", b"jelmer@apache.org")
c.write_to_path()
commit_sha = r.do_commit(b"message")
self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].author)
self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].committer)
def test_commit_config_identity_strips_than(self):
# commit falls back to the users' identity if it wasn't specified,
# and strips superfluous <>
r = self._repo
c = r.get_config()
c.set((b"user",), b"name", b"Jelmer")
c.set((b"user",), b"email", b"<jelmer@apache.org>")
c.write_to_path()
commit_sha = r.do_commit(b"message")
self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].author)
self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].committer)
def test_commit_config_identity_in_memoryrepo(self):
# commit falls back to the users' identity if it wasn't specified
r = MemoryRepo.init_bare([], {})
c = r.get_config()
c.set((b"user",), b"name", b"Jelmer")
c.set((b"user",), b"email", b"jelmer@apache.org")
commit_sha = r.do_commit(b"message", tree=objects.Tree().id)
self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].author)
self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].committer)
def overrideEnv(self, name, value):
def restore():
if oldval is not None:
os.environ[name] = oldval
else:
del os.environ[name]
oldval = os.environ.get(name)
os.environ[name] = value
self.addCleanup(restore)
def test_commit_config_identity_from_env(self):
# commit falls back to the users' identity if it wasn't specified
self.overrideEnv("GIT_COMMITTER_NAME", "joe")
self.overrideEnv("GIT_COMMITTER_EMAIL", "joe@example.com")
r = self._repo
c = r.get_config()
c.set((b"user",), b"name", b"Jelmer")
c.set((b"user",), b"email", b"jelmer@apache.org")
c.write_to_path()
commit_sha = r.do_commit(b"message")
self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].author)
self.assertEqual(b"joe <joe@example.com>", r[commit_sha].committer)
def test_commit_fail_ref(self):
r = self._repo
def set_if_equals(name, old_ref, new_ref, **kwargs):
return False
r.refs.set_if_equals = set_if_equals
def add_if_new(name, new_ref, **kwargs):
self.fail("Unexpected call to add_if_new")
r.refs.add_if_new = add_if_new
old_shas = set(r.object_store)
self.assertRaises(
errors.CommitError,
r.do_commit,
b"failed commit",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12345,
commit_timezone=0,
author_timestamp=12345,
author_timezone=0,
)
new_shas = set(r.object_store) - old_shas
self.assertEqual(1, len(new_shas))
# Check that the new commit (now garbage) was added.
new_commit = r[new_shas.pop()]
self.assertEqual(r[self._root_commit].tree, new_commit.tree)
self.assertEqual(b"failed commit", new_commit.message)
def test_commit_branch(self):
r = self._repo
commit_sha = r.do_commit(
b"commit to branch",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
ref=b"refs/heads/new_branch",
)
self.assertEqual(self._root_commit, r[b"HEAD"].id)
self.assertEqual(commit_sha, r[b"refs/heads/new_branch"].id)
self.assertEqual([], r[commit_sha].parents)
self.assertTrue(b"refs/heads/new_branch" in r)
new_branch_head = commit_sha
commit_sha = r.do_commit(
b"commit to branch 2",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
ref=b"refs/heads/new_branch",
)
self.assertEqual(self._root_commit, r[b"HEAD"].id)
self.assertEqual(commit_sha, r[b"refs/heads/new_branch"].id)
self.assertEqual([new_branch_head], r[commit_sha].parents)
def test_commit_merge_heads(self):
r = self._repo
merge_1 = r.do_commit(
b"commit to branch 2",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
ref=b"refs/heads/new_branch",
)
commit_sha = r.do_commit(
b"commit with merge",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
merge_heads=[merge_1],
)
self.assertEqual([self._root_commit, merge_1], r[commit_sha].parents)
def test_commit_dangling_commit(self):
r = self._repo
old_shas = set(r.object_store)
old_refs = r.get_refs()
commit_sha = r.do_commit(
b"commit with no ref",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
ref=None,
)
new_shas = set(r.object_store) - old_shas
# New sha is added, but no new refs
self.assertEqual(1, len(new_shas))
new_commit = r[new_shas.pop()]
self.assertEqual(r[self._root_commit].tree, new_commit.tree)
self.assertEqual([], r[commit_sha].parents)
self.assertEqual(old_refs, r.get_refs())
def test_commit_dangling_commit_with_parents(self):
r = self._repo
old_shas = set(r.object_store)
old_refs = r.get_refs()
commit_sha = r.do_commit(
b"commit with no ref",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
ref=None,
merge_heads=[self._root_commit],
)
new_shas = set(r.object_store) - old_shas
# New sha is added, but no new refs
self.assertEqual(1, len(new_shas))
new_commit = r[new_shas.pop()]
self.assertEqual(r[self._root_commit].tree, new_commit.tree)
self.assertEqual([self._root_commit], r[commit_sha].parents)
self.assertEqual(old_refs, r.get_refs())
def test_stage_absolute(self):
r = self._repo
os.remove(os.path.join(r.path, "a"))
self.assertRaises(ValueError, r.stage, [os.path.join(r.path, "a")])
def test_stage_deleted(self):
r = self._repo
os.remove(os.path.join(r.path, "a"))
r.stage(["a"])
r.stage(["a"]) # double-stage a deleted path
def test_stage_directory(self):
r = self._repo
os.mkdir(os.path.join(r.path, "c"))
r.stage(["c"])
self.assertEqual([b"a"], list(r.open_index()))
def test_unstage_midify_file_with_dir(self):
os.mkdir(os.path.join(self._repo.path, 'new_dir'))
full_path = os.path.join(self._repo.path, 'new_dir', 'foo')
with open(full_path, 'w') as f:
f.write('hello')
porcelain.add(self._repo, paths=[full_path])
porcelain.commit(
self._repo,
message=b"unitest",
committer=b"Jane <jane@example.com>",
author=b"John <john@example.com>",
)
with open(full_path, 'a') as f:
f.write('something new')
self._repo.unstage(['new_dir/foo'])
status = list(porcelain.status(self._repo))
self.assertEqual([{'add': [], 'delete': [], 'modify': []}, [b'new_dir/foo'], []], status)
def test_unstage_while_no_commit(self):
file = 'foo'
full_path = os.path.join(self._repo.path, file)
with open(full_path, 'w') as f:
f.write('hello')
porcelain.add(self._repo, paths=[full_path])
self._repo.unstage([file])
status = list(porcelain.status(self._repo))
self.assertEqual([{'add': [], 'delete': [], 'modify': []}, [], ['foo']], status)
def test_unstage_add_file(self):
file = 'foo'
full_path = os.path.join(self._repo.path, file)
porcelain.commit(
self._repo,
message=b"unitest",
committer=b"Jane <jane@example.com>",
author=b"John <john@example.com>",
)
with open(full_path, 'w') as f:
f.write('hello')
porcelain.add(self._repo, paths=[full_path])
self._repo.unstage([file])
status = list(porcelain.status(self._repo))
self.assertEqual([{'add': [], 'delete': [], 'modify': []}, [], ['foo']], status)
def test_unstage_modify_file(self):
file = 'foo'
full_path = os.path.join(self._repo.path, file)
with open(full_path, 'w') as f:
f.write('hello')
porcelain.add(self._repo, paths=[full_path])
porcelain.commit(
self._repo,
message=b"unitest",
committer=b"Jane <jane@example.com>",
author=b"John <john@example.com>",
)
with open(full_path, 'a') as f:
f.write('broken')
porcelain.add(self._repo, paths=[full_path])
self._repo.unstage([file])
status = list(porcelain.status(self._repo))
self.assertEqual([{'add': [], 'delete': [], 'modify': []}, [b'foo'], []], status)
def test_unstage_remove_file(self):
file = 'foo'
full_path = os.path.join(self._repo.path, file)
with open(full_path, 'w') as f:
f.write('hello')
porcelain.add(self._repo, paths=[full_path])
porcelain.commit(
self._repo,
message=b"unitest",
committer=b"Jane <jane@example.com>",
author=b"John <john@example.com>",
)
os.remove(full_path)
self._repo.unstage([file])
status = list(porcelain.status(self._repo))
self.assertEqual([{'add': [], 'delete': [], 'modify': []}, [b'foo'], []], status)
@skipIf(
sys.platform in ("win32", "darwin"),
"tries to implicitly decode as utf8",
)
def test_commit_no_encode_decode(self):
r = self._repo
repo_path_bytes = os.fsencode(r.path)
encodings = ("utf8", "latin1")
names = [u"À".encode(encoding) for encoding in encodings]
for name, encoding in zip(names, encodings):
full_path = os.path.join(repo_path_bytes, name)
with open(full_path, "wb") as f:
f.write(encoding.encode("ascii"))
# These files are break tear_down_repo, so cleanup these files
# ourselves.
self.addCleanup(os.remove, full_path)
r.stage(names)
commit_sha = r.do_commit(
b"Files with different encodings",
committer=b"Test Committer <test@nodomain.com>",
author=b"Test Author <test@nodomain.com>",
commit_timestamp=12395,
commit_timezone=0,
author_timestamp=12395,
author_timezone=0,
ref=None,
merge_heads=[self._root_commit],
)
for name, encoding in zip(names, encodings):
mode, id = tree_lookup_path(r.get_object, r[commit_sha].tree, name)
self.assertEqual(stat.S_IFREG | 0o644, mode)
self.assertEqual(encoding.encode("ascii"), r[id].data)
def test_discover_intended(self):
path = os.path.join(self._repo_dir, "b/c")
r = Repo.discover(path)
self.assertEqual(r.head(), self._repo.head())
def test_discover_isrepo(self):
r = Repo.discover(self._repo_dir)
self.assertEqual(r.head(), self._repo.head())
def test_discover_notrepo(self):
with self.assertRaises(NotGitRepository):
Repo.discover("/")
class CheckUserIdentityTests(TestCase):
def test_valid(self):
check_user_identity(b"Me <me@example.com>")
def test_invalid(self):
self.assertRaises(InvalidUserIdentity, check_user_identity, b"No Email")
self.assertRaises(
InvalidUserIdentity, check_user_identity, b"Fullname <missing"
)
self.assertRaises(
InvalidUserIdentity, check_user_identity, b"Fullname missing>"
)
self.assertRaises(
InvalidUserIdentity, check_user_identity, b"Fullname >order<>"
)
diff --git a/setup.py b/setup.py
index b1b6e5e3..8ca2a2fb 100755
--- a/setup.py
+++ b/setup.py
@@ -1,136 +1,136 @@
#!/usr/bin/python3
# encoding: utf-8
# Setup file for dulwich
# Copyright (C) 2008-2016 Jelmer Vernooij <jelmer@jelmer.uk>
try:
from setuptools import setup, Extension
except ImportError:
from distutils.core import setup, Extension
has_setuptools = False
else:
has_setuptools = True
from distutils.core import Distribution
import io
import os
import sys
from typing import Dict, Any
if sys.version_info < (3, 6):
raise Exception(
'Dulwich only supports Python 3.6 and later. '
'For 2.7 support, please install a version prior to 0.20')
-dulwich_version_string = '0.20.26'
+dulwich_version_string = '0.20.27'
class DulwichDistribution(Distribution):
def is_pure(self):
if self.pure:
return True
def has_ext_modules(self):
return not self.pure
global_options = Distribution.global_options + [
('pure', None, "use pure Python code instead of C "
"extensions (slower on CPython)")]
pure = False
if sys.platform == 'darwin' and os.path.exists('/usr/bin/xcodebuild'):
# XCode 4.0 dropped support for ppc architecture, which is hardcoded in
# distutils.sysconfig
import subprocess
p = subprocess.Popen(
['/usr/bin/xcodebuild', '-version'], stdout=subprocess.PIPE,
stderr=subprocess.PIPE, env={})
out, err = p.communicate()
for line in out.splitlines():
line = line.decode("utf8")
# Also parse only first digit, because 3.2.1 can't be parsed nicely
if (line.startswith('Xcode') and
int(line.split()[1].split('.')[0]) >= 4):
os.environ['ARCHFLAGS'] = ''
tests_require = ['fastimport']
if '__pypy__' not in sys.modules and sys.platform != 'win32':
tests_require.extend([
'gevent', 'geventhttpclient', 'setuptools>=17.1'])
ext_modules = [
Extension('dulwich._objects', ['dulwich/_objects.c']),
Extension('dulwich._pack', ['dulwich/_pack.c']),
Extension('dulwich._diff_tree', ['dulwich/_diff_tree.c']),
]
setup_kwargs = {} # type: Dict[str, Any]
scripts = ['bin/dul-receive-pack', 'bin/dul-upload-pack']
if has_setuptools:
setup_kwargs['extras_require'] = {
'fastimport': ['fastimport'],
'https': ['urllib3[secure]>=1.24.1'],
'pgp': ['gpg'],
'watch': ['pyinotify'],
}
setup_kwargs['install_requires'] = ['urllib3>=1.24.1', 'certifi']
setup_kwargs['include_package_data'] = True
setup_kwargs['test_suite'] = 'dulwich.tests.test_suite'
setup_kwargs['tests_require'] = tests_require
setup_kwargs['entry_points'] = {
"console_scripts": [
"dulwich=dulwich.cli:main",
]}
setup_kwargs['python_requires'] = '>=3.6'
else:
scripts.append('bin/dulwich')
with io.open(os.path.join(os.path.dirname(__file__), "README.rst"),
encoding="utf-8") as f:
description = f.read()
setup(name='dulwich',
author="Jelmer Vernooij",
author_email="jelmer@jelmer.uk",
url="https://www.dulwich.io/",
long_description=description,
description="Python Git Library",
version=dulwich_version_string,
license='Apachev2 or later or GPLv2',
project_urls={
"Bug Tracker": "https://github.com/dulwich/dulwich/issues",
"Repository": "https://www.dulwich.io/code/",
"GitHub": "https://github.com/dulwich/dulwich",
},
keywords="git vcs",
packages=['dulwich', 'dulwich.tests', 'dulwich.tests.compat',
'dulwich.contrib'],
package_data={'': ['../docs/tutorial/*.txt', 'py.typed']},
scripts=scripts,
ext_modules=ext_modules,
zip_safe=False,
distclass=DulwichDistribution,
classifiers=[
'Development Status :: 4 - Beta',
'License :: OSI Approved :: Apache Software License',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
'Programming Language :: Python :: 3.9',
'Programming Language :: Python :: 3.10',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Operating System :: POSIX',
'Operating System :: Microsoft :: Windows',
'Topic :: Software Development :: Version Control',
],
**setup_kwargs
)
File Metadata
Details
Attached
Mime Type
text/x-diff
Expires
Jul 4 2025, 8:52 AM (6 w, 5 d ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
3268301
Attached To
rPPDW python3-dulwich packaging
Event Timeline
Log In to Comment