m.connect('repo_as_fork', "/repo_as_fork/{repo_name:.*}",

                  action="repo_as_fork", conditions=dict(method=["PUT"],

                                                      function=check_repo))

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/repos_groups') as m:

        m.connect("repos_groups", "/repos_groups",

    """REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #         path_prefix='/_admin', name_prefix='_admin_')

    @LoginRequired()

                                            c.repo_last_rev) * 100)

        defaults = RepoModel()._get_defaults(repo_name)

        c.repos_list = [('', _('--REMOVE FORK--'))]

        c.repos_list += [(x.repo_id, x.repo_name) for x in

                   Repository.query().order_by(Repository.repo_name).all()]

    def repo_as_fork(self, repo_name):

        """

        Mark given repository as a fork of another

        :param repo_name:

        """

        try:

                                    self.rhodecode_user.username)

            fork = repo.fork.repo_name if repo.fork else _('Nothing')

            Session.commit()

                    category='success')

        except Exception, e:

            raise

            encoding="UTF-8",

            force_defaults=False

        )

        grant_perm = request.POST.get('create_repo_perm', False)

        user_model = UserModel()

        if grant_perm:

            perm = Permission.get_by_key('hg.create.none')

            user_model.revoke_perm(id, perm)

        c.available_members = [(x.user_id, x.username) for x in

                               self.sa.query(User).all()]

        available_members = [safe_unicode(x[0]) for x in c.available_members]

        users_group_form = UsersGroupForm(edit=True,

                                          old_data=c.users_group.get_dict(),

                                          available_members=available_members)()

            UsersGroupModel().grant_perm(id, perm)

            h.flash(_("Granted 'repository create' permission to user"),

                    category='success')

            Session.commit()

        else:

            perm = Permission.get_by_key('hg.create.repository')

    :created_on: Aug 20, 2011

    :author: marcink

    :license: GPLv3, see COPYING for more details.

"""

# 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; version 2

# of the License or (at your opinion) any later version of the license.

# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

        if self._error is not None:

            raw_response = None

                        error=self._error)

        try:

            return func

        else:

            raise AttributeError("No such method: %s" % self._req_method)

    def index(self):

        if c.rhodecode_repo.alias != 'hg':

            raise HTTPNotFound()

        c.repo_bookmarks = OrderedDict()

        bookmarks = [(name, c.rhodecode_repo.get_changeset(hash_)) for \

        branch_name = request.params.get('branch', None)

        try:

            if branch_name:

                                                    branch_name=branch_name)]

                c.total_cs = len(collection)

            else:

                collection = list(c.rhodecode_repo)

                c.total_cs = len(c.rhodecode_repo)

            c.pagination = RepoPage(collection, page=p, item_count=c.total_cs,

                                    items_per_page=c.size, branch=branch_name)

        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:

            log.error(traceback.format_exc())

            h.flash(str(e), category='warning')

        self._graph(c.rhodecode_repo, collection, c.total_cs, c.size, p)

                data.append(['', vtx, edges])

        c.jsdata = json.dumps(data)

                c.changeset_2 = EmptyChangeset(repo=c.rhodecode_repo)

                node2 = FileNode('.', '', changeset=c.changeset_2)

        except RepositoryError:

                                f_path=f_path))

        if c.action == 'download':

            _d, _f = ScmModel().get_nodes(repo_name, cs.raw_id, f_path,

                                          flat=False)

            return _d + _f

            return render('/switch_to_list.html')

        else:

            return HTTPBadRequest()

                         'session, session attrs %s' % (username, cs))

                user.update_lastlogin()

                Session.commit()

                if c.came_from:

                    return redirect(c.came_from)

                else:

        download_l.append(tags_group)

        return download_l

def convert_line_endings(line, mode):

    """

    Converts a given line  "line end" accordingly to given mode

    Available modes are::

        0 - Unix

        1 - Mac

        2 - DOS

    :param line: given line to convert

    :param mode: mode to convert to

    :rtype: str

def safe_unicode(str_, from_encoding='utf8'):

    """

    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

def safe_str(unicode_, to_encoding='utf8'):

    """

    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

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

    """

    Custom engine_from_config functions that makes sure we use NullPool for

    applies to sqlalchemy versions < 0.7.0

    """

def age(curdate):

    """

    turns a datetime into an age string.

    :param curdate: datetime object

    :rtype: unicode

    :returns: unicode words describing age

def uri_filter(uri):

    """

    Removes user:password from given url string

    :param uri:

    :rtype: unicode

    """

    if not uri:

        return ''

def credentials_filter(uri):

    """

    Returns a url with removed credentials

    :param uri:

    """

def get_changeset_safe(repo, rev):

    """

    repo it returns a Dummy one instead

    :param repo:

    :param rev:

    """

    """

    Returns tuple of (number, id) from repository containing this package

    or None if repository could not be found.

    :param quiet: prints error for fetching revision if True

    """

def extract_mentioned_users(s):

    """

    Returns unique usernames from given string s that have @mention

    :param s: string to get mentions

    """

    usrs = {}

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

    Anontation library for usage in rhodecode, previously part of vcs

    :created_on: Dec 4, 2011

    :author: marcink

    :license: GPLv3, see COPYING for more details.

"""

class PasswordGenerator(object):

    """

    characters

    usage::

def generate_api_key(str_, salt=None):

    """

    Generates API KEY from given string

    :param str_:

    :param salt:

    """

def authfunc(environ, username, password):

    """

    access control.

    :param environ: needed only for using in Basic auth

                if user_model.create_ldap(username, password, user_dn,

                                          user_attrs):

                    log.info('created new ldap user %s', username)

                return True

            except (LdapUsernameError, LdapPasswordError,):

                pass

    user.update_lastlogin()

    Session.commit()

    log.debug('User %s is now logged in by container authentication',

              user.username)

    return user

        if self._api_key and self._api_key != self.anonymous_user.api_key:

            log.debug('Auth User lookup by API KEY %s', self._api_key)

            is_user_loaded = user_model.fill_data(self, api_key=self._api_key)

        elif (self.user_id is not None and

              self.user_id != self.anonymous_user.user_id):

            log.debug('Auth User lookup by USER ID %s', self.user_id)

        # lookup by username

        elif self.username and \

            str2bool(config.get('container_auth_enabled', False)):

            log.debug('Auth User lookup by USER NAME %s', self.username)

            dbuser = login_container_auth(self.username)

            if dbuser is not None:

            return True

        log.debug('permission denied')

        return False

    rhodecode.lib.backup_manager

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

    repositories and send it to backup server using RSA key via ssh.

    :created_on: Feb 28, 2010

            c.repository_followers = self.scm_model.get_followers(c.repo_name)

            c.repository_forks = self.scm_model.get_forks(c.repo_name)

        repo = Repository.get_by_repo_name(repo_name)

        if repo is None:

            return True

        repo = repo.scm_instance

        repo_size = repo.count()

        # return if repo have no revisions

def create_repo_fork(form_data, cur_user):

    """

    Creates a fork of repository using interval VCS methods

    :param form_data:

    :param cur_user:

    """

            update_after_clone=update_after_clone)

    action_logger(cur_user, 'user_forked_repo:%s' % fork_name,

                   org_repo_name, '', Session)

    action_logger(cur_user, 'user_created_fork:%s' % fork_name,

    # finally commit at latest possible stage

    Session.commit()

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

    Python backward compatibility functions and common libs

    :created_on: Oct 7, 2011

    :author: marcink

    :license: GPLv3, see COPYING for more details.

"""

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

class _odict(object):

    """Ordered dict data structure, with O(1) complexity for dict operations

    that modify one element.

    Overwriting values doesn't change their original sequential order.

    """

from rhodecode.lib.dbmigrate.migrate.versioning import *

from rhodecode.lib.dbmigrate.migrate.changeset import *

warnings.simplefilter('always', DeprecationWarning)

                    for x in _sa_version.split("."))

SQLA_06 = _sa_version >= (0, 6)

SQLA_07 = _sa_version >= (0, 7)

                except:

                    trans.rollback()

                    raise

    def create_script(self, description, **k):

        """API to :meth:`migrate.versioning.version.Collection.create_new_python_version`"""

        k['use_timestamp_numbering'] = self.use_timestamp_numbering

        self.versions.create_new_python_version(description, **k)

        and store them in self.versions

        """

        super(Collection, self).__init__(path)

        # Create temporary list of files, allowing skipped version numbers.

        files = os.listdir(path)

        if '1' in files:

        script.PythonScript.create(filepath, **k)

        self.versions[ver] = Version(ver, self.path, [filename])

    def create_new_sql_version(self, database, description, **k):

        """Create SQL files for new version"""

        ver = self._next_ver_num(k.pop('use_timestamp_numbering', False))

            filepath = self._version_path(filename)

            script.SqlScript.create(filepath, **k)

            self.versions[ver].add_script(filepath)

    def version(self, vernum=None):

        """Returns latest Version if vernum is not given.

        Otherwise, returns wanted version"""

class Version(object):

    """A single version in a collection

    :param path: Path to script files

    :param filelist: List of scripts

    :type vernum: int, VerNum

        for script in filelist:

            self.add_script(os.path.join(path, script))

    def script(self, database=None, operation=None):

        """Returns SQL or Python Script"""

        for db in (database, 'default'):

    def _add_script_sql(self, path):

        basename = os.path.basename(path)

        match = self.SQL_FILENAME.match(basename)

        if match:

            basename = basename.replace('.sql', '')

            parts = basename.split('_')

    Schemas for migrations

    :created_on: Nov 1, 2011

    :author: marcink

    :license: <name>, see LICENSE_FILE for more details.

"""

        self.cache_active = False

    def __repr__(self):

        Returns Invalidation object if this given key should be invalidated

        None otherwise. `cache_active = False` means that this cache

        state is not valid and needs to be invalidated

        :param key:

        """

        return cls.query()\

    def set_invalidate(cls, key):

        """

        Mark this Cache key for invalidation

        :param key:

        """

    def set_valid(cls, key):

        """

        Mark this cache key as active and currently cached

        :param key:

        """

        inv_obj = Session.query(CacheInvalidation)\

    repository_id = Column('repository_id', String(250), primary_key=True)

    repository_path = Column('repository_path', Text)

    version = Column('version', Integer)

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

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

    from rhodecode.lib.dbmigrate.schema.db_1_1_0 import UserFollowing

    UserFollowing().__table__.create()

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

    # Add table `cache_invalidation`

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

                        nullable=True, unique=False, default=None)

    clone_uri.create(Repository().__table__)

    #ADD downloads column#

    enable_downloads = Column("downloads", Boolean(), nullable=True, unique=None, default=True)

    enable_downloads.create(Repository().__table__)

    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UserFollowing

                          default=datetime.datetime.now)

    follows_from.create(UserFollowing().__table__)

    Don't create your own engine; bind migrate_engine to your metadata

    """

    return

                                            self.items_per_page))

            self.last_page = self.first_page + self.page_count - 1

            # valid pages

            if self.page > self.last_page:

                self.page = self.last_page

    """

    Generates a html string for changed nodes in changeset page.

    It limits the output to 30 entries

    :param nodes: LazyNodesGenerator

    """

    if nodes:

    """

    Makes a breadcrumbs link to repo within a group

    joins » on each group to create a fancy link

    ex::

        group >> subgroup >> repo

    :param groups_and_repos:

    """

    groups, repo_name = groups_and_repos

    """

    Displays a fancy two colored bar for number of added/deleted

    lines of code on file

    :param stats: two element list of added/deleted lines of code

    """

def rst_w_mentions(source):

    """

    Wrapped rst renderer with @mention highlighting

    :param source:

    """

    return literal('<div class="rst-block">%s</div>' %

    rhodecode.lib.markup_renderer

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

    Renderer for markup languages with ability to parse using rst or markdown

    :created_on: Oct 27, 2011

    :author: marcink

    :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>

class MarkupRenderer(object):

    RESTRUCTUREDTEXT_DISALLOWED_DIRECTIVES = ['include', 'meta', 'raw']

    MARKDOWN_PAT = re.compile(r'md|mkdn?|mdown|markdown',re.IGNORECASE)

    RST_PAT = re.compile(r're?st',re.IGNORECASE)

    PLAIN_PAT = re.compile(r'readme',re.IGNORECASE)

    def __detect_renderer(self, source, filename=None):

        """

        runs detection of what renderer should be used for generating html

        from a markup language

        filename can be also explicitly a renderer name

        :param source:

        :param filename:

        """

        Renders a given filename using detected renderer

        it detects renderers based on file extension or mimetype.

        At last it will just do a simple html replacing new lines with <br/>

        :param file_name:

        :param source:

        """

    @classmethod

    def rst_with_mentions(cls, source):

        mention_pat = re.compile(r'(?:^@|\s@)(\w+)')

        def wrapp(match_obj):

            uname = match_obj.groups()[0]

            return ' **@%(uname)s** ' % {'uname':uname}

        mention_hl = mention_pat.sub(wrapp, source).strip()

        return cls.rst(mention_hl)