# -*- coding: utf-8 -*-

"""

    vcs.backends.git.repository

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Git repository implementation.

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

import errno

import logging

import os

import re

import time

import urllib.error

import urllib.parse

import urllib.request

from collections import OrderedDict

import mercurial.util  # import url as hg_url

from dulwich.config import ConfigFile

from dulwich.objects import Tag

from dulwich.repo import NotGitRepository, Repo

from kallithea.lib.vcs import subprocessio

from kallithea.lib.vcs.backends.base import BaseRepository, CollectionGenerator

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError, TagAlreadyExistError,

                                          TagDoesNotExistError)

from kallithea.lib.vcs.utils import ascii_str, date_fromtimestamp, makedate, safe_bytes, safe_str

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.utils.paths import abspath, get_user_home

from .changeset import GitChangeset

from .inmemory import GitInMemoryChangeset

from .workdir import GitWorkdir

SHA_PATTERN = re.compile(r'^([0-9a-fA-F]{12}|[0-9a-fA-F]{40})$')

log = logging.getLogger(__name__)

class GitRepository(BaseRepository):

    """

    Git repository backend.

    """

    DEFAULT_BRANCH_NAME = 'master'

    scm = 'git'

    def __init__(self, repo_path, create=False, src_url=None,

                 update_after_clone=False, bare=False):

        self.path = abspath(repo_path)

        stdout, _stderr = self._run_git_command(cmd, cwd=cwd)

        return safe_str(stdout)

    @classmethod

    def _check_url(cls, url):

        """

        Function will check given url and try to verify if it's a valid

        link. Sometimes it may happened that git will issue basic

        auth request that can cause whole API to hang when used from python

        or other external calls.

        On failures it'll raise urllib2.HTTPError, exception is also thrown

        when the return code is non 200

        """

        # check first if it's not an local url

        if os.path.isdir(url) or url.startswith('file:'):

            return True

        if url.startswith('git://'):

            return True

        if '+' in url[:url.find('://')]:

            url = url[url.find('+') + 1:]

        url_obj = mercurial.util.url(safe_bytes(url))

        if not test_uri.endswith(b'info/refs'):

            test_uri = test_uri.rstrip(b'/') + b'/info/refs'

        url_obj.passwd = b'*****'

        cleaned_uri = str(url_obj)

        o = urllib.request.build_opener(*handlers)

        o.addheaders = [('User-Agent', 'git/1.7.8.0')]  # fake some git

        req = urllib.request.Request(

            "%s?%s" % (

                safe_str(test_uri),

                urllib.parse.urlencode({"service": 'git-upload-pack'})

            ))

        try:

            resp = o.open(req)

            if resp.code != 200:

                raise Exception('Return Code is not 200')

        except Exception as e:

            # means it cannot be cloned

            raise urllib.error.URLError("[%s] org_exc: %s" % (cleaned_uri, e))

        # now detect if it's proper git repo

        gitdata = resp.read()

        if b'service=git-upload-pack' not in gitdata:

            raise urllib.error.URLError(

                "url [%s] does not look like an git" % cleaned_uri)

        return True

import datetime

import logging

import os

import time

import urllib.error

import urllib.parse

import urllib.request

from collections import OrderedDict

import mercurial.commands

import mercurial.error

import mercurial.exchange

import mercurial.hg

import mercurial.hgweb

import mercurial.httppeer

import mercurial.localrepo

import mercurial.match

import mercurial.mdiff

import mercurial.node

import mercurial.patch

import mercurial.scmutil

import mercurial.sshpeer

import mercurial.tags

import mercurial.ui

import mercurial.util

from kallithea.lib.vcs.backends.base import BaseRepository, CollectionGenerator

from kallithea.lib.vcs.exceptions import (BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError, TagAlreadyExistError,

                                          TagDoesNotExistError, VCSError)

from kallithea.lib.vcs.utils import ascii_str, author_email, author_name, date_fromtimestamp, makedate, safe_bytes, safe_str

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.utils.paths import abspath

from .changeset import MercurialChangeset

from .inmemory import MercurialInMemoryChangeset

from .workdir import MercurialWorkdir

log = logging.getLogger(__name__)

class MercurialRepository(BaseRepository):

    """

    Mercurial repository backend

    """

    DEFAULT_BRANCH_NAME = 'default'

    scm = 'hg'

    def __init__(self, repo_path, create=False, baseui=None, src_url=None,

                 update_after_clone=False):

        """

        Raises RepositoryError if repository could not be find at the given

        ``repo_path``.

        """

        Function will check given url and try to verify if it's a valid

        link. Sometimes it may happened that mercurial will issue basic

        auth request that can cause whole API to hang when used from python

        or other external calls.

        On failures it'll raise urllib2.HTTPError, exception is also thrown

        when the return code is non 200

        """

        # check first if it's not an local url

        url = safe_bytes(url)

        if os.path.isdir(url) or url.startswith(b'file:'):

            return True

        if url.startswith(b'ssh:'):

            # in case of invalid uri or authentication issues, sshpeer will

            # throw an exception.

            mercurial.sshpeer.instance(repoui or mercurial.ui.ui(), url, False).lookup(b'tip')

            return True

        url_prefix = None

        if b'+' in url[:url.find(b'://')]:

            url_prefix, url = url.split(b'+', 1)

        url_obj = mercurial.util.url(url)

        url_obj.passwd = b'*****'

        cleaned_uri = str(url_obj)

        o = urllib.request.build_opener(*handlers)

        o.addheaders = [('Content-Type', 'application/mercurial-0.1'),

                        ('Accept', 'application/mercurial-0.1')]

        req = urllib.request.Request(

            "%s?%s" % (

                test_uri,

                urllib.parse.urlencode({

                    'cmd': 'between',

                    'pairs': "%s-%s" % ('0' * 40, '0' * 40),

                })

            ))

        try:

            resp = o.open(req)

            if resp.code != 200:

                raise Exception('Return Code is not 200')

        except Exception as e:

            # means it cannot be cloned

            raise urllib.error.URLError("[%s] org_exc: %s" % (cleaned_uri, e))

        if not url_prefix: # skip svn+http://... (and git+... too)

            # now check if it's a proper hg repo

            try:

"""

Utilities aimed to help achieve mostly basic tasks.

"""

import datetime

import os

import re

import time

from kallithea.lib.vcs.exceptions import RepositoryError, VCSError

from kallithea.lib.vcs.utils.paths import abspath

ALIASES = ['hg', 'git']

def get_scm(path, search_up=False, explicit_alias=None):

    """

    Returns one of alias from ``ALIASES`` (in order of precedence same as

    shortcuts given in ``ALIASES``) and top working dir path for the given

    argument. If no scm-specific directory is found or more than one scm is

    found at that directory, ``VCSError`` is raised.

    :param search_up: if set to ``True``, this function would try to

      move up to parent directory every time no scm is recognized for the

      currently checked path. Default: ``False``.

    :param explicit_alias: can be one of available backend aliases, when given

      it will return given explicit alias in repositories under more than one

      version control, if explicit_alias is different than found it will raise

      VCSError

    """

    if not os.path.isdir(path):

    else:

        days = 0

        matched = re.match(

            r'^((?P<weeks>\d+) ?w(eeks?)?)? ?((?P<days>\d+) ?d(ays?)?)?$', text)

        if matched:

            groupdict = matched.groupdict()

            if groupdict['days']:

                days += int(matched.groupdict()['days'])

            if groupdict['weeks']:

                days += int(matched.groupdict()['weeks']) * 7

            past = datetime.datetime.now() - datetime.timedelta(days=days)

            return datetime.datetime(*past.timetuple()[:3])

    raise ValueError('Wrong date: "%s"' % text)

def get_dict_for_attrs(obj, attrs):

    """

    Returns dictionary for each attribute from given ``obj``.

    """

    data = {}

    for attr in attrs:

        data[attr] = getattr(obj, attr)

    return data