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

# encoding: UTF-8

import sys

import datetime

import string

from kallithea.lib.vcs.utils.filesize import filesizeformat

class ProgressBarError(Exception):

    pass

class AlreadyFinishedError(ProgressBarError):

    pass

class ProgressBar(object):

    default_elements = ['percentage', 'bar', 'steps']

    def __init__(self, steps=100, stream=None, elements=None):

        self.step = 0

        self.steps = steps

        self.stream = stream or sys.stderr

        self.bar_char = '='

        self.width = 50

        self.separator = ' | '

        self.elements = elements or self.default_elements

        self.started = None

        self.finished = False

        separator = self.get_separator()

        elements = self.get_elements()

        return string.Template(separator.join((('$%s' % e) for e in elements)))

    def get_total_time(self, current_time=None):

        if current_time is None:

            current_time = datetime.datetime.now()

        if not self.started:

            return datetime.timedelta()

        return current_time - self.started

    def get_rendered_total_time(self):

        delta = self.get_total_time()

        if not delta:

            ttime = '-'

        else:

            ttime = str(delta)

        return '%s %s' % (self.time_label, ttime)

    def get_eta(self, current_time=None):

        if current_time is None:

            current_time = datetime.datetime.now()

        if self.step == 0:

            return datetime.timedelta()

        eta_seconds = total_seconds * self.steps / self.step - total_seconds

        return datetime.timedelta(seconds=int(eta_seconds))

    def get_rendered_eta(self):

        eta = self.get_eta()

        if not eta:

            eta = '--:--:--'

        else:

            eta = str(eta).rjust(8)

        return '%s: %s' % (self.eta_label, eta)

    def get_percentage(self):

        return float(self.step) / self.steps * 100

    def get_rendered_percentage(self):

        perc = self.get_percentage()

        return ('%s%%' % (int(perc))).rjust(5)

    def get_rendered_steps(self):

        return '%s: %s/%s' % (self.steps_label, self.step, self.steps)

    def get_rendered_speed(self, step=None, total_seconds=None):

        if step is None:

            step = self.step

        if total_seconds is None:

        if step <= 0 or total_seconds <= 0:

            speed = '-'

        else:

            speed = filesizeformat(float(step) / total_seconds)

        return '%s: %s/s' % (self.speed_label, speed)

    def get_rendered_transfer(self, step=None, steps=None):

        if step is None:

            step = self.step

        if steps is None:

            steps = self.steps

        if steps <= 0:

            return '%s: -' % self.transfer_label

        total = filesizeformat(float(steps))

        if step <= 0:

            transferred = '-'

        else:

            transferred = filesizeformat(float(step))

        return '%s: %s / %s' % (self.transfer_label, transferred, total)

    def get_context(self):

        return {

            'percentage': self.get_rendered_percentage(),

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

import os

import mock

import time

import shutil

import datetime

import pytest

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

from kallithea.lib.vcs.utils.helpers import get_dict_for_attrs

from kallithea.lib.vcs.utils.helpers import get_scm

from kallithea.lib.vcs.utils.helpers import get_scms_for_path

from kallithea.lib.vcs.utils.helpers import parse_changesets

from kallithea.lib.vcs.utils.helpers import parse_datetime

from kallithea.lib.vcs.utils import author_email, author_name

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

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.tests.vcs.conf import TEST_HG_REPO, TEST_GIT_REPO, TESTS_TMP_PATH

class TestPaths(object):

    def _test_get_dirs_for_path(self, path, expected):

        """

        Tests if get_dirs_for_path returns same as expected.

        """

        expected = sorted(expected)

        result = sorted(get_dirs_for_path(path))

        assert result == expected, \

            "%s != %s which was expected result for path %s" % (result, expected, path)

    def test_get_dirs_for_path(self):

        path = 'foo/bar/baz/file'

        paths_and_results = (

            ('foo/bar/baz/file', ['foo', 'foo/bar', 'foo/bar/baz']),

        for test_str, result in self.TEST_AUTHORS:

            assert result[0] == author_name(test_str)

class TestGetDictForAttrs(object):

    def test_returned_dict_has_expected_attrs(self):

        obj = mock.Mock()

        obj.NOT_INCLUDED = 'this key/value should not be included'

        obj.CONST = True

        obj.foo = 'aaa'

        obj.attrs = {'foo': 'bar'}

        obj.date = datetime.datetime(2010, 12, 31)

        obj.count = 1001

        assert get_dict_for_attrs(obj, ['CONST', 'foo', 'attrs', 'date', 'count']) ==  {

            'CONST': True,

            'foo': 'aaa',

            'attrs': {'foo': 'bar'},

            'date': datetime.datetime(2010, 12, 31),

            'count': 1001,

        }

class TestGetUserHome(object):

    @mock.patch.object(os, 'environ', {})

    def test_defaults_to_none(self):

        assert get_user_home() == ''

    @mock.patch.object(os, 'environ', {'HOME': '/home/foobar'})

    def test_unix_like(self):

        assert get_user_home() == '/home/foobar'

    @mock.patch.object(os, 'environ', {'USERPROFILE': '/Users/foobar'})

    def test_windows_like(self):

        assert get_user_home() == '/Users/foobar'

    @mock.patch.object(os, 'environ', {'HOME': '/home/foobar',

        'USERPROFILE': '/Users/foobar'})

    def test_prefers_home_over_userprofile(self):

        assert get_user_home() == '/home/foobar'