init

1 files changed, 1731 insertions, 0 deletions

diff --git a/weechat/.weechat/python/grep.py b/weechat/.weechat/python/grep.py
new file mode 100644
index 0000000..4fd5c64
--- /dev/null
+++ b/weechat/.weechat/python/grep.py
@@ -0,0 +1,1731 @@
+# -*- coding: utf-8 -*-
+###
+# Copyright (c) 2009-2011 by Elián Hanisch <lambdae2@gmail.com>
+#
+# 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/>.
+###
+
+###
+# Search in Weechat buffers and logs (for Weechat 0.3.*)
+#
+#   Inspired by xt's grep.py
+#   Originally I just wanted to add some fixes in grep.py, but then
+#   I got carried away and rewrote everything, so new script.
+#
+#   Commands:
+#   * /grep
+#     Search in logs or buffers, see /help grep
+#   * /logs:
+#     Lists logs in ~/.weechat/logs, see /help logs
+#
+#   Settings:
+#   * plugins.var.python.grep.clear_buffer:
+#     Clear the results buffer before each search. Valid values: on, off
+#
+#   * plugins.var.python.grep.go_to_buffer:
+#     Automatically go to grep buffer when search is over. Valid values: on, off
+#
+#   * plugins.var.python.grep.log_filter:
+#     Coma separated list of patterns that grep will use for exclude logs, e.g.
+#     if you use '*server/*' any log in the 'server' folder will be excluded
+#     when using the command '/grep log'
+#
+#   * plugins.var.python.grep.show_summary:
+#     Shows summary for each log. Valid values: on, off
+#
+#   * plugins.var.python.grep.max_lines:
+#     Grep will only print the last matched lines that don't surpass the value defined here.
+#
+#   * plugins.var.python.grep.size_limit:
+#     Size limit in KiB, is used for decide whenever grepping should run in background or not. If
+#     the logs to grep have a total size bigger than this value then grep run as a new process.
+#     It can be used for force or disable background process, using '0' forces to always grep in
+#     background, while using '' (empty string) will disable it.
+#
+#   * plugins.var.python.grep.default_tail_head:
+#     Config option for define default number of lines returned when using --head or --tail options.
+#     Can be overriden in the command with --number option.
+#
+#
+#   TODO:
+#   * try to figure out why hook_process chokes in long outputs (using a tempfile as a
+#   workaround now)
+#   * possibly add option for defining time intervals
+#
+#
+#   History:
+#
+#   2015-01-31, Nicd-
+#   version 0.7.5:
+#   '~' is now expaned to the home directory in the log file path so
+#   paths like '~/logs/' should work.
+#
+#   2015-01-14, nils_2
+#   version 0.7.4: make q work to quit grep buffer (requested by: gb)
+#
+#   2014-03-29, Felix Eckhofer <felix@tribut.de>
+#   version 0.7.3: fix typo
+#
+#   2011-01-09
+#   version 0.7.2: bug fixes
+#
+#   2010-11-15
+#   version 0.7.1:
+#   * use TempFile so temporal files are guaranteed to be deleted.
+#   * enable Archlinux workaround.
+#
+#   2010-10-26
+#   version 0.7:
+#   * added templates.
+#   * using --only-match shows only unique strings.
+#   * fixed bug that inverted -B -A switches when used with -t
+#
+#   2010-10-14
+#   version 0.6.8: by xt <xt@bash.no>
+#   * supress highlights when printing in grep buffer
+#
+#   2010-10-06
+#   version 0.6.7: by xt <xt@bash.no> 
+#   * better temporary file:
+#    use tempfile.mkstemp. to create a temp file in log dir, 
+#    makes it safer with regards to write permission and multi user
+#
+#   2010-04-08
+#   version 0.6.6: bug fixes
+#   * use WEECHAT_LIST_POS_END in log file completion, makes completion faster
+#   * disable bytecode if using python 2.6
+#   * use single quotes in command string
+#   * fix bug that could change buffer's title when using /grep stop
+#
+#   2010-01-24
+#   version 0.6.5: disable bytecode is a 2.6 feature, instead, resort to delete the bytecode manually
+#
+#   2010-01-19
+#   version 0.6.4: bug fix
+#   version 0.6.3: added options --invert --only-match (replaces --exact, which is still available
+#   but removed from help)
+#   * use new 'irc_nick_color' info
+#   * don't generate bytecode when spawning a new process
+#   * show active options in buffer title
+#
+#   2010-01-17
+#   version 0.6.2: removed 2.6-ish code
+#   version 0.6.1: fixed bug when grepping in grep's buffer
+#
+#   2010-01-14
+#   version 0.6.0: implemented grep in background
+#   * improved context lines presentation.
+#   * grepping for big (or many) log files runs in a weechat_process.
+#   * added /grep stop.
+#   * added 'size_limit' option
+#   * fixed a infolist leak when grepping buffers
+#   * added 'default_tail_head' option
+#   * results are sort by line count
+#   * don't die if log is corrupted (has NULL chars in it)
+#   * changed presentation of /logs
+#   * log path completion doesn't suck anymore
+#   * removed all tabs, because I learned how to configure Vim so that spaces aren't annoying
+#   anymore. This was the script's original policy.
+#
+#   2010-01-05
+#   version 0.5.5: rename script to 'grep.py' (FlashCode <flashcode@flashtux.org>).
+#
+#   2010-01-04
+#   version 0.5.4.1: fix index error when using --after/before-context options.
+#
+#   2010-01-03
+#   version 0.5.4: new features
+#   * added --after-context and --before-context options.
+#   * added --context as a shortcut for using both -A -B options.
+#
+#   2009-11-06
+#   version 0.5.3: improvements for long grep output
+#   * grep buffer input accepts the same flags as /grep for repeat a search with different
+#     options.
+#   * tweaks in grep's output.
+#   * max_lines option added for limit grep's output.
+#   * code in update_buffer() optimized.
+#   * time stats in buffer title.
+#   * added go_to_buffer config option.
+#   * added --buffer for search only in buffers.
+#   * refactoring.
+#
+#   2009-10-12, omero
+#   version 0.5.2: made it python-2.4.x compliant
+#
+#   2009-08-17
+#   version 0.5.1: some refactoring, show_summary option added.
+#
+#   2009-08-13
+#   version 0.5: rewritten from xt's grep.py
+#   * fixed searching in non weechat logs, for cases like, if you're
+#     switching from irssi and rename and copy your irssi logs to %h/logs
+#   * fixed "timestamp rainbow" when you /grep in grep's buffer
+#   * allow to search in other buffers other than current or in logs
+#     of currently closed buffers with cmd 'buffer'
+#   * allow to search in any log file in %h/logs with cmd 'log'
+#   * added --count for return the number of matched lines
+#   * added --matchcase for case sensible search
+#   * added --hilight for color matches
+#   * added --head and --tail options, and --number
+#   * added command /logs for list files in %h/logs
+#   * added config option for clear the buffer before a search
+#   * added config option for filter logs we don't want to grep
+#   * added the posibility to repeat last search with another regexp by writing
+#     it in grep's buffer
+#   * changed spaces for tabs in the code, which is my preference
+#
+###
+
+from os import path
+import sys, getopt, time, os, re, tempfile
+
+try:
+    import weechat
+    from weechat import WEECHAT_RC_OK, prnt, prnt_date_tags
+    import_ok = True
+except ImportError:
+    import_ok = False
+
+SCRIPT_NAME    = "grep"
+SCRIPT_AUTHOR  = "Elián Hanisch <lambdae2@gmail.com>"
+SCRIPT_VERSION = "0.7.5"
+SCRIPT_LICENSE = "GPL3"
+SCRIPT_DESC    = "Search in buffers and logs"
+SCRIPT_COMMAND = "grep"
+
+### Default Settings ###
+settings = {
+'clear_buffer'      : 'off',
+'log_filter'        : '',
+'go_to_buffer'      : 'on',
+'max_lines'         : '4000',
+'show_summary'      : 'on',
+'size_limit'        : '2048',
+'default_tail_head' : '10',
+}
+
+### Class definitions ###
+class linesDict(dict):
+    """
+    Class for handling matched lines in more than one buffer.
+    linesDict[buffer_name] = matched_lines_list
+    """
+    def __setitem__(self, key, value):
+        assert isinstance(value, list)
+        if key not in self:
+            dict.__setitem__(self, key, value)
+        else:
+            dict.__getitem__(self, key).extend(value)
+
+    def get_matches_count(self):
+        """Return the sum of total matches stored."""
+        if dict.__len__(self):
+            return sum(map(lambda L: L.matches_count, self.itervalues()))
+        else:
+            return 0
+
+    def __len__(self):
+        """Return the sum of total lines stored."""
+        if dict.__len__(self):
+            return sum(map(len, self.itervalues()))
+        else:
+            return 0
+
+    def __str__(self):
+        """Returns buffer count or buffer name if there's just one stored."""
+        n = len(self.keys())
+        if n == 1:
+            return self.keys()[0]
+        elif n > 1:
+            return '%s logs' %n
+        else:
+            return ''
+
+    def items(self):
+        """Returns a list of items sorted by line count."""
+        items = dict.items(self)
+        items.sort(key=lambda i: len(i[1]))
+        return items
+
+    def items_count(self):
+        """Returns a list of items sorted by match count."""
+        items = dict.items(self)
+        items.sort(key=lambda i: i[1].matches_count)
+        return items
+
+    def strip_separator(self):
+        for L in self.itervalues():
+            L.strip_separator()
+
+    def get_last_lines(self, n):
+        total_lines = len(self)
+        #debug('total: %s n: %s' %(total_lines, n))
+        if n >= total_lines:
+            # nothing to do
+            return
+        for k, v in reversed(self.items()):
+            l = len(v)
+            if n > 0:
+                if l > n:
+                    del v[:l-n]
+                    v.stripped_lines = l-n
+                n -= l
+            else:
+                del v[:]
+                v.stripped_lines = l
+
+class linesList(list):
+    """Class for list of matches, since sometimes I need to add lines that aren't matches, I need an
+    independent counter."""
+    _sep = '...'
+    def __init__(self, *args):
+        list.__init__(self, *args)
+        self.matches_count = 0
+        self.stripped_lines = 0
+
+    def append(self, item):
+        """Append lines, can be a string or a list with strings."""
+        if isinstance(item, str):
+            list.append(self, item)
+        else:
+            self.extend(item)
+
+    def append_separator(self):
+        """adds a separator into the list, makes sure it doen't add two together."""
+        s = self._sep
+        if (self and self[-1] != s) or not self:
+            self.append(s)
+
+    def onlyUniq(self):
+        s = set(self)
+        del self[:]
+        self.extend(s)
+
+    def count_match(self, item=None):
+        if item is None or isinstance(item, str):
+            self.matches_count += 1
+        else:
+            self.matches_count += len(item)
+
+    def strip_separator(self):
+        """removes separators if there are first or/and last in the list."""
+        if self:
+            s = self._sep
+            if self[0] == s:
+                del self[0]
+            if self[-1] == s:
+                del self[-1]
+
+### Misc functions ###
+now = time.time
+def get_size(f):
+    try:
+        return os.stat(f).st_size
+    except OSError:
+        return 0
+
+sizeDict = {0:'b', 1:'KiB', 2:'MiB', 3:'GiB', 4:'TiB'}
+def human_readable_size(size):
+    power = 0
+    while size > 1024:
+        power += 1
+        size /= 1024.0
+    return '%.2f %s' %(size, sizeDict.get(power, ''))
+
+def color_nick(nick):
+    """Returns coloured nick, with coloured mode if any."""
+    if not nick: return ''
+    wcolor = weechat.color
+    config_string = lambda s : weechat.config_string(weechat.config_get(s))
+    config_int = lambda s : weechat.config_integer(weechat.config_get(s))
+    # prefix and suffix
+    prefix = config_string('irc.look.nick_prefix')
+    suffix = config_string('irc.look.nick_suffix')
+    prefix_c = suffix_c = wcolor(config_string('weechat.color.chat_delimiters'))
+    if nick[0] == prefix:
+        nick = nick[1:]
+    else:
+        prefix = prefix_c = ''
+    if nick[-1] == suffix:
+        nick = nick[:-1]
+        suffix = wcolor(color_delimiter) + suffix
+    else:
+        suffix = suffix_c = ''
+    # nick mode
+    modes = '@!+%'
+    if nick[0] in modes:
+        mode, nick = nick[0], nick[1:]
+        mode_color = wcolor(config_string('weechat.color.nicklist_prefix%d' \
+            %(modes.find(mode) + 1)))
+    else:
+        mode = mode_color = ''
+    # nick color
+    nick_color = weechat.info_get('irc_nick_color', nick)
+    if not nick_color:
+        # probably we're in WeeChat 0.3.0
+        #debug('no irc_nick_color')
+        color_nicks_number = config_int('weechat.look.color_nicks_number')
+        idx = (sum(map(ord, nick))%color_nicks_number) + 1
+        nick_color = wcolor(config_string('weechat.color.chat_nick_color%02d' %idx))
+    return ''.join((prefix_c, prefix, mode_color, mode, nick_color, nick, suffix_c, suffix))
+
+### Config and value validation ###
+boolDict = {'on':True, 'off':False}
+def get_config_boolean(config):
+    value = weechat.config_get_plugin(config)
+    try:
+        return boolDict[value]
+    except KeyError:
+        default = settings[config]
+        error("Error while fetching config '%s'. Using default value '%s'." %(config, default))
+        error("'%s' is invalid, allowed: 'on', 'off'" %value)
+        return boolDict[default]
+
+def get_config_int(config, allow_empty_string=False):
+    value = weechat.config_get_plugin(config)
+    try:
+        return int(value)
+    except ValueError:
+        if value == '' and allow_empty_string:
+            return value
+        default = settings[config]
+        error("Error while fetching config '%s'. Using default value '%s'." %(config, default))
+        error("'%s' is not a number." %value)
+        return int(default)
+
+def get_config_log_filter():
+    filter = weechat.config_get_plugin('log_filter')
+    if filter:
+        return filter.split(',')
+    else:
+        return []
+
+def get_home():
+    home = weechat.config_string(weechat.config_get('logger.file.path'))
+    home = path.abspath(path.expanduser(home))
+    return home.replace('%h', weechat.info_get('weechat_dir', ''))
+
+def strip_home(s, dir=''):
+    """Strips home dir from the begging of the log path, this makes them sorter."""
+    if not dir:
+        global home_dir
+        dir = home_dir
+    l = len(dir)
+    if s[:l] == dir:
+        return s[l:]
+    return s
+
+### Messages ###
+script_nick = SCRIPT_NAME
+def error(s, buffer=''):
+    """Error msg"""
+    prnt(buffer, '%s%s %s' %(weechat.prefix('error'), script_nick, s))
+    if weechat.config_get_plugin('debug'):
+        import traceback
+        if traceback.sys.exc_type:
+            trace = traceback.format_exc()
+            prnt('', trace)
+
+def say(s, buffer=''):
+    """normal msg"""
+    prnt_date_tags(buffer, 0, 'no_highlight', '%s\t%s' %(script_nick, s))
+
+
+
+### Log files and buffers ###
+cache_dir = {} # note: don't remove, needed for completion if the script was loaded recently
+def dir_list(dir, filter_list=(), filter_excludes=True, include_dir=False):
+    """Returns a list of files in 'dir' and its subdirs."""
+    global cache_dir
+    from os import walk
+    from fnmatch import fnmatch
+    #debug('dir_list: listing in %s' %dir)
+    key = (dir, include_dir)
+    try:
+        return cache_dir[key]
+    except KeyError:
+        pass
+    
+    filter_list = filter_list or get_config_log_filter()
+    dir_len = len(dir)
+    if filter_list:
+        def filter(file):
+            file = file[dir_len:] # pattern shouldn't match home dir
+            for pattern in filter_list:
+                if fnmatch(file, pattern):
+                    return filter_excludes
+            return not filter_excludes
+    else:
+        filter = lambda f : not filter_excludes
+
+    file_list = []
+    extend = file_list.extend
+    join = path.join
+    def walk_path():
+        for basedir, subdirs, files in walk(dir):
+            #if include_dir:
+            #    subdirs = map(lambda s : join(s, ''), subdirs)
+            #    files.extend(subdirs)
+            files_path = map(lambda f : join(basedir, f), files)
+            files_path = [ file for file in files_path if not filter(file) ]
+            extend(files_path)
+
+    walk_path()
+    cache_dir[key] = file_list
+    #debug('dir_list: got %s' %str(file_list))
+    return file_list
+
+def get_file_by_pattern(pattern, all=False):
+    """Returns the first log whose path matches 'pattern',
+    if all is True returns all logs that matches."""
+    if not pattern: return []
+    #debug('get_file_by_filename: searching for %s.' %pattern)
+    # do envvar expandsion and check file
+    file = path.expanduser(pattern)
+    file = path.expandvars(file)
+    if path.isfile(file):
+        return [file]
+    # lets see if there's a matching log
+    global home_dir
+    file = path.join(home_dir, pattern)
+    if path.isfile(file):
+        return [file]
+    else:
+        from fnmatch import fnmatch
+        file = []
+        file_list = dir_list(home_dir)
+        n = len(home_dir)
+        for log in file_list:
+            basename = log[n:]
+            if fnmatch(basename, pattern):
+                file.append(log)
+        #debug('get_file_by_filename: got %s.' %file)
+        if not all and file:
+            file.sort()
+            return [ file[-1] ]
+        return file
+
+def get_file_by_buffer(buffer):
+    """Given buffer pointer, finds log's path or returns None."""
+    #debug('get_file_by_buffer: searching for %s' %buffer)
+    infolist = weechat.infolist_get('logger_buffer', '', '')
+    if not infolist: return
+    try:
+        while weechat.infolist_next(infolist):
+            pointer = weechat.infolist_pointer(infolist, 'buffer')
+            if pointer == buffer:
+                file = weechat.infolist_string(infolist, 'log_filename')
+                if weechat.infolist_integer(infolist, 'log_enabled'):
+                    #debug('get_file_by_buffer: got %s' %file)
+                    return file
+                #else:
+                #    debug('get_file_by_buffer: got %s but log not enabled' %file)
+    finally:
+        #debug('infolist gets freed')
+        weechat.infolist_free(infolist)
+
+def get_file_by_name(buffer_name):
+    """Given a buffer name, returns its log path or None. buffer_name should be in 'server.#channel'
+    or '#channel' format."""
+    #debug('get_file_by_name: searching for %s' %buffer_name)
+    # common mask options
+    config_masks = ('logger.mask.irc', 'logger.file.mask')
+    # since there's no buffer pointer, we try to replace some local vars in mask, like $channel and
+    # $server, then replace the local vars left with '*', and use it as a mask for get the path with
+    # get_file_by_pattern
+    for config in config_masks:
+        mask = weechat.config_string(weechat.config_get(config))
+        #debug('get_file_by_name: mask: %s' %mask)
+        if '$name' in mask:
+            mask = mask.replace('$name', buffer_name)
+        elif '$channel' in mask or '$server' in mask:
+            if '.' in buffer_name and \
+                    '#' not in buffer_name[:buffer_name.find('.')]: # the dot isn't part of the channel name
+                #    ^ I'm asuming channel starts with #, i'm lazy.
+                server, channel = buffer_name.split('.', 1)
+            else:
+                server, channel = '*', buffer_name
+            if '$channel' in mask:
+                mask = mask.replace('$channel', channel)
+            if '$server' in mask:
+                mask = mask.replace('$server', server)
+        # change the unreplaced vars by '*'
+        from string import letters
+        if '%' in mask:
+            # vars for time formatting
+            mask = mask.replace('%', '$')
+        if '$' in mask:
+            masks = mask.split('$')
+            masks = map(lambda s: s.lstrip(letters), masks)
+            mask = '*'.join(masks)
+            if mask[0] != '*':
+                mask = '*' + mask
+        #debug('get_file_by_name: using mask %s' %mask)
+        file = get_file_by_pattern(mask)
+        #debug('get_file_by_name: got file %s' %file)
+        if file:
+            return file
+    return None
+
+def get_buffer_by_name(buffer_name):
+    """Given a buffer name returns its buffer pointer or None."""
+    #debug('get_buffer_by_name: searching for %s' %buffer_name)
+    pointer = weechat.buffer_search('', buffer_name)
+    if not pointer:
+        try:
+            infolist = weechat.infolist_get('buffer', '', '')
+            while weechat.infolist_next(infolist):
+                short_name = weechat.infolist_string(infolist, 'short_name')
+                name = weechat.infolist_string(infolist, 'name')
+                if buffer_name in (short_name, name):
+                    #debug('get_buffer_by_name: found %s' %name)
+                    pointer = weechat.buffer_search('', name)
+                    return pointer
+        finally:
+            weechat.infolist_free(infolist)
+    #debug('get_buffer_by_name: got %s' %pointer)
+    return pointer
+
+def get_all_buffers():
+    """Returns list with pointers of all open buffers."""
+    buffers = []
+    infolist = weechat.infolist_get('buffer', '', '')
+    while weechat.infolist_next(infolist):
+        buffers.append(weechat.infolist_pointer(infolist, 'pointer'))
+    weechat.infolist_free(infolist)
+    grep_buffer = weechat.buffer_search('python', SCRIPT_NAME)
+    if grep_buffer and grep_buffer in buffers:
+        # remove it from list
+        del buffers[buffers.index(grep_buffer)]
+    return buffers
+
+### Grep ###
+def make_regexp(pattern, matchcase=False):
+    """Returns a compiled regexp."""
+    if pattern in ('.', '.*', '.?', '.+'):
+        # because I don't need to use a regexp if we're going to match all lines
+        return None
+    # matching takes a lot more time if pattern starts or ends with .* and it isn't needed.
+    if pattern[:2] == '.*':
+        pattern = pattern[2:]
+    if pattern[-2:] == '.*':
+        pattern = pattern[:-2]
+    try:
+        if not matchcase:
+            regexp = re.compile(pattern, re.IGNORECASE)
+        else:
+            regexp = re.compile(pattern)
+    except Exception, e:
+        raise Exception, 'Bad pattern, %s' %e
+    return regexp
+
+def check_string(s, regexp, hilight='', exact=False):
+    """Checks 's' with a regexp and returns it if is a match."""
+    if not regexp:
+        return s
+
+    elif exact:
+        matchlist = regexp.findall(s)
+        if matchlist:
+            if isinstance(matchlist[0], tuple):
+                # join tuples (when there's more than one match group in regexp)
+                return [ ' '.join(t) for t in matchlist ]
+            return matchlist
+
+    elif hilight:
+        matchlist = regexp.findall(s)
+        if matchlist:
+            if isinstance(matchlist[0], tuple):
+                # flatten matchlist
+                matchlist = [ item for L in matchlist for item in L if item ]
+            matchlist = list(set(matchlist)) # remove duplicates if any
+            # apply hilight
+            color_hilight, color_reset = hilight.split(',', 1)
+            for m in matchlist:
+                s = s.replace(m, '%s%s%s' % (color_hilight, m, color_reset))
+            return s
+
+    # no need for findall() here
+    elif regexp.search(s):
+        return s
+
+def grep_file(file, head, tail, after_context, before_context, count, regexp, hilight, exact, invert):
+    """Return a list of lines that match 'regexp' in 'file', if no regexp returns all lines."""
+    if count:
+        tail = head = after_context = before_context = False
+        hilight = ''
+    elif exact:
+        before_context = after_context = False
+        hilight = ''
+    elif invert:
+        hilight = ''
+    #debug(' '.join(map(str, (file, head, tail, after_context, before_context))))
+
+    lines = linesList()
+    # define these locally as it makes the loop run slightly faster
+    append = lines.append
+    count_match = lines.count_match
+    separator = lines.append_separator
+    if invert:
+        def check(s):
+            if check_string(s, regexp, hilight, exact):
+                return None
+            else:
+                return s
+    else:
+        check = lambda s: check_string(s, regexp, hilight, exact)
+    
+    try:
+        file_object = open(file, 'r')
+    except IOError:
+        # file doesn't exist
+        return lines
+    if tail or before_context:
+        # for these options, I need to seek in the file, but is slower and uses a good deal of
+        # memory if the log is too big, so we do this *only* for these options.
+        file_lines = file_object.readlines()
+
+        if tail:
+            # instead of searching in the whole file and later pick the last few lines, we
+            # reverse the log, search until count reached and reverse it again, that way is a lot
+            # faster
+            file_lines.reverse()
+            # don't invert context switches
+            before_context, after_context = after_context, before_context
+
+        if before_context:
+            before_context_range = range(1, before_context + 1)
+            before_context_range.reverse()
+
+        limit = tail or head
+
+        line_idx = 0
+        while line_idx < len(file_lines):
+            line = file_lines[line_idx]
+            line = check(line)
+            if line:
+                if before_context:
+                    separator()
+                    trimmed = False
+                    for id in before_context_range:
+                        try:
+                            context_line = file_lines[line_idx - id]
+                            if check(context_line):
+                                # match in before context, that means we appended these same lines in a
+                                # previous match, so we delete them merging both paragraphs
+                                if not trimmed:
+                                    del lines[id - before_context - 1:]
+                                    trimmed = True
+                            else:
+                                append(context_line)
+                        except IndexError:
+                            pass
+                append(line)
+                count_match(line)
+                if after_context:
+                    id, offset = 0, 0
+                    while id < after_context + offset:
+                        id += 1
+                        try:
+                            context_line = file_lines[line_idx + id]
+                            _context_line = check(context_line)
+                            if _context_line:
+                                offset = id
+                                context_line = _context_line # so match is hilighted with --hilight
+                                count_match()
+                            append(context_line)
+                        except IndexError:
+                            pass
+                    separator()
+                    line_idx += id
+                if limit and lines.matches_count >= limit:
+                    break
+            line_idx += 1
+
+        if tail:
+            lines.reverse()
+    else:
+        # do a normal grep
+        limit = head
+
+        for line in file_object:
+            line = check(line)
+            if line:
+                count or append(line)
+                count_match(line)
+                if after_context:
+                    id, offset = 0, 0
+                    while id < after_context + offset:
+                        id += 1
+                        try:
+                            context_line = file_object.next()
+                            _context_line = check(context_line)
+                            if _context_line:
+                                offset = id
+                                context_line = _context_line
+                                count_match()
+                            count or append(context_line)
+                        except StopIteration:
+                            pass
+                    separator()
+                if limit and lines.matches_count >= limit:
+                    break
+
+    file_object.close()
+    return lines
+
+def grep_buffer(buffer, head, tail, after_context, before_context, count, regexp, hilight, exact,
+        invert):
+    """Return a list of lines that match 'regexp' in 'buffer', if no regexp returns all lines."""
+    lines = linesList()
+    if count:
+        tail = head = after_context = before_context = False
+        hilight = ''
+    elif exact:
+        before_context = after_context = False
+    #debug(' '.join(map(str, (tail, head, after_context, before_context, count, exact, hilight))))
+
+    # Using /grep in grep's buffer can lead to some funny effects
+    # We should take measures if that's the case
+    def make_get_line_funcion():
+        """Returns a function for get lines from the infolist, depending if the buffer is grep's or
+        not."""
+        string_remove_color = weechat.string_remove_color
+        infolist_string = weechat.infolist_string
+        grep_buffer = weechat.buffer_search('python', SCRIPT_NAME)
+        if grep_buffer and buffer == grep_buffer:
+            def function(infolist):
+                prefix = infolist_string(infolist, 'prefix')
+                message = infolist_string(infolist, 'message')
+                if prefix: # only our messages have prefix, ignore it
+                    return None
+                return message
+        else:
+            infolist_time = weechat.infolist_time
+            def function(infolist):
+                prefix = string_remove_color(infolist_string(infolist, 'prefix'), '')
+                message = string_remove_color(infolist_string(infolist, 'message'), '')
+                date = infolist_time(infolist, 'date')
+                return '%s\t%s\t%s' %(date, prefix, message)
+        return function
+    get_line = make_get_line_funcion()
+
+    infolist = weechat.infolist_get('buffer_lines', buffer, '')
+    if tail:
+        # like with grep_file() if we need the last few matching lines, we move the cursor to
+        # the end and search backwards
+        infolist_next = weechat.infolist_prev
+        infolist_prev = weechat.infolist_next
+    else:
+        infolist_next = weechat.infolist_next
+        infolist_prev = weechat.infolist_prev
+    limit = head or tail
+
+    # define these locally as it makes the loop run slightly faster
+    append = lines.append
+    count_match = lines.count_match
+    separator = lines.append_separator
+    if invert:
+        def check(s):
+            if check_string(s, regexp, hilight, exact):
+                return None
+            else:
+                return s
+    else:
+        check = lambda s: check_string(s, regexp, hilight, exact)
+
+    if before_context:
+        before_context_range = range(1, before_context + 1)
+        before_context_range.reverse()
+
+    while infolist_next(infolist):
+        line = get_line(infolist)
+        if line is None: continue
+        line = check(line)
+        if line:
+            if before_context:
+                separator()
+                trimmed = False
+                for id in before_context_range:
+                    if not infolist_prev(infolist):
+                        trimmed = True
+                for id in before_context_range:
+                    context_line = get_line(infolist)
+                    if check(context_line):
+                        if not trimmed:
+                            del lines[id - before_context - 1:]
+                            trimmed = True
+                    else:
+                        append(context_line)
+                    infolist_next(infolist)
+            count or append(line)
+            count_match(line)
+            if after_context:
+                id, offset = 0, 0
+                while id < after_context + offset:
+                    id += 1
+                    if infolist_next(infolist):
+                        context_line = get_line(infolist)
+                        _context_line = check(context_line)
+                        if _context_line:
+                            context_line = _context_line
+                            offset = id
+                            count_match()
+                        append(context_line)
+                    else:
+                        # in the main loop infolist_next will start again an cause an infinite loop
+                        # this will avoid it
+                        infolist_next = lambda x: 0
+                separator()
+            if limit and lines.matches_count >= limit:
+                break
+    weechat.infolist_free(infolist)
+
+    if tail:
+        lines.reverse()
+    return lines
+
+### this is our main grep function
+hook_file_grep = None
+def show_matching_lines():
+    """
+    Greps buffers in search_in_buffers or files in search_in_files and updates grep buffer with the
+    result.
+    """
+    global pattern, matchcase, number, count, exact, hilight, invert
+    global tail, head, after_context, before_context
+    global search_in_files, search_in_buffers, matched_lines, home_dir
+    global time_start
+    matched_lines = linesDict()
+    #debug('buffers:%s \nlogs:%s' %(search_in_buffers, search_in_files))
+    time_start = now()
+
+    # buffers
+    if search_in_buffers:
+        regexp = make_regexp(pattern, matchcase)
+        for buffer in search_in_buffers:
+            buffer_name = weechat.buffer_get_string(buffer, 'name')
+            matched_lines[buffer_name] = grep_buffer(buffer, head, tail, after_context,
+                    before_context, count, regexp, hilight, exact, invert)
+
+    # logs
+    if search_in_files:
+        size_limit = get_config_int('size_limit', allow_empty_string=True)
+        background = False
+        if size_limit or size_limit == 0:
+            size = sum(map(get_size, search_in_files))
+            if size > size_limit * 1024:
+                background = True
+        elif size_limit == '':
+            background = False
+
+        if not background:
+            # run grep normally
+            regexp = make_regexp(pattern, matchcase)
+            for log in search_in_files:
+                log_name = strip_home(log)
+                matched_lines[log_name] = grep_file(log, head, tail, after_context, before_context,
+                        count, regexp, hilight, exact, invert)
+            buffer_update()
+        else:
+            # we hook a process so grepping runs in background.
+            #debug('on background')
+            global hook_file_grep, script_path, bytecode
+            timeout = 1000*60*5 # 5 min
+
+            quotify = lambda s: '"%s"' %s
+            files_string = ', '.join(map(quotify, search_in_files))
+
+            global tmpFile
+            # we keep the file descriptor as a global var so it isn't deleted until next grep
+            tmpFile = tempfile.NamedTemporaryFile(prefix=SCRIPT_NAME,
+                    dir=weechat.info_get('weechat_dir', ''))
+            cmd = grep_process_cmd %dict(logs=files_string, head=head, pattern=pattern, tail=tail,
+                    hilight=hilight, after_context=after_context, before_context=before_context,
+                    exact=exact, matchcase=matchcase, home_dir=home_dir, script_path=script_path,
+                    count=count, invert=invert, bytecode=bytecode, filename=tmpFile.name,
+                    python=weechat.info_get('python2_bin', '') or 'python')
+
+            #debug(cmd)
+            hook_file_grep = weechat.hook_process(cmd, timeout, 'grep_file_callback', tmpFile.name)
+            global pattern_tmpl
+            if hook_file_grep:
+                buffer_create("Searching for '%s' in %s worth of data..." %(pattern_tmpl,
+                    human_readable_size(size)))
+    else:
+        buffer_update()
+
+# defined here for commodity
+grep_process_cmd = """%(python)s -%(bytecode)sc '
+import sys, cPickle, os
+sys.path.append("%(script_path)s") # add WeeChat script dir so we can import grep
+from grep import make_regexp, grep_file, strip_home
+logs = (%(logs)s, )
+try:
+    regexp = make_regexp("%(pattern)s", %(matchcase)s)
+    d = {}
+    for log in logs:
+        log_name = strip_home(log, "%(home_dir)s")
+        lines = grep_file(log, %(head)s, %(tail)s, %(after_context)s, %(before_context)s,
+        %(count)s, regexp, "%(hilight)s", %(exact)s, %(invert)s)
+        d[log_name] = lines
+    fd = open("%(filename)s", "wb")
+    cPickle.dump(d, fd, -1)
+    fd.close()
+except Exception, e:
+    print >> sys.stderr, e'
+"""
+
+grep_stdout = grep_stderr = ''
+def grep_file_callback(filename, command, rc, stdout, stderr):
+    global hook_file_grep, grep_stderr,  grep_stdout
+    global matched_lines
+    #debug("rc: %s\nstderr: %s\nstdout: %s" %(rc, repr(stderr), repr(stdout)))
+    if stdout:
+        grep_stdout += stdout
+    if stderr:
+        grep_stderr += stderr
+    if int(rc) >= 0:
+  
+        def set_buffer_error():
+            grep_buffer = buffer_create()
+            title = weechat.buffer_get_string(grep_buffer, 'title')
+            title = title + ' %serror' %color_title
+            weechat.buffer_set(grep_buffer, 'title', title)
+
+        try:
+            if grep_stderr:
+                error(grep_stderr)
+                set_buffer_error()
+            #elif grep_stdout:
+                #debug(grep_stdout)
+            elif path.exists(filename):
+                import cPickle
+                try:
+                    #debug(file)
+                    fd = open(filename, 'rb')
+                    d = cPickle.load(fd)
+                    matched_lines.update(d)
+                    fd.close()
+                except Exception, e:
+                    error(e)
+                    set_buffer_error()
+                else:
+                    buffer_update()
+            global tmpFile
+            tmpFile = None
+        finally:
+            grep_stdout = grep_stderr = ''
+            hook_file_grep = None
+    return WEECHAT_RC_OK
+
+def get_grep_file_status():
+    global search_in_files, matched_lines, time_start
+    elapsed = now() - time_start
+    if len(search_in_files) == 1:
+        log = '%s (%s)' %(strip_home(search_in_files[0]),
+                human_readable_size(get_size(search_in_files[0])))
+    else:
+        size = sum(map(get_size, search_in_files))
+        log = '%s log files (%s)' %(len(search_in_files), human_readable_size(size))
+    return 'Searching in %s, running for %.4f seconds. Interrupt it with "/grep stop" or "stop"' \
+        ' in grep buffer.' %(log, elapsed)
+
+### Grep buffer ###
+def buffer_update():
+    """Updates our buffer with new lines."""
+    global pattern_tmpl, matched_lines, pattern, count, hilight, invert, exact
+    time_grep = now()
+
+    buffer = buffer_create()
+    if get_config_boolean('clear_buffer'):
+        weechat.buffer_clear(buffer)
+    matched_lines.strip_separator() # remove first and last separators of each list
+    len_total_lines = len(matched_lines)
+    max_lines = get_config_int('max_lines')
+    if not count and len_total_lines > max_lines:
+        weechat.buffer_clear(buffer)
+
+    def _make_summary(log, lines, note):
+        return '%s matches "%s%s%s"%s in %s%s%s%s' \
+                %(lines.matches_count, color_summary, pattern_tmpl, color_info,
+                  invert and ' (inverted)' or '',
+                  color_summary, log, color_reset, note)
+
+    if count:
+        make_summary = lambda log, lines : _make_summary(log, lines, ' (not shown)')
+    else:
+        def make_summary(log, lines):
+            if lines.stripped_lines:
+                if lines:
+                    note = ' (last %s lines shown)' %len(lines)
+                else:
+                    note = ' (not shown)'
+            else:
+                note = ''
+            return _make_summary(log, lines, note)
+
+    global weechat_format
+    if hilight:
+        # we don't want colors if there's match highlighting
+        format_line = lambda s : '%s %s %s' %split_line(s)
+    else:
+        def format_line(s):
+            global nick_dict, weechat_format
+            date, nick, msg = split_line(s)
+            if weechat_format:
+                try:
+                    nick = nick_dict[nick]
+                except KeyError:
+                    # cache nick
+                    nick_c = color_nick(nick)
+                    nick_dict[nick] = nick_c
+                    nick = nick_c
+                return '%s%s %s%s %s' %(color_date, date, nick, color_reset, msg)
+            else:
+                #no formatting
+                return msg
+
+    prnt(buffer, '\n')
+    print_line('Search for "%s%s%s"%s in %s%s%s.' %(color_summary, pattern_tmpl, color_info,
+        invert and ' (inverted)' or '', color_summary, matched_lines, color_reset),
+            buffer)
+    # print last <max_lines> lines
+    if matched_lines.get_matches_count():
+        if count:
+            # with count we sort by matches lines instead of just lines.
+            matched_lines_items = matched_lines.items_count()
+        else:
+            matched_lines_items = matched_lines.items()
+
+        matched_lines.get_last_lines(max_lines)
+        for log, lines in matched_lines_items:
+            if lines.matches_count:
+                # matched lines
+                if not count:
+                    # print lines
+                    weechat_format = True
+                    if exact:
+                        lines.onlyUniq()
+                    for line in lines:
+                        #debug(repr(line))
+                        if line == linesList._sep:
+                            # separator
+                            prnt(buffer, context_sep)
+                        else:
+                            if '\x00' in line:
+                                # log was corrupted
+                                error("Found garbage in log '%s', maybe it's corrupted" %log)
+                                line = line.replace('\x00', '')
+                            prnt_date_tags(buffer, 0, 'no_highlight', format_line(line))
+
+                # summary
+                if count or get_config_boolean('show_summary'):
+                    summary = make_summary(log, lines)
+                    print_line(summary, buffer)
+
+            # separator
+            if not count and lines:
+                prnt(buffer, '\n')
+    else:
+        print_line('No matches found.', buffer)
+
+    # set title
+    global time_start
+    time_end = now()
+    # total time
+    time_total = time_end - time_start
+    # percent of the total time used for grepping
+    time_grep_pct = (time_grep - time_start)/time_total*100
+    #debug('time: %.4f seconds (%.2f%%)' %(time_total, time_grep_pct))
+    if not count and len_total_lines > max_lines:
+        note = ' (last %s lines shown)' %len(matched_lines)
+    else:
+        note = ''
+    title = "'q': close buffer | Search in %s%s%s %s matches%s | pattern \"%s%s%s\"%s %s | %.4f seconds (%.2f%%)" \
+            %(color_title, matched_lines, color_reset, matched_lines.get_matches_count(), note,
+              color_title, pattern_tmpl, color_reset, invert and ' (inverted)' or '', format_options(),
+              time_total, time_grep_pct)
+    weechat.buffer_set(buffer, 'title', title)
+
+    if get_config_boolean('go_to_buffer'):
+        weechat.buffer_set(buffer, 'display', '1')
+
+    # free matched_lines so it can be removed from memory
+    del matched_lines
+    
+def split_line(s):
+    """Splits log's line 's' in 3 parts, date, nick and msg."""
+    global weechat_format
+    if weechat_format and s.count('\t') >= 2:
+        date, nick, msg = s.split('\t', 2) # date, nick, message
+    else:
+        # looks like log isn't in weechat's format
+        weechat_format = False # incoming lines won't be formatted
+        date, nick, msg = '', '', s
+    # remove tabs
+    if '\t' in msg:
+        msg = msg.replace('\t', '    ')
+    return date, nick, msg
+
+def print_line(s, buffer=None, display=False):
+    """Prints 's' in script's buffer as 'script_nick'. For displaying search summaries."""
+    if buffer is None:
+        buffer = buffer_create()
+    say('%s%s' %(color_info, s), buffer)
+    if display and get_config_boolean('go_to_buffer'):
+        weechat.buffer_set(buffer, 'display', '1')
+
+def format_options():
+    global matchcase, number, count, exact, hilight, invert
+    global tail, head, after_context, before_context
+    options = []
+    append = options.append
+    insert = options.insert
+    chars = 'cHmov'
+    for i, flag in enumerate((count, hilight, matchcase, exact, invert)):
+        if flag:
+            append(chars[i])
+
+    if head or tail:
+        n = get_config_int('default_tail_head')
+        if head:
+            append('h')
+            if head != n:
+                insert(-1, ' -')
+                append('n')
+                append(head)
+        elif tail:
+            append('t')
+            if tail != n:
+                insert(-1, ' -')
+                append('n')
+                append(tail)
+
+    if before_context and after_context and (before_context == after_context):
+        append(' -C')
+        append(before_context)
+    else:
+        if before_context:
+            append(' -B')
+            append(before_context)
+        if after_context:
+            append(' -A')
+            append(after_context)
+
+    s = ''.join(map(str, options)).strip()
+    if s and s[0] != '-':
+        s = '-' + s
+    return s
+
+def buffer_create(title=None):
+    """Returns our buffer pointer, creates and cleans the buffer if needed."""
+    buffer = weechat.buffer_search('python', SCRIPT_NAME)
+    if not buffer:
+        buffer = weechat.buffer_new(SCRIPT_NAME, 'buffer_input', '', '', '')
+        weechat.buffer_set(buffer, 'time_for_each_line', '0')
+        weechat.buffer_set(buffer, 'nicklist', '0')
+        weechat.buffer_set(buffer, 'title', title or 'grep output buffer')
+        weechat.buffer_set(buffer, 'localvar_set_no_log', '1')
+    elif title:
+        weechat.buffer_set(buffer, 'title', title)
+    return buffer
+
+def buffer_input(data, buffer, input_data):
+    """Repeats last search with 'input_data' as regexp."""
+    try:
+        cmd_grep_stop(buffer, input_data)
+    except:
+        return WEECHAT_RC_OK
+    if input_data in ('q', 'Q'):
+        weechat.buffer_close(buffer)
+        return weechat.WEECHAT_RC_OK
+
+    global search_in_buffers, search_in_files
+    global pattern
+    try:
+        if pattern and (search_in_files or search_in_buffers):
+            # check if the buffer pointers are still valid
+            for pointer in search_in_buffers:
+                infolist = weechat.infolist_get('buffer', pointer, '')
+                if not infolist:
+                    del search_in_buffers[search_in_buffers.index(pointer)]
+                weechat.infolist_free(infolist)
+            try:
+                cmd_grep_parsing(input_data)
+            except Exception, e:
+                error('Argument error, %s' %e, buffer=buffer)
+                return WEECHAT_RC_OK
+            try:
+                show_matching_lines()
+            except Exception, e:
+                error(e)
+    except NameError:
+        error("There isn't any previous search to repeat.", buffer=buffer)
+    return WEECHAT_RC_OK
+
+### Commands ###
+def cmd_init():
+    """Resets global vars."""
+    global home_dir, cache_dir, nick_dict
+    global pattern_tmpl, pattern, matchcase, number, count, exact, hilight, invert
+    global tail, head, after_context, before_context
+    hilight = ''
+    head = tail = after_context = before_context = invert = False
+    matchcase = count = exact = False
+    pattern_tmpl = pattern = number = None
+    home_dir = get_home()
+    cache_dir = {} # for avoid walking the dir tree more than once per command
+    nick_dict = {} # nick cache for don't calculate nick color every time
+
+def cmd_grep_parsing(args):
+    """Parses args for /grep and grep input buffer."""
+    global pattern_tmpl, pattern, matchcase, number, count, exact, hilight, invert
+    global tail, head, after_context, before_context
+    global log_name, buffer_name, only_buffers, all
+    opts, args = getopt.gnu_getopt(args.split(), 'cmHeahtivn:bA:B:C:o', ['count', 'matchcase', 'hilight',
+        'exact', 'all', 'head', 'tail', 'number=', 'buffer', 'after-context=', 'before-context=',
+        'context=', 'invert', 'only-match'])
+    #debug(opts, 'opts: '); debug(args, 'args: ')
+    if len(args) >= 2:
+        if args[0] == 'log':
+            del args[0]
+            log_name = args.pop(0)
+        elif args[0] == 'buffer':
+            del args[0]
+            buffer_name = args.pop(0)
+
+    def tmplReplacer(match):
+        """This function will replace templates with regexps"""
+        s = match.groups()[0]
+        tmpl_args = s.split()
+        tmpl_key, _, tmpl_args = s.partition(' ')
+        try:
+            template = templates[tmpl_key]
+            if callable(template):
+                r = template(tmpl_args)
+                if not r:
+                    error("Template %s returned empty string "\
+                          "(WeeChat doesn't have enough data)." %t)
+                return r
+            else:
+                return template
+        except:
+            return t
+
+    args = ' '.join(args) # join pattern for keep spaces
+    if args:
+        pattern_tmpl = args  
+        pattern = _tmplRe.sub(tmplReplacer, args)
+        debug('Using regexp: %s', pattern)
+    if not pattern:
+        raise Exception, 'No pattern for grep the logs.'
+
+    def positive_number(opt, val):
+        try:
+            number = int(val)
+            if number < 0:
+                raise ValueError
+            return number
+        except ValueError:
+            if len(opt) == 1:
+                opt = '-' + opt
+            else:
+                opt = '--' + opt
+            raise Exception, "argument for %s must be a positive integer." %opt
+
+    for opt, val in opts:
+        opt = opt.strip('-')
+        if opt in ('c', 'count'):
+            count = not count
+        elif opt in ('m', 'matchcase'):
+            matchcase = not matchcase
+        elif opt in ('H', 'hilight'):
+            # hilight must be always a string!
+            if hilight:
+                hilight = ''
+            else:
+                hilight = '%s,%s' %(color_hilight, color_reset)
+            # we pass the colors in the variable itself because check_string() must not use
+            # weechat's module when applying the colors (this is for grep in a hooked process)
+        elif opt in ('e', 'exact', 'o', 'only-match'):
+            exact = not exact
+            invert = False
+        elif opt in ('a', 'all'):
+            all = not all
+        elif opt in ('h', 'head'):
+            head = not head
+            tail = False
+        elif opt in ('t', 'tail'):
+            tail = not tail
+            head = False
+        elif opt in ('b', 'buffer'):
+            only_buffers = True
+        elif opt in ('n', 'number'):
+            number = positive_number(opt, val)
+        elif opt in ('C', 'context'):
+            n = positive_number(opt, val)
+            after_context = n
+            before_context = n
+        elif opt in ('A', 'after-context'):
+            after_context = positive_number(opt, val)
+        elif opt in ('B', 'before-context'):
+            before_context = positive_number(opt, val)
+        elif opt in ('i', 'v', 'invert'):
+            invert = not invert
+            exact = False
+    # number check
+    if number is not None:
+        if number == 0:
+            head = tail = False
+            number = None
+        elif head:
+            head = number
+        elif tail:
+            tail = number
+    else:
+        n = get_config_int('default_tail_head')
+        if head:
+            head = n
+        elif tail:
+            tail = n
+
+def cmd_grep_stop(buffer, args):
+    global hook_file_grep, pattern, matched_lines, tmpFile
+    if hook_file_grep:
+        if args == 'stop':
+            weechat.unhook(hook_file_grep)
+            hook_file_grep = None
+            s = 'Search for \'%s\' stopped.' %pattern
+            say(s, buffer)
+            grep_buffer = weechat.buffer_search('python', SCRIPT_NAME)
+            if grep_buffer:
+                weechat.buffer_set(grep_buffer, 'title', s)
+            del matched_lines
+            tmpFile = None
+        else:
+            say(get_grep_file_status(), buffer)
+        raise Exception
+
+def cmd_grep(data, buffer, args):
+    """Search in buffers and logs."""
+    global pattern, matchcase, head, tail, number, count, exact, hilight
+    try:
+        cmd_grep_stop(buffer, args)
+    except:
+        return WEECHAT_RC_OK
+
+    if not args:
+        weechat.command('', '/help %s' %SCRIPT_COMMAND)
+        return WEECHAT_RC_OK
+
+    cmd_init()
+    global log_name, buffer_name, only_buffers, all
+    log_name = buffer_name = ''
+    only_buffers = all = False
+
+    # parse
+    try:
+        cmd_grep_parsing(args)
+    except Exception, e:
+        error('Argument error, %s' %e)
+        return WEECHAT_RC_OK
+
+    # find logs
+    log_file = search_buffer = None
+    if log_name:
+        log_file = get_file_by_pattern(log_name, all)
+        if not log_file:
+            error("Couldn't find any log for %s. Try /logs" %log_name)
+            return WEECHAT_RC_OK
+    elif all:
+        search_buffer = get_all_buffers()
+    elif buffer_name:
+        search_buffer = get_buffer_by_name(buffer_name)
+        if not search_buffer:
+            # there's no buffer, try in the logs
+            log_file = get_file_by_name(buffer_name)
+            if not log_file:
+                error("Logs or buffer for '%s' not found." %buffer_name)
+                return WEECHAT_RC_OK
+        else:
+            search_buffer = [search_buffer]
+    else:
+        search_buffer = [buffer]
+
+    # make the log list
+    global search_in_files, search_in_buffers
+    search_in_files = []
+    search_in_buffers = []
+    if log_file:
+        search_in_files = log_file
+    elif not only_buffers:
+        #debug(search_buffer)
+        for pointer in search_buffer:
+            log = get_file_by_buffer(pointer)
+            #debug('buffer %s log %s' %(pointer, log))
+            if log:
+                search_in_files.append(log)
+            else:
+                search_in_buffers.append(pointer)
+    else:
+        search_in_buffers = search_buffer
+
+    # grepping
+    try:
+        show_matching_lines()
+    except Exception, e:
+        error(e)
+    return WEECHAT_RC_OK
+
+def cmd_logs(data, buffer, args):
+    """List files in Weechat's log dir."""
+    cmd_init()
+    global home_dir
+    sort_by_size = False
+    filter = []
+
+    try:
+        opts, args = getopt.gnu_getopt(args.split(), 's', ['size'])
+        if args:
+            filter = args
+        for opt, var in opts:
+            opt = opt.strip('-')
+            if opt in ('size', 's'):
+                sort_by_size = True
+    except Exception, e:
+        error('Argument error, %s' %e)
+        return WEECHAT_RC_OK
+
+    # is there's a filter, filter_excludes should be False
+    file_list = dir_list(home_dir, filter, filter_excludes=not filter)
+    if sort_by_size:
+        file_list.sort(key=get_size)
+    else:
+        file_list.sort()
+
+    file_sizes = map(lambda x: human_readable_size(get_size(x)), file_list)
+    # calculate column lenght
+    if file_list:
+        L = file_list[:]
+        L.sort(key=len)
+        bigest = L[-1]
+        column_len = len(bigest) + 3
+    else:
+        column_len = ''
+
+    buffer = buffer_create()
+    if get_config_boolean('clear_buffer'):
+        weechat.buffer_clear(buffer)
+    file_list = zip(file_list, file_sizes)
+    msg = 'Found %s logs.' %len(file_list)
+
+    print_line(msg, buffer, display=True)
+    for file, size in file_list:
+        separator = column_len and '.'*(column_len - len(file))
+        prnt(buffer, '%s %s %s' %(strip_home(file), separator, size))
+    if file_list:
+        print_line(msg, buffer)
+    return WEECHAT_RC_OK
+
+
+### Completion ###
+def completion_log_files(data, completion_item, buffer, completion):
+    #debug('completion: %s' %', '.join((data, completion_item, buffer, completion)))
+    global home_dir
+    l = len(home_dir)
+    completion_list_add = weechat.hook_completion_list_add
+    WEECHAT_LIST_POS_END = weechat.WEECHAT_LIST_POS_END
+    for log in dir_list(home_dir):
+        completion_list_add(completion, log[l:], 0, WEECHAT_LIST_POS_END)
+    return WEECHAT_RC_OK
+
+def completion_grep_args(data, completion_item, buffer, completion):
+    for arg in ('count', 'all', 'matchcase', 'hilight', 'exact', 'head', 'tail', 'number', 'buffer',
+            'after-context', 'before-context', 'context', 'invert', 'only-match'):
+        weechat.hook_completion_list_add(completion, '--' + arg, 0, weechat.WEECHAT_LIST_POS_SORT)
+    for tmpl in templates:
+        weechat.hook_completion_list_add(completion, '%{' + tmpl, 0, weechat.WEECHAT_LIST_POS_SORT)
+    return WEECHAT_RC_OK
+
+
+### Templates ###
+# template placeholder
+_tmplRe = re.compile(r'%\{(\w+.*?)(?:\}|$)')
+# will match 999.999.999.999 but I don't care
+ipAddress = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
+domain = r'[\w-]{2,}(?:\.[\w-]{2,})*\.[a-z]{2,}'
+url = r'\w+://(?:%s|%s)(?::\d+)?(?:/[^\])>\s]*)?' % (domain, ipAddress)
+
+def make_url_regexp(args):
+    #debug('make url: %s', args)
+    if args:
+        words = r'(?:%s)' %'|'.join(map(re.escape, args.split()))
+        return r'(?:\w+://|www\.)[^\s]*%s[^\s]*(?:/[^\])>\s]*)?' %words
+    else:
+        return url
+
+def make_simple_regexp(pattern):
+    s = ''
+    for c in pattern:
+        if c == '*':
+            s += '.*'
+        elif c == '?':
+            s += '.'
+        else:
+            s += re.escape(c)
+    return s
+
+templates = {
+            'ip': ipAddress,
+           'url': make_url_regexp,
+        'escape': lambda s: re.escape(s),
+        'simple': make_simple_regexp,
+        'domain': domain,
+        }
+
+### Main ###
+def delete_bytecode():
+    global script_path
+    bytecode = path.join(script_path, SCRIPT_NAME + '.pyc')
+    if path.isfile(bytecode):
+        os.remove(bytecode)
+    return WEECHAT_RC_OK
+
+if __name__ == '__main__' and import_ok and \
+        weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, \
+        SCRIPT_DESC, 'delete_bytecode', ''):
+    home_dir = get_home()
+
+    # for import ourselves
+    global script_path
+    script_path = path.dirname(__file__)
+    sys.path.append(script_path)
+    delete_bytecode()
+
+    # check python version
+    import sys
+    global bytecode
+    if sys.version_info > (2, 6):
+        bytecode = 'B'
+    else:
+        bytecode = ''
+
+
+    weechat.hook_command(SCRIPT_COMMAND, cmd_grep.__doc__,
+            "[log <file> | buffer <name> | stop] [-a|--all] [-b|--buffer] [-c|--count] [-m|--matchcase] "
+            "[-H|--hilight] [-o|--only-match] [-i|-v|--invert] [(-h|--head)|(-t|--tail) [-n|--number <n>]] "
+            "[-A|--after-context <n>] [-B|--before-context <n>] [-C|--context <n> ] <expression>",
+# help
+"""
+     log <file>: Search in one log that matches <file> in the logger path.
+                 Use '*' and '?' as wildcards.
+  buffer <name>: Search in buffer <name>, if there's no buffer with <name> it will
+                 try to search for a log file.
+           stop: Stops a currently running search.
+       -a --all: Search in all open buffers.
+                 If used with 'log <file>' search in all logs that matches <file>.
+    -b --buffer: Search only in buffers, not in file logs.
+     -c --count: Just count the number of matched lines instead of showing them.
+ -m --matchcase: Don't do case insensible search.
+   -H --hilight: Colour exact matches in output buffer.
+-o --only-match: Print only the matching part of the line (unique matches).
+ -v -i --invert: Print lines that don't match the regular expression.
+      -t --tail: Print the last 10 matching lines.
+      -h --head: Print the first 10 matching lines.
+-n --number <n>: Overrides default number of lines for --tail or --head.
+-A --after-context <n>: Shows <n> lines of trailing context after matching lines.
+-B --before-context <n>: Shows <n> lines of leading context before matching lines.
+-C --context <n>: Same as using both --after-context and --before-context simultaneously.
+  <expression>: Expression to search.
+
+Grep buffer:
+  Input line accepts most arguments of /grep, it'll repeat last search using the new
+  arguments provided. You can't search in different logs from the buffer's input.
+  Boolean arguments like --count, --tail, --head, --hilight, ... are toggleable
+
+Python regular expression syntax:
+  See http://docs.python.org/lib/re-syntax.html
+
+Grep Templates:
+     %{url [text]}: Matches anything like an url, or an url with text.
+             %{ip}: Matches anything that looks like an ip.
+         %{domain}: Matches anything like a domain.
+    %{escape text}: Escapes text in pattern.
+ %{simple pattern}: Converts a pattern with '*' and '?' wildcards into a regexp.
+
+Examples:
+  Search for urls with the word 'weechat' said by 'nick'
+    /grep nick\\t.*%{url weechat}
+  Search for '*.*' string
+    /grep %{escape *.*}
+""",
+            # completion template
+            "buffer %(buffers_names) %(grep_arguments)|%*"
+            "||log %(grep_log_files) %(grep_arguments)|%*"
+            "||stop"
+            "||%(grep_arguments)|%*",
+            'cmd_grep' ,'')
+    weechat.hook_command('logs', cmd_logs.__doc__, "[-s|--size] [<filter>]",
+            "-s --size: Sort logs by size.\n"
+            " <filter>: Only show logs that match <filter>. Use '*' and '?' as wildcards.", '--size', 'cmd_logs', '')
+
+    weechat.hook_completion('grep_log_files', "list of log files",
+            'completion_log_files', '')
+    weechat.hook_completion('grep_arguments', "list of arguments",
+            'completion_grep_args', '')
+
+    # settings
+    for opt, val in settings.iteritems():
+        if not weechat.config_is_set_plugin(opt):
+            weechat.config_set_plugin(opt, val)
+
+    # colors
+    color_date        = weechat.color('brown')
+    color_info        = weechat.color('cyan')
+    color_hilight     = weechat.color('lightred')
+    color_reset       = weechat.color('reset')
+    color_title       = weechat.color('yellow')
+    color_summary     = weechat.color('lightcyan')
+    color_delimiter   = weechat.color('chat_delimiters')
+    color_script_nick = weechat.color('chat_nick')
+    
+    # pretty [grep]
+    script_nick = '%s[%s%s%s]%s' %(color_delimiter, color_script_nick, SCRIPT_NAME, color_delimiter,
+            color_reset)
+    script_nick_nocolor = '[%s]' %SCRIPT_NAME
+    # paragraph separator when using context options
+    context_sep = '%s\t%s--' %(script_nick, color_info)
+
+    # -------------------------------------------------------------------------
+    # Debug
+
+    if weechat.config_get_plugin('debug'):
+        try:
+            # custom debug module I use, allows me to inspect script's objects.
+            import pybuffer
+            debug = pybuffer.debugBuffer(globals(), '%s_debug' % SCRIPT_NAME)
+        except:
+            def debug(s, *args):
+                if not isinstance(s, basestring):
+                    s = str(s)
+                if args:
+                    s = s %args
+                prnt('', '%s\t%s' %(script_nick, s))
+    else:
+        def debug(*args):
+            pass
+
+# vim:set shiftwidth=4 tabstop=4 softtabstop=4 expandtab textwidth=100: