logo

dotfiles

My dotfiles, one branch per machine, rebased on base git clone https://hacktivis.me/git/dotfiles.git

colorize_nicks.py (16123B)

    

  1. # -*- coding: utf-8 -*-
  2. #
  3. # Copyright (c) 2010 by xt <xt@bash.no>
  4. #
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 3 of the License, or
  8. # (at your option) any later version.
  9. #
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14. #
  15. # You should have received a copy of the GNU General Public License
  16. # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17. #
  19. # This script colors nicks in IRC channels in the actual message
  20. # not just in the prefix section.
  21. #
  22. #
  23. # History:
  24. # 2018-04-06: Joey Pabalinas <joeypabalinas@gmail.com>
  25. #   version 26: fix freezes with too many nicks in one line
  26. # 2018-03-18: nils_2
  27. #   version 25: fix unable to run function colorize_config_reload_cb()
  28. # 2017-06-20: lbeziaud <louis.beziaud@ens-rennes.fr>
  29. #   version 24: colorize utf8 nicks
  30. # 2017-03-01, arza <arza@arza.us>
  31. #   version 23: don't colorize nicklist group names
  32. # 2016-05-01, Simmo Saan <simmo.saan@gmail.com>
  33. #   version 22: invalidate cached colors on hash algorithm change
  34. # 2015-07-28, xt
  35. #   version 21: fix problems with nicks with commas in them
  36. # 2015-04-19, xt
  37. #   version 20: fix ignore of nicks in URLs
  38. # 2015-04-18, xt
  39. #   version 19: new option ignore nicks in URLs
  40. # 2015-03-03, xt
  41. #   version 18: iterate buffers looking for nicklists instead of servers
  42. # 2015-02-23, holomorph
  43. #   version 17: fix coloring in non-channel buffers (#58)
  44. # 2014-09-17, holomorph
  45. #   version 16: use weechat config facilities
  46. #               clean unused, minor linting, some simplification
  47. # 2014-05-05, holomorph
  48. #   version 15: fix python2-specific re.search check
  49. # 2013-01-29, nils_2
  50. #   version 14: make script compatible with Python 3.x
  51. # 2012-10-19, ldvx
  52. #   version 13: Iterate over every word to prevent incorrect colorization of
  53. #               nicks. Added option greedy_matching.
  54. # 2012-04-28, ldvx
  55. #   version 12: added ignore_tags to avoid colorizing nicks if tags are present
  56. # 2012-01-14, nesthib
  57. #   version 11: input_text_display hook and modifier to colorize nicks in input bar
  58. # 2010-12-22, xt
  59. #   version 10: hook config option for updating blacklist
  60. # 2010-12-20, xt
  61. #   version 0.9: hook new config option for weechat 0.3.4
  62. # 2010-11-01, nils_2
  63. #   version 0.8: hook_modifier() added to communicate with rainbow_text
  64. # 2010-10-01, xt
  65. #   version 0.7: changes to support non-irc-plugins
  66. # 2010-07-29, xt
  67. #   version 0.6: compile regexp as per patch from Chris quigybo@hotmail.com
  68. # 2010-07-19, xt
  69. #   version 0.5: fix bug with incorrect coloring of own nick
  70. # 2010-06-02, xt
  71. #   version 0.4: update to reflect API changes
  72. # 2010-03-26, xt
  73. #   version 0.3: fix error with exception
  74. # 2010-03-24, xt
  75. #   version 0.2: use ignore_channels when populating to increase performance.
  76. # 2010-02-03, xt
  77. #   version 0.1: initial (based on ruby script by dominikh)
  78. #
  79. # Known issues: nicks will not get colorized if they begin with a character
  80. # such as ~ (which some irc networks do happen to accept)
  82. import weechat
  83. import re
  84. w = weechat
  86. SCRIPT_NAME    = "colorize_nicks"
  87. SCRIPT_AUTHOR  = "xt <xt@bash.no>"
  88. SCRIPT_VERSION = "26"
  89. SCRIPT_LICENSE = "GPL"
  90. SCRIPT_DESC    = "Use the weechat nick colors in the chat area"
  92. # Based on the recommendations in RFC 7613. A valid nick is composed
  93. # of anything but " ,*?.!@".
  94. VALID_NICK = r'([@~&!%+-])?([^\s,\*?\.!@]+)'
  95. valid_nick_re = re.compile(VALID_NICK)
  96. ignore_channels = []
  97. ignore_nicks = []
  99. # Dict with every nick on every channel with its color as lookup value
  100. colored_nicks = {}
  102. CONFIG_FILE_NAME = "colorize_nicks"
  104. # config file and options
  105. colorize_config_file = ""
  106. colorize_config_option = {}
  108. def colorize_config_init():
  109.     '''
  110.     Initialization of configuration file.
  111.     Sections: look.
  112.     '''
  113.     global colorize_config_file, colorize_config_option
  114.     colorize_config_file = weechat.config_new(CONFIG_FILE_NAME,
  115.                                               "", "")
  116.     if colorize_config_file == "":
  117.         return
  119.     # section "look"
  120.     section_look = weechat.config_new_section(
  121.         colorize_config_file, "look", 0, 0, "", "", "", "", "", "", "", "", "", "")
  122.     if section_look == "":
  123.         weechat.config_free(colorize_config_file)
  124.         return
  125.     colorize_config_option["blacklist_channels"] = weechat.config_new_option(
  126.         colorize_config_file, section_look, "blacklist_channels",
  127.         "string", "Comma separated list of channels", "", 0, 0,
  128.         "", "", 0, "", "", "", "", "", "")
  129.     colorize_config_option["blacklist_nicks"] = weechat.config_new_option(
  130.         colorize_config_file, section_look, "blacklist_nicks",
  131.         "string", "Comma separated list of nicks", "", 0, 0,
  132.         "so,root", "so,root", 0, "", "", "", "", "", "")
  133.     colorize_config_option["min_nick_length"] = weechat.config_new_option(
  134.         colorize_config_file, section_look, "min_nick_length",
  135.         "integer", "Minimum length nick to colorize", "",
  136.         2, 20, "", "", 0, "", "", "", "", "", "")
  137.     colorize_config_option["colorize_input"] = weechat.config_new_option(
  138.         colorize_config_file, section_look, "colorize_input",
  139.         "boolean", "Whether to colorize input", "", 0,
  140.         0, "off", "off", 0, "", "", "", "", "", "")
  141.     colorize_config_option["ignore_tags"] = weechat.config_new_option(
  142.         colorize_config_file, section_look, "ignore_tags",
  143.         "string", "Comma separated list of tags to ignore; i.e. irc_join,irc_part,irc_quit", "", 0, 0,
  144.         "", "", 0, "", "", "", "", "", "")
  145.     colorize_config_option["greedy_matching"] = weechat.config_new_option(
  146.         colorize_config_file, section_look, "greedy_matching",
  147.         "boolean", "If off, then use lazy matching instead", "", 0,
  148.         0, "on", "on", 0, "", "", "", "", "", "")
  149.     colorize_config_option["match_limit"] = weechat.config_new_option(
  150.         colorize_config_file, section_look, "match_limit",
  151.         "integer", "Fall back to lazy matching if greedy matches exceeds this number", "",
  152.         20, 1000, "", "", 0, "", "", "", "", "", "")
  153.     colorize_config_option["ignore_nicks_in_urls"] = weechat.config_new_option(
  154.         colorize_config_file, section_look, "ignore_nicks_in_urls",
  155.         "boolean", "If on, don't colorize nicks inside URLs", "", 0,
  156.         0, "off", "off", 0, "", "", "", "", "", "")
  158. def colorize_config_read():
  159.     ''' Read configuration file. '''
  160.     global colorize_config_file
  161.     return weechat.config_read(colorize_config_file)
  163. def colorize_nick_color(nick, my_nick):
  164.     ''' Retrieve nick color from weechat. '''
  165.     if nick == my_nick:
  166.         return w.color(w.config_string(w.config_get('weechat.color.chat_nick_self')))
  167.     else:
  168.         return w.info_get('irc_nick_color', nick)
  170. def colorize_cb(data, modifier, modifier_data, line):
  171.     ''' Callback that does the colorizing, and returns new line if changed '''
  173.     global ignore_nicks, ignore_channels, colored_nicks
  176.     full_name = modifier_data.split(';')[1]
  177.     channel = '.'.join(full_name.split('.')[1:])
  179.     buffer = w.buffer_search('', full_name)
  180.     # Check if buffer has colorized nicks
  181.     if buffer not in colored_nicks:
  182.         return line
  184.     if channel and channel in ignore_channels:
  185.         return line
  187.     min_length = w.config_integer(colorize_config_option['min_nick_length'])
  188.     reset = w.color('reset')
  190.     # Don't colorize if the ignored tag is present in message
  191.     tags_line = modifier_data.rsplit(';')
  192.     if len(tags_line) >= 3:
  193.         tags_line = tags_line[2].split(',')
  194.         for i in w.config_string(colorize_config_option['ignore_tags']).split(','):
  195.             if i in tags_line:
  196.                 return line
  198.     for words in valid_nick_re.findall(line):
  199.         nick = words[1]
  200.         # Check that nick is not ignored and longer than minimum length
  201.         if len(nick) < min_length or nick in ignore_nicks:
  202.             continue
  204.         # If the matched word is not a known nick, we try to match the
  205.         # word without its first or last character (if not a letter).
  206.         # This is necessary as "foo:" is a valid nick, which could be
  207.         # adressed as "foo::".
  208.         if nick not in colored_nicks[buffer]:
  209.             if not nick[-1].isalpha() and not nick[0].isalpha():
  210.                 if nick[1:-1] in colored_nicks[buffer]:
  211.                     nick = nick[1:-1]
  212.             elif not nick[0].isalpha():
  213.                 if nick[1:] in colored_nicks[buffer]:
  214.                     nick = nick[1:]
  215.             elif not nick[-1].isalpha():
  216.                 if nick[:-1] in colored_nicks[buffer]:
  217.                     nick = nick[:-1]
  219.         # Check that nick is in the dictionary colored_nicks
  220.         if nick in colored_nicks[buffer]:
  221.             nick_color = colored_nicks[buffer][nick]
  223.             try:
  224.                 # Let's use greedy matching. Will check against every word in a line.
  225.                 if w.config_boolean(colorize_config_option['greedy_matching']):
  226.                     cnt = 0
  227.                     limit = w.config_integer(colorize_config_option['match_limit'])
  229.                     for word in line.split():
  230.                         cnt += 1
  231.                         assert cnt < limit
  232.                         #  if cnt > limit:
  233.                             #  raise RuntimeError('Exceeded colorize_nicks.look.match_limit.');
  235.                         if w.config_boolean(colorize_config_option['ignore_nicks_in_urls']) and \
  236.                               word.startswith(('http://', 'https://')):
  237.                             continue
  239.                         if nick in word:
  240.                             # Is there a nick that contains nick and has a greater lenght?
  241.                             # If so let's save that nick into var biggest_nick
  242.                             biggest_nick = ""
  243.                             for i in colored_nicks[buffer]:
  244.                                 cnt += 1
  245.                                 assert cnt < limit
  247.                                 if nick in i and nick != i and len(i) > len(nick):
  248.                                     if i in word:
  249.                                         # If a nick with greater len is found, and that word
  250.                                         # also happens to be in word, then let's save this nick
  251.                                         biggest_nick = i
  252.                             # If there's a nick with greater len, then let's skip this
  253.                             # As we will have the chance to colorize when biggest_nick
  254.                             # iterates being nick.
  255.                             if len(biggest_nick) > 0 and biggest_nick in word:
  256.                                 pass
  257.                             elif len(word) < len(biggest_nick) or len(biggest_nick) == 0:
  258.                                 new_word = word.replace(nick, '%s%s%s' % (nick_color, nick, reset))
  259.                                 line = line.replace(word, new_word)
  261.                 # Switch to lazy matching
  262.                 else:
  263.                     raise AssertionError
  265.             except AssertionError:
  266.                 # Let's use lazy matching for nick
  267.                 nick_color = colored_nicks[buffer][nick]
  268.                 # The two .? are in case somebody writes "nick:", "nick,", etc
  269.                 # to address somebody
  270.                 regex = r"(\A|\s).?(%s).?(\Z|\s)" % re.escape(nick)
  271.                 match = re.search(regex, line)
  272.                 if match is not None:
  273.                     new_line = line[:match.start(2)] + nick_color+nick+reset + line[match.end(2):]
  274.                     line = new_line
  276.     return line
  278. def colorize_input_cb(data, modifier, modifier_data, line):
  279.     ''' Callback that does the colorizing in input '''
  281.     global ignore_nicks, ignore_channels, colored_nicks
  283.     min_length = w.config_integer(colorize_config_option['min_nick_length'])
  285.     if not w.config_boolean(colorize_config_option['colorize_input']):
  286.         return line
  288.     buffer = w.current_buffer()
  289.     # Check if buffer has colorized nicks
  290.     if buffer not in colored_nicks:
  291.         return line
  293.     channel = w.buffer_get_string(buffer, 'name')
  294.     if channel and channel in ignore_channels:
  295.         return line
  297.     reset = w.color('reset')
  299.     for words in valid_nick_re.findall(line):
  300.         nick = words[1]
  301.         # Check that nick is not ignored and longer than minimum length
  302.         if len(nick) < min_length or nick in ignore_nicks:
  303.             continue
  304.         if nick in colored_nicks[buffer]:
  305.             nick_color = colored_nicks[buffer][nick]
  306.             line = line.replace(nick, '%s%s%s' % (nick_color, nick, reset))
  308.     return line
  310. def populate_nicks(*args):
  311.     ''' Fills entire dict with all nicks weechat can see and what color it has
  312.     assigned to it. '''
  313.     global colored_nicks
  315.     colored_nicks = {}
  317.     buffers = w.infolist_get('buffer', '', '')
  318.     while w.infolist_next(buffers):
  319.         buffer_ptr = w.infolist_pointer(buffers, 'pointer')
  320.         my_nick = w.buffer_get_string(buffer_ptr, 'localvar_nick')
  321.         nicklist = w.infolist_get('nicklist', buffer_ptr, '')
  322.         while w.infolist_next(nicklist):
  323.             if buffer_ptr not in colored_nicks:
  324.                 colored_nicks[buffer_ptr] = {}
  326.             if w.infolist_string(nicklist, 'type') != 'nick':
  327.                 continue
  329.             nick = w.infolist_string(nicklist, 'name')
  330.             nick_color = colorize_nick_color(nick, my_nick)
  332.             colored_nicks[buffer_ptr][nick] = nick_color
  334.         w.infolist_free(nicklist)
  336.     w.infolist_free(buffers)
  338.     return w.WEECHAT_RC_OK
  340. def add_nick(data, signal, type_data):
  341.     ''' Add nick to dict of colored nicks '''
  342.     global colored_nicks
  344.     # Nicks can have , in them in some protocols
  345.     splitted = type_data.split(',')
  346.     pointer = splitted[0]
  347.     nick = ",".join(splitted[1:])
  348.     if pointer not in colored_nicks:
  349.         colored_nicks[pointer] = {}
  351.     my_nick = w.buffer_get_string(pointer, 'localvar_nick')
  352.     nick_color = colorize_nick_color(nick, my_nick)
  354.     colored_nicks[pointer][nick] = nick_color
  356.     return w.WEECHAT_RC_OK
  358. def remove_nick(data, signal, type_data):
  359.     ''' Remove nick from dict with colored nicks '''
  360.     global colored_nicks
  362.     # Nicks can have , in them in some protocols
  363.     splitted = type_data.split(',')
  364.     pointer = splitted[0]
  365.     nick = ",".join(splitted[1:])
  367.     if pointer in colored_nicks and nick in colored_nicks[pointer]:
  368.         del colored_nicks[pointer][nick]
  370.     return w.WEECHAT_RC_OK
  372. def update_blacklist(*args):
  373.     ''' Set the blacklist for channels and nicks. '''
  374.     global ignore_channels, ignore_nicks
  375.     ignore_channels = w.config_string(colorize_config_option['blacklist_channels']).split(',')
  376.     ignore_nicks = w.config_string(colorize_config_option['blacklist_nicks']).split(',')
  377.     return w.WEECHAT_RC_OK
  379. if __name__ == "__main__":
  380.     if w.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE,
  381.                   SCRIPT_DESC, "", ""):
  382.         colorize_config_init()
  383.         colorize_config_read()
  385.         # Run once to get data ready
  386.         update_blacklist()
  387.         populate_nicks()
  389.         w.hook_signal('nicklist_nick_added', 'add_nick', '')
  390.         w.hook_signal('nicklist_nick_removed', 'remove_nick', '')
  391.         w.hook_modifier('weechat_print', 'colorize_cb', '')
  392.         # Hook config for changing colors
  393.         w.hook_config('weechat.color.chat_nick_colors', 'populate_nicks', '')
  394.         w.hook_config('weechat.look.nick_color_hash', 'populate_nicks', '')
  395.         # Hook for working togheter with other scripts (like colorize_lines)
  396.         w.hook_modifier('colorize_nicks', 'colorize_cb', '')
  397.         # Hook for modifying input
  398.         w.hook_modifier('250|input_text_display', 'colorize_input_cb', '')
  399.         # Hook for updating blacklist (this could be improved to use fnmatch)
  400.         weechat.hook_config('%s.look.blacklist*' % SCRIPT_NAME, 'update_blacklist', '')