Page Menu
Home
Software Heritage
Search
Configure Global Search
Log In
Files
F9749554
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Flag For Later
Size
458 KB
Subscribers
None
View Options
This file is larger than 256 KB, so syntax highlighting was skipped.
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 00000000..7ba03084
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: jelmer
diff --git a/NEWS b/NEWS
index 41df77cb..c51ea231 100644
--- a/NEWS
+++ b/NEWS
@@ -1,2287 +1,2309 @@
+0.20.30 2022-01-08
+
+0.20.29 2022-01-08
+
+ * Support staging submodules.
+ (Jelmer Vernooij)
+
+ * Drop deprecated Index.iterblobs and iter_fresh_blobs.
+ (Jelmer Vernooij)
+
+ * Unify clone behaviour of ``Repo.clone`` and
+ ``porcelain.clone``, and add branch parameter for
+ clone. (Peter Rowlands, #851)
+
+0.20.28 2022-01-05
+
+ * Fix hook test on Mac OSX / Linux when dulwich is
+ not installed system-wide. (Jelmer Vernooij, #919)
+
+ * Cope with gecos being unset.
+ (Jelmer Vernooij, #917)
+
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 3f3f472b..fc2a42b7 100644
--- a/PKG-INFO
+++ b/PKG-INFO
@@ -1,127 +1,127 @@
Metadata-Version: 2.1
Name: dulwich
-Version: 0.20.27
+Version: 0.20.30
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 3f3f472b..fc2a42b7 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.27
+Version: 0.20.30
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 a9f8ea6e..cb1509bc 100644
--- a/dulwich.egg-info/SOURCES.txt
+++ b/dulwich.egg-info/SOURCES.txt
@@ -1,254 +1,255 @@
.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/FUNDING.yml
.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 cb4d9056..b6d26379 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, 27)
+__version__ = (0, 20, 30)
diff --git a/dulwich/index.py b/dulwich/index.py
index 700b2d4e..2c5a1735 100644
--- a/dulwich/index.py
+++ b/dulwich/index.py
@@ -1,984 +1,960 @@
# index.py -- File parser/writer for the git index file
# 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.
#
"""Parser for the git index file format."""
import collections
import os
import stat
import struct
import sys
from typing import (
Any,
BinaryIO,
Callable,
Dict,
List,
Optional,
TYPE_CHECKING,
Iterable,
Iterator,
Tuple,
)
if TYPE_CHECKING:
from dulwich.object_store import BaseObjectStore
from dulwich.file import GitFile
from dulwich.objects import (
Blob,
S_IFGITLINK,
S_ISGITLINK,
Tree,
hex_to_sha,
sha_to_hex,
)
from dulwich.pack import (
SHA1Reader,
SHA1Writer,
)
# TODO(jelmer): Switch to dataclass?
IndexEntry = collections.namedtuple(
"IndexEntry",
[
"ctime",
"mtime",
"dev",
"ino",
"mode",
"uid",
"gid",
"size",
"sha",
"flags",
"extended_flags",
],
)
# 2-bit stage (during merge)
FLAG_STAGEMASK = 0x3000
# assume-valid
FLAG_VALID = 0x8000
# extended flag (must be zero in version 2)
FLAG_EXTENDED = 0x4000
# used by sparse checkout
EXTENDED_FLAG_SKIP_WORKTREE = 0x4000
# used by "git add -N"
EXTENDED_FLAG_INTEND_TO_ADD = 0x2000
DEFAULT_VERSION = 2
def pathsplit(path):
"""Split a /-delimited path into a directory part and a basename.
Args:
path: The path to split.
Returns:
Tuple with directory name and basename
"""
try:
(dirname, basename) = path.rsplit(b"/", 1)
except ValueError:
return (b"", path)
else:
return (dirname, basename)
def pathjoin(*args):
"""Join a /-delimited path."""
return b"/".join([p for p in args if p])
def read_cache_time(f):
"""Read a cache time.
Args:
f: File-like object to read from
Returns:
Tuple with seconds and nanoseconds
"""
return struct.unpack(">LL", f.read(8))
def write_cache_time(f, t):
"""Write a cache time.
Args:
f: File-like object to write to
t: Time to write (as int, float or tuple with secs and nsecs)
"""
if isinstance(t, int):
t = (t, 0)
elif isinstance(t, float):
(secs, nsecs) = divmod(t, 1.0)
t = (int(secs), int(nsecs * 1000000000))
elif not isinstance(t, tuple):
raise TypeError(t)
f.write(struct.pack(">LL", *t))
def read_cache_entry(f, version: int) -> Tuple[str, IndexEntry]:
"""Read an entry from a cache file.
Args:
f: File-like object to read from
Returns:
tuple with: name, IndexEntry
"""
beginoffset = f.tell()
ctime = read_cache_time(f)
mtime = read_cache_time(f)
(
dev,
ino,
mode,
uid,
gid,
size,
sha,
flags,
) = struct.unpack(">LLLLLL20sH", f.read(20 + 4 * 6 + 2))
if flags & FLAG_EXTENDED:
if version < 3:
raise AssertionError(
'extended flag set in index with version < 3')
(extended_flags, ) = struct.unpack(">H", f.read(2))
else:
extended_flags = 0
name = f.read((flags & 0x0FFF))
# Padding:
if version < 4:
real_size = (f.tell() - beginoffset + 8) & ~7
f.read((beginoffset + real_size) - f.tell())
return (
name,
IndexEntry(
ctime,
mtime,
dev,
ino,
mode,
uid,
gid,
size,
sha_to_hex(sha),
flags & ~0x0FFF,
extended_flags,
))
def write_cache_entry(f, name, entry, version):
"""Write an index entry to a file.
Args:
f: File object
entry: IndexEntry to write, tuple with:
"""
beginoffset = f.tell()
write_cache_time(f, entry.ctime)
write_cache_time(f, entry.mtime)
flags = len(name) | (entry.flags & ~0x0FFF)
if entry.extended_flags:
flags |= FLAG_EXTENDED
if flags & FLAG_EXTENDED and version is not None and version < 3:
raise AssertionError('unable to use extended flags in version < 3')
f.write(
struct.pack(
b">LLLLLL20sH",
entry.dev & 0xFFFFFFFF,
entry.ino & 0xFFFFFFFF,
entry.mode,
entry.uid,
entry.gid,
entry.size,
hex_to_sha(entry.sha),
flags,
)
)
if flags & FLAG_EXTENDED:
f.write(struct.pack(b">H", entry.extended_flags))
f.write(name)
if version < 4:
real_size = (f.tell() - beginoffset + 8) & ~7
f.write(b"\0" * ((beginoffset + real_size) - f.tell()))
def read_index(f: BinaryIO):
"""Read an index file, yielding the individual entries."""
header = f.read(4)
if header != b"DIRC":
raise AssertionError("Invalid index file header: %r" % header)
(version, num_entries) = struct.unpack(b">LL", f.read(4 * 2))
assert version in (1, 2, 3), "index version is %r" % version
for i in range(num_entries):
yield read_cache_entry(f, version)
def read_index_dict(f):
"""Read an index file and return it as a dictionary.
Args:
f: File object to read from
"""
ret = {}
for name, entry in read_index(f):
ret[name] = entry
return ret
def write_index(f: BinaryIO, entries: List[Tuple[bytes, IndexEntry]], version: Optional[int] = None):
"""Write an index file.
Args:
f: File-like object to write to
version: Version number to write
entries: Iterable over the entries to write
"""
if version is None:
version = DEFAULT_VERSION
f.write(b"DIRC")
f.write(struct.pack(b">LL", version, len(entries)))
for name, entry in entries:
write_cache_entry(f, name, entry, version)
def write_index_dict(
f: BinaryIO,
entries: Dict[bytes, IndexEntry],
version: Optional[int] = None,
) -> None:
"""Write an index file based on the contents of a dictionary."""
entries_list = []
for name in sorted(entries):
entries_list.append((name, entries[name]))
write_index(f, entries_list, version=version)
def cleanup_mode(mode: int) -> int:
"""Cleanup a mode value.
This will return a mode that can be stored in a tree object.
Args:
mode: Mode to clean up.
Returns:
mode
"""
if stat.S_ISLNK(mode):
return stat.S_IFLNK
elif stat.S_ISDIR(mode):
return stat.S_IFDIR
elif S_ISGITLINK(mode):
return S_IFGITLINK
ret = stat.S_IFREG | 0o644
if mode & 0o100:
ret |= 0o111
return ret
class Index(object):
"""A Git Index file."""
def __init__(self, filename):
"""Open an index file.
Args:
filename: Path to the index file
"""
self._filename = filename
# TODO(jelmer): Store the version returned by read_index
self._version = None
self.clear()
self.read()
@property
def path(self):
return self._filename
def __repr__(self):
return "%s(%r)" % (self.__class__.__name__, self._filename)
def write(self) -> None:
"""Write current contents of index to disk."""
f = GitFile(self._filename, "wb")
try:
f = SHA1Writer(f)
write_index_dict(f, self._byname, version=self._version)
finally:
f.close()
def read(self):
"""Read current contents of index from disk."""
if not os.path.exists(self._filename):
return
f = GitFile(self._filename, "rb")
try:
f = SHA1Reader(f)
for name, entry in read_index(f):
self[name] = entry
# FIXME: Additional data?
f.read(os.path.getsize(self._filename) - f.tell() - 20)
f.check_sha()
finally:
f.close()
def __len__(self) -> int:
"""Number of entries in this index file."""
return len(self._byname)
def __getitem__(self, name: bytes) -> IndexEntry:
"""Retrieve entry by relative path.
Returns: tuple with (ctime, mtime, dev, ino, mode, uid, gid, size, sha,
flags)
"""
return self._byname[name]
def __iter__(self) -> Iterator[bytes]:
"""Iterate over the paths in this index."""
return iter(self._byname)
def get_sha1(self, path: bytes) -> bytes:
"""Return the (git object) SHA1 for the object at a path."""
return self[path].sha
def get_mode(self, path: bytes) -> int:
"""Return the POSIX file mode for the object at a path."""
return self[path].mode
def iterobjects(self) -> Iterable[Tuple[bytes, bytes, int]]:
"""Iterate over path, sha, mode tuples for use with commit_tree."""
for path in self:
entry = self[path]
yield path, entry.sha, cleanup_mode(entry.mode)
- def iterblobs(self):
- import warnings
-
- warnings.warn("Use iterobjects() instead.", PendingDeprecationWarning)
- return self.iterobjects()
-
def clear(self):
"""Remove all contents from this index."""
self._byname = {}
def __setitem__(self, name, x):
assert isinstance(name, bytes)
assert len(x) == len(IndexEntry._fields)
# Remove the old entry if any
self._byname[name] = IndexEntry(*x)
def __delitem__(self, name):
assert isinstance(name, bytes)
del self._byname[name]
def iteritems(self):
return self._byname.items()
def items(self):
return self._byname.items()
def update(self, entries):
for name, value in entries.items():
self[name] = value
def changes_from_tree(self, object_store, tree, want_unchanged=False):
"""Find the differences between the contents of this index and a tree.
Args:
object_store: Object store to use for retrieving tree contents
tree: SHA1 of the root tree
want_unchanged: Whether unchanged files should be reported
Returns: Iterator over tuples with (oldpath, newpath), (oldmode,
newmode), (oldsha, newsha)
"""
def lookup_entry(path):
entry = self[path]
return entry.sha, cleanup_mode(entry.mode)
for (name, mode, sha) in changes_from_tree(
self._byname.keys(),
lookup_entry,
object_store,
tree,
want_unchanged=want_unchanged,
):
yield (name, mode, sha)
def commit(self, object_store):
"""Create a new tree from an index.
Args:
object_store: Object store to save the tree in
Returns:
Root tree SHA
"""
return commit_tree(object_store, self.iterobjects())
def commit_tree(
object_store: "BaseObjectStore", blobs: Iterable[Tuple[bytes, bytes, int]]
) -> bytes:
"""Commit a new tree.
Args:
object_store: Object store to add trees to
blobs: Iterable over blob path, sha, mode entries
Returns:
SHA1 of the created tree.
"""
trees = {b"": {}} # type: Dict[bytes, Any]
def add_tree(path):
if path in trees:
return trees[path]
dirname, basename = pathsplit(path)
t = add_tree(dirname)
assert isinstance(basename, bytes)
newtree = {}
t[basename] = newtree
trees[path] = newtree
return newtree
for path, sha, mode in blobs:
tree_path, basename = pathsplit(path)
tree = add_tree(tree_path)
tree[basename] = (mode, sha)
def build_tree(path):
tree = Tree()
for basename, entry in trees[path].items():
if isinstance(entry, dict):
mode = stat.S_IFDIR
sha = build_tree(pathjoin(path, basename))
else:
(mode, sha) = entry
tree.add(basename, mode, sha)
object_store.add_object(tree)
return tree.id
return build_tree(b"")
def commit_index(object_store: "BaseObjectStore", index: Index) -> bytes:
"""Create a new tree from an index.
Args:
object_store: Object store to save the tree in
index: Index file
Note: This function is deprecated, use index.commit() instead.
Returns: Root tree sha.
"""
return commit_tree(object_store, index.iterobjects())
def changes_from_tree(
names: Iterable[bytes],
lookup_entry: Callable[[bytes], Tuple[bytes, int]],
object_store: "BaseObjectStore",
tree: Optional[bytes],
want_unchanged=False,
) -> Iterable[
Tuple[
Tuple[Optional[bytes], Optional[bytes]],
Tuple[Optional[int], Optional[int]],
Tuple[Optional[bytes], Optional[bytes]],
]
]:
"""Find the differences between the contents of a tree and
a working copy.
Args:
names: Iterable of names in the working copy
lookup_entry: Function to lookup an entry in the working copy
object_store: Object store to use for retrieving tree contents
tree: SHA1 of the root tree, or None for an empty tree
want_unchanged: Whether unchanged files should be reported
Returns: Iterator over tuples with (oldpath, newpath), (oldmode, newmode),
(oldsha, newsha)
"""
# TODO(jelmer): Support a include_trees option
other_names = set(names)
if tree is not None:
for (name, mode, sha) in object_store.iter_tree_contents(tree):
try:
(other_sha, other_mode) = lookup_entry(name)
except KeyError:
# Was removed
yield ((name, None), (mode, None), (sha, None))
else:
other_names.remove(name)
if want_unchanged or other_sha != sha or other_mode != mode:
yield ((name, name), (mode, other_mode), (sha, other_sha))
# Mention added files
for name in other_names:
try:
(other_sha, other_mode) = lookup_entry(name)
except KeyError:
pass
else:
yield ((None, name), (None, other_mode), (None, other_sha))
def index_entry_from_stat(
stat_val, hex_sha: bytes, flags: int, mode: Optional[int] = None,
extended_flags: Optional[int] = None
):
"""Create a new index entry from a stat value.
Args:
stat_val: POSIX stat_result instance
hex_sha: Hex sha of the object
flags: Index flags
"""
if mode is None:
mode = cleanup_mode(stat_val.st_mode)
return IndexEntry(
stat_val.st_ctime,
stat_val.st_mtime,
stat_val.st_dev,
stat_val.st_ino,
mode,
stat_val.st_uid,
stat_val.st_gid,
stat_val.st_size,
hex_sha,
flags,
extended_flags
)
def build_file_from_blob(
blob, mode, target_path, honor_filemode=True, tree_encoding="utf-8"
):
"""Build a file or symlink on disk based on a Git object.
Args:
obj: The git object
mode: File mode
target_path: Path to write to
honor_filemode: An optional flag to honor core.filemode setting in
config file, default is core.filemode=True, change executable bit
Returns: stat object for the file
"""
try:
oldstat = os.lstat(target_path)
except FileNotFoundError:
oldstat = None
contents = blob.as_raw_string()
if stat.S_ISLNK(mode):
# FIXME: This will fail on Windows. What should we do instead?
if oldstat:
os.unlink(target_path)
if sys.platform == "win32":
# os.readlink on Python3 on Windows requires a unicode string.
contents = contents.decode(tree_encoding)
target_path = target_path.decode(tree_encoding)
os.symlink(contents, target_path)
else:
if oldstat is not None and oldstat.st_size == len(contents):
with open(target_path, "rb") as f:
if f.read() == contents:
return oldstat
with open(target_path, "wb") as f:
# Write out file
f.write(contents)
if honor_filemode:
os.chmod(target_path, mode)
return os.lstat(target_path)
INVALID_DOTNAMES = (b".git", b".", b"..", b"")
def validate_path_element_default(element):
return element.lower() not in INVALID_DOTNAMES
def validate_path_element_ntfs(element):
stripped = element.rstrip(b". ").lower()
if stripped in INVALID_DOTNAMES:
return False
if stripped == b"git~1":
return False
return True
def validate_path(path, element_validator=validate_path_element_default):
"""Default path validator that just checks for .git/."""
parts = path.split(b"/")
for p in parts:
if not element_validator(p):
return False
else:
return True
def build_index_from_tree(
root_path,
index_path,
object_store,
tree_id,
honor_filemode=True,
validate_path_element=validate_path_element_default,
):
"""Generate and materialize index from a tree
Args:
tree_id: Tree to materialize
root_path: Target dir for materialized index files
index_path: Target path for generated index
object_store: Non-empty object store holding tree contents
honor_filemode: An optional flag to honor core.filemode setting in
config file, default is core.filemode=True, change executable bit
validate_path_element: Function to validate path elements to check
out; default just refuses .git and .. directories.
Note: existing index is wiped and contents are not merged
in a working dir. Suitable only for fresh clones.
"""
index = Index(index_path)
if not isinstance(root_path, bytes):
root_path = os.fsencode(root_path)
for entry in object_store.iter_tree_contents(tree_id):
if not validate_path(entry.path, validate_path_element):
continue
full_path = _tree_to_fs_path(root_path, entry.path)
if not os.path.exists(os.path.dirname(full_path)):
os.makedirs(os.path.dirname(full_path))
# TODO(jelmer): Merge new index into working tree
if S_ISGITLINK(entry.mode):
if not os.path.isdir(full_path):
os.mkdir(full_path)
st = os.lstat(full_path)
# TODO(jelmer): record and return submodule paths
else:
obj = object_store[entry.sha]
st = build_file_from_blob(
obj, entry.mode, full_path, honor_filemode=honor_filemode
)
# Add file to index
if not honor_filemode or S_ISGITLINK(entry.mode):
# we can not use tuple slicing to build a new tuple,
# because on windows that will convert the times to
# longs, which causes errors further along
st_tuple = (
entry.mode,
st.st_ino,
st.st_dev,
st.st_nlink,
st.st_uid,
st.st_gid,
st.st_size,
st.st_atime,
st.st_mtime,
st.st_ctime,
)
st = st.__class__(st_tuple)
index[entry.path] = index_entry_from_stat(st, entry.sha, 0)
index.write()
def blob_from_path_and_mode(fs_path, mode, tree_encoding="utf-8"):
"""Create a blob from a path and a stat object.
Args:
fs_path: Full file system path to file
st: A stat object
Returns: A `Blob` object
"""
assert isinstance(fs_path, bytes)
blob = Blob()
if stat.S_ISLNK(mode):
if sys.platform == "win32":
# os.readlink on Python3 on Windows requires a unicode string.
fs_path = os.fsdecode(fs_path)
blob.data = os.readlink(fs_path).encode(tree_encoding)
else:
blob.data = os.readlink(fs_path)
else:
with open(fs_path, "rb") as f:
blob.data = f.read()
return blob
def blob_from_path_and_stat(fs_path, st, tree_encoding="utf-8"):
"""Create a blob from a path and a stat object.
Args:
fs_path: Full file system path to file
st: A stat object
Returns: A `Blob` object
"""
return blob_from_path_and_mode(fs_path, st.st_mode, tree_encoding)
def read_submodule_head(path):
"""Read the head commit of a submodule.
Args:
path: path to the submodule
Returns: HEAD sha, None if not a valid head/repository
"""
from dulwich.errors import NotGitRepository
from dulwich.repo import Repo
# Repo currently expects a "str", so decode if necessary.
# TODO(jelmer): Perhaps move this into Repo() ?
if not isinstance(path, str):
path = os.fsdecode(path)
try:
repo = Repo(path)
except NotGitRepository:
return None
try:
return repo.head()
except KeyError:
return None
def _has_directory_changed(tree_path, entry):
"""Check if a directory has changed after getting an error.
When handling an error trying to create a blob from a path, call this
function. It will check if the path is a directory. If it's a directory
and a submodule, check the submodule head to see if it's has changed. If
not, consider the file as changed as Git tracked a file and not a
directory.
Return true if the given path should be considered as changed and False
otherwise or if the path is not a directory.
"""
# This is actually a directory
if os.path.exists(os.path.join(tree_path, b".git")):
# Submodule
head = read_submodule_head(tree_path)
if entry.sha != head:
return True
else:
# The file was changed to a directory, so consider it removed.
return True
return False
def get_unstaged_changes(index: Index, root_path, filter_blob_callback=None):
"""Walk through an index and check for differences against working tree.
Args:
index: index to check
root_path: path in which to find files
Returns: iterator over paths with unstaged changes
"""
# For each entry in the index check the sha1 & ensure not staged
if not isinstance(root_path, bytes):
root_path = os.fsencode(root_path)
for tree_path, entry in index.iteritems():
full_path = _tree_to_fs_path(root_path, tree_path)
try:
st = os.lstat(full_path)
if stat.S_ISDIR(st.st_mode):
if _has_directory_changed(tree_path, entry):
yield tree_path
continue
if not stat.S_ISREG(st.st_mode) and not stat.S_ISLNK(st.st_mode):
continue
blob = blob_from_path_and_stat(full_path, st)
if filter_blob_callback is not None:
blob = filter_blob_callback(blob, tree_path)
except FileNotFoundError:
# The file was removed, so we assume that counts as
# different from whatever file used to exist.
yield tree_path
else:
if blob.id != entry.sha:
yield tree_path
os_sep_bytes = os.sep.encode("ascii")
def _tree_to_fs_path(root_path, tree_path: bytes):
"""Convert a git tree path to a file system path.
Args:
root_path: Root filesystem path
tree_path: Git tree path as bytes
Returns: File system path.
"""
assert isinstance(tree_path, bytes)
if os_sep_bytes != b"/":
sep_corrected_path = tree_path.replace(b"/", os_sep_bytes)
else:
sep_corrected_path = tree_path
return os.path.join(root_path, sep_corrected_path)
def _fs_to_tree_path(fs_path):
"""Convert a file system path to a git tree path.
Args:
fs_path: File system path.
Returns: Git tree path as bytes
"""
if not isinstance(fs_path, bytes):
fs_path_bytes = os.fsencode(fs_path)
else:
fs_path_bytes = fs_path
if os_sep_bytes != b"/":
tree_path = fs_path_bytes.replace(os_sep_bytes, b"/")
else:
tree_path = fs_path_bytes
return tree_path
+def index_entry_from_directory(st, path):
+ if os.path.exists(os.path.join(path, b".git")):
+ head = read_submodule_head(path)
+ if head is None:
+ return None
+ return index_entry_from_stat(st, head, 0, mode=S_IFGITLINK)
+ return None
+
+
def index_entry_from_path(path, object_store=None):
"""Create an index from a filesystem path.
This returns an index value for files, symlinks
and tree references. for directories and
non-existant files it returns None
Args:
path: Path to create an index entry for
object_store: Optional object store to
save new blobs in
Returns: An index entry; None for directories
"""
assert isinstance(path, bytes)
st = os.lstat(path)
if stat.S_ISDIR(st.st_mode):
- if os.path.exists(os.path.join(path, b".git")):
- head = read_submodule_head(path)
- if head is None:
- return None
- return index_entry_from_stat(st, head, 0, mode=S_IFGITLINK)
- return None
+ return index_entry_from_directory(st, path)
if stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode):
blob = blob_from_path_and_stat(path, st)
if object_store is not None:
object_store.add_object(blob)
return index_entry_from_stat(st, blob.id, 0)
return None
def iter_fresh_entries(
paths, root_path, object_store: Optional["BaseObjectStore"] = None
):
"""Iterate over current versions of index entries on disk.
Args:
paths: Paths to iterate over
root_path: Root path to access from
store: Optional store to save new blobs in
Returns: Iterator over path, index_entry
"""
for path in paths:
p = _tree_to_fs_path(root_path, path)
try:
entry = index_entry_from_path(p, object_store=object_store)
except (FileNotFoundError, IsADirectoryError):
entry = None
yield path, entry
-def iter_fresh_blobs(index, root_path):
- """Iterate over versions of blobs on disk referenced by index.
-
- Don't use this function; it removes missing entries from index.
-
- Args:
- index: Index file
- root_path: Root path to access from
- include_deleted: Include deleted entries with sha and
- mode set to None
- Returns: Iterator over path, sha, mode
- """
- import warnings
-
- warnings.warn(PendingDeprecationWarning, "Use iter_fresh_objects instead.")
- for entry in iter_fresh_objects(index, root_path, include_deleted=True):
- if entry[1] is None:
- del index[entry[0]]
- else:
- yield entry
-
-
def iter_fresh_objects(paths, root_path, include_deleted=False, object_store=None):
"""Iterate over versions of objecs on disk referenced by index.
Args:
root_path: Root path to access from
include_deleted: Include deleted entries with sha and
mode set to None
object_store: Optional object store to report new items to
Returns: Iterator over path, sha, mode
"""
for path, entry in iter_fresh_entries(paths, root_path, object_store=object_store):
if entry is None:
if include_deleted:
yield path, None, None
else:
entry = IndexEntry(*entry)
yield path, entry.sha, cleanup_mode(entry.mode)
def refresh_index(index, root_path):
"""Refresh the contents of an index.
This is the equivalent to running 'git commit -a'.
Args:
index: Index to update
root_path: Root filesystem path
"""
for path, entry in iter_fresh_entries(index, root_path):
index[path] = path
diff --git a/dulwich/porcelain.py b/dulwich/porcelain.py
index 0749f444..8d4ab0eb 100644
--- a/dulwich/porcelain.py
+++ b/dulwich/porcelain.py
@@ -1,1941 +1,1909 @@
# porcelain.py -- Porcelain-like layer on top of Dulwich
# Copyright (C) 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.
#
"""Simple wrapper that provides porcelain-like functions on top of Dulwich.
Currently implemented:
* archive
* add
* branch{_create,_delete,_list}
* check-ignore
* checkout
* clone
* commit
* commit-tree
* daemon
* describe
* diff-tree
* fetch
* init
* ls-files
* ls-remote
* ls-tree
* pull
* push
* rm
* remote{_add}
* receive-pack
* reset
* rev-list
* tag{_create,_delete,_list}
* upload-pack
* update-server-info
* status
* symbolic-ref
These functions are meant to behave similarly to the git subcommands.
Differences in behaviour are considered bugs.
Note: one of the consequences of this is that paths tend to be
interpreted relative to the current working directory rather than relative
to the repository root.
Functions should generally accept both unicode strings and bytestrings
"""
from collections import namedtuple
from contextlib import (
closing,
contextmanager,
)
from io import BytesIO, RawIOBase
import datetime
import os
from pathlib import Path
import posixpath
-import shutil
import stat
import sys
import time
from typing import (
Dict,
Optional,
Tuple,
Union,
)
from dulwich.archive import (
tar_stream,
)
from dulwich.client import (
get_transport_and_path,
)
from dulwich.config import (
StackedConfig,
)
from dulwich.diff_tree import (
CHANGE_ADD,
CHANGE_DELETE,
CHANGE_MODIFY,
CHANGE_RENAME,
CHANGE_COPY,
RENAME_CHANGE_TYPES,
)
from dulwich.errors import (
SendPackError,
)
from dulwich.graph import (
can_fast_forward,
)
from dulwich.ignore import IgnoreFilterManager
from dulwich.index import (
blob_from_path_and_stat,
get_unstaged_changes,
build_file_from_blob,
_fs_to_tree_path,
)
from dulwich.object_store import (
tree_lookup_path,
)
from dulwich.objects import (
Commit,
Tag,
format_timezone,
parse_timezone,
pretty_format_tree_entry,
)
from dulwich.objectspec import (
parse_commit,
parse_object,
parse_ref,
parse_reftuples,
parse_tree,
)
from dulwich.pack import (
write_pack_index,
write_pack_objects,
)
from dulwich.patch import write_tree_diff
from dulwich.protocol import (
Protocol,
ZERO_SHA,
)
from dulwich.refs import (
ANNOTATED_TAG_SUFFIX,
LOCAL_BRANCH_PREFIX,
+ LOCAL_TAG_PREFIX,
strip_peeled_refs,
RefsContainer,
)
from dulwich.repo import BaseRepo, Repo
from dulwich.server import (
FileSystemBackend,
TCPGitServer,
ReceivePackHandler,
UploadPackHandler,
update_server_info as server_update_server_info,
)
# Module level tuple definition for status output
GitStatus = namedtuple("GitStatus", "staged unstaged untracked")
class NoneStream(RawIOBase):
"""Fallback if stdout or stderr are unavailable, does nothing."""
def read(self, size=-1):
return None
def readall(self):
return None
def readinto(self, b):
return None
def write(self, b):
return None
default_bytes_out_stream = getattr(sys.stdout, "buffer", None) or NoneStream()
default_bytes_err_stream = getattr(sys.stderr, "buffer", None) or NoneStream()
DEFAULT_ENCODING = "utf-8"
class Error(Exception):
"""Porcelain-based error. """
def __init__(self, msg, inner=None):
super(Error, self).__init__(msg)
self.inner = inner
class RemoteExists(Error):
"""Raised when the remote already exists."""
def open_repo(path_or_repo):
"""Open an argument that can be a repository or a path for a repository."""
if isinstance(path_or_repo, BaseRepo):
return path_or_repo
return Repo(path_or_repo)
@contextmanager
def _noop_context_manager(obj):
"""Context manager that has the same api as closing but does nothing."""
yield obj
def open_repo_closing(path_or_repo):
"""Open an argument that can be a repository or a path for a repository.
returns a context manager that will close the repo on exit if the argument
is a path, else does nothing if the argument is a repo.
"""
if isinstance(path_or_repo, BaseRepo):
return _noop_context_manager(path_or_repo)
return closing(Repo(path_or_repo))
def path_to_tree_path(repopath, path, tree_encoding=DEFAULT_ENCODING):
"""Convert a path to a path usable in an index, e.g. bytes and relative to
the repository root.
Args:
repopath: Repository path, absolute or relative to the cwd
path: A path, absolute or relative to the cwd
Returns: A path formatted for use in e.g. an index
"""
# Resolve might returns a relative path on Windows
# https://bugs.python.org/issue38671
if sys.platform == "win32":
path = os.path.abspath(path)
path = Path(path)
resolved_path = path.resolve()
# Resolve and abspath seems to behave differently regarding symlinks,
# as we are doing abspath on the file path, we need to do the same on
# the repo path or they might not match
if sys.platform == "win32":
repopath = os.path.abspath(repopath)
repopath = Path(repopath).resolve()
try:
relpath = resolved_path.relative_to(repopath)
except ValueError:
# If path is a symlink that points to a file outside the repo, we
# want the relpath for the link itself, not the resolved target
if path.is_symlink():
parent = path.parent.resolve()
relpath = (parent / path.name).relative_to(repopath)
else:
raise
if sys.platform == "win32":
return str(relpath).replace(os.path.sep, "/").encode(tree_encoding)
else:
return bytes(relpath)
class DivergedBranches(Error):
"""Branches have diverged and fast-forward is not possible."""
def check_diverged(repo, current_sha, new_sha):
"""Check if updating to a sha can be done with fast forwarding.
Args:
repo: Repository object
current_sha: Current head sha
new_sha: New head sha
"""
try:
can = can_fast_forward(repo, current_sha, new_sha)
except KeyError:
can = False
if not can:
raise DivergedBranches(current_sha, new_sha)
def archive(
repo,
committish=None,
outstream=default_bytes_out_stream,
errstream=default_bytes_err_stream,
):
"""Create an archive.
Args:
repo: Path of repository for which to generate an archive.
committish: Commit SHA1 or ref to use
outstream: Output stream (defaults to stdout)
errstream: Error stream (defaults to stderr)
"""
if committish is None:
committish = "HEAD"
with open_repo_closing(repo) as repo_obj:
c = parse_commit(repo_obj, committish)
for chunk in tar_stream(
repo_obj.object_store, repo_obj.object_store[c.tree], c.commit_time
):
outstream.write(chunk)
def update_server_info(repo="."):
"""Update server info files for a repository.
Args:
repo: path to the repository
"""
with open_repo_closing(repo) as r:
server_update_server_info(r)
def symbolic_ref(repo, ref_name, force=False):
"""Set git symbolic ref into HEAD.
Args:
repo: path to the repository
ref_name: short name of the new ref
force: force settings without checking if it exists in refs/heads
"""
with open_repo_closing(repo) as repo_obj:
ref_path = _make_branch_ref(ref_name)
if not force and ref_path not in repo_obj.refs.keys():
raise Error("fatal: ref `%s` is not a ref" % ref_name)
repo_obj.refs.set_symbolic_ref(b"HEAD", ref_path)
def commit(
repo=".",
message=None,
author=None,
committer=None,
encoding=None,
no_verify=False,
):
"""Create a new commit.
Args:
repo: Path to repository
message: Optional commit message
author: Optional author name and email
committer: Optional committer name and email
no_verify: Skip pre-commit and commit-msg hooks
Returns: SHA1 of the new commit
"""
# FIXME: Support --all argument
# FIXME: Support --signoff argument
if getattr(message, "encode", None):
message = message.encode(encoding or DEFAULT_ENCODING)
if getattr(author, "encode", None):
author = author.encode(encoding or DEFAULT_ENCODING)
if getattr(committer, "encode", None):
committer = committer.encode(encoding or DEFAULT_ENCODING)
with open_repo_closing(repo) as r:
return r.do_commit(
message=message,
author=author,
committer=committer,
encoding=encoding,
no_verify=no_verify,
)
def commit_tree(repo, tree, message=None, author=None, committer=None):
"""Create a new commit object.
Args:
repo: Path to repository
tree: An existing tree object
author: Optional author name and email
committer: Optional committer name and email
"""
with open_repo_closing(repo) as r:
return r.do_commit(
message=message, tree=tree, committer=committer, author=author
)
def init(path=".", bare=False):
"""Create a new git repository.
Args:
path: Path to repository.
bare: Whether to create a bare repository.
Returns: A Repo instance
"""
if not os.path.exists(path):
os.mkdir(path)
if bare:
return Repo.init_bare(path)
else:
return Repo.init(path)
def clone(
source,
target=None,
bare=False,
checkout=None,
errstream=default_bytes_err_stream,
outstream=None,
origin=b"origin",
depth=None,
+ branch=None,
**kwargs
):
"""Clone a local or remote git repository.
Args:
source: Path or URL for source repository
target: Path to target repository (optional)
bare: Whether or not to create a bare repository
checkout: Whether or not to check-out HEAD after cloning
errstream: Optional stream to write progress to
outstream: Optional stream to write progress to (deprecated)
origin: Name of remote from the repository used to clone
depth: Depth to fetch at
+ branch: Optional branch or tag to be used as HEAD in the new repository
+ instead of the cloned repository's HEAD.
Returns: The new repository
"""
- # TODO(jelmer): This code overlaps quite a bit with Repo.clone
if outstream is not None:
import warnings
warnings.warn(
"outstream= has been deprecated in favour of errstream=.",
DeprecationWarning,
stacklevel=3,
)
- errstream = outstream
+ # TODO(jelmer): Capture logging output and stream to errstream
if checkout is None:
checkout = not bare
if checkout and bare:
raise Error("checkout and bare are incompatible")
if target is None:
target = source.split("/")[-1]
- if not os.path.exists(target):
- os.mkdir(target)
+ mkdir = not os.path.exists(target)
- if bare:
- r = Repo.init_bare(target)
- else:
- r = Repo.init(target)
-
- reflog_message = b"clone: from " + source.encode("utf-8")
- try:
- target_config = r.get_config()
- if not isinstance(source, bytes):
- source = source.encode(DEFAULT_ENCODING)
- target_config.set((b"remote", origin), b"url", source)
- target_config.set(
- (b"remote", origin),
- b"fetch",
- b"+refs/heads/*:refs/remotes/" + origin + b"/*",
- )
- target_config.write_to_path()
- fetch_result = fetch(
- r,
- origin,
- errstream=errstream,
- message=reflog_message,
- depth=depth,
- **kwargs
+ with open_repo_closing(source) as r:
+ return r.clone(
+ target,
+ mkdir=mkdir,
+ bare=bare,
+ origin=origin,
+ checkout=checkout,
+ branch=branch,
)
- for key, target in fetch_result.symrefs.items():
- r.refs.set_symbolic_ref(key, target)
- try:
- head = r[fetch_result.refs[b"HEAD"]]
- except KeyError:
- head = None
- else:
- r[b"HEAD"] = head.id
- if checkout and not bare and head is not None:
- errstream.write(b"Checking out " + head.id + b"\n")
- r.reset_index(head.tree)
- except BaseException:
- shutil.rmtree(target)
- r.close()
- raise
-
- return r
def add(repo=".", paths=None):
"""Add files to the staging area.
Args:
repo: Repository for the files
paths: Paths to add. No value passed stages all modified files.
Returns: Tuple with set of added files and ignored files
If the repository contains ignored directories, the returned set will
contain the path to an ignored directory (with trailing slash). Individual
files within ignored directories will not be returned.
"""
ignored = set()
with open_repo_closing(repo) as r:
repo_path = Path(r.path).resolve()
ignore_manager = IgnoreFilterManager.from_repo(r)
if not paths:
paths = list(
get_untracked_paths(
str(Path(os.getcwd()).resolve()),
str(repo_path),
r.open_index(),
)
)
relpaths = []
if not isinstance(paths, list):
paths = [paths]
for p in paths:
path = Path(p)
relpath = str(path.resolve().relative_to(repo_path))
# FIXME: Support patterns
if path.is_dir():
relpath = os.path.join(relpath, "")
if ignore_manager.is_ignored(relpath):
ignored.add(relpath)
continue
relpaths.append(relpath)
r.stage(relpaths)
return (relpaths, ignored)
def _is_subdir(subdir, parentdir):
"""Check whether subdir is parentdir or a subdir of parentdir
If parentdir or subdir is a relative path, it will be disamgibuated
relative to the pwd.
"""
parentdir_abs = os.path.realpath(parentdir) + os.path.sep
subdir_abs = os.path.realpath(subdir) + os.path.sep
return subdir_abs.startswith(parentdir_abs)
# TODO: option to remove ignored files also, in line with `git clean -fdx`
def clean(repo=".", target_dir=None):
"""Remove any untracked files from the target directory recursively
Equivalent to running `git clean -fd` in target_dir.
Args:
repo: Repository where the files may be tracked
target_dir: Directory to clean - current directory if None
"""
if target_dir is None:
target_dir = os.getcwd()
with open_repo_closing(repo) as r:
if not _is_subdir(target_dir, r.path):
raise Error("target_dir must be in the repo's working dir")
config = r.get_config_stack()
require_force = config.get_boolean( # noqa: F841
(b"clean",), b"requireForce", True
)
# TODO(jelmer): if require_force is set, then make sure that -f, -i or
# -n is specified.
index = r.open_index()
ignore_manager = IgnoreFilterManager.from_repo(r)
paths_in_wd = _walk_working_dir_paths(target_dir, r.path)
# Reverse file visit order, so that files and subdirectories are
# removed before containing directory
for ap, is_dir in reversed(list(paths_in_wd)):
if is_dir:
# All subdirectories and files have been removed if untracked,
# so dir contains no tracked files iff it is empty.
is_empty = len(os.listdir(ap)) == 0
if is_empty:
os.rmdir(ap)
else:
ip = path_to_tree_path(r.path, ap)
is_tracked = ip in index
rp = os.path.relpath(ap, r.path)
is_ignored = ignore_manager.is_ignored(rp)
if not is_tracked and not is_ignored:
os.remove(ap)
def remove(repo=".", paths=None, cached=False):
"""Remove files from the staging area.
Args:
repo: Repository for the files
paths: Paths to remove
"""
with open_repo_closing(repo) as r:
index = r.open_index()
for p in paths:
full_path = os.fsencode(os.path.abspath(p))
tree_path = path_to_tree_path(r.path, p)
try:
index_sha = index[tree_path].sha
except KeyError:
raise Error("%s did not match any files" % p)
if not cached:
try:
st = os.lstat(full_path)
except OSError:
pass
else:
try:
blob = blob_from_path_and_stat(full_path, st)
except IOError:
pass
else:
try:
committed_sha = tree_lookup_path(
r.__getitem__, r[r.head()].tree, tree_path
)[1]
except KeyError:
committed_sha = None
if blob.id != index_sha and index_sha != committed_sha:
raise Error(
"file has staged content differing "
"from both the file and head: %s" % p
)
if index_sha != committed_sha:
raise Error("file has staged changes: %s" % p)
os.remove(full_path)
del index[tree_path]
index.write()
rm = remove
def commit_decode(commit, contents, default_encoding=DEFAULT_ENCODING):
if commit.encoding:
encoding = commit.encoding.decode("ascii")
else:
encoding = default_encoding
return contents.decode(encoding, "replace")
def commit_encode(commit, contents, default_encoding=DEFAULT_ENCODING):
if commit.encoding:
encoding = commit.encoding.decode("ascii")
else:
encoding = default_encoding
return contents.encode(encoding)
def print_commit(commit, decode, outstream=sys.stdout):
"""Write a human-readable commit log entry.
Args:
commit: A `Commit` object
outstream: A stream file to write to
"""
outstream.write("-" * 50 + "\n")
outstream.write("commit: " + commit.id.decode("ascii") + "\n")
if len(commit.parents) > 1:
outstream.write(
"merge: "
+ "...".join([c.decode("ascii") for c in commit.parents[1:]])
+ "\n"
)
outstream.write("Author: " + decode(commit.author) + "\n")
if commit.author != commit.committer:
outstream.write("Committer: " + decode(commit.committer) + "\n")
time_tuple = time.gmtime(commit.author_time + commit.author_timezone)
time_str = time.strftime("%a %b %d %Y %H:%M:%S", time_tuple)
timezone_str = format_timezone(commit.author_timezone).decode("ascii")
outstream.write("Date: " + time_str + " " + timezone_str + "\n")
outstream.write("\n")
outstream.write(decode(commit.message) + "\n")
outstream.write("\n")
def print_tag(tag, decode, outstream=sys.stdout):
"""Write a human-readable tag.
Args:
tag: A `Tag` object
decode: Function for decoding bytes to unicode string
outstream: A stream to write to
"""
outstream.write("Tagger: " + decode(tag.tagger) + "\n")
time_tuple = time.gmtime(tag.tag_time + tag.tag_timezone)
time_str = time.strftime("%a %b %d %Y %H:%M:%S", time_tuple)
timezone_str = format_timezone(tag.tag_timezone).decode("ascii")
outstream.write("Date: " + time_str + " " + timezone_str + "\n")
outstream.write("\n")
outstream.write(decode(tag.message))
outstream.write("\n")
def show_blob(repo, blob, decode, outstream=sys.stdout):
"""Write a blob to a stream.
Args:
repo: A `Repo` object
blob: A `Blob` object
decode: Function for decoding bytes to unicode string
outstream: A stream file to write to
"""
outstream.write(decode(blob.data))
def show_commit(repo, commit, decode, outstream=sys.stdout):
"""Show a commit to a stream.
Args:
repo: A `Repo` object
commit: A `Commit` object
decode: Function for decoding bytes to unicode string
outstream: Stream to write to
"""
print_commit(commit, decode=decode, outstream=outstream)
if commit.parents:
parent_commit = repo[commit.parents[0]]
base_tree = parent_commit.tree
else:
base_tree = None
diffstream = BytesIO()
write_tree_diff(diffstream, repo.object_store, base_tree, commit.tree)
diffstream.seek(0)
outstream.write(commit_decode(commit, diffstream.getvalue()))
def show_tree(repo, tree, decode, outstream=sys.stdout):
"""Print a tree to a stream.
Args:
repo: A `Repo` object
tree: A `Tree` object
decode: Function for decoding bytes to unicode string
outstream: Stream to write to
"""
for n in tree:
outstream.write(decode(n) + "\n")
def show_tag(repo, tag, decode, outstream=sys.stdout):
"""Print a tag to a stream.
Args:
repo: A `Repo` object
tag: A `Tag` object
decode: Function for decoding bytes to unicode string
outstream: Stream to write to
"""
print_tag(tag, decode, outstream)
show_object(repo, repo[tag.object[1]], decode, outstream)
def show_object(repo, obj, decode, outstream):
return {
b"tree": show_tree,
b"blob": show_blob,
b"commit": show_commit,
b"tag": show_tag,
}[obj.type_name](repo, obj, decode, outstream)
def print_name_status(changes):
"""Print a simple status summary, listing changed files."""
for change in changes:
if not change:
continue
if isinstance(change, list):
change = change[0]
if change.type == CHANGE_ADD:
path1 = change.new.path
path2 = ""
kind = "A"
elif change.type == CHANGE_DELETE:
path1 = change.old.path
path2 = ""
kind = "D"
elif change.type == CHANGE_MODIFY:
path1 = change.new.path
path2 = ""
kind = "M"
elif change.type in RENAME_CHANGE_TYPES:
path1 = change.old.path
path2 = change.new.path
if change.type == CHANGE_RENAME:
kind = "R"
elif change.type == CHANGE_COPY:
kind = "C"
yield "%-8s%-20s%-20s" % (kind, path1, path2)
def log(
repo=".",
paths=None,
outstream=sys.stdout,
max_entries=None,
reverse=False,
name_status=False,
):
"""Write commit logs.
Args:
repo: Path to repository
paths: Optional set of specific paths to print entries for
outstream: Stream to write log output to
reverse: Reverse order in which entries are printed
name_status: Print name status
max_entries: Optional maximum number of entries to display
"""
with open_repo_closing(repo) as r:
walker = r.get_walker(max_entries=max_entries, paths=paths, reverse=reverse)
for entry in walker:
def decode(x):
return commit_decode(entry.commit, x)
print_commit(entry.commit, decode, outstream)
if name_status:
outstream.writelines(
[line + "\n" for line in print_name_status(entry.changes())]
)
# TODO(jelmer): better default for encoding?
def show(
repo=".",
objects=None,
outstream=sys.stdout,
default_encoding=DEFAULT_ENCODING,
):
"""Print the changes in a commit.
Args:
repo: Path to repository
objects: Objects to show (defaults to [HEAD])
outstream: Stream to write to
default_encoding: Default encoding to use if none is set in the
commit
"""
if objects is None:
objects = ["HEAD"]
if not isinstance(objects, list):
objects = [objects]
with open_repo_closing(repo) as r:
for objectish in objects:
o = parse_object(r, objectish)
if isinstance(o, Commit):
def decode(x):
return commit_decode(o, x, default_encoding)
else:
def decode(x):
return x.decode(default_encoding)
show_object(r, o, decode, outstream)
def diff_tree(repo, old_tree, new_tree, outstream=sys.stdout):
"""Compares the content and mode of blobs found via two tree objects.
Args:
repo: Path to repository
old_tree: Id of old tree
new_tree: Id of new tree
outstream: Stream to write to
"""
with open_repo_closing(repo) as r:
write_tree_diff(outstream, r.object_store, old_tree, new_tree)
def rev_list(repo, commits, outstream=sys.stdout):
"""Lists commit objects in reverse chronological order.
Args:
repo: Path to repository
commits: Commits over which to iterate
outstream: Stream to write to
"""
with open_repo_closing(repo) as r:
for entry in r.get_walker(include=[r[c].id for c in commits]):
outstream.write(entry.commit.id + b"\n")
def tag(*args, **kwargs):
import warnings
warnings.warn(
"tag has been deprecated in favour of tag_create.", DeprecationWarning
)
return tag_create(*args, **kwargs)
def tag_create(
repo,
tag,
author=None,
message=None,
annotated=False,
objectish="HEAD",
tag_time=None,
tag_timezone=None,
sign=False,
):
"""Creates a tag in git via dulwich calls:
Args:
repo: Path to repository
tag: tag string
author: tag author (optional, if annotated is set)
message: tag message (optional)
annotated: whether to create an annotated tag
objectish: object the tag should point at, defaults to HEAD
tag_time: Optional time for annotated tag
tag_timezone: Optional timezone for annotated tag
sign: GPG Sign the tag (bool, defaults to False,
pass True to use default GPG key,
pass a str containing Key ID to use a specific GPG key)
"""
with open_repo_closing(repo) as r:
object = parse_object(r, objectish)
if annotated:
# Create the tag object
tag_obj = Tag()
if author is None:
# TODO(jelmer): Don't use repo private method.
author = r._get_user_identity(r.get_config_stack())
tag_obj.tagger = author
tag_obj.message = message + "\n".encode()
tag_obj.name = tag
tag_obj.object = (type(object), object.id)
if tag_time is None:
tag_time = int(time.time())
tag_obj.tag_time = tag_time
if tag_timezone is None:
# TODO(jelmer) Use current user timezone rather than UTC
tag_timezone = 0
elif isinstance(tag_timezone, str):
tag_timezone = parse_timezone(tag_timezone)
tag_obj.tag_timezone = tag_timezone
if sign:
tag_obj.sign(sign if isinstance(sign, str) else None)
r.object_store.add_object(tag_obj)
tag_id = tag_obj.id
else:
tag_id = object.id
r.refs[_make_tag_ref(tag)] = tag_id
def list_tags(*args, **kwargs):
import warnings
warnings.warn(
"list_tags has been deprecated in favour of tag_list.",
DeprecationWarning,
)
return tag_list(*args, **kwargs)
def tag_list(repo, outstream=sys.stdout):
"""List all tags.
Args:
repo: Path to repository
outstream: Stream to write tags to
"""
with open_repo_closing(repo) as r:
tags = sorted(r.refs.as_dict(b"refs/tags"))
return tags
def tag_delete(repo, name):
"""Remove a tag.
Args:
repo: Path to repository
name: Name of tag to remove
"""
with open_repo_closing(repo) as r:
if isinstance(name, bytes):
names = [name]
elif isinstance(name, list):
names = name
else:
raise Error("Unexpected tag name type %r" % name)
for name in names:
del r.refs[_make_tag_ref(name)]
def reset(repo, mode, treeish="HEAD"):
"""Reset current HEAD to the specified state.
Args:
repo: Path to repository
mode: Mode ("hard", "soft", "mixed")
treeish: Treeish to reset to
"""
if mode != "hard":
raise Error("hard is the only mode currently supported")
with open_repo_closing(repo) as r:
tree = parse_tree(r, treeish)
r.reset_index(tree.id)
def get_remote_repo(
repo: Repo, remote_location: Optional[Union[str, bytes]] = None
) -> Tuple[Optional[str], str]:
config = repo.get_config()
if remote_location is None:
remote_location = get_branch_remote(repo)
if isinstance(remote_location, str):
encoded_location = remote_location.encode()
else:
encoded_location = remote_location
section = (b"remote", encoded_location)
remote_name = None # type: Optional[str]
if config.has_section(section):
remote_name = encoded_location.decode()
url = config.get(section, "url")
encoded_location = url
else:
remote_name = None
return (remote_name, encoded_location.decode())
def push(
repo,
remote_location=None,
refspecs=None,
outstream=default_bytes_out_stream,
errstream=default_bytes_err_stream,
force=False,
**kwargs
):
"""Remote push with dulwich via dulwich.client
Args:
repo: Path to repository
remote_location: Location of the remote
refspecs: Refs to push to remote
outstream: A stream file to write output
errstream: A stream file to write errors
force: Force overwriting refs
"""
# Open the repo
with open_repo_closing(repo) as r:
if refspecs is None:
refspecs = [active_branch(r)]
(remote_name, remote_location) = get_remote_repo(r, remote_location)
# Get the client and path
client, path = get_transport_and_path(
remote_location, config=r.get_config_stack(), **kwargs
)
selected_refs = []
remote_changed_refs = {}
def update_refs(refs):
selected_refs.extend(parse_reftuples(r.refs, refs, refspecs, force=force))
new_refs = {}
# TODO: Handle selected_refs == {None: None}
for (lh, rh, force_ref) in selected_refs:
if lh is None:
new_refs[rh] = ZERO_SHA
remote_changed_refs[rh] = None
else:
try:
localsha = r.refs[lh]
except KeyError:
raise Error("No valid ref %s in local repository" % lh)
if not force_ref and rh in refs:
check_diverged(r, refs[rh], localsha)
new_refs[rh] = localsha
remote_changed_refs[rh] = localsha
return new_refs
err_encoding = getattr(errstream, "encoding", None) or DEFAULT_ENCODING
remote_location = client.get_url(path)
try:
result = client.send_pack(
path,
update_refs,
generate_pack_data=r.generate_pack_data,
progress=errstream.write,
)
except SendPackError as e:
raise Error(
"Push to " + remote_location + " failed -> " + e.args[0].decode(),
inner=e,
)
else:
errstream.write(
b"Push to " + remote_location.encode(err_encoding) + b" successful.\n"
)
for ref, error in (result.ref_status or {}).items():
if error is not None:
errstream.write(
b"Push of ref %s failed: %s\n" % (ref, error.encode(err_encoding))
)
else:
errstream.write(b"Ref %s updated\n" % ref)
if remote_name is not None:
_import_remote_refs(r.refs, remote_name, remote_changed_refs)
def pull(
repo,
remote_location=None,
refspecs=None,
outstream=default_bytes_out_stream,
errstream=default_bytes_err_stream,
fast_forward=True,
force=False,
**kwargs
):
"""Pull from remote via dulwich.client
Args:
repo: Path to repository
remote_location: Location of the remote
refspec: refspecs to fetch
outstream: A stream file to write to output
errstream: A stream file to write to errors
"""
# Open the repo
with open_repo_closing(repo) as r:
(remote_name, remote_location) = get_remote_repo(r, remote_location)
if refspecs is None:
refspecs = [b"HEAD"]
selected_refs = []
def determine_wants(remote_refs, **kwargs):
selected_refs.extend(
parse_reftuples(remote_refs, r.refs, refspecs, force=force)
)
return [
remote_refs[lh]
for (lh, rh, force_ref) in selected_refs
if remote_refs[lh] not in r.object_store
]
client, path = get_transport_and_path(
remote_location, config=r.get_config_stack(), **kwargs
)
fetch_result = client.fetch(
path, r, progress=errstream.write, determine_wants=determine_wants
)
for (lh, rh, force_ref) in selected_refs:
try:
check_diverged(r, r.refs[rh], fetch_result.refs[lh])
except DivergedBranches:
if fast_forward:
raise
else:
raise NotImplementedError("merge is not yet supported")
r.refs[rh] = fetch_result.refs[lh]
if selected_refs:
r[b"HEAD"] = fetch_result.refs[selected_refs[0][1]]
# Perform 'git checkout .' - syncs staged changes
tree = r[b"HEAD"].tree
r.reset_index(tree=tree)
if remote_name is not None:
_import_remote_refs(r.refs, remote_name, fetch_result.refs)
def status(repo=".", ignored=False):
"""Returns staged, unstaged, and untracked changes relative to the HEAD.
Args:
repo: Path to repository or repository object
ignored: Whether to include ignored files in `untracked`
Returns: GitStatus tuple,
staged - dict with lists of staged paths (diff index/HEAD)
unstaged - list of unstaged paths (diff index/working-tree)
untracked - list of untracked, un-ignored & non-.git paths
"""
with open_repo_closing(repo) as r:
# 1. Get status of staged
tracked_changes = get_tree_changes(r)
# 2. Get status of unstaged
index = r.open_index()
normalizer = r.get_blob_normalizer()
filter_callback = normalizer.checkin_normalize
unstaged_changes = list(get_unstaged_changes(index, r.path, filter_callback))
untracked_paths = get_untracked_paths(
r.path, r.path, index, exclude_ignored=not ignored
)
untracked_changes = list(untracked_paths)
return GitStatus(tracked_changes, unstaged_changes, untracked_changes)
def _walk_working_dir_paths(frompath, basepath, prune_dirnames=None):
"""Get path, is_dir for files in working dir from frompath
Args:
frompath: Path to begin walk
basepath: Path to compare to
prune_dirnames: Optional callback to prune dirnames during os.walk
dirnames will be set to result of prune_dirnames(dirpath, dirnames)
"""
for dirpath, dirnames, filenames in os.walk(frompath):
# Skip .git and below.
if ".git" in dirnames:
dirnames.remove(".git")
if dirpath != basepath:
continue
if ".git" in filenames:
filenames.remove(".git")
if dirpath != basepath:
continue
if dirpath != frompath:
yield dirpath, True
for filename in filenames:
filepath = os.path.join(dirpath, filename)
yield filepath, False
if prune_dirnames:
dirnames[:] = prune_dirnames(dirpath, dirnames)
def get_untracked_paths(frompath, basepath, index, exclude_ignored=False):
"""Get untracked paths.
Args:
frompath: Path to walk
basepath: Path to compare to
index: Index to check against
exclude_ignored: Whether to exclude ignored paths
Note: ignored directories will never be walked for performance reasons.
If exclude_ignored is False, only the path to an ignored directory will
be yielded, no files inside the directory will be returned
"""
with open_repo_closing(basepath) as r:
ignore_manager = IgnoreFilterManager.from_repo(r)
ignored_dirs = []
def prune_dirnames(dirpath, dirnames):
for i in range(len(dirnames) - 1, -1, -1):
path = os.path.join(dirpath, dirnames[i])
ip = os.path.join(os.path.relpath(path, basepath), "")
if ignore_manager.is_ignored(ip):
if not exclude_ignored:
ignored_dirs.append(
os.path.join(os.path.relpath(path, frompath), "")
)
del dirnames[i]
return dirnames
for ap, is_dir in _walk_working_dir_paths(
frompath, basepath, prune_dirnames=prune_dirnames
):
if not is_dir:
ip = path_to_tree_path(basepath, ap)
if ip not in index:
if (
not exclude_ignored
or not ignore_manager.is_ignored(
os.path.relpath(ap, basepath)
)
):
yield os.path.relpath(ap, frompath)
yield from ignored_dirs
def get_tree_changes(repo):
"""Return add/delete/modify changes to tree by comparing index to HEAD.
Args:
repo: repo path or object
Returns: dict with lists for each type of change
"""
with open_repo_closing(repo) as r:
index = r.open_index()
# Compares the Index to the HEAD & determines changes
# Iterate through the changes and report add/delete/modify
# TODO: call out to dulwich.diff_tree somehow.
tracked_changes = {
"add": [],
"delete": [],
"modify": [],
}
try:
tree_id = r[b"HEAD"].tree
except KeyError:
tree_id = None
for change in index.changes_from_tree(r.object_store, tree_id):
if not change[0][0]:
tracked_changes["add"].append(change[0][1])
elif not change[0][1]:
tracked_changes["delete"].append(change[0][0])
elif change[0][0] == change[0][1]:
tracked_changes["modify"].append(change[0][0])
else:
raise NotImplementedError("git mv ops not yet supported")
return tracked_changes
def daemon(path=".", address=None, port=None):
"""Run a daemon serving Git requests over TCP/IP.
Args:
path: Path to the directory to serve.
address: Optional address to listen on (defaults to ::)
port: Optional port to listen on (defaults to TCP_GIT_PORT)
"""
# TODO(jelmer): Support git-daemon-export-ok and --export-all.
backend = FileSystemBackend(path)
server = TCPGitServer(backend, address, port)
server.serve_forever()
def web_daemon(path=".", address=None, port=None):
"""Run a daemon serving Git requests over HTTP.
Args:
path: Path to the directory to serve
address: Optional address to listen on (defaults to ::)
port: Optional port to listen on (defaults to 80)
"""
from dulwich.web import (
make_wsgi_chain,
make_server,
WSGIRequestHandlerLogger,
WSGIServerLogger,
)
backend = FileSystemBackend(path)
app = make_wsgi_chain(backend)
server = make_server(
address,
port,
app,
handler_class=WSGIRequestHandlerLogger,
server_class=WSGIServerLogger,
)
server.serve_forever()
def upload_pack(path=".", inf=None, outf=None):
"""Upload a pack file after negotiating its contents using smart protocol.
Args:
path: Path to the repository
inf: Input stream to communicate with client
outf: Output stream to communicate with client
"""
if outf is None:
outf = getattr(sys.stdout, "buffer", sys.stdout)
if inf is None:
inf = getattr(sys.stdin, "buffer", sys.stdin)
path = os.path.expanduser(path)
backend = FileSystemBackend(path)
def send_fn(data):
outf.write(data)
outf.flush()
proto = Protocol(inf.read, send_fn)
handler = UploadPackHandler(backend, [path], proto)
# FIXME: Catch exceptions and write a single-line summary to outf.
handler.handle()
return 0
def receive_pack(path=".", inf=None, outf=None):
"""Receive a pack file after negotiating its contents using smart protocol.
Args:
path: Path to the repository
inf: Input stream to communicate with client
outf: Output stream to communicate with client
"""
if outf is None:
outf = getattr(sys.stdout, "buffer", sys.stdout)
if inf is None:
inf = getattr(sys.stdin, "buffer", sys.stdin)
path = os.path.expanduser(path)
backend = FileSystemBackend(path)
def send_fn(data):
outf.write(data)
outf.flush()
proto = Protocol(inf.read, send_fn)
handler = ReceivePackHandler(backend, [path], proto)
# FIXME: Catch exceptions and write a single-line summary to outf.
handler.handle()
return 0
def _make_branch_ref(name):
if getattr(name, "encode", None):
name = name.encode(DEFAULT_ENCODING)
return LOCAL_BRANCH_PREFIX + name
def _make_tag_ref(name):
if getattr(name, "encode", None):
name = name.encode(DEFAULT_ENCODING)
- return b"refs/tags/" + name
+ return LOCAL_TAG_PREFIX + name
def branch_delete(repo, name):
"""Delete a branch.
Args:
repo: Path to the repository
name: Name of the branch
"""
with open_repo_closing(repo) as r:
if isinstance(name, list):
names = name
else:
names = [name]
for name in names:
del r.refs[_make_branch_ref(name)]
def branch_create(repo, name, objectish=None, force=False):
"""Create a branch.
Args:
repo: Path to the repository
name: Name of the new branch
objectish: Target object to point new branch at (defaults to HEAD)
force: Force creation of branch, even if it already exists
"""
with open_repo_closing(repo) as r:
if objectish is None:
objectish = "HEAD"
object = parse_object(r, objectish)
refname = _make_branch_ref(name)
ref_message = b"branch: Created from " + objectish.encode("utf-8")
if force:
r.refs.set_if_equals(refname, None, object.id, message=ref_message)
else:
if not r.refs.add_if_new(refname, object.id, message=ref_message):
raise Error("Branch with name %s already exists." % name)
def branch_list(repo):
"""List all branches.
Args:
repo: Path to the repository
"""
with open_repo_closing(repo) as r:
return r.refs.keys(base=LOCAL_BRANCH_PREFIX)
def active_branch(repo):
"""Return the active branch in the repository, if any.
Args:
repo: Repository to open
Returns:
branch name
Raises:
KeyError: if the repository does not have a working tree
IndexError: if HEAD is floating
"""
with open_repo_closing(repo) as r:
active_ref = r.refs.follow(b"HEAD")[0][1]
if not active_ref.startswith(LOCAL_BRANCH_PREFIX):
raise ValueError(active_ref)
return active_ref[len(LOCAL_BRANCH_PREFIX) :]
def get_branch_remote(repo):
"""Return the active branch's remote name, if any.
Args:
repo: Repository to open
Returns:
remote name
Raises:
KeyError: if the repository does not have a working tree
"""
with open_repo_closing(repo) as r:
branch_name = active_branch(r.path)
config = r.get_config()
try:
remote_name = config.get((b"branch", branch_name), b"remote")
except KeyError:
remote_name = b"origin"
return remote_name
def _import_remote_refs(
refs_container: RefsContainer,
remote_name: str,
refs: Dict[str, str],
message: Optional[bytes] = None,
prune: bool = False,
prune_tags: bool = False,
):
stripped_refs = strip_peeled_refs(refs)
branches = {
n[len(LOCAL_BRANCH_PREFIX) :]: v
for (n, v) in stripped_refs.items()
if n.startswith(LOCAL_BRANCH_PREFIX)
}
refs_container.import_refs(
b"refs/remotes/" + remote_name.encode(),
branches,
message=message,
prune=prune,
)
tags = {
n[len(b"refs/tags/") :]: v
for (n, v) in stripped_refs.items()
if n.startswith(b"refs/tags/") and not n.endswith(ANNOTATED_TAG_SUFFIX)
}
refs_container.import_refs(b"refs/tags", tags, message=message, prune=prune_tags)
def fetch(
repo,
remote_location=None,
outstream=sys.stdout,
errstream=default_bytes_err_stream,
message=None,
depth=None,
prune=False,
prune_tags=False,
force=False,
**kwargs
):
"""Fetch objects from a remote server.
Args:
repo: Path to the repository
remote_location: String identifying a remote server
outstream: Output stream (defaults to stdout)
errstream: Error stream (defaults to stderr)
message: Reflog message (defaults to b"fetch: from <remote_name>")
depth: Depth to fetch at
prune: Prune remote removed refs
prune_tags: Prune reomte removed tags
Returns:
Dictionary with refs on the remote
"""
with open_repo_closing(repo) as r:
(remote_name, remote_location) = get_remote_repo(r, remote_location)
if message is None:
message = b"fetch: from " + remote_location.encode("utf-8")
client, path = get_transport_and_path(
remote_location, config=r.get_config_stack(), **kwargs
)
fetch_result = client.fetch(path, r, progress=errstream.write, depth=depth)
if remote_name is not None:
_import_remote_refs(
r.refs,
remote_name,
fetch_result.refs,
message,
prune=prune,
prune_tags=prune_tags,
)
return fetch_result
def ls_remote(remote, config=None, **kwargs):
"""List the refs in a remote.
Args:
remote: Remote repository location
config: Configuration to use
Returns:
Dictionary with remote refs
"""
if config is None:
config = StackedConfig.default()
client, host_path = get_transport_and_path(remote, config=config, **kwargs)
return client.get_refs(host_path)
def repack(repo):
"""Repack loose files in a repository.
Currently this only packs loose objects.
Args:
repo: Path to the repository
"""
with open_repo_closing(repo) as r:
r.object_store.pack_loose_objects()
def pack_objects(repo, object_ids, packf, idxf, delta_window_size=None):
"""Pack objects into a file.
Args:
repo: Path to the repository
object_ids: List of object ids to write
packf: File-like object to write to
idxf: File-like object to write to (can be None)
"""
with open_repo_closing(repo) as r:
entries, data_sum = write_pack_objects(
packf,
r.object_store.iter_shas((oid, None) for oid in object_ids),
delta_window_size=delta_window_size,
)
if idxf is not None:
entries = sorted([(k, v[0], v[1]) for (k, v) in entries.items()])
write_pack_index(idxf, entries, data_sum)
def ls_tree(
repo,
treeish=b"HEAD",
outstream=sys.stdout,
recursive=False,
name_only=False,
):
"""List contents of a tree.
Args:
repo: Path to the repository
tree_ish: Tree id to list
outstream: Output stream (defaults to stdout)
recursive: Whether to recursively list files
name_only: Only print item name
"""
def list_tree(store, treeid, base):
for (name, mode, sha) in store[treeid].iteritems():
if base:
name = posixpath.join(base, name)
if name_only:
outstream.write(name + b"\n")
else:
outstream.write(pretty_format_tree_entry(name, mode, sha))
if stat.S_ISDIR(mode) and recursive:
list_tree(store, sha, name)
with open_repo_closing(repo) as r:
tree = parse_tree(r, treeish)
list_tree(r.object_store, tree.id, "")
def remote_add(repo, name, url):
"""Add a remote.
Args:
repo: Path to the repository
name: Remote name
url: Remote URL
"""
if not isinstance(name, bytes):
name = name.encode(DEFAULT_ENCODING)
if not isinstance(url, bytes):
url = url.encode(DEFAULT_ENCODING)
with open_repo_closing(repo) as r:
c = r.get_config()
section = (b"remote", name)
if c.has_section(section):
raise RemoteExists(section)
c.set(section, b"url", url)
c.write_to_path()
def check_ignore(repo, paths, no_index=False):
"""Debug gitignore files.
Args:
repo: Path to the repository
paths: List of paths to check for
no_index: Don't check index
Returns: List of ignored files
"""
with open_repo_closing(repo) as r:
index = r.open_index()
ignore_manager = IgnoreFilterManager.from_repo(r)
for path in paths:
if not no_index and path_to_tree_path(r.path, path) in index:
continue
if os.path.isabs(path):
path = os.path.relpath(path, r.path)
if ignore_manager.is_ignored(path):
yield path
def update_head(repo, target, detached=False, new_branch=None):
"""Update HEAD to point at a new branch/commit.
Note that this does not actually update the working tree.
Args:
repo: Path to the repository
detach: Create a detached head
target: Branch or committish to switch to
new_branch: New branch to create
"""
with open_repo_closing(repo) as r:
if new_branch is not None:
to_set = _make_branch_ref(new_branch)
else:
to_set = b"HEAD"
if detached:
# TODO(jelmer): Provide some way so that the actual ref gets
# updated rather than what it points to, so the delete isn't
# necessary.
del r.refs[to_set]
r.refs[to_set] = parse_commit(r, target).id
else:
r.refs.set_symbolic_ref(to_set, parse_ref(r, target))
if new_branch is not None:
r.refs.set_symbolic_ref(b"HEAD", to_set)
def reset_file(repo, file_path: str, target: bytes = b'HEAD'):
"""Reset the file to specific commit or branch.
Args:
repo: dulwich Repo object
file_path: file to reset, relative to the repository path
target: branch or commit or b'HEAD' to reset
"""
tree = parse_tree(repo, treeish=target)
file_path = _fs_to_tree_path(file_path)
file_entry = tree.lookup_path(repo.object_store.__getitem__, file_path)
full_path = os.path.join(repo.path.encode(), file_path)
blob = repo.object_store[file_entry[1]]
mode = file_entry[0]
build_file_from_blob(blob, mode, full_path)
def check_mailmap(repo, contact):
"""Check canonical name and email of contact.
Args:
repo: Path to the repository
contact: Contact name and/or email
Returns: Canonical contact data
"""
with open_repo_closing(repo) as r:
from dulwich.mailmap import Mailmap
try:
mailmap = Mailmap.from_path(os.path.join(r.path, ".mailmap"))
except FileNotFoundError:
mailmap = Mailmap()
return mailmap.lookup(contact)
def fsck(repo):
"""Check a repository.
Args:
repo: A path to the repository
Returns: Iterator over errors/warnings
"""
with open_repo_closing(repo) as r:
# TODO(jelmer): check pack files
# TODO(jelmer): check graph
# TODO(jelmer): check refs
for sha in r.object_store:
o = r.object_store[sha]
try:
o.check()
except Exception as e:
yield (sha, e)
def stash_list(repo):
"""List all stashes in a repository."""
with open_repo_closing(repo) as r:
from dulwich.stash import Stash
stash = Stash.from_repo(r)
return enumerate(list(stash.stashes()))
def stash_push(repo):
"""Push a new stash onto the stack."""
with open_repo_closing(repo) as r:
from dulwich.stash import Stash
stash = Stash.from_repo(r)
stash.push()
def stash_pop(repo, index):
"""Pop a stash from the stack."""
with open_repo_closing(repo) as r:
from dulwich.stash import Stash
stash = Stash.from_repo(r)
stash.pop(index)
def stash_drop(repo, index):
"""Drop a stash from the stack."""
with open_repo_closing(repo) as r:
from dulwich.stash import Stash
stash = Stash.from_repo(r)
stash.drop(index)
def ls_files(repo):
"""List all files in an index."""
with open_repo_closing(repo) as r:
return sorted(r.open_index())
def describe(repo):
"""Describe the repository version.
Args:
projdir: git repository root
Returns: a string description of the current git revision
Examples: "gabcdefh", "v0.1" or "v0.1-5-gabcdefh".
"""
# Get the repository
with open_repo_closing(repo) as r:
# Get a list of all tags
refs = r.get_refs()
tags = {}
for key, value in refs.items():
key = key.decode()
obj = r.get_object(value)
if u"tags" not in key:
continue
_, tag = key.rsplit(u"/", 1)
try:
commit = obj.object
except AttributeError:
continue
else:
commit = r.get_object(commit[1])
tags[tag] = [
datetime.datetime(*time.gmtime(commit.commit_time)[:6]),
commit.id.decode("ascii"),
]
sorted_tags = sorted(tags.items(), key=lambda tag: tag[1][0], reverse=True)
# If there are no tags, return the current commit
if len(sorted_tags) == 0:
return "g{}".format(r[r.head()].id.decode("ascii")[:7])
# We're now 0 commits from the top
commit_count = 0
# Get the latest commit
latest_commit = r[r.head()]
# Walk through all commits
walker = r.get_walker()
for entry in walker:
# Check if tag
commit_id = entry.commit.id.decode("ascii")
for tag in sorted_tags:
tag_name = tag[0]
tag_commit = tag[1][1]
if commit_id == tag_commit:
if commit_count == 0:
return tag_name
else:
return "{}-{}-g{}".format(
tag_name,
commit_count,
latest_commit.id.decode("ascii")[:7],
)
commit_count += 1
# Return plain commit if no parent tag can be found
return "g{}".format(latest_commit.id.decode("ascii")[:7])
def get_object_by_path(repo, path, committish=None):
"""Get an object by path.
Args:
repo: A path to the repository
path: Path to look up
committish: Commit to look up path in
Returns: A `ShaFile` object
"""
if committish is None:
committish = "HEAD"
# Get the repository
with open_repo_closing(repo) as r:
commit = parse_commit(r, committish)
base_tree = commit.tree
if not isinstance(path, bytes):
path = commit_encode(commit, path)
(mode, sha) = tree_lookup_path(r.object_store.__getitem__, base_tree, path)
return r[sha]
def write_tree(repo):
"""Write a tree object from the index.
Args:
repo: Repository for which to write tree
Returns: tree id for the tree that was written
"""
with open_repo_closing(repo) as r:
return r.open_index().commit(r.object_store)
diff --git a/dulwich/refs.py b/dulwich/refs.py
index bda6bdc5..9d022f44 100644
--- a/dulwich/refs.py
+++ b/dulwich/refs.py
@@ -1,1205 +1,1271 @@
# refs.py -- For dealing with git refs
# 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.
#
"""Ref handling.
"""
import os
from dulwich.errors import (
PackedRefsException,
RefFormatError,
)
from dulwich.objects import (
git_line,
valid_hexsha,
ZERO_SHA,
+ Tag,
)
from dulwich.file import (
GitFile,
ensure_dir_exists,
)
SYMREF = b"ref: "
LOCAL_BRANCH_PREFIX = b"refs/heads/"
LOCAL_TAG_PREFIX = b"refs/tags/"
BAD_REF_CHARS = set(b"\177 ~^:?*[")
ANNOTATED_TAG_SUFFIX = b"^{}"
def parse_symref_value(contents):
"""Parse a symref value.
Args:
contents: Contents to parse
Returns: Destination
"""
if contents.startswith(SYMREF):
return contents[len(SYMREF) :].rstrip(b"\r\n")
raise ValueError(contents)
def check_ref_format(refname):
"""Check if a refname is correctly formatted.
Implements all the same rules as git-check-ref-format[1].
[1]
http://www.kernel.org/pub/software/scm/git/docs/git-check-ref-format.html
Args:
refname: The refname to check
Returns: True if refname is valid, False otherwise
"""
# These could be combined into one big expression, but are listed
# separately to parallel [1].
if b"/." in refname or refname.startswith(b"."):
return False
if b"/" not in refname:
return False
if b".." in refname:
return False
for i, c in enumerate(refname):
if ord(refname[i : i + 1]) < 0o40 or c in BAD_REF_CHARS:
return False
if refname[-1] in b"/.":
return False
if refname.endswith(b".lock"):
return False
if b"@{" in refname:
return False
if b"\\" in refname:
return False
return True
class RefsContainer(object):
"""A container for refs."""
def __init__(self, logger=None):
self._logger = logger
def _log(
self,
ref,
old_sha,
new_sha,
committer=None,
timestamp=None,
timezone=None,
message=None,
):
if self._logger is None:
return
if message is None:
return
self._logger(ref, old_sha, new_sha, committer, timestamp, timezone, message)
def set_symbolic_ref(
self,
name,
other,
committer=None,
timestamp=None,
timezone=None,
message=None,
):
"""Make a ref point at another ref.
Args:
name: Name of the ref to set
other: Name of the ref to point at
message: Optional message
"""
raise NotImplementedError(self.set_symbolic_ref)
def get_packed_refs(self):
"""Get contents of the packed-refs file.
Returns: Dictionary mapping ref names to SHA1s
Note: Will return an empty dictionary when no packed-refs file is
present.
"""
raise NotImplementedError(self.get_packed_refs)
def get_peeled(self, name):
"""Return the cached peeled value of a ref, if available.
Args:
name: Name of the ref to peel
Returns: The peeled value of the ref. If the ref is known not point to
a tag, this will be the SHA the ref refers to. If the ref may point
to a tag, but no cached information is available, None is returned.
"""
return None
def import_refs(
self,
base,
other,
committer=None,
timestamp=None,
timezone=None,
message=None,
prune=False,
):
if prune:
to_delete = set(self.subkeys(base))
else:
to_delete = set()
for name, value in other.items():
if value is None:
to_delete.add(name)
else:
self.set_if_equals(
b"/".join((base, name)), None, value, message=message
)
if to_delete:
try:
to_delete.remove(name)
except KeyError:
pass
for ref in to_delete:
self.remove_if_equals(b"/".join((base, ref)), None, message=message)
def allkeys(self):
"""All refs present in this container."""
raise NotImplementedError(self.allkeys)
def __iter__(self):
return iter(self.allkeys())
def keys(self, base=None):
"""Refs present in this container.
Args:
base: An optional base to return refs under.
Returns: An unsorted set of valid refs in this container, including
packed refs.
"""
if base is not None:
return self.subkeys(base)
else:
return self.allkeys()
def subkeys(self, base):
"""Refs present in this container under a base.
Args:
base: The base to return refs under.
Returns: A set of valid refs in this container under the base; the base
prefix is stripped from the ref names returned.
"""
keys = set()
base_len = len(base) + 1
for refname in self.allkeys():
if refname.startswith(base):
keys.add(refname[base_len:])
return keys
def as_dict(self, base=None):
"""Return the contents of this container as a dictionary."""
ret = {}
keys = self.keys(base)
if base is None:
base = b""
else:
base = base.rstrip(b"/")
for key in keys:
try:
ret[key] = self[(base + b"/" + key).strip(b"/")]
except KeyError:
continue # Unable to resolve
return ret
def _check_refname(self, name):
"""Ensure a refname is valid and lives in refs or is HEAD.
HEAD is not a valid refname according to git-check-ref-format, but this
class needs to be able to touch HEAD. Also, check_ref_format expects
refnames without the leading 'refs/', but this class requires that
so it cannot touch anything outside the refs dir (or HEAD).
Args:
name: The name of the reference.
Raises:
KeyError: if a refname is not HEAD or is otherwise not valid.
"""
if name in (b"HEAD", b"refs/stash"):
return
if not name.startswith(b"refs/") or not check_ref_format(name[5:]):
raise RefFormatError(name)
def read_ref(self, refname):
"""Read a reference without following any references.
Args:
refname: The name of the reference
Returns: The contents of the ref file, or None if it does
not exist.
"""
contents = self.read_loose_ref(refname)
if not contents:
contents = self.get_packed_refs().get(refname, None)
return contents
def read_loose_ref(self, name):
"""Read a loose reference and return its contents.
Args:
name: the refname to read
Returns: The contents of the ref file, or None if it does
not exist.
"""
raise NotImplementedError(self.read_loose_ref)
def follow(self, name):
"""Follow a reference name.
Returns: a tuple of (refnames, sha), wheres refnames are the names of
references in the chain
"""
contents = SYMREF + name
depth = 0
refnames = []
while contents.startswith(SYMREF):
refname = contents[len(SYMREF) :]
refnames.append(refname)
contents = self.read_ref(refname)
if not contents:
break
depth += 1
if depth > 5:
raise KeyError(name)
return refnames, contents
def _follow(self, name):
import warnings
warnings.warn(
"RefsContainer._follow is deprecated. Use RefsContainer.follow " "instead.",
DeprecationWarning,
)
refnames, contents = self.follow(name)
if not refnames:
return (None, contents)
return (refnames[-1], contents)
def __contains__(self, refname):
if self.read_ref(refname):
return True
return False
def __getitem__(self, name):
"""Get the SHA1 for a reference name.
This method follows all symbolic references.
"""
_, sha = self.follow(name)
if sha is None:
raise KeyError(name)
return sha
def set_if_equals(
self,
name,
old_ref,
new_ref,
committer=None,
timestamp=None,
timezone=None,
message=None,
):
"""Set a refname to new_ref only if it currently equals old_ref.
This method follows all symbolic references if applicable for the
subclass, and can be used to perform an atomic compare-and-swap
operation.
Args:
name: The refname to set.
old_ref: The old sha the refname must refer to, or None to set
unconditionally.
new_ref: The new sha the refname will refer to.
message: Message for reflog
Returns: True if the set was successful, False otherwise.
"""
raise NotImplementedError(self.set_if_equals)
def add_if_new(self, name, ref):
"""Add a new reference only if it does not already exist.
Args:
name: Ref name
ref: Ref value
message: Message for reflog
"""
raise NotImplementedError(self.add_if_new)
def __setitem__(self, name, ref):
"""Set a reference name to point to the given SHA1.
This method follows all symbolic references if applicable for the
subclass.
Note: This method unconditionally overwrites the contents of a
reference. To update atomically only if the reference has not
changed, use set_if_equals().
Args:
name: The refname to set.
ref: The new sha the refname will refer to.
"""
self.set_if_equals(name, None, ref)
def remove_if_equals(
self,
name,
old_ref,
committer=None,
timestamp=None,
timezone=None,
message=None,
):
"""Remove a refname only if it currently equals old_ref.
This method does not follow symbolic references, even if applicable for
the subclass. It can be used to perform an atomic compare-and-delete
operation.
Args:
name: The refname to delete.
old_ref: The old sha the refname must refer to, or None to
delete unconditionally.
message: Message for reflog
Returns: True if the delete was successful, False otherwise.
"""
raise NotImplementedError(self.remove_if_equals)
def __delitem__(self, name):
"""Remove a refname.
This method does not follow symbolic references, even if applicable for
the subclass.
Note: This method unconditionally deletes the contents of a reference.
To delete atomically only if the reference has not changed, use
remove_if_equals().
Args:
name: The refname to delete.
"""
self.remove_if_equals(name, None)
def get_symrefs(self):
"""Get a dict with all symrefs in this container.
Returns: Dictionary mapping source ref to target ref
"""
ret = {}
for src in self.allkeys():
try:
dst = parse_symref_value(self.read_ref(src))
except ValueError:
pass
else:
ret[src] = dst
return ret
def watch(self):
"""Watch for changes to the refs in this container.
Returns a context manager that yields tuples with (refname, new_sha)
"""
raise NotImplementedError(self.watch)
class _DictRefsWatcher(object):
def __init__(self, refs):
self._refs = refs
def __enter__(self):
from queue import Queue
self.queue = Queue()
self._refs._watchers.add(self)
return self
def __next__(self):
return self.queue.get()
def _notify(self, entry):
self.queue.put_nowait(entry)
def __exit__(self, exc_type, exc_val, exc_tb):
self._refs._watchers.remove(self)
return False
class DictRefsContainer(RefsContainer):
"""RefsContainer backed by a simple dict.
This container does not support symbolic or packed references and is not
threadsafe.
"""
def __init__(self, refs, logger=None):
super(DictRefsContainer, self).__init__(logger=logger)
self._refs = refs
self._peeled = {}
self._watchers = set()
def allkeys(self):
return self._refs.keys()
def read_loose_ref(self, name):
return self._refs.get(name, None)
def get_packed_refs(self):
return {}
def _notify(self, ref, newsha):
for watcher in self._watchers:
watcher._notify((ref, newsha))
def watch(self):
return _DictRefsWatcher(self)
def set_symbolic_ref(
self,
name,
other,
committer=None,
timestamp=None,
timezone=None,
message=None,
):
old = self.follow(name)[-1]
new = SYMREF + other
self._refs[name] = new
self._notify(name, new)
self._log(
name,
old,
new,
committer=committer,
timestamp=timestamp,
timezone=timezone,
message=message,
)
def set_if_equals(
self,
name,
old_ref,
new_ref,
committer=None,
timestamp=None,
timezone=None,
message=None,
):
if old_ref is not None and self._refs.get(name, ZERO_SHA) != old_ref:
return False
realnames, _ = self.follow(name)
for realname in realnames:
self._check_refname(realname)
old = self._refs.get(realname)
self._refs[realname] = new_ref
self._notify(realname, new_ref)
self._log(
realname,
old,
new_ref,
committer=committer,
timestamp=timestamp,
timezone=timezone,
message=message,
)
return True
def add_if_new(
self,
name,
ref,
committer=None,
timestamp=None,
timezone=None,
message=None,
):
if name in self._refs:
return False
self._refs[name] = ref
self._notify(name, ref)
self._log(
name,
None,
ref,
committer=committer,
timestamp=timestamp,
timezone=timezone,
message=message,
)
return True
def remove_if_equals(
self,
name,
old_ref,
committer=None,
timestamp=None,
timezone=None,
message=None,
):
if old_ref is not None and self._refs.get(name, ZERO_SHA) != old_ref:
return False
try:
old = self._refs.pop(name)
except KeyError:
pass
else:
self._notify(name, None)
self._log(
name,
old,
None,
committer=committer,
timestamp=timestamp,
timezone=timezone,
message=message,
)
return True
def get_peeled(self, name):
return self._peeled.get(name)
def _update(self, refs):
"""Update multiple refs; intended only for testing."""
# TODO(dborowitz): replace this with a public function that uses
# set_if_equal.
for ref, sha in refs.items():
self.set_if_equals(ref, None, sha)
def _update_peeled(self, peeled):
"""Update cached peeled refs; intended only for testing."""
self._peeled.update(peeled)
class InfoRefsContainer(RefsContainer):
"""Refs container that reads refs from a info/refs file."""
def __init__(self, f):
self._refs = {}
self._peeled = {}
for line in f.readlines():
sha, name = line.rstrip(b"\n").split(b"\t")
if name.endswith(ANNOTATED_TAG_SUFFIX):
name = name[:-3]
if not check_ref_format(name):
raise ValueError("invalid ref name %r" % name)
self._peeled[name] = sha
else:
if not check_ref_format(name):
raise ValueError("invalid ref name %r" % name)
self._refs[name] = sha
def allkeys(self):
return self._refs.keys()
def read_loose_ref(self, name):
return self._refs.get(name, None)
def get_packed_refs(self):
return {}
def get_peeled(self, name):
try:
return self._peeled[name]
except KeyError:
return self._refs[name]
class _InotifyRefsWatcher(object):
def __init__(self, path):
import pyinotify
from queue import Queue
self.path = os.fsdecode(path)
self.manager = pyinotify.WatchManager()
self.manager.add_watch(
self.path,
pyinotify.IN_DELETE | pyinotify.IN_CLOSE_WRITE | pyinotify.IN_MOVED_TO,
rec=True,
auto_add=True,
)
self.notifier = pyinotify.ThreadedNotifier(
self.manager, default_proc_fun=self._notify
)
self.queue = Queue()
def _notify(self, event):
if event.dir:
return
if event.pathname.endswith(".lock"):
return
ref = os.fsencode(os.path.relpath(event.pathname, self.path))
if event.maskname == "IN_DELETE":
self.queue.put_nowait((ref, None))
elif event.maskname in ("IN_CLOSE_WRITE", "IN_MOVED_TO"):
with open(event.pathname, "rb") as f:
sha = f.readline().rstrip(b"\n\r")
self.queue.put_nowait((ref, sha))
def __next__(self):
return self.queue.get()
def __enter__(self):
self.notifier.start()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.notifier.stop()
return False
class DiskRefsContainer(RefsContainer):
"""Refs container that reads refs from disk."""
def __init__(self, path, worktree_path=None, logger=None):
super(DiskRefsContainer, self).__init__(logger=logger)
if getattr(path, "encode", None) is not None:
path = os.fsencode(path)
self.path = path
if worktree_path is None:
worktree_path = path
if getattr(worktree_path, "encode", None) is not None:
worktree_path = os.fsencode(worktree_path)
self.worktree_path = worktree_path
self._packed_refs = None
self._peeled_refs = None
def __repr__(self):
return "%s(%r)" % (self.__class__.__name__, self.path)
def subkeys(self, base):
subkeys = set()
path = self.refpath(base)
for root, unused_dirs, files in os.walk(path):
dir = root[len(path) :]
if os.path.sep != "/":
dir = dir.replace(os.fsencode(os.path.sep), b"/")
dir = dir.strip(b"/")
for filename in files:
refname = b"/".join(([dir] if dir else []) + [filename])
# check_ref_format requires at least one /, so we prepend the
# base before calling it.
if check_ref_format(base + b"/" + refname):
subkeys.add(refname)
for key in self.get_packed_refs():
if key.startswith(base):
subkeys.add(key[len(base) :].strip(b"/"))
return subkeys
def allkeys(self):
allkeys = set()
if os.path.exists(self.refpath(b"HEAD")):
allkeys.add(b"HEAD")
path = self.refpath(b"")
refspath = self.refpath(b"refs")
for root, unused_dirs, files in os.walk(refspath):
dir = root[len(path) :]
if os.path.sep != "/":
dir = dir.replace(os.fsencode(os.path.sep), b"/")
for filename in files:
refname = b"/".join([dir, filename])
if check_ref_format(refname):
allkeys.add(refname)
allkeys.update(self.get_packed_refs())
return allkeys
def refpath(self, name):
"""Return the disk path of a ref."""
if os.path.sep != "/":
name = name.replace(b"/", os.fsencode(os.path.sep))
# TODO: as the 'HEAD' reference is working tree specific, it
# should actually not be a part of RefsContainer
if name == b"HEAD":
return os.path.join(self.worktree_path, name)
else:
return os.path.join(self.path, name)
def get_packed_refs(self):
"""Get contents of the packed-refs file.
Returns: Dictionary mapping ref names to SHA1s
Note: Will return an empty dictionary when no packed-refs file is
present.
"""
# TODO: invalidate the cache on repacking
if self._packed_refs is None:
# set both to empty because we want _peeled_refs to be
# None if and only if _packed_refs is also None.
self._packed_refs = {}
self._peeled_refs = {}
path = os.path.join(self.path, b"packed-refs")
try:
f = GitFile(path, "rb")
except FileNotFoundError:
return {}
with f:
first_line = next(iter(f)).rstrip()
if first_line.startswith(b"# pack-refs") and b" peeled" in first_line:
for sha, name, peeled in read_packed_refs_with_peeled(f):
self._packed_refs[name] = sha
if peeled:
self._peeled_refs[name] = peeled
else:
f.seek(0)
for sha, name in read_packed_refs(f):
self._packed_refs[name] = sha
return self._packed_refs
def get_peeled(self, name):
"""Return the cached peeled value of a ref, if available.
Args:
name: Name of the ref to peel
Returns: The peeled value of the ref. If the ref is known not point to
a tag, this will be the SHA the ref refers to. If the ref may point
to a tag, but no cached information is available, None is returned.
"""
self.get_packed_refs()
if self._peeled_refs is None or name not in self._packed_refs:
# No cache: no peeled refs were read, or this ref is loose
return None
if name in self._peeled_refs:
return self._peeled_refs[name]
else:
# Known not peelable
return self[name]
def read_loose_ref(self, name):
"""Read a reference file and return its contents.
If the reference file a symbolic reference, only read the first line of
the file. Otherwise, only read the first 40 bytes.
Args:
name: the refname to read, relative to refpath
Returns: The contents of the ref file, or None if the file does not
exist.
Raises:
IOError: if any other error occurs
"""
filename = self.refpath(name)
try:
with GitFile(filename, "rb") as f:
header = f.read(len(SYMREF))
if header == SYMREF:
# Read only the first line
return header + next(iter(f)).rstrip(b"\r\n")
else:
# Read only the first 40 bytes
return header + f.read(40 - len(SYMREF))
except (FileNotFoundError, IsADirectoryError, NotADirectoryError):
return None
def _remove_packed_ref(self, name):
if self._packed_refs is None:
return
filename = os.path.join(self.path, b"packed-refs")
# reread cached refs from disk, while holding the lock
f = GitFile(filename, "wb")
try:
self._packed_refs = None
self.get_packed_refs()
if name not in self._packed_refs:
return
del self._packed_refs[name]
if name in self._peeled_refs:
del self._peeled_refs[name]
write_packed_refs(f, self._packed_refs, self._peeled_refs)
f.close()
finally:
f.abort()
def set_symbolic_ref(
self,
name,
other,
committer=None,
timestamp=None,
timezone=None,
message=None,
):
"""Make a ref point at another ref.
Args:
name: Name of the ref to set
other: Name of the ref to point at
message: Optional message to describe the change
"""
self._check_refname(name)
self._check_refname(other)
filename = self.refpath(name)
f = GitFile(filename, "wb")
try:
f.write(SYMREF + other + b"\n")
sha = self.follow(name)[-1]
self._log(
name,
sha,
sha,
committer=committer,
timestamp=timestamp,
timezone=timezone,
message=message,
)
except BaseException:
f.abort()
raise
else:
f.close()
def set_if_equals(
self,
name,
old_ref,
new_ref,
committer=None,
timestamp=None,
timezone=None,
message=None,
):
"""Set a refname to new_ref only if it currently equals old_ref.
This method follows all symbolic references, and can be used to perform
an atomic compare-and-swap operation.
Args:
name: The refname to set.
old_ref: The old sha the refname must refer to, or None to set
unconditionally.
new_ref: The new sha the refname will refer to.
message: Set message for reflog
Returns: True if the set was successful, False otherwise.
"""
self._check_refname(name)
try:
realnames, _ = self.follow(name)
realname = realnames[-1]
except (KeyError, IndexError):
realname = name
filename = self.refpath(realname)
# make sure none of the ancestor folders is in packed refs
probe_ref = os.path.dirname(realname)
packed_refs = self.get_packed_refs()
while probe_ref:
if packed_refs.get(probe_ref, None) is not None:
raise NotADirectoryError(filename)
probe_ref = os.path.dirname(probe_ref)
ensure_dir_exists(os.path.dirname(filename))
with GitFile(filename, "wb") as f:
if old_ref is not None:
try:
# read again while holding the lock
orig_ref = self.read_loose_ref(realname)
if orig_ref is None:
orig_ref = self.get_packed_refs().get(realname, ZERO_SHA)
if orig_ref != old_ref:
f.abort()
return False
except (OSError, IOError):
f.abort()
raise
try:
f.write(new_ref + b"\n")
except (OSError, IOError):
f.abort()
raise
self._log(
realname,
old_ref,
new_ref,
committer=committer,
timestamp=timestamp,
timezone=timezone,
message=message,
)
return True
def add_if_new(
self,
name,
ref,
committer=None,
timestamp=None,
timezone=None,
message=None,
):
"""Add a new reference only if it does not already exist.
This method follows symrefs, and only ensures that the last ref in the
chain does not exist.
Args:
name: The refname to set.
ref: The new sha the refname will refer to.
message: Optional message for reflog
Returns: True if the add was successful, False otherwise.
"""
try:
realnames, contents = self.follow(name)
if contents is not None:
return False
realname = realnames[-1]
except (KeyError, IndexError):
realname = name
self._check_refname(realname)
filename = self.refpath(realname)
ensure_dir_exists(os.path.dirname(filename))
with GitFile(filename, "wb") as f:
if os.path.exists(filename) or name in self.get_packed_refs():
f.abort()
return False
try:
f.write(ref + b"\n")
except (OSError, IOError):
f.abort()
raise
else:
self._log(
name,
None,
ref,
committer=committer,
timestamp=timestamp,
timezone=timezone,
message=message,
)
return True
def remove_if_equals(
self,
name,
old_ref,
committer=None,
timestamp=None,
timezone=None,
message=None,
):
"""Remove a refname only if it currently equals old_ref.
This method does not follow symbolic references. It can be used to
perform an atomic compare-and-delete operation.
Args:
name: The refname to delete.
old_ref: The old sha the refname must refer to, or None to
delete unconditionally.
message: Optional message
Returns: True if the delete was successful, False otherwise.
"""
self._check_refname(name)
filename = self.refpath(name)
ensure_dir_exists(os.path.dirname(filename))
f = GitFile(filename, "wb")
try:
if old_ref is not None:
orig_ref = self.read_loose_ref(name)
if orig_ref is None:
orig_ref = self.get_packed_refs().get(name, ZERO_SHA)
if orig_ref != old_ref:
return False
# remove the reference file itself
try:
os.remove(filename)
except FileNotFoundError:
pass # may only be packed
self._remove_packed_ref(name)
self._log(
name,
old_ref,
None,
committer=committer,
timestamp=timestamp,
timezone=timezone,
message=message,
)
finally:
# never write, we just wanted the lock
f.abort()
# outside of the lock, clean-up any parent directory that might now
# be empty. this ensures that re-creating a reference of the same
# name of what was previously a directory works as expected
parent = name
while True:
try:
parent, _ = parent.rsplit(b"/", 1)
except ValueError:
break
if parent == b'refs':
break
parent_filename = self.refpath(parent)
try:
os.rmdir(parent_filename)
except OSError:
# this can be caused by the parent directory being
# removed by another process, being not empty, etc.
# in any case, this is non fatal because we already
# removed the reference, just ignore it
break
return True
def watch(self):
import pyinotify # noqa: F401
return _InotifyRefsWatcher(self.path)
def _split_ref_line(line):
"""Split a single ref line into a tuple of SHA1 and name."""
fields = line.rstrip(b"\n\r").split(b" ")
if len(fields) != 2:
raise PackedRefsException("invalid ref line %r" % line)
sha, name = fields
if not valid_hexsha(sha):
raise PackedRefsException("Invalid hex sha %r" % sha)
if not check_ref_format(name):
raise PackedRefsException("invalid ref name %r" % name)
return (sha, name)
def read_packed_refs(f):
"""Read a packed refs file.
Args:
f: file-like object to read from
Returns: Iterator over tuples with SHA1s and ref names.
"""
for line in f:
if line.startswith(b"#"):
# Comment
continue
if line.startswith(b"^"):
raise PackedRefsException("found peeled ref in packed-refs without peeled")
yield _split_ref_line(line)
def read_packed_refs_with_peeled(f):
"""Read a packed refs file including peeled refs.
Assumes the "# pack-refs with: peeled" line was already read. Yields tuples
with ref names, SHA1s, and peeled SHA1s (or None).
Args:
f: file-like object to read from, seek'ed to the second line
"""
last = None
for line in f:
if line[0] == b"#":
continue
line = line.rstrip(b"\r\n")
if line.startswith(b"^"):
if not last:
raise PackedRefsException("unexpected peeled ref line")
if not valid_hexsha(line[1:]):
raise PackedRefsException("Invalid hex sha %r" % line[1:])
sha, name = _split_ref_line(last)
last = None
yield (sha, name, line[1:])
else:
if last:
sha, name = _split_ref_line(last)
yield (sha, name, None)
last = line
if last:
sha, name = _split_ref_line(last)
yield (sha, name, None)
def write_packed_refs(f, packed_refs, peeled_refs=None):
"""Write a packed refs file.
Args:
f: empty file-like object to write to
packed_refs: dict of refname to sha of packed refs to write
peeled_refs: dict of refname to peeled value of sha
"""
if peeled_refs is None:
peeled_refs = {}
else:
f.write(b"# pack-refs with: peeled\n")
for refname in sorted(packed_refs.keys()):
f.write(git_line(packed_refs[refname], refname))
if refname in peeled_refs:
f.write(b"^" + peeled_refs[refname] + b"\n")
def read_info_refs(f):
ret = {}
for line in f.readlines():
(sha, name) = line.rstrip(b"\r\n").split(b"\t", 1)
ret[name] = sha
return ret
def write_info_refs(refs, store):
"""Generate info refs."""
for name, sha in sorted(refs.items()):
# get_refs() includes HEAD as a special case, but we don't want to
# advertise it
if name == b"HEAD":
continue
try:
o = store[sha]
except KeyError:
continue
peeled = store.peel_sha(sha)
yield o.id + b"\t" + name + b"\n"
if o.id != peeled.id:
yield peeled.id + b"\t" + name + ANNOTATED_TAG_SUFFIX + b"\n"
def is_local_branch(x):
return x.startswith(LOCAL_BRANCH_PREFIX)
def strip_peeled_refs(refs):
"""Remove all peeled refs"""
return {
ref: sha
for (ref, sha) in refs.items()
if not ref.endswith(ANNOTATED_TAG_SUFFIX)
}
+
+
+def _set_origin_head(refs, origin, origin_head):
+ # set refs/remotes/origin/HEAD
+ origin_base = b"refs/remotes/" + origin + b"/"
+ if origin_head and origin_head.startswith(LOCAL_BRANCH_PREFIX):
+ origin_ref = origin_base + b"HEAD"
+ target_ref = origin_base + origin_head[len(LOCAL_BRANCH_PREFIX) :]
+ if target_ref in refs:
+ refs.set_symbolic_ref(origin_ref, target_ref)
+
+
+def _set_default_branch(refs, origin, origin_head, branch, ref_message):
+ origin_base = b"refs/remotes/" + origin + b"/"
+ if branch:
+ origin_ref = origin_base + branch
+ if origin_ref in refs:
+ local_ref = LOCAL_BRANCH_PREFIX + branch
+ refs.add_if_new(
+ local_ref, refs[origin_ref], ref_message
+ )
+ head_ref = local_ref
+ elif LOCAL_TAG_PREFIX + branch in refs:
+ head_ref = LOCAL_TAG_PREFIX + branch
+ else:
+ raise ValueError(
+ "%s is not a valid branch or tag" % os.fsencode(branch)
+ )
+ elif origin_head:
+ head_ref = origin_head
+ if origin_head.startswith(LOCAL_BRANCH_PREFIX):
+ origin_ref = origin_base + origin_head[len(LOCAL_BRANCH_PREFIX) :]
+ else:
+ origin_ref = origin_head
+ try:
+ refs.add_if_new(
+ head_ref, refs[origin_ref], ref_message
+ )
+ except KeyError:
+ pass
+ return head_ref
+
+
+def _set_head(refs, head_ref, ref_message):
+ if head_ref.startswith(LOCAL_TAG_PREFIX):
+ # detach HEAD at specified tag
+ head = refs[head_ref]
+ if isinstance(head, Tag):
+ _cls, obj = head.object
+ head = obj.get_object(obj).id
+ del refs[b"HEAD"]
+ refs.set_if_equals(
+ b"HEAD", None, head, message=ref_message
+ )
+ else:
+ # set HEAD to specific branch
+ try:
+ head = refs[head_ref]
+ refs.set_symbolic_ref(b"HEAD", head_ref)
+ refs.set_if_equals(
+ b"HEAD", None, head, message=ref_message
+ )
+ except KeyError:
+ head = None
+ return head
diff --git a/dulwich/repo.py b/dulwich/repo.py
index 29b0e669..e0362ef4 100644
--- a/dulwich/repo.py
+++ b/dulwich/repo.py
@@ -1,1704 +1,1749 @@
# 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,
+ LOCAL_BRANCH_PREFIX,
+ LOCAL_TAG_PREFIX,
check_ref_format,
RefsContainer,
DictRefsContainer,
InfoRefsContainer,
DiskRefsContainer,
read_packed_refs,
read_packed_refs_with_peeled,
write_packed_refs,
SYMREF,
+ _set_default_branch,
+ _set_head,
+ _set_origin_head,
)
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 gecos:
+ fullname = gecos.split(",")[0]
+ else:
+ fullname = None
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
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._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.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,
+ index_entry_from_directory,
_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):
+ if stat.S_ISDIR(st.st_mode):
+ entry = index_entry_from_directory(st, full_path)
+ if entry:
+ index[tree_path] = entry
+ else:
+ try:
+ del index[tree_path]
+ except KeyError:
+ pass
+ elif 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,
+ branch=None,
):
"""Clone this repository.
Args:
target_path: Target path
mkdir: Create the target directory
bare: Whether to create a bare repository
+ checkout: Whether or not to check-out HEAD after cloning
origin: Base name for refs in target repository
cloned from this repository
+ branch: Optional branch or tag to be used as HEAD in the new repository
+ instead of this repository's HEAD.
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
- )
+
+ if mkdir:
+ os.mkdir(target_path)
+
try:
- target.refs.add_if_new(
- DEFAULT_REF, self.refs[DEFAULT_REF], message=ref_message
+ target = None
+ if not bare:
+ target = Repo.init(target_path)
+ if checkout is None:
+ checkout = True
+ else:
+ if checkout:
+ raise ValueError("checkout and bare are incompatible")
+ target = Repo.init_bare(target_path)
+
+ target_config = target.get_config()
+ target_config.set((b"remote", origin), b"url", encoded_path)
+ target_config.set(
+ (b"remote", origin),
+ b"fetch",
+ b"+refs/heads/*:refs/remotes/" + origin + b"/*",
)
- 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()
+ target_config.write_to_path()
+
+ ref_message = b"clone: from " + encoded_path
+ self.fetch(target)
+ 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
+ )
+
+ head_chain, origin_sha = self.refs.follow(b"HEAD")
+ origin_head = head_chain[-1] if head_chain else None
+ if origin_sha and not origin_head:
+ # set detached HEAD
+ target.refs[b"HEAD"] = origin_sha
+ _set_origin_head(target.refs, origin, origin_head)
+ head_ref = _set_default_branch(
+ target.refs, origin, origin_head, branch, ref_message
+ )
+
+ # Update target head
+ if head_ref:
+ head = _set_head(target.refs, head_ref, ref_message)
+ else:
+ head = None
+
+ if checkout and head is not None:
+ target.reset_index()
+ except BaseException:
+ if target is not None:
+ target.close()
+ if mkdir:
+ import shutil
+ shutil.rmtree(target_path)
+ raise
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
+ head = self[b"HEAD"]
+ if isinstance(head, Tag):
+ _cls, obj = head.object
+ head = self.get_object(obj)
+ tree = 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_index.py b/dulwich/tests/test_index.py
index fc9cf75e..aa673181 100644
--- a/dulwich/tests/test_index.py
+++ b/dulwich/tests/test_index.py
@@ -1,841 +1,817 @@
# -*- coding: utf-8 -*-
# test_index.py -- Tests for the git index
# encoding: utf-8
# Copyright (C) 2008-2009 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 index."""
from io import BytesIO
import os
import shutil
import stat
import struct
import sys
import tempfile
-import warnings
from dulwich.index import (
Index,
build_index_from_tree,
cleanup_mode,
commit_tree,
get_unstaged_changes,
index_entry_from_stat,
read_index,
read_index_dict,
validate_path_element_default,
validate_path_element_ntfs,
write_cache_time,
write_index,
write_index_dict,
_tree_to_fs_path,
_fs_to_tree_path,
IndexEntry,
)
from dulwich.object_store import (
MemoryObjectStore,
)
from dulwich.objects import (
Blob,
Commit,
Tree,
S_IFGITLINK,
)
from dulwich.repo import Repo
from dulwich.tests import (
TestCase,
skipIf,
)
-from dulwich.tests.utils import (
- setup_warning_catcher,
-)
def can_symlink():
"""Return whether running process can create symlinks."""
if sys.platform != "win32":
# Platforms other than Windows should allow symlinks without issues.
return True
if not hasattr(os, "symlink"):
# Older Python versions do not have `os.symlink` on Windows.
return False
test_source = tempfile.mkdtemp()
test_target = test_source + "can_symlink"
try:
os.symlink(test_source, test_target)
except (NotImplementedError, OSError):
return False
return True
class IndexTestCase(TestCase):
datadir = os.path.join(os.path.dirname(__file__), "data/indexes")
def get_simple_index(self, name):
return Index(os.path.join(self.datadir, name))
class SimpleIndexTestCase(IndexTestCase):
def test_len(self):
self.assertEqual(1, len(self.get_simple_index("index")))
def test_iter(self):
self.assertEqual([b"bla"], list(self.get_simple_index("index")))
def test_iterobjects(self):
self.assertEqual(
[(b"bla", b"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", 33188)],
list(self.get_simple_index("index").iterobjects()),
)
- def test_iterblobs(self):
- warnings.simplefilter("always", UserWarning)
- self.addCleanup(warnings.resetwarnings)
- warnings_list, restore_warnings = setup_warning_catcher()
- self.addCleanup(restore_warnings)
-
- self.assertEqual(
- [(b"bla", b"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", 33188)],
- list(self.get_simple_index("index").iterblobs()),
- )
-
- expected_warning = PendingDeprecationWarning("Use iterobjects() instead.")
- 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)
- )
-
def test_getitem(self):
self.assertEqual(
(
(1230680220, 0),
(1230680220, 0),
2050,
3761020,
33188,
1000,
1000,
0,
b"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391",
0,
0,
),
self.get_simple_index("index")[b"bla"],
)
def test_empty(self):
i = self.get_simple_index("notanindex")
self.assertEqual(0, len(i))
self.assertFalse(os.path.exists(i._filename))
def test_against_empty_tree(self):
i = self.get_simple_index("index")
changes = list(i.changes_from_tree(MemoryObjectStore(), None))
self.assertEqual(1, len(changes))
(oldname, newname), (oldmode, newmode), (oldsha, newsha) = changes[0]
self.assertEqual(b"bla", newname)
self.assertEqual(b"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", newsha)
class SimpleIndexWriterTestCase(IndexTestCase):
def setUp(self):
IndexTestCase.setUp(self)
self.tempdir = tempfile.mkdtemp()
def tearDown(self):
IndexTestCase.tearDown(self)
shutil.rmtree(self.tempdir)
def test_simple_write(self):
entries = [
(
b"barbla",
IndexEntry(
(1230680220, 0),
(1230680220, 0),
2050,
3761020,
33188,
1000,
1000,
0,
b"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391",
0,
0)
)
]
filename = os.path.join(self.tempdir, "test-simple-write-index")
with open(filename, "wb+") as x:
write_index(x, entries)
with open(filename, "rb") as x:
self.assertEqual(entries, list(read_index(x)))
class ReadIndexDictTests(IndexTestCase):
def setUp(self):
IndexTestCase.setUp(self)
self.tempdir = tempfile.mkdtemp()
def tearDown(self):
IndexTestCase.tearDown(self)
shutil.rmtree(self.tempdir)
def test_simple_write(self):
entries = {
b"barbla": IndexEntry(
(1230680220, 0),
(1230680220, 0),
2050,
3761020,
33188,
1000,
1000,
0,
b"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391",
0,
0,
)
}
filename = os.path.join(self.tempdir, "test-simple-write-index")
with open(filename, "wb+") as x:
write_index_dict(x, entries)
with open(filename, "rb") as x:
self.assertEqual(entries, read_index_dict(x))
class CommitTreeTests(TestCase):
def setUp(self):
super(CommitTreeTests, self).setUp()
self.store = MemoryObjectStore()
def test_single_blob(self):
blob = Blob()
blob.data = b"foo"
self.store.add_object(blob)
blobs = [(b"bla", blob.id, stat.S_IFREG)]
rootid = commit_tree(self.store, blobs)
self.assertEqual(rootid, b"1a1e80437220f9312e855c37ac4398b68e5c1d50")
self.assertEqual((stat.S_IFREG, blob.id), self.store[rootid][b"bla"])
self.assertEqual(set([rootid, blob.id]), set(self.store._data.keys()))
def test_nested(self):
blob = Blob()
blob.data = b"foo"
self.store.add_object(blob)
blobs = [(b"bla/bar", blob.id, stat.S_IFREG)]
rootid = commit_tree(self.store, blobs)
self.assertEqual(rootid, b"d92b959b216ad0d044671981196781b3258fa537")
dirid = self.store[rootid][b"bla"][1]
self.assertEqual(dirid, b"c1a1deb9788150829579a8b4efa6311e7b638650")
self.assertEqual((stat.S_IFDIR, dirid), self.store[rootid][b"bla"])
self.assertEqual((stat.S_IFREG, blob.id), self.store[dirid][b"bar"])
self.assertEqual(set([rootid, dirid, blob.id]), set(self.store._data.keys()))
class CleanupModeTests(TestCase):
def assertModeEqual(self, expected, got):
self.assertEqual(expected, got, "%o != %o" % (expected, got))
def test_file(self):
self.assertModeEqual(0o100644, cleanup_mode(0o100000))
def test_executable(self):
self.assertModeEqual(0o100755, cleanup_mode(0o100711))
self.assertModeEqual(0o100755, cleanup_mode(0o100700))
def test_symlink(self):
self.assertModeEqual(0o120000, cleanup_mode(0o120711))
def test_dir(self):
self.assertModeEqual(0o040000, cleanup_mode(0o40531))
def test_submodule(self):
self.assertModeEqual(0o160000, cleanup_mode(0o160744))
class WriteCacheTimeTests(TestCase):
def test_write_string(self):
f = BytesIO()
self.assertRaises(TypeError, write_cache_time, f, "foo")
def test_write_int(self):
f = BytesIO()
write_cache_time(f, 434343)
self.assertEqual(struct.pack(">LL", 434343, 0), f.getvalue())
def test_write_tuple(self):
f = BytesIO()
write_cache_time(f, (434343, 21))
self.assertEqual(struct.pack(">LL", 434343, 21), f.getvalue())
def test_write_float(self):
f = BytesIO()
write_cache_time(f, 434343.000000021)
self.assertEqual(struct.pack(">LL", 434343, 21), f.getvalue())
class IndexEntryFromStatTests(TestCase):
def test_simple(self):
st = os.stat_result(
(
16877,
131078,
64769,
154,
1000,
1000,
12288,
1323629595,
1324180496,
1324180496,
)
)
entry = index_entry_from_stat(st, "22" * 20, 0)
self.assertEqual(
entry,
IndexEntry(
1324180496,
1324180496,
64769,
131078,
16384,
1000,
1000,
12288,
"2222222222222222222222222222222222222222",
0,
None,
),
)
def test_override_mode(self):
st = os.stat_result(
(
stat.S_IFREG + 0o644,
131078,
64769,
154,
1000,
1000,
12288,
1323629595,
1324180496,
1324180496,
)
)
entry = index_entry_from_stat(st, "22" * 20, 0, mode=stat.S_IFREG + 0o755)
self.assertEqual(
entry,
IndexEntry(
1324180496,
1324180496,
64769,
131078,
33261,
1000,
1000,
12288,
"2222222222222222222222222222222222222222",
0,
None,
),
)
class BuildIndexTests(TestCase):
def assertReasonableIndexEntry(self, index_entry, mode, filesize, sha):
self.assertEqual(index_entry[4], mode) # mode
self.assertEqual(index_entry[7], filesize) # filesize
self.assertEqual(index_entry[8], sha) # sha
def assertFileContents(self, path, contents, symlink=False):
if symlink:
self.assertEqual(os.readlink(path), contents)
else:
with open(path, "rb") as f:
self.assertEqual(f.read(), contents)
def test_empty(self):
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
with Repo.init(repo_dir) as repo:
tree = Tree()
repo.object_store.add_object(tree)
build_index_from_tree(
repo.path, repo.index_path(), repo.object_store, tree.id
)
# Verify index entries
index = repo.open_index()
self.assertEqual(len(index), 0)
# Verify no files
self.assertEqual([".git"], os.listdir(repo.path))
def test_git_dir(self):
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
with Repo.init(repo_dir) as repo:
# Populate repo
filea = Blob.from_string(b"file a")
filee = Blob.from_string(b"d")
tree = Tree()
tree[b".git/a"] = (stat.S_IFREG | 0o644, filea.id)
tree[b"c/e"] = (stat.S_IFREG | 0o644, filee.id)
repo.object_store.add_objects([(o, None) for o in [filea, filee, tree]])
build_index_from_tree(
repo.path, repo.index_path(), repo.object_store, tree.id
)
# Verify index entries
index = repo.open_index()
self.assertEqual(len(index), 1)
# filea
apath = os.path.join(repo.path, ".git", "a")
self.assertFalse(os.path.exists(apath))
# filee
epath = os.path.join(repo.path, "c", "e")
self.assertTrue(os.path.exists(epath))
self.assertReasonableIndexEntry(
index[b"c/e"], stat.S_IFREG | 0o644, 1, filee.id
)
self.assertFileContents(epath, b"d")
def test_nonempty(self):
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
with Repo.init(repo_dir) as repo:
# Populate repo
filea = Blob.from_string(b"file a")
fileb = Blob.from_string(b"file b")
filed = Blob.from_string(b"file d")
tree = Tree()
tree[b"a"] = (stat.S_IFREG | 0o644, filea.id)
tree[b"b"] = (stat.S_IFREG | 0o644, fileb.id)
tree[b"c/d"] = (stat.S_IFREG | 0o644, filed.id)
repo.object_store.add_objects(
[(o, None) for o in [filea, fileb, filed, tree]]
)
build_index_from_tree(
repo.path, repo.index_path(), repo.object_store, tree.id
)
# Verify index entries
index = repo.open_index()
self.assertEqual(len(index), 3)
# filea
apath = os.path.join(repo.path, "a")
self.assertTrue(os.path.exists(apath))
self.assertReasonableIndexEntry(
index[b"a"], stat.S_IFREG | 0o644, 6, filea.id
)
self.assertFileContents(apath, b"file a")
# fileb
bpath = os.path.join(repo.path, "b")
self.assertTrue(os.path.exists(bpath))
self.assertReasonableIndexEntry(
index[b"b"], stat.S_IFREG | 0o644, 6, fileb.id
)
self.assertFileContents(bpath, b"file b")
# filed
dpath = os.path.join(repo.path, "c", "d")
self.assertTrue(os.path.exists(dpath))
self.assertReasonableIndexEntry(
index[b"c/d"], stat.S_IFREG | 0o644, 6, filed.id
)
self.assertFileContents(dpath, b"file d")
# Verify no extra files
self.assertEqual([".git", "a", "b", "c"], sorted(os.listdir(repo.path)))
self.assertEqual(["d"], sorted(os.listdir(os.path.join(repo.path, "c"))))
@skipIf(not getattr(os, "sync", None), "Requires sync support")
def test_norewrite(self):
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
with Repo.init(repo_dir) as repo:
# Populate repo
filea = Blob.from_string(b"file a")
filea_path = os.path.join(repo_dir, "a")
tree = Tree()
tree[b"a"] = (stat.S_IFREG | 0o644, filea.id)
repo.object_store.add_objects([(o, None) for o in [filea, tree]])
# First Write
build_index_from_tree(
repo.path, repo.index_path(), repo.object_store, tree.id
)
# Use sync as metadata can be cached on some FS
os.sync()
mtime = os.stat(filea_path).st_mtime
# Test Rewrite
build_index_from_tree(
repo.path, repo.index_path(), repo.object_store, tree.id
)
os.sync()
self.assertEqual(mtime, os.stat(filea_path).st_mtime)
# Modify content
with open(filea_path, "wb") as fh:
fh.write(b"test a")
os.sync()
mtime = os.stat(filea_path).st_mtime
# Test rewrite
build_index_from_tree(
repo.path, repo.index_path(), repo.object_store, tree.id
)
os.sync()
with open(filea_path, "rb") as fh:
self.assertEqual(b"file a", fh.read())
@skipIf(not can_symlink(), "Requires symlink support")
def test_symlink(self):
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
with Repo.init(repo_dir) as repo:
# Populate repo
filed = Blob.from_string(b"file d")
filee = Blob.from_string(b"d")
tree = Tree()
tree[b"c/d"] = (stat.S_IFREG | 0o644, filed.id)
tree[b"c/e"] = (stat.S_IFLNK, filee.id) # symlink
repo.object_store.add_objects([(o, None) for o in [filed, filee, tree]])
build_index_from_tree(
repo.path, repo.index_path(), repo.object_store, tree.id
)
# Verify index entries
index = repo.open_index()
# symlink to d
epath = os.path.join(repo.path, "c", "e")
self.assertTrue(os.path.exists(epath))
self.assertReasonableIndexEntry(
index[b"c/e"],
stat.S_IFLNK,
0 if sys.platform == "win32" else 1,
filee.id,
)
self.assertFileContents(epath, "d", symlink=True)
def test_no_decode_encode(self):
repo_dir = tempfile.mkdtemp()
repo_dir_bytes = os.fsencode(repo_dir)
self.addCleanup(shutil.rmtree, repo_dir)
with Repo.init(repo_dir) as repo:
# Populate repo
file = Blob.from_string(b"foo")
tree = Tree()
latin1_name = u"À".encode("latin1")
latin1_path = os.path.join(repo_dir_bytes, latin1_name)
utf8_name = u"À".encode("utf8")
utf8_path = os.path.join(repo_dir_bytes, utf8_name)
tree[latin1_name] = (stat.S_IFREG | 0o644, file.id)
tree[utf8_name] = (stat.S_IFREG | 0o644, file.id)
repo.object_store.add_objects([(o, None) for o in [file, tree]])
try:
build_index_from_tree(
repo.path, repo.index_path(), repo.object_store, tree.id
)
except OSError as e:
if e.errno == 92 and sys.platform == "darwin":
# Our filename isn't supported by the platform :(
self.skipTest("can not write filename %r" % e.filename)
else:
raise
except UnicodeDecodeError:
# This happens e.g. with python3.6 on Windows.
# It implicitly decodes using utf8, which doesn't work.
self.skipTest("can not implicitly convert as utf8")
# Verify index entries
index = repo.open_index()
self.assertIn(latin1_name, index)
self.assertIn(utf8_name, index)
self.assertTrue(os.path.exists(latin1_path))
self.assertTrue(os.path.exists(utf8_path))
def test_git_submodule(self):
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
with Repo.init(repo_dir) as repo:
filea = Blob.from_string(b"file alalala")
subtree = Tree()
subtree[b"a"] = (stat.S_IFREG | 0o644, filea.id)
c = Commit()
c.tree = subtree.id
c.committer = c.author = b"Somebody <somebody@example.com>"
c.commit_time = c.author_time = 42342
c.commit_timezone = c.author_timezone = 0
c.parents = []
c.message = b"Subcommit"
tree = Tree()
tree[b"c"] = (S_IFGITLINK, c.id)
repo.object_store.add_objects([(o, None) for o in [tree]])
build_index_from_tree(
repo.path, repo.index_path(), repo.object_store, tree.id
)
# Verify index entries
index = repo.open_index()
self.assertEqual(len(index), 1)
# filea
apath = os.path.join(repo.path, "c/a")
self.assertFalse(os.path.exists(apath))
# dir c
cpath = os.path.join(repo.path, "c")
self.assertTrue(os.path.isdir(cpath))
self.assertEqual(index[b"c"][4], S_IFGITLINK) # mode
self.assertEqual(index[b"c"][8], c.id) # sha
def test_git_submodule_exists(self):
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
with Repo.init(repo_dir) as repo:
filea = Blob.from_string(b"file alalala")
subtree = Tree()
subtree[b"a"] = (stat.S_IFREG | 0o644, filea.id)
c = Commit()
c.tree = subtree.id
c.committer = c.author = b"Somebody <somebody@example.com>"
c.commit_time = c.author_time = 42342
c.commit_timezone = c.author_timezone = 0
c.parents = []
c.message = b"Subcommit"
tree = Tree()
tree[b"c"] = (S_IFGITLINK, c.id)
os.mkdir(os.path.join(repo_dir, "c"))
repo.object_store.add_objects([(o, None) for o in [tree]])
build_index_from_tree(
repo.path, repo.index_path(), repo.object_store, tree.id
)
# Verify index entries
index = repo.open_index()
self.assertEqual(len(index), 1)
# filea
apath = os.path.join(repo.path, "c/a")
self.assertFalse(os.path.exists(apath))
# dir c
cpath = os.path.join(repo.path, "c")
self.assertTrue(os.path.isdir(cpath))
self.assertEqual(index[b"c"][4], S_IFGITLINK) # mode
self.assertEqual(index[b"c"][8], c.id) # sha
class GetUnstagedChangesTests(TestCase):
def test_get_unstaged_changes(self):
"""Unit test for get_unstaged_changes."""
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
with Repo.init(repo_dir) as repo:
# Commit a dummy file then modify it
foo1_fullpath = os.path.join(repo_dir, "foo1")
with open(foo1_fullpath, "wb") as f:
f.write(b"origstuff")
foo2_fullpath = os.path.join(repo_dir, "foo2")
with open(foo2_fullpath, "wb") as f:
f.write(b"origstuff")
repo.stage(["foo1", "foo2"])
repo.do_commit(
b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
with open(foo1_fullpath, "wb") as f:
f.write(b"newstuff")
# modify access and modify time of path
os.utime(foo1_fullpath, (0, 0))
changes = get_unstaged_changes(repo.open_index(), repo_dir)
self.assertEqual(list(changes), [b"foo1"])
def test_get_unstaged_deleted_changes(self):
"""Unit test for get_unstaged_changes."""
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
with Repo.init(repo_dir) as repo:
# Commit a dummy file then remove it
foo1_fullpath = os.path.join(repo_dir, "foo1")
with open(foo1_fullpath, "wb") as f:
f.write(b"origstuff")
repo.stage(["foo1"])
repo.do_commit(
b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
os.unlink(foo1_fullpath)
changes = get_unstaged_changes(repo.open_index(), repo_dir)
self.assertEqual(list(changes), [b"foo1"])
def test_get_unstaged_changes_removed_replaced_by_directory(self):
"""Unit test for get_unstaged_changes."""
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
with Repo.init(repo_dir) as repo:
# Commit a dummy file then modify it
foo1_fullpath = os.path.join(repo_dir, "foo1")
with open(foo1_fullpath, "wb") as f:
f.write(b"origstuff")
repo.stage(["foo1"])
repo.do_commit(
b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
os.remove(foo1_fullpath)
os.mkdir(foo1_fullpath)
changes = get_unstaged_changes(repo.open_index(), repo_dir)
self.assertEqual(list(changes), [b"foo1"])
@skipIf(not can_symlink(), "Requires symlink support")
def test_get_unstaged_changes_removed_replaced_by_link(self):
"""Unit test for get_unstaged_changes."""
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
with Repo.init(repo_dir) as repo:
# Commit a dummy file then modify it
foo1_fullpath = os.path.join(repo_dir, "foo1")
with open(foo1_fullpath, "wb") as f:
f.write(b"origstuff")
repo.stage(["foo1"])
repo.do_commit(
b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
os.remove(foo1_fullpath)
os.symlink(os.path.dirname(foo1_fullpath), foo1_fullpath)
changes = get_unstaged_changes(repo.open_index(), repo_dir)
self.assertEqual(list(changes), [b"foo1"])
class TestValidatePathElement(TestCase):
def test_default(self):
self.assertTrue(validate_path_element_default(b"bla"))
self.assertTrue(validate_path_element_default(b".bla"))
self.assertFalse(validate_path_element_default(b".git"))
self.assertFalse(validate_path_element_default(b".giT"))
self.assertFalse(validate_path_element_default(b".."))
self.assertTrue(validate_path_element_default(b"git~1"))
def test_ntfs(self):
self.assertTrue(validate_path_element_ntfs(b"bla"))
self.assertTrue(validate_path_element_ntfs(b".bla"))
self.assertFalse(validate_path_element_ntfs(b".git"))
self.assertFalse(validate_path_element_ntfs(b".giT"))
self.assertFalse(validate_path_element_ntfs(b".."))
self.assertFalse(validate_path_element_ntfs(b"git~1"))
class TestTreeFSPathConversion(TestCase):
def test_tree_to_fs_path(self):
tree_path = u"délwíçh/foo".encode("utf8")
fs_path = _tree_to_fs_path(b"/prefix/path", tree_path)
self.assertEqual(
fs_path,
os.fsencode(os.path.join(u"/prefix/path", u"délwíçh", u"foo")),
)
def test_fs_to_tree_path_str(self):
fs_path = os.path.join(os.path.join(u"délwíçh", u"foo"))
tree_path = _fs_to_tree_path(fs_path)
self.assertEqual(tree_path, u"délwíçh/foo".encode("utf-8"))
def test_fs_to_tree_path_bytes(self):
fs_path = os.path.join(os.fsencode(os.path.join(u"délwíçh", u"foo")))
tree_path = _fs_to_tree_path(fs_path)
self.assertEqual(tree_path, u"délwíçh/foo".encode("utf-8"))
diff --git a/dulwich/tests/test_porcelain.py b/dulwich/tests/test_porcelain.py
index 0334f192..5618066e 100644
--- a/dulwich/tests/test_porcelain.py
+++ b/dulwich/tests/test_porcelain.py
@@ -1,2807 +1,2815 @@
# test_porcelain.py -- porcelain tests
# Copyright (C) 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.
#
"""Tests for dulwich.porcelain."""
from io import BytesIO, StringIO
import os
import platform
import re
import shutil
import stat
import subprocess
import sys
import tarfile
import tempfile
import time
from unittest import skipIf
from dulwich import porcelain
from dulwich.diff_tree import tree_changes
from dulwich.errors import (
CommitError,
)
from dulwich.objects import (
Blob,
Tag,
Tree,
ZERO_SHA,
)
from dulwich.repo import (
NoIndexPresent,
Repo,
)
from dulwich.tests import (
TestCase,
)
from dulwich.tests.utils import (
build_commit_graph,
make_commit,
make_object,
)
def flat_walk_dir(dir_to_walk):
for dirpath, _, filenames in os.walk(dir_to_walk):
rel_dirpath = os.path.relpath(dirpath, dir_to_walk)
if not dirpath == dir_to_walk:
yield rel_dirpath
for filename in filenames:
if dirpath == dir_to_walk:
yield filename
else:
yield os.path.join(rel_dirpath, filename)
class PorcelainTestCase(TestCase):
def setUp(self):
super(PorcelainTestCase, self).setUp()
self.test_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, self.test_dir)
self.repo_path = os.path.join(self.test_dir, "repo")
self.repo = Repo.init(self.repo_path, mkdir=True)
self.addCleanup(self.repo.close)
class PorcelainGpgTestCase(PorcelainTestCase):
DEFAULT_KEY = """
-----BEGIN PGP PRIVATE KEY BLOCK-----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=ivA/
-----END PGP PRIVATE KEY BLOCK-----
"""
DEFAULT_KEY_ID = "8EB47C310E1F24AE383D832F7CDD800A52E65E26"
NON_DEFAULT_KEY = """
-----BEGIN PGP PRIVATE KEY BLOCK-----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=9zU5
-----END PGP PRIVATE KEY BLOCK-----
"""
NON_DEFAULT_KEY_ID = "6A93393F50C5E6ACD3D6FB45B936212EDB4E14C0"
def setUp(self):
super(PorcelainGpgTestCase, self).setUp()
self.gpg_dir = os.path.join(self.test_dir, "gpg")
os.mkdir(self.gpg_dir, mode=0o700)
self.addCleanup(shutil.rmtree, self.gpg_dir)
self._old_gnupghome = os.environ.get("GNUPGHOME")
os.environ["GNUPGHOME"] = self.gpg_dir
if self._old_gnupghome is None:
self.addCleanup(os.environ.__delitem__, "GNUPGHOME")
else:
self.addCleanup(os.environ.__setitem__, "GNUPGHOME", self._old_gnupghome)
def import_default_key(self):
subprocess.run(
["gpg", "--import"],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
input=PorcelainGpgTestCase.DEFAULT_KEY,
universal_newlines=True,
)
def import_non_default_key(self):
subprocess.run(
["gpg", "--import"],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
input=PorcelainGpgTestCase.NON_DEFAULT_KEY,
universal_newlines=True,
)
class ArchiveTests(PorcelainTestCase):
"""Tests for the archive command."""
def test_simple(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"refs/heads/master"] = c3.id
out = BytesIO()
err = BytesIO()
porcelain.archive(
self.repo.path, b"refs/heads/master", outstream=out, errstream=err
)
self.assertEqual(b"", err.getvalue())
tf = tarfile.TarFile(fileobj=out)
self.addCleanup(tf.close)
self.assertEqual([], tf.getnames())
class UpdateServerInfoTests(PorcelainTestCase):
def test_simple(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"refs/heads/foo"] = c3.id
porcelain.update_server_info(self.repo.path)
self.assertTrue(
os.path.exists(os.path.join(self.repo.controldir(), "info", "refs"))
)
class CommitTests(PorcelainTestCase):
def test_custom_author(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"refs/heads/foo"] = c3.id
sha = porcelain.commit(
self.repo.path,
message=b"Some message",
author=b"Joe <joe@example.com>",
committer=b"Bob <bob@example.com>",
)
self.assertTrue(isinstance(sha, bytes))
self.assertEqual(len(sha), 40)
def test_unicode(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"refs/heads/foo"] = c3.id
sha = porcelain.commit(
self.repo.path,
message="Some message",
author="Joe <joe@example.com>",
committer="Bob <bob@example.com>",
)
self.assertTrue(isinstance(sha, bytes))
self.assertEqual(len(sha), 40)
def test_no_verify(self):
if os.name != "posix":
self.skipTest("shell hook tests requires POSIX shell")
self.assertTrue(os.path.exists("/bin/sh"))
hooks_dir = os.path.join(self.repo.controldir(), "hooks")
os.makedirs(hooks_dir, exist_ok=True)
self.addCleanup(shutil.rmtree, hooks_dir)
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
hook_fail = "#!/bin/sh\nexit 1"
# hooks are executed in pre-commit, commit-msg order
# test commit-msg failure first, then pre-commit failure, then
# no_verify to skip both hooks
commit_msg = os.path.join(hooks_dir, "commit-msg")
with open(commit_msg, "w") as f:
f.write(hook_fail)
os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
with self.assertRaises(CommitError):
porcelain.commit(
self.repo.path,
message="Some message",
author="Joe <joe@example.com>",
committer="Bob <bob@example.com>",
)
pre_commit = os.path.join(hooks_dir, "pre-commit")
with open(pre_commit, "w") as f:
f.write(hook_fail)
os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
with self.assertRaises(CommitError):
porcelain.commit(
self.repo.path,
message="Some message",
author="Joe <joe@example.com>",
committer="Bob <bob@example.com>",
)
sha = porcelain.commit(
self.repo.path,
message="Some message",
author="Joe <joe@example.com>",
committer="Bob <bob@example.com>",
no_verify=True,
)
self.assertTrue(isinstance(sha, bytes))
self.assertEqual(len(sha), 40)
class CleanTests(PorcelainTestCase):
def put_files(self, tracked, ignored, untracked, empty_dirs):
"""Put the described files in the wd"""
all_files = tracked | ignored | untracked
for file_path in all_files:
abs_path = os.path.join(self.repo.path, file_path)
# File may need to be written in a dir that doesn't exist yet, so
# create the parent dir(s) as necessary
parent_dir = os.path.dirname(abs_path)
try:
os.makedirs(parent_dir)
except FileExistsError:
pass
with open(abs_path, "w") as f:
f.write("")
with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
f.writelines(ignored)
for dir_path in empty_dirs:
os.mkdir(os.path.join(self.repo.path, "empty_dir"))
files_to_add = [os.path.join(self.repo.path, t) for t in tracked]
porcelain.add(repo=self.repo.path, paths=files_to_add)
porcelain.commit(repo=self.repo.path, message="init commit")
def assert_wd(self, expected_paths):
"""Assert paths of files and dirs in wd are same as expected_paths"""
control_dir_rel = os.path.relpath(self.repo._controldir, self.repo.path)
# normalize paths to simplify comparison across platforms
found_paths = {
os.path.normpath(p)
for p in flat_walk_dir(self.repo.path)
if not p.split(os.sep)[0] == control_dir_rel
}
norm_expected_paths = {os.path.normpath(p) for p in expected_paths}
self.assertEqual(found_paths, norm_expected_paths)
def test_from_root(self):
self.put_files(
tracked={"tracked_file", "tracked_dir/tracked_file", ".gitignore"},
ignored={"ignored_file"},
untracked={
"untracked_file",
"tracked_dir/untracked_dir/untracked_file",
"untracked_dir/untracked_dir/untracked_file",
},
empty_dirs={"empty_dir"},
)
porcelain.clean(repo=self.repo.path, target_dir=self.repo.path)
self.assert_wd(
{
"tracked_file",
"tracked_dir/tracked_file",
".gitignore",
"ignored_file",
"tracked_dir",
}
)
def test_from_subdir(self):
self.put_files(
tracked={"tracked_file", "tracked_dir/tracked_file", ".gitignore"},
ignored={"ignored_file"},
untracked={
"untracked_file",
"tracked_dir/untracked_dir/untracked_file",
"untracked_dir/untracked_dir/untracked_file",
},
empty_dirs={"empty_dir"},
)
porcelain.clean(
repo=self.repo,
target_dir=os.path.join(self.repo.path, "untracked_dir"),
)
self.assert_wd(
{
"tracked_file",
"tracked_dir/tracked_file",
".gitignore",
"ignored_file",
"untracked_file",
"tracked_dir/untracked_dir/untracked_file",
"empty_dir",
"untracked_dir",
"tracked_dir",
"tracked_dir/untracked_dir",
}
)
class CloneTests(PorcelainTestCase):
def test_simple_local(self):
f1_1 = make_object(Blob, data=b"f1")
commit_spec = [[1], [2, 1], [3, 1, 2]]
trees = {
1: [(b"f1", f1_1), (b"f2", f1_1)],
2: [(b"f1", f1_1), (b"f2", f1_1)],
3: [(b"f1", f1_1), (b"f2", f1_1)],
}
c1, c2, c3 = build_commit_graph(self.repo.object_store, commit_spec, trees)
self.repo.refs[b"refs/heads/master"] = c3.id
self.repo.refs[b"refs/tags/foo"] = c3.id
target_path = tempfile.mkdtemp()
errstream = BytesIO()
self.addCleanup(shutil.rmtree, target_path)
r = porcelain.clone(
self.repo.path, target_path, checkout=False, errstream=errstream
)
self.addCleanup(r.close)
self.assertEqual(r.path, target_path)
target_repo = Repo(target_path)
self.assertEqual(0, len(target_repo.open_index()))
self.assertEqual(c3.id, target_repo.refs[b"refs/tags/foo"])
self.assertTrue(b"f1" not in os.listdir(target_path))
self.assertTrue(b"f2" not in os.listdir(target_path))
c = r.get_config()
encoded_path = self.repo.path
if not isinstance(encoded_path, bytes):
encoded_path = encoded_path.encode("utf-8")
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_simple_local_with_checkout(self):
f1_1 = make_object(Blob, data=b"f1")
commit_spec = [[1], [2, 1], [3, 1, 2]]
trees = {
1: [(b"f1", f1_1), (b"f2", f1_1)],
2: [(b"f1", f1_1), (b"f2", f1_1)],
3: [(b"f1", f1_1), (b"f2", f1_1)],
}
c1, c2, c3 = build_commit_graph(self.repo.object_store, commit_spec, trees)
self.repo.refs[b"refs/heads/master"] = c3.id
target_path = tempfile.mkdtemp()
errstream = BytesIO()
self.addCleanup(shutil.rmtree, target_path)
with porcelain.clone(
self.repo.path, target_path, checkout=True, errstream=errstream
) as r:
self.assertEqual(r.path, target_path)
with Repo(target_path) as r:
self.assertEqual(r.head(), c3.id)
self.assertTrue("f1" in os.listdir(target_path))
self.assertTrue("f2" in os.listdir(target_path))
def test_bare_local_with_checkout(self):
f1_1 = make_object(Blob, data=b"f1")
commit_spec = [[1], [2, 1], [3, 1, 2]]
trees = {
1: [(b"f1", f1_1), (b"f2", f1_1)],
2: [(b"f1", f1_1), (b"f2", f1_1)],
3: [(b"f1", f1_1), (b"f2", f1_1)],
}
c1, c2, c3 = build_commit_graph(self.repo.object_store, commit_spec, trees)
self.repo.refs[b"refs/heads/master"] = c3.id
target_path = tempfile.mkdtemp()
errstream = BytesIO()
self.addCleanup(shutil.rmtree, target_path)
with porcelain.clone(
self.repo.path, target_path, bare=True, errstream=errstream
) as r:
self.assertEqual(r.path, target_path)
with Repo(target_path) as r:
r.head()
self.assertRaises(NoIndexPresent, r.open_index)
self.assertFalse(b"f1" in os.listdir(target_path))
self.assertFalse(b"f2" in os.listdir(target_path))
def test_no_checkout_with_bare(self):
f1_1 = make_object(Blob, data=b"f1")
commit_spec = [[1]]
trees = {1: [(b"f1", f1_1), (b"f2", f1_1)]}
(c1,) = build_commit_graph(self.repo.object_store, commit_spec, trees)
self.repo.refs[b"refs/heads/master"] = c1.id
self.repo.refs[b"HEAD"] = c1.id
target_path = tempfile.mkdtemp()
errstream = BytesIO()
self.addCleanup(shutil.rmtree, target_path)
self.assertRaises(
porcelain.Error,
porcelain.clone,
self.repo.path,
target_path,
checkout=True,
bare=True,
errstream=errstream,
)
def test_no_head_no_checkout(self):
f1_1 = make_object(Blob, data=b"f1")
commit_spec = [[1]]
trees = {1: [(b"f1", f1_1), (b"f2", f1_1)]}
(c1,) = build_commit_graph(self.repo.object_store, commit_spec, trees)
self.repo.refs[b"refs/heads/master"] = c1.id
target_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, target_path)
errstream = BytesIO()
r = porcelain.clone(
self.repo.path, target_path, checkout=True, errstream=errstream
)
r.close()
def test_no_head_no_checkout_outstream_errstream_autofallback(self):
f1_1 = make_object(Blob, data=b"f1")
commit_spec = [[1]]
trees = {1: [(b"f1", f1_1), (b"f2", f1_1)]}
(c1,) = build_commit_graph(self.repo.object_store, commit_spec, trees)
self.repo.refs[b"refs/heads/master"] = c1.id
target_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, target_path)
errstream = porcelain.NoneStream()
r = porcelain.clone(
self.repo.path, target_path, checkout=True, errstream=errstream
)
r.close()
def test_source_broken(self):
- target_path = tempfile.mkdtemp()
- self.assertRaises(Exception, porcelain.clone, "/nonexistant/repo", target_path)
- self.assertFalse(os.path.exists(target_path))
+ with tempfile.TemporaryDirectory() as parent:
+ target_path = os.path.join(parent, "target")
+ self.assertRaises(
+ Exception, porcelain.clone, "/nonexistant/repo", target_path
+ )
+ self.assertFalse(os.path.exists(target_path))
def test_fetch_symref(self):
f1_1 = make_object(Blob, data=b"f1")
trees = {1: [(b"f1", f1_1), (b"f2", f1_1)]}
[c1] = build_commit_graph(self.repo.object_store, [[1]], trees)
self.repo.refs.set_symbolic_ref(b"HEAD", b"refs/heads/else")
self.repo.refs[b"refs/heads/else"] = c1.id
target_path = tempfile.mkdtemp()
errstream = BytesIO()
self.addCleanup(shutil.rmtree, target_path)
r = porcelain.clone(
self.repo.path, target_path, checkout=False, errstream=errstream
)
self.addCleanup(r.close)
self.assertEqual(r.path, target_path)
target_repo = Repo(target_path)
self.assertEqual(0, len(target_repo.open_index()))
self.assertEqual(c1.id, target_repo.refs[b"refs/heads/else"])
self.assertEqual(c1.id, target_repo.refs[b"HEAD"])
- self.assertEqual({b"HEAD": b"refs/heads/else"}, target_repo.refs.get_symrefs())
+ self.assertEqual(
+ {b"HEAD": b"refs/heads/else", b"refs/remotes/origin/HEAD": b"refs/remotes/origin/else"},
+ target_repo.refs.get_symrefs(),
+ )
class InitTests(TestCase):
def test_non_bare(self):
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
porcelain.init(repo_dir)
def test_bare(self):
repo_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, repo_dir)
porcelain.init(repo_dir, bare=True)
class AddTests(PorcelainTestCase):
def test_add_default_paths(self):
# create a file for initial commit
fullpath = os.path.join(self.repo.path, "blah")
with open(fullpath, "w") as f:
f.write("\n")
porcelain.add(repo=self.repo.path, paths=[fullpath])
porcelain.commit(
repo=self.repo.path,
message=b"test",
author=b"test <email>",
committer=b"test <email>",
)
# Add a second test file and a file in a directory
with open(os.path.join(self.repo.path, "foo"), "w") as f:
f.write("\n")
os.mkdir(os.path.join(self.repo.path, "adir"))
with open(os.path.join(self.repo.path, "adir", "afile"), "w") as f:
f.write("\n")
cwd = os.getcwd()
try:
os.chdir(self.repo.path)
self.assertEqual(set(["foo", "blah", "adir", ".git"]), set(os.listdir(".")))
self.assertEqual(
(["foo", os.path.join("adir", "afile")], set()),
porcelain.add(self.repo.path),
)
finally:
os.chdir(cwd)
# Check that foo was added and nothing in .git was modified
index = self.repo.open_index()
self.assertEqual(sorted(index), [b"adir/afile", b"blah", b"foo"])
def test_add_default_paths_subdir(self):
os.mkdir(os.path.join(self.repo.path, "foo"))
with open(os.path.join(self.repo.path, "blah"), "w") as f:
f.write("\n")
with open(os.path.join(self.repo.path, "foo", "blie"), "w") as f:
f.write("\n")
cwd = os.getcwd()
try:
os.chdir(os.path.join(self.repo.path, "foo"))
porcelain.add(repo=self.repo.path)
porcelain.commit(
repo=self.repo.path,
message=b"test",
author=b"test <email>",
committer=b"test <email>",
)
finally:
os.chdir(cwd)
index = self.repo.open_index()
self.assertEqual(sorted(index), [b"foo/blie"])
def test_add_file(self):
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("BAR")
porcelain.add(self.repo.path, paths=[fullpath])
self.assertIn(b"foo", self.repo.open_index())
def test_add_ignored(self):
with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
f.write("foo\nsubdir/")
with open(os.path.join(self.repo.path, "foo"), "w") as f:
f.write("BAR")
with open(os.path.join(self.repo.path, "bar"), "w") as f:
f.write("BAR")
os.mkdir(os.path.join(self.repo.path, "subdir"))
with open(os.path.join(self.repo.path, "subdir", "baz"), "w") as f:
f.write("BAZ")
(added, ignored) = porcelain.add(
self.repo.path,
paths=[
os.path.join(self.repo.path, "foo"),
os.path.join(self.repo.path, "bar"),
os.path.join(self.repo.path, "subdir"),
],
)
self.assertIn(b"bar", self.repo.open_index())
self.assertEqual(set(["bar"]), set(added))
self.assertEqual(set(["foo", os.path.join("subdir", "")]), ignored)
def test_add_file_absolute_path(self):
# Absolute paths are (not yet) supported
with open(os.path.join(self.repo.path, "foo"), "w") as f:
f.write("BAR")
porcelain.add(self.repo, paths=[os.path.join(self.repo.path, "foo")])
self.assertIn(b"foo", self.repo.open_index())
def test_add_not_in_repo(self):
with open(os.path.join(self.test_dir, "foo"), "w") as f:
f.write("BAR")
self.assertRaises(
ValueError,
porcelain.add,
self.repo,
paths=[os.path.join(self.test_dir, "foo")],
)
self.assertRaises(
(ValueError, FileNotFoundError),
porcelain.add,
self.repo,
paths=["../foo"],
)
self.assertEqual([], list(self.repo.open_index()))
def test_add_file_clrf_conversion(self):
# Set the right configuration to the repo
c = self.repo.get_config()
c.set("core", "autocrlf", "input")
c.write_to_path()
# Add a file with CRLF line-ending
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "wb") as f:
f.write(b"line1\r\nline2")
porcelain.add(self.repo.path, paths=[fullpath])
# The line-endings should have been converted to LF
index = self.repo.open_index()
self.assertIn(b"foo", index)
entry = index[b"foo"]
blob = self.repo[entry.sha]
self.assertEqual(blob.data, b"line1\nline2")
class RemoveTests(PorcelainTestCase):
def test_remove_file(self):
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("BAR")
porcelain.add(self.repo.path, paths=[fullpath])
porcelain.commit(
repo=self.repo,
message=b"test",
author=b"test <email>",
committer=b"test <email>",
)
self.assertTrue(os.path.exists(os.path.join(self.repo.path, "foo")))
cwd = os.getcwd()
try:
os.chdir(self.repo.path)
porcelain.remove(self.repo.path, paths=["foo"])
finally:
os.chdir(cwd)
self.assertFalse(os.path.exists(os.path.join(self.repo.path, "foo")))
def test_remove_file_staged(self):
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("BAR")
cwd = os.getcwd()
try:
os.chdir(self.repo.path)
porcelain.add(self.repo.path, paths=[fullpath])
self.assertRaises(Exception, porcelain.rm, self.repo.path, paths=["foo"])
finally:
os.chdir(cwd)
def test_remove_file_removed_on_disk(self):
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("BAR")
porcelain.add(self.repo.path, paths=[fullpath])
cwd = os.getcwd()
try:
os.chdir(self.repo.path)
os.remove(fullpath)
porcelain.remove(self.repo.path, paths=["foo"])
finally:
os.chdir(cwd)
self.assertFalse(os.path.exists(os.path.join(self.repo.path, "foo")))
class LogTests(PorcelainTestCase):
def test_simple(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
outstream = StringIO()
porcelain.log(self.repo.path, outstream=outstream)
self.assertEqual(3, outstream.getvalue().count("-" * 50))
def test_max_entries(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
outstream = StringIO()
porcelain.log(self.repo.path, outstream=outstream, max_entries=1)
self.assertEqual(1, outstream.getvalue().count("-" * 50))
class ShowTests(PorcelainTestCase):
def test_nolist(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
outstream = StringIO()
porcelain.show(self.repo.path, objects=c3.id, outstream=outstream)
self.assertTrue(outstream.getvalue().startswith("-" * 50))
def test_simple(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
outstream = StringIO()
porcelain.show(self.repo.path, objects=[c3.id], outstream=outstream)
self.assertTrue(outstream.getvalue().startswith("-" * 50))
def test_blob(self):
b = Blob.from_string(b"The Foo\n")
self.repo.object_store.add_object(b)
outstream = StringIO()
porcelain.show(self.repo.path, objects=[b.id], outstream=outstream)
self.assertEqual(outstream.getvalue(), "The Foo\n")
def test_commit_no_parent(self):
a = Blob.from_string(b"The Foo\n")
ta = Tree()
ta.add(b"somename", 0o100644, a.id)
ca = make_commit(tree=ta.id)
self.repo.object_store.add_objects([(a, None), (ta, None), (ca, None)])
outstream = StringIO()
porcelain.show(self.repo.path, objects=[ca.id], outstream=outstream)
self.assertMultiLineEqual(
outstream.getvalue(),
"""\
--------------------------------------------------
commit: 344da06c1bb85901270b3e8875c988a027ec087d
Author: Test Author <test@nodomain.com>
Committer: Test Committer <test@nodomain.com>
Date: Fri Jan 01 2010 00:00:00 +0000
Test message.
diff --git a/somename b/somename
new file mode 100644
index 0000000..ea5c7bf
--- /dev/null
+++ b/somename
@@ -0,0 +1 @@
+The Foo
""",
)
def test_tag(self):
a = Blob.from_string(b"The Foo\n")
ta = Tree()
ta.add(b"somename", 0o100644, a.id)
ca = make_commit(tree=ta.id)
self.repo.object_store.add_objects([(a, None), (ta, None), (ca, None)])
porcelain.tag_create(
self.repo.path,
b"tryme",
b"foo <foo@bar.com>",
b"bar",
annotated=True,
objectish=ca.id,
tag_time=1552854211,
tag_timezone=0,
)
outstream = StringIO()
porcelain.show(self.repo, objects=[b"refs/tags/tryme"], outstream=outstream)
self.maxDiff = None
self.assertMultiLineEqual(
outstream.getvalue(),
"""\
Tagger: foo <foo@bar.com>
Date: Sun Mar 17 2019 20:23:31 +0000
bar
--------------------------------------------------
commit: 344da06c1bb85901270b3e8875c988a027ec087d
Author: Test Author <test@nodomain.com>
Committer: Test Committer <test@nodomain.com>
Date: Fri Jan 01 2010 00:00:00 +0000
Test message.
diff --git a/somename b/somename
new file mode 100644
index 0000000..ea5c7bf
--- /dev/null
+++ b/somename
@@ -0,0 +1 @@
+The Foo
""",
)
def test_commit_with_change(self):
a = Blob.from_string(b"The Foo\n")
ta = Tree()
ta.add(b"somename", 0o100644, a.id)
ca = make_commit(tree=ta.id)
b = Blob.from_string(b"The Bar\n")
tb = Tree()
tb.add(b"somename", 0o100644, b.id)
cb = make_commit(tree=tb.id, parents=[ca.id])
self.repo.object_store.add_objects(
[
(a, None),
(b, None),
(ta, None),
(tb, None),
(ca, None),
(cb, None),
]
)
outstream = StringIO()
porcelain.show(self.repo.path, objects=[cb.id], outstream=outstream)
self.assertMultiLineEqual(
outstream.getvalue(),
"""\
--------------------------------------------------
commit: 2c6b6c9cb72c130956657e1fdae58e5b103744fa
Author: Test Author <test@nodomain.com>
Committer: Test Committer <test@nodomain.com>
Date: Fri Jan 01 2010 00:00:00 +0000
Test message.
diff --git a/somename b/somename
index ea5c7bf..fd38bcb 100644
--- a/somename
+++ b/somename
@@ -1 +1 @@
-The Foo
+The Bar
""",
)
class SymbolicRefTests(PorcelainTestCase):
def test_set_wrong_symbolic_ref(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
self.assertRaises(
porcelain.Error, porcelain.symbolic_ref, self.repo.path, b"foobar"
)
def test_set_force_wrong_symbolic_ref(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
porcelain.symbolic_ref(self.repo.path, b"force_foobar", force=True)
# test if we actually changed the file
with self.repo.get_named_file("HEAD") as f:
new_ref = f.read()
self.assertEqual(new_ref, b"ref: refs/heads/force_foobar\n")
def test_set_symbolic_ref(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
porcelain.symbolic_ref(self.repo.path, b"master")
def test_set_symbolic_ref_other_than_master(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store,
[[1], [2, 1], [3, 1, 2]],
attrs=dict(refs="develop"),
)
self.repo.refs[b"HEAD"] = c3.id
self.repo.refs[b"refs/heads/develop"] = c3.id
porcelain.symbolic_ref(self.repo.path, b"develop")
# test if we actually changed the file
with self.repo.get_named_file("HEAD") as f:
new_ref = f.read()
self.assertEqual(new_ref, b"ref: refs/heads/develop\n")
class DiffTreeTests(PorcelainTestCase):
def test_empty(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
outstream = BytesIO()
porcelain.diff_tree(self.repo.path, c2.tree, c3.tree, outstream=outstream)
self.assertEqual(outstream.getvalue(), b"")
class CommitTreeTests(PorcelainTestCase):
def test_simple(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
b = Blob()
b.data = b"foo the bar"
t = Tree()
t.add(b"somename", 0o100644, b.id)
self.repo.object_store.add_object(t)
self.repo.object_store.add_object(b)
sha = porcelain.commit_tree(
self.repo.path,
t.id,
message=b"Withcommit.",
author=b"Joe <joe@example.com>",
committer=b"Jane <jane@example.com>",
)
self.assertTrue(isinstance(sha, bytes))
self.assertEqual(len(sha), 40)
class RevListTests(PorcelainTestCase):
def test_simple(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
outstream = BytesIO()
porcelain.rev_list(self.repo.path, [c3.id], outstream=outstream)
self.assertEqual(
c3.id + b"\n" + c2.id + b"\n" + c1.id + b"\n", outstream.getvalue()
)
@skipIf(platform.python_implementation() == "PyPy" or sys.platform == "win32", "gpgme not easily available or supported on Windows and PyPy")
class TagCreateSignTests(PorcelainGpgTestCase):
def test_default_key(self):
import gpg
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
cfg = self.repo.get_config()
cfg.set(("user",), "signingKey", PorcelainGpgTestCase.DEFAULT_KEY_ID)
self.import_default_key()
porcelain.tag_create(
self.repo.path,
b"tryme",
b"foo <foo@bar.com>",
b"bar",
annotated=True,
sign=True,
)
tags = self.repo.refs.as_dict(b"refs/tags")
self.assertEqual(list(tags.keys()), [b"tryme"])
tag = self.repo[b"refs/tags/tryme"]
self.assertTrue(isinstance(tag, Tag))
self.assertEqual(b"foo <foo@bar.com>", tag.tagger)
self.assertEqual(b"bar\n", tag.message)
self.assertLess(time.time() - tag.tag_time, 5)
tag = self.repo[b'refs/tags/tryme']
# GPG Signatures aren't deterministic, so we can't do a static assertion.
tag.verify()
tag.verify(keyids=[PorcelainGpgTestCase.DEFAULT_KEY_ID])
self.import_non_default_key()
self.assertRaises(
gpg.errors.MissingSignatures,
tag.verify,
keyids=[PorcelainGpgTestCase.NON_DEFAULT_KEY_ID],
)
tag._chunked_text = [b"bad data", tag._signature]
self.assertRaises(
gpg.errors.BadSignatures,
tag.verify,
)
def test_non_default_key(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
cfg = self.repo.get_config()
cfg.set(("user",), "signingKey", PorcelainGpgTestCase.DEFAULT_KEY_ID)
self.import_non_default_key()
porcelain.tag_create(
self.repo.path,
b"tryme",
b"foo <foo@bar.com>",
b"bar",
annotated=True,
sign=PorcelainGpgTestCase.NON_DEFAULT_KEY_ID,
)
tags = self.repo.refs.as_dict(b"refs/tags")
self.assertEqual(list(tags.keys()), [b"tryme"])
tag = self.repo[b"refs/tags/tryme"]
self.assertTrue(isinstance(tag, Tag))
self.assertEqual(b"foo <foo@bar.com>", tag.tagger)
self.assertEqual(b"bar\n", tag.message)
self.assertLess(time.time() - tag.tag_time, 5)
tag = self.repo[b'refs/tags/tryme']
# GPG Signatures aren't deterministic, so we can't do a static assertion.
tag.verify()
class TagCreateTests(PorcelainTestCase):
def test_annotated(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
porcelain.tag_create(
self.repo.path,
b"tryme",
b"foo <foo@bar.com>",
b"bar",
annotated=True,
)
tags = self.repo.refs.as_dict(b"refs/tags")
self.assertEqual(list(tags.keys()), [b"tryme"])
tag = self.repo[b"refs/tags/tryme"]
self.assertTrue(isinstance(tag, Tag))
self.assertEqual(b"foo <foo@bar.com>", tag.tagger)
self.assertEqual(b"bar\n", tag.message)
self.assertLess(time.time() - tag.tag_time, 5)
def test_unannotated(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
porcelain.tag_create(self.repo.path, b"tryme", annotated=False)
tags = self.repo.refs.as_dict(b"refs/tags")
self.assertEqual(list(tags.keys()), [b"tryme"])
self.repo[b"refs/tags/tryme"]
self.assertEqual(list(tags.values()), [self.repo.head()])
def test_unannotated_unicode(self):
c1, c2, c3 = build_commit_graph(
self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
)
self.repo.refs[b"HEAD"] = c3.id
porcelain.tag_create(self.repo.path, "tryme", annotated=False)
tags = self.repo.refs.as_dict(b"refs/tags")
self.assertEqual(list(tags.keys()), [b"tryme"])
self.repo[b"refs/tags/tryme"]
self.assertEqual(list(tags.values()), [self.repo.head()])
class TagListTests(PorcelainTestCase):
def test_empty(self):
tags = porcelain.tag_list(self.repo.path)
self.assertEqual([], tags)
def test_simple(self):
self.repo.refs[b"refs/tags/foo"] = b"aa" * 20
self.repo.refs[b"refs/tags/bar/bla"] = b"bb" * 20
tags = porcelain.tag_list(self.repo.path)
self.assertEqual([b"bar/bla", b"foo"], tags)
class TagDeleteTests(PorcelainTestCase):
def test_simple(self):
[c1] = build_commit_graph(self.repo.object_store, [[1]])
self.repo[b"HEAD"] = c1.id
porcelain.tag_create(self.repo, b"foo")
self.assertTrue(b"foo" in porcelain.tag_list(self.repo))
porcelain.tag_delete(self.repo, b"foo")
self.assertFalse(b"foo" in porcelain.tag_list(self.repo))
class ResetTests(PorcelainTestCase):
def test_hard_head(self):
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("BAR")
porcelain.add(self.repo.path, paths=[fullpath])
porcelain.commit(
self.repo.path,
message=b"Some message",
committer=b"Jane <jane@example.com>",
author=b"John <john@example.com>",
)
with open(os.path.join(self.repo.path, "foo"), "wb") as f:
f.write(b"OOH")
porcelain.reset(self.repo, "hard", b"HEAD")
index = self.repo.open_index()
changes = list(
tree_changes(
self.repo,
index.commit(self.repo.object_store),
self.repo[b"HEAD"].tree,
)
)
self.assertEqual([], changes)
def test_hard_commit(self):
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("BAR")
porcelain.add(self.repo.path, paths=[fullpath])
sha = porcelain.commit(
self.repo.path,
message=b"Some message",
committer=b"Jane <jane@example.com>",
author=b"John <john@example.com>",
)
with open(fullpath, "wb") as f:
f.write(b"BAZ")
porcelain.add(self.repo.path, paths=[fullpath])
porcelain.commit(
self.repo.path,
message=b"Some other message",
committer=b"Jane <jane@example.com>",
author=b"John <john@example.com>",
)
porcelain.reset(self.repo, "hard", sha)
index = self.repo.open_index()
changes = list(
tree_changes(
self.repo,
index.commit(self.repo.object_store),
self.repo[sha].tree,
)
)
self.assertEqual([], changes)
class ResetFileTests(PorcelainTestCase):
def test_reset_modify_file_to_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])
sha = 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')
porcelain.reset_file(self.repo, file, target=sha)
with open(full_path, 'r') as f:
self.assertEqual('hello', f.read())
def test_reset_remove_file_to_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])
sha = porcelain.commit(
self.repo,
message=b"unitest",
committer=b"Jane <jane@example.com>",
author=b"John <john@example.com>",
)
os.remove(full_path)
porcelain.reset_file(self.repo, file, target=sha)
with open(full_path, 'r') as f:
self.assertEqual('hello', f.read())
def test_resetfile_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])
sha = 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')
porcelain.commit(
self.repo,
message=b"unitest 2",
committer=b"Jane <jane@example.com>",
author=b"John <john@example.com>",
)
porcelain.reset_file(self.repo, os.path.join('new_dir', 'foo'), target=sha)
with open(full_path, 'r') as f:
self.assertEqual('hello', f.read())
class PushTests(PorcelainTestCase):
def test_simple(self):
"""
Basic test of porcelain push where self.repo is the remote. First
clone the remote, commit a file to the clone, then push the changes
back to the remote.
"""
outstream = BytesIO()
errstream = BytesIO()
porcelain.commit(
repo=self.repo.path,
message=b"init",
author=b"author <email>",
committer=b"committer <email>",
)
# Setup target repo cloned from temp test repo
clone_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, clone_path)
target_repo = porcelain.clone(
self.repo.path, target=clone_path, errstream=errstream
)
try:
self.assertEqual(target_repo[b"HEAD"], self.repo[b"HEAD"])
finally:
target_repo.close()
# create a second file to be pushed back to origin
handle, fullpath = tempfile.mkstemp(dir=clone_path)
os.close(handle)
porcelain.add(repo=clone_path, paths=[fullpath])
porcelain.commit(
repo=clone_path,
message=b"push",
author=b"author <email>",
committer=b"committer <email>",
)
# Setup a non-checked out branch in the remote
refs_path = b"refs/heads/foo"
new_id = self.repo[b"HEAD"].id
self.assertNotEqual(new_id, ZERO_SHA)
self.repo.refs[refs_path] = new_id
# Push to the remote
porcelain.push(
clone_path,
"origin",
b"HEAD:" + refs_path,
outstream=outstream,
errstream=errstream,
)
self.assertEqual(
target_repo.refs[b"refs/remotes/origin/foo"],
target_repo.refs[b"HEAD"],
)
# Check that the target and source
with Repo(clone_path) as r_clone:
self.assertEqual(
{
b"HEAD": new_id,
b"refs/heads/foo": r_clone[b"HEAD"].id,
b"refs/heads/master": new_id,
},
self.repo.get_refs(),
)
self.assertEqual(r_clone[b"HEAD"].id, self.repo[refs_path].id)
# Get the change in the target repo corresponding to the add
# this will be in the foo branch.
change = list(
tree_changes(
self.repo,
self.repo[b"HEAD"].tree,
self.repo[b"refs/heads/foo"].tree,
)
)[0]
self.assertEqual(
os.path.basename(fullpath), change.new.path.decode("ascii")
)
def test_local_missing(self):
"""Pushing a new branch."""
outstream = BytesIO()
errstream = BytesIO()
# Setup target repo cloned from temp test repo
clone_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, clone_path)
target_repo = porcelain.init(clone_path)
target_repo.close()
self.assertRaises(
porcelain.Error,
porcelain.push,
self.repo,
clone_path,
b"HEAD:refs/heads/master",
outstream=outstream,
errstream=errstream,
)
def test_new(self):
"""Pushing a new branch."""
outstream = BytesIO()
errstream = BytesIO()
# Setup target repo cloned from temp test repo
clone_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, clone_path)
target_repo = porcelain.init(clone_path)
target_repo.close()
# create a second file to be pushed back to origin
handle, fullpath = tempfile.mkstemp(dir=clone_path)
os.close(handle)
porcelain.add(repo=clone_path, paths=[fullpath])
new_id = porcelain.commit(
repo=self.repo,
message=b"push",
author=b"author <email>",
committer=b"committer <email>",
)
# Push to the remote
porcelain.push(
self.repo,
clone_path,
b"HEAD:refs/heads/master",
outstream=outstream,
errstream=errstream,
)
with Repo(clone_path) as r_clone:
self.assertEqual(
{
b"HEAD": new_id,
b"refs/heads/master": new_id,
},
r_clone.get_refs(),
)
def test_delete(self):
"""Basic test of porcelain push, removing a branch."""
outstream = BytesIO()
errstream = BytesIO()
porcelain.commit(
repo=self.repo.path,
message=b"init",
author=b"author <email>",
committer=b"committer <email>",
)
# Setup target repo cloned from temp test repo
clone_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, clone_path)
target_repo = porcelain.clone(
self.repo.path, target=clone_path, errstream=errstream
)
target_repo.close()
# Setup a non-checked out branch in the remote
refs_path = b"refs/heads/foo"
new_id = self.repo[b"HEAD"].id
self.assertNotEqual(new_id, ZERO_SHA)
self.repo.refs[refs_path] = new_id
# Push to the remote
porcelain.push(
clone_path,
self.repo.path,
b":" + refs_path,
outstream=outstream,
errstream=errstream,
)
self.assertEqual(
{
b"HEAD": new_id,
b"refs/heads/master": new_id,
},
self.repo.get_refs(),
)
def test_diverged(self):
outstream = BytesIO()
errstream = BytesIO()
porcelain.commit(
repo=self.repo.path,
message=b"init",
author=b"author <email>",
committer=b"committer <email>",
)
# Setup target repo cloned from temp test repo
clone_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, clone_path)
target_repo = porcelain.clone(
self.repo.path, target=clone_path, errstream=errstream
)
target_repo.close()
remote_id = porcelain.commit(
repo=self.repo.path,
message=b"remote change",
author=b"author <email>",
committer=b"committer <email>",
)
local_id = porcelain.commit(
repo=clone_path,
message=b"local change",
author=b"author <email>",
committer=b"committer <email>",
)
outstream = BytesIO()
errstream = BytesIO()
# Push to the remote
self.assertRaises(
porcelain.DivergedBranches,
porcelain.push,
clone_path,
self.repo.path,
b"refs/heads/master",
outstream=outstream,
errstream=errstream,
)
self.assertEqual(
{
b"HEAD": remote_id,
b"refs/heads/master": remote_id,
},
self.repo.get_refs(),
)
self.assertEqual(b"", outstream.getvalue())
self.assertEqual(b"", errstream.getvalue())
outstream = BytesIO()
errstream = BytesIO()
# Push to the remote with --force
porcelain.push(
clone_path,
self.repo.path,
b"refs/heads/master",
outstream=outstream,
errstream=errstream,
force=True,
)
self.assertEqual(
{
b"HEAD": local_id,
b"refs/heads/master": local_id,
},
self.repo.get_refs(),
)
self.assertEqual(b"", outstream.getvalue())
self.assertTrue(re.match(b"Push to .* successful.\n", errstream.getvalue()))
class PullTests(PorcelainTestCase):
def setUp(self):
super(PullTests, self).setUp()
# create a file for initial commit
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(
repo=self.repo.path,
message=b"test",
author=b"test <email>",
committer=b"test <email>",
)
# Setup target repo
self.target_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, self.target_path)
target_repo = porcelain.clone(
self.repo.path, target=self.target_path, errstream=BytesIO()
)
target_repo.close()
# create a second file to be pushed
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(
repo=self.repo.path,
message=b"test2",
author=b"test2 <email>",
committer=b"test2 <email>",
)
self.assertIn(b"refs/heads/master", self.repo.refs)
self.assertIn(b"refs/heads/master", target_repo.refs)
def test_simple(self):
outstream = BytesIO()
errstream = BytesIO()
# Pull changes into the cloned repo
porcelain.pull(
self.target_path,
self.repo.path,
b"refs/heads/master",
outstream=outstream,
errstream=errstream,
)
# Check the target repo for pushed changes
with Repo(self.target_path) as r:
self.assertEqual(r[b"HEAD"].id, self.repo[b"HEAD"].id)
def test_diverged(self):
outstream = BytesIO()
errstream = BytesIO()
c3a = porcelain.commit(
repo=self.target_path,
message=b"test3a",
author=b"test2 <email>",
committer=b"test2 <email>",
)
porcelain.commit(
repo=self.repo.path,
message=b"test3b",
author=b"test2 <email>",
committer=b"test2 <email>",
)
# Pull changes into the cloned repo
self.assertRaises(
porcelain.DivergedBranches,
porcelain.pull,
self.target_path,
self.repo.path,
b"refs/heads/master",
outstream=outstream,
errstream=errstream,
)
# Check the target repo for pushed changes
with Repo(self.target_path) as r:
self.assertEqual(r[b"refs/heads/master"].id, c3a)
self.assertRaises(
NotImplementedError,
porcelain.pull,
self.target_path,
self.repo.path,
b"refs/heads/master",
outstream=outstream,
errstream=errstream,
fast_forward=False,
)
# Check the target repo for pushed changes
with Repo(self.target_path) as r:
self.assertEqual(r[b"refs/heads/master"].id, c3a)
def test_no_refspec(self):
outstream = BytesIO()
errstream = BytesIO()
# Pull changes into the cloned repo
porcelain.pull(
self.target_path,
self.repo.path,
outstream=outstream,
errstream=errstream,
)
# Check the target repo for pushed changes
with Repo(self.target_path) as r:
self.assertEqual(r[b"HEAD"].id, self.repo[b"HEAD"].id)
def test_no_remote_location(self):
outstream = BytesIO()
errstream = BytesIO()
# Pull changes into the cloned repo
porcelain.pull(
self.target_path,
refspecs=b"refs/heads/master",
outstream=outstream,
errstream=errstream,
)
# Check the target repo for pushed changes
with Repo(self.target_path) as r:
self.assertEqual(r[b"HEAD"].id, self.repo[b"HEAD"].id)
class StatusTests(PorcelainTestCase):
def test_empty(self):
results = porcelain.status(self.repo)
self.assertEqual({"add": [], "delete": [], "modify": []}, results.staged)
self.assertEqual([], results.unstaged)
def test_status_base(self):
"""Integration test for `status` functionality."""
# Commit a dummy file then modify it
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("origstuff")
porcelain.add(repo=self.repo.path, paths=[fullpath])
porcelain.commit(
repo=self.repo.path,
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
# modify access and modify time of path
os.utime(fullpath, (0, 0))
with open(fullpath, "wb") as f:
f.write(b"stuff")
# Make a dummy file and stage it
filename_add = "bar"
fullpath = os.path.join(self.repo.path, filename_add)
with open(fullpath, "w") as f:
f.write("stuff")
porcelain.add(repo=self.repo.path, paths=fullpath)
results = porcelain.status(self.repo)
self.assertEqual(results.staged["add"][0], filename_add.encode("ascii"))
self.assertEqual(results.unstaged, [b"foo"])
def test_status_all(self):
del_path = os.path.join(self.repo.path, "foo")
mod_path = os.path.join(self.repo.path, "bar")
add_path = os.path.join(self.repo.path, "baz")
us_path = os.path.join(self.repo.path, "blye")
ut_path = os.path.join(self.repo.path, "blyat")
with open(del_path, "w") as f:
f.write("origstuff")
with open(mod_path, "w") as f:
f.write("origstuff")
with open(us_path, "w") as f:
f.write("origstuff")
porcelain.add(repo=self.repo.path, paths=[del_path, mod_path, us_path])
porcelain.commit(
repo=self.repo.path,
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
porcelain.remove(self.repo.path, [del_path])
with open(add_path, "w") as f:
f.write("origstuff")
with open(mod_path, "w") as f:
f.write("more_origstuff")
with open(us_path, "w") as f:
f.write("more_origstuff")
porcelain.add(repo=self.repo.path, paths=[add_path, mod_path])
with open(us_path, "w") as f:
f.write("\norigstuff")
with open(ut_path, "w") as f:
f.write("origstuff")
results = porcelain.status(self.repo.path)
self.assertDictEqual(
{"add": [b"baz"], "delete": [b"foo"], "modify": [b"bar"]},
results.staged,
)
self.assertListEqual(results.unstaged, [b"blye"])
self.assertListEqual(results.untracked, ["blyat"])
def test_status_crlf_mismatch(self):
# First make a commit as if the file has been added on a Linux system
# or with core.autocrlf=True
file_path = os.path.join(self.repo.path, "crlf")
with open(file_path, "wb") as f:
f.write(b"line1\nline2")
porcelain.add(repo=self.repo.path, paths=[file_path])
porcelain.commit(
repo=self.repo.path,
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
# Then update the file as if it was created by CGit on a Windows
# system with core.autocrlf=true
with open(file_path, "wb") as f:
f.write(b"line1\r\nline2")
results = porcelain.status(self.repo)
self.assertDictEqual({"add": [], "delete": [], "modify": []}, results.staged)
self.assertListEqual(results.unstaged, [b"crlf"])
self.assertListEqual(results.untracked, [])
def test_status_autocrlf_true(self):
# First make a commit as if the file has been added on a Linux system
# or with core.autocrlf=True
file_path = os.path.join(self.repo.path, "crlf")
with open(file_path, "wb") as f:
f.write(b"line1\nline2")
porcelain.add(repo=self.repo.path, paths=[file_path])
porcelain.commit(
repo=self.repo.path,
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
# Then update the file as if it was created by CGit on a Windows
# system with core.autocrlf=true
with open(file_path, "wb") as f:
f.write(b"line1\r\nline2")
# TODO: It should be set automatically by looking at the configuration
c = self.repo.get_config()
c.set("core", "autocrlf", True)
c.write_to_path()
results = porcelain.status(self.repo)
self.assertDictEqual({"add": [], "delete": [], "modify": []}, results.staged)
self.assertListEqual(results.unstaged, [])
self.assertListEqual(results.untracked, [])
def test_status_autocrlf_input(self):
# Commit existing file with CRLF
file_path = os.path.join(self.repo.path, "crlf-exists")
with open(file_path, "wb") as f:
f.write(b"line1\r\nline2")
porcelain.add(repo=self.repo.path, paths=[file_path])
porcelain.commit(
repo=self.repo.path,
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
c = self.repo.get_config()
c.set("core", "autocrlf", "input")
c.write_to_path()
# Add new (untracked) file
file_path = os.path.join(self.repo.path, "crlf-new")
with open(file_path, "wb") as f:
f.write(b"line1\r\nline2")
porcelain.add(repo=self.repo.path, paths=[file_path])
results = porcelain.status(self.repo)
self.assertDictEqual({"add": [b"crlf-new"], "delete": [], "modify": []}, results.staged)
self.assertListEqual(results.unstaged, [])
self.assertListEqual(results.untracked, [])
def test_get_tree_changes_add(self):
"""Unit test for get_tree_changes add."""
# Make a dummy file, stage
filename = "bar"
fullpath = os.path.join(self.repo.path, filename)
with open(fullpath, "w") as f:
f.write("stuff")
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(
repo=self.repo.path,
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
filename = "foo"
fullpath = os.path.join(self.repo.path, filename)
with open(fullpath, "w") as f:
f.write("stuff")
porcelain.add(repo=self.repo.path, paths=fullpath)
changes = porcelain.get_tree_changes(self.repo.path)
self.assertEqual(changes["add"][0], filename.encode("ascii"))
self.assertEqual(len(changes["add"]), 1)
self.assertEqual(len(changes["modify"]), 0)
self.assertEqual(len(changes["delete"]), 0)
def test_get_tree_changes_modify(self):
"""Unit test for get_tree_changes modify."""
# Make a dummy file, stage, commit, modify
filename = "foo"
fullpath = os.path.join(self.repo.path, filename)
with open(fullpath, "w") as f:
f.write("stuff")
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(
repo=self.repo.path,
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
with open(fullpath, "w") as f:
f.write("otherstuff")
porcelain.add(repo=self.repo.path, paths=fullpath)
changes = porcelain.get_tree_changes(self.repo.path)
self.assertEqual(changes["modify"][0], filename.encode("ascii"))
self.assertEqual(len(changes["add"]), 0)
self.assertEqual(len(changes["modify"]), 1)
self.assertEqual(len(changes["delete"]), 0)
def test_get_tree_changes_delete(self):
"""Unit test for get_tree_changes delete."""
# Make a dummy file, stage, commit, remove
filename = "foo"
fullpath = os.path.join(self.repo.path, filename)
with open(fullpath, "w") as f:
f.write("stuff")
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(
repo=self.repo.path,
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
cwd = os.getcwd()
try:
os.chdir(self.repo.path)
porcelain.remove(repo=self.repo.path, paths=[filename])
finally:
os.chdir(cwd)
changes = porcelain.get_tree_changes(self.repo.path)
self.assertEqual(changes["delete"][0], filename.encode("ascii"))
self.assertEqual(len(changes["add"]), 0)
self.assertEqual(len(changes["modify"]), 0)
self.assertEqual(len(changes["delete"]), 1)
def test_get_untracked_paths(self):
with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
f.write("ignored\n")
with open(os.path.join(self.repo.path, "ignored"), "w") as f:
f.write("blah\n")
with open(os.path.join(self.repo.path, "notignored"), "w") as f:
f.write("blah\n")
os.symlink(
os.path.join(self.repo.path, os.pardir, "external_target"),
os.path.join(self.repo.path, "link"),
)
self.assertEqual(
set(["ignored", "notignored", ".gitignore", "link"]),
set(
porcelain.get_untracked_paths(
self.repo.path, self.repo.path, self.repo.open_index()
)
),
)
self.assertEqual(
set([".gitignore", "notignored", "link"]),
set(porcelain.status(self.repo).untracked),
)
self.assertEqual(
set([".gitignore", "notignored", "ignored", "link"]),
set(porcelain.status(self.repo, ignored=True).untracked),
)
def test_get_untracked_paths_subrepo(self):
with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
f.write("nested/\n")
with open(os.path.join(self.repo.path, "notignored"), "w") as f:
f.write("blah\n")
subrepo = Repo.init(os.path.join(self.repo.path, "nested"), mkdir=True)
with open(os.path.join(subrepo.path, "ignored"), "w") as f:
f.write("bleep\n")
with open(os.path.join(subrepo.path, "with"), "w") as f:
f.write("bloop\n")
with open(os.path.join(subrepo.path, "manager"), "w") as f:
f.write("blop\n")
self.assertEqual(
set([".gitignore", "notignored", os.path.join("nested", "")]),
set(
porcelain.get_untracked_paths(
self.repo.path, self.repo.path, self.repo.open_index()
)
),
)
self.assertEqual(
set([".gitignore", "notignored"]),
set(
porcelain.get_untracked_paths(
self.repo.path,
self.repo.path,
self.repo.open_index(),
exclude_ignored=True,
)
),
)
self.assertEqual(
set(["ignored", "with", "manager"]),
set(
porcelain.get_untracked_paths(
subrepo.path, subrepo.path, subrepo.open_index()
)
),
)
self.assertEqual(
set(),
set(
porcelain.get_untracked_paths(
subrepo.path,
self.repo.path,
self.repo.open_index(),
)
),
)
self.assertEqual(
set([os.path.join('nested', 'ignored'),
os.path.join('nested', 'with'),
os.path.join('nested', 'manager')]),
set(
porcelain.get_untracked_paths(
self.repo.path,
subrepo.path,
self.repo.open_index(),
)
),
)
def test_get_untracked_paths_subdir(self):
with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
f.write("subdir/\nignored")
with open(os.path.join(self.repo.path, "notignored"), "w") as f:
f.write("blah\n")
os.mkdir(os.path.join(self.repo.path, "subdir"))
with open(os.path.join(self.repo.path, "ignored"), "w") as f:
f.write("foo")
with open(os.path.join(self.repo.path, "subdir", "ignored"), "w") as f:
f.write("foo")
self.assertEqual(
set(
[
".gitignore",
"notignored",
"ignored",
os.path.join("subdir", ""),
]
),
set(
porcelain.get_untracked_paths(
self.repo.path,
self.repo.path,
self.repo.open_index(),
)
)
)
self.assertEqual(
set([".gitignore", "notignored"]),
set(
porcelain.get_untracked_paths(
self.repo.path,
self.repo.path,
self.repo.open_index(),
exclude_ignored=True,
)
)
)
# TODO(jelmer): Add test for dulwich.porcelain.daemon
class UploadPackTests(PorcelainTestCase):
"""Tests for upload_pack."""
def test_upload_pack(self):
outf = BytesIO()
exitcode = porcelain.upload_pack(self.repo.path, BytesIO(b"0000"), outf)
outlines = outf.getvalue().splitlines()
self.assertEqual([b"0000"], outlines)
self.assertEqual(0, exitcode)
class ReceivePackTests(PorcelainTestCase):
"""Tests for receive_pack."""
def test_receive_pack(self):
filename = "foo"
fullpath = os.path.join(self.repo.path, filename)
with open(fullpath, "w") as f:
f.write("stuff")
porcelain.add(repo=self.repo.path, paths=fullpath)
self.repo.do_commit(
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
author_timestamp=1402354300,
commit_timestamp=1402354300,
author_timezone=0,
commit_timezone=0,
)
outf = BytesIO()
exitcode = porcelain.receive_pack(self.repo.path, BytesIO(b"0000"), outf)
outlines = outf.getvalue().splitlines()
self.assertEqual(
[
b"0091319b56ce3aee2d489f759736a79cc552c9bb86d9 HEAD\x00 report-status " # noqa: E501
b"delete-refs quiet ofs-delta side-band-64k "
b"no-done symref=HEAD:refs/heads/master",
b"003f319b56ce3aee2d489f759736a79cc552c9bb86d9 refs/heads/master",
b"0000",
],
outlines,
)
self.assertEqual(0, exitcode)
class BranchListTests(PorcelainTestCase):
def test_standard(self):
self.assertEqual(set([]), set(porcelain.branch_list(self.repo)))
def test_new_branch(self):
[c1] = build_commit_graph(self.repo.object_store, [[1]])
self.repo[b"HEAD"] = c1.id
porcelain.branch_create(self.repo, b"foo")
self.assertEqual(
set([b"master", b"foo"]), set(porcelain.branch_list(self.repo))
)
class BranchCreateTests(PorcelainTestCase):
def test_branch_exists(self):
[c1] = build_commit_graph(self.repo.object_store, [[1]])
self.repo[b"HEAD"] = c1.id
porcelain.branch_create(self.repo, b"foo")
self.assertRaises(porcelain.Error, porcelain.branch_create, self.repo, b"foo")
porcelain.branch_create(self.repo, b"foo", force=True)
def test_new_branch(self):
[c1] = build_commit_graph(self.repo.object_store, [[1]])
self.repo[b"HEAD"] = c1.id
porcelain.branch_create(self.repo, b"foo")
self.assertEqual(
set([b"master", b"foo"]), set(porcelain.branch_list(self.repo))
)
class BranchDeleteTests(PorcelainTestCase):
def test_simple(self):
[c1] = build_commit_graph(self.repo.object_store, [[1]])
self.repo[b"HEAD"] = c1.id
porcelain.branch_create(self.repo, b"foo")
self.assertTrue(b"foo" in porcelain.branch_list(self.repo))
porcelain.branch_delete(self.repo, b"foo")
self.assertFalse(b"foo" in porcelain.branch_list(self.repo))
def test_simple_unicode(self):
[c1] = build_commit_graph(self.repo.object_store, [[1]])
self.repo[b"HEAD"] = c1.id
porcelain.branch_create(self.repo, "foo")
self.assertTrue(b"foo" in porcelain.branch_list(self.repo))
porcelain.branch_delete(self.repo, "foo")
self.assertFalse(b"foo" in porcelain.branch_list(self.repo))
class FetchTests(PorcelainTestCase):
def test_simple(self):
outstream = BytesIO()
errstream = BytesIO()
# create a file for initial commit
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(
repo=self.repo.path,
message=b"test",
author=b"test <email>",
committer=b"test <email>",
)
# Setup target repo
target_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, target_path)
target_repo = porcelain.clone(
self.repo.path, target=target_path, errstream=errstream
)
# create a second file to be pushed
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(
repo=self.repo.path,
message=b"test2",
author=b"test2 <email>",
committer=b"test2 <email>",
)
self.assertFalse(self.repo[b"HEAD"].id in target_repo)
target_repo.close()
# Fetch changes into the cloned repo
porcelain.fetch(target_path, "origin", outstream=outstream, errstream=errstream)
# Assert that fetch updated the local image of the remote
self.assert_correct_remote_refs(target_repo.get_refs(), self.repo.get_refs())
# Check the target repo for pushed changes
with Repo(target_path) as r:
self.assertTrue(self.repo[b"HEAD"].id in r)
def test_with_remote_name(self):
remote_name = "origin"
outstream = BytesIO()
errstream = BytesIO()
# create a file for initial commit
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(
repo=self.repo.path,
message=b"test",
author=b"test <email>",
committer=b"test <email>",
)
# Setup target repo
target_path = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, target_path)
target_repo = porcelain.clone(
self.repo.path, target=target_path, errstream=errstream
)
# Capture current refs
target_refs = target_repo.get_refs()
# create a second file to be pushed
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.commit(
repo=self.repo.path,
message=b"test2",
author=b"test2 <email>",
committer=b"test2 <email>",
)
self.assertFalse(self.repo[b"HEAD"].id in target_repo)
target_config = target_repo.get_config()
target_config.set(
(b"remote", remote_name.encode()), b"url", self.repo.path.encode()
)
target_repo.close()
# Fetch changes into the cloned repo
porcelain.fetch(
target_path, remote_name, outstream=outstream, errstream=errstream
)
# Assert that fetch updated the local image of the remote
self.assert_correct_remote_refs(target_repo.get_refs(), self.repo.get_refs())
# Check the target repo for pushed changes, as well as updates
# for the refs
with Repo(target_path) as r:
self.assertTrue(self.repo[b"HEAD"].id in r)
self.assertNotEqual(self.repo.get_refs(), target_refs)
def assert_correct_remote_refs(
self, local_refs, remote_refs, remote_name=b"origin"
):
"""Assert that known remote refs corresponds to actual remote refs."""
local_ref_prefix = b"refs/heads"
remote_ref_prefix = b"refs/remotes/" + remote_name
locally_known_remote_refs = {
k[len(remote_ref_prefix) + 1 :]: v
for k, v in local_refs.items()
if k.startswith(remote_ref_prefix)
}
normalized_remote_refs = {
k[len(local_ref_prefix) + 1 :]: v
for k, v in remote_refs.items()
if k.startswith(local_ref_prefix)
}
+ if b"HEAD" in locally_known_remote_refs and b"HEAD" in remote_refs:
+ normalized_remote_refs[b"HEAD"] = remote_refs[b"HEAD"]
self.assertEqual(locally_known_remote_refs, normalized_remote_refs)
class RepackTests(PorcelainTestCase):
def test_empty(self):
porcelain.repack(self.repo)
def test_simple(self):
handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
os.close(handle)
porcelain.add(repo=self.repo.path, paths=fullpath)
porcelain.repack(self.repo)
class LsTreeTests(PorcelainTestCase):
def test_empty(self):
porcelain.commit(
repo=self.repo.path,
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
f = StringIO()
porcelain.ls_tree(self.repo, b"HEAD", outstream=f)
self.assertEqual(f.getvalue(), "")
def test_simple(self):
# Commit a dummy file then modify it
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("origstuff")
porcelain.add(repo=self.repo.path, paths=[fullpath])
porcelain.commit(
repo=self.repo.path,
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
f = StringIO()
porcelain.ls_tree(self.repo, b"HEAD", outstream=f)
self.assertEqual(
f.getvalue(),
"100644 blob 8b82634d7eae019850bb883f06abf428c58bc9aa\tfoo\n",
)
def test_recursive(self):
# Create a directory then write a dummy file in it
dirpath = os.path.join(self.repo.path, "adir")
filepath = os.path.join(dirpath, "afile")
os.mkdir(dirpath)
with open(filepath, "w") as f:
f.write("origstuff")
porcelain.add(repo=self.repo.path, paths=[filepath])
porcelain.commit(
repo=self.repo.path,
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
f = StringIO()
porcelain.ls_tree(self.repo, b"HEAD", outstream=f)
self.assertEqual(
f.getvalue(),
"40000 tree b145cc69a5e17693e24d8a7be0016ed8075de66d\tadir\n",
)
f = StringIO()
porcelain.ls_tree(self.repo, b"HEAD", outstream=f, recursive=True)
self.assertEqual(
f.getvalue(),
"40000 tree b145cc69a5e17693e24d8a7be0016ed8075de66d\tadir\n"
"100644 blob 8b82634d7eae019850bb883f06abf428c58bc9aa\tadir"
"/afile\n",
)
class LsRemoteTests(PorcelainTestCase):
def test_empty(self):
self.assertEqual({}, porcelain.ls_remote(self.repo.path))
def test_some(self):
cid = porcelain.commit(
repo=self.repo.path,
message=b"test status",
author=b"author <email>",
committer=b"committer <email>",
)
self.assertEqual(
{b"refs/heads/master": cid, b"HEAD": cid},
porcelain.ls_remote(self.repo.path),
)
class LsFilesTests(PorcelainTestCase):
def test_empty(self):
self.assertEqual([], list(porcelain.ls_files(self.repo)))
def test_simple(self):
# Commit a dummy file then modify it
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("origstuff")
porcelain.add(repo=self.repo.path, paths=[fullpath])
self.assertEqual([b"foo"], list(porcelain.ls_files(self.repo)))
class RemoteAddTests(PorcelainTestCase):
def test_new(self):
porcelain.remote_add(self.repo, "jelmer", "git://jelmer.uk/code/dulwich")
c = self.repo.get_config()
self.assertEqual(
c.get((b"remote", b"jelmer"), b"url"),
b"git://jelmer.uk/code/dulwich",
)
def test_exists(self):
porcelain.remote_add(self.repo, "jelmer", "git://jelmer.uk/code/dulwich")
self.assertRaises(
porcelain.RemoteExists,
porcelain.remote_add,
self.repo,
"jelmer",
"git://jelmer.uk/code/dulwich",
)
class CheckIgnoreTests(PorcelainTestCase):
def test_check_ignored(self):
with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
f.write("foo")
foo_path = os.path.join(self.repo.path, "foo")
with open(foo_path, "w") as f:
f.write("BAR")
bar_path = os.path.join(self.repo.path, "bar")
with open(bar_path, "w") as f:
f.write("BAR")
self.assertEqual(["foo"], list(porcelain.check_ignore(self.repo, [foo_path])))
self.assertEqual([], list(porcelain.check_ignore(self.repo, [bar_path])))
def test_check_added_abs(self):
path = os.path.join(self.repo.path, "foo")
with open(path, "w") as f:
f.write("BAR")
self.repo.stage(["foo"])
with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
f.write("foo\n")
self.assertEqual([], list(porcelain.check_ignore(self.repo, [path])))
self.assertEqual(
["foo"],
list(porcelain.check_ignore(self.repo, [path], no_index=True)),
)
def test_check_added_rel(self):
with open(os.path.join(self.repo.path, "foo"), "w") as f:
f.write("BAR")
self.repo.stage(["foo"])
with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
f.write("foo\n")
cwd = os.getcwd()
os.mkdir(os.path.join(self.repo.path, "bar"))
os.chdir(os.path.join(self.repo.path, "bar"))
try:
self.assertEqual(list(porcelain.check_ignore(self.repo, ["../foo"])), [])
self.assertEqual(
["../foo"],
list(porcelain.check_ignore(self.repo, ["../foo"], no_index=True)),
)
finally:
os.chdir(cwd)
class UpdateHeadTests(PorcelainTestCase):
def test_set_to_branch(self):
[c1] = build_commit_graph(self.repo.object_store, [[1]])
self.repo.refs[b"refs/heads/blah"] = c1.id
porcelain.update_head(self.repo, "blah")
self.assertEqual(c1.id, self.repo.head())
self.assertEqual(b"ref: refs/heads/blah", self.repo.refs.read_ref(b"HEAD"))
def test_set_to_branch_detached(self):
[c1] = build_commit_graph(self.repo.object_store, [[1]])
self.repo.refs[b"refs/heads/blah"] = c1.id
porcelain.update_head(self.repo, "blah", detached=True)
self.assertEqual(c1.id, self.repo.head())
self.assertEqual(c1.id, self.repo.refs.read_ref(b"HEAD"))
def test_set_to_commit_detached(self):
[c1] = build_commit_graph(self.repo.object_store, [[1]])
self.repo.refs[b"refs/heads/blah"] = c1.id
porcelain.update_head(self.repo, c1.id, detached=True)
self.assertEqual(c1.id, self.repo.head())
self.assertEqual(c1.id, self.repo.refs.read_ref(b"HEAD"))
def test_set_new_branch(self):
[c1] = build_commit_graph(self.repo.object_store, [[1]])
self.repo.refs[b"refs/heads/blah"] = c1.id
porcelain.update_head(self.repo, "blah", new_branch="bar")
self.assertEqual(c1.id, self.repo.head())
self.assertEqual(b"ref: refs/heads/bar", self.repo.refs.read_ref(b"HEAD"))
class MailmapTests(PorcelainTestCase):
def test_no_mailmap(self):
self.assertEqual(
b"Jelmer Vernooij <jelmer@samba.org>",
porcelain.check_mailmap(self.repo, b"Jelmer Vernooij <jelmer@samba.org>"),
)
def test_mailmap_lookup(self):
with open(os.path.join(self.repo.path, ".mailmap"), "wb") as f:
f.write(
b"""\
Jelmer Vernooij <jelmer@debian.org>
"""
)
self.assertEqual(
b"Jelmer Vernooij <jelmer@debian.org>",
porcelain.check_mailmap(self.repo, b"Jelmer Vernooij <jelmer@samba.org>"),
)
class FsckTests(PorcelainTestCase):
def test_none(self):
self.assertEqual([], list(porcelain.fsck(self.repo)))
def test_git_dir(self):
obj = Tree()
a = Blob()
a.data = b"foo"
obj.add(b".git", 0o100644, a.id)
self.repo.object_store.add_objects([(a, None), (obj, None)])
self.assertEqual(
[(obj.id, "invalid name .git")],
[(sha, str(e)) for (sha, e) in porcelain.fsck(self.repo)],
)
class DescribeTests(PorcelainTestCase):
def test_no_commits(self):
self.assertRaises(KeyError, porcelain.describe, self.repo.path)
def test_single_commit(self):
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("BAR")
porcelain.add(repo=self.repo.path, paths=[fullpath])
sha = porcelain.commit(
self.repo.path,
message=b"Some message",
author=b"Joe <joe@example.com>",
committer=b"Bob <bob@example.com>",
)
self.assertEqual(
"g{}".format(sha[:7].decode("ascii")),
porcelain.describe(self.repo.path),
)
def test_tag(self):
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("BAR")
porcelain.add(repo=self.repo.path, paths=[fullpath])
porcelain.commit(
self.repo.path,
message=b"Some message",
author=b"Joe <joe@example.com>",
committer=b"Bob <bob@example.com>",
)
porcelain.tag_create(
self.repo.path,
b"tryme",
b"foo <foo@bar.com>",
b"bar",
annotated=True,
)
self.assertEqual("tryme", porcelain.describe(self.repo.path))
def test_tag_and_commit(self):
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("BAR")
porcelain.add(repo=self.repo.path, paths=[fullpath])
porcelain.commit(
self.repo.path,
message=b"Some message",
author=b"Joe <joe@example.com>",
committer=b"Bob <bob@example.com>",
)
porcelain.tag_create(
self.repo.path,
b"tryme",
b"foo <foo@bar.com>",
b"bar",
annotated=True,
)
with open(fullpath, "w") as f:
f.write("BAR2")
porcelain.add(repo=self.repo.path, paths=[fullpath])
sha = porcelain.commit(
self.repo.path,
message=b"Some message",
author=b"Joe <joe@example.com>",
committer=b"Bob <bob@example.com>",
)
self.assertEqual(
"tryme-1-g{}".format(sha[:7].decode("ascii")),
porcelain.describe(self.repo.path),
)
class PathToTreeTests(PorcelainTestCase):
def setUp(self):
super(PathToTreeTests, self).setUp()
self.fp = os.path.join(self.test_dir, "bar")
with open(self.fp, "w") as f:
f.write("something")
oldcwd = os.getcwd()
self.addCleanup(os.chdir, oldcwd)
os.chdir(self.test_dir)
def test_path_to_tree_path_base(self):
self.assertEqual(b"bar", porcelain.path_to_tree_path(self.test_dir, self.fp))
self.assertEqual(b"bar", porcelain.path_to_tree_path(".", "./bar"))
self.assertEqual(b"bar", porcelain.path_to_tree_path(".", "bar"))
cwd = os.getcwd()
self.assertEqual(
b"bar", porcelain.path_to_tree_path(".", os.path.join(cwd, "bar"))
)
self.assertEqual(b"bar", porcelain.path_to_tree_path(cwd, "bar"))
def test_path_to_tree_path_syntax(self):
self.assertEqual(b"bar", porcelain.path_to_tree_path(".", "./bar"))
def test_path_to_tree_path_error(self):
with self.assertRaises(ValueError):
with tempfile.TemporaryDirectory() as od:
porcelain.path_to_tree_path(od, self.fp)
def test_path_to_tree_path_rel(self):
cwd = os.getcwd()
os.mkdir(os.path.join(self.repo.path, "foo"))
os.mkdir(os.path.join(self.repo.path, "foo/bar"))
try:
os.chdir(os.path.join(self.repo.path, "foo/bar"))
with open("baz", "w") as f:
f.write("contents")
self.assertEqual(b"bar/baz", porcelain.path_to_tree_path("..", "baz"))
self.assertEqual(
b"bar/baz",
porcelain.path_to_tree_path(
os.path.join(os.getcwd(), ".."),
os.path.join(os.getcwd(), "baz"),
),
)
self.assertEqual(
b"bar/baz",
porcelain.path_to_tree_path("..", os.path.join(os.getcwd(), "baz")),
)
self.assertEqual(
b"bar/baz",
porcelain.path_to_tree_path(os.path.join(os.getcwd(), ".."), "baz"),
)
finally:
os.chdir(cwd)
class GetObjectByPathTests(PorcelainTestCase):
def test_simple(self):
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("BAR")
porcelain.add(repo=self.repo.path, paths=[fullpath])
porcelain.commit(
self.repo.path,
message=b"Some message",
author=b"Joe <joe@example.com>",
committer=b"Bob <bob@example.com>",
)
self.assertEqual(b"BAR", porcelain.get_object_by_path(self.repo, "foo").data)
self.assertEqual(b"BAR", porcelain.get_object_by_path(self.repo, b"foo").data)
def test_encoding(self):
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("BAR")
porcelain.add(repo=self.repo.path, paths=[fullpath])
porcelain.commit(
self.repo.path,
message=b"Some message",
author=b"Joe <joe@example.com>",
committer=b"Bob <bob@example.com>",
encoding=b"utf-8",
)
self.assertEqual(b"BAR", porcelain.get_object_by_path(self.repo, "foo").data)
self.assertEqual(b"BAR", porcelain.get_object_by_path(self.repo, b"foo").data)
def test_missing(self):
self.assertRaises(KeyError, porcelain.get_object_by_path, self.repo, "foo")
class WriteTreeTests(PorcelainTestCase):
def test_simple(self):
fullpath = os.path.join(self.repo.path, "foo")
with open(fullpath, "w") as f:
f.write("BAR")
porcelain.add(repo=self.repo.path, paths=[fullpath])
self.assertEqual(
b"d2092c8a9f311f0311083bf8d177f2ca0ab5b241",
porcelain.write_tree(self.repo),
)
class ActiveBranchTests(PorcelainTestCase):
def test_simple(self):
self.assertEqual(b"master", porcelain.active_branch(self.repo))
diff --git a/dulwich/tests/test_repository.py b/dulwich/tests/test_repository.py
index f8975cad..ee328013 100644
--- a/dulwich/tests/test_repository.py
+++ b/dulwich/tests/test_repository.py
@@ -1,1420 +1,1473 @@
# -*- 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/remotes/origin/HEAD": 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_clone_branch(self):
+ r = self.open_repo("a.git")
+ r.refs[b"refs/heads/mybranch"] = b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a"
+ tmp_dir = self.mkdtemp()
+ self.addCleanup(shutil.rmtree, tmp_dir)
+ with r.clone(tmp_dir, mkdir=False, branch=b"mybranch") as t:
+ # HEAD should point to specified branch and not origin HEAD
+ chain, sha = t.refs.follow(b"HEAD")
+ self.assertEqual(chain[-1], b"refs/heads/mybranch")
+ self.assertEqual(sha, b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a")
+ self.assertEqual(
+ t.refs[b"refs/remotes/origin/HEAD"],
+ b"a90fa2d900a17e99b433217e988c4eb4a2e9a097",
+ )
+
+ def test_clone_tag(self):
+ r = self.open_repo("a.git")
+ tmp_dir = self.mkdtemp()
+ self.addCleanup(shutil.rmtree, tmp_dir)
+ with r.clone(tmp_dir, mkdir=False, branch=b"mytag") as t:
+ # HEAD should be detached (and not a symbolic ref) at tag
+ self.assertEqual(
+ t.refs.read_ref(b"HEAD"),
+ b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a",
+ )
+ self.assertEqual(
+ t.refs[b"refs/remotes/origin/HEAD"],
+ b"a90fa2d900a17e99b433217e988c4eb4a2e9a097",
+ )
+
+ def test_clone_invalid_branch(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,
+ branch=b"mybranch",
+ )
+
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,
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))
+sys.path.extend(%(path)r)
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)}
+""" % {
+ 'executable': sys.executable,
+ 'path': [os.path.join(os.path.dirname(__file__), '..', '..')] + 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
+ self.assertEqual([], list(r.open_index()))
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_stage_submodule(self):
+ r = self._repo
+ s = Repo.init(os.path.join(r.path, "sub"), mkdir=True)
+ s.do_commit(b'message')
+ r.stage(["sub"])
+ self.assertEqual([b"a", b"sub"], 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/releaser.conf b/releaser.conf
index bcad72df..4d8177fc 100644
--- a/releaser.conf
+++ b/releaser.conf
@@ -1,15 +1,15 @@
# See https://github.com/jelmer/releaser
news_file: "NEWS"
timeout_days: 5
tag_name: "dulwich-$VERSION"
-verify_command: "make check"
+verify_command: "flake8 && make check"
update_version {
path: "setup.py"
match: "^dulwich_version_string = '(.*)'$"
new_line: "dulwich_version_string = '$VERSION'"
}
update_version {
path: "dulwich/__init__.py"
match: "^__version__ = \((.*)\)$"
new_line: "__version__ = $TUPLED_VERSION"
}
diff --git a/setup.py b/setup.py
index 8ca2a2fb..e0ee7431 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.27'
+dulwich_version_string = '0.20.30'
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
Mon, Aug 25, 5:57 PM (1 w, 13 h ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
3260968
Attached To
rPPDW python3-dulwich packaging
Event Timeline
Log In to Comment