def parse_changesets(text):

    """

    Returns dictionary with *start*, *main* and *end* ids.

    Examples::

        >>> parse_changesets('aaabbb')

        {'start': None, 'main': 'aaabbb', 'end': None}

        >>> parse_changesets('aaabbb..cccddd')

        {'start': 'aaabbb', 'main': None, 'end': 'cccddd'}

    """

    text = text.strip()

    CID_RE = r'[a-zA-Z0-9]+'

    if '..' not in text:

        m = re.match(r'^(?P<cid>%s)$' % CID_RE, text)

        if m:

            return {

                'start': None,

                'main': text,

                'end': None,

            }

    else:

        RE = r'^(?P<start>%s)?\.{2,3}(?P<end>%s)?$' % (CID_RE, CID_RE)

        m = re.match(RE, text)

        if m:

            result = m.groupdict()

            result['main'] = None

            return result

    raise ValueError("IDs not recognized")

def parse_datetime(text):

    """

    Parses given text and returns ``datetime.datetime`` instance or raises

    ``ValueError``.

    :param text: string of desired date/datetime or something more verbose,

      like *yesterday*, *2weeks 3days*, etc.

    """

    text = text.strip().lower()

    INPUT_FORMATS = (

        '%Y-%m-%d %H:%M:%S',

        '%Y-%m-%d %H:%M',

        '%Y-%m-%d',

        '%m/%d/%Y %H:%M:%S',

        '%m/%d/%Y %H:%M',

        '%m/%d/%Y',

        '%m/%d/%y %H:%M:%S',

        '%m/%d/%y %H:%M',

        '%m/%d/%y',

    )

    for format in INPUT_FORMATS:

        try:

            return datetime.datetime(*time.strptime(text, format)[:6])

        except ValueError:

            pass

    # Try descriptive texts

    if text == 'tomorrow':

        future = datetime.datetime.now() + datetime.timedelta(days=1)

        args = future.timetuple()[:3] + (23, 59, 59)

        return datetime.datetime(*args)

    elif text == 'today':

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

    elif text == 'now':

        return datetime.datetime.now()

    elif text == 'yesterday':

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

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

    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

        self.steps_label = 'Step'

        self.time_label = 'Time'

        self.eta_label = 'ETA'

        self.speed_label = 'Speed'

        self.transfer_label = 'Transfer'

    def __str__(self):

        return self.get_line()

    def __iter__(self):

        start = self.step

        end = self.steps + 1

        for x in xrange(start, end):

            self.render(x)

            yield x

    def get_separator(self):

        return self.separator

    def get_bar_char(self):

        return self.bar_char

    def get_bar(self):

        char = self.get_bar_char()

        perc = self.get_percentage()

        length = int(self.width * perc / 100)

        bar = char * length

        bar = bar.ljust(self.width)

        return bar

    def get_elements(self):

        return self.elements

    def get_template(self):

        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(),

            'bar': self.get_bar(),

            'steps': self.get_rendered_steps(),

            'time': self.get_rendered_total_time(),

            'eta': self.get_rendered_eta(),

            'speed': self.get_rendered_speed(),

            'transfer': self.get_rendered_transfer(),

        }

    def get_line(self):

        template = self.get_template()

        context = self.get_context()

        return template.safe_substitute(**context)

    def write(self, data):

        self.stream.write(data)

    def render(self, step):

        if not self.started:

            self.started = datetime.datetime.now()

        if self.finished:

            raise AlreadyFinishedError

        self.step = step

        self.write('\r%s' % self)

        if step == self.steps:

            self.finished = True

        if step == self.steps:

            self.write('\n')

"""

termcolors.py

Grabbed from Django (http://www.djangoproject.com)

"""

color_names = ('black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white')

foreground = dict([(color_names[x], '3%s' % x) for x in range(8)])

background = dict([(color_names[x], '4%s' % x) for x in range(8)])

RESET = '0'

opt_dict = {'bold': '1', 'underscore': '4', 'blink': '5', 'reverse': '7', 'conceal': '8'}

def colorize(text='', opts=(), **kwargs):

    """

    Returns your text, enclosed in ANSI graphics codes.

    Depends on the keyword arguments 'fg' and 'bg', and the contents of

    the opts tuple/list.

    Returns the RESET code if no parameters are given.

    Valid colors:

        'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'

    Valid options:

        'bold'

        'underscore'

        'blink'

        'reverse'

        'conceal'

        'noreset' - string will not be auto-terminated with the RESET code

    Examples:

        colorize('hello', fg='red', bg='blue', opts=('blink',))

        colorize()

        colorize('goodbye', opts=('underscore',))

        print colorize('first line', fg='red', opts=('noreset',))

        print 'this should be red too'

        print colorize('and so should this')

        print 'this should not be red'

    """

# -*- 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']),

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

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

        )

        for path, expected in paths_and_results:

            self._test_get_dirs_for_path(path, expected)

    def test_get_scm(self):

        assert ('hg', TEST_HG_REPO) == get_scm(TEST_HG_REPO)

        assert ('git', TEST_GIT_REPO) == get_scm(TEST_GIT_REPO)

    def test_get_two_scms_for_path(self):

        multialias_repo_path = os.path.join(TESTS_TMP_PATH, 'hg-git-repo-2')

        if os.path.isdir(multialias_repo_path):

            shutil.rmtree(multialias_repo_path)

        os.mkdir(multialias_repo_path)

        with pytest.raises(VCSError):

            get_scm(multialias_repo_path)

    def test_get_scm_error_path(self):

        with pytest.raises(VCSError):

            get_scm('err')

    def test_get_scms_for_path(self):

        new = os.path.join(TESTS_TMP_PATH, 'vcs-scms-for-path-%s' % time.time())

        os.mkdir(new)

        assert get_scms_for_path(new) == []

        os.mkdir(os.path.join(new, '.tux'))

        assert get_scms_for_path(new) == []

        os.mkdir(os.path.join(new, '.git'))

        assert set(get_scms_for_path(new)) == set(['git'])

        os.mkdir(os.path.join(new, '.hg'))

        assert set(get_scms_for_path(new)) == set(['git', 'hg'])

class TestParseChangesets(object):

    def test_main_is_returned_correctly(self):

        assert parse_changesets('123456') == {

            'start': None,

            'main': '123456',

            'end': None,

        }

    def test_start_is_returned_correctly(self):

        assert parse_changesets('aaabbb..') == {

            'start': 'aaabbb',

            'main': None,

            'end': None,

        }

    def test_end_is_returned_correctly(self):

        assert parse_changesets('..cccddd') == {

            'start': None,

            'main': None,

            'end': 'cccddd',

        }

    def test_that_two_or_three_dots_are_allowed(self):

        text1 = 'a..b'

        text2 = 'a...b'

        assert parse_changesets(text1) == parse_changesets(text2)

    def test_that_input_is_stripped_first(self):

        text1 = 'a..bb'

        text2 = '  a..bb\t\n\t '

        assert parse_changesets(text1) == parse_changesets(text2)

    def test_today(self):

        today = datetime.date.today()

        assert parse_datetime('today') == datetime.datetime(*today.timetuple()[:3])

    def test_yesterday(self):

        yesterday = datetime.date.today() - datetime.timedelta(days=1)

        assert parse_datetime('yesterday') == datetime.datetime(*yesterday.timetuple()[:3])

    def test_tomorrow(self):

        tomorrow = datetime.date.today() + datetime.timedelta(days=1)

        args = tomorrow.timetuple()[:3] + (23, 59, 59)

        assert parse_datetime('tomorrow') == datetime.datetime(*args)

    def test_days(self):

        timestamp = datetime.datetime.today() - datetime.timedelta(days=3)

        args = timestamp.timetuple()[:3] + (0, 0, 0, 0)

        expected = datetime.datetime(*args)

        assert parse_datetime('3d') == expected

        assert parse_datetime('3 d') == expected

        assert parse_datetime('3 day') == expected

        assert parse_datetime('3 days') == expected

    def test_weeks(self):

        timestamp = datetime.datetime.today() - datetime.timedelta(days=3 * 7)

        args = timestamp.timetuple()[:3] + (0, 0, 0, 0)

        expected = datetime.datetime(*args)

        assert parse_datetime('3w') == expected

        assert parse_datetime('3 w') == expected

        assert parse_datetime('3 week') == expected

        assert parse_datetime('3 weeks') == expected

    def test_mixed(self):

        timestamp = datetime.datetime.today() - datetime.timedelta(days=2 * 7 + 3)

        args = timestamp.timetuple()[:3] + (0, 0, 0, 0)

        expected = datetime.datetime(*args)

        assert parse_datetime('2w3d') == expected

        assert parse_datetime('2w 3d') == expected

        assert parse_datetime('2w 3 days') == expected

        assert parse_datetime('2 weeks 3 days') == expected

class TestAuthorExtractors(object):

    TEST_AUTHORS = [("Username Last'o'Name <username@example.com>",

                    ("Username Last'o'Name", "username@example.com")),

                  ("Username Last'o'Name Spaces < username@example.com >",

                    ("Username Last'o'Name Spaces", "username@example.com")),

                  ("Username Last'o'Name <username.lastname@example.com>",

                    ("Username Last'o'Name", "username.lastname@example.com")),

                  ('mrf RFC_SPEC <username+lastname@example.com>',

                    ('mrf RFC_SPEC', 'username+lastname@example.com')),

                  ('username <user@example.com>',

                    ('username', 'user@example.com')),

                  ('username <user@example.com',

                   ('username', 'user@example.com')),

                  ('broken missing@example.com',

                   ('broken', 'missing@example.com')),

                  ('<justemail@example.com>',

                   ('', 'justemail@example.com')),

                  ('justname',

                   ('justname', '')),

                  ('Mr Double Name withemail@example.com ',

                   ('Mr Double Name', 'withemail@example.com')),

                  (u'John Doe <джондо à éẋàṁṗłê.ç°ḿ>',

                   (u'John Doe <\u0434\u0436\u043e\u043d\u0434\u043e \xe0 \xe9\u1e8b\xe0\u1e41\u1e57\u0142\xea.\xe7\xb0\u1e3f>', '')),

                  ]

    def test_author_email(self):

        for test_str, result in self.TEST_AUTHORS:

            assert result[1] == author_email(test_str)

    def test_author_name(self):

        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'