# -*- coding: utf-8 -*-

"""

    rhodecode.lib.indexers.__init__

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

    Whoosh indexing module for RhodeCode

    :created_on: Aug 17, 2010

    :author: marcink

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

    :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, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

import os

import sys

import traceback

import logging

from os.path import dirname as dn, join as jn

#to get the rhodecode import

sys.path.append(dn(dn(dn(os.path.realpath(__file__)))))

from string import strip

from shutil import rmtree

from whoosh.analysis import RegexTokenizer, LowercaseFilter, StopFilter

from whoosh.fields import TEXT, ID, STORED, NUMERIC, BOOLEAN, Schema, FieldType

from whoosh.index import create_in, open_dir

from whoosh.formats import Characters

from whoosh.highlight import highlight, HtmlFormatter, ContextFragmenter

from webhelpers.html.builder import escape, literal

from sqlalchemy import engine_from_config

from rhodecode.model import init_model

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

from rhodecode.config.environment import load_environment

from rhodecode.lib.utils2 import LazyProperty

from rhodecode.lib.utils import BasePasterCommand, Command, add_cache,\

    load_rcextensions

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)

    def command(self):

        logging.config.fileConfig(self.path_to_ini_file)

        from pylons import config

        add_cache(config)

        engine = engine_from_config(config, 'sqlalchemy.db1.')

        init_model(engine)

        index_location = config['index_dir']

        repo_location = self.options.repo_location \

            if self.options.repo_location else RepoModel().repos_path

        repo_list = map(strip, self.options.repo_list.split(',')) \

            if self.options.repo_list else None

        repo_update_list = map(strip, self.options.repo_update_list.split(',')) \

            if self.options.repo_update_list else None

        load_rcextensions(config['here'])

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

        # WHOOSH DAEMON

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

        from rhodecode.lib.pidlock import LockHeld, DaemonLock

        from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

        try:

            l = DaemonLock(file_=jn(dn(dn(index_location)), 'make_index.lock'))

            WhooshIndexingDaemon(index_location=index_location,

                                 repo_location=repo_location,

                                 repo_list=repo_list,

                                 repo_update_list=repo_update_list)\

                .run(full_index=self.options.full_index)

            l.release()

        except LockHeld:

            sys.exit(1)

    def update_parser(self):

        self.parser.add_option('--repo-location',

                          action='store',

                          dest='repo_location',

                          help="Specifies repositories location to index OPTIONAL",

                          )

        self.parser.add_option('--index-only',

                          action='store',

                          dest='repo_list',

                          help="Specifies a comma separated list of repositores "

                                "to build index on. If not given all repositories "

                                "are scanned for indexing. OPTIONAL",

                          )

        self.parser.add_option('--update-only',

                          action='store',

                          dest='repo_update_list',

                          help="Specifies a comma separated list of repositores "

                                "to re-build index on. OPTIONAL",

                          )

        self.parser.add_option('-f',

                          action='store_true',

                          dest='full_index',

                          help="Specifies that index should be made full i.e"

                                " destroy old and build from scratch",

                          default=False)

class WhooshResultWrapper(object):

    def __init__(self, search_type, searcher, matcher, highlight_items,

                 repo_location):

        self.search_type = search_type

        self.searcher = searcher

        self.matcher = matcher

        self.highlight_items = highlight_items

        self.fragment_size = 200

        self.repo_location = repo_location

    @LazyProperty

    def doc_ids(self):

        docs_id = []

        while self.matcher.is_active():

                     ' index does not exist')

        elif not exists_in(self.index_location, CHGSET_IDX_NAME):

            log.info('Running full index build as the changeset'

                     ' index does not exist')

        else:

            self.initial = False

    def get_paths(self, repo):

        """

        recursive walk in root dir and return a set of all path in that dir

        based on repository walk function

        """

        index_paths_ = set()

        try:

            tip = repo.get_changeset('tip')

            for _topnode, _dirs, files in tip.walk('/'):

                for f in files:

                    index_paths_.add(jn(repo.path, f.path))

        except RepositoryError:

            log.debug(traceback.format_exc())

            pass

        return index_paths_

    def get_node(self, repo, path):

        n_path = path[len(repo.path) + 1:]

        node = repo.get_changeset().get_node(n_path)

        return node

    def get_node_mtime(self, node):

        return mktime(node.last_changeset.date.timetuple())

    def add_doc(self, writer, path, repo, repo_name):

        """

        Adding doc to writer this function itself fetches data from

        the instance of vcs backend

        """

        node = self.get_node(repo, path)

        indexed = indexed_w_content = 0

        # we just index the content of chosen files, and skip binary files

        if node.extension in INDEX_EXTENSIONS and not node.is_binary:

            u_content = node.content

            if not isinstance(u_content, unicode):

                log.warning('  >> %s Could not get this content as unicode '

                            'replacing with empty content' % path)

                u_content = u''

            else:

                log.debug('    >> %s [WITH CONTENT]' % path)

                indexed_w_content += 1

        else:

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

            # just index file name without it's content

            u_content = u''

            indexed += 1

        p = safe_unicode(path)

        writer.add_document(

            fileid=p,

            owner=unicode(repo.contact),

            repository=safe_unicode(repo_name),

            path=p,

            content=u_content,

            modtime=self.get_node_mtime(node),

            extension=node.extension

        )

        return indexed, indexed_w_content

    def index_changesets(self, writer, repo_name, repo, start_rev=None):

        """

        Add all changeset in the vcs repo starting at start_rev

        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)

        for idx_path in self.get_paths(repo):

            i, iwc = self.add_doc(file_idx_writer, idx_path, repo, repo_name)

            i_cnt += i

            iwc_cnt += iwc

        log.debug('added %s files %s with content for repo %s' %

                  (i_cnt + iwc_cnt, iwc_cnt, repo.path))

        return i_cnt, iwc_cnt

    def update_changeset_index(self):

        idx = open_dir(self.index_location, indexname=CHGSET_IDX_NAME)

        with idx.searcher() as searcher:

            writer = idx.writer()

            writer_is_dirty = False

            try:

                indexed_total = 0

                for repo_name, repo in self.repo_paths.items():

                    # skip indexing if there aren't any revs in the repo

                    num_of_revs = len(repo)

                    if num_of_revs < 1:

                        continue

                    qp = QueryParser('repository', schema=CHGSETS_SCHEMA)

                    q = qp.parse(u"last:t AND %s" % repo_name)

                    results = searcher.search(q)

                    # default to scanning the entire repo

                    last_rev = 0

                    start_id = None

                    if len(results) > 0:

                        # assuming that there is only one result, if not this

                        # may require a full re-index.

                        start_id = results[0]['raw_id']

                        last_rev = repo.get_changeset(revision=start_id).revision

                    # there are new changesets to index or a new repo to index

                    if last_rev == 0 or num_of_revs > last_rev + 1:

                        # delete the docs in the index for the previous

                        # last changeset(s)

                        for hit in results:

                            q = qp.parse(u"last:t AND %s AND raw_id:%s" %

                                            (repo_name, hit['raw_id']))

                            writer.delete_by_query(q)

                        # index from the previous last changeset + all new ones

                        indexed_total += self.index_changesets(writer,

                                                repo_name, repo, start_id)

                        writer_is_dirty = True

                log.debug('indexed %s changesets for repo %s' % (

                             indexed_total, repo_name)

                )

            finally:

                if writer_is_dirty:

                    log.debug('>> COMMITING CHANGES TO CHANGESET INDEX<<')

                    writer.commit(merge=True)

                    log.debug('>> COMMITTED CHANGES TO CHANGESET INDEX<<')

                else:

                    writer.cancel

                    log.debug('>> NOTHING TO COMMIT<<')

    def update_file_index(self):

        log.debug((u'STARTING INCREMENTAL INDEXING UPDATE FOR EXTENSIONS %s '

                   'AND REPOS %s') % (INDEX_EXTENSIONS, self.repo_paths.keys()))

        idx = open_dir(self.index_location, indexname=self.indexname)

        # The set of all paths in the index

        indexed_paths = set()

        # The set of all paths we need to re-index

        to_index = set()

import re

from itertools import chain

from dulwich import objects

from subprocess import Popen, PIPE

from rhodecode.lib.vcs.conf import settings

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.exceptions import ChangesetError

from rhodecode.lib.vcs.exceptions import NodeDoesNotExistError

from rhodecode.lib.vcs.exceptions import VCSError

from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError

from rhodecode.lib.vcs.exceptions import ImproperArchiveTypeError

from rhodecode.lib.vcs.backends.base import BaseChangeset

from rhodecode.lib.vcs.nodes import FileNode, DirNode, NodeKind, RootNode, \

    RemovedFileNode, SubModuleNode

from rhodecode.lib.vcs.utils import safe_unicode

from rhodecode.lib.vcs.utils import date_fromtimestamp

from rhodecode.lib.vcs.utils.lazy import LazyProperty

class GitChangeset(BaseChangeset):

    """

    Represents state of the repository at single revision.

    """

    def __init__(self, repository, revision):

        self._stat_modes = {}

        self.repository = repository

        try:

            commit = self.repository._repo.get_object(revision)

            if isinstance(commit, objects.Tag):

                revision = commit.object[1]

                commit = self.repository._repo.get_object(commit.object[1])

        except KeyError:

            raise RepositoryError("Cannot get object with id %s" % revision)

        self.raw_id = revision

        self.id = self.raw_id

        self.short_id = self.raw_id[:12]

        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 _get_id_for_path(self, path):

        # FIXME: Please, spare a couple of minutes and make those codes cleaner;

        if not path in self._paths:

            path = path.strip('/')

            # set root tree

            tree = self.repository._repo[self._tree_id]

            if path == '':

                self._paths[''] = tree.id

                return tree.id

            splitted = path.split('/')

            dirs, name = splitted[:-1], splitted[-1]

            curdir = ''

            # initially extract things from root dir

            for item, stat, id in tree.iteritems():

                if curdir:

                    name = '/'.join((curdir, item))

                else:

                    name = item

                self._paths[name] = id

                self._stat_modes[name] = stat

            for dir in dirs:

                if curdir:

                    curdir = '/'.join((curdir, dir))

                else:

                    curdir = dir

                dir_id = None

                for item, stat, id in tree.iteritems():

                    if dir == item:

                        dir_id = id

                if dir_id:

                    # Update tree

                    tree = self.repository._repo[dir_id]

                    if not isinstance(tree, objects.Tree):

                        raise ChangesetError('%s is not a directory' % curdir)

                else:

                    raise ChangesetError('%s have not been found' % curdir)

                # cache all items from the given traversed tree

                for item, stat, id in tree.iteritems():

                    if curdir:

                        name = '/'.join((curdir, item))

                    else:

                        name = item

                    self._paths[name] = id

                    self._stat_modes[name] = stat

            if not path in self._paths:

                raise NodeDoesNotExistError("There is no file nor directory "

                    "at the given path %r at revision %r"

                    % (path, self.short_id))

        return self._paths[path]

    def _get_kind(self, path):

        obj = self.repository._repo[self._get_id_for_path(path)]

        if isinstance(obj, objects.Blob):

            return NodeKind.FILE

        elif isinstance(obj, objects.Tree):

            return NodeKind.DIR

    def _get_file_nodes(self):

        return chain(*(t[2] for t in self.walk()))

    @LazyProperty

    def parents(self):

        """

        Returns list of parents changesets.

        """

        return [self.repository.get_changeset(parent)

                for parent in self._commit.parents]

import os

import posixpath

from rhodecode.lib.vcs.backends.base import BaseChangeset

from rhodecode.lib.vcs.conf import settings

from rhodecode.lib.vcs.exceptions import  ChangesetDoesNotExistError, \

    ChangesetError, ImproperArchiveTypeError, NodeDoesNotExistError, VCSError

from rhodecode.lib.vcs.nodes import AddedFileNodesGenerator, \

    ChangedFileNodesGenerator, DirNode, FileNode, NodeKind, \

    RemovedFileNodesGenerator, RootNode, SubModuleNode

from rhodecode.lib.vcs.utils import safe_str, safe_unicode, date_fromtimestamp

from rhodecode.lib.vcs.utils.lazy import LazyProperty

from rhodecode.lib.vcs.utils.paths import get_dirs_for_path

from rhodecode.lib.vcs.utils.hgcompat import archival, hex

class MercurialChangeset(BaseChangeset):

    """

    Represents state of the repository at the single revision.

    """

    def __init__(self, repository, revision):

        self.repository = repository

        self.raw_id = revision

        self._ctx = repository._repo[revision]

        self.revision = self._ctx._rev

        self.nodes = {}

    @LazyProperty

    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:

            return u'tip'

        return self.short_id

    @LazyProperty

    def short_id(self):

        return self.raw_id[:12]

    @LazyProperty

    def parents(self):

        """

        Returns list of parents changesets.

        """

        return [self.repository.get_changeset(parent.rev())

                for parent in self._ctx.parents() if parent.rev() >= 0]

    def next(self, branch=None):

        if branch and self.branch != branch:

            raise VCSError('Branch option used on changeset not belonging '

                           'to that branch')

        def _next(changeset, branch):

            try:

                next_ = changeset.revision + 1

                next_rev = changeset.repository.revisions[next_]

            except IndexError:

                raise ChangesetDoesNotExistError

            cs = changeset.repository.get_changeset(next_rev)

            if branch and branch != cs.branch:

                return _next(cs, branch)

            return cs

        return _next(self, branch)

    def prev(self, branch=None):

        if branch and self.branch != branch:

            raise VCSError('Branch option used on changeset not belonging '

                           'to that branch')

        def _prev(changeset, branch):

            try:

                prev_ = changeset.revision - 1

                if prev_ < 0:

                    raise IndexError

                prev_rev = changeset.repository.revisions[prev_]

            except IndexError:

                raise ChangesetDoesNotExistError

            cs = changeset.repository.get_changeset(prev_rev)

            if branch and branch != cs.branch:

                return _prev(cs, branch)

            return cs

        return _prev(self, branch)

    def diff(self, ignore_whitespace=True, context=3):

        return ''.join(self._ctx.diff(git=True,

                                      ignore_whitespace=ignore_whitespace,

                                      context=context))

    def _fix_path(self, path):

        """

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

        needed. Also mercurial keeps filenodes as str so we need to decode

        from unicode to str

        """

        if path.endswith('/'):

            path = path.rstrip('/')