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

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

# Sequences

RESET_SEQ = "\033[0m"

COLOR_SEQ = "\033[0;%dm"

BOLD_SEQ = "\033[1m"

COLORS = {

    'CRITICAL': MAGENTA,

    'ERROR': RED,

    'WARNING': CYAN,

    'INFO': GREEN,

    'DEBUG': BLUE,

    'SQL': YELLOW

}

def one_space_trim(s):

    if s.find("  ") == -1:

        return s

    else:

        s = s.replace('  ', ' ')

        return one_space_trim(s)

def format_sql(sql):

    sql = sql.replace('\n', '')

    sql = one_space_trim(sql)

    sql = sql \

        .replace(',', ',\n\t') \

        .replace('SELECT', '\n\tSELECT \n\t') \

        .replace('UPDATE', '\n\tUPDATE \n\t') \

        .replace('DELETE', '\n\tDELETE \n\t') \

        .replace('FROM', '\n\tFROM') \

        .replace('ORDER BY', '\n\tORDER BY') \

        .replace('LIMIT', '\n\tLIMIT') \

        .replace('WHERE', '\n\tWHERE') \

        .replace('AND', '\n\tAND') \

        .replace('LEFT', '\n\tLEFT') \

        .replace('INNER', '\n\tINNER') \

        .replace('INSERT', '\n\tINSERT') \

        .replace('DELETE', '\n\tDELETE')

    return sql

class ColorFormatter(logging.Formatter):

    def __init__(self, *args, **kwargs):

        # can't do super(...) here because Formatter is an old school class

        logging.Formatter.__init__(self, *args, **kwargs)

    def format(self, record):

        """

        Changes record's levelname to use with COLORS enum

        """

        levelname = record.levelname

        start = COLOR_SEQ % (COLORS[levelname])

        def_record = logging.Formatter.format(self, record)

        end = RESET_SEQ

        colored_record = ''.join([start, def_record, end])

        return colored_record

class ColorFormatterSql(logging.Formatter):

    def __init__(self, *args, **kwargs):

        # can't do super(...) here because Formatter is an old school class

        logging.Formatter.__init__(self, *args, **kwargs)

    def format(self, record):

        """

        Changes record's levelname to use with COLORS enum

        """

        start = COLOR_SEQ % (COLORS['SQL'])

        def_record = format_sql(logging.Formatter.format(self, record))

        end = RESET_SEQ

        colored_record = ''.join([start, def_record, end])

        return colored_record

                    else:

                        if aln:

                            lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))

                        else:

                            lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        else:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if aln:

                        lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))

                    else:

                        lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        # in case you wonder about the seemingly redundant <div> here: since the

        # content in the other cell also is wrapped in a div, some browsers in

        # some configurations seem to mess up the formatting...

        if nocls:

            yield 0, ('<table class="%stable">' % self.cssclass +

                      '<tr><td><div class="linenodiv">'

                      '<pre>' + ls + '</pre></div></td>'

                      '<td id="hlcode" class="code">')

        else:

            yield 0, ('<table class="%stable">' % self.cssclass +

                      '<tr><td class="linenos"><div class="linenodiv">'

                      '<pre>' + ls + '</pre></div></td>'

                      '<td id="hlcode" class="code">')

        yield 0, ''.join(inner_lines)

        yield 0, '</td></tr></table>'

_whitespace_re = re.compile(r'(\t)|( )(?=\n|</div>)')

def _markup_whitespace(m):

    groups = m.groups()

    if groups[0]:

        return '<u>\t</u>'

    if groups[1]:

        return ' <i></i>'

def markup_whitespace(s):

    return _whitespace_re.sub(_markup_whitespace, s)

def pygmentize(filenode, **kwargs):

    """

    pygmentize function using pygments

    :param filenode:

    """

    lexer = get_custom_lexer(filenode.extension) or filenode.lexer

    return literal(markup_whitespace(

        code_highlight(safe_unicode(filenode.content), lexer, CodeHtmlFormatter(**kwargs))))

def hsv_to_rgb(h, s, v):

    if s == 0.0:

        return v, v, v

    i = int(h * 6.0)  # XXX assume int() truncates!

    f = (h * 6.0) - i

    p = v * (1.0 - s)

    q = v * (1.0 - s * f)

    t = v * (1.0 - s * (1.0 - f))

    i = i % 6

    if i == 0:

        return v, t, p

    if i == 1:

        return q, v, p

    if i == 2:

        return p, v, t

    if i == 3:

        return p, q, v

    if i == 4:

        return t, p, v

    if i == 5:

        return v, p, q

def gen_color(n=10000):

    """generator for getting n of evenly distributed colors using

    hsv color and golden ratio. It always return same order of colors

    :returns: RGB tuple

    """

    golden_ratio = 0.618033988749895

    h = 0.22717784590367374

        h += golden_ratio

        h %= 1

        HSV_tuple = [h, 0.95, 0.95]

        RGB_tuple = hsv_to_rgb(*HSV_tuple)

        yield [str(int(x * 256)) for x in RGB_tuple]

def pygmentize_annotation(repo_name, filenode, **kwargs):

    """

    pygmentize function for annotation

    :param filenode:

    """

    cgenerator = gen_color()

    color_dict = {}

    def get_color_string(cs):

        if cs in color_dict:

            col = color_dict[cs]

        else:

            col = color_dict[cs] = next(cgenerator)

        return "color: rgb(%s)! important;" % (', '.join(col))

    def url_func(changeset):

        author = escape(changeset.author)

        date = changeset.date

        message = escape(changeset.message)

        tooltip_html = ("<b>Author:</b> %s<br/>"

                        "<b>Date:</b> %s</b><br/>"

                        "<b>Message:</b> %s") % (author, date, message)

        lnk_format = show_id(changeset)

        uri = link_to(

                lnk_format,

                url('changeset_home', repo_name=repo_name,

                    revision=changeset.raw_id),

                style=get_color_string(changeset.raw_id),

                **{'data-toggle': 'popover',

                   'data-content': tooltip_html}

              )

        uri += '\n'

        return uri

    return literal(markup_whitespace(annotate_highlight(filenode, url_func, **kwargs)))

class _Message(object):

    """A message returned by ``pop_flash_messages()``.

    Converting the message to a string returns the message text. Instances

    also have the following attributes:

    * ``category``: the category specified when the message was created.

    * ``message``: the html-safe message text.

    """

    def __init__(self, category, message):

        self.category = category

        self.message = message

def _session_flash_messages(append=None, clear=False):

    """Manage a message queue in tg.session: return the current message queue

    after appending the given message, and possibly clearing the queue."""

    key = 'flash'

    from tg import session

    if key in session:

        flash_messages = session[key]

    else:

        if append is None:  # common fast path - also used for clearing empty queue

            return []  # don't bother saving

        flash_messages = []

        session[key] = flash_messages

    if append is not None and append not in flash_messages:

        flash_messages.append(append)

    if clear:

        session.pop(key, None)

    session.save()

    return flash_messages

def flash(message, category, logf=None):

    """

    Show a message to the user _and_ log it through the specified function

    category: notice (default), warning, error, success

    logf: a custom log function - such as log.debug

    logf defaults to log.info, unless category equals 'success', in which

    case logf defaults to log.debug.

    """

    assert category in ('error', 'success', 'warning'), category

    if hasattr(message, '__html__'):

        # render to HTML for storing in cookie

        safe_message = unicode(message)

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

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import time

from sqlalchemy.interfaces import ConnectionProxy

log = logging.getLogger('timerproxy')

def color_sql(sql):

    COLOR_SEQ = "\033[1;%dm"

    COLOR_SQL = YELLOW

    normal = '\x1b[0m'

    return ''.join([COLOR_SEQ % COLOR_SQL, sql, normal])

class TimerProxy(ConnectionProxy):

    def __init__(self):

        super(TimerProxy, self).__init__()

    def cursor_execute(self, execute, cursor, statement, parameters,

                       context, executemany):

        now = time.time()

        try:

            log.info(color_sql(">>>>> STARTING QUERY >>>>>"))

            return execute(cursor, statement, parameters, context)

        finally:

            total = time.time() - now

            log.info(color_sql("<<<<< TOTAL TIME: %f <<<<<" % total))

# encoding: UTF-8

from __future__ import print_function

import datetime

import string

import sys

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

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

        total_seconds = self.get_total_time().total_seconds()

        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:

            total_seconds = self.get_total_time().total_seconds()

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

        'NOTICE':       { 'fg': 'red' },

        'SQL_FIELD':    { 'fg': 'green', 'opts': ('bold',) },

        'SQL_COLTYPE':  { 'fg': 'green' },

        'SQL_KEYWORD':  { 'fg': 'yellow' },

        'SQL_TABLE':    { 'opts': ('bold',) },

        'HTTP_INFO':         { 'opts': ('bold',) },

        'HTTP_SUCCESS':      { },

        'HTTP_REDIRECT':     { 'fg': 'green' },

        'HTTP_NOT_MODIFIED': { 'fg': 'cyan' },

        'HTTP_BAD_REQUEST':  { 'fg': 'red', 'opts': ('bold',) },

        'HTTP_NOT_FOUND':    { 'fg': 'yellow' },

        'HTTP_SERVER_ERROR': { 'fg': 'magenta', 'opts': ('bold',) },

    },

    LIGHT_PALETTE: {

        'ERROR':        { 'fg': 'red', 'opts': ('bold',) },

        'NOTICE':       { 'fg': 'red' },

        'SQL_FIELD':    { 'fg': 'green', 'opts': ('bold',) },

        'SQL_COLTYPE':  { 'fg': 'green' },

        'SQL_KEYWORD':  { 'fg': 'blue' },

        'SQL_TABLE':    { 'opts': ('bold',) },

        'HTTP_INFO':         { 'opts': ('bold',) },

        'HTTP_SUCCESS':      { },

        'HTTP_REDIRECT':     { 'fg': 'green', 'opts': ('bold',) },

        'HTTP_NOT_MODIFIED': { 'fg': 'green' },

        'HTTP_BAD_REQUEST':  { 'fg': 'red', 'opts': ('bold',) },

        'HTTP_NOT_FOUND':    { 'fg': 'red' },

        'HTTP_SERVER_ERROR': { 'fg': 'magenta', 'opts': ('bold',) },

    }

}

DEFAULT_PALETTE = DARK_PALETTE

# ---------------------------- #

# --- End of termcolors.py --- #

# ---------------------------- #

class ColoredProgressBar(ProgressBar):

    BAR_COLORS = (

        (10, 'red'),

        (30, 'magenta'),

        (50, 'yellow'),

        (99, 'green'),

        (100, 'blue'),

    )

    def get_line(self):

        line = super(ColoredProgressBar, self).get_line()

        perc = self.get_percentage()

        if perc > 100:

            color = 'blue'

        for max_perc, color in self.BAR_COLORS:

            if perc <= max_perc:

                break

        return colorize(line, fg=color)

class AnimatedProgressBar(ProgressBar):

    def get_bar_char(self):

        chars = '-/|\\'

        if self.step >= self.steps:

            return '='

        return chars[self.step % len(chars)]

class BarOnlyProgressBar(ProgressBar):

    default_elements = ['bar', 'steps']

    def get_bar(self):

        bar = super(BarOnlyProgressBar, self).get_bar()

        perc = self.get_percentage()

        perc_text = '%s%%' % int(perc)

        text = (' %s%% ' % (perc_text)).center(self.width, '=')

        L = text.find(' ')

        R = text.rfind(' ')

        bar = ' '.join((bar[:L], perc_text, bar[R:]))

        return bar

class AnimatedColoredProgressBar(AnimatedProgressBar,

                                 ColoredProgressBar):

    pass

class BarOnlyColoredProgressBar(ColoredProgressBar,

                                BarOnlyProgressBar):

    pass

def main():

    import time

    print("Standard progress bar...")

    bar = ProgressBar(30)

        bar.render(x)

        time.sleep(0.02)

    bar.stream.write('\n')

    print()

    print("Empty bar...")

    bar = ProgressBar(50)

    bar.render(0)

    print()

    print()

    print("Colored bar...")

    bar = ColoredProgressBar(20)

    for x in bar:

        time.sleep(0.01)

    print()

    print("Animated char bar...")

    bar = AnimatedProgressBar(20)

    for x in bar:

        time.sleep(0.01)

    print()

    print("Animated + colored char bar...")

    bar = AnimatedColoredProgressBar(20)

    for x in bar:

        time.sleep(0.01)

    print()

    print("Bar only ...")

    bar = BarOnlyProgressBar(20)

    for x in bar:

        time.sleep(0.01)

    print()

    print("Colored, longer bar-only, eta, total time ...")

    bar = BarOnlyColoredProgressBar(40)

    bar.width = 60

    bar.elements += ['time', 'eta']

    for x in bar:

        time.sleep(0.01)

    print()

    print()

    print("File transfer bar, breaks after 2 seconds ...")

    total_bytes = 1024 * 1024 * 2

    bar = ProgressBar(total_bytes)

    bar.width = 50

    bar.elements.remove('steps')

    bar.elements += ['transfer', 'time', 'eta', 'speed']

        bar.render(x)

        time.sleep(0.01)

        now = datetime.datetime.now()

        if now - bar.started >= datetime.timedelta(seconds=2):

            break

    print()

    print()

if __name__ == '__main__':

    main()

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

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.model.gist

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

gist model for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: May 9, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import os

import random

import shutil

import time

import traceback

from kallithea.lib import ext_json

from kallithea.lib.utils2 import AttributeDict, ascii_bytes, safe_int, safe_unicode, time_to_datetime

from kallithea.model.db import Gist, Session, User

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

GIST_STORE_LOC = '.rc_gist_store'

GIST_METADATA_FILE = '.rc_gist_metadata'

def make_gist_access_id():

    """Generate a random, URL safe, almost certainly unique gist identifier."""

    rnd = random.SystemRandom() # use cryptographically secure system PRNG

    alphabet = '23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjklmnpqrstuvwxyz'

    length = 20

class GistModel(object):

    def __delete_gist(self, gist):

        """

        removes gist from filesystem

        :param gist: gist object

        """

        root_path = RepoModel().repos_path

        rm_path = os.path.join(root_path, GIST_STORE_LOC, gist.gist_access_id)

        log.info("Removing %s", rm_path)

        shutil.rmtree(rm_path)

    def _store_metadata(self, repo, gist_id, gist_access_id, user_id, gist_type,

                        gist_expires):

        """

        store metadata inside the gist, this can be later used for imports

        or gist identification

        """

        metadata = {

            'metadata_version': '1',

            'gist_db_id': gist_id,

            'gist_access_id': gist_access_id,

            'gist_owner_id': user_id,

            'gist_type': gist_type,

            'gist_expires': gist_expires,

            'gist_updated': time.time(),

        }

        with open(os.path.join(repo.path, '.hg', GIST_METADATA_FILE), 'wb') as f:

            f.write(ascii_bytes(ext_json.dumps(metadata)))

    def get_gist(self, gist):

        return Gist.guess_instance(gist)

    def get_gist_files(self, gist_access_id, revision=None):

        """

        Get files for given gist

        :param gist_access_id:

        """

        repo = Gist.get_by_access_id(gist_access_id)

        cs = repo.scm_instance.get_changeset(revision)

        return cs, [n for n in cs.get_node('/')]

    def create(self, description, owner, ip_addr, gist_mapping,

               gist_type=Gist.GIST_PUBLIC, lifetime=-1):

        """

        :param description: description of the gist

        :param owner: user who created this gist

        :param gist_mapping: mapping {filename:{'content':content},...}

        :param gist_type: type of gist private/public

        :param lifetime: in minutes, -1 == forever

        """

        owner = User.guess_instance(owner)

        gist_access_id = make_gist_access_id()

        lifetime = safe_int(lifetime, -1)

        gist_expires = time.time() + (lifetime * 60) if lifetime != -1 else -1

        log.debug('set GIST expiration date to: %s',

                  time_to_datetime(gist_expires)

                   if gist_expires != -1 else 'forever')

        # create the Database version

        gist = Gist()

        gist.gist_description = description

        gist.gist_access_id = gist_access_id

        gist.owner_id = owner.user_id

        gist.gist_expires = gist_expires

        gist.gist_type = safe_unicode(gist_type)

        Session().add(gist)

        Session().flush() # make database assign gist.gist_id

        if gist_type == Gist.GIST_PUBLIC:

            # use DB ID for easy to use GIST ID

            gist.gist_access_id = unicode(gist.gist_id)

        log.debug('Creating new %s GIST repo %s', gist_type, gist.gist_access_id)

        repo = RepoModel()._create_filesystem_repo(

            repo_name=gist.gist_access_id, repo_type='hg', repo_group=GIST_STORE_LOC)

        processed_mapping = {}

        for filename in gist_mapping:

            if filename != os.path.basename(filename):

                raise Exception('Filename cannot be inside a directory')

            content = gist_mapping[filename]['content']

            # TODO: expand support for setting explicit lexers

#             if lexer is None:

#                 try:

#                     guess_lexer = pygments.lexers.guess_lexer_for_filename

#                     lexer = guess_lexer(filename,content)

#                 except pygments.util.ClassNotFound:

#                     lexer = 'text'

            processed_mapping[filename] = {'content': content}

        # now create single multifile commit

class HgHttpVcsTest(HgVcsTest, HttpVcsTest):

    pass

class GitHttpVcsTest(GitVcsTest, HttpVcsTest):

    pass

class HgSshVcsTest(HgVcsTest, SshVcsTest):

    @staticmethod

    def _ssh_param(repo_name, user, ssh_key, client_ip):

        # Specify a custom ssh command on the command line

        return r"""--config ui.ssh="bash -c 'SSH_ORIGINAL_COMMAND=\"\$2\" SSH_CONNECTION=\"%s 1024 127.0.0.1 22\" kallithea-cli ssh-serve -c %s %s %s' --" ssh://someuser@somehost/%s""" % (

            client_ip,

            CONFIG['__file__'],

            user.user_id,

            ssh_key.user_ssh_key_id,

            repo_name)

class GitSshVcsTest(GitVcsTest, SshVcsTest):

    @staticmethod

    def _ssh_param(repo_name, user, ssh_key, client_ip):

        # Set a custom ssh command in the global environment

        os.environ['GIT_SSH_COMMAND'] = r"""bash -c 'SSH_ORIGINAL_COMMAND="$2" SSH_CONNECTION="%s 1024 127.0.0.1 22" kallithea-cli ssh-serve -c %s %s %s' --""" % (

            client_ip,

            CONFIG['__file__'],

            user.user_id,

            ssh_key.user_ssh_key_id)

        return "ssh://someuser@somehost/%s""" % repo_name

parametrize_vcs_test = base.parametrize('vt', [

    HgHttpVcsTest,

    GitHttpVcsTest,

    HgSshVcsTest,

    GitSshVcsTest,

])

parametrize_vcs_test_hg = base.parametrize('vt', [

    HgHttpVcsTest,

    HgSshVcsTest,

])

parametrize_vcs_test_http = base.parametrize('vt', [

    HgHttpVcsTest,

    GitHttpVcsTest,

])

class Command(object):

    def __init__(self, cwd):

        self.cwd = cwd

    def execute(self, *args, **environ):

        """

        Runs command on the system with given ``args`` using simple space

        join without safe quoting.

        """

        command = ' '.join(args)