args, other = parser.parse_known_args()

    return parser, args, other

def _run(argv):

    conf = None

    parser, args, other = argparser(argv)

    api_credentials_given = (args.apikey and args.apihost)

    if args.save_config:

        if not api_credentials_given:

            raise parser.error('--save-config requires --apikey and --apihost')

        conf = RcConf(config_location=args.config,

                      autocreate=True, config={'apikey': args.apikey,

                                               'apihost': args.apihost})

        sys.exit()

    if not conf:

        conf = RcConf(config_location=args.config, autoload=True)

        if not conf:

            if not api_credentials_given:

                parser.error('Could not find config file and missing '

                             '--apikey or --apihost in params')

    apikey = args.apikey or conf['apikey']

    host = args.apihost or conf['apihost']

    DEFAULT_FILENAME = 'gistfile1.txt'

    if other:

        # skip multifiles for now

        filename = other[0]

        if filename == '-':

            filename = DEFAULT_FILENAME

            gist_content = ''

            for line in fileinput.input('-'):

                gist_content += line

        else:

            with open(filename, 'rb') as f:

                gist_content = f.read()

    else:

        filename = DEFAULT_FILENAME

        gist_content = None

        # little bit hacky but cross platform check where the

        # stdin comes from we skip the terminal case it can be handled by '-'

        mode = os.fstat(0).st_mode

        if stat.S_ISFIFO(mode):

            # "stdin is piped"

            gist_content = sys.stdin.read()

        elif stat.S_ISREG(mode):

            # "stdin is redirected"

            gist_content = sys.stdin.read()

        else:

            # "stdin is terminal"

            pass

    # make sure we don't upload binary stuff

    if gist_content and '\0' in gist_content:

        raise Exception('Error: binary files upload is not possible')

    filename = os.path.basename(args.filename or filename)

    if gist_content:

        files = {

            filename: {

                'content': gist_content,

                'lexer': None

            }

        }

        margs = dict(

            gist_lifetime=args.lifetime,

            gist_description=args.description,

            gist_type='private' if args.private else 'public',

            files=files

        )

        json_data = api_call(apikey, host, 'create_gist', **margs)['result']

        if args.format == FORMAT_JSON:

            print json.dumps(json_data)

        elif args.format == FORMAT_PRETTY:

            print 'Created %s gist %s' % (json_data['gist_type'],

                                          json_data['gist_url'])

    return 0

def main(argv=None):

    """

    Main execution function for cli

    :param argv:

    """

    if argv is None:

        argv = sys.argv

    try:

        return _run(argv)

    except Exception, e:

        print e

        return 1

if __name__ == '__main__':

    sys.exit(main(sys.argv))

    try:

        val = int(val)

    except (ValueError, TypeError):

        val = default

    return val

def safe_unicode(str_, from_encoding=None):

    """

    safe unicode function. Does few trick to turn str_ into unicode

    In case of UnicodeDecode error we try to return it with encoding detected

    by chardet library if it fails fallback to unicode with errors replaced

    :param str_: string to decode

    :rtype: unicode

    :returns: unicode object

    """

    if isinstance(str_, unicode):

        return str_

    if not from_encoding:

        import rhodecode

        DEFAULT_ENCODINGS = aslist(rhodecode.CONFIG.get('default_encoding',

                                                        'utf8'), sep=',')

        from_encoding = DEFAULT_ENCODINGS

    if not isinstance(from_encoding, (list, tuple)):

        from_encoding = [from_encoding]

    try:

        return unicode(str_)

    except UnicodeDecodeError:

        pass

    for enc in from_encoding:

        try:

            return unicode(str_, enc)

        except UnicodeDecodeError:

            pass

    try:

        import chardet

        encoding = chardet.detect(str_)['encoding']

        if encoding is None:

            raise Exception()

        return str_.decode(encoding)

    except (ImportError, UnicodeDecodeError, Exception):

        return unicode(str_, from_encoding[0], 'replace')

def safe_str(unicode_, to_encoding=None):

    """

    safe str function. Does few trick to turn unicode_ into string

    In case of UnicodeEncodeError we try to return it with encoding detected

    by chardet library if it fails fallback to string with errors replaced

    :param unicode_: unicode to encode

    :rtype: str

    :returns: str object

    """

    # if it's not basestr cast to str

    if not isinstance(unicode_, basestring):

        return str(unicode_)

    if isinstance(unicode_, str):

        return unicode_

    if not to_encoding:

        import rhodecode

        DEFAULT_ENCODINGS = aslist(rhodecode.CONFIG.get('default_encoding',

                                                        'utf8'), sep=',')

        to_encoding = DEFAULT_ENCODINGS

    if not isinstance(to_encoding, (list, tuple)):

        to_encoding = [to_encoding]

    for enc in to_encoding:

        try:

            return unicode_.encode(enc)

        except UnicodeEncodeError:

            pass

    try:

        import chardet

        encoding = chardet.detect(unicode_)['encoding']

        if encoding is None:

            raise UnicodeEncodeError()

        return unicode_.encode(encoding)

    except (ImportError, UnicodeEncodeError):

        return unicode_.encode(to_encoding[0], 'replace')

def remove_suffix(s, suffix):

    if s.endswith(suffix):

        s = s[:-1 * len(suffix)]

    return s

def remove_prefix(s, prefix):

    if s.startswith(prefix):

        s = s[len(prefix):]

    return s

def engine_from_config(configuration, prefix='sqlalchemy.', **kwargs):

    """

    Custom engine_from_config functions that makes sure we use NullPool for

    file based sqlite databases. This prevents errors on sqlite. This only

    applies to sqlalchemy versions < 0.7.0

    """

    import sqlalchemy

    from sqlalchemy import engine_from_config as efc

    import logging

    if int(sqlalchemy.__version__.split('.')[1]) < 7:

        # This solution should work for sqlalchemy < 0.7.0, and should use

        # proxy=TimerProxy() for execution time profiling

        from sqlalchemy.pool import NullPool

        url = configuration[prefix + 'url']

        if url.startswith('sqlite'):

            kwargs.update({'poolclass': NullPool})

        return efc(configuration, prefix, **kwargs)

    else:

        import time

        from sqlalchemy import event

        from sqlalchemy.engine import Engine

        log = logging.getLogger('sqlalchemy.engine')

        BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = xrange(30, 38)

        engine = efc(configuration, prefix, **kwargs)

        def color_sql(sql):

            COLOR_SEQ = "\033[1;%dm"

            COLOR_SQL = YELLOW

            normal = '\x1b[0m'

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

        if configuration['debug']:

            #attach events only for debug configuration

            def before_cursor_execute(conn, cursor, statement,

                                    parameters, context, executemany):

                context._query_start_time = time.time()

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

            def after_cursor_execute(conn, cursor, statement,

                                    parameters, context, executemany):

                total = time.time() - context._query_start_time

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

            event.listen(engine, "before_cursor_execute",

                         before_cursor_execute)

            event.listen(engine, "after_cursor_execute",

                         after_cursor_execute)

    return engine

def age(prevdate, show_short_version=False, now=None):

    """

    turns a datetime into an age string.

    If show_short_version is True, then it will generate a not so accurate but shorter string,

    example: 2days ago, instead of 2 days and 23 hours ago.

    :param prevdate: datetime object

    :param show_short_version: if it should aproximate the date and return a shorter string

    :rtype: unicode

    :returns: unicode words describing age

    """

    now = now or datetime.datetime.now()

    order = ['year', 'month', 'day', 'hour', 'minute', 'second']

    deltas = {}

    future = False

    if prevdate > now:

        now, prevdate = prevdate, now

        future = True

    if future:

        prevdate = prevdate.replace(microsecond=0)

    # Get date parts deltas

    from dateutil import relativedelta

    for part in order:

        d = relativedelta.relativedelta(now, prevdate)

    :param val:

    :param default:

    """

    try:

        val = int(val)

    except (ValueError, TypeError):

        val = default

    return val

def safe_unicode(str_, from_encoding=None):

    """

    safe unicode function. Does few trick to turn str_ into unicode

    In case of UnicodeDecode error we try to return it with encoding detected

    by chardet library if it fails fallback to unicode with errors replaced

    :param str_: string to decode

    :rtype: unicode

    :returns: unicode object

    """

    if isinstance(str_, unicode):

        return str_

    if not from_encoding:

        from rhodecode.lib.vcs.conf import settings

        from_encoding = settings.DEFAULT_ENCODINGS

    if not isinstance(from_encoding, (list, tuple)):

        from_encoding = [from_encoding]

    try:

        return unicode(str_)

    except UnicodeDecodeError:

        pass

    for enc in from_encoding:

        try:

            return unicode(str_, enc)

        except UnicodeDecodeError:

            pass

    try:

        import chardet

        encoding = chardet.detect(str_)['encoding']

        if encoding is None:

            raise Exception()

        return str_.decode(encoding)

    except (ImportError, UnicodeDecodeError, Exception):

        return unicode(str_, from_encoding[0], 'replace')

def safe_str(unicode_, to_encoding=None):

    """

    safe str function. Does few trick to turn unicode_ into string

    In case of UnicodeEncodeError we try to return it with encoding detected

    by chardet library if it fails fallback to string with errors replaced

    :param unicode_: unicode to encode

    :rtype: str

    :returns: str object

    """

    # if it's not basestr cast to str

    if not isinstance(unicode_, basestring):

        return str(unicode_)

    if isinstance(unicode_, str):

        return unicode_

    if not to_encoding:

        from rhodecode.lib.vcs.conf import settings

        to_encoding = settings.DEFAULT_ENCODINGS

    if not isinstance(to_encoding, (list, tuple)):

        to_encoding = [to_encoding]

    for enc in to_encoding:

        try:

            return unicode_.encode(enc)

        except UnicodeEncodeError:

            pass

    try:

        import chardet

        encoding = chardet.detect(unicode_)['encoding']

        if encoding is None:

            raise UnicodeEncodeError()

        return unicode_.encode(encoding)

    except (ImportError, UnicodeEncodeError):

        return unicode_.encode(to_encoding[0], 'replace')

def author_email(author):

    """

    returns email address of given author.

    If any of <,> sign are found, it fallbacks to regex findall()

    and returns first found result or empty string

    Regex taken from http://www.regular-expressions.info/email.html

    """

    import re

    r = author.find('>')

    l = author.find('<')

    if l == -1 or r == -1:

        # fallback to regex match of email out of a string

        email_re = re.compile(r"""[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!"""

                              r"""#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z"""

                              r"""0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]"""

                              r"""*[a-z0-9])?""", re.IGNORECASE)

        m = re.findall(email_re, author)

        return m[0] if m else ''

    return author[l + 1:r].strip()

def author_name(author):

    """

    get name of author, or else username.

    It'll try to find an email in the author string and just cut it off

    to get the username

    """

    if not '@' in author:

        return author

    else:

        return author.replace(author_email(author), '').replace('<', '')\

            .replace('>', '').strip()

    user = sa.query(User).filter(User.username == USER).scalar()

    if user is None:

        raise Exception('user not found')

    repo = sa.query(Repository).filter(Repository.repo_name == HG_REPO).scalar()

    if repo is None:

        print 'repo not found creating'

        form_data = {'repo_name': HG_REPO,

                     'repo_type': 'hg',

                     'private':False,

                     'clone_uri': '' }

        rm = RepoModel(sa)

        rm.base_path = '/home/hg'

        rm.create(form_data, user)

    print 'done'

def set_anonymous_access(enable=True):

    sa = get_session()

    user = sa.query(User).filter(User.username == 'default').one()

    user.active = enable

    sa.add(user)

    sa.commit()

def get_anonymous_access():

    sa = get_session()

    return sa.query(User).filter(User.username == 'default').one().active

#==============================================================================

# TESTS

#==============================================================================

def test_clone_with_credentials(no_errors=False, repo=HG_REPO, method=METHOD,

                                seq=None, backend='hg'):

    cwd = path = jn(TESTS_TMP_PATH, repo)

    if seq == None:

        seq = _RandomNameSequence().next()

    try:

        shutil.rmtree(path, ignore_errors=True)

        os.makedirs(path)

        #print 'made dirs %s' % jn(path)

    except OSError:

        raise

    clone_url = 'http://%(user)s:%(pass)s@%(host)s/%(cloned_repo)s' % \

                  {'user': USER,

                   'pass': PASS,

                   'host': HOST,

                   'cloned_repo': repo, }

    dest = path + seq

    if method == 'pull':

        stdout, stderr = Command(cwd).execute(backend, method, '--cwd', dest, clone_url)

    else:

        stdout, stderr = Command(cwd).execute(backend, method, clone_url, dest)

        print stdout,'sdasdsadsa'

        if not no_errors:

            if backend == 'hg':

                assert """adding file changes""" in stdout, 'no messages about cloning'

                assert """abort""" not in stderr , 'got error from clone'

            elif backend == 'git':

                assert """Cloning into""" in stdout, 'no messages about cloning'

if __name__ == '__main__':

    try:

        create_test_user(force=False)

        seq = None

        import time

        try:

            METHOD = sys.argv[3]

        except Exception:

            pass

        try:

            backend = sys.argv[4]

        except Exception:

            backend = 'hg'

        if METHOD == 'pull':

            seq = _RandomNameSequence().next()

            test_clone_with_credentials(repo=sys.argv[1], method='clone',

                                        seq=seq, backend=backend)

        s = time.time()

        for i in range(1, int(sys.argv[2]) + 1):

            print 'take', i

            test_clone_with_credentials(repo=sys.argv[1], method=METHOD,

                                        seq=seq, backend=backend)

        print 'time taken %.3f' % (time.time() - s)

    except Exception, e:

        sys.exit('stop on %s' % e)