# -*- 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

                    if isinstance(x, tuple) and len(x) == 2:

                        group_value, group_label = x

                    elif isinstance(x, basestring):

                        group_value = group_label = x

                    else:

                        log.error('invalid select option %r', x)

                        raise

                    og.add_option(group_label, group_value)

            else:

                options.add_option(label, value)

    return webhelpers2_select(name, selected_values, options, id=id, **attrs)

safeid = _make_safe_id_component

def FID(raw_id, path):

    """

    Creates a unique ID for filenode based on it's hash of path and revision

    it's safe to use in urls

    :param raw_id:

    :param path:

    """

    return 'C-%s-%s' % (short_id(raw_id), hashlib.md5(safe_bytes(path)).hexdigest()[:12])

class _FilesBreadCrumbs(object):

    def __call__(self, repo_name, rev, paths):

        if isinstance(paths, str):

            paths = safe_unicode(paths)

        url_l = [link_to(repo_name, url('files_home',

                                        repo_name=repo_name,

                                        revision=rev, f_path=''),

                         class_='ypjax-link')]

        paths_l = paths.split('/')

        for cnt, p in enumerate(paths_l):

            if p != '':

                url_l.append(link_to(p,

                                     url('files_home',

                                         repo_name=repo_name,

                                         revision=rev,

                                         f_path='/'.join(paths_l[:cnt + 1])

                                         ),

                                     class_='ypjax-link'

                                     )

                             )

        return literal('/'.join(url_l))

files_breadcrumbs = _FilesBreadCrumbs()

class CodeHtmlFormatter(HtmlFormatter):

    """

    My code Html Formatter for source codes

    """

    def wrap(self, source, outfile):

        return self._wrap_div(self._wrap_pre(self._wrap_code(source)))

    def _wrap_code(self, source):

        for cnt, it in enumerate(source):

            i, t = it

            t = '<span id="L%s">%s</span>' % (cnt + 1, t)

            yield i, t

    def _wrap_tablelinenos(self, inner):

        inner_lines = []

        lncount = 0

        for t, line in inner:

            if t:

                lncount += 1

            inner_lines.append(line)

        fl = self.linenostart

        mw = len(str(lncount + fl - 1))

        sp = self.linenospecial

        st = self.linenostep

        la = self.lineanchors

        aln = self.anchorlinenos

        nocls = self.noclasses

        if sp:

            lines = []

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

                if i % st == 0:

                    if i % sp == 0:

                        if aln:

                            lines.append('<a href="#%s%d" class="special">%*d</a>' %

                                         (la, i, mw, i))

                        else:

                            lines.append('<span class="special">%*d</span>' % (mw, i))

                    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)

    else:

        # Apply str - the message might be an exception with __str__

        # Escape, so we can trust the result without further escaping, without any risk of injection

        safe_message = html_escape(unicode(message))

    if logf is None:

        logf = log.info

        if category == 'success':

            logf = log.debug

    logf('Flash %s: %s', category, safe_message)

    _session_flash_messages(append=(category, safe_message))

def pop_flash_messages():

    """Return all accumulated messages and delete them from the session.

    The return value is a list of ``Message`` objects.

    """

    return [_Message(category, message) for category, message in _session_flash_messages(clear=True)]

age = lambda x, y=False: _age(x, y)

capitalize = lambda x: x.capitalize()

email = author_email

short_id = lambda x: x[:12]

hide_credentials = lambda x: ''.join(credentials_filter(x))

def show_id(cs):

    """

    Configurable function that shows ID

    by default it's r123:fffeeefffeee

    :param cs: changeset instance

    """

    from kallithea import CONFIG

    def_len = safe_int(CONFIG.get('show_sha_length', 12))

    show_rev = str2bool(CONFIG.get('show_revision_number', False))

    raw_id = cs.raw_id[:def_len]

    if show_rev:

        return 'r%s:%s' % (cs.revision, raw_id)

    else:

        return raw_id

def fmt_date(date):

    if date:

        return date.strftime("%Y-%m-%d %H:%M:%S")

    return ""

def is_git(repository):

    if hasattr(repository, 'alias'):

        _type = repository.alias

    elif hasattr(repository, 'repo_type'):

        _type = repository.repo_type

    else:

        _type = repository

    return _type == 'git'

def is_hg(repository):

    if hasattr(repository, 'alias'):

        _type = repository.alias

    elif hasattr(repository, 'repo_type'):

        _type = repository.repo_type

    else:

        _type = repository

    return _type == 'hg'

@cache_region('long_term', 'user_attr_or_none')

def user_attr_or_none(author, show_attr):

    """Try to match email part of VCS committer string with a local user and return show_attr

    - or return None if user not found"""

    email = author_email(author)

    if email:

        from kallithea.model.db import User

        user = User.get_by_email(email, cache=True) # cache will only use sql_cache_short

        if user is not None:

            return getattr(user, show_attr)

    return None

def email_or_none(author):

    """Try to match email part of VCS committer string with a local user.

    Return primary email of user, email part of the specified author name, or None."""

    if not author:

        return None

    email = user_attr_or_none(author, 'email')

    if email is not None:

        return email # always use user's main email address - not necessarily the one used to find user

    # extract email from the commit string

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

            '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'

    """

    code_list = []

    if text == '' and len(opts) == 1 and opts[0] == 'reset':

        return '\x1b[%sm' % RESET

    for k, v in kwargs.items():

        if k == 'fg':

            code_list.append(foreground[v])

        elif k == 'bg':

            code_list.append(background[v])

    for o in opts:

        if o in opt_dict:

            code_list.append(opt_dict[o])

    if 'noreset' not in opts:

        text = text + '\x1b[%sm' % RESET

    return ('\x1b[%sm' % ';'.join(code_list)) + text

def make_style(opts=(), **kwargs):

    """

    Returns a function with default parameters for colorize()

    Example:

        bold_red = make_style(opts=('bold',), fg='red')

        print bold_red('hello')

        KEYWORD = make_style(fg='yellow')

        COMMENT = make_style(fg='blue', opts=('bold',))

    """

    return lambda text: colorize(text, opts, **kwargs)

NOCOLOR_PALETTE = 'nocolor'

DARK_PALETTE = 'dark'

LIGHT_PALETTE = 'light'

PALETTES = {

    NOCOLOR_PALETTE: {

        'ERROR':        {},

        'NOTICE':       {},

        'SQL_FIELD':    {},

        'SQL_COLTYPE':  {},

        'SQL_KEYWORD':  {},

        'SQL_TABLE':    {},

        'HTTP_INFO':         {},

        'HTTP_SUCCESS':      {},

        'HTTP_REDIRECT':     {},

        'HTTP_NOT_MODIFIED': {},

        'HTTP_BAD_REQUEST':  {},

        'HTTP_NOT_FOUND':    {},

        'HTTP_SERVER_ERROR': {},

    },

    DARK_PALETTE: {

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

        '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):