log = logging.getLogger(__name__)

# CUSTOM ANALYZER wordsplit + lowercase filter

ANALYZER = RegexTokenizer(expression=r"\w+") | LowercaseFilter()

#INDEX SCHEMA DEFINITION

SCHEMA = Schema(

    fileid=ID(unique=True),

    owner=TEXT(),

    repository=TEXT(stored=True),

    path=TEXT(stored=True),

    content=FieldType(format=Characters(), analyzer=ANALYZER,

                      scorable=True, stored=True),

    modtime=STORED(),

    extension=TEXT(stored=True)

)

IDX_NAME = 'HG_INDEX'

FORMATTER = HtmlFormatter('span', between='\n<span class="break">...</span>\n')

FRAGMENTER = ContextFragmenter(200)

CHGSETS_SCHEMA = Schema(

    raw_id=ID(unique=True, stored=True),

    last=BOOLEAN(),

    owner=TEXT(),

    repository=ID(unique=True, stored=True),

    author=TEXT(stored=True),

    message=FieldType(format=Characters(), analyzer=ANALYZER,

                      scorable=True, stored=True),

    parents=TEXT(),

    added=TEXT(),

    removed=TEXT(),

    changed=TEXT(),

)

CHGSET_IDX_NAME = 'CHGSET_INDEX'

class MakeIndex(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    summary = "Creates index for full text search given configuration file"

    group_name = "RhodeCode"

    takes_config_file = -1

    parser = Command.standard_parser(verbose=True)

        to the index writer

        :param writer: the whoosh index writer to add to

        :param repo_name: name of the repository from whence the

          changeset originates including the repository group

        :param repo: the vcs repository instance to index changesets for,

          the presumption is the repo has changesets to index

        :param start_rev=None: the full sha id to start indexing from

          if start_rev is None then index from the first changeset in

          the repo

        """

        if start_rev is None:

            start_rev = repo[0].raw_id

        log.debug('indexing changesets in %s starting at rev: %s' %

                  (repo_name, start_rev))

        indexed = 0

        for cs in repo.get_changesets(start=start_rev):

            log.debug('    >> %s' % cs)

            writer.add_document(

                raw_id=unicode(cs.raw_id),

                owner=unicode(repo.contact),

                repository=safe_unicode(repo_name),

                author=cs.author,

                message=cs.message,

                last=cs.last,

                added=u' '.join([node.path for node in cs.added]).lower(),

                removed=u' '.join([node.path for node in cs.removed]).lower(),

                changed=u' '.join([node.path for node in cs.changed]).lower(),

                parents=u' '.join([cs.raw_id for cs in cs.parents]),

            )

            indexed += 1

        log.debug('indexed %d changesets for repo %s' % (indexed, repo_name))

        return indexed

    def index_files(self, file_idx_writer, repo_name, repo):

        """

        Index files for given repo_name

        :param file_idx_writer: the whoosh index writer to add to

        :param repo_name: name of the repository we're indexing

        :param repo: instance of vcs repo

        """

        i_cnt = iwc_cnt = 0

        log.debug('building index for [%s]' % repo.path)

        self._commit = commit

        self._tree_id = commit.tree

        self._commiter_property = 'committer'

        self._date_property = 'commit_time'

        self._date_tz_property = 'commit_timezone'

        self.revision = repository.revisions.index(revision)

        self.message = safe_unicode(commit.message)

        #self.branch = None

        self.tags = []

        self.nodes = {}

        self._paths = {}

    @LazyProperty

    def author(self):

        return safe_unicode(getattr(self._commit, self._commiter_property))

    @LazyProperty

    def date(self):

        return date_fromtimestamp(getattr(self._commit, self._date_property),

                                  getattr(self._commit, self._date_tz_property))

    @LazyProperty

    def status(self):

        """

        Returns modified, added, removed, deleted files for current changeset

        """

        return self.changed, self.added, self.removed

    @LazyProperty

    def branch(self):

        heads = self.repository._heads(reverse=False)

        ref = heads.get(self.raw_id)

        if ref:

            return safe_unicode(ref)

    def _fix_path(self, path):

        """

        Paths are stored without trailing slash so we need to get rid off it if

        needed.

        """

        if path.endswith('/'):

            path = path.rstrip('/')

        return path

    def tags(self):

        return map(safe_unicode, self._ctx.tags())

    @LazyProperty

    def branch(self):

        return  safe_unicode(self._ctx.branch())

    @LazyProperty

    def bookmarks(self):

        return map(safe_unicode, self._ctx.bookmarks())

    @LazyProperty

    def message(self):

        return safe_unicode(self._ctx.description())

    @LazyProperty

    def author(self):

        return safe_unicode(self._ctx.user())

    @LazyProperty

    def date(self):

        return date_fromtimestamp(*self._ctx.date())

    @LazyProperty

    def status(self):

        """

        Returns modified, added, removed, deleted files for current changeset

        """

        return self.repository._repo.status(self._ctx.p1().node(),

                                            self._ctx.node())

    @LazyProperty

    def _file_paths(self):

        return list(self._ctx)

    @LazyProperty

    def _dir_paths(self):

        p = list(set(get_dirs_for_path(*self._file_paths)))

        p.insert(0, '')

        return p

    @LazyProperty

    def _paths(self):

        return self._dir_paths + self._file_paths

    @LazyProperty

    def id(self):

        if self.last: