- fixed issue #459. Changed the way of obtaining logger in reindex task.

- fixed #453 added ID field in whoosh SCHEMA that solves the issue of

  reindexing modified files

1.3.6 (**2012-05-17**)

----------------------

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    def __load_data(self, repo_name=None):

        """

            return redirect(url('repos'))

        c.default_user_id = User.get_by_username('default').user_id

        c.in_public_journal = UserFollowing.query()\

            .filter(UserFollowing.user_id == c.default_user_id)\

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

        return defaults

    @HasPermissionAllDecorator('hg.admin')

        self.__load_defaults()

        form_result = {}

        try:

                            .to_python(dict(request.POST))

            RepoModel().create(form_result, self.rhodecode_user)

            if form_result['clone_uri']:

        repo_model = RepoModel()

        changed_name = repo_name

        _form = RepoForm(edit=True, old_data={'repo_name': repo_name},

        try:

            form_result = _form.to_python(dict(request.POST))

            repo = repo_model.update(repo_name, form_result)

        c.repo_groups = RepoGroup.groups_choices()

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        new_repo = request.GET.get('repo', '')

        c.new_repo = repo_name_slug(new_repo)

class FilesController(BaseRepoController):

    def __before__(self):

        super(FilesController, self).__before__()

        c.cut_off_limit = self.cut_off_limit

        return file_node

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def index(self, repo_name, revision, f_path, annotate=False):

            c.file = c.changeset.get_node(f_path)

            if c.file.is_file():

            else:

        except RepositoryError, e:

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

            redirect(h.url('files_home', repo_name=repo_name,

        return render('files/files.html')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def rawfile(self, repo_name, revision, f_path):

        response.content_type = file_node.mimetype

        return file_node.content

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def raw(self, repo_name, revision, f_path):

        response.content_type = mimetype

        return file_node.content

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def edit(self, repo_name, revision, f_path):

        r_post = request.POST

        return render('files/files_edit.html')

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def add(self, repo_name, revision, f_path):

        r_post = request.POST

        return render('files/files_add.html')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def archivefile(self, repo_name, fname):

        response.content_type = str(content_type)

        return get_chunked_archive(archive)

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def diff(self, repo_name, f_path):

        return render('files/file_diff.html')

        hist_l = []

        changesets_group = ([], _("Changesets"))

        return hist_l

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def nodelist(self, repo_name, revision, f_path):

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            cs = self.__get_cs_or_redirect(revision, repo_name)

from rhodecode.model.repo import RepoModel

from rhodecode.model.db import RepoGroup

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    @HasRepoPermissionAllDecorator('repository.admin')

    def index(self, repo_name):

        _form = RepoSettingsForm(edit=True,

                                 old_data={'repo_name': repo_name},

        try:

            form_result = _form.to_python(dict(request.POST))

        loc = "%s:%s" % (cls.__class__.__name__, func.__name__)

        log.debug('Checking if %s is authenticated @ %s' % (user.username, loc))

        if user.is_authenticated or api_access_ok:

            )

            return func(*fargs, **fkwargs)

        else:

from rhodecode.lib.rcmail.exceptions import BadHeaders

from rhodecode.lib.rcmail.exceptions import InvalidMessage

class Attachment(object):

    """

    Encapsulates file attachment information.

        """

        if not self.recipients:

        if not self.body and not self.html:

        if not self.sender:

        if self.is_bad_headers():

            raise BadHeaders

    return out

class MIMEPart(MIMEBase):

    """

    A reimplementation of nearly everything in email.mime to be more useful

        self.set_payload(encoded, charset=charset)

    def extract_payload(self, mail):

        ctype, ctype_params = mail.content_encoding['Content-Type']

        cdisp, cdisp_params = mail.content_encoding['Content-Disposition']

def header_to_mime_encoding(value, not_email=False, separator=", "):

    encoder = Charset(DEFAULT_ENCODING)

    if type(value) == list:

    else:

        return properly_encode_header(value, encoder, not_email)

def properly_encode_header(value, encoder, not_email):

    """

    The only thing special (weird) about this function is that it tries

#

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

from socket import sslerror

from rhodecode.lib.rcmail.message import Message

        if isinstance(recipients, basestring):

            recipients = [recipients]

        msg = Message(subject, recipients, body, html, self.mail_from,

        raw_msg = msg.to_message()

        if self.ssl:

             'description': repo.description \

                if repo.description != 'unknown' else '%s repository' % name,

             'private': False,

            }

            rm.create(form_data, user, just_db=True)

    sa.commit()

    install test repository into tmp dir

    """

    from rhodecode.lib.db_manage import DbManage

    # PART ONE create db

    dbconf = config['sqlalchemy.db1.url']

        log.debug('remove %s' % data_path)

        shutil.rmtree(data_path)

    cur_dir = dn(dn(abspath(__file__)))

    tar = tarfile.open(jn(cur_dir, 'tests', "vcs_test_hg.tar.gz"))

    tar.extractall(jn(TESTS_TMP_PATH, HG_REPO))

    tar.close()

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

# PASTER COMMANDS

        # --root ==> doesn't put '^' character for bounderies

        # -r sha ==> blames for the given revision

        so, se = self.repository.run_git_command(cmd)

        annotate = []

        for i, blame_line in enumerate(so.split('\n')[:-1]):

            ln_no = i + 1

            annotate.append((ln_no, self.repository.get_changeset(id), line))

        return annotate

                    curtree = newtree

                parent[reversed_dirnames[-1]] = DIRMOD, curtree.id

            else:

            new_trees.append(parent)

            # Update ancestors

            for parent, tree, path in reversed([(a[1], b[1], b[0]) for a, b in

        commit.parents = [p._commit.id for p in self.parents if p]

        commit.author = commit.committer = safe_str(author)

        commit.encoding = ENCODING

        # Compute date

        if date is None:

                    "for this repository %s" % (revision, self))

        elif is_bstr(revision):

                raise ChangesetDoesNotExistError("Revision %r does not exist "

                    "for this repository %s" % (revision, self))

            if ref.startswith('refs/heads/') and not ref.endswith('/HEAD')]

        return OrderedDict(sorted(_branches, key=sortkey, reverse=False))

    def _get_tags(self):

        if not self.revisions:

            self._repo.get_refs().items() if ref.startswith('refs/tags/')]

        return OrderedDict(sorted(_tags, key=sortkey, reverse=True))

    def tag(self, name, user, revision=None, message=None, date=None,

            **kwargs):

        """

        except OSError, e:

            raise RepositoryError(e.strerror)

    def get_changeset(self, revision=None):

        """

        Returns ``GitChangeset`` object representing commit from git repository

        from .repository import MercurialRepository

        if not isinstance(message, unicode) or not isinstance(author, unicode):

            raise RepositoryError('Given message and author needs to be '

        if branch is None:

            branch = MercurialRepository.DEFAULT_BRANCH_NAME

    def __repr__(self):

        return '<%s %r @ %s>' % (self.__class__.__name__, self.path,

class RemovedFileNode(FileNode):

    def __repr__(self):

        return '<%s %r @ %s>' % (self.__class__.__name__, self.path,

class RootNode(DirNode):

    def __repr__(self):

        return '<%s %r @ %s>' % (self.__class__.__name__, self.path,

    def _extract_submodule_url(self):

        if self.alias == 'git':

    password = Column("password", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

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

    admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)

    lastname = Column("lastname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    _email = Column("email", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)

    repo_id = Column("repo_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    repo_name = Column("repo_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)

    clone_uri = Column("clone_uri", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=False, default=None)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)

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

    enable_statistics = Column("statistics", Boolean(), nullable=True, unique=None, default=True)

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

    description = Column("description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    created_on = Column('created_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

    fork_id = Column("fork_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=False, default=None)

    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=False, default=None)

def RepoForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        clone_uri = All(UnicodeString(strip=True, min=1, not_empty=False))

        repo_group = OneOf(repo_groups, hideList=True)

        repo_type = OneOf(supported_backends)

        private = StringBoolean(if_missing=False)

        enable_statistics = StringBoolean(if_missing=False)

        enable_downloads = StringBoolean(if_missing=False)

        if edit:

            #this is repo owner

def RepoSettingsForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        description = UnicodeString(strip=True, min=1, not_empty=True)

        repo_group = OneOf(repo_groups, hideList=True)

        private = StringBoolean(if_missing=False)

        chained_validators = [ValidRepoName(edit, old_data), ValidPerms(),

                              ValidSettings]

    return _RepoForm

import cStringIO

from sqlalchemy import func

from rhodecode.lib.vcs import get_backend

from rhodecode.lib.vcs.exceptions import RepositoryError

    def get_unread_journal(self):

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

	padding: 5px !important;

}

.tablerow0 {

	background-color: #F8F8F8;

}

                <span class="help-block">${_('Type of repository to create.')}</span>

            </div>

         </div>

        <div class="field">

            <div class="label label-textarea">

                <label for="description">${_('Description')}:</label>

                </div>

            </div>

            <div class="field">

                <div class="label label-textarea">

                    <label for="description">${_('Description')}:</label>

                </div>

        </div>

        ${h.end_form()}

        ${h.form(url('repo_as_fork', repo_name=c.repo_info.repo_name),method='put')}

        <div class="form">

           <div class="fields">

           </div>

               <div class="field" style="border:none;color:#888">

               <ul>

               </ul>

               </div>

        </div>

    <div id="perms" class="table">

           %for section in sorted(c.perm_user.permissions.keys()):

              <div class="perms_section_head">${section.replace("_"," ").capitalize()}</div>

              <div id='tbl_list_wrap_${section}' class="yui-skin-sam">

               <table id="tbl_list_${section}">

                <thead>

               </table>

              </div>

           %endfor

</div>

<div class="box box-right">

    <!-- box / title -->

                'Group':"${_('Group')}",

                'members':"${_('members')}",

                'search truncated': "${_('search truncated')}",

            };

            var _TM = TRANSLATION_MAP;

          ##${comment.comment_inline_form(cs)}

          ## diff block

          <h3 style="padding-top:8px;">${h.link_to('r%s:%s' % (cs.revision,h.short_id(cs.raw_id)),h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}</h3>

          ${diff_block.diff_block(c.changes[cs.raw_id])}

          ##${comment.comments(cs)}

<dl>

	<dd>

	</dd>

</dl>

<div id="body" class="codeblock">

        </div>

    </div>

    <script>

      var func = function(node){

          return node.parentNode.parentNode.parentNode.parentNode;

      }

import os

import time

import logging