base.py
1693 lines
| 53.1 KiB
| text/x-python
|
PythonLexer
r1 | # -*- coding: utf-8 -*- | ||
r2487 | # Copyright (C) 2014-2018 RhodeCode GmbH | ||
r1 | # | ||
# This program is free software: you can redistribute it and/or modify | |||
# it under the terms of the GNU Affero General Public License, version 3 | |||
# (only), as published by the Free Software Foundation. | |||
# | |||
# This program is distributed in the hope that it will be useful, | |||
# but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
# GNU General Public License for more details. | |||
# | |||
# You should have received a copy of the GNU Affero General Public License | |||
# along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
# | |||
# This program is dual-licensed. If you wish to learn more about the | |||
# RhodeCode Enterprise Edition, including its added features, Support services, | |||
# and proprietary license terms, please see https://rhodecode.com/licenses/ | |||
""" | |||
Base module for all VCS systems | |||
""" | |||
import collections | |||
import datetime | |||
r2619 | import fnmatch | ||
r1 | import itertools | ||
import logging | |||
import os | |||
r2619 | import re | ||
r1 | import time | ||
import warnings | |||
from zope.cachedescriptors.property import Lazy as LazyProperty | |||
from rhodecode.lib.utils2 import safe_str, safe_unicode | |||
from rhodecode.lib.vcs import connection | |||
from rhodecode.lib.vcs.utils import author_name, author_email | |||
from rhodecode.lib.vcs.conf import settings | |||
from rhodecode.lib.vcs.exceptions import ( | |||
CommitError, EmptyRepositoryError, NodeAlreadyAddedError, | |||
NodeAlreadyChangedError, NodeAlreadyExistsError, NodeAlreadyRemovedError, | |||
NodeDoesNotExistError, NodeNotChangedError, VCSError, | |||
ImproperArchiveTypeError, BranchDoesNotExistError, CommitDoesNotExistError, | |||
RepositoryError) | |||
log = logging.getLogger(__name__) | |||
FILEMODE_DEFAULT = 0100644 | |||
FILEMODE_EXECUTABLE = 0100755 | |||
Reference = collections.namedtuple('Reference', ('type', 'name', 'commit_id')) | |||
MergeResponse = collections.namedtuple( | |||
'MergeResponse', | |||
|
r1051 | ('possible', 'executed', 'merge_ref', 'failure_reason')) | |
r1 | |||
class MergeFailureReason(object): | |||
""" | |||
Enumeration with all the reasons why the server side merge could fail. | |||
DO NOT change the number of the reasons, as they may be stored in the | |||
database. | |||
Changing the name of a reason is acceptable and encouraged to deprecate old | |||
reasons. | |||
""" | |||
# Everything went well. | |||
NONE = 0 | |||
# An unexpected exception was raised. Check the logs for more details. | |||
UNKNOWN = 1 | |||
# The merge was not successful, there are conflicts. | |||
MERGE_FAILED = 2 | |||
# The merge succeeded but we could not push it to the target repository. | |||
PUSH_FAILED = 3 | |||
# The specified target is not a head in the target repository. | |||
TARGET_IS_NOT_HEAD = 4 | |||
# The source repository contains more branches than the target. Pushing | |||
# the merge will create additional branches in the target. | |||
HG_SOURCE_HAS_MORE_BRANCHES = 5 | |||
# The target reference has multiple heads. That does not allow to correctly | |||
# identify the target location. This could only happen for mercurial | |||
# branches. | |||
HG_TARGET_HAS_MULTIPLE_HEADS = 6 | |||
# The target repository is locked | |||
TARGET_IS_LOCKED = 7 | |||
|
r1081 | # Deprecated, use MISSING_TARGET_REF or MISSING_SOURCE_REF instead. | |
r1 | # A involved commit could not be found. | ||
|
r1081 | _DEPRECATED_MISSING_COMMIT = 8 | |
r1 | |||
|
r1067 | # The target repo reference is missing. | |
MISSING_TARGET_REF = 9 | |||
# The source repo reference is missing. | |||
MISSING_SOURCE_REF = 10 | |||
|
r1106 | # The merge was not successful, there are conflicts related to sub | |
# repositories. | |||
SUBREPO_MERGE_FAILED = 11 | |||
r1 | |||
|
r1069 | class UpdateFailureReason(object): | |
""" | |||
Enumeration with all the reasons why the pull request update could fail. | |||
DO NOT change the number of the reasons, as they may be stored in the | |||
database. | |||
Changing the name of a reason is acceptable and encouraged to deprecate old | |||
reasons. | |||
""" | |||
# Everything went well. | |||
NONE = 0 | |||
# An unexpected exception was raised. Check the logs for more details. | |||
UNKNOWN = 1 | |||
# The pull request is up to date. | |||
NO_CHANGE = 2 | |||
# The pull request has a reference type that is not supported for update. | |||
r1687 | WRONG_REF_TYPE = 3 | ||
|
r1069 | ||
# Update failed because the target reference is missing. | |||
MISSING_TARGET_REF = 4 | |||
# Update failed because the source reference is missing. | |||
MISSING_SOURCE_REF = 5 | |||
r1 | class BaseRepository(object): | ||
""" | |||
Base Repository for final backends | |||
.. attribute:: DEFAULT_BRANCH_NAME | |||
name of default branch (i.e. "trunk" for svn, "master" for git etc. | |||
.. attribute:: commit_ids | |||
list of all available commit ids, in ascending order | |||
.. attribute:: path | |||
absolute path to the repository | |||
.. attribute:: bookmarks | |||
Mapping from name to :term:`Commit ID` of the bookmark. Empty in case | |||
there are no bookmarks or the backend implementation does not support | |||
bookmarks. | |||
.. attribute:: tags | |||
Mapping from name to :term:`Commit ID` of the tag. | |||
""" | |||
DEFAULT_BRANCH_NAME = None | |||
DEFAULT_CONTACT = u"Unknown" | |||
DEFAULT_DESCRIPTION = u"unknown" | |||
EMPTY_COMMIT_ID = '0' * 40 | |||
path = None | |||
def __init__(self, repo_path, config=None, create=False, **kwargs): | |||
""" | |||
Initializes repository. Raises RepositoryError if repository could | |||
not be find at the given ``repo_path`` or directory at ``repo_path`` | |||
exists and ``create`` is set to True. | |||
:param repo_path: local path of the repository | |||
:param config: repository configuration | |||
:param create=False: if set to True, would try to create repository. | |||
:param src_url=None: if set, should be proper url from which repository | |||
would be cloned; requires ``create`` parameter to be set to True - | |||
raises RepositoryError if src_url is set and create evaluates to | |||
False | |||
""" | |||
raise NotImplementedError | |||
def __repr__(self): | |||
return '<%s at %s>' % (self.__class__.__name__, self.path) | |||
def __len__(self): | |||
return self.count() | |||
def __eq__(self, other): | |||
same_instance = isinstance(other, self.__class__) | |||
return same_instance and other.path == self.path | |||
def __ne__(self, other): | |||
return not self.__eq__(other) | |||
r2518 | @classmethod | ||
def get_default_config(cls, default=None): | |||
config = Config() | |||
if default and isinstance(default, list): | |||
for section, key, val in default: | |||
config.set(section, key, val) | |||
return config | |||
r1 | @LazyProperty | ||
def EMPTY_COMMIT(self): | |||
return EmptyCommit(self.EMPTY_COMMIT_ID) | |||
@LazyProperty | |||
def alias(self): | |||
for k, v in settings.BACKENDS.items(): | |||
if v.split('.')[-1] == str(self.__class__.__name__): | |||
return k | |||
@LazyProperty | |||
def name(self): | |||
return safe_unicode(os.path.basename(self.path)) | |||
@LazyProperty | |||
def description(self): | |||
raise NotImplementedError | |||
def refs(self): | |||
""" | |||
returns a `dict` with branches, bookmarks, tags, and closed_branches | |||
for this repository | |||
""" | |||
r1243 | return dict( | ||
branches=self.branches, | |||
branches_closed=self.branches_closed, | |||
tags=self.tags, | |||
bookmarks=self.bookmarks | |||
) | |||
r1 | |||
@LazyProperty | |||
def branches(self): | |||
""" | |||
A `dict` which maps branch names to commit ids. | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
r2617 | def branches_closed(self): | ||
""" | |||
A `dict` which maps tags names to commit ids. | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
def bookmarks(self): | |||
""" | |||
A `dict` which maps tags names to commit ids. | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
r1243 | def tags(self): | ||
""" | |||
A `dict` which maps tags names to commit ids. | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
r1 | def size(self): | ||
""" | |||
Returns combined size in bytes for all repository files | |||
""" | |||
tip = self.get_commit() | |||
return tip.size | |||
def size_at_commit(self, commit_id): | |||
commit = self.get_commit(commit_id) | |||
return commit.size | |||
def is_empty(self): | |||
return not bool(self.commit_ids) | |||
@staticmethod | |||
def check_url(url, config): | |||
""" | |||
Function will check given url and try to verify if it's a valid | |||
link. | |||
""" | |||
raise NotImplementedError | |||
@staticmethod | |||
def is_valid_repository(path): | |||
""" | |||
Check if given `path` contains a valid repository of this backend | |||
""" | |||
raise NotImplementedError | |||
# ========================================================================== | |||
# COMMITS | |||
# ========================================================================== | |||
def get_commit(self, commit_id=None, commit_idx=None, pre_load=None): | |||
""" | |||
Returns instance of `BaseCommit` class. If `commit_id` and `commit_idx` | |||
are both None, most recent commit is returned. | |||
:param pre_load: Optional. List of commit attributes to load. | |||
:raises ``EmptyRepositoryError``: if there are no commits | |||
""" | |||
raise NotImplementedError | |||
def __iter__(self): | |||
for commit_id in self.commit_ids: | |||
yield self.get_commit(commit_id=commit_id) | |||
def get_commits( | |||
self, start_id=None, end_id=None, start_date=None, end_date=None, | |||
r2144 | branch_name=None, show_hidden=False, pre_load=None): | ||
r1 | """ | ||
Returns iterator of `BaseCommit` objects from start to end | |||
not inclusive. This should behave just like a list, ie. end is not | |||
inclusive. | |||
:param start_id: None or str, must be a valid commit id | |||
:param end_id: None or str, must be a valid commit id | |||
:param start_date: | |||
:param end_date: | |||
:param branch_name: | |||
r2144 | :param show_hidden: | ||
r1 | :param pre_load: | ||
""" | |||
raise NotImplementedError | |||
def __getitem__(self, key): | |||
""" | |||
Allows index based access to the commit objects of this repository. | |||
""" | |||
pre_load = ["author", "branch", "date", "message", "parents"] | |||
if isinstance(key, slice): | |||
return self._get_range(key, pre_load) | |||
return self.get_commit(commit_idx=key, pre_load=pre_load) | |||
def _get_range(self, slice_obj, pre_load): | |||
for commit_id in self.commit_ids.__getitem__(slice_obj): | |||
yield self.get_commit(commit_id=commit_id, pre_load=pre_load) | |||
def count(self): | |||
return len(self.commit_ids) | |||
def tag(self, name, user, commit_id=None, message=None, date=None, **opts): | |||
""" | |||
Creates and returns a tag for the given ``commit_id``. | |||
:param name: name for new tag | |||
:param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" | |||
:param commit_id: commit id for which new tag would be created | |||
:param message: message of the tag's commit | |||
:param date: date of tag's commit | |||
:raises TagAlreadyExistError: if tag with same name already exists | |||
""" | |||
raise NotImplementedError | |||
def remove_tag(self, name, user, message=None, date=None): | |||
""" | |||
Removes tag with the given ``name``. | |||
:param name: name of the tag to be removed | |||
:param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" | |||
:param message: message of the tag's removal commit | |||
:param date: date of tag's removal commit | |||
:raises TagDoesNotExistError: if tag with given name does not exists | |||
""" | |||
raise NotImplementedError | |||
def get_diff( | |||
self, commit1, commit2, path=None, ignore_whitespace=False, | |||
context=3, path1=None): | |||
""" | |||
Returns (git like) *diff*, as plain text. Shows changes introduced by | |||
`commit2` since `commit1`. | |||
:param commit1: Entry point from which diff is shown. Can be | |||
``self.EMPTY_COMMIT`` - in this case, patch showing all | |||
the changes since empty state of the repository until `commit2` | |||
:param commit2: Until which commit changes should be shown. | |||
:param path: Can be set to a path of a file to create a diff of that | |||
file. If `path1` is also set, this value is only associated to | |||
`commit2`. | |||
:param ignore_whitespace: If set to ``True``, would not show whitespace | |||
changes. Defaults to ``False``. | |||
:param context: How many lines before/after changed lines should be | |||
shown. Defaults to ``3``. | |||
:param path1: Can be set to a path to associate with `commit1`. This | |||
parameter works only for backends which support diff generation for | |||
different paths. Other backends will raise a `ValueError` if `path1` | |||
is set and has a different value than `path`. | |||
r1259 | :param file_path: filter this diff by given path pattern | ||
r1 | """ | ||
raise NotImplementedError | |||
def strip(self, commit_id, branch=None): | |||
""" | |||
Strip given commit_id from the repository | |||
""" | |||
raise NotImplementedError | |||
def get_common_ancestor(self, commit_id1, commit_id2, repo2): | |||
""" | |||
Return a latest common ancestor commit if one exists for this repo | |||
`commit_id1` vs `commit_id2` from `repo2`. | |||
:param commit_id1: Commit it from this repository to use as a | |||
target for the comparison. | |||
:param commit_id2: Source commit id to use for comparison. | |||
:param repo2: Source repository to use for comparison. | |||
""" | |||
raise NotImplementedError | |||
def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None): | |||
""" | |||
Compare this repository's revision `commit_id1` with `commit_id2`. | |||
Returns a tuple(commits, ancestor) that would be merged from | |||
`commit_id2`. Doing a normal compare (``merge=False``), ``None`` | |||
will be returned as ancestor. | |||
:param commit_id1: Commit it from this repository to use as a | |||
target for the comparison. | |||
:param commit_id2: Source commit id to use for comparison. | |||
:param repo2: Source repository to use for comparison. | |||
:param merge: If set to ``True`` will do a merge compare which also | |||
returns the common ancestor. | |||
:param pre_load: Optional. List of commit attributes to load. | |||
""" | |||
raise NotImplementedError | |||
def merge(self, target_ref, source_repo, source_ref, workspace_id, | |||
|
r360 | user_name='', user_email='', message='', dry_run=False, | |
|
r2055 | use_rebase=False, close_branch=False): | |
r1 | """ | ||
Merge the revisions specified in `source_ref` from `source_repo` | |||
onto the `target_ref` of this repository. | |||
`source_ref` and `target_ref` are named tupls with the following | |||
fields `type`, `name` and `commit_id`. | |||
Returns a MergeResponse named tuple with the following fields | |||
'possible', 'executed', 'source_commit', 'target_commit', | |||
'merge_commit'. | |||
:param target_ref: `target_ref` points to the commit on top of which | |||
the `source_ref` should be merged. | |||
:param source_repo: The repository that contains the commits to be | |||
merged. | |||
:param source_ref: `source_ref` points to the topmost commit from | |||
the `source_repo` which should be merged. | |||
:param workspace_id: `workspace_id` unique identifier. | |||
:param user_name: Merge commit `user_name`. | |||
:param user_email: Merge commit `user_email`. | |||
:param message: Merge commit `message`. | |||
:param dry_run: If `True` the merge will not take place. | |||
|
r360 | :param use_rebase: If `True` commits from the source will be rebased | |
on top of the target instead of being merged. | |||
|
r2055 | :param close_branch: If `True` branch will be close before merging it | |
r1 | """ | ||
if dry_run: | |||
r924 | message = message or 'dry_run_merge_message' | ||
user_email = user_email or 'dry-run-merge@rhodecode.com' | |||
user_name = user_name or 'Dry-Run User' | |||
r1 | else: | ||
if not user_name: | |||
raise ValueError('user_name cannot be empty') | |||
if not user_email: | |||
raise ValueError('user_email cannot be empty') | |||
if not message: | |||
raise ValueError('message cannot be empty') | |||
shadow_repository_path = self._maybe_prepare_merge_workspace( | |||
r2471 | workspace_id, target_ref, source_ref) | ||
r1 | |||
try: | |||
return self._merge_repo( | |||
shadow_repository_path, target_ref, source_repo, | |||
|
r360 | source_ref, message, user_name, user_email, dry_run=dry_run, | |
|
r2055 | use_rebase=use_rebase, close_branch=close_branch) | |
r1 | except RepositoryError: | ||
r147 | log.exception( | ||
'Unexpected failure when running merge, dry-run=%s', | |||
dry_run) | |||
r1 | return MergeResponse( | ||
False, False, None, MergeFailureReason.UNKNOWN) | |||
def _merge_repo(self, shadow_repository_path, target_ref, | |||
source_repo, source_ref, merge_message, | |||
|
r2055 | merger_name, merger_email, dry_run=False, | |
use_rebase=False, close_branch=False): | |||
r1 | """Internal implementation of merge.""" | ||
raise NotImplementedError | |||
r2471 | def _maybe_prepare_merge_workspace(self, workspace_id, target_ref, source_ref): | ||
r1 | """ | ||
Create the merge workspace. | |||
:param workspace_id: `workspace_id` unique identifier. | |||
""" | |||
raise NotImplementedError | |||
def cleanup_merge_workspace(self, workspace_id): | |||
""" | |||
Remove merge workspace. | |||
This function MUST not fail in case there is no workspace associated to | |||
the given `workspace_id`. | |||
:param workspace_id: `workspace_id` unique identifier. | |||
""" | |||
raise NotImplementedError | |||
# ========== # | |||
# COMMIT API # | |||
# ========== # | |||
@LazyProperty | |||
def in_memory_commit(self): | |||
""" | |||
Returns :class:`InMemoryCommit` object for this repository. | |||
""" | |||
raise NotImplementedError | |||
# ======================== # | |||
# UTILITIES FOR SUBCLASSES # | |||
# ======================== # | |||
def _validate_diff_commits(self, commit1, commit2): | |||
""" | |||
Validates that the given commits are related to this repository. | |||
Intended as a utility for sub classes to have a consistent validation | |||
of input parameters in methods like :meth:`get_diff`. | |||
""" | |||
self._validate_commit(commit1) | |||
self._validate_commit(commit2) | |||
if (isinstance(commit1, EmptyCommit) and | |||
isinstance(commit2, EmptyCommit)): | |||
raise ValueError("Cannot compare two empty commits") | |||
def _validate_commit(self, commit): | |||
if not isinstance(commit, BaseCommit): | |||
raise TypeError( | |||
"%s is not of type BaseCommit" % repr(commit)) | |||
if commit.repository != self and not isinstance(commit, EmptyCommit): | |||
raise ValueError( | |||
"Commit %s must be a valid commit from this repository %s, " | |||
"related to this repository instead %s." % | |||
(commit, self, commit.repository)) | |||
def _validate_commit_id(self, commit_id): | |||
if not isinstance(commit_id, basestring): | |||
raise TypeError("commit_id must be a string value") | |||
def _validate_commit_idx(self, commit_idx): | |||
if not isinstance(commit_idx, (int, long)): | |||
raise TypeError("commit_idx must be a numeric value") | |||
def _validate_branch_name(self, branch_name): | |||
if branch_name and branch_name not in self.branches_all: | |||
msg = ("Branch %s not found in %s" % (branch_name, self)) | |||
raise BranchDoesNotExistError(msg) | |||
# | |||
# Supporting deprecated API parts | |||
# TODO: johbo: consider to move this into a mixin | |||
# | |||
@property | |||
def EMPTY_CHANGESET(self): | |||
warnings.warn( | |||
"Use EMPTY_COMMIT or EMPTY_COMMIT_ID instead", DeprecationWarning) | |||
return self.EMPTY_COMMIT_ID | |||
@property | |||
def revisions(self): | |||
warnings.warn("Use commits attribute instead", DeprecationWarning) | |||
return self.commit_ids | |||
@revisions.setter | |||
def revisions(self, value): | |||
warnings.warn("Use commits attribute instead", DeprecationWarning) | |||
self.commit_ids = value | |||
def get_changeset(self, revision=None, pre_load=None): | |||
warnings.warn("Use get_commit instead", DeprecationWarning) | |||
commit_id = None | |||
commit_idx = None | |||
if isinstance(revision, basestring): | |||
commit_id = revision | |||
else: | |||
commit_idx = revision | |||
return self.get_commit( | |||
commit_id=commit_id, commit_idx=commit_idx, pre_load=pre_load) | |||
def get_changesets( | |||
self, start=None, end=None, start_date=None, end_date=None, | |||
branch_name=None, pre_load=None): | |||
warnings.warn("Use get_commits instead", DeprecationWarning) | |||
start_id = self._revision_to_commit(start) | |||
end_id = self._revision_to_commit(end) | |||
return self.get_commits( | |||
start_id=start_id, end_id=end_id, start_date=start_date, | |||
end_date=end_date, branch_name=branch_name, pre_load=pre_load) | |||
def _revision_to_commit(self, revision): | |||
""" | |||
Translates a revision to a commit_id | |||
Helps to support the old changeset based API which allows to use | |||
commit ids and commit indices interchangeable. | |||
""" | |||
if revision is None: | |||
return revision | |||
if isinstance(revision, basestring): | |||
commit_id = revision | |||
else: | |||
commit_id = self.commit_ids[revision] | |||
return commit_id | |||
@property | |||
def in_memory_changeset(self): | |||
warnings.warn("Use in_memory_commit instead", DeprecationWarning) | |||
return self.in_memory_commit | |||
r2618 | # | ||
def get_path_permissions(self, username): | |||
""" | |||
Returns a path permission checker or None if not supported | |||
:param username: session user name | |||
:return: an instance of BasePathPermissionChecker or None | |||
""" | |||
return None | |||
r1 | |||
class BaseCommit(object): | |||
""" | |||
Each backend should implement it's commit representation. | |||
**Attributes** | |||
``repository`` | |||
repository object within which commit exists | |||
``id`` | |||
The commit id, may be ``raw_id`` or i.e. for mercurial's tip | |||
just ``tip``. | |||
``raw_id`` | |||
raw commit representation (i.e. full 40 length sha for git | |||
backend) | |||
``short_id`` | |||
shortened (if apply) version of ``raw_id``; it would be simple | |||
shortcut for ``raw_id[:12]`` for git/mercurial backends or same | |||
as ``raw_id`` for subversion | |||
``idx`` | |||
commit index | |||
``files`` | |||
list of ``FileNode`` (``Node`` with NodeKind.FILE) objects | |||
``dirs`` | |||
list of ``DirNode`` (``Node`` with NodeKind.DIR) objects | |||
``nodes`` | |||
combined list of ``Node`` objects | |||
``author`` | |||
author of the commit, as unicode | |||
``message`` | |||
message of the commit, as unicode | |||
``parents`` | |||
list of parent commits | |||
""" | |||
branch = None | |||
""" | |||
Depending on the backend this should be set to the branch name of the | |||
commit. Backends not supporting branches on commits should leave this | |||
value as ``None``. | |||
""" | |||
_ARCHIVE_PREFIX_TEMPLATE = b'{repo_name}-{short_id}' | |||
""" | |||
This template is used to generate a default prefix for repository archives | |||
if no prefix has been specified. | |||
""" | |||
def __str__(self): | |||
return '<%s at %s:%s>' % ( | |||
self.__class__.__name__, self.idx, self.short_id) | |||
def __repr__(self): | |||
return self.__str__() | |||
def __unicode__(self): | |||
return u'%s:%s' % (self.idx, self.short_id) | |||
def __eq__(self, other): | |||
r985 | same_instance = isinstance(other, self.__class__) | ||
return same_instance and self.raw_id == other.raw_id | |||
r1 | |||
def __json__(self): | |||
parents = [] | |||
try: | |||
for parent in self.parents: | |||
parents.append({'raw_id': parent.raw_id}) | |||
except NotImplementedError: | |||
# empty commit doesn't have parents implemented | |||
pass | |||
return { | |||
'short_id': self.short_id, | |||
'raw_id': self.raw_id, | |||
'revision': self.idx, | |||
'message': self.message, | |||
'date': self.date, | |||
'author': self.author, | |||
'parents': parents, | |||
'branch': self.branch | |||
} | |||
r2337 | def _get_refs(self): | ||
return { | |||
'branches': [self.branch], | |||
'bookmarks': getattr(self, 'bookmarks', []), | |||
'tags': self.tags | |||
} | |||
r1 | @LazyProperty | ||
def last(self): | |||
""" | |||
``True`` if this is last commit in repository, ``False`` | |||
otherwise; trying to access this attribute while there is no | |||
commits would raise `EmptyRepositoryError` | |||
""" | |||
if self.repository is None: | |||
raise CommitError("Cannot check if it's most recent commit") | |||
return self.raw_id == self.repository.commit_ids[-1] | |||
@LazyProperty | |||
def parents(self): | |||
""" | |||
Returns list of parent commits. | |||
""" | |||
raise NotImplementedError | |||
@property | |||
def merge(self): | |||
""" | |||
Returns boolean if commit is a merge. | |||
""" | |||
return len(self.parents) > 1 | |||
@LazyProperty | |||
def children(self): | |||
""" | |||
Returns list of child commits. | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
def id(self): | |||
""" | |||
Returns string identifying this commit. | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
def raw_id(self): | |||
""" | |||
Returns raw string identifying this commit. | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
def short_id(self): | |||
""" | |||
Returns shortened version of ``raw_id`` attribute, as string, | |||
identifying this commit, useful for presentation to users. | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
def idx(self): | |||
""" | |||
Returns integer identifying this commit. | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
def committer(self): | |||
""" | |||
Returns committer for this commit | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
def committer_name(self): | |||
""" | |||
Returns committer name for this commit | |||
""" | |||
return author_name(self.committer) | |||
@LazyProperty | |||
def committer_email(self): | |||
""" | |||
Returns committer email address for this commit | |||
""" | |||
return author_email(self.committer) | |||
@LazyProperty | |||
def author(self): | |||
""" | |||
Returns author for this commit | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
def author_name(self): | |||
""" | |||
Returns author name for this commit | |||
""" | |||
return author_name(self.author) | |||
@LazyProperty | |||
def author_email(self): | |||
""" | |||
Returns author email address for this commit | |||
""" | |||
return author_email(self.author) | |||
def get_file_mode(self, path): | |||
""" | |||
Returns stat mode of the file at `path`. | |||
""" | |||
raise NotImplementedError | |||
def is_link(self, path): | |||
""" | |||
Returns ``True`` if given `path` is a symlink | |||
""" | |||
raise NotImplementedError | |||
def get_file_content(self, path): | |||
""" | |||
Returns content of the file at the given `path`. | |||
""" | |||
raise NotImplementedError | |||
def get_file_size(self, path): | |||
""" | |||
Returns size of the file at the given `path`. | |||
""" | |||
raise NotImplementedError | |||
def get_file_commit(self, path, pre_load=None): | |||
""" | |||
Returns last commit of the file at the given `path`. | |||
:param pre_load: Optional. List of commit attributes to load. | |||
""" | |||
r1179 | commits = self.get_file_history(path, limit=1, pre_load=pre_load) | ||
if not commits: | |||
raise RepositoryError( | |||
'Failed to fetch history for path {}. ' | |||
'Please check if such path exists in your repository'.format( | |||
path)) | |||
return commits[0] | |||
r1 | |||
def get_file_history(self, path, limit=None, pre_load=None): | |||
""" | |||
Returns history of file as reversed list of :class:`BaseCommit` | |||
objects for which file at given `path` has been modified. | |||
:param limit: Optional. Allows to limit the size of the returned | |||
history. This is intended as a hint to the underlying backend, so | |||
that it can apply optimizations depending on the limit. | |||
:param pre_load: Optional. List of commit attributes to load. | |||
""" | |||
raise NotImplementedError | |||
def get_file_annotate(self, path, pre_load=None): | |||
""" | |||
Returns a generator of four element tuples with | |||
lineno, sha, commit lazy loader and line | |||
:param pre_load: Optional. List of commit attributes to load. | |||
""" | |||
raise NotImplementedError | |||
def get_nodes(self, path): | |||
""" | |||
Returns combined ``DirNode`` and ``FileNode`` objects list representing | |||
state of commit at the given ``path``. | |||
:raises ``CommitError``: if node at the given ``path`` is not | |||
instance of ``DirNode`` | |||
""" | |||
raise NotImplementedError | |||
def get_node(self, path): | |||
""" | |||
Returns ``Node`` object from the given ``path``. | |||
:raises ``NodeDoesNotExistError``: if there is no node at the given | |||
``path`` | |||
""" | |||
raise NotImplementedError | |||
def get_largefile_node(self, path): | |||
""" | |||
r1577 | Returns the path to largefile from Mercurial/Git-lfs storage. | ||
or None if it's not a largefile node | |||
r1 | """ | ||
r1577 | return None | ||
r1 | |||
def archive_repo(self, file_path, kind='tgz', subrepos=None, | |||
prefix=None, write_metadata=False, mtime=None): | |||
""" | |||
Creates an archive containing the contents of the repository. | |||
:param file_path: path to the file which to create the archive. | |||
:param kind: one of following: ``"tbz2"``, ``"tgz"``, ``"zip"``. | |||
:param prefix: name of root directory in archive. | |||
Default is repository name and commit's short_id joined with dash: | |||
``"{repo_name}-{short_id}"``. | |||
:param write_metadata: write a metadata file into archive. | |||
:param mtime: custom modification time for archive creation, defaults | |||
to time.time() if not given. | |||
:raise VCSError: If prefix has a problem. | |||
""" | |||
allowed_kinds = settings.ARCHIVE_SPECS.keys() | |||
if kind not in allowed_kinds: | |||
raise ImproperArchiveTypeError( | |||
'Archive kind (%s) not supported use one of %s' % | |||
(kind, allowed_kinds)) | |||
prefix = self._validate_archive_prefix(prefix) | |||
|
r869 | mtime = mtime or time.mktime(self.date.timetuple()) | |
r1 | |||
file_info = [] | |||
cur_rev = self.repository.get_commit(commit_id=self.raw_id) | |||
for _r, _d, files in cur_rev.walk('/'): | |||
for f in files: | |||
f_path = os.path.join(prefix, f.path) | |||
file_info.append( | |||
r501 | (f_path, f.mode, f.is_link(), f.raw_bytes)) | ||
r1 | |||
if write_metadata: | |||
metadata = [ | |||
('repo_name', self.repository.name), | |||
('rev', self.raw_id), | |||
('create_time', mtime), | |||
('branch', self.branch), | |||
('tags', ','.join(self.tags)), | |||
] | |||
meta = ["%s:%s" % (f_name, value) for f_name, value in metadata] | |||
file_info.append(('.archival.txt', 0644, False, '\n'.join(meta))) | |||
connection.Hg.archive_repo(file_path, mtime, file_info, kind) | |||
def _validate_archive_prefix(self, prefix): | |||
if prefix is None: | |||
prefix = self._ARCHIVE_PREFIX_TEMPLATE.format( | |||
repo_name=safe_str(self.repository.name), | |||
short_id=self.short_id) | |||
elif not isinstance(prefix, str): | |||
raise ValueError("prefix not a bytes object: %s" % repr(prefix)) | |||
elif prefix.startswith('/'): | |||
raise VCSError("Prefix cannot start with leading slash") | |||
elif prefix.strip() == '': | |||
raise VCSError("Prefix cannot be empty") | |||
return prefix | |||
@LazyProperty | |||
def root(self): | |||
""" | |||
Returns ``RootNode`` object for this commit. | |||
""" | |||
return self.get_node('') | |||
def next(self, branch=None): | |||
""" | |||
Returns next commit from current, if branch is gives it will return | |||
next commit belonging to this branch | |||
:param branch: show commits within the given named branch | |||
""" | |||
indexes = xrange(self.idx + 1, self.repository.count()) | |||
return self._find_next(indexes, branch) | |||
def prev(self, branch=None): | |||
""" | |||
Returns previous commit from current, if branch is gives it will | |||
return previous commit belonging to this branch | |||
:param branch: show commit within the given named branch | |||
""" | |||
indexes = xrange(self.idx - 1, -1, -1) | |||
return self._find_next(indexes, branch) | |||
def _find_next(self, indexes, branch=None): | |||
if branch and self.branch != branch: | |||
raise VCSError('Branch option used on commit not belonging ' | |||
'to that branch') | |||
for next_idx in indexes: | |||
commit = self.repository.get_commit(commit_idx=next_idx) | |||
if branch and branch != commit.branch: | |||
continue | |||
return commit | |||
raise CommitDoesNotExistError | |||
def diff(self, ignore_whitespace=True, context=3): | |||
""" | |||
Returns a `Diff` object representing the change made by this commit. | |||
""" | |||
parent = ( | |||
self.parents[0] if self.parents else self.repository.EMPTY_COMMIT) | |||
diff = self.repository.get_diff( | |||
parent, self, | |||
ignore_whitespace=ignore_whitespace, | |||
context=context) | |||
return diff | |||
@LazyProperty | |||
def added(self): | |||
""" | |||
Returns list of added ``FileNode`` objects. | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
def changed(self): | |||
""" | |||
Returns list of modified ``FileNode`` objects. | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
def removed(self): | |||
""" | |||
Returns list of removed ``FileNode`` objects. | |||
""" | |||
raise NotImplementedError | |||
@LazyProperty | |||
def size(self): | |||
""" | |||
Returns total number of bytes from contents of all filenodes. | |||
""" | |||
return sum((node.size for node in self.get_filenodes_generator())) | |||
def walk(self, topurl=''): | |||
""" | |||
Similar to os.walk method. Insted of filesystem it walks through | |||
commit starting at given ``topurl``. Returns generator of tuples | |||
(topnode, dirnodes, filenodes). | |||
""" | |||
topnode = self.get_node(topurl) | |||
if not topnode.is_dir(): | |||
return | |||
yield (topnode, topnode.dirs, topnode.files) | |||
for dirnode in topnode.dirs: | |||
for tup in self.walk(dirnode.path): | |||
yield tup | |||
def get_filenodes_generator(self): | |||
""" | |||
Returns generator that yields *all* file nodes. | |||
""" | |||
for topnode, dirs, files in self.walk(): | |||
for node in files: | |||
yield node | |||
# | |||
# Utilities for sub classes to support consistent behavior | |||
# | |||
def no_node_at_path(self, path): | |||
return NodeDoesNotExistError( | |||
r1735 | u"There is no file nor directory at the given path: " | ||
r1838 | u"`%s` at commit %s" % (safe_unicode(path), self.short_id)) | ||
r1 | |||
def _fix_path(self, path): | |||
""" | |||
Paths are stored without trailing slash so we need to get rid off it if | |||
needed. | |||
""" | |||
return path.rstrip('/') | |||
# | |||
# Deprecated API based on changesets | |||
# | |||
@property | |||
def revision(self): | |||
warnings.warn("Use idx instead", DeprecationWarning) | |||
return self.idx | |||
@revision.setter | |||
def revision(self, value): | |||
warnings.warn("Use idx instead", DeprecationWarning) | |||
self.idx = value | |||
def get_file_changeset(self, path): | |||
warnings.warn("Use get_file_commit instead", DeprecationWarning) | |||
return self.get_file_commit(path) | |||
class BaseChangesetClass(type): | |||
def __instancecheck__(self, instance): | |||
return isinstance(instance, BaseCommit) | |||
class BaseChangeset(BaseCommit): | |||
__metaclass__ = BaseChangesetClass | |||
def __new__(cls, *args, **kwargs): | |||
warnings.warn( | |||
"Use BaseCommit instead of BaseChangeset", DeprecationWarning) | |||
return super(BaseChangeset, cls).__new__(cls, *args, **kwargs) | |||
class BaseInMemoryCommit(object): | |||
""" | |||
Represents differences between repository's state (most recent head) and | |||
changes made *in place*. | |||
**Attributes** | |||
``repository`` | |||
repository object for this in-memory-commit | |||
``added`` | |||
list of ``FileNode`` objects marked as *added* | |||
``changed`` | |||
list of ``FileNode`` objects marked as *changed* | |||
``removed`` | |||
list of ``FileNode`` or ``RemovedFileNode`` objects marked to be | |||
*removed* | |||
``parents`` | |||
list of :class:`BaseCommit` instances representing parents of | |||
in-memory commit. Should always be 2-element sequence. | |||
""" | |||
def __init__(self, repository): | |||
self.repository = repository | |||
self.added = [] | |||
self.changed = [] | |||
self.removed = [] | |||
self.parents = [] | |||
def add(self, *filenodes): | |||
""" | |||
Marks given ``FileNode`` objects as *to be committed*. | |||
:raises ``NodeAlreadyExistsError``: if node with same path exists at | |||
latest commit | |||
:raises ``NodeAlreadyAddedError``: if node with same path is already | |||
marked as *added* | |||
""" | |||
# Check if not already marked as *added* first | |||
for node in filenodes: | |||
if node.path in (n.path for n in self.added): | |||
raise NodeAlreadyAddedError( | |||
"Such FileNode %s is already marked for addition" | |||
% node.path) | |||
for node in filenodes: | |||
self.added.append(node) | |||
def change(self, *filenodes): | |||
""" | |||
Marks given ``FileNode`` objects to be *changed* in next commit. | |||
:raises ``EmptyRepositoryError``: if there are no commits yet | |||
:raises ``NodeAlreadyExistsError``: if node with same path is already | |||
marked to be *changed* | |||
:raises ``NodeAlreadyRemovedError``: if node with same path is already | |||
marked to be *removed* | |||
:raises ``NodeDoesNotExistError``: if node doesn't exist in latest | |||
commit | |||
:raises ``NodeNotChangedError``: if node hasn't really be changed | |||
""" | |||
for node in filenodes: | |||
if node.path in (n.path for n in self.removed): | |||
raise NodeAlreadyRemovedError( | |||
"Node at %s is already marked as removed" % node.path) | |||
try: | |||
self.repository.get_commit() | |||
except EmptyRepositoryError: | |||
raise EmptyRepositoryError( | |||
"Nothing to change - try to *add* new nodes rather than " | |||
"changing them") | |||
for node in filenodes: | |||
if node.path in (n.path for n in self.changed): | |||
raise NodeAlreadyChangedError( | |||
"Node at '%s' is already marked as changed" % node.path) | |||
self.changed.append(node) | |||
def remove(self, *filenodes): | |||
""" | |||
Marks given ``FileNode`` (or ``RemovedFileNode``) objects to be | |||
*removed* in next commit. | |||
:raises ``NodeAlreadyRemovedError``: if node has been already marked to | |||
be *removed* | |||
:raises ``NodeAlreadyChangedError``: if node has been already marked to | |||
be *changed* | |||
""" | |||
for node in filenodes: | |||
if node.path in (n.path for n in self.removed): | |||
raise NodeAlreadyRemovedError( | |||
"Node is already marked to for removal at %s" % node.path) | |||
if node.path in (n.path for n in self.changed): | |||
raise NodeAlreadyChangedError( | |||
"Node is already marked to be changed at %s" % node.path) | |||
# We only mark node as *removed* - real removal is done by | |||
# commit method | |||
self.removed.append(node) | |||
def reset(self): | |||
""" | |||
Resets this instance to initial state (cleans ``added``, ``changed`` | |||
and ``removed`` lists). | |||
""" | |||
self.added = [] | |||
self.changed = [] | |||
self.removed = [] | |||
self.parents = [] | |||
def get_ipaths(self): | |||
""" | |||
Returns generator of paths from nodes marked as added, changed or | |||
removed. | |||
""" | |||
for node in itertools.chain(self.added, self.changed, self.removed): | |||
yield node.path | |||
def get_paths(self): | |||
""" | |||
Returns list of paths from nodes marked as added, changed or removed. | |||
""" | |||
return list(self.get_ipaths()) | |||
def check_integrity(self, parents=None): | |||
""" | |||
Checks in-memory commit's integrity. Also, sets parents if not | |||
already set. | |||
:raises CommitError: if any error occurs (i.e. | |||
``NodeDoesNotExistError``). | |||
""" | |||
if not self.parents: | |||
parents = parents or [] | |||
if len(parents) == 0: | |||
try: | |||
parents = [self.repository.get_commit(), None] | |||
except EmptyRepositoryError: | |||
parents = [None, None] | |||
elif len(parents) == 1: | |||
parents += [None] | |||
self.parents = parents | |||
# Local parents, only if not None | |||
parents = [p for p in self.parents if p] | |||
# Check nodes marked as added | |||
for p in parents: | |||
for node in self.added: | |||
try: | |||
p.get_node(node.path) | |||
except NodeDoesNotExistError: | |||
pass | |||
else: | |||
raise NodeAlreadyExistsError( | |||
"Node `%s` already exists at %s" % (node.path, p)) | |||
# Check nodes marked as changed | |||
missing = set(self.changed) | |||
not_changed = set(self.changed) | |||
if self.changed and not parents: | |||
raise NodeDoesNotExistError(str(self.changed[0].path)) | |||
for p in parents: | |||
for node in self.changed: | |||
try: | |||
old = p.get_node(node.path) | |||
missing.remove(node) | |||
# if content actually changed, remove node from not_changed | |||
if old.content != node.content: | |||
not_changed.remove(node) | |||
except NodeDoesNotExistError: | |||
pass | |||
if self.changed and missing: | |||
raise NodeDoesNotExistError( | |||
"Node `%s` marked as modified but missing in parents: %s" | |||
% (node.path, parents)) | |||
if self.changed and not_changed: | |||
raise NodeNotChangedError( | |||
"Node `%s` wasn't actually changed (parents: %s)" | |||
% (not_changed.pop().path, parents)) | |||
# Check nodes marked as removed | |||
if self.removed and not parents: | |||
raise NodeDoesNotExistError( | |||
"Cannot remove node at %s as there " | |||
"were no parents specified" % self.removed[0].path) | |||
really_removed = set() | |||
for p in parents: | |||
for node in self.removed: | |||
try: | |||
p.get_node(node.path) | |||
really_removed.add(node) | |||
except CommitError: | |||
pass | |||
not_removed = set(self.removed) - really_removed | |||
if not_removed: | |||
# TODO: johbo: This code branch does not seem to be covered | |||
raise NodeDoesNotExistError( | |||
"Cannot remove node at %s from " | |||
"following parents: %s" % (not_removed, parents)) | |||
def commit( | |||
self, message, author, parents=None, branch=None, date=None, | |||
**kwargs): | |||
""" | |||
Performs in-memory commit (doesn't check workdir in any way) and | |||
returns newly created :class:`BaseCommit`. Updates repository's | |||
attribute `commits`. | |||
.. note:: | |||
While overriding this method each backend's should call | |||
``self.check_integrity(parents)`` in the first place. | |||
:param message: message of the commit | |||
:param author: full username, i.e. "Joe Doe <joe.doe@example.com>" | |||
:param parents: single parent or sequence of parents from which commit | |||
would be derived | |||
:param date: ``datetime.datetime`` instance. Defaults to | |||
``datetime.datetime.now()``. | |||
:param branch: branch name, as string. If none given, default backend's | |||
branch would be used. | |||
:raises ``CommitError``: if any error occurs while committing | |||
""" | |||
raise NotImplementedError | |||
class BaseInMemoryChangesetClass(type): | |||
def __instancecheck__(self, instance): | |||
return isinstance(instance, BaseInMemoryCommit) | |||
class BaseInMemoryChangeset(BaseInMemoryCommit): | |||
__metaclass__ = BaseInMemoryChangesetClass | |||
def __new__(cls, *args, **kwargs): | |||
warnings.warn( | |||
"Use BaseCommit instead of BaseInMemoryCommit", DeprecationWarning) | |||
return super(BaseInMemoryChangeset, cls).__new__(cls, *args, **kwargs) | |||
class EmptyCommit(BaseCommit): | |||
""" | |||
An dummy empty commit. It's possible to pass hash when creating | |||
an EmptyCommit | |||
""" | |||
def __init__( | |||
self, commit_id='0' * 40, repo=None, alias=None, idx=-1, | |||
message='', author='', date=None): | |||
self._empty_commit_id = commit_id | |||
# TODO: johbo: Solve idx parameter, default value does not make | |||
# too much sense | |||
self.idx = idx | |||
self.message = message | |||
self.author = author | |||
self.date = date or datetime.datetime.fromtimestamp(0) | |||
self.repository = repo | |||
self.alias = alias | |||
@LazyProperty | |||
def raw_id(self): | |||
""" | |||
Returns raw string identifying this commit, useful for web | |||
representation. | |||
""" | |||
return self._empty_commit_id | |||
@LazyProperty | |||
def branch(self): | |||
if self.alias: | |||
from rhodecode.lib.vcs.backends import get_backend | |||
return get_backend(self.alias).DEFAULT_BRANCH_NAME | |||
@LazyProperty | |||
def short_id(self): | |||
return self.raw_id[:12] | |||
r621 | @LazyProperty | ||
def id(self): | |||
return self.raw_id | |||
r1 | def get_file_commit(self, path): | ||
return self | |||
def get_file_content(self, path): | |||
return u'' | |||
def get_file_size(self, path): | |||
return 0 | |||
class EmptyChangesetClass(type): | |||
def __instancecheck__(self, instance): | |||
return isinstance(instance, EmptyCommit) | |||
class EmptyChangeset(EmptyCommit): | |||
__metaclass__ = EmptyChangesetClass | |||
def __new__(cls, *args, **kwargs): | |||
warnings.warn( | |||
"Use EmptyCommit instead of EmptyChangeset", DeprecationWarning) | |||
return super(EmptyCommit, cls).__new__(cls, *args, **kwargs) | |||
def __init__(self, cs='0' * 40, repo=None, requested_revision=None, | |||
alias=None, revision=-1, message='', author='', date=None): | |||
if requested_revision is not None: | |||
warnings.warn( | |||
"Parameter requested_revision not supported anymore", | |||
DeprecationWarning) | |||
super(EmptyChangeset, self).__init__( | |||
commit_id=cs, repo=repo, alias=alias, idx=revision, | |||
message=message, author=author, date=date) | |||
@property | |||
def revision(self): | |||
warnings.warn("Use idx instead", DeprecationWarning) | |||
return self.idx | |||
@revision.setter | |||
def revision(self, value): | |||
warnings.warn("Use idx instead", DeprecationWarning) | |||
self.idx = value | |||
r1255 | class EmptyRepository(BaseRepository): | ||
def __init__(self, repo_path=None, config=None, create=False, **kwargs): | |||
pass | |||
def get_diff(self, *args, **kwargs): | |||
from rhodecode.lib.vcs.backends.git.diff import GitDiff | |||
return GitDiff('') | |||
r1 | class CollectionGenerator(object): | ||
def __init__(self, repo, commit_ids, collection_size=None, pre_load=None): | |||
self.repo = repo | |||
self.commit_ids = commit_ids | |||
# TODO: (oliver) this isn't currently hooked up | |||
self.collection_size = None | |||
self.pre_load = pre_load | |||
def __len__(self): | |||
if self.collection_size is not None: | |||
return self.collection_size | |||
return self.commit_ids.__len__() | |||
def __iter__(self): | |||
for commit_id in self.commit_ids: | |||
# TODO: johbo: Mercurial passes in commit indices or commit ids | |||
yield self._commit_factory(commit_id) | |||
def _commit_factory(self, commit_id): | |||
""" | |||
Allows backends to override the way commits are generated. | |||
""" | |||
return self.repo.get_commit(commit_id=commit_id, | |||
pre_load=self.pre_load) | |||
def __getslice__(self, i, j): | |||
""" | |||
Returns an iterator of sliced repository | |||
""" | |||
commit_ids = self.commit_ids[i:j] | |||
return self.__class__( | |||
self.repo, commit_ids, pre_load=self.pre_load) | |||
def __repr__(self): | |||
return '<CollectionGenerator[len:%s]>' % (self.__len__()) | |||
class Config(object): | |||
""" | |||
Represents the configuration for a repository. | |||
The API is inspired by :class:`ConfigParser.ConfigParser` from the | |||
standard library. It implements only the needed subset. | |||
""" | |||
def __init__(self): | |||
self._values = {} | |||
def copy(self): | |||
clone = Config() | |||
for section, values in self._values.items(): | |||
clone._values[section] = values.copy() | |||
return clone | |||
def __repr__(self): | |||
r752 | return '<Config(%s sections) at %s>' % ( | ||
len(self._values), hex(id(self))) | |||
r1 | |||
def items(self, section): | |||
return self._values.get(section, {}).iteritems() | |||
def get(self, section, option): | |||
return self._values.get(section, {}).get(option) | |||
def set(self, section, option, value): | |||
section_values = self._values.setdefault(section, {}) | |||
section_values[option] = value | |||
def clear_section(self, section): | |||
self._values[section] = {} | |||
def serialize(self): | |||
""" | |||
Creates a list of three tuples (section, key, value) representing | |||
this config object. | |||
""" | |||
items = [] | |||
for section in self._values: | |||
for option, value in self._values[section].items(): | |||
items.append( | |||
(safe_str(section), safe_str(option), safe_str(value))) | |||
return items | |||
class Diff(object): | |||
""" | |||
Represents a diff result from a repository backend. | |||
r1259 | Subclasses have to provide a backend specific value for | ||
:attr:`_header_re` and :attr:`_meta_re`. | |||
r1 | """ | ||
r1259 | _meta_re = None | ||
r1 | _header_re = None | ||
def __init__(self, raw_diff): | |||
self.raw = raw_diff | |||
def chunks(self): | |||
""" | |||
split the diff in chunks of separate --git a/file b/file chunks | |||
to make diffs consistent we must prepend with \n, and make sure | |||
we can detect last chunk as this was also has special rule | |||
""" | |||
r1259 | |||
diff_parts = ('\n' + self.raw).split('\ndiff --git') | |||
header = diff_parts[0] | |||
if self._meta_re: | |||
match = self._meta_re.match(header) | |||
chunks = diff_parts[1:] | |||
r1 | total_chunks = len(chunks) | ||
r1259 | |||
return ( | |||
DiffChunk(chunk, self, cur_chunk == total_chunks) | |||
for cur_chunk, chunk in enumerate(chunks, start=1)) | |||
r1 | |||
class DiffChunk(object): | |||
def __init__(self, chunk, diff, last_chunk): | |||
self._diff = diff | |||
# since we split by \ndiff --git that part is lost from original diff | |||
# we need to re-apply it at the end, EXCEPT ! if it's last chunk | |||
if not last_chunk: | |||
chunk += '\n' | |||
match = self._diff._header_re.match(chunk) | |||
self.header = match.groupdict() | |||
self.diff = chunk[match.end():] | |||
self.raw = chunk | |||
r2618 | |||
class BasePathPermissionChecker(object): | |||
r2619 | @staticmethod | ||
def create_from_patterns(includes, excludes): | |||
if includes and '*' in includes and not excludes: | |||
return AllPathPermissionChecker() | |||
elif excludes and '*' in excludes: | |||
return NonePathPermissionChecker() | |||
else: | |||
return PatternPathPermissionChecker(includes, excludes) | |||
@property | |||
def has_full_access(self): | |||
raise NotImplemented() | |||
r2618 | |||
def has_access(self, path): | |||
raise NotImplemented() | |||
r2619 | |||
class AllPathPermissionChecker(BasePathPermissionChecker): | |||
@property | |||
def has_full_access(self): | |||
return True | |||
def has_access(self, path): | |||
return True | |||
class NonePathPermissionChecker(BasePathPermissionChecker): | |||
@property | |||
def has_full_access(self): | |||
return False | |||
def has_access(self, path): | |||
return False | |||
class PatternPathPermissionChecker(BasePathPermissionChecker): | |||
def __init__(self, includes, excludes): | |||
self.includes = includes | |||
self.excludes = excludes | |||
self.includes_re = [] if not includes else [re.compile(fnmatch.translate(pattern)) for pattern in includes] | |||
self.excludes_re = [] if not excludes else [re.compile(fnmatch.translate(pattern)) for pattern in excludes] | |||
@property | |||
def has_full_access(self): | |||
return '*' in self.includes and not self.excludes | |||
def has_access(self, path): | |||
for re in self.excludes_re: | |||
if re.match(path): | |||
return False | |||
for re in self.includes_re: | |||
if re.match(path): | |||
return True | |||
return False |