- fixed #99 Unicode errors, on file node paths with non utf-8 characters

- journal fork fixes

- removed issue with space inside renamed repository after deletion

- fixed strange issue on formencode imports

- fixed #126 Deleting repository on Windows, rename used incompatible chars. 

- windows fixes for os.kill and path spliting, issues #148 and #133

1.1.7 (**2011-03-23**)

======================

news

----

    def __init__(self, user_id):

        self.user_id = user_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)

class RepoTemp(object):

    def __init__(self, repo_id):

        self.repo_id = repo_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)

class ScmModel(BaseModel):

    """Generic Scm Model

    """

    @LazyProperty

    def repos_path(self):

        baseui = make_ui('db')

        repos_list = {}

        for name, path in get_filesystem_repos(repos_path, recursive=True):

            try:

                    raise RepositoryError('Duplicate repository name %s '

                                    'found in %s' % (name, path))

                else:

                    klass = get_backend(path[0])

            except OSError:

                continue

        return repos_list

    def get_repos(self, all_repos=None):

        :param all_repos: give specific repositories list, good for filtering

            this have to be a list of  just the repository names

        """

        if all_repos is None:

            repos = self.sa.query(Repository)\

                             .all()]

        for r_name in all_repos:

            r_dbr = self.get(r_name, invalidation_list)

            if r_dbr is not None:

                repo, dbrepo = r_dbr

                last_change = repo.last_change

                tip = h.get_changeset_safe(repo, 'tip')

                tmp_d = {}

                tmp_d['name'] = dbrepo.repo_name

                tmp_d['name_sort'] = tmp_d['name'].lower()

                tmp_d['description'] = dbrepo.description

                tmp_d['description_sort'] = tmp_d['description']

                tmp_d['last_change'] = last_change

                tmp_d['tip'] = tip.raw_id

                tmp_d['tip_sort'] = tip.revision

                tmp_d['rev'] = tip.revision

                tmp_d['contact'] = dbrepo.user.full_contact

                tmp_d['contact_sort'] = tmp_d['contact']

                tmp_d['owner_sort'] = tmp_d['contact']

                tmp_d['repo_archives'] = list(repo._get_archives())

                tmp_d['last_msg'] = tip.message

                tmp_d['repo'] = repo

                tmp_d['dbrepo'] = dbrepo.get_dict()

                yield tmp_d

    def get(self, repo_name, invalidation_list=None, retval='all'):

        """Returns a tuple of Repository,DbRepository,

        Get's repository from given name, creates BackendInstance and

        propagates it's data from database with all additional information

        if retval == 'repo' or 'all':

            r = _get_repo(repo_name)

        if retval == 'dbrepo' or 'all':

            dbr = RepoModel().get_full(repo_name, cache=True,

                                          invalidate=dbinvalidate)

        return r, dbr

    def mark_for_invalidation(self, repo_name):

        """Puts cache invalidation task into db for

        further global cache invalidation

            self.sa.add(cache)

            self.sa.commit()

        except (DatabaseError,):

            log.error(traceback.format_exc())

            self.sa.rollback()

    def toggle_following_repo(self, follow_repo_id, user_id):

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_repo_id == follow_repo_id)\

            .filter(UserFollowing.user_id == user_id).scalar()

                return

            except:

                log.error(traceback.format_exc())

                self.sa.rollback()

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_repo_id = follow_repo_id

            self.sa.add(f)

            self.sa.commit()

                .filter(Repository.fork_id == repo_id).count()

        else:

            return self.sa.query(Repository)\

                .filter(Repository.fork \

                        == RepoModel().get_by_repo_name(repo_id)).count()

    def pull_changes(self, repo_name, username):

        repo, dbrepo = self.get(repo_name, retval='all')

        try:

            extras = {'ip':'',

                      'username':username,

            log.error(traceback.format_exc())

            raise

    def get_unread_journal(self):

        return self.sa.query(UserLog).count()

    def _should_invalidate(self, repo_name):

        """Looks up database for invalidation signals for this repo_name

        :param repo_name:

        """